[dev.fuzz] all: merge master (7764ee5) into dev.fuzz

Conflicts:

- api/next.txt

Merge List:

+ 2021-02-19 7764ee5614 runtime: fix invalid nil g check for for mips64x
+ 2021-02-19 87f425da14 cmd/go/internal/mvs: split Reqs into narrower per-function interfaces
+ 2021-02-19 4da0188c6c cmd/go/internal/modget: split resolveCandidates into two methods
+ 2021-02-19 5f2e24efb3 cmd/internal/diff: skip over Cygwin warning in diff output
+ 2021-02-19 ee7038f6a5 net: disable Windows netsh tests when netsh won't run
+ 2021-02-19 40765ffa95 os/exec: disable failing LookPathTest on windows/arm64
+ 2021-02-19 b445d6ea34 runtime/pprof: expect tests to pass on macOS
+ 2021-02-19 b110a43628 runtime: delete gosave (dead code)
+ 2021-02-19 474d5f4f4d math: remove most 387 implementations
+ 2021-02-19 c7c6c113be runtime: convert windows/arm64 assembly
+ 2021-02-19 3527caa7d6 runtime: initial windows/arm64 implementation files
+ 2021-02-19 427bd7599d runtime: generate windows/arm64 callback asm
+ 2021-02-19 f6c4b4bf96 syscall: add windows/arm64 support
+ 2021-02-19 ac024a0c7b cmd/vendor: get golang.org/x/sys@beda7e5e158
+ 2021-02-19 a3b97e7628 test: disable nilptr on windows/arm64
+ 2021-02-19 985d087782 cmd/link: add windows/arm64 support
+ 2021-02-19 95a44d2409 cmd/internal/objfile: recognize Windows ARM64 executables
+ 2021-02-19 0ca0551f02 debug/pe: recognize arm64 executables
+ 2021-02-19 0c633125f2 cmd/dist: add windows/arm64 support
+ 2021-02-19 bb6efb9609 build: set GOPATH consistently in run.bash, run.bat, run.rc
+ 2021-02-19 a1222b7535 cmd/link: add debug print in deadcode
+ 2021-02-19 1c659f2525 cmd/link: clean up windows PE generation
+ 2021-02-19 b6379f190b syscall: clean up windows a bit
+ 2021-02-19 09e059afb1 runtime: enable framepointer on all arm64
+ 2021-02-19 b19e7b518e runtime: clean up windows a bit
+ 2021-02-19 5421c37a1d runtime: fix windows/arm externalthreadhandler
+ 2021-02-19 91cc484ea9 runtime: fix time on windows/arm under WINE
+ 2021-02-19 38672d3dcf runtime: crash earlier on windows for runtime.abort
+ 2021-02-19 a1e9148e3d runtime: print hex numbers with hex prefixes in traceback debug
+ 2021-02-19 75e273fc2c runtime: fix windows/arm CONTEXT_CONTROL
+ 2021-02-19 76ab626bfc runtime: factor common code out of defs_windows_*.go
+ 2021-02-19 ece954d8b8 runtime: find g in Windows profiler using SP
+ 2021-02-19 a54f7fc0fd runtime: do not treat asmcgocall as a topofstack on g0
+ 2021-02-19 776ee4079a runtime: do not treat morestack as a topofstack
+ 2021-02-19 5ecd9e34df runtime: do not treat mcall as a topofstack
+ 2021-02-19 54da3ab385 runtime: use TOPFRAME to identify top-of-frame functions
+ 2021-02-19 fbe74dbf42 runtime: use FuncInfo SPWRITE flag to identify untraceable profile samples
+ 2021-02-19 4dd77bdc91 cmd/asm, cmd/link, runtime: introduce FuncInfo flag bits
+ 2021-02-19 aa0388f2ed runtime: remove unnecessary writes to gp.sched.g
+ 2021-02-19 6fe8981620 cmd/internal/obj/riscv: fix JMP name<>(SB)
+ 2021-02-19 01f05d8ff1 runtime: unify asmcgocall and systemstack traceback setup
+ 2021-02-19 229695a283 runtime: clean up funcID assignment
+ 2021-02-19 c80da0a33a runtime: handle nil gp in cpuprof
+ 2021-02-19 a78879ac67 runtime: move sys.DefaultGoroot to runtime.defaultGOROOT
+ 2021-02-19 8ac23a1f15 runtime: document, clean up internal/sys
+ 2021-02-19 678568a5cf runtime: delete windows setlasterror (unused)
+ 2021-02-19 0d94f989d1 runtime: clean up system calls during cgo callback init
+ 2021-02-19 e7ee3c1fa8 os: report Windows exit status in hex
+ 2021-02-18 eb982727e3 cmd/go/internal/mvs: fix Downgrade to match Algorithm 4
+ 2021-02-18 3b7277d365 cmd/go: add a script test for artifacts resulting from 'go get -u'
+ 2021-02-18 f3c2208e2c cmd/go: add script tests for potential upgrades due to downgrades
+ 2021-02-18 a5c8a15f64 cmd/go/internal/mvs: clarify and annotate test cases
+ 2021-02-18 a76efea1fe cmd/go/internal/mvs: don't emit duplicates from Req
+ 2021-02-18 609d82b289 cmd/dist: set GOARM=7 for windows/arm
+ 2021-02-18 f0be3cc547 runtime: unbreak linux/riscv64 following regabi merge
+ 2021-02-18 07ef313525 runtime/cgo: add cast in C code to avoid C compiler warning
+ 2021-02-17 2f0da6d9e2 go/types: revert "no 'declared but not used' errors for invalid var decls"
+ 2021-02-17 70c37ee7d0 cmd/compile/internal/test: gofmt abiutils_test.go
+ 2021-02-16 84825599dc all: merge branch dev.regabi (d3cd4830ad) into master
+ 2021-02-16 d3cd4830ad [dev.regabi] test: run abi/regabipragma test with -c=1
+ 2021-02-16 03cea563d1 [dev.regabi] all: merge master (5faf941) into dev.regabi
+ 2021-02-16 b8fb049c7a [dev.regabi] cmd/go: copy internal/abi in TestNewReleaseRebuildsStalePackagesInGOPATH
+ 2021-02-16 5faf941df0 internal/goversion: update Version to 1.17
+ 2021-02-16 ed55da46ab [dev.regabi] go/types: overlapping embedded interfaces requires go1.14
+ 2021-02-16 7696c94334 [dev.regabi] go/types: type alias decl requires go1.9
+ 2021-02-16 c2358a1ae7 [dev.regabi] runtime: stub out spillArgs and unspillArgs
+ 2021-02-16 8cfbf34dd9 internal/abi: set register count constants to zero for regabi experiment
+ 2021-02-16 6f3da9d2f6 README: pull gopher image from website
+ 2021-02-16 d28aae26b0 [dev.regabi] cmd/link: recognize internal/abi as runtime package
+ 2021-02-16 098504c73f cmd/link: generate trampoline for inter-dependent packages
+ 2021-02-16 1004a7cb31 runtime/metrics: update documentation to current interface
+ 2021-02-16 6530f2617f doc/go1.16: remove draft notice
+ 2021-02-16 353e111455 doc/go1.16: fix mismatched id attribute
+ 2021-02-16 e0215315f5 [dev.regabi] reflect: support for register ABI on amd64 for reflect.(Value).Call
+ 2021-02-16 f0d23c9dbb internal/poll: netpollcheckerr before sendfile
+ 2021-02-16 0cb3415154 doc: remove all docs not tied to distribution
+ 2021-02-16 626ef08127 doc: remove install.html and install-source.html
+ 2021-02-16 30641e36aa internal/poll: if copy_file_range returns 0, assume it failed
+ 2021-02-15 33d72fd412 doc/faq: update generics entry to reflect accepted proposal
+ 2021-02-15 852ce7c212 cmd/go: provide a more helpful suggestion for "go vet -?"
+ 2021-02-13 66c27093d0 cmd/link: fix typo in link_test.go
+ 2021-02-13 b81efb7ec4 [dev.regabi] go/types: add support for language version checking
+ 2021-02-13 a7e9b4b948 [dev.regabi] go/types: untyped shift counts must fit into uint
+ 2021-02-13 060fa49bd2 [dev.regabi] go/types: refuse excessively long constants
+ 2021-02-12 baa6c75dce [dev.regabi] internal/abi: add new internal/abi package for ABI constants
+ 2021-02-12 d1fd9a8863 [dev.regabi] all: merge master (ff0e93e) into dev.regabi
+ 2021-02-12 ff0e93ea31 doc/go1.16: note that package path elements beginning with '.' are disallowed
+ 2021-02-11 249da7ec02 CONTRIBUTORS: update for the Go 1.16 release
+ 2021-02-11 864d4f1c6b cmd/go: multiple small 'go help' fixes
+ 2021-02-11 26ceae85a8 spec: More precise wording in section on function calls.
+ 2021-02-11 930c2c9a68 cmd/go: reject embedded files that can't be packed into modules
+ 2021-02-11 e5b08e6d5c io/fs: allow backslash in ValidPath, reject in os.DirFS.Open
+ 2021-02-10 ed8079096f cmd/compile: mark concrete call of reflect.(*rtype).Method as REFLECTMETHOD
+ 2021-02-10 59703d53e2 [dev.regabi] cmd/link: stop using ABI aliases if wrapper is enabled
+ 2021-02-09 e9c9683597 cmd/go: suppress errors from 'go get -d' for packages that only conditionally exist
+ 2021-02-09 168d6a49a5 [dev.regabi] go/types: use 512 bits as max. integer precision
+ 2021-02-09 0a62067708 [dev.regabi] go/types: adjust importer to match compiler importer
+ 2021-02-09 1c58fcf7ed [dev.regabi] go/types: handle untyped constant arithmetic overflow
+ 2021-02-09 493363ccff [dev.regabi] go/types: must not import a package called "init"
+ 2021-02-09 e0ac989cf3 archive/tar: detect out of bounds accesses in PAX records resulting from padded lengths
+ 2021-02-09 c48d1503ba [dev.regabi] go/types: report unused packages in source order
+ 2021-02-09 813958f13c [dev.regabi] go/types: factor out sorting of methods
+ 2021-02-09 11d15c171b [dev.regabi] go/types: convert untyped arguments to delete
+ 2021-02-09 c9d6f45fec runtime/metrics: fix a couple of documentation typpos
+ 2021-02-09 cea4e21b52 io/fs: backslash is always a glob meta character
+ 2021-02-08 dc725bfb3c doc/go1.16: mention new vet check for asn1.Unmarshal
+ 2021-02-08 618e3c15bd [dev.regabi] go/types: consistently report nil type as "untyped nil"
+ 2021-02-08 50449de66a [dev.regabi] all: merge master (1901853) into dev.regabi
+ 2021-02-08 7b0dfb177f [dev.regabi] runtime: use g register in some assembly functions on AMD64
+ 2021-02-08 2e60c00f56 [dev.regabi] cmd/internal/obj/x86: use g register in stack bounds check
+ 2021-02-08 22f9e1ccbc [dev.regabi] runtime: initialize special registers before sigpanic
+ 2021-02-08 5d7dc53888 [dev.regabi] cmd/compile, runtime: reserve R14 as g registers on AMD64
+ 2021-02-08 1901853098 runtime/metrics: fix panic in readingAllMetric example
+ 2021-02-08 ed3e4afa12 syscall/plan9: remove spooky fd action at a distance
+ 2021-02-08 a21de9ec73 [dev.regabi] cmd/link: resolve symbol ABI in shared linkage
+ 2021-02-05 724d0720b3 doc/go1.16: add missed heading tag in vet section
+ 2021-02-05 b54cd94d47 embed, io/fs: clarify that leading and trailing slashes are disallowed
+ 2021-02-05 4516afebed testing/fstest: avoid symlink-induced failures in tester
+ 2021-02-05 8fa84772ba [dev.regabi] runtime: delete gosave function
+ 2021-02-05 946351d5a2 [dev.regabi] runtime: zero X15 in racecall
+ 2021-02-05 397a46a10a [dev.regabi] cmd/asm: define g register on AMD64
+ 2021-02-05 e79c2fd428 [dev.regabi] runtime: mark racecallbackthunk as ABIInternal
+ 2021-02-05 7cc6de59f2 [dev.regabi] runtime: don't mark rt0_go ABIInternal
+ 2021-02-05 63de211014 [dev.regabi] runtime/cgo: call setg_gcc in crosscall_amd64
+ 2021-02-04 120b819f45 [dev.regabi] go/types: report error for invalid main function signature
+ 2021-02-04 52d5cb2822 [dev.regabi] cmd/internal/obj: access Attribute atomically
+ 2021-02-04 bc451b5770 [dev.regabi] go/types: port check_test.go ergonomics from dev.typeparams
+ 2021-02-04 afd67f3334 [dev.regabi] go/types: no "declared but not used" errors for invalid var decls
+ 2021-02-04 8869086d8f runtime: fix typo in histogram.go
+ 2021-02-03 401d7e5a24 [dev.regabi] cmd/compile: reserve X15 as zero register on AMD64
+ 2021-02-03 bfc7418e6d [dev.regabi] runtime, syscall, etc.: mark Darwin syscall wrappers as ABIInternal
+ 2021-02-03 e491c6eea9 math/big: fix comment in divRecursiveStep
+ 2021-02-02 23b0c1f76e [dev.regabi] all: merge master (fca94ab) into dev.regabi
+ 2021-02-02 fca94ab3ab spec: improve the example in Type assertions section
+ 2021-02-02 98f8454a73 cmd/link: don't decode type symbol in shared library in deadcode
+ 2021-02-02 1426a571b7 cmd/link: fix off-by-1 error in findShlibSection
+ 2021-02-01 32e789f4fb test: fix incorrectly laid out instructions in issue11656.go
+ 2021-02-01 ca6999e27c [dev.regabi] test: add a test for inlining closures
+ 2021-02-01 0b6cfea634 doc/go1.16: document that on OpenBSD syscalls are now made through libc
+ 2021-02-01 26e29aa15a cmd/link: disable TestPIESize if CGO isn't enabled
+ 2021-02-01 6ac91e460c doc/go1.16: minor markup fixes
+ 2021-01-29 44361140c0 embed: update docs for proposal tweaks
+ 2021-01-29 68058edc39 runtime: document pointer write atomicity for memclrNoHeapPointers
+ 2021-01-28 c8bd8010ff syscall: generate readlen/writelen for openbsd libc
+ 2021-01-28 41bb49b878 cmd/go: revert TestScript/build_trimpath to use ioutil.ReadFile
+ 2021-01-28 725a642c2d runtime: correct syscall10/syscall10X on openbsd/amd64
+ 2021-01-28 4b068cafb5 doc/go1.16: document go/build/constraint package
+ 2021-01-28 376518d77f runtime,syscall: convert syscall on openbsd/arm64 to libc
+ 2021-01-27 aca22bddf2 [dev.regabi] cmd/compile: remove nested functions from expands_calls.go
+ 2021-01-27 667e08ba8c [dev.regabi] cmd/go: Use GOMAXPROCS to limit default build, compile parallelism
+ 2021-01-27 00f2ff5c94 api/go1.16: add go/build/constraint APIs
+ 2021-01-27 35334caf18 crypto/x509: remove leftover CertificateRequest field
+ 2021-01-27 a5a5e2c968 runtime: make sure to remove open-coded defer entries in all cases after a recover
+ 2021-01-27 8cfa01943a runtime: block console ctrlhandler when the signal is handled
+ 2021-01-27 ff9e8364c6 cmd/go: skip issue33139 when the 'cc' script command is unavailable
+ 2021-01-27 cd176b3615 runtime: switch runtime to libc for openbsd/arm64
+ 2021-01-27 6c8fbfbdcf runtime: convert openbsd/arm64 locking to libc
+ 2021-01-27 5cdf0da1bf syscall: clean up mkasm related changes
+ 2021-01-27 210f70e298 doc/go1.16: fix closing brace in .Export format
+ 2021-01-27 0f797f168d math: fix typo in sqrt.go code comment
+ 2021-01-26 9b636feafe [dev.regabi] cmd/compile: missing last patch set for cl286013
+ 2021-01-26 f7dad5eae4 [dev.regabi] cmd/compile: remove leftover code form late call lowering work
+ 2021-01-26 8634a234df runtime,syscall: convert syscall on openbsd/amd64 to libc
+ 2021-01-26 1d5e14632e os: further document limitations around naked file descriptors
+ 2021-01-25 5e4a0cdde3 [dev.regabi] all: merge master (bf0f7c9) into dev.regabi
+ 2021-01-26 cf263e9f77 os: correct names in CreateTemp and MkdirTemp doc comments
+ 2021-01-26 ce8b318624 net/http/fcgi: remove locking added to prevent a test-only race
+ 2021-01-25 bf0f7c9d78 doc/go1.16: mention os.DirFS in os section
+ 2021-01-25 deaf29a8a8 cmd/compile: fix order-of-assignment issue w/ defers
+ 2021-01-25 ad2ca26a52 doc/go1.16: mention os.DirEntry and types moved from os to io/fs
+ 2021-01-25 a51921fa5b doc/go1.16: mention new testing/iotest functions
+ 2021-01-25 e6b6d107f7 doc/go1.16: mention deprecation of io/ioutil
+ 2021-01-25 7eaaf28cae [dev.regabi] cmd/compile: disallow taking address of SSA'd values
+ 2021-01-25 96a276363b doc/go1.16: mention go/build changes
+ 2021-01-25 3d85c69a0b html/template: revert "avoid race when escaping updates template"
+ 2021-01-25 54514c6b28 cmd/go: fix TestScript/cgo_path, cgo_path_space when CC set
+ 2021-01-25 6f5e79f470 [dev.regabi] cmd/compile/internal: specify memory layout
+ 2021-01-25 cabffc199d [dev.regabi] cmd/compile/internal: add internal ABI specification
+ 2021-01-25 6de8443f3b doc/asm: add a section on go_asm.h, clean up go_tls.h section
+ 2021-01-25 6a4739ccc5 [dev.regabi] cmd/compile: enable rational constant arithmetic
+ 2021-01-25 be9612a832 [dev.regabi] os: disable TestDirFS until #42637 is fixed
+ 2021-01-25 8ee3d39838 [dev.regabi] cmd/go: workaround -race issue on ppc64le
+ 2021-01-25 54b251f542 lib/time, time/tzdata: update tzdata to 2021a
+ 2021-01-25 5a76c3d548 [dev.regabi] cmd/compile: modify abiutils for recently updated ABI
+ 2021-01-25 ff82cc971a os: force consistent mtime before running fstest on directory on Windows
+ 2021-01-25 044f937a73 doc/go1.16: fix WalkDir and Walk links
+ 2021-01-25 063c72f06d [dev.regabi] cmd/compile: backport changes from dev.typeparams (9456804)
+ 2021-01-23 b634f5d97a doc/go1.16: add crypto/x509 memory optimization
+ 2021-01-23 9897655c61 doc/go1.16: reword ambiguously parsable sentence
+ 2021-01-23 cd99385ff4 cmd/internal/obj/arm64: fix VMOVQ instruction encoding error
+ 2021-01-23 d05d6fab32 [dev.regabi] cmd/compile: replace ir.Name map with ir.NameSet for SSA 2
+ 2021-01-23 66ee8b158f runtime: restore cgo_import_dynamic for libc.so on openbsd
+ 2021-01-23 48badc5fa8 [dev.regabi] cmd/compile: fix escape analysis problem with closures
+ 2021-01-23 51e1819a8d [dev.regabi] cmd/compile: scan body of closure in tooHairy to check for disallowed nodes
+ 2021-01-22 25c39e4fb5 io/ioutil: fix example test for WriteFile to allow it to run in the playground
+ 2021-01-22 eb21b31e48 runtime: define dummy msanmove
+ 2021-01-22 3a778ff50f runtime: check for g0 stack last in signal handler
+ 2021-01-22 a2cef9b544 cmd/go: don't lookup the path for CC when invoking cgo
+ 2021-01-22 7e0a81d280 [dev.regabi] all: merge master (dab3e5a) into dev.regabi
+ 2021-01-22 dab3e5affe runtime: switch runtime to libc for openbsd/amd64
+ 2021-01-22 a1b53d85da cmd/go: add documentation for test and xtest fields output by go list
+ 2021-01-22 b268b60774 runtime: remove pthread_kill/pthread_self for openbsd
+ 2021-01-22 ec4051763d runtime: fix typo in mgcscavenge.go
+ 2021-01-22 7ece3a7b17 net/http: fix flaky TestDisableKeepAliveUpgrade
+ 2021-01-22 50cba0506f time: clarify Timer.Reset behavior on AfterFunc Timers
+ 2021-01-22 cf10e69f17 doc/go1.16: mention net/http.Transport.GetProxyConnectHeader
+ 2021-01-22 ec1b945265 doc/go1.16: mention path/filepath.WalkDir
+ 2021-01-22 11def3d40b doc/go1.16: mention syscall.AllThreadsSyscall
+ 2021-01-21 07b0235609 doc/go1.16: add notes about package-specific fs.FS changes
+ 2021-01-21 e2b4f1fea5 doc/go1.16: minor formatting fix
+ 2021-01-21 9f43a9e07b doc/go1.16: mention new debug/elf constants
+ 2021-01-21 3c2f11ba5b cmd/go: overwrite program name with full path
+ 2021-01-21 953d1feca9 all: introduce and use internal/execabs
+ 2021-01-21 b186e4d70d cmd/go: add test case for cgo CC setting
+ 2021-01-21 5a8a2265fb cmd/cgo: report exec errors a bit more clearly
+ 2021-01-21 46e2e2e9d9 cmd/go: pass resolved CC, GCCGO to cgo
+ 2021-01-21 3d40895e36 runtime: switch openbsd/arm64 to pthreads
+ 2021-01-21 d95ca91380 crypto/elliptic: fix P-224 field reduction
+ 2021-01-21 d7e71c01ad [dev.regabi] cmd/compile: replace ir.Name map with ir.NameSet for dwarf
+ 2021-01-21 5248f59a22 [dev.regabi] cmd/compile: replace ir.Name map with ir.NameSet for SSA
+ 2021-01-21 970d8b6cb2 [dev.regabi] cmd/compile: replace ir.Name map with ir.NameSet in inlining
+ 2021-01-21 68a4664475 [dev.regabi] cmd/compile: remove tempAssigns in walkCall1
+ 2021-01-21 fd9a391cdd [dev.regabi] cmd/compile: remove CallExpr.Rargs
+ 2021-01-21 19a6db6b63 [dev.regabi] cmd/compile: make sure mkcall* passed non-nil init
+ 2021-01-21 9f036844db [dev.regabi] cmd/compile: use ir.DoChildren directly in inlining
+ 2021-01-21 213c3905e9 [dev.regabi] cmd/compile: use node walked flag to prevent double walk for walkSelect
+ 2021-01-20 1760d736f6 [dev.regabi] cmd/compile: exporting, importing, and inlining functions with OCLOSURE
+ 2021-01-20 ecf4ebf100 cmd/internal/moddeps: check content of all modules in GOROOT
+ 2021-01-20 92cb157cf3 [dev.regabi] cmd/compile: late expansion of return values
+ 2021-01-20 d2d155d1ae runtime: don't adjust timer pp field in timerWaiting status
+ 2021-01-20 803d18fc6c cmd/go: set Incomplete field on go list output if no files match embed
+ 2021-01-20 6e243ce71d cmd/go: have go mod vendor copy embedded files in subdirs
+ 2021-01-20 be28e5abc5 cmd/go: fix mod_get_fallback test
+ 2021-01-20 928bda4f4a runtime: convert openbsd/amd64 locking to libc
+ 2021-01-19 824f2d635c cmd/go: allow go fmt to complete when embedded file is missing
+ 2021-01-19 0575e35e50 cmd/compile: require 'go 1.16' go.mod line for //go:embed
+ 2021-01-19 9423d50d53 [dev.regabi] cmd/compile: use '%q' for printing rune values less than 128
+ 2021-01-19 ccb2e90688 cmd/link: exit before Asmb2 if error
+ 2021-01-19 ca5774a5a5 embed: treat uninitialized FS as empty
+ 2021-01-19 d047c91a6c cmd/link,runtime: switch openbsd/amd64 to pthreads
+ 2021-01-19 61debffd97 runtime: factor out usesLibcall
+ 2021-01-19 9fed39d281 runtime: factor out mStackIsSystemAllocated
+ 2021-01-19 a2f825c542 [dev.regabi] cmd/compile: directly create go.map and go.track symbols
+ 2021-01-19 4a4212c0e5 [dev.regabi] cmd/compile: refactor Linksym creation
+ 2021-01-19 4f5c603c0f [dev.regabi] cmd/compile: cleanup callTargetLSym
+ 2021-01-18 dbab079835 runtime: free Windows event handles after last lock is dropped
+ 2021-01-18 5a8fbb0d2d os: do not close syscall.Stdin in TestReadStdin
+ 2021-01-18 422f38fb6c [dev.regabi] cmd/compile: move stack objects to liveness
+ 2021-01-18 6113db0bb4 [dev.regabi] cmd/compile: convert OPANIC argument to interface{} during typecheck
+ 2021-01-18 4c835f9169 [dev.regabi] cmd/compile: use LinksymOffsetExpr in TypePtr/ItabAddr
+ 2021-01-18 0ffa1ead6e [dev.regabi] cmd/compile: use *obj.LSym instead of *ir.Name for staticdata functions
+ 2021-01-17 7e0fa38aad [dev.regabi] cmd/compile: remove unneeded packages from ir.Pkgs
+ 2021-01-17 99a5db11ac [dev.regabi] cmd/compile: use LinksymOffsetExpr in walkConvInterface
+ 2021-01-17 87845d14f9 [dev.regabi] cmd/compile: add ir.TailCallStmt
+ 2021-01-17 e3027c6828 [dev.regabi] cmd/compile: fix linux-amd64-noopt builder
+ 2021-01-17 59ff93fe64 [dev.regabi] cmd/compile: rename NameOffsetExpr to LinksymOffsetExpr
+ 2021-01-17 82b9cae700 [dev.regabi] cmd/compile: change ir.NameOffsetExpr to use *obj.LSym instead of *Name
+ 2021-01-17 88956fc4b1 [dev.regabi] cmd/compile: stop analyze NameOffsetExpr.Name_ in escape analysis
+ 2021-01-17 7ce2a8383d [dev.regabi] cmd/compile: simplify stack temp initialization
+ 2021-01-17 ba0e8a92fa [dev.regabi] cmd/compile: refactor temp construction in walk
+ 2021-01-17 78e5aabcdb [dev.regabi] cmd/compile: replace Node.HasCall with walk.mayCall
+ 2021-01-16 6de9423445 [dev.regabi] cmd/compile: cleanup OAS2FUNC ordering
+ 2021-01-16 a956a0e909 [dev.regabi] cmd/compile, runtime: fix up comments/error messages from recent renames
+ 2021-01-16 ab3b67abfd [dev.regabi] cmd/compile: remove ONEWOBJ
+ 2021-01-16 c9b1445ac8 [dev.regabi] cmd/compile: remove TypeAssertExpr {Src,Dst}Type fields
+ 2021-01-15 682a1d2176 runtime: detect errors in DuplicateHandle
+ 2021-01-15 9f83418b83 cmd/link: remove GOROOT write in TestBuildForTvOS
+ 2021-01-15 ec9470162f cmd/compile: allow embed into any string or byte slice type
+ 2021-01-15 54198b04db cmd/compile: disallow embed of var inside func
+ 2021-01-15 b386c735e7 cmd/go: fix go generate docs
+ 2021-01-15 bb5075a525 syscall: remove RtlGenRandom and move it into internal/syscall
+ 2021-01-15 1deae0b597 os: invoke processKiller synchronously in testKillProcess
+ 2021-01-15 03a875137f [dev.regabi] cmd/compile: unexport reflectdata.WriteType
+ 2021-01-15 14537e6e54 [dev.regabi] cmd/compile: move stkobj symbol generation to SSA
+ 2021-01-15 ab523fc510 [dev.regabi] cmd/compile: don't promote Byval CaptureVars if Addrtaken
+ 2021-01-15 ff196c3e84 crypto/x509: update iOS bundled roots to version 55188.40.9
+ 2021-01-15 b7a698c73f [dev.regabi] test: disable test on windows because expected contains path separators.
+ 2021-01-15 4be7af23f9 [dev.regabi] cmd/compile: fix ICE during ir.Dump
+ 2021-01-14 e125ccd10e cmd/go: in 'go mod edit', validate versions given to -retract and -exclude
+ 2021-01-14 eb330020dc cmd/dist, cmd/go: pass -arch for C compilation on Darwin
+ 2021-01-14 84e8a06f62 cmd/cgo: remove unnecessary space in cgo export header
+ 2021-01-14 0c86b999c3 cmd/test2json: document passing -test.paniconexit0
+ 2021-01-14 9135795891 cmd/go/internal/load: report positions for embed errors
+ 2021-01-14 35b9c66601 [dev.regabi] cmd/compile,cmd/link: additional code review suggestions for CL 270863
+ 2021-01-14 d9b79e53bb cmd/compile: fix wrong complement for arm64 floating-point comparisons
+ 2021-01-14 c73232d08f cmd/go/internal/load: refactor setErrorPos to PackageError.setPos
+ 2021-01-14 6aa28d3e06 go/build: report positions for go:embed directives
+ 2021-01-14 9734fd482d [dev.regabi] cmd/compile: use node walked flag to prevent double walk for walkSwitch
+ 2021-01-14 f97983249a [dev.regabi] cmd/compile: move more PAUTOHEAP to SSA construction
+ 2021-01-14 4476300425 [dev.regabi] cmd/compile: use byte for CallExpr.Use
+ 2021-01-14 5a5ab24689 [dev.regabi] cmd/compile: do not rely on CallExpr.Rargs for detect already walked calls
+ 2021-01-14 983ac4b086 [dev.regabi] cmd/compile: fix ICE when initializing blank vars
+ 2021-01-13 7eb31d999c cmd/go: add hints to more missing sum error messages
+ 2021-01-13 d6d4673728 [dev.regabi] cmd/compile: fix GOEXPERIMENT=regabi builder
+ 2021-01-13 c41b999ad4 [dev.regabi] cmd/compile: refactor abiutils from "gc" into new "abi"
+ 2021-01-13 861707a8c8 [dev.regabi] cmd/compile: added limited //go:registerparams pragma for new ABI dev
+ 2021-01-13 c1370e918f [dev.regabi] cmd/compile: add code to support register ABI spills around morestack calls
+ 2021-01-13 2abd24f3b7 [dev.regabi] test: make run.go error messages slightly more informative
+ 2021-01-13 9a19481acb [dev.regabi] cmd/compile: make ordering for InvertFlags more stable
+ 2021-01-12 d9acf6f3a3 [dev.regabi] cmd/compile: remove Func.ClosureType
+ 2021-01-12 41352fd401 [dev.regabi] cmd/compile: transform closures during walk
+ 2021-01-12 d6ad88b4db [dev.regabi] cmd/compile: compile functions before closures
+ 2021-01-12 432f9ffb11 [dev.regabi] cmd/compile: unindent compileFunctions
+ 2021-01-12 cc90e7a51e [dev.regabi] cmd/compile: always use the compile queue
+ 2021-01-12 cd5b74d2df [dev.regabi] cmd/compile: call NeedFuncSym in InitLSym
+ 2021-01-12 ba76567bc2 cmd/go/internal/modload: delete unused *mvsReqs.next method
+ 2021-01-12 665def2c11 encoding/asn1: document unmarshaling behavior for IMPLICIT string fields
+ 2021-01-12 95acd8121b [dev.regabi] cmd/compile: remove Name.Typegen
+ 2021-01-12 12ee55ba7b [dev.regabi] cmd/compile: stop using Vargen for import/export
+ 2021-01-12 b4d2a0445b [dev.regabi] cmd/compile: refactor closure var setup/teardown
+ 2021-01-12 f57f484053 [dev.regabi] cmd/compile: decouple escape analysis from Name.Vargen
+ 2021-01-11 81ea89adf3 cmd/go: fix non-script staleness checks interacting badly with GOFLAGS
+ 2021-01-11 759309029f doc: update editors.html for Go 1.16
+ 2021-01-11 c3b4c7093a cmd/internal/objfile: don't require runtime.symtab symbol for XCOFF
+ 2021-01-10 7fd84c6e46 [dev.regabi] cmd/compile: remove OCLOSUREREAD
+ 2021-01-10 c9c26d7ffb [dev.regabi] cmd/compile: use ClosureVars for method value wrappers
+ 2021-01-10 950cf4d46c [dev.regabi] cmd/compile: bind closure vars during SSA constructions
+ 2021-01-10 8b2efa990b [dev.regabi] cmd/compile: deref PAUTOHEAPs during SSA construction
+ 2021-01-08 59bfc18e34 cmd/go: add hint to read 'go help vcs' to GOVCS errors
+ 2021-01-08 6ee9b118a2 [dev.regabi] cmd/compile: remove fmt_test code; it has outlived its usefulness
+ 2021-01-08 cd6f3a54e4 cmd/go: revise 'go help' documentation for modules
+ 2021-01-08 6192b98751 cmd/go: make hints in error messages more consistent
+ 2021-01-08 25886cf4bd cmd/go: preserve sums for indirect deps fetched by 'go mod download'
+ 2021-01-08 6250833911 runtime/metrics: mark histogram metrics as cumulative
+ 2021-01-08 8f6a9acbb3 runtime/metrics: remove unused StopTheWorld Description field
+ 2021-01-08 6598c65646 cmd/compile: fix exponential-time init-cycle reporting
+ 2021-01-08 fefad1dc85 test: fix timeout code for invoking compiler
+ 2021-01-08 6728118e0a cmd/go: pass signals forward during "go tool"
+ 2021-01-08 e65c543f3c go/build/constraint: add parser for build tag constraint expressions
+ 2021-01-08 0c5afc4fb7 testing/fstest,os: clarify racy behavior of TestFS
+ 2021-01-08 32afcc9436 runtime/metrics: change unit on *-by-size metrics to match bucket unit
+ 2021-01-08 c6513bca5a io/fs: minor corrections to Glob doc
+ 2021-01-08 b241938e04 [dev.regabi] cmd/compile: fix some methods error text
+ 2021-01-08 304f769ffc cmd/compile: don't short-circuit copies whose source is volatile
+ 2021-01-08 ae97717133 runtime,runtime/metrics: use explicit histogram boundaries
+ 2021-01-08 a9ccd2d795 go/build: skip string literal while findEmbed
+ 2021-01-08 d92f8add32 archive/tar: fix typo in comment
+ 2021-01-08 cab1202183 cmd/link: accept extra blocks in TestFallocate
+ 2021-01-08 ee4d32249b io/fs: minor corrections to Glob release date
+ 2021-01-08 54bd1ccce2 cmd: update to latest golang.org/x/tools
+ 2021-01-07 9ec21a8f34 Revert "reflect: support multiple keys in struct tags"
+ 2021-01-07 091414b5b7 io/fs: correct WalkDirFunc documentation
+ 2021-01-07 9b55088d6b doc/go1.16: add release note for disallowing non-ASCII import paths
+ 2021-01-07 fa90aaca7d cmd/compile: fix late expand_calls leaf type for OpStructSelect/OpArraySelect
+ 2021-01-07 7cee66d4cb cmd/go: add documentation for Embed fields in go list output
+ 2021-01-07 e60cffa4ca html/template: attach functions to namespace
+ 2021-01-07 6da2d3b7d7 cmd/link: fix typo in asm.go
+ 2021-01-07 df81a15819 runtime: check mips64 VDSO clock_gettime return code
+ 2021-01-06 4787e906cf crypto/x509: rollback new CertificateRequest fields
+ 2021-01-06 c9658bee93 cmd/go: make module suggestion more friendly
+ 2021-01-06 4c668b25c6 runtime/metrics: fix panic message for Float64Histogram
+ 2021-01-06 d2131704a6 net/http/httputil: fix deadlock in DumpRequestOut
+ 2021-01-05 3e1e13ce6d cmd/go: set cfg.BuildMod to "readonly" by default with no module root
+ 2021-01-05 0b0d004983 cmd/go: pass embedcfg to gccgo if supported
+ 2021-01-05 cb05a0aa6a [dev.regabi] cmd/compile: remove toolstash scaffolding
+ 2021-01-05 9821838832 [dev.regabi] cmd/compile: remove CaptureVars
+ 2021-01-05 fd43831f44 [dev.regabi] cmd/compile: reimplement capture analysis
+ 2021-01-05 fb69c67cad [dev.regabi] test: enable finalizer tests on !amd64
+ 2021-01-05 1b85e7c057 cmd/go: don't scan gccgo standard library packages for imports
+ 2021-01-05 81f4f0e912 [dev.regabi] cmd/compile: remove race-y check in Name.Canonical
+ 2021-01-05 6b37b15d95 runtime: don't take allglock in tracebackothers
+ 2021-01-05 4a9d9adea4 [dev.regabi] cmd/compile: remove initname function
+ 2021-01-05 77365c5ed7 [dev.regabi] cmd/compile: add Name.Canonical and move Byval
+ 2021-01-05 e09783cbc0 [dev.regabi] cmd/compile: make ir.StaticValue safer
+ 2021-01-05 9aa950c407 [dev.regabi] cmd/compile: make ir.OuterValue safer
+ 2021-01-05 eb626409d1 [dev.regabi] cmd/compile: simplify CaptureVars
+ 2021-01-05 c28ca67a96 [dev.regabi] cmd/compile: fix ir.Dump for []*CaseClause, etc
+ 2021-01-04 9eef49cfa6 math/rand: fix typo in comment
+ 2021-01-04 b01fb2af9e testing/fstest: fix typo in error message
+ 2021-01-04 f24e40c14a [dev.regabi] cmd/compile: remove Name.Class_ accessors
+ 2021-01-04 d89705e087 [dev.regabi] cmd/compile: fix re-export of parameters
+ 2021-01-04 290b4154b7 [dev.regabi] cmd/compile: fix ICE due to large uint64 constants
+ 2021-01-04 a30fd52884 [dev.regabi] cmd/compile: use ir.NewNameAt in SubstArgTypes
+ 2021-01-03 8fc44cf0fa [dev.regabi] cmd/compile: remove a couple CloneName calls
+ 2021-01-03 907a4bfdc7 [dev.regabi] cmd/compile: fix map assignment order
+ 2021-01-03 f2e6dab048 [dev.regabi] cmd/compile: remove walkReturn "common case" path
+ 2021-01-03 d36a6bf44d [dev.regabi] cmd/compile: improve walkReturn common case
+ 2021-01-03 a317067d65 [dev.regabi] cmd/compile: improve ascompatee
+ 2021-01-03 5d80a590a2 [dev.regabi] cmd/compile: simplify walkReturn
+ 2021-01-03 bb1b6c95c2 [dev.regabi] cmd/compile: remove Node.{,Set}Walkdef
+ 2021-01-03 57c426c9a5 [dev.regabi] cmd/compile: tighten typecheckdef to *ir.Name
+ 2021-01-03 b1747756e3 [dev.regabi] cmd/compile: reorganize escape analysis somewhat
+ 2021-01-02 f2538033c0 [dev.regabi] cmd/compile: remove Nodes.Set [generated]
+ 2021-01-02 2f2d4b4e68 [dev.regabi] cmd/compile: remove {Ptr,Set}Init from Node interface
+ 2021-01-01 3dd5867605 doc: 2021 is the Year of the Gopher
+ 2021-01-01 1544a03198 [dev.regabi] cmd/compile: refactor redundant type conversion [generated]
+ 2021-01-01 7958a23ea3 [dev.regabi] cmd/compile: use *ir.Name where possible in inl.go
+ 2021-01-01 bfa97ba48f [dev.regabi] test: add another closure test case
+ 2021-01-01 67ad695416 [dev.regabi] cmd/compile: split escape analysis state
+ 2021-01-01 fad9a8b528 [dev.regabi] cmd/compile: simplify inlining of closures
+ 2021-01-01 7d55669847 [dev.regabi] cmd/compile: simplify dwarfgen.declPos
+ 2021-01-01 9ed1577779 [dev.regabi] cmd/compile: remove Func.ClosureEnter
+ 2021-01-01 ece345aa69 [dev.regabi] cmd/compile: expand documentation for Func.Closure{Vars,Enter}
+ 2021-01-01 6ddbc75efd [dev.regabi] cmd/compile: earlier deadcode removal
+ 2021-01-01 68e6fa4f68 [dev.regabi] cmd/compile: fix package-initialization order
+ 2021-01-01 3a4474cdfd [dev.regabi] cmd/compile: some more manual shuffling
+ 2021-01-01 0f1d2129c4 [dev.regabi] cmd/compile: reshuffle type-checking code [generated]
+ 2021-01-01 b8fd3440cd [dev.regabi] cmd/compile: report unused variables during typecheck
+ 2021-01-01 fd22df9905 [dev.regabi] cmd/compile: remove idempotent Name() calls [generated]
+ 2020-12-31 dfbcff80c6 [dev.regabi] cmd/compile: make copyExpr return *ir.Name directly
+ 2020-12-31 77fd81a3e6 [dev.regabi] cmd/compile: use names for keep alive variables in function call
+ 2020-12-31 8fe1197654 [dev.regabi] cmd/compile: remove Name.orig
+ 2020-12-31 477b049060 [dev.regabi] cmd/compile: fix printing of method expressions
+ 2020-12-31 95ce805d14 io/fs: remove darwin/arm64 special condition
+ 2020-12-30 20d0991b86 lib/time, time/tzdata: update tzdata to 2020f
+ 2020-12-30 ed301733bb misc/cgo/testcarchive: remove special flags for Darwin/ARM
+ 2020-12-30 0ae2e032f2 misc/cgo/test: enable TestCrossPackageTests on darwin/arm64
+ 2020-12-30 178c667db2 [dev.regabi] cmd/compile: fix OSLICEARR comments
+ 2020-12-30 f0d99def5b [dev.regabi] cmd/compile: add newline to ir.Dump
+ 2020-12-30 451693af71 [dev.regabi] cmd/compile: simplify typecheckdef
+ 2020-12-30 0c1a899a6c [dev.regabi] cmd/compile: fix defined-pointer method call check
+ 2020-12-30 f9b67f76a5 [dev.regabi] cmd/compile: change ir.DoChildren to use bool result type
+ 2020-12-30 499851bac8 [dev.regabi] cmd/compile: generalize ir/mknode.go
+ 2020-12-30 82ab3d1448 [dev.regabi] cmd/compile: use *ir.Name for Decl.X
+ 2020-12-30 9958b7ed3e [dev.regabi] cmd/compile: unexport ir.FmtNode
+ 2020-12-29 780b4de16b misc/ios: fix wording for command line instructions
+ 2020-12-29 b4a71c95d2 doc/go1.16: reference misc/ios/README for how to build iOS programs
+ 2020-12-29 f83e0f6616 misc/ios: add to README how to build ios executables
+ 2020-12-29 f5816624cd [dev.regabi] cmd/compile: change AddrExpr.Alloc to AddrExpr.Prealloc
+ 2020-12-29 850aa7c60c [dev.regabi] cmd/compile: use *ir.Name instead of ir.Node for CaseClause.Var
+ 2020-12-29 37babc97bb [dev.regabi] cmd/compile: allow visitor visits *ir.Name
+ 2020-12-29 5cf3c87fa6 [dev.regabi] cmd/compile: generate case/comm clause functions in mknode.go
+ 2020-12-29 b3e1ec97fd [dev.regabi] cmd/compile: move new addrtaken bit back to the old name
+ 2020-12-29 0620c674dd [dev.regabi] cmd/compile: remove original addrtaken bit
+ 2020-12-29 0523d525ae [dev.regabi] cmd/compile: separate out address taken computation from typechecker
+ 2020-12-29 9ea272e5ec [dev.regabi] cmd/compile: simplify ir.Func somewhat
+ 2020-12-29 e40cb4d4ae [dev.regabi] cmd/compile: remove more unused code
+ 2020-12-29 6f30c95048 [dev.regabi] cmd/compile: remove unneeded indirection
+ 2020-12-29 171fc6f223 [dev.regabi] cmd/compile: remove workarounds for go/constant issues
+ 2020-12-29 33801cdc62 [dev.regabi] cmd/compile: use Ntype where possible
+ 2020-12-29 82ad3083f8 [dev.regabi] cmd/compile: remove typ from AssignOpStmt
+ 2020-12-29 e34c44a7c4 [dev.regabi] cmd/compile: refactoring typecheck arith
+ 2020-12-29 a5ec920160 [dev.regabi] cmd/compile: more Linksym cleanup
+ 2020-12-29 ec59b197d5 [dev.regabi] cmd/compile: rewrite to use linksym helpers [generated]
+ 2020-12-29 25c613c02d [dev.regabi] cmd/compile: add Linksym helpers
+ 2020-12-29 289da2b33e [dev.regabi] cmd/compile: move Node.Opt to Name
+ 2020-12-29 6acbae4fcc [dev.regabi] cmd/compile: address some ir TODOs
+ 2020-12-29 4629f6a51d [dev.regabi] cmd/compile: merge {Selector,CallPart,Method}Expr
+ 2020-12-29 e563715b30 [dev.regabi] cmd/compile: remove Sym.Importdef
+ 2020-12-29 3f370b75fb [dev.regabi] cmd/compile: cleanup //go:generate directives
+ 2020-12-28 4fd9455882 io/fs: fix typo in comment
+ 2020-12-28 07569dac4e [dev.regabi] all: merge master (1d78139) into dev.regabi
+ 2020-12-28 76136be027 [dev.regabi] cmd/compile: check for recursive import in ImportBody
+ 2020-12-28 fda7ec3a3f [dev.regabi] cmd/compile: remove Name.IsDDD, etc
+ 2020-12-28 098a6490b9 [dev.regabi] cmd/compile: remove Declare in makepartialcall
+ 2020-12-28 137f0d2e06 [dev.regabi] cmd/compile: remove unnecessary Name.Sym call
+ 2020-12-28 3383b5c74a [dev.regabi] cmd/compile: flatten dependency graph [generated]
+ 2020-12-28 f8afb8216a [dev.regabi] cmd/compile: rename CommStmt and CaseStmt [generated]
+ 2020-12-28 5f3bd59a0d [dev.regabi] cmd/compile: remove some unneeded code in package ir
+ 2020-12-28 3bdafb0d82 [dev.regabi] cmd/compile: remove CommStmt.List
+ 2020-12-28 2ecf52b841 [dev.regabi] cmd/compile: separate CommStmt from CaseStmt
+ 2020-12-28 ed9772e130 [dev.regabi] cmd/compile: add explicit file name in types generation
+ 2020-12-28 a59d26603f [dev.regabi] cmd/compile: use []*CaseStmt in {Select,Switch}Stmt
+ 2020-12-28 fbc4458c06 [dev.regabi] cmd/compile: simplify some tree traversal code
+ 2020-12-28 6c67677541 [dev.regabi] cmd/compile: simplify FuncName and PkgFuncName
+ 2020-12-28 676d794b81 [dev.regabi] cmd/compile: remove refersToCommonName
+ 2020-12-28 c98548e110 [dev.regabi] cmd/compile: merge ascompatee, ascompatee1, and reorder3
+ 2020-12-28 4c215c4fa9 [dev.regabi] cmd/compile: simplify and optimize reorder3
+ 2020-12-28 e6c973198d [dev.regabi] cmd/compile: stop mangling SelectorExpr.Sel for ODOTMETH
+ 2020-12-28 135ce1c485 [dev.regabi] cmd/compile: desugar OMETHEXPR into ONAME during walk
+ 2020-12-28 0f732f8c91 [dev.regabi] cmd/compile: minor walkExpr cleanups
+ 2020-12-28 0de8eafd98 [dev.regabi] cmd/compile: remove SelectorExpr.Offset field
+ 2020-12-28 a4f335f420 [dev.regabi] cmd/compile: always use a Field for ODOTPTR expressions
+ 2020-12-26 1d78139128 runtime/cgo: fix Android build with NDK 22
+ 2020-12-25 2018b68a65 net/mail: don't use MDT in test
+ 2020-12-25 e4f293d853 [dev.regabi] cmd/compile: fix OCALLMETH desugaring
+ 2020-12-25 1d9a1f67d5 [dev.regabi] cmd/compile: don't emit reflect data for method types
+ 2020-12-25 396b6c2e7c [dev.regabi] cmd/compile: cleanup assignment typechecking
+ 2020-12-25 e24d2f3d05 [dev.regabi] cmd/compile: remove typ from RangeStmt
+ 2020-12-25 2785c691c2 [dev.regabi] cmd/compile: cleanup devirtualization docs
+ 2020-12-25 4b1d0fe66f [dev.regabi] cmd/compile: new devirtualization pkg [generated]
+ 2020-12-24 082cc8b7d9 [dev.regabi] cmd/compile: change ir.IsAssignable -> ir.IsAddressable
+ 2020-12-24 27b248b307 [dev.regabi] cmd/compile: separate range stmt Vars to Key, Value nodes
+ 2020-12-23 40818038bf [dev.regabi] cmd/compile: change CaseStmt.Vars to Var
+ 2020-12-23 b116404444 runtime: shift timeHistogram buckets and allow negative durations
+ 2020-12-23 8db7e2fecd runtime: fix allocs-by-size and frees-by-size buckets
+ 2020-12-23 fb96f07e1a runtime: fix nStackRoots comment about stack roots
+ 2020-12-23 d1502b3c72 lib/time, time/tzdata: update tzdata to 2020e
+ 2020-12-23 30c99cbb7a cmd/go: add the Retract field to 'go help mod edit' definition of the GoMod struct
+ 2020-12-23 49d0b239cb doc: fix a typo in contribute.html
+ 2020-12-23 9eeed291bc [dev.regabi] cmd/compile: eliminate usage of ir.Node in liveness
+ 2020-12-23 d1d64e4cea [dev.regabi] cmd/compile: split SliceExpr.List into separate fields
+ 2020-12-23 98a73030b0 cmd/go: in 'go get', promote named implicit dependencies to explicit
+ 2020-12-23 d19018e8f1 [dev.regabi] cmd/compile: split SliceHeaderExpr.LenCap into separate fields
+ 2020-12-23 53f082b0ee [dev.regabi] cmd/compile: cleanup export code further
+ 2020-12-23 31267f82e1 [dev.regabi] cmd/compile: simplify function/interface/struct typechecking
+ 2020-12-23 addade2cce [dev.regabi] cmd/compile: prefer types constructors over typecheck
+ 2020-12-23 18ebfb49e9 [dev.regabi] cmd/compile: cleanup noder
+ 2020-12-23 87a592b356 [dev.regabi] cmd/compile: cleanup import/export code
+ 2020-12-23 5898025026 [dev.regabi] cmd/compile: update mkbuiltin.go to use new type constructors
+ 2020-12-23 63c96c2ee7 [dev.regabi] cmd/compile: update mkbuiltin.go and re-enable TestBuiltin
+ 2020-12-23 37f138df6b [dev.regabi] cmd/compile: split out package test [generated]
+ 2020-12-23 3d8a3cb06b [dev.regabi] cmd/compile: split out package pkginit [generated]
+ 2020-12-23 3f04d964ab [dev.regabi] cmd/compile: split up walkexpr1, walkstmt [generated]
+ 2020-12-23 e4895ab4c0 [dev.regabi] cmd/compile: split out package walk [generated]
+ 2020-12-23 01fd2d05c8 [dev.regabi] cmd/compile: split out package dwarfgen [generated]
+ 2020-12-23 6c34d2f420 [dev.regabi] cmd/compile: split out package ssagen [generated]
+ 2020-12-23 de65151e50 [dev.regabi] cmd/compile: split out package reflectdata [generated]
+ 2020-12-23 4dfb5d91a8 [dev.regabi] cmd/compile: split out package staticdata [generated]
+ 2020-12-23 fbc82f03b1 [dev.regabi] cmd/compile: split out package noder [generated]
+ 2020-12-23 de454eef5f [dev.regabi] cmd/compile: split out package escape [generated]
+ 2020-12-23 071ab0a14c [dev.regabi] cmd/compile: split out package liveness [generated]
+ 2020-12-23 0ced54062e [dev.regabi] cmd/compile: split out package objw [generated]
+ 2020-12-23 575fd6ff0a [dev.regabi] cmd/compile: split out package inline [generated]
+ 2020-12-23 0256ba99a8 [dev.regabi] cmd/compile: split up typecheck1 [generated]
+ 2020-12-23 b9693d7627 [dev.regabi] cmd/compile: split out package typecheck [generated]
+ 2020-12-23 dac0de3748 [dev.regabi] cmd/compile: move type size calculations into package types [generated]
+ 2020-12-23 527a1895d6 [dev.regabi] cmd/compile: move helpers into package ir [generated]
+ 2020-12-23 65c4c6dfb2 [dev.regabi] cmd/compile: group known symbols, packages, names [generated]
+ 2020-12-23 9ee309255a [dev.regabi] cmd/compile: move helpers into package types [generated]
+ 2020-12-23 ead4957892 [dev.regabi] cmd/compile: move helpers into package base [generated]
+ 2020-12-23 440308ffd7 [dev.regabi] cmd/compile: simplify Nodes usage [generated]
+ 2020-12-23 f9d373720e [dev.regabi] cmd/compile: remove Left, Right etc methods [generated]
+ 2020-12-23 14d667341f [dev.regabi] cmd/compile: remove Node.Left etc [generated]
+ 2020-12-23 6f27d29be0 [dev.regabi] cmd/compile: remove ir.Nod [generated]
+ 2020-12-23 fd6ba1c8a2 os/signal: fix a deadlock with syscall.AllThreadsSyscall() use
+ 2020-12-23 69cf39089f [dev.regabi] cmd/compile: do not die in early base.FlushErrors
+ 2020-12-23 6d03cde88a [dev.regabi] cmd/dist: automatically bootstrap cmd subdirs
+ 2020-12-23 b0b0d98283 runtime: linux iscgo support for not blocking nptl signals
+ 2020-12-23 d1d1099c91 [dev.regabi] cmd/compile: fixes for big rewrite
+ 2020-12-22 223331fc0c cmd/go/internal/modload: add hint for missing implicit dependency
+ 2020-12-22 ec741b0447 [dev.regabi] all: merge master (c9fb4eb) into dev.regabi
+ 2020-12-22 acc32ea124 [dev.regabi] codereview.cfg: add config for dev.regabi
+ 2020-12-22 c9fb4eb0a2 cmd/link: handle grouped resource sections
+ 2020-12-22 c40934b33d [dev.regabi] cmd/compile: adjust one case in walkexpr
+ 2020-12-22 280e7fd1ee [dev.regabi] cmd/compile: only access Func method on concrete types
+ 2020-12-22 51ba53f5c2 [dev.regabi] cmd/compile: separate misc for gc split
+ 2020-12-22 572f168ed2 [dev.regabi] cmd/compile: separate various from Main
+ 2020-12-22 3b12c6dc08 [dev.regabi] cmd/compile: separate typecheck more cleanly
+ 2020-12-22 7c8f5356ab [dev.regabi] cmd/compile: separate dowidth better
+ 2020-12-22 c06a354bcc test: trigger SIGSEGV instead of SIGTRAP in issue11656.go
+ 2020-12-22 0aa9b4709a cmd/pack: r command create output file if not exist
+ 2020-12-22 cb28c96be8 [dev.regabi] cmd/compile,cmd/link: initial support for ABI wrappers
+ 2020-12-22 c8610e4700 [dev.regabi] cmd/compile: add ir.BasicLit to represent literals
+ 2020-12-22 3512cde10a [dev.regabi] cmd/compile: stop reusing Ntype for OSLICELIT length
+ 2020-12-22 2755361e6a [dev.regabi] cmd/compile: change noder.declNames to returns ir.Names
+ 2020-12-22 301af2cb71 [dev.regabi] runtime/race: adjust test pattern match for ABI wrapper
+ 2020-12-22 4d27c4c223 runtime: correct error handling in several FreeBSD syscall wrappers
+ 2020-12-22 9b6147120a cmd/pack: treat compiler's -linkobj output as "compiler object"
+ 2020-12-22 306b2451c8 [dev.regabi] runtime: fix ABI targets in runtime.panic{Index,Slice} shims
+ 2020-12-21 bc7e4d9257 syscall: don't generate ptrace on iOS
+ 2020-12-21 94cfeca0a5 [dev.regabi] cmd/compile: stop using ONONAME with Name
+ 2020-12-21 cb4898a77d [dev.regabi] cmd/compile: simplify declaration importing
+ 2020-12-21 06915ac14d [dev.regabi] cmd/compile: move itabname call out of implements
+ 2020-12-21 6cff874c47 runtime/metrics: add Read examples
+ 2020-12-21 4e8f681eff Merge "[dev.regabi] all: merge master into dev.regabi" into dev.regabi
+ 2020-12-21 1a523c8ab0 [dev.regabi] cmd/compile: separate nowritebarrierrec from main
+ 2020-12-21 e999c17022 [dev.regabi] cmd/compile: separate ssa from other phases
+ 2020-12-21 4836e28ac0 [dev.regabi] cmd/compile: separate noder more cleanly
+ 2020-12-21 85ce6ecfe3 [dev.regabi] cmd/compile: separate exportsym more cleanly
+ 2020-12-21 1a3b036b83 [dev.regabi] cmd/compile: collect global compilation state
+ 2020-12-21 2153a99914 [dev.regabi] cmd/compile: setup to move Addrconst, Patch into cmd/internal/obj
+ 2020-12-21 0bb0baf683 [dev.regabi] cmd/compile: cleanup for concrete types - more
+ 2020-12-21 ca8e17164e [dev.regabi] all: merge master into dev.regabi
+ 2020-12-21 8438a5779b runtime: use _exit on darwin
+ 2020-12-21 cb95819cf6 runtime: detect netbsd netpoll overrun in sysmon
+ 2020-12-21 53c984d976 runtime: skip wakep call in wakeNetPoller on Plan 9
+ 2020-12-21 9abbe27710 test: skip issue11656.go on mips/mips64/ppc64
+ 2020-12-20 89b44b4e2b cmd/compile: recognize reassignments involving receives
+ 2020-12-19 55b58018f4 test: for issue11656 try to execute trap, not call it
+ 2020-12-18 626cc7c02d test: permit "exponent too large" error
+ 2020-12-18 139cd0e12f go/build: make TestDependencies work again
+ 2020-12-18 2de7866470 os: remove dependency on strings package
+ 2020-12-18 c45313bf45 [dev.regabi] cmd/compile: remove prealloc map
+ 2020-12-18 ffb0cb7044 [dev.regabi] cmd/compile: remove uses of Name.Offset, Name.copy
+ 2020-12-18 c76be2a24e [dev.regabi] cmd/compile: add ONAMEOFFSET, delete to-be-deleted fields
+ 2020-12-18 4e8f1e139f [dev.regabi] cmd/compile: cleanup for concrete types - sinit
+ 2020-12-18 27aba22651 [dev.regabi] cmd/compile: cleanup for concrete types - walk
+ 2020-12-18 0b9cb63b8d [dev.regabi] cmd/compile: rename ir.Find to ir.Any and update uses
+ 2020-12-18 ae652a4ac9 os/signal: fix flaky tests for NotifyContext.
+ 2020-12-18 740851baca cmd/link: avoid use of -T when linking with lld
+ 2020-12-18 f1778c28a9 test: recognize and use gc build tag
+ 2020-12-17 8fcf318123 api/go1.16: remove crypto/tls APIs that are moved to Go 1.17
+ 2020-12-17 520f3b72db crypto/tls: revert "add HandshakeContext method to Conn"
+ 2020-12-17 2ff33f5e44 api: promote next to go1.16
+ 2020-12-17 aeedc9f804 [dev.regabi] cmd/compile: remove OSELRECV
+ 2020-12-17 0328c3b660 [dev.regabi] cmd/compile: use OSELRECV2 for all <-c variants
+ 2020-12-17 88e1415d08 [dev.regabi] cmd/compile: add type assertion in regabi test
+ 2020-12-17 9c384e881e [dev.regabi] cmd/compile: cleanup for concrete types - mop-up
+ 2020-12-17 be64c8bece [dev.regabi] cmd/compile: cleanup for concrete types - noder
+ 2020-12-17 5024396563 [dev.regabi] cmd/compile: cleanup for concrete types - subr
+ 2020-12-17 dd67b13d07 [dev.regabi] cmd/compile: cleanup for concrete types - range, select, swt
+ 2020-12-17 42fec2ded4 [dev.regabi] cmd/compile: cleanup for concrete types - const
+ 2020-12-17 389ae3d5ba [dev.regabi] cmd/compile: cleanup for concrete types - inl
+ 2020-12-17 5fe64298a4 [dev.regabi] cmd/compile: cleanup for concrete types - import/export
+ 2020-12-17 aa55d4e54b [dev.regabi] cmd/compile: cleanup for concrete types - escape
+ 2020-12-17 846740c17f [dev.regabi] cmd/compile: cleanup for concrete types - ssa
+ 2020-12-17 bf9bbbd6ed [dev.regabi] cmd/compile: cleanup for concrete types - order
+ 2020-12-17 4ac6a6317b [dev.regabi] cmd/compile: cleanup for concrete types - typecheck
+ 2020-12-17 f6efa3d4a4 [dev.regabi] cmd/compile: simplify ir.Find, replace ir.Inspect with ir.Visit
+ 2020-12-17 f6d2834f8f [dev.regabi] cmd/compile: limit Implicit method to nodes where it is defined
+ 2020-12-17 7fde0d2b50 [dev.regabi] cmd/compile: remove use of Initorder, Offset Node fields for initorder
+ 2020-12-17 114af2a044 [dev.regabi] cmd/compile: change Nodes to be a slice
+ 2020-12-17 4dfc7333f4 [dev.regabi] cmd/compile: update ir/fmt for concrete types
+ 2020-12-17 a997543292 [dev.regabi] cmd/compile: fix potential closure waste in Order
+ 2020-12-17 578fbbe3aa [dev.regabi] cmd/compile: rewrite some generic ir.Nod calls
+ 2020-12-17 5ae70b85c6 [dev.regabi] cmd/compile: cleanup preparing for concrete types, 2
+ 2020-12-17 fa06894b36 [dev.regabi] cmd/compile: cleanup preparing for concrete types
+ 2020-12-17 5a4db102b2 html/template: avoid race when escaping updates template
+ 2020-12-16 b0f01e17f8 go/types: report error for invalid (but empty) expr switch
+ 2020-12-16 5abda2618b cmd/link: handle large relocation addend on darwin/arm64
+ 2020-12-16 a318d56c1e cmd/link: pass arch-specific flags to external linker when testing supported flag
+ 2020-12-16 f4e7a6b905 cmd/internal/goobj: fix buglet in object file reader
+ 2020-12-16 75e16f5127 doc/go1.16: add link to reflect.StructTag
+ 2020-12-16 08b5091d03 net: close connection in localServer teardown
+ 2020-12-16 8981092d71 cmd/link: ignore SEH marking on PE objects
+ 2020-12-15 731bb54038 test: update for gofrontend error message changes
+ 2020-12-15 129bb1917b doc/go1.15: mention 1.15.3 cgo restriction on empty structs
+ 2020-12-15 685a322fe4 test: match gofrontend error messages
+ 2020-12-15 3d6467824c test: only require issue11674 errors with gc compiler
+ 2020-12-15 7cdc84a15b test: remove bug429 (duplicates runtime.TestSimpleDeadlock)
+ 2020-12-15 412dc2f4d3 test: adjust issue11371 to fit in required precision
+ 2020-12-15 8e2d74b705 test: only check for issue11362 error with gc
+ 2020-12-15 f8ac237032 test: import file name for issue19028
+ 2020-12-15 a508840c67 doc/go1.16: fix path, path/filepath release notes
+ 2020-12-15 5046cb8a6e doc/go1.16: fix formatting in net, net/http and net/http/httputil sections
+ 2020-12-15 3298300ddf text/template: error on range over send channel
+ 2020-12-15 4c2d66f642 [dev.regabi] cmd/compile: use ir.Ident for imported identifiers
+ 2020-12-15 305d93ef84 [dev.regabi] cmd/compile: type check externdcl earlier
+ 2020-12-15 9f16620f46 [dev.regabi] cmd/compile: fix latent Sym.SetPkgDef issue
+ 2020-12-15 5a25a3fd1d test: recognize gofrontend error messages
+ 2020-12-14 fea898a4b0 [dev.regabi] cmd/compile: intercept the making of OADDR nodes
+ 2020-12-14 663cd862ed cmd/link: do not mark resource section as writable
+ 2020-12-14 48dfa2b2dc cmd/link: deal with ADDR32NB relocations the same way as ADDR32 on arm
+ 2020-12-14 033390d9ad cmd/link: recognize arm header of PE objects
+ 2020-12-14 48906a6d57 net/http/pprof: don't treat os.Args as format string in Cmdline handler
+ 2020-12-14 6e3cc5c56f go/types: report invalid ... in conversions
+ 2020-12-14 278b9a8a4a io/fs: fix package reference in FS godoc
+ 2020-12-14 617383377f [dev.regabi] cmd/compile: reorg generated array hash loop
+ 2020-12-14 d06794da4a doc/go1.16: add missing <code> tag
+ 2020-12-14 dea6d94a44 math/big: add test for recursive division panic
+ 2020-12-14 2f5b1a3974 test: make a race detector test robust to timing variations
+ 2020-12-14 c81343ce3a net/http: attempt deadlock fix in TestDisableKeepAliveUpgrade
+ 2020-12-14 828746ec57 debug/dwarf: don't try to parse addr/rnglists header
+ 2020-12-14 be10af7c4e test: match gofrontend error messages
+ 2020-12-14 89f38323fa [dev.regabi] cmd/compile: add register ABI analysis utilities
+ 2020-12-14 ce61ccca8f test: match gofrontend error messages
+ 2020-12-14 a58be734ea cmd/compile: fix incorrect shift count type with s390x rules
+ 2020-12-14 8ce37e4110 [dev.regabi] cmd/compile: fix noopt builder
+ 2020-12-14 7e17b46c58 [dev.regabi] cmd/compile/internal/types: add IsScalar query method
+ 2020-12-14 2b76429eb0 [dev.regabi] cmd/compile: refactor type initialization code into helper
+ 2020-12-14 9c5241e520 [dev.regabi] cmd/compile: remove unnecessary String methods
+ 2020-12-14 267975dc47 Merge branch 'master' into dev.regabi
+ 2020-12-14 64d8846aae cmd/go: print hint when 'go install' run without version outside module
+ 2020-12-14 451b6b38fd cmd/go: refactor error reporting in internal/load
+ 2020-12-09 63bc23b545 [dev.regabi] cmd/compile: first start towards using Ident
+ 2020-12-09 eae8fd519b [dev.regabi] cmd/compile: iexport debug crumbs for toolstash
+ 2020-12-09 837b35cc55 [dev.regabi] cmd/compile: adjust IR representations
+ 2020-12-09 0c49440664 [dev.regabi] cmd/compile: arrange for walkstmt, walkexpr, to return from switch cases
+ 2020-12-09 4090af83c5 [dev.regabi] cmd/compile: use reflection in ir.Dump
+ 2020-12-09 e2d278bfeb [dev.regabi] cmd/compile: two small fixes
+ 2020-12-08 dbf2fc8cff [dev.regabi] cmd/compile: replace many uses of ir.Node with *ir.Name
+ 2020-12-08 bb31c75343 [dev.regabi] cmd/compile: ir.Node is no longer an ssa.Aux
+ 2020-12-08 6db970e20a [dev.regabi] cmd/compile: rewrite Aux uses of ir.Node to *ir.Name [generated]
+ 2020-12-08 1c8943a6ad [dev.regabi] cmd/compile: introduce FwdRefAux for wrapping ir.Node as ssa.Aux
+ 2020-12-08 dcec658f6c [dev.regabi] cmd/compile: change LocalSlot.N to *ir.Name
+ 2020-12-08 1a98ab0e2d [dev.regabi] cmd/compile: add ssa.Aux tag interface for Value.Aux
+ 2020-12-07 63722da46b [dev.regabi] cmd/compile: fix comment
+ 2020-12-07 6d783e7440 [dev.regabi] cmd/compile: export all Node fields [generated]
+ 2020-12-07 2de0af3b1b [dev.regabi] cmd/compile: prepare mknode for rename of Func.body
+ 2020-12-07 724374f859 [dev.regabi] cmd/compile: rewrite stale format strings
+ 2020-12-07 61889ba680 [dev.regabi] cmd/compile: simplify fmtmap
+ 2020-12-07 6ea2b8c54c [dev.regabi] cmd/compile: clean up and document formatting
+ 2020-12-07 bb4a37bd93 [dev.regabi] cmd/compile: move Type, Sym printing to package types [generated]
+ 2020-12-07 70155cca81 [dev.regabi] cmd/compile: untangle FmtFlag, FmtMode
+ 2020-12-07 3904a62829 [dev.regabi] cmd/compile: remove mode.Sprintf etc in printer
+ 2020-12-07 fb17dfa43d [dev.regabi] cmd/compile: narrow interface between ir and types
+ 2020-12-07 3b25f3c150 [dev.regabi] cmd/compile: simplify Op, Node, Nodes printing
+ 2020-12-07 8ce2605c5b [dev.regabi] cmd/compile: untangle ir.Dump printing
+ 2020-12-07 158c9dd131 [dev.regabi] cmd/compile: reorganize ir/fmt.go
+ 2020-12-07 a79742f39a [dev.regabi] cmd/compile: remove "short" node header mode
+ 2020-12-07 ef5964dd6b [dev.regabi] cmd/compile: arrange for typecheck1 to end in switch
+ 2020-12-07 dcc640e839 [dev.regabi] test: add exhaustive test of evaluated but not used
+ 2020-12-07 2cec6c4a8c [dev.regabi] cmd/compile: generate Node methods using program
+ 2020-12-07 d90b199e9c [dev.regabi] cmd/compile: silence errors about missing blank methods
+ 2020-12-06 e885df2731 [dev.regabi] cmd/compile: change iexport to avoid map[ir.Node]
+ 2020-12-06 2d4c95565a [dev.regabi] cmd/compile: change nowritebarrierrec to use map[*ir.Func]
+ 2020-12-06 1b5eed8982 [dev.regabi] cmd/compile: replace NodeQueue with NameQueue
+ 2020-12-06 6c5967e528 [dev.regabi] cmd/compile: change NodeSet to NameSet
+ 2020-12-04 46b6e70e3b [dev.regabi] cmd/compile: replace ir.Node with *ir.Name in Order
+ 2020-12-04 b75f51c645 [dev.regabi] cmd/compile: replace ir.Node with *ir.Name in Liveness
+ 2020-12-04 133b03e1c3 [dev.regabi] cmd/compile: rewrite code to use DeclaredBy
+ 2020-12-04 d9cb84c84b [dev.regabi] cmd/compile: add SameSource, Uses, and DeclaredBy helpers
+ 2020-12-04 5dbd2e8e44 [dev.regabi] cmd/compile: remove DeepCopyNode interface
+ 2020-12-04 9ab3d854ad [dev.regabi] cmd/compile: avoid general traversal in deadcode
+ 2020-12-04 bb5aa2b664 [dev.regabi] cmd/compile: implement editChildren for nodes
+ 2020-12-04 4725c3ffd1 [dev.regabi] cmd/compile: implement doChildren for nodes
+ 2020-12-04 18f2df7e81 [dev.regabi] cmd/compile: implement copy for nodes
+ 2020-12-04 d855b30fe4 [dev.regabi] cmd/compile: use ir.EditChildren for inline rewriting
+ 2020-12-04 b9df26d7a8 [dev.regabi] cmd/compile: use ir.Find for "search" traversals
+ 2020-12-04 0d1b44c645 [dev.regabi] cmd/compile: introduce IR visitors
+ 2020-12-04 7fcf5b994c [dev.regabi] cmd/compile: replace inlcopy with ir.DeepCopy
+ 2020-12-04 989a3f5041 [dev.regabi] cmd/compile: adjustments to Copy and DeepCopy
+ 2020-12-04 99ecfcae31 [dev.regabi] cmd/compile: swap inlining order of if then vs else blocks
+ 2020-12-04 84cb51d7d7 [dev.regabi] cmd/compile: eliminate more SetOrig
+ 2020-12-03 351bc2f38c [dev.regabi] cmd/compile: store types.Field on {Selector,CallPart}Expr
+ 2020-12-03 a2058bac21 [dev.regabi] cmd/compile: add ConstExpr
+ 2020-12-03 beb5e05404 [dev.regabi] cmd/compile: refactoring prep for ConstExpr
+ 2020-12-03 7e81135be7 [dev.regabi] cmd/compile: rename addinit(n, init) to initExpr(init, n)
+ 2020-12-03 6e30fc10fc [dev.regabi] all: merge master (d0c0dc682c1f) into dev.regabi
+ 2020-12-03 59b8916d48 [dev.regabi] cmd/compile: handle OCONVNOP better in ssa
+ 2020-12-03 00e5727790 [dev.regabi] cmd/compile: remove okAs
+ 2020-12-03 5a3b6796cd [dev.regabi] cmd/compile: remove extra typ field in Name struct
+ 2020-12-02 64bc656aed [dev.regabi] cmd/compile: use explicit block statements for init
+ 2020-12-02 ecc8d15bc5 [dev.regabi] cmd/compile: delete OEMPTY
+ 2020-12-02 ec5f349b22 [dev.regabi] cmd/compile: merge OBLOCK and OEMPTY
+ 2020-12-02 c769d393de [dev.regabi] cmd/compile: add ir.NewDeclNameAt
+ 2020-12-02 c10b0ad628 [dev.regabi] cmd/compile: add Pkg parameter to type constructors
+ 2020-12-02 42e46f4ae0 [dev.regabi] cmd/compile: comment out //go:linkname warning
+ 2020-12-02 77a71e0057 [dev.regabi] cmd/compile: add Interface, Signature, and Struct constructors
+ 2020-12-02 15085f8974 [dev.regabi] cmd/compile: tweak hash bucket type descriptor
+ 2020-12-01 1408d26ccc [dev.regabi] cmd/compile: cleanup some leftover cruft
+ 2020-12-01 5ffa275f3c [dev.regabi] cmd/compile: first pass at abstracting Type
+ 2020-12-01 6ca23a45fe [dev.regabi] cmd/compile: only save ONAMEs on Curfn.Dcl
+ 2020-12-01 a17c5e2fce [dev.regabi] cmd/compile: add NewBasic and cleanup universe
+ 2020-12-01 f37aa5e4e2 [dev.regabi] cmd/compile: add NewNamed
+ 2020-12-01 63a6f08b39 [dev.regabi] cmd/compile: move setUnderlying to package types
+ 2020-12-01 f2311462ab [dev.regabi] cmd/compile: cleanup type-checking of defined types
+ 2020-12-01 2d6ff998ed [dev.regabi] cmd/compile: process //go:linknames after declarations
+ 2020-12-01 ecff7628ea [dev.regabi] cmd/compile: unexport Node.RawCopy
+ 2020-12-01 4da41fb3f8 [dev.regabi] cmd/compile: use ir.Copy instead of direct use of RawCopy
+ 2020-12-01 dadfc80bc1 [dev.regabi] cmd/compile: improve findTypeLoop
+ 2020-12-01 45f3b646d4 [dev.regabi] cmd/compile: add OSTMTEXPR Op
+ 2020-12-01 9a5a11adfa [dev.regabi] cmd/compile: add custom expression Node implementations
+ 2020-12-01 0f9f27287b [dev.regabi] cmd/compile: remove types.InitSyms
+ 2020-11-30 41ad4dec99 [dev.regabi] cmd/compile: fix -h
+ 2020-11-30 ffa68716a0 [dev.regabi] cmd/compile: add custom statement Node implementations
+ 2020-11-30 2bc814cd18 [dev.regabi] cmd/compile: clean up ONEW node
+ 2020-11-30 b7f67b75d2 [dev.regabi] cmd/compile: clean up in preparation for expression Nodes
+ 2020-11-30 5fc192af56 [dev.regabi] cmd/compile: clean up Order.copyExpr TODO
+ 2020-11-30 7c9b6b1ca2 [dev.regabi] cmd/compile: clean up in preparation for statement Nodes
+ 2020-11-30 c6de5d8d1f [dev.regabi] cmd/compile: simplify export data representation of nil
+ 2020-11-30 ae1a337809 [dev.regabi] cmd/compile: remove ODCLFIELD and ODDD ops
+ 2020-11-30 4e7685ef1a [dev.regabi] cmd/compile: add custom type syntax Node implementations
+ 2020-11-30 d40869fced [dev.regabi] cmd/compile: move gc.treecopy to ir.DeepCopy
+ 2020-11-30 f0001e8867 [dev.regabi] cmd/compile: add OTSLICE Op
+ 2020-11-30 1b84aabb01 [dev.regabi] cmd/compile: move typenod, typenodl to ir.TypeNode, ir.TypeNodeAt [generated]
+ 2020-11-30 e5c6463e20 [dev.regabi] cmd/compile: add ir.CallPartExpr
+ 2020-11-30 4eaef981b5 [dev.regabi] cmd/compile: add ir.Closure, ir.ClosureRead
+ 2020-11-30 e84b27bec5 [dev.regabi] cmd/compile: clean up Name and Func uses
+ 2020-11-30 c4bd0b7474 [dev.regabi] cmd/compile: make ir.Func the ODCLFUNC Node implementation
+ 2020-11-30 65ae15ac5d [dev.regabi] cmd/compile: move func code from node.go to func.go
+ 2020-11-30 862f638a89 [dev.regabi] cmd/compile: make ir.Name the ONAME Node implementation
+ 2020-11-30 f6106d195d [dev.regabi] cmd/compile: add ir.PkgName
+ 2020-11-30 420809ab08 [dev.regabi] cmd/compile: move name code from node.go to name.go
+ 2020-11-30 be3d8b40b5 [dev.regabi] cmd/compile: ir.BranchStmt, add ir.EmptyStmt, ir.LabelStmt
+ 2020-11-30 b09dbc6913 [dev.regabi] cmd/compile: remove SetOp(OEMPTY) calls
+ 2020-11-30 171787efcd [dev.regabi] cmd/compile: remove Orig, SetOrig from Node interface
+ 2020-11-30 79a3d5ce15 [dev.regabi] cmd/compile: setup for new Node implementations
+ 2020-11-30 0c65a2f317 [dev.regabi] cmd/compile: drop Node.HasOpt method
+ 2020-11-30 65f4ec2fae [dev.regabi] cmd/compile: cleanup label handling
+ 2020-11-25 88e33f6ecb [dev.regabi] cmd/compile: fix latent import/export issue with break/continue
+ 2020-11-25 40f5bc4d55 [dev.regabi] merge master 4481ad6eb6 into dev.regabi
+ 2020-11-25 41f3af9d04 [dev.regabi] cmd/compile: replace *Node type with an interface Node [generated]
+ 2020-11-25 4d0d9c2c5c [dev.regabi] cmd/compile: introduce ir.INode interface for *ir.Node
+ 2020-11-25 c26aead50c [dev.regabi] cmd/compile: convert types.Node (a pointer) to types.IRNode (an interface)
+ 2020-11-25 acb4d1cef1 [dev.regabi] cmd/compile: use Node getters and setters [generated]
+ 2020-11-25 41ab6689ed [dev.regabi] cmd/compile: rewrite a few ++/--/+=/-= to prep for getters/setters [generated]
+ 2020-11-25 048debb224 [dev.regabi] cmd/compile: remove gc ↔ ssa cycle hacks
+ 2020-11-25 84e2bd611f [dev.regabi] cmd/compile: introduce cmd/compile/internal/ir [generated]
+ 2020-11-25 331b8b4797 [dev.regabi] cmd/compile: move okforconst into its own declaration
+ 2020-11-25 26b66fd60b [dev.regabi] cmd/compile: introduce cmd/compile/internal/base [generated]
+ 2020-11-25 eb3086e5a8 [dev.regabi] cmd/compile: finish cleanup of Debug parsing
+ 2020-11-25 3c240f5d17 [dev.regabi] cmd/compile: clean up debug flag (-d) handling [generated]
+ 2020-11-25 756661c82a [dev.regabi] cmd/compile: finish cleanup of Flag initialization
+ 2020-11-25 259fd8adbb [dev.regabi] cmd/compile: fix reporting of overflow
+ 2020-11-25 18573aea3c [dev.regabi] cmd/compile: clean up flag handling [generated]
+ 2020-11-25 6e583d65ab [dev.regabi] cmd/compile: simplify fmt handling of Nodes
+ 2020-11-25 d166ef6876 [dev.regabi] cmd/compile: add Node field getters and setters
+ 2020-11-25 9262909764 [dev.regabi] cmd/compile: rewrite problematic use of Node fields
+ 2020-11-25 9e0e43d84d [dev.regabi] cmd/compile: remove uses of dummy
+ 2020-11-25 4a6b4fd139 [dev.regabi] add FatalfAt and fix Fatalf docs
+ 2020-11-25 484449c641 [dev.regabi] cmd/compile: remove file mistakenly added by CL 272248
+ 2020-11-25 7d72951229 [dev.regabi] cmd/compile: replace Val with go/constant.Value
+ 2020-11-24 6826287c6b [dev.regabi] cmd/compile: replace evconst with non-mutating version
+ 2020-11-24 c22bc745c3 [dev.regabi] cmd/compile: delete n.List after collapsing OADDSTR to OLITERAL
+ 2020-11-24 ee6132a698 [dev.regabi] cmd/compile: introduce OMETHEXPR instead of overloading ONAME
+ 2020-11-24 4f9d54e41d [dev.regabi] cmd/compile: add OMETHEXPR
+ 2020-11-24 fd11a32c92 [dev.regabi] cmd/compile: clean up Node.Func
+ 2020-11-24 8e2106327c [dev.regabi] cmd/compile: clean up tests to know less about Node
+ 2020-11-24 742c05e3bc [dev.regabi] cmd/compile: prep refactoring for switching to go/constant
+ 2020-11-24 015423a15b [dev.regabi] strconv: add to bootstrap packages
+ 2020-11-24 c767d73227 [dev.regabi] cmd/compile: remove CTRUNE
+ 2020-11-24 6dae48fb0b [dev.regabi] cmd/compile: refactor type/value assertions
+ 2020-11-24 88a9e2f9ad [dev.regabi] cmd/compile: replace CTNIL with ONIL
+ 2020-11-24 4af2decf30 [dev.regabi] cmd/compile: add (unused) ONIL constant
+ 2020-11-24 668e3a598f [dev.regabi] cmd/compile: cleanup type switch typechecking
+ 2020-11-24 96f3fb7244 [dev.regabi] go/constant: avoid heap allocations in match
+ 2020-11-24 1abb12fc97 [dev.regabi] go/constant: optimize BitLen
+ 2020-11-24 228b732ad9 [dev.regabi] cmd/compile: prepare for package ir
+ 2020-11-24 e37597f7f0 [dev.regabi] cmd/compile: rename a few 'base' identifiers
+ 2020-11-24 357c576878 [dev.regabi] cmd/compile: clean up error API
+ 2020-11-24 5fd949e4bd [dev.regabi] cmd/compile: initialize importMap lazily
+ 2020-11-24 7b144ed4f7 [dev.regabi] cmd/compile: rewrite concurrentFlagOk to be clearer
+ 2020-11-24 c754f25241 [dev.regabi] cmd/compile/internal/types: remove Func.Nname
+ 2020-11-24 c50c7a8c06 [dev.regabi] cmd/compile/internal/gc: refactor to use stop using Func.Nname
+ 2020-11-24 d5928847de [dev.regabi] cmd/compile/internal/gc: prep for Func.Nname removal refactoring
+ 2020-11-24 b30c7a8044 [dev.regabi] cmd/compile/internal/gc: add MethodName for getting referenced method
+ 2020-11-24 e1047302bd [dev.regabi] cmd/compile/internal/types: add pos/sym/typ params to NewField

Change-Id: I9c6085171cb95684cc2c71879b915fa650c31dab

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index cebc92f53f8adcae9b5435a85e086b0e46109f0e..ccbe4627f38753b1b6d212e2aa65e81fb81e5fc7 100644 (file)
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -30,6 +30,7 @@ Aaron Bieber <deftly@gmail.com>
 Aaron Cannon <cannona@fireantproductions.com>
 Aaron France <aaron.l.france@gmail.com>
 Aaron Jacobs <jacobsa@google.com>
+Aaron Jensen <jensen.aaro@gmail.com>
 Aaron Kemp <kemp.aaron@gmail.com>
 Aaron Patterson <tenderlove@ruby-lang.org>
 Aaron Stein <aaronstein12@gmail.com>
@@ -71,9 +72,11 @@ Ahmet Alp Balkan <ahmetb@google.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
 Ahsun Ahmed <ahmed.ahsun@gmail.com>
+Aidan Coyle <packrat386@gmail.com>
 Aiden Scandella <ai@uber.com>
 Ainar Garipov <gugl.zadolbal@gmail.com>
 Aishraj Dahal <aishraj@users.noreply.github.com>
+Ajanthan Balachandran <balaajanthan@gmail.com>
 Akhil Indurti <aindurti@gmail.com>
 Akihiro Suda <suda.kyoto@gmail.com>
 Akshat Kumar <seed@mail.nanosouffle.net>
@@ -104,9 +107,11 @@ Alex Buchanan <buchanae@gmail.com>
 Alex Carol <alex.carol.c@gmail.com>
 Alex Gaynor <alex@alloy.us>
 Alex Harford <alex.harford@saucelabs.com>
+Alex Hays <alex.hays@leftfieldlabs.com>
 Alex Jin <toalexjin@gmail.com>
 Alex Kohler <alexjohnkohler@gmail.com>
 Alex Myasoedov <msoedov@gmail.com>
+Alex Opie <amtopie@gmail.com>
 Alex Plugaru <alex@plugaru.org> <alexandru.plugaru@gmail.com>
 Alex Schroeder <alex@gnu.org>
 Alex Sergeyev <abc@alexsergeyev.com>
@@ -119,6 +124,7 @@ Alexander F Rødseth <alexander.rodseth@appeartv.com>
 Alexander Greim <alexxx@iltempo.de>
 Alexander Guz <kalimatas@gmail.com>
 Alexander Kauer <alexander@affine.space>
+Alexander Klauer <Alexander.Klauer@googlemail.com>
 Alexander Kucherenko <alxkchr@gmail.com>
 Alexander Larsson <alexander.larsson@gmail.com>
 Alexander Lourier <aml@rulezz.ru>
@@ -150,16 +156,19 @@ Alexey Naidonov <alexey.naidyonov@gmail.com>
 Alexey Neganov <neganovalexey@gmail.com>
 Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
 Alexey Semenyuk <alexsemenyuk88@gmail.com>
+Alexey Vilenskiy <bynovhack@gmail.com>
 Alexis Hildebrandt <surryhill@gmail.com>
 Alexis Hunt <lexer@google.com>
 Alexis Imperial-Legrand <ail@google.com>
 Ali Farooq <ali.farooq0@pm.me>
 Ali Rizvi-Santiago <arizvisa@gmail.com>
 Aliaksandr Valialkin <valyala@gmail.com>
+Alice Merrick <amerrick@google.com>
 Alif Rachmawadi <subosito@gmail.com>
 Allan Simon <allan.simon@supinfo.com>
 Allen Li <ayatane@google.com>
 Alok Menghrajani <alok.menghrajani@gmail.com>
+Alwin Doss <alwindoss84@gmail.com>
 Aman Gupta <aman@tmm1.net>
 Amarjeet Anand <amarjeetanandsingh@gmail.com>
 Amir Mohammad Saied <amir@gluegadget.com>
@@ -168,6 +177,8 @@ Amrut Joshi <amrut.joshi@gmail.com>
 An Long <aisk1988@gmail.com>
 An Xiao <hac@zju.edu.cn>
 Anand K. Mistry <anand@mistry.ninja>
+Ananya Saxena <ananyasaxena1@gmail.com>
+Anatol Pomozov <anatol.pomozov@gmail.com>
 Anders Pearson <anders@columbia.edu>
 Anderson Queiroz <contato@andersonq.eti.br>
 André Carvalho <asantostc@gmail.com>
@@ -199,6 +210,7 @@ Andrew G. Morgan <agm@google.com>
 Andrew Gerrand <adg@golang.org>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Jackura <ajackura@google.com>
+Andrew Kemm <andrewkemm@gmail.com>
 Andrew Louis <alouis@digitalocean.com>
 Andrew Lutomirski <andy@luto.us>
 Andrew Medvedev <andrew.y.medvedev@gmail.com>
@@ -216,6 +228,7 @@ Andrew Werner <andrew@upthere.com> <awerner32@gmail.com>
 Andrew Wilkins <axwalk@gmail.com>
 Andrew Williams <williams.andrew@gmail.com>
 Andrew Z Allen <me@andrewzallen.com>
+Andrey Bokhanko <andreybokhanko@gmail.com>
 Andrey Mirtchovski <mirtchovski@gmail.com>
 Andrey Petrov <andrey.petrov@shazow.net>
 Andrii Soldatenko <andrii.soldatenko@gmail.com>
@@ -230,6 +243,7 @@ Andy Maloney <asmaloney@gmail.com>
 Andy Pan <panjf2000@gmail.com>
 Andy Walker <walkeraj@gmail.com>
 Andy Wang <cbeuw.andy@gmail.com>
+Andy Williams <andy@andy.xyz>
 Andzej Maciusovic <andzej.maciusovic@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -274,6 +288,7 @@ Arne Hormann <arnehormann@gmail.com>
 Arnout Engelen <arnout@bzzt.net>
 Aron Nopanen <aron.nopanen@gmail.com>
 Artem Alekseev <artem.alekseev@intel.com>
+Artem Khvastunov <artem.khvastunov@jetbrains.com>
 Artem Kolin <artemkaxboy@gmail.com>
 Arthur Fabre <arthur@arthurfabre.com>
 Arthur Khashaev <arthur@khashaev.ru>
@@ -281,8 +296,10 @@ Artyom Pervukhin <artyom.pervukhin@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
 Ashish Gandhi <ag@ashishgandhi.org>
 Asim Shankar <asimshankar@gmail.com>
+Assel Meher <asselmeher@gmail.com>
 Atin Malaviya <amalaviy@akamai.com>
 Ato Araki <ato.araki@gmail.com>
+Atsushi Toyama <atsushi.tohyama.160.333@gmail.com>
 Audrey Lim <audreylh@gmail.com>
 Audrius Butkevicius <audrius.butkevicius@gmail.com>
 Augusto Roman <aroman@gmail.com>
@@ -291,6 +308,7 @@ Aurélien Rainone <aurelien.rainone@gmail.com>
 Aurélio A. Heckert <aurium@gmail.com>
 Austin Clements <austin@google.com> <aclements@csail.mit.edu>
 Avi Flax <avi@timehop.com>
+Aviv Klasquin Komissar <avivklas@gmail.com>
 awaw fumin <awawfumin@gmail.com>
 Awn Umar <awn@cryptolosophy.io>
 Axel Wagner <axel.wagner.hh@googlemail.com>
@@ -298,6 +316,7 @@ Ayan George <ayan@ayan.net>
 Ayanamist Yang <ayanamist@gmail.com>
 Ayke van Laethem <aykevanlaethem@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
+Ayzat Sadykov <ayzat.ziko.93@gmail.com>
 Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
 Balaram Makam <bmakam.qdt@qualcommdatacenter.com>
@@ -308,10 +327,12 @@ Bartosz Grzybowski <melkorm@gmail.com>
 Bartosz Oler <brtsz@google.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
+Ben Cartwright-Cox <Ben@Benjojo.co.uk>
 Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
 Ben Haines <bhainesva@gmail.com>
 Ben Hoyt <benhoyt@gmail.com>
+Ben Kraft <benkraft@khanacademy.org>
 Ben Laurie <ben@links.org> <benl@google.com>
 Ben Lubar <ben.lubar@gmail.com>
 Ben Lynn <benlynn@gmail.com>
@@ -319,6 +340,7 @@ Ben Olive <sionide21@gmail.com>
 Ben Schwartz <bemasc@google.com>
 Ben Shi <powerman1st@163.com>
 Ben Toews <mastahyeti@gmail.com>
+Benjamin Barenblat <bbaren@google.com>
 Benjamin Black <b@b3k.us>
 Benjamin Cable <cable.benjamin@gmail.com>
 Benjamin Hsieh <tanookiben@users.noreply.github.com>
@@ -356,6 +378,7 @@ Bobby Powers <bobbypowers@gmail.com>
 Boqin Qin <bobbqqin@gmail.com>
 Boris Nagaev <nagaev@google.com>
 Borja Clemente <borja.clemente@gmail.com>
+Boshi Lian <bolian@microsoft.com>
 Brad Burch <brad.burch@gmail.com>
 Brad Erickson <bderickson@gmail.com>
 Brad Fitzpatrick <bradfitz@golang.org> <bradfitz@gmail.com>
@@ -368,10 +391,12 @@ Bradford Lamson-Scribner <brad.lamson@gmail.com>
 Bradley Falzon <brad@teambrad.net>
 Brady Catherman <brady@gmail.com>
 Brady Sullivan <brady@bsull.com>
+Branden J. Brown <zephyrtronium@gmail.com>
 Brandon Bennett <bbennett@fb.com>
 Brandon Gilmore <varz@google.com>
 Brandon Philips <brandon@ifup.org>
 Brandon Ryan <bjryan19@gmail.com>
+Brave Cow <rsr715@gmail.com>
 Brayden Cloud <bcloud@google.com>
 Brendan Daniel Tracey <tracey.brendan@gmail.com>
 Brendan O'Dea <bod@golang.org>
@@ -389,6 +414,7 @@ Brian Slesinsky <skybrian@google.com>
 Brian Smith <ohohvi@gmail.com>
 Brian Starke <brian.starke@gmail.com>
 Bryan Alexander <Kozical@msn.com>
+Bryan Boreham <bjboreham@gmail.com>
 Bryan C. Mills <bcmills@google.com>
 Bryan Chan <bryan.chan@ca.ibm.com>
 Bryan Ford <brynosaurus@gmail.com>
@@ -407,6 +433,7 @@ Carl Mastrangelo <notcarl@google.com>
 Carl Shapiro <cshapiro@google.com> <cshapiro@golang.org>
 Carlisia Campos <carlisia@grokkingtech.io>
 Carlo Alberto Ferraris <cafxx@strayorange.com>
+Carlos Alexandro Becker <caarlos0@gmail.com>
 Carlos Amedee <carlos@golang.org>
 Carlos Castillo <cookieo9@gmail.com>
 Carlos Cirello <uldericofilho@gmail.com>
@@ -422,6 +449,7 @@ Casey Callendrello <squeed@gmail.com>
 Casey Marshall <casey.marshall@gmail.com>
 Catalin Nicutar <cnicutar@google.com>
 Catalin Patulea <catalinp@google.com>
+Cathal O'Callaghan <cathalsocallaghan@gmail.com>
 Cedric Staub <cs@squareup.com>
 Cezar Sá Espinola <cezarsa@gmail.com>
 Chad Rosier <mrosier.qdt@qualcommdatacenter.com>
@@ -434,10 +462,14 @@ Charles Kenney <charlesc.kenney@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
 Charles Weill <weill@google.com>
+Charlotte Brandhorst-Satzkorn <catzkorn@gmail.com>
 Chauncy Cullitan <chauncyc@google.com>
+Chen Zhidong <njutczd@gmail.com>
 Chen Zhihan <energiehund@gmail.com>
 Cherry Zhang <cherryyz@google.com>
 Chew Choon Keat <choonkeat@gmail.com>
+Chiawen Chen <golopot@gmail.com>
+Chirag Sukhala <cchirag77@gmail.com>
 Cholerae Hu <choleraehyq@gmail.com>
 Chotepud Teo <AlexRouSg@users.noreply.github.com>
 Chris Ball <chris@printf.net>
@@ -460,6 +492,8 @@ Chris Raynor <raynor@google.com>
 Chris Roche <rodaine@gmail.com>
 Chris Smith <chrsmith@users.noreply.github.com>
 Chris Stockton <chrisstocktonaz@gmail.com>
+Chris Taylor <taylorza@gmail.com>
+Chris Waldon <christopher.waldon.dev@gmail.com>
 Chris Zou <chriszou@ca.ibm.com>
 Christian Alexander <christian@linux.com>
 Christian Couder <chriscool@tuxfamily.org>
@@ -467,6 +501,7 @@ Christian Himpel <chressie@googlemail.com> <chressie@gmail.com>
 Christian Muehlhaeuser <muesli@gmail.com>
 Christian Pellegrin <chri@evolware.org>
 Christian R. Petrin <christianpetrin@gmail.com>
+Christian Svensson <blue@cmd.nu>
 Christine Hansmann <chhansmann@gmail.com>
 Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Christoph Blecker <admin@toph.ca>
@@ -474,6 +509,7 @@ Christoph Hack <christoph@tux21b.org>
 Christopher Cahoon <chris.cahoon@gmail.com>
 Christopher Guiney <chris@guiney.net>
 Christopher Henderson <chris@chenderson.org>
+Christopher Hlubek <christopher.hlubek@networkteam.com>
 Christopher Koch <chrisko@google.com>
 Christopher Loessl <cloessl+github@gmail.com>
 Christopher Nelson <nadiasvertex@gmail.com>
@@ -506,7 +542,10 @@ Costin Chirvasuta <ctin@google.com>
 Craig Citro <craigcitro@google.com>
 Cristian Staretu <unclejacksons@gmail.com>
 Cuihtlauac ALVARADO <cuihtlauac.alvarado@orange.com>
+Cuong Manh Le <cuong@orijtech.com>
+Curtis La Graff <curtis@lagraff.me>
 Cyrill Schumacher <cyrill@schumacher.fm>
+Dai Jie <gzdaijie@gmail.com>
 Daisuke Fujita <dtanshi45@gmail.com>
 Daisuke Suzuki <daisuzu@gmail.com>
 Daker Fernandes Pinheiro <daker.fernandes.pinheiro@intel.com>
@@ -525,12 +564,14 @@ Dan Peterson <dpiddy@gmail.com>
 Dan Pupius <dan@medium.com>
 Dan Scales <danscales@google.com>
 Dan Sinclair <dan.sinclair@gmail.com>
+Daniel Cohen <dcohen@gatech.edu>
 Daniel Cormier <danielc@knowbe4.com>
 Daniël de Kok <me@danieldk.eu>
 Daniel Fleischman <danielfleischman@gmail.com>
 Daniel Ingram <ingramds@appstate.edu>
 Daniel Johansson <dajo2002@gmail.com>
 Daniel Kerwin <d.kerwin@gini.net>
+Daniel Kessler <dkess@google.com>
 Daniel Krech <eikeon@eikeon.com>
 Daniel Kumor <rdkumor@gmail.com>
 Daniel Langner <s8572327@gmail.com>
@@ -538,10 +579,12 @@ Daniel Lidén <daniel.liden.87@gmail.com>
 Daniel Lublin <daniel@lublin.se>
 Daniel Mangum <georgedanielmangum@gmail.com>
 Daniel Martí <mvdan@mvdan.cc>
+Daniel McCarney <cpu@letsencrypt.org>
 Daniel Morsing <daniel.morsing@gmail.com>
 Daniel Nadasi <dnadasi@google.com>
 Daniel Nephin <dnephin@gmail.com>
 Daniel Ortiz Pereira da Silva <daniel.particular@gmail.com>
+Daniel S. Fava <danielsfava@gmail.com>
 Daniel Skinner <daniel@dasa.cc>
 Daniel Speichert <daniel@speichert.pl>
 Daniel Theophanes <kardianos@gmail.com>
@@ -563,6 +606,7 @@ Dave Cheney <dave@cheney.net>
 Dave Day <djd@golang.org>
 Dave Grijalva <dgrijalva@ngmoco.com>
 Dave MacFarlane <driusan@gmail.com>
+Dave Pifke <dave@pifke.org>
 Dave Russell <forfuncsake@gmail.com>
 David Anderson <danderson@google.com>
 David Barnett <dbarnett@google.com>
@@ -593,6 +637,7 @@ David McLeish <davemc@google.com>
 David Ndungu <dnjuguna@gmail.com>
 David NewHamlet <david@newhamlet.com>
 David Presotto <presotto@gmail.com>
+David Qu <davidqu12345@gmail.com>
 David R. Jenni <david.r.jenni@gmail.com>
 David Sansome <me@davidsansome.com>
 David Stainton <dstainton415@gmail.com>
@@ -642,6 +687,7 @@ Diwaker Gupta <diwakergupta@gmail.com>
 Dmitri Goutnik <dgoutnik@gmail.com>
 Dmitri Popov <operator@cv.dp-net.com>
 Dmitri Shuralyov <dmitshur@golang.org> <dmitri@shuralyov.com>
+Dmitrii Okunev <xaionaro@gmail.com>
 Dmitriy Cherchenko <dcherchenko@gmail.com>
 Dmitriy Dudkin <dudkin.dmitriy@gmail.com>
 Dmitriy Shelenin <deemok@googlemail.com> <deemok@gmail.com>
@@ -655,6 +701,7 @@ Dmitry Yakunin <nonamezeil@gmail.com>
 Doga Fincan <doga@icloud.com>
 Domas Tamašauskas <puerdomus@gmail.com>
 Domen Ipavec <domen@ipavec.net>
+Dominic Della Valle <ddvpublic@Gmail.com>
 Dominic Green <dominicgreen1@gmail.com>
 Dominik Honnef <dominik.honnef@gmail.com>
 Dominik Vogt <vogt@linux.vnet.ibm.com>
@@ -696,6 +743,7 @@ Elias Naur <mail@eliasnaur.com> <elias.naur@gmail.com>
 Elliot Morrison-Reed <elliotmr@gmail.com>
 Ellison Leão <ellisonleao@gmail.com>
 Emerson Lin <linyintor@gmail.com>
+Emil Bektimirov <lefelys@gmail.com>
 Emil Hessman <emil@hessman.se>
 Emil Mursalimov <mursalimovemeel@gmail.com>
 Emilien Kenler <hello@emilienkenler.com>
@@ -760,6 +808,7 @@ Fatih Arslan <fatih@arslan.io>
 Fazal Majid <majid@apsalar.com>
 Fazlul Shahriar <fshahriar@gmail.com>
 Federico Bond <federicobond@gmail.com>
+Federico Guerinoni <guerinoni.federico@gmail.com>
 Federico Simoncelli <fsimonce@redhat.com>
 Fedor Indutny <fedor@indutny.com>
 Fedor Korotkiy <dartslon@gmail.com>
@@ -781,6 +830,7 @@ Florin Patan <florinpatan@gmail.com>
 Folke Behrens <folke@google.com>
 Ford Hurley <ford.hurley@gmail.com>
 Francesc Campoy <campoy@golang.org>
+Francesco Guardiani <francescoguard@gmail.com>
 Francesco Renzi <rentziass@gmail.com>
 Francisco Claude <fclaude@recoded.cl>
 Francisco Rojas <francisco.rojas.gallegos@gmail.com>
@@ -811,8 +861,10 @@ Gabriel Russell <gabriel.russell@gmail.com>
 Gareth Paul Jones <gpj@foursquare.com>
 Garret Kelly <gdk@google.com>
 Garrick Evans <garrick@google.com>
+Garry McNulty <garrmcnu@gmail.com>
 Gary Burd <gary@beagledreams.com> <gary.burd@gmail.com>
 Gary Elliott <garyelliott@google.com>
+Gaurav Singh <gaurav1086@gmail.com>
 Gaurish Sharma <contact@gaurishsharma.com>
 Gautham Thambidorai <gautham.dorai@gmail.com>
 Gauthier Jolly <gauthier.jolly@gmail.com>
@@ -827,6 +879,7 @@ Georg Reinke <guelfey@gmail.com>
 George Gkirtsou <ggirtsou@gmail.com>
 George Hartzell <hartzell@alerce.com>
 George Shammas <george@shamm.as> <georgyo@gmail.com>
+George Tsilias <tsiliasg@gmail.com>
 Gerasimos (Makis) Maropoulos <kataras2006@hotmail.com>
 Gerasimos Dimitriadis <gedimitr@gmail.com>
 Gergely Brautigam <skarlso777@gmail.com>
@@ -862,6 +915,7 @@ GitHub User @frennkie (6499251) <mail@rhab.de>
 GitHub User @geedchin (11672310) <geedchin@gmail.com>
 GitHub User @GrigoriyMikhalkin (3637857) <grigoriymikhalkin@gmail.com>
 GitHub User @hengwu0 (41297446) <41297446+hengwu0@users.noreply.github.com>
+GitHub User @hitzhangjie (3725760) <hit.zhangjie@gmail.com>
 GitHub User @itchyny (375258) <itchyny@hatena.ne.jp>
 GitHub User @jinmiaoluo (39730824) <jinmiaoluo@icloud.com>
 GitHub User @jopbrown (6345470) <msshane2008@gmail.com>
@@ -873,6 +927,7 @@ GitHub User @LotusFenn (13775899) <fenn.lotus@gmail.com>
 GitHub User @ly303550688 (11519839) <yang.liu636@gmail.com>
 GitHub User @madiganz (18340029) <zacharywmadigan@gmail.com>
 GitHub User @maltalex (10195391) <code@bit48.net>
+GitHub User @markruler (38225900) <csu0414@gmail.com>
 GitHub User @Matts966 (28551465) <Matts966@users.noreply.github.com>
 GitHub User @micnncim (21333876) <micnncim@gmail.com>
 GitHub User @mkishere (224617) <224617+mkishere@users.noreply.github.com>
@@ -886,6 +941,8 @@ GitHub User @ramenjuniti (32011829) <ramenjuniti@gmail.com>
 GitHub User @saitarunreddy (21041941) <saitarunreddypalla@gmail.com>
 GitHub User @shogo-ma (9860598) <Choroma194@gmail.com>
 GitHub User @skanehira (7888591) <sho19921005@gmail.com>
+GitHub User @soolaugust (10558124) <soolaugust@gmail.com>
+GitHub User @surechen (7249331) <surechen17@gmail.com>
 GitHub User @tatsumack (4510569) <tatsu.mack@gmail.com>
 GitHub User @tell-k (26263) <ffk2005@gmail.com>
 GitHub User @tennashi (10219626) <tennashio@gmail.com>
@@ -908,6 +965,7 @@ Gordon Tyler <gordon@doxxx.net>
 Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Grant Griffiths <ggp493@gmail.com>
+Green Lightning <GreenLightning.git@googlemail.com>
 Greg Poirier <greg.istehbest@gmail.com>
 Greg Steuck <gnezdo+github@google.com>
 Greg Thelen <gthelen@google.com>
@@ -920,6 +978,7 @@ Guilherme Garnier <guilherme.garnier@gmail.com>
 Guilherme Goncalves <guilhermeaugustosg@gmail.com>
 Guilherme Rezende <guilhermebr@gmail.com>
 Guillaume J. Charmes <guillaume@charmes.net>
+Guillaume Sottas <guillaumesottas@gmail.com>
 Günther Noack <gnoack@google.com>
 Guobiao Mei <meiguobiao@gmail.com>
 Guoliang Wang <iamwgliang@gmail.com>
@@ -936,6 +995,8 @@ HAMANO Tsukasa <hamano@osstech.co.jp>
 Han-Wen Nienhuys <hanwen@google.com>
 Hang Qian <hangqian90@gmail.com>
 Hanjun Kim <hallazzang@gmail.com>
+Hanlin Shi <shihanlin9@gmail.com>
+Haoran Luo <haoran.luo@chaitin.com>
 Haosdent Huang <haosdent@gmail.com>
 Harald Nordgren <haraldnordgren@gmail.com>
 Hari haran <hariharan.uno@gmail.com>
@@ -950,9 +1011,11 @@ Håvard Haugen <havard.haugen@gmail.com>
 He Liu <liulonnie@gmail.com>
 Hector Chu <hectorchu@gmail.com>
 Hector Martin Cantero <hector@marcansoft.com>
+Hein Khant Zaw <heinkhantzaw1@gmail.com>
 Henning Schmiedehausen <henning@schmiedehausen.org>
 Henrik Edwards <henrik.edwards@gmail.com>
 Henrik Hodne <henrik@hodne.io>
+Henrique Vicente <henriquevicente@gmail.com>
 Henry Adi Sumarto <henry.adisumarto@gmail.com>
 Henry Bubert <google@mindeco.de>
 Henry Chang <mr.changyuheng@gmail.com>
@@ -969,6 +1032,7 @@ Hironao OTSUBO <motemen@gmail.com>
 Hiroshi Ioka <hirochachacha@gmail.com>
 Hitoshi Mitake <mitake.hitoshi@gmail.com>
 Holden Huang <ttyh061@gmail.com>
+Songlin Jiang <hollowman@hollowman.ml>
 Hong Ruiqi <hongruiqi@gmail.com>
 Hongfei Tan <feilengcui008@gmail.com>
 Horacio Duran <horacio.duran@gmail.com>
@@ -990,6 +1054,7 @@ Ian Haken <ihaken@netflix.com>
 Ian Kent <iankent85@gmail.com>
 Ian Lance Taylor <iant@golang.org>
 Ian Leue <ian@appboy.com>
+Ian Tay <iantay@google.com>
 Ian Zapolsky <ianzapolsky@gmail.com>
 Ibrahim AshShohail <ibra.sho@gmail.com>
 Icarus Sparry <golang@icarus.freeuk.com>
@@ -997,9 +1062,11 @@ Iccha Sethi <icchasethi@gmail.com>
 Idora Shinatose <idora.shinatose@gmail.com>
 Ignacio Hagopian <jsign.uy@gmail.com>
 Igor Bernstein <igorbernstein@google.com>
+Igor Bolotnikov <igor.v.bolotnikov@gmail.com>
 Igor Dolzhikov <bluesriverz@gmail.com>
 Igor Vashyst <ivashyst@gmail.com>
 Igor Zhilianin <igor.zhilianin@gmail.com>
+Ikko Ashimine <eltociear@gmail.com>
 Illya Yalovyy <yalovoy@gmail.com>
 Ilya Sinelnikov <sidhmangh@gmail.com>
 Ilya Tocar <ilya.tocar@intel.com>
@@ -1037,6 +1104,7 @@ Jacob Blain Christen <dweomer5@gmail.com>
 Jacob H. Haven <jacob@cloudflare.com>
 Jacob Hoffman-Andrews <github@hoffman-andrews.com>
 Jacob Walker <jacobwalker0814@gmail.com>
+Jaden Teng <long.asyn@gmail.com>
 Jae Kwon <jae@tendermint.com>
 Jake B <doogie1012@gmail.com>
 Jakob Borg <jakob@nym.se>
@@ -1044,6 +1112,7 @@ Jakob Weisblat <jakobw@mit.edu>
 Jakub Čajka <jcajka@redhat.com>
 Jakub Kaczmarzyk <jakubk@mit.edu>
 Jakub Ryszard Czarnowicz <j.czarnowicz@gmail.com>
+Jakub Warczarek <jakub.warczarek@gmail.com>
 Jamal Carvalho <jamal.a.carvalho@gmail.com>
 James Aguilar <jaguilar@google.com>
 James Bardin <j.bardin@gmail.com>
@@ -1056,9 +1125,11 @@ James Eady <jmeady@google.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Hartig <fastest963@gmail.com>
+James Kasten <jdkasten@google.com>
 James Lawrence <jljatone@gmail.com>
 James Meneghello <rawrz0r@gmail.com>
 James Myers <jfmyers9@gmail.com>
+James Naftel <james.naftel@gmail.com>
 James Neve <jamesoneve@gmail.com>
 James Nugent <james@jen20.com>
 James P. Cooper <jamespcooper@gmail.com>
@@ -1108,6 +1179,7 @@ Javier Kohen <jkohen@google.com>
 Javier Revillas <jrevillas@massivedynamic.io>
 Javier Segura <javism@gmail.com>
 Jay Conrod <jayconrod@google.com>
+Jay Lee <BusyJayLee@gmail.com>
 Jay Taylor <outtatime@gmail.com>
 Jay Weisskopf <jay@jayschwa.net>
 Jean de Klerk <deklerk@google.com>
@@ -1140,14 +1212,17 @@ Jeremy Jay <jeremy@pbnjay.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jeroen Simonetti <jeroen@simonetti.nl>
+Jérôme Doucet <jerdct@gmail.com>
 Jerrin Shaji George <jerrinsg@gmail.com>
 Jess Frazelle <me@jessfraz.com>
 Jesse Szwedko <jesse.szwedko@gmail.com>
 Jesús Espino <jespinog@gmail.com>
 Jia Zhan <jzhan@uber.com>
 Jiacai Liu <jiacai2050@gmail.com>
+Jiahao Lu <lujjjh@gmail.com>
 Jianing Yu <jnyu@google.com>
 Jianqiao Li <jianqiaoli@google.com>
+Jiayu Yi <yijiayu@gmail.com>
 Jie Ma <jienius@outlook.com>
 Jihyun Yu <yjh0502@gmail.com>
 Jim Cote <jfcote87@gmail.com>
@@ -1183,6 +1258,7 @@ Joey Geiger <jgeiger@users.noreply.github.com>
 Johan Brandhorst <johan.brandhorst@gmail.com>
 Johan Euphrosine <proppy@google.com>
 Johan Jansson <johan.jansson@iki.fi>
+Johan Knutzen <johan@senri.se>
 Johan Sageryd <j@1616.se>
 John Asmuth <jasmuth@gmail.com>
 John Beisley <huin@google.com>
@@ -1210,6 +1286,7 @@ Johnny Luo <johnnyluo1980@gmail.com>
 Jon Chen <jchen@justin.tv>
 Jon Johnson <jonjohnson@google.com>
 Jonas Bernoulli <jonas@bernoul.li>
+Jonathan Albrecht <jonathan.albrecht@ibm.com>
 Jonathan Allie <jonallie@google.com>
 Jonathan Amsterdam <jba@google.com>
 Jonathan Boulle <jonathanboulle@gmail.com>
@@ -1223,6 +1300,7 @@ Jonathan Pentecost <pentecostjonathan@gmail.com>
 Jonathan Pittman <jmpittman@google.com> <jonathan.mark.pittman@gmail.com>
 Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Stacks <jonstacks13@gmail.com>
+Jonathan Swinney <jswinney@amazon.com>
 Jonathan Wills <runningwild@gmail.com>
 Jonathon Lacher <jonathon.lacher@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
@@ -1233,6 +1311,7 @@ Jordan Krage <jmank88@gmail.com>
 Jordan Lewis <jordanthelewis@gmail.com>
 Jordan Liggitt <liggitt@google.com>
 Jordan Rhee <jordanrh@microsoft.com>
+Jordan Rupprecht <rupprecht@google.com>
 Jordi Martin <jordimartin@gmail.com>
 Jorge Araya <jorgejavieran@yahoo.com.mx>
 Jorge L. Fatta <jorge.fatta@auth0.com>
@@ -1276,6 +1355,7 @@ Julien Salleyron <julien.salleyron@gmail.com>
 Julien Schmidt <google@julienschmidt.com>
 Julio Montes <julio.montes@intel.com>
 Jun Zhang <jim.zoumo@gmail.com>
+Junchen Li <junchen.li@arm.com>
 Junda Liu <junda@celer.network>
 Jungho Ahn <jhahn@google.com>
 Junya Hayashi <ledmonster@gmail.com>
@@ -1287,6 +1367,7 @@ Justin Nuß <nuss.justin@gmail.com>
 Justyn Temme <justyntemme@gmail.com>
 Kai Backman <kaib@golang.org>
 Kai Dong <dokia2357@gmail.com>
+Kai Lüke <kai@kinvolk.io>
 Kai Trukenmüller <ktye78@gmail.com>
 Kale Blankenship <kale@lemnisys.com>
 Kaleb Elwert <kelwert@atlassian.com>
@@ -1314,6 +1395,7 @@ Kazuhiro Sera <seratch@gmail.com>
 KB Sriram <kbsriram@google.com>
 Keegan Carruthers-Smith <keegan.csmith@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
+Keiichi Hirobe <chalenge.akane@gmail.com>
 Keiji Yoshida <keijiyoshida.mail@gmail.com>
 Keisuke Kishimoto <keisuke.kishimoto@gmail.com>
 Keith Ball <inflatablewoman@gmail.com>
@@ -1322,6 +1404,7 @@ Keith Rarick <kr@xph.us>
 Kelly Heller <pestophagous@gmail.com>
 Kelsey Hightower <kelsey.hightower@gmail.com>
 Kelvin Foo Chuan Lyi <vmirage@gmail.com>
+Kemal Elmizan <kemalelmizan@gmail.com>
 Ken Friedenbach <kenliz@cruzio.com>
 Ken Rockot <ken@oz.gs> <ken.rockot@gmail.com>
 Ken Sedgwick <ken@bonsai.com>
@@ -1331,6 +1414,7 @@ Kenji Kaneda <kenji.kaneda@gmail.com>
 Kenji Yano <kenji.yano@gmail.com>
 Kenneth Shaw <kenshaw@gmail.com>
 Kenny Grant <kennygrant@gmail.com>
+Kensei Nakada <handbomusic@gmail.com>
 Kenta Mori <zoncoen@gmail.com>
 Kerollos Magdy <kerolloz@yahoo.com>
 Ketan Parmar <ketanbparmar@gmail.com>
@@ -1342,10 +1426,12 @@ Kevin Gillette <extemporalgenome@gmail.com>
 Kevin Kirsche <kev.kirsche@gmail.com>
 Kevin Klues <klueska@gmail.com> <klueska@google.com>
 Kevin Malachowski <chowski@google.com>
+Kevin Parsons <kevpar@microsoft.com>
 Kevin Ruffin <kruffin@gmail.com>
 Kevin Vu <kevin.m.vu@gmail.com>
 Kevin Zita <bleedgreenandgold@gmail.com>
 Keyan Pishdadian <kpishdadian@gmail.com>
+Keyuan Li <keyuanli123@gmail.com>
 Kezhu Wang <kezhuw@gmail.com>
 Khosrow Moossavi <khos2ow@gmail.com>
 Kieran Colford <kieran@kcolford.com>
@@ -1358,6 +1444,7 @@ Kirill Smelkov <kirr@nexedi.com>
 Kirill Tatchihin <kirabsuir@gmail.com>
 Kirk Han <kirk91.han@gmail.com>
 Kirklin McDonald <kirklin.mcdonald@gmail.com>
+KJ Tsanaktsidis <ktsanaktsidis@zendesk.com>
 Klaus Post <klauspost@gmail.com>
 Kodie Goodwin <kodiegoodwin@gmail.com>
 Koichi Shiraishi <zchee.io@gmail.com>
@@ -1371,6 +1458,7 @@ Kris Kwiatkowski <kris@cloudflare.com>
 Kris Nova <kris@nivenly.com>
 Kris Rousey <krousey@google.com>
 Kristopher Watts <traetox@gmail.com>
+Krzysztof Dąbrowski <krzysdabro@live.com>
 Kshitij Saraogi <kshitijsaraogi@gmail.com>
 Kun Li <likunarmstrong@gmail.com>
 Kunpei Sakai <namusyaka@gmail.com>
@@ -1412,8 +1500,10 @@ Leonardo Comelli <leonardo.comelli@gmail.com>
 Leonel Quinteros <leonel.quinteros@gmail.com>
 Lev Shamardin <shamardin@gmail.com>
 Lewin Bormann <lewin.bormann@gmail.com>
+Lewis Waddicor <nemesismk2@gmail.com>
 Liam Haworth <liam@haworth.id.au>
 Lily Chung <lilithkchung@gmail.com>
+Lingchao Xin <douglarek@gmail.com>
 Lion Yang <lion@aosc.xyz>
 Liz Rice <liz@lizrice.com>
 Lloyd Dewolf <foolswisdom@gmail.com>
@@ -1427,6 +1517,7 @@ Luan Santos <cfcluan@gmail.com>
 Lubomir I. Ivanov <neolit123@gmail.com>
 Luca Bruno <luca.bruno@coreos.com>
 Luca Greco <luca.greco@alcacoop.it>
+Luca Spiller <luca@stackednotion.com>
 Lucas Bremgartner <lucas.bremgartner@gmail.com>
 Lucas Clemente <lclemente@google.com>
 Lucien Stuker <lucien.stuker@gmail.com>
@@ -1450,6 +1541,8 @@ Maarten Bezemer <maarten.bezemer@gmail.com>
 Maciej Dębski <maciejd@google.com>
 Madhu Rajanna <madhupr007@gmail.com>
 Magnus Hiie <magnus.hiie@gmail.com>
+Mahdi Hosseini Moghaddam <seyed.mahdi.hosseini.moghaddam@ibm.com>
+Maia Lee <maia.lee@leftfieldlabs.com>
 Maicon Costa <maiconscosta@gmail.com>
 Mak Kolybabi <mak@kolybabi.com>
 Maksym Trykur <maksym.trykur@gmail.com>
@@ -1470,6 +1563,7 @@ Marcel Edmund Franke <marcel.edmund.franke@gmail.com>
 Marcel van Lohuizen <mpvl@golang.org>
 Marcelo Cantos <marcelo.cantos@gmail.com>
 Marcelo E. Magallon <marcelo.magallon@gmail.com>
+Marco Gazerro <gazerro@open2b.com>
 Marco Hennings <marco.hennings@freiheit.com>
 Marcus Weiner <marcus.weiner@gmail.com>
 Marcus Willock <crazcalm@gmail.com>
@@ -1481,6 +1575,7 @@ Marius A. Eriksen <marius@grailbio.com>
 Marius Nuennerich <mnu@google.com>
 Mark Adams <mark@markadams.me>
 Mark Bucciarelli <mkbucc@gmail.com>
+Mark Dain <mark@markdain.net>
 Mark Glines <mark@glines.org>
 Mark Harrison <marhar@google.com>
 Mark Percival <m@mdp.im>
@@ -1533,6 +1628,7 @@ Máté Gulyás <mgulyas86@gmail.com>
 Matej Baćo <matejbaco@gmail.com>
 Mateus Amin <mateus.amin@gmail.com>
 Mateusz Czapliński <czapkofan@gmail.com>
+Matheus Alcantara <matheusssilv97@gmail.com>
 Mathias Beke <git@denbeke.be>
 Mathias Hall-Andersen <mathias@hall-andersen.dk>
 Mathias Leppich <mleppich@muhqu.de>
@@ -1566,6 +1662,7 @@ Matthew Waters <mwwaters@gmail.com>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
 Matthieu Olivier <olivier.matthieu@gmail.com>
 Matthijs Kooijman <matthijs@stdin.nl>
+Max Drosdo.www <g1ran1q@gmail.com>
 Max Riveiro <kavu13@gmail.com>
 Max Schmitt <max@schmitt.mx>
 Max Semenik <maxsem.wiki@gmail.com>
@@ -1603,6 +1700,7 @@ Michael Hudson-Doyle <michael.hudson@linaro.org>
 Michael Kasch <michael.kasch@gmail.com>
 Michael Käufl <golang@c.michael-kaeufl.de>
 Michael Kelly <mjk@google.com>
+Michaël Lévesque-Dion <mlevesquedion@google.com>
 Michael Lewis <mikelikespie@gmail.com>
 Michael MacInnis <Michael.P.MacInnis@gmail.com>
 Michael Marineau <michael.marineau@coreos.com>
@@ -1624,6 +1722,7 @@ Michael Teichgräber <mteichgraeber@gmx.de> <mt4swm@googlemail.com>
 Michael Traver <mtraver@google.com>
 Michael Vetter <g.bluehut@gmail.com>
 Michael Vogt <mvo@ubuntu.com>
+Michail Kargakis <mkargaki@redhat.com>
 Michal Bohuslávek <mbohuslavek@gmail.com>
 Michal Cierniak <cierniak@google.com>
 Michał Derkacz <ziutek@lnet.pl>
@@ -1633,6 +1732,7 @@ Michal Pristas <michal.pristas@gmail.com>
 Michal Rostecki <mrostecki@suse.de>
 Michalis Kargakis <michaliskargakis@gmail.com>
 Michel Lespinasse <walken@google.com>
+Michele Di Pede <michele.di.pede@gmail.com>
 Mickael Kerjean <mickael.kerjean@gmail.com>
 Mickey Reiss <mickeyreiss@gmail.com>
 Miek Gieben <miek@miek.nl> <remigius.gieben@gmail.com>
@@ -1670,6 +1770,7 @@ Miquel Sabaté Solà <mikisabate@gmail.com>
 Mirko Hansen <baaazen@gmail.com>
 Miroslav Genov <mgenov@gmail.com>
 Misty De Meo <mistydemeo@gmail.com>
+Mohamed Attahri <mohamed@attahri.com>
 Mohit Agarwal <mohit@sdf.org>
 Mohit kumar Bajoria <mohitbajo36@gmail.com>
 Mohit Verma <vmohit.93@gmail.com>
@@ -1683,6 +1784,7 @@ Môshe van der Sterre <moshevds@gmail.com>
 Mostyn Bramley-Moore <mostyn@antipode.se>
 Mrunal Patel <mrunalp@gmail.com>
 Muhammad Falak R Wani <falakreyaz@gmail.com>
+Muhammad Hamza Farrukh <hamzafarrukh141@gmail.com>
 Muhammed Uluyol <uluyol0@gmail.com>
 Muir Manders <muir@mnd.rs>
 Mukesh Sharma <sharma.mukesh439@gmail.com>
@@ -1692,6 +1794,7 @@ Naman Aggarwal <aggarwal.nam@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nao Yonashiro <owan.orisano@gmail.com>
 Naoki Kanatani <k12naoki@gmail.com>
+Natanael Copa <ncopa@mirantis.com>
 Nate Wilkinson <nathanwilk7@gmail.com>
 Nathan Cantelmo <n.cantelmo@gmail.com>
 Nathan Caza <mastercactapus@gmail.com>
@@ -1708,6 +1811,7 @@ Nathaniel Cook <nvcook42@gmail.com>
 Naveen Kumar Sangi <naveenkumarsangi@protonmail.com>
 Neeilan Selvalingam <neeilan96@gmail.com>
 Neelesh Chandola <neelesh.c98@gmail.com>
+Nehal J Wani <nehaljw.kkd1@gmail.com>
 Neil Lyons <nwjlyons@googlemail.com>
 Neuman Vong <neuman.vong@gmail.com>
 Neven Sajko <nsajko@gmail.com>
@@ -1760,6 +1864,7 @@ Noel Georgi <git@frezbo.com>
 Norberto Lopes <nlopes.ml@gmail.com>
 Norman B. Lancaster <qbradq@gmail.com>
 Nuno Cruces <ncruces@users.noreply.github.com>
+Obei Sideg <obei.sideg@gmail.com>
 Obeyda Djeffal <djefobey@gmail.com>
 Odin Ugedal <odin@ugedal.com>
 Oleg Bulatov <dmage@yandex-team.ru>
@@ -1769,12 +1874,17 @@ Oling Cat <olingcat@gmail.com>
 Oliver Hookins <ohookins@gmail.com>
 Oliver Powell <oliverpowell84@gmail.com>
 Oliver Stenbom <ostenbom@pivotal.io>
+Oliver Tan <otan@cockroachlabs.com>
 Oliver Tonnhofer <olt@bogosoft.com>
 Olivier Antoine <olivier.antoine@gmail.com>
 Olivier Duperray <duperray.olivier@gmail.com>
 Olivier Poitrey <rs@dailymotion.com>
 Olivier Saingre <osaingre@gmail.com>
+Olivier Wulveryck <olivier.wulveryck@gmail.com>
 Omar Jarjur <ojarjur@google.com>
+Onkar Jadhav <omjadhav2610@gmail.com>
+Ori Bernstein <ori@eigenstate.org>
+Ori Rawlings <orirawlings@gmail.com>
 Oryan Moshe <iamoryanmoshe@gmail.com>
 Osamu TONOMORI <osamingo@gmail.com>
 Özgür Kesim <oec-go@kesim.org>
@@ -1798,7 +1908,9 @@ Pat Moroney <pat@pat.email>
 Patrick Barker <barkerp@vmware.com>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
+Patrick Gundlach <gundlach@speedata.de>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
+Patrick Jones <ithuriel@google.com>
 Patrick Lee <pattyshack101@gmail.com>
 Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
@@ -1811,6 +1923,9 @@ Paul Borman <borman@google.com>
 Paul Boyd <boyd.paul2@gmail.com>
 Paul Chang <paulchang@google.com>
 Paul D. Weber <x0bdev@gmail.com>
+Paul Davis <43160081+Pawls@users.noreply.github.com>
+Paul E. Murphy <murp@ibm.com>
+Paul Forgey <paulf@tessier-ashpool.net>
 Paul Hammond <paul@paulhammond.org>
 Paul Hankin <paulhankin@google.com>
 Paul Jolly <paul@myitcv.org.uk>
@@ -1836,7 +1951,9 @@ Pavel Zinovkin <pavel.zinovkin@gmail.com>
 Pavlo Sumkin <ymkins@gmail.com>
 Pawel Knap <pawelknap88@gmail.com>
 Pawel Szczur <filemon@google.com>
+Paweł Szulik <pawel.szulik@intel.com>
 Pei Xian Chee <luciolas1991@gmail.com>
+Pei-Ming Wu <p408865@gmail.com>
 Percy Wegmann <ox.to.a.cart@gmail.com>
 Perry Abbott <perry.j.abbott@gmail.com>
 Petar Dambovaliev <petar.atanasov.1987@gmail.com>
@@ -1876,6 +1993,7 @@ Philip Hofer <phofer@umich.edu>
 Philip K. Warren <pkwarren@gmail.com>
 Philip Nelson <me@pnelson.ca>
 Philipp Stephani <phst@google.com>
+Phillip Campbell <15082+phillc@users.noreply.github.com>
 Pierre Carru <pierre.carru@eshard.com>
 Pierre Durand <pierredurand@gmail.com>
 Pierre Prinetti <pierreprinetti@gmail.com>
@@ -1885,6 +2003,7 @@ Pieter Droogendijk <pieter@binky.org.uk>
 Pietro Gagliardi <pietro10@mac.com>
 Piyush Mishra <piyush@codeitout.com>
 Plekhanov Maxim <kishtatix@gmail.com>
+Poh Zi How <poh.zihow@gmail.com>
 Polina Osadcha <polliosa@google.com>
 Pontus Leitzler <leitzler@gmail.com>
 Povilas Versockas <p.versockas@gmail.com>
@@ -1904,14 +2023,17 @@ Quentin Perez <qperez@ocs.online.net>
 Quentin Renard <contact@asticode.com>
 Quentin Smith <quentin@golang.org>
 Quey-Liang Kao <s101062801@m101.nthu.edu.tw>
+Quim Muntal <quimmuntal@gmail.com>
 Quinn Slack <sqs@sourcegraph.com>
 Quinten Yearsley <qyearsley@chromium.org>
 Quoc-Viet Nguyen <afelion@gmail.com>
+Radek Simko <radek.simko@gmail.com>
 Radek Sohlich <sohlich@gmail.com>
 Radu Berinde <radu@cockroachlabs.com>
 Rafal Jeczalik <rjeczalik@gmail.com>
 Raghavendra Nagaraj <jamdagni86@gmail.com>
 Rahul Chaudhry <rahulchaudhry@chromium.org>
+Rahul Wadhwani <rahulwadhwani21@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
 Rajat Goel <rajat.goel2010@gmail.com>
 Rajath Agasthya <rajathagasthya@gmail.com>
@@ -1935,6 +2057,7 @@ Ren Ogaki <re.yuz77777@gmail.com>
 Rens Rikkerink <Ikkerens@users.noreply.github.com>
 Rhys Hiltner <rhys@justin.tv>
 Ricardo Padilha <ricardospadilha@gmail.com>
+Ricardo Pchevuzinske Katz <ricardo.katz@serpro.gov.br>
 Ricardo Seriani <ricardo.seriani@gmail.com>
 Richard Barnes <rlb@ipv.sx>
 Richard Crowley <r@rcrowley.org>
@@ -1991,6 +2114,7 @@ Roman Kollár <roman.kollar.0@gmail.com>
 Roman Shchekin <mrqtros@gmail.com>
 Ron Hashimoto <mail@h2so5.net>
 Ron Minnich <rminnich@gmail.com>
+Ronnie Ebrin <ebrin.ronnie@protonmail.com>
 Ross Chater <rdchater@gmail.com>
 Ross Kinsey <rossikinsey@gmail.com>
 Ross Light <light@google.com> <rlight2@gmail.com>
@@ -2010,6 +2134,7 @@ Ryan Brown <ribrdb@google.com>
 Ryan Canty <jrcanty@gmail.com>
 Ryan Dahl <ry@tinyclouds.org>
 Ryan Hitchman <hitchmanr@gmail.com>
+Ryan Kohler <ryankohler@google.com>
 Ryan Lower <rpjlower@gmail.com>
 Ryan Roden-Corrent <ryan@rcorre.net>
 Ryan Seys <ryan@ryanseys.com>
@@ -2023,7 +2148,9 @@ S.Çağlar Onur <caglar@10ur.org>
 Sabin Mihai Rapan <sabin.rapan@gmail.com>
 Sad Pencil <qh06@qq.com>
 Sai Cheemalapati <saicheems@google.com>
+Sai Kiran Dasika <kirandasika30@gmail.com>
 Sakeven Jiang <jc5930@sina.cn>
+Salaheddin M. Mahmud <salah.mahmud@gmail.com>
 Salmān Aljammāz <s@0x65.net>
 Sam Arnold <sarnold64@bloomberg.net>
 Sam Boyer <tech@samboyer.org>
@@ -2033,6 +2160,7 @@ Sam Ding <samding@ca.ibm.com>
 Sam Hug <samuel.b.hug@gmail.com>
 Sam Thorogood <thorogood@google.com> <sam.thorogood@gmail.com>
 Sam Whited <sam@samwhited.com>
+Sam Xie <xsambundy@gmail.com>
 Sameer Ajmani <sameer@golang.org> <ajmani@gmail.com>
 Sami Commerot <samic@google.com>
 Sami Pönkänen <sami.ponkanen@gmail.com>
@@ -2042,6 +2170,7 @@ Samuele Pedroni <pedronis@lucediurna.net>
 Sander van Harmelen <sander@vanharmelen.nl>
 Sanjay Menakuru <balasanjay@gmail.com>
 Santhosh Kumar Tekuri <santhosh.tekuri@gmail.com>
+Santiago De la Cruz <51337247+xhit@users.noreply.github.com>
 Sarah Adams <shadams@google.com>
 Sardorbek Pulatov <sardorbek.pulatov@outlook.com>
 Sascha Brawer <sascha@brawer.ch>
@@ -2062,6 +2191,7 @@ Sean Chittenden <seanc@joyent.com>
 Sean Christopherson <sean.j.christopherson@intel.com>
 Sean Dolphin <Sean.Dolphin@kpcompass.com>
 Sean Harger <sharger@google.com>
+Sean Hildebrand <seanwhildebrand@gmail.com>
 Sean Liao <seankhliao@gmail.com>
 Sean Rees <sean@erifax.org>
 Sebastiaan van Stijn <github@gone.nl>
@@ -2094,10 +2224,12 @@ Serhii Aheienko <serhii.aheienko@gmail.com>
 Seth Hoenig <seth.a.hoenig@gmail.com>
 Seth Vargo <sethvargo@gmail.com>
 Shahar Kohanim <skohanim@gmail.com>
+Shailesh Suryawanshi <ss.shailesh28@gmail.com>
 Shamil Garatuev <garatuev@gmail.com>
 Shane Hansen <shanemhansen@gmail.com>
 Shang Jian Ding <sding3@ncsu.edu>
 Shaozhen Ding <dsz0111@gmail.com>
+Shaquille Que <shaquille@golang.org>
 Shaquille Wyan Que <shaqqywyan@gmail.com>
 Shaun Dunning <shaun.dunning@uservoice.com>
 Shawn Elliott <selliott@microsoft.com>
@@ -2108,8 +2240,11 @@ Shenghou Ma <minux@golang.org> <minux.ma@gmail.com>
 Shengjing Zhu <zsj950618@gmail.com>
 Shengyu Zhang <shengyu.zhang@chaitin.com>
 Shi Han Ng <shihanng@gmail.com>
+ShihCheng Tu <mrtoastcheng@gmail.com>
 Shijie Hao <haormj@gmail.com>
+Shin Fan <shinfan@google.com>
 Shinji Tanaka <shinji.tanaka@gmail.com>
+Shinnosuke Sawada <6warashi9@gmail.com>
 Shintaro Kaneko <kaneshin0120@gmail.com>
 Shivakumar GN <shivakumar.gn@gmail.com>
 Shivani Singhal <shivani.singhal2804@gmail.com>
@@ -2121,17 +2256,21 @@ Silvan Jegen <s.jegen@gmail.com>
 Simarpreet Singh <simar@linux.com>
 Simon Drake <simondrake1990@gmail.com>
 Simon Ferquel <simon.ferquel@docker.com>
+Simon Frei <freisim93@gmail.com>
 Simon Jefford <simon.jefford@gmail.com>
 Simon Rawet <simon@rawet.se>
 Simon Rozman <simon@rozman.si>
+Simon Ser <contact@emersion.fr>
 Simon Thulbourn <simon+github@thulbourn.com>
 Simon Whitehead <chemnova@gmail.com>
 Sina Siadat <siadat@gmail.com>
 Sjoerd Siebinga <sjoerd.siebinga@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Song Gao <song@gao.io>
+Songjiayang <songjiayang1@gmail.com>
 Soojin Nam <jsunam@gmail.com>
 Søren L. Hansen <soren@linux2go.dk>
+Sparrow Li <liyuancylx@gmail.com>
 Spencer Kocot <spencerkocot@gmail.com>
 Spencer Nelson <s@spenczar.com>
 Spencer Tung <spencertung@google.com>
@@ -2140,12 +2279,14 @@ Srdjan Petrovic <spetrovic@google.com>
 Sridhar Venkatakrishnan <sridhar@laddoo.net>
 Srinidhi Kaushik <shrinidhi.kaushik@gmail.com>
 StalkR <stalkr@stalkr.net>
+Stan Hu <stanhu@gmail.com>
 Stan Schwertly <stan@schwertly.com>
 Stanislav Afanasev <php.progger@gmail.com>
 Steeve Morin <steeve.morin@gmail.com>
 Stefan Baebler <sbaebler@outbrain.com>
 Stefan Nilsson <snilsson@nada.kth.se> <trolleriprofessorn@gmail.com>
 Stepan Shabalin <neverliberty@gmail.com>
+Stephan Klatt <stephan.klatt@gmail.com>
 Stephan Renatus <srenatus@chef.io>
 Stephan Zuercher <zuercher@gmail.com>
 Stéphane Travostino <stephane.travostino@gmail.com>
@@ -2163,13 +2304,16 @@ Steve Mynott <steve.mynott@gmail.com>
 Steve Newman <snewman@google.com>
 Steve Phillips <elimisteve@gmail.com>
 Steve Streeting <steve@stevestreeting.com>
+Steve Traut <straut@google.com>
 Steven Buss <sbuss@google.com>
 Steven Elliot Harris <seharris@gmail.com>
 Steven Erenst <stevenerenst@gmail.com>
 Steven Hartland <steven.hartland@multiplay.co.uk>
 Steven Littiebrant <imgroxx@gmail.com>
+Steven Maude <git@stevenmaude.co.uk>
 Steven Wilkin <stevenwilkin@gmail.com>
 Stuart Jansen <sjansen@buscaluz.org>
+Subham Sarkar <sarkar.subhams2@gmail.com>
 Sue Spence <virtuallysue@gmail.com>
 Sugu Sougoumarane <ssougou@gmail.com>
 Suharsh Sivakumar <suharshs@google.com>
@@ -2193,6 +2337,7 @@ Taesu Pyo <pyotaesu@gmail.com>
 Tai Le <letientai299@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Takashi Matsuo <tmatsuo@google.com>
+Takashi Mima <tks.m1205@gmail.com>
 Takayoshi Nishida <takayoshi.nishida@gmail.com>
 Takeshi YAMANASHI <9.nashi@gmail.com>
 Takuto Ikuta <tikuta@google.com>
@@ -2221,6 +2366,7 @@ Thanatat Tamtan <acoshift@gmail.com>
 The Hatsune Daishi <nao20010128@gmail.com>
 Thiago Avelino <t@avelino.xxx>
 Thiago Fransosi Farina <thiago.farina@gmail.com> <tfarina@chromium.org>
+Thom Wiggers <thom@thomwiggers.nl>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Bonfort <thomas.bonfort@gmail.com>
 Thomas Bouldin <inlined@google.com>
@@ -2245,6 +2391,7 @@ Tim Ebringer <tim.ebringer@gmail.com>
 Tim Heckman <t@heckman.io>
 Tim Henderson <tim.tadh@gmail.com>
 Tim Hockin <thockin@google.com>
+Tim King <taking@google.com>
 Tim Möhlmann <muhlemmer@gmail.com>
 Tim Swast <swast@google.com>
 Tim Wright <tenortim@gmail.com>
@@ -2252,8 +2399,10 @@ Tim Xu <xiaoxubeii@gmail.com>
 Timmy Douglas <timmyd983@gmail.com>
 Timo Savola <timo.savola@gmail.com>
 Timo Truyts <alkaloid.btx@gmail.com>
+Timothy Gu <timothygu99@gmail.com>
 Timothy Studd <tim@timstudd.com>
 Tipp Moseley <tipp@google.com>
+Tiwei Bie <tiwei.btw@antgroup.com>
 Tobias Assarsson <tobias.assarsson@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com> <tobias.columbus@googlemail.com>
 Tobias Klauser <tklauser@distanz.ch>
@@ -2268,11 +2417,13 @@ Tom Lanyon <tomlanyon@google.com>
 Tom Levy <tomlevy93@gmail.com>
 Tom Limoncelli <tal@whatexit.org>
 Tom Linford <tomlinford@gmail.com>
+Tom Panton <tom@tomandtally.co.uk>
 Tom Parkin <tom.parkin@gmail.com>
 Tom Payne <twpayne@gmail.com>
 Tom Szymanski <tgs@google.com>
 Tom Thorogood <me+google@tomthorogood.co.uk>
 Tom Wilkie <tom@weave.works>
+Tom Zierbock <tomzierbock@gmail.com>
 Tomas Dabasinskas <tomas@dabasinskas.net>
 Tommy Schaefer <tommy.schaefer@teecom.com>
 Tomohiro Kusumoto <zabio1192@gmail.com>
@@ -2298,6 +2449,7 @@ Tristan Colgate <tcolgate@gmail.com>
 Tristan Ooohry <ooohry@gmail.com>
 Tristan Rice <rice@fn.lc>
 Troels Thomsen <troels@thomsen.io>
+Trong Bui <trong.buiquoc@gmail.com>
 Trung Nguyen <trung.n.k@gmail.com>
 Tsuji Daishiro <dram.dt.shonan@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
@@ -2308,6 +2460,7 @@ Tyler Bunnell <tylerbunnell@gmail.com>
 Tyler Treat <ttreat31@gmail.com>
 Tyson Andre <tysonandre775@gmail.com>
 Tzach Shabtay <tzachshabtay@gmail.com>
+Tzu-Chiao Yeh <su3g4284zo6y7@gmail.com>
 Tzu-Jung Lee <roylee17@currant.com>
 Udalov Max <re.udalov@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
@@ -2316,6 +2469,7 @@ Ulrich Kunitz <uli.kunitz@gmail.com>
 Umang Parmar <umangjparmar@gmail.com>
 Uriel Mangado <uriel@berlinblue.org>
 Urvil Patel <patelurvil38@gmail.com>
+Utkarsh Dixit <53217283+utkarsh-extc@users.noreply.github.com>
 Uttam C Pawar <uttam.c.pawar@intel.com>
 Vadim Grek <vadimprog@gmail.com>
 Vadim Vygonets <unixdj@gmail.com>
@@ -2327,6 +2481,7 @@ Venil Noronha <veniln@vmware.com>
 Veselkov Konstantin <kostozyb@gmail.com>
 Viacheslav Poturaev <vearutop@gmail.com>
 Victor Chudnovsky <vchudnov@google.com>
+Victor Michel <victor@optimyze.cloud>
 Victor Vrantchan <vrancean+github@gmail.com>
 Vignesh Ramachandra <vickyramachandra@gmail.com>
 Vikas Kedia <vikask@google.com>
@@ -2341,6 +2496,7 @@ Visweswara R <r.visweswara@gmail.com>
 Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
 Vitor De Mario <vitordemario@gmail.com>
 Vivek Sekhar <vsekhar@google.com>
+Vivek V <iamvivekv96@gmail.com>
 Vivian Liang <vliang88@gmail.com>
 Vlad Krasnov <vlad@cloudflare.com>
 Vladimir Evgrafov <evgrafov.vladimir@gmail.com>
@@ -2392,6 +2548,7 @@ Wu Yunzhou <yunzhouwu@gmail.com>
 Xi Ruoyao <xry23333@gmail.com>
 Xia Bin <snyh@snyh.org>
 Xiangdong Ji <xiangdong.ji@arm.com>
+Xiaodong Liu <teaofmoli@gmail.com>
 Xing Xing <mikespook@gmail.com>
 Xingqang Bai <bxq2011hust@qq.com>
 Xu Fei <badgangkiller@gmail.com>
@@ -2459,6 +2616,7 @@ Zhou Peng <p@ctriple.cn>
 Ziad Hatahet <hatahet@gmail.com>
 Ziheng Liu <lzhfromustc@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
+Zyad A. Ali <zyad.ali.me@gmail.com>
 Максадбек Ахмедов <a.maksadbek@gmail.com>
 Максим Федосеев <max.faceless.frei@gmail.com>
 Роман Хавроненко <hagen1778@gmail.com>

diff --git a/README.md b/README.md
index 49231bf25d2c171cfa9f41eb85f4c493d0a7870e..837734b6e574bfd1f3c99d2a8a4845e58534dbb8 100644 (file)
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.
 
-![Gopher image](doc/gopher/fiveyears.jpg)
+![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
 *Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
 
 Our canonical Git repository is located at https://go.googlesource.com/go.
@@ -19,22 +19,20 @@ BSD-style license found in the LICENSE file.
 Official binary distributions are available at https://golang.org/dl/.
 
 After downloading a binary release, visit https://golang.org/doc/install
-or load [doc/install.html](./doc/install.html) in your web browser for installation
-instructions.
+for installation instructions.
 
 #### Install From Source
 
 If a binary distribution is not available for your combination of
 operating system and architecture, visit
-https://golang.org/doc/install/source or load [doc/install-source.html](./doc/install-source.html)
-in your web browser for source installation instructions.
+https://golang.org/doc/install/source
+for source installation instructions.
 
 ### Contributing
 
 Go is the work of thousands of contributors. We appreciate your help!
 
-To contribute, please read the contribution guidelines:
-       https://golang.org/doc/contribute.html
+To contribute, please read the contribution guidelines at https://golang.org/doc/contribute.html.
 
 Note that the Go project uses the issue tracker for bug reports and
 proposals only. See https://golang.org/wiki/Questions for a list of

diff --git a/api/go1.16.txt b/api/go1.16.txt
new file mode 100644 (file)
index 0000000..ce015fd
--- /dev/null
+++ b/api/go1.16.txt
@@ -0,0 +1,501 @@
+pkg archive/zip, method (*ReadCloser) Open(string) (fs.File, error)
+pkg archive/zip, method (*Reader) Open(string) (fs.File, error)
+pkg crypto/x509, method (SystemRootsError) Unwrap() error
+pkg debug/elf, const DT_ADDRRNGHI = 1879047935
+pkg debug/elf, const DT_ADDRRNGHI DynTag
+pkg debug/elf, const DT_ADDRRNGLO = 1879047680
+pkg debug/elf, const DT_ADDRRNGLO DynTag
+pkg debug/elf, const DT_AUDIT = 1879047932
+pkg debug/elf, const DT_AUDIT DynTag
+pkg debug/elf, const DT_AUXILIARY = 2147483645
+pkg debug/elf, const DT_AUXILIARY DynTag
+pkg debug/elf, const DT_CHECKSUM = 1879047672
+pkg debug/elf, const DT_CHECKSUM DynTag
+pkg debug/elf, const DT_CONFIG = 1879047930
+pkg debug/elf, const DT_CONFIG DynTag
+pkg debug/elf, const DT_DEPAUDIT = 1879047931
+pkg debug/elf, const DT_DEPAUDIT DynTag
+pkg debug/elf, const DT_FEATURE = 1879047676
+pkg debug/elf, const DT_FEATURE DynTag
+pkg debug/elf, const DT_FILTER = 2147483647
+pkg debug/elf, const DT_FILTER DynTag
+pkg debug/elf, const DT_FLAGS_1 = 1879048187
+pkg debug/elf, const DT_FLAGS_1 DynTag
+pkg debug/elf, const DT_GNU_CONFLICT = 1879047928
+pkg debug/elf, const DT_GNU_CONFLICT DynTag
+pkg debug/elf, const DT_GNU_CONFLICTSZ = 1879047670
+pkg debug/elf, const DT_GNU_CONFLICTSZ DynTag
+pkg debug/elf, const DT_GNU_HASH = 1879047925
+pkg debug/elf, const DT_GNU_HASH DynTag
+pkg debug/elf, const DT_GNU_LIBLIST = 1879047929
+pkg debug/elf, const DT_GNU_LIBLIST DynTag
+pkg debug/elf, const DT_GNU_LIBLISTSZ = 1879047671
+pkg debug/elf, const DT_GNU_LIBLISTSZ DynTag
+pkg debug/elf, const DT_GNU_PRELINKED = 1879047669
+pkg debug/elf, const DT_GNU_PRELINKED DynTag
+pkg debug/elf, const DT_MIPS_AUX_DYNAMIC = 1879048241
+pkg debug/elf, const DT_MIPS_AUX_DYNAMIC DynTag
+pkg debug/elf, const DT_MIPS_BASE_ADDRESS = 1879048198
+pkg debug/elf, const DT_MIPS_BASE_ADDRESS DynTag
+pkg debug/elf, const DT_MIPS_COMPACT_SIZE = 1879048239
+pkg debug/elf, const DT_MIPS_COMPACT_SIZE DynTag
+pkg debug/elf, const DT_MIPS_CONFLICT = 1879048200
+pkg debug/elf, const DT_MIPS_CONFLICT DynTag
+pkg debug/elf, const DT_MIPS_CONFLICTNO = 1879048203
+pkg debug/elf, const DT_MIPS_CONFLICTNO DynTag
+pkg debug/elf, const DT_MIPS_CXX_FLAGS = 1879048226
+pkg debug/elf, const DT_MIPS_CXX_FLAGS DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASS = 1879048215
+pkg debug/elf, const DT_MIPS_DELTA_CLASS DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM = 1879048224
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO = 1879048225
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO = 1879048216
+pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE = 1879048217
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE DynTag
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO = 1879048218
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_RELOC = 1879048219
+pkg debug/elf, const DT_MIPS_DELTA_RELOC DynTag
+pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO = 1879048220
+pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_SYM = 1879048221
+pkg debug/elf, const DT_MIPS_DELTA_SYM DynTag
+pkg debug/elf, const DT_MIPS_DELTA_SYM_NO = 1879048222
+pkg debug/elf, const DT_MIPS_DELTA_SYM_NO DynTag
+pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN = 1879048235
+pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN DynTag
+pkg debug/elf, const DT_MIPS_FLAGS = 1879048197
+pkg debug/elf, const DT_MIPS_FLAGS DynTag
+pkg debug/elf, const DT_MIPS_GOTSYM = 1879048211
+pkg debug/elf, const DT_MIPS_GOTSYM DynTag
+pkg debug/elf, const DT_MIPS_GP_VALUE = 1879048240
+pkg debug/elf, const DT_MIPS_GP_VALUE DynTag
+pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX = 1879048231
+pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_HIPAGENO = 1879048212
+pkg debug/elf, const DT_MIPS_HIPAGENO DynTag
+pkg debug/elf, const DT_MIPS_ICHECKSUM = 1879048195
+pkg debug/elf, const DT_MIPS_ICHECKSUM DynTag
+pkg debug/elf, const DT_MIPS_INTERFACE = 1879048234
+pkg debug/elf, const DT_MIPS_INTERFACE DynTag
+pkg debug/elf, const DT_MIPS_INTERFACE_SIZE = 1879048236
+pkg debug/elf, const DT_MIPS_INTERFACE_SIZE DynTag
+pkg debug/elf, const DT_MIPS_IVERSION = 1879048196
+pkg debug/elf, const DT_MIPS_IVERSION DynTag
+pkg debug/elf, const DT_MIPS_LIBLIST = 1879048201
+pkg debug/elf, const DT_MIPS_LIBLIST DynTag
+pkg debug/elf, const DT_MIPS_LIBLISTNO = 1879048208
+pkg debug/elf, const DT_MIPS_LIBLISTNO DynTag
+pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX = 1879048229
+pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX = 1879048230
+pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_LOCAL_GOTNO = 1879048202
+pkg debug/elf, const DT_MIPS_LOCAL_GOTNO DynTag
+pkg debug/elf, const DT_MIPS_MSYM = 1879048199
+pkg debug/elf, const DT_MIPS_MSYM DynTag
+pkg debug/elf, const DT_MIPS_OPTIONS = 1879048233
+pkg debug/elf, const DT_MIPS_OPTIONS DynTag
+pkg debug/elf, const DT_MIPS_PERF_SUFFIX = 1879048238
+pkg debug/elf, const DT_MIPS_PERF_SUFFIX DynTag
+pkg debug/elf, const DT_MIPS_PIXIE_INIT = 1879048227
+pkg debug/elf, const DT_MIPS_PIXIE_INIT DynTag
+pkg debug/elf, const DT_MIPS_PLTGOT = 1879048242
+pkg debug/elf, const DT_MIPS_PLTGOT DynTag
+pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX = 1879048232
+pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_RLD_MAP = 1879048214
+pkg debug/elf, const DT_MIPS_RLD_MAP DynTag
+pkg debug/elf, const DT_MIPS_RLD_MAP_REL = 1879048245
+pkg debug/elf, const DT_MIPS_RLD_MAP_REL DynTag
+pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 1879048237
+pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR DynTag
+pkg debug/elf, const DT_MIPS_RLD_VERSION = 1879048193
+pkg debug/elf, const DT_MIPS_RLD_VERSION DynTag
+pkg debug/elf, const DT_MIPS_RWPLT = 1879048244
+pkg debug/elf, const DT_MIPS_RWPLT DynTag
+pkg debug/elf, const DT_MIPS_SYMBOL_LIB = 1879048228
+pkg debug/elf, const DT_MIPS_SYMBOL_LIB DynTag
+pkg debug/elf, const DT_MIPS_SYMTABNO = 1879048209
+pkg debug/elf, const DT_MIPS_SYMTABNO DynTag
+pkg debug/elf, const DT_MIPS_TIME_STAMP = 1879048194
+pkg debug/elf, const DT_MIPS_TIME_STAMP DynTag
+pkg debug/elf, const DT_MIPS_UNREFEXTNO = 1879048210
+pkg debug/elf, const DT_MIPS_UNREFEXTNO DynTag
+pkg debug/elf, const DT_MOVEENT = 1879047674
+pkg debug/elf, const DT_MOVEENT DynTag
+pkg debug/elf, const DT_MOVESZ = 1879047675
+pkg debug/elf, const DT_MOVESZ DynTag
+pkg debug/elf, const DT_MOVETAB = 1879047934
+pkg debug/elf, const DT_MOVETAB DynTag
+pkg debug/elf, const DT_PLTPAD = 1879047933
+pkg debug/elf, const DT_PLTPAD DynTag
+pkg debug/elf, const DT_PLTPADSZ = 1879047673
+pkg debug/elf, const DT_PLTPADSZ DynTag
+pkg debug/elf, const DT_POSFLAG_1 = 1879047677
+pkg debug/elf, const DT_POSFLAG_1 DynTag
+pkg debug/elf, const DT_PPC64_GLINK = 1879048192
+pkg debug/elf, const DT_PPC64_GLINK DynTag
+pkg debug/elf, const DT_PPC64_OPD = 1879048193
+pkg debug/elf, const DT_PPC64_OPD DynTag
+pkg debug/elf, const DT_PPC64_OPDSZ = 1879048194
+pkg debug/elf, const DT_PPC64_OPDSZ DynTag
+pkg debug/elf, const DT_PPC64_OPT = 1879048195
+pkg debug/elf, const DT_PPC64_OPT DynTag
+pkg debug/elf, const DT_PPC_GOT = 1879048192
+pkg debug/elf, const DT_PPC_GOT DynTag
+pkg debug/elf, const DT_PPC_OPT = 1879048193
+pkg debug/elf, const DT_PPC_OPT DynTag
+pkg debug/elf, const DT_RELACOUNT = 1879048185
+pkg debug/elf, const DT_RELACOUNT DynTag
+pkg debug/elf, const DT_RELCOUNT = 1879048186
+pkg debug/elf, const DT_RELCOUNT DynTag
+pkg debug/elf, const DT_SPARC_REGISTER = 1879048193
+pkg debug/elf, const DT_SPARC_REGISTER DynTag
+pkg debug/elf, const DT_SYMINENT = 1879047679
+pkg debug/elf, const DT_SYMINENT DynTag
+pkg debug/elf, const DT_SYMINFO = 1879047935
+pkg debug/elf, const DT_SYMINFO DynTag
+pkg debug/elf, const DT_SYMINSZ = 1879047678
+pkg debug/elf, const DT_SYMINSZ DynTag
+pkg debug/elf, const DT_SYMTAB_SHNDX = 34
+pkg debug/elf, const DT_SYMTAB_SHNDX DynTag
+pkg debug/elf, const DT_TLSDESC_GOT = 1879047927
+pkg debug/elf, const DT_TLSDESC_GOT DynTag
+pkg debug/elf, const DT_TLSDESC_PLT = 1879047926
+pkg debug/elf, const DT_TLSDESC_PLT DynTag
+pkg debug/elf, const DT_USED = 2147483646
+pkg debug/elf, const DT_USED DynTag
+pkg debug/elf, const DT_VALRNGHI = 1879047679
+pkg debug/elf, const DT_VALRNGHI DynTag
+pkg debug/elf, const DT_VALRNGLO = 1879047424
+pkg debug/elf, const DT_VALRNGLO DynTag
+pkg debug/elf, const DT_VERDEF = 1879048188
+pkg debug/elf, const DT_VERDEF DynTag
+pkg debug/elf, const DT_VERDEFNUM = 1879048189
+pkg debug/elf, const DT_VERDEFNUM DynTag
+pkg debug/elf, const PT_AARCH64_ARCHEXT = 1879048192
+pkg debug/elf, const PT_AARCH64_ARCHEXT ProgType
+pkg debug/elf, const PT_AARCH64_UNWIND = 1879048193
+pkg debug/elf, const PT_AARCH64_UNWIND ProgType
+pkg debug/elf, const PT_ARM_ARCHEXT = 1879048192
+pkg debug/elf, const PT_ARM_ARCHEXT ProgType
+pkg debug/elf, const PT_ARM_EXIDX = 1879048193
+pkg debug/elf, const PT_ARM_EXIDX ProgType
+pkg debug/elf, const PT_GNU_EH_FRAME = 1685382480
+pkg debug/elf, const PT_GNU_EH_FRAME ProgType
+pkg debug/elf, const PT_GNU_MBIND_HI = 1685386580
+pkg debug/elf, const PT_GNU_MBIND_HI ProgType
+pkg debug/elf, const PT_GNU_MBIND_LO = 1685382485
+pkg debug/elf, const PT_GNU_MBIND_LO ProgType
+pkg debug/elf, const PT_GNU_PROPERTY = 1685382483
+pkg debug/elf, const PT_GNU_PROPERTY ProgType
+pkg debug/elf, const PT_GNU_RELRO = 1685382482
+pkg debug/elf, const PT_GNU_RELRO ProgType
+pkg debug/elf, const PT_GNU_STACK = 1685382481
+pkg debug/elf, const PT_GNU_STACK ProgType
+pkg debug/elf, const PT_MIPS_ABIFLAGS = 1879048195
+pkg debug/elf, const PT_MIPS_ABIFLAGS ProgType
+pkg debug/elf, const PT_MIPS_OPTIONS = 1879048194
+pkg debug/elf, const PT_MIPS_OPTIONS ProgType
+pkg debug/elf, const PT_MIPS_REGINFO = 1879048192
+pkg debug/elf, const PT_MIPS_REGINFO ProgType
+pkg debug/elf, const PT_MIPS_RTPROC = 1879048193
+pkg debug/elf, const PT_MIPS_RTPROC ProgType
+pkg debug/elf, const PT_OPENBSD_BOOTDATA = 1705253862
+pkg debug/elf, const PT_OPENBSD_BOOTDATA ProgType
+pkg debug/elf, const PT_OPENBSD_RANDOMIZE = 1705237478
+pkg debug/elf, const PT_OPENBSD_RANDOMIZE ProgType
+pkg debug/elf, const PT_OPENBSD_WXNEEDED = 1705237479
+pkg debug/elf, const PT_OPENBSD_WXNEEDED ProgType
+pkg debug/elf, const PT_PAX_FLAGS = 1694766464
+pkg debug/elf, const PT_PAX_FLAGS ProgType
+pkg debug/elf, const PT_S390_PGSTE = 1879048192
+pkg debug/elf, const PT_S390_PGSTE ProgType
+pkg debug/elf, const PT_SUNWSTACK = 1879048187
+pkg debug/elf, const PT_SUNWSTACK ProgType
+pkg debug/elf, const PT_SUNW_EH_FRAME = 1685382480
+pkg debug/elf, const PT_SUNW_EH_FRAME ProgType
+pkg embed, method (FS) Open(string) (fs.File, error)
+pkg embed, method (FS) ReadDir(string) ([]fs.DirEntry, error)
+pkg embed, method (FS) ReadFile(string) ([]uint8, error)
+pkg embed, type FS struct
+pkg flag, func Func(string, string, func(string) error)
+pkg flag, method (*FlagSet) Func(string, string, func(string) error)
+pkg go/build, type Package struct, EmbedPatterns []string
+pkg go/build, type Package struct, EmbedPatternPos map[string][]token.Position
+pkg go/build, type Package struct, IgnoredOtherFiles []string
+pkg go/build, type Package struct, TestEmbedPatterns []string
+pkg go/build, type Package struct, TestEmbedPatternPos map[string][]token.Position
+pkg go/build, type Package struct, XTestEmbedPatterns []string
+pkg go/build, type Package struct, XTestEmbedPatternPos map[string][]token.Position
+pkg go/build/constraint, func IsGoBuild(string) bool
+pkg go/build/constraint, func IsPlusBuild(string) bool
+pkg go/build/constraint, func Parse(string) (Expr, error)
+pkg go/build/constraint, func PlusBuildLines(Expr) ([]string, error)
+pkg go/build/constraint, method (*AndExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*AndExpr) String() string
+pkg go/build/constraint, method (*NotExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*NotExpr) String() string
+pkg go/build/constraint, method (*OrExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*OrExpr) String() string
+pkg go/build/constraint, method (*SyntaxError) Error() string
+pkg go/build/constraint, method (*TagExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*TagExpr) String() string
+pkg go/build/constraint, type AndExpr struct
+pkg go/build/constraint, type AndExpr struct, X Expr
+pkg go/build/constraint, type AndExpr struct, Y Expr
+pkg go/build/constraint, type Expr interface, Eval(func(string) bool) bool
+pkg go/build/constraint, type Expr interface, String() string
+pkg go/build/constraint, type Expr interface, unexported methods
+pkg go/build/constraint, type NotExpr struct
+pkg go/build/constraint, type NotExpr struct, X Expr
+pkg go/build/constraint, type OrExpr struct
+pkg go/build/constraint, type OrExpr struct, X Expr
+pkg go/build/constraint, type OrExpr struct, Y Expr
+pkg go/build/constraint, type SyntaxError struct
+pkg go/build/constraint, type SyntaxError struct, Err string
+pkg go/build/constraint, type SyntaxError struct, Offset int
+pkg go/build/constraint, type TagExpr struct
+pkg go/build/constraint, type TagExpr struct, Tag string
+pkg html/template, func ParseFS(fs.FS, ...string) (*Template, error)
+pkg html/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
+pkg io, func NopCloser(Reader) ReadCloser
+pkg io, func ReadAll(Reader) ([]uint8, error)
+pkg io, type ReadSeekCloser interface { Close, Read, Seek }
+pkg io, type ReadSeekCloser interface, Close() error
+pkg io, type ReadSeekCloser interface, Read([]uint8) (int, error)
+pkg io, type ReadSeekCloser interface, Seek(int64, int) (int64, error)
+pkg io, var Discard Writer
+pkg io/fs, const ModeAppend = 1073741824
+pkg io/fs, const ModeAppend FileMode
+pkg io/fs, const ModeCharDevice = 2097152
+pkg io/fs, const ModeCharDevice FileMode
+pkg io/fs, const ModeDevice = 67108864
+pkg io/fs, const ModeDevice FileMode
+pkg io/fs, const ModeDir = 2147483648
+pkg io/fs, const ModeDir FileMode
+pkg io/fs, const ModeExclusive = 536870912
+pkg io/fs, const ModeExclusive FileMode
+pkg io/fs, const ModeIrregular = 524288
+pkg io/fs, const ModeIrregular FileMode
+pkg io/fs, const ModeNamedPipe = 33554432
+pkg io/fs, const ModeNamedPipe FileMode
+pkg io/fs, const ModePerm = 511
+pkg io/fs, const ModePerm FileMode
+pkg io/fs, const ModeSetgid = 4194304
+pkg io/fs, const ModeSetgid FileMode
+pkg io/fs, const ModeSetuid = 8388608
+pkg io/fs, const ModeSetuid FileMode
+pkg io/fs, const ModeSocket = 16777216
+pkg io/fs, const ModeSocket FileMode
+pkg io/fs, const ModeSticky = 1048576
+pkg io/fs, const ModeSticky FileMode
+pkg io/fs, const ModeSymlink = 134217728
+pkg io/fs, const ModeSymlink FileMode
+pkg io/fs, const ModeTemporary = 268435456
+pkg io/fs, const ModeTemporary FileMode
+pkg io/fs, const ModeType = 2401763328
+pkg io/fs, const ModeType FileMode
+pkg io/fs, func Glob(FS, string) ([]string, error)
+pkg io/fs, func ReadDir(FS, string) ([]DirEntry, error)
+pkg io/fs, func ReadFile(FS, string) ([]uint8, error)
+pkg io/fs, func Stat(FS, string) (FileInfo, error)
+pkg io/fs, func Sub(FS, string) (FS, error)
+pkg io/fs, func ValidPath(string) bool
+pkg io/fs, func WalkDir(FS, string, WalkDirFunc) error
+pkg io/fs, method (*PathError) Error() string
+pkg io/fs, method (*PathError) Timeout() bool
+pkg io/fs, method (*PathError) Unwrap() error
+pkg io/fs, method (FileMode) IsDir() bool
+pkg io/fs, method (FileMode) IsRegular() bool
+pkg io/fs, method (FileMode) Perm() FileMode
+pkg io/fs, method (FileMode) String() string
+pkg io/fs, method (FileMode) Type() FileMode
+pkg io/fs, type DirEntry interface { Info, IsDir, Name, Type }
+pkg io/fs, type DirEntry interface, Info() (FileInfo, error)
+pkg io/fs, type DirEntry interface, IsDir() bool
+pkg io/fs, type DirEntry interface, Name() string
+pkg io/fs, type DirEntry interface, Type() FileMode
+pkg io/fs, type FS interface { Open }
+pkg io/fs, type FS interface, Open(string) (File, error)
+pkg io/fs, type File interface { Close, Read, Stat }
+pkg io/fs, type File interface, Close() error
+pkg io/fs, type File interface, Read([]uint8) (int, error)
+pkg io/fs, type File interface, Stat() (FileInfo, error)
+pkg io/fs, type FileInfo interface { IsDir, ModTime, Mode, Name, Size, Sys }
+pkg io/fs, type FileInfo interface, IsDir() bool
+pkg io/fs, type FileInfo interface, ModTime() time.Time
+pkg io/fs, type FileInfo interface, Mode() FileMode
+pkg io/fs, type FileInfo interface, Name() string
+pkg io/fs, type FileInfo interface, Size() int64
+pkg io/fs, type FileInfo interface, Sys() interface{}
+pkg io/fs, type FileMode uint32
+pkg io/fs, type GlobFS interface { Glob, Open }
+pkg io/fs, type GlobFS interface, Glob(string) ([]string, error)
+pkg io/fs, type GlobFS interface, Open(string) (File, error)
+pkg io/fs, type PathError struct
+pkg io/fs, type PathError struct, Err error
+pkg io/fs, type PathError struct, Op string
+pkg io/fs, type PathError struct, Path string
+pkg io/fs, type ReadDirFS interface { Open, ReadDir }
+pkg io/fs, type ReadDirFS interface, Open(string) (File, error)
+pkg io/fs, type ReadDirFS interface, ReadDir(string) ([]DirEntry, error)
+pkg io/fs, type ReadDirFile interface { Close, Read, ReadDir, Stat }
+pkg io/fs, type ReadDirFile interface, Close() error
+pkg io/fs, type ReadDirFile interface, Read([]uint8) (int, error)
+pkg io/fs, type ReadDirFile interface, ReadDir(int) ([]DirEntry, error)
+pkg io/fs, type ReadDirFile interface, Stat() (FileInfo, error)
+pkg io/fs, type ReadFileFS interface { Open, ReadFile }
+pkg io/fs, type ReadFileFS interface, Open(string) (File, error)
+pkg io/fs, type ReadFileFS interface, ReadFile(string) ([]uint8, error)
+pkg io/fs, type StatFS interface { Open, Stat }
+pkg io/fs, type StatFS interface, Open(string) (File, error)
+pkg io/fs, type StatFS interface, Stat(string) (FileInfo, error)
+pkg io/fs, type SubFS interface { Open, Sub }
+pkg io/fs, type SubFS interface, Open(string) (File, error)
+pkg io/fs, type SubFS interface, Sub(string) (FS, error)
+pkg io/fs, type WalkDirFunc func(string, DirEntry, error) error
+pkg io/fs, var ErrClosed error
+pkg io/fs, var ErrExist error
+pkg io/fs, var ErrInvalid error
+pkg io/fs, var ErrNotExist error
+pkg io/fs, var ErrPermission error
+pkg io/fs, var SkipDir error
+pkg log, func Default() *Logger
+pkg net, var ErrClosed error
+pkg net/http, func FS(fs.FS) FileSystem
+pkg net/http, type Transport struct, GetProxyConnectHeader func(context.Context, *url.URL, string) (Header, error)
+pkg os, const ModeAppend fs.FileMode
+pkg os, const ModeCharDevice fs.FileMode
+pkg os, const ModeDevice fs.FileMode
+pkg os, const ModeDir fs.FileMode
+pkg os, const ModeExclusive fs.FileMode
+pkg os, const ModeIrregular fs.FileMode
+pkg os, const ModeNamedPipe fs.FileMode
+pkg os, const ModePerm fs.FileMode
+pkg os, const ModeSetgid fs.FileMode
+pkg os, const ModeSetuid fs.FileMode
+pkg os, const ModeSocket fs.FileMode
+pkg os, const ModeSticky fs.FileMode
+pkg os, const ModeSymlink fs.FileMode
+pkg os, const ModeTemporary fs.FileMode
+pkg os, const ModeType fs.FileMode
+pkg os, func Chmod(string, fs.FileMode) error
+pkg os, func CreateTemp(string, string) (*File, error)
+pkg os, func DirFS(string) fs.FS
+pkg os, func Lstat(string) (fs.FileInfo, error)
+pkg os, func Mkdir(string, fs.FileMode) error
+pkg os, func MkdirAll(string, fs.FileMode) error
+pkg os, func MkdirTemp(string, string) (string, error)
+pkg os, func OpenFile(string, int, fs.FileMode) (*File, error)
+pkg os, func ReadDir(string) ([]fs.DirEntry, error)
+pkg os, func ReadFile(string) ([]uint8, error)
+pkg os, func SameFile(fs.FileInfo, fs.FileInfo) bool
+pkg os, func Stat(string) (fs.FileInfo, error)
+pkg os, func WriteFile(string, []uint8, fs.FileMode) error
+pkg os, method (*File) Chmod(fs.FileMode) error
+pkg os, method (*File) ReadDir(int) ([]fs.DirEntry, error)
+pkg os, method (*File) Readdir(int) ([]fs.FileInfo, error)
+pkg os, method (*File) Stat() (fs.FileInfo, error)
+pkg os, type DirEntry = fs.DirEntry
+pkg os, type FileInfo = fs.FileInfo
+pkg os, type FileMode = fs.FileMode
+pkg os, type PathError = fs.PathError
+pkg os, var ErrProcessDone error
+pkg os/signal, func NotifyContext(context.Context, ...os.Signal) (context.Context, context.CancelFunc)
+pkg path/filepath, func WalkDir(string, fs.WalkDirFunc) error
+pkg runtime/metrics, const KindBad = 0
+pkg runtime/metrics, const KindBad ValueKind
+pkg runtime/metrics, const KindFloat64 = 2
+pkg runtime/metrics, const KindFloat64 ValueKind
+pkg runtime/metrics, const KindFloat64Histogram = 3
+pkg runtime/metrics, const KindFloat64Histogram ValueKind
+pkg runtime/metrics, const KindUint64 = 1
+pkg runtime/metrics, const KindUint64 ValueKind
+pkg runtime/metrics, func All() []Description
+pkg runtime/metrics, func Read([]Sample)
+pkg runtime/metrics, method (Value) Float64() float64
+pkg runtime/metrics, method (Value) Float64Histogram() *Float64Histogram
+pkg runtime/metrics, method (Value) Kind() ValueKind
+pkg runtime/metrics, method (Value) Uint64() uint64
+pkg runtime/metrics, type Description struct
+pkg runtime/metrics, type Description struct, Cumulative bool
+pkg runtime/metrics, type Description struct, Description string
+pkg runtime/metrics, type Description struct, Kind ValueKind
+pkg runtime/metrics, type Description struct, Name string
+pkg runtime/metrics, type Float64Histogram struct
+pkg runtime/metrics, type Float64Histogram struct, Buckets []float64
+pkg runtime/metrics, type Float64Histogram struct, Counts []uint64
+pkg runtime/metrics, type Sample struct
+pkg runtime/metrics, type Sample struct, Name string
+pkg runtime/metrics, type Sample struct, Value Value
+pkg runtime/metrics, type Value struct
+pkg runtime/metrics, type ValueKind int
+pkg syscall (linux-386), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386), func Setegid(int) error
+pkg syscall (linux-386), func Seteuid(int) error
+pkg syscall (linux-386-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386-cgo), func Setegid(int) error
+pkg syscall (linux-386-cgo), func Seteuid(int) error
+pkg syscall (linux-amd64), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64), func Setegid(int) error
+pkg syscall (linux-amd64), func Seteuid(int) error
+pkg syscall (linux-amd64-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64-cgo), func Setegid(int) error
+pkg syscall (linux-amd64-cgo), func Seteuid(int) error
+pkg syscall (linux-arm), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm), func Setegid(int) error
+pkg syscall (linux-arm), func Seteuid(int) error
+pkg syscall (linux-arm-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm-cgo), func Setegid(int) error
+pkg syscall (linux-arm-cgo), func Seteuid(int) error
+pkg syscall (windows-386), method (*DLLError) Unwrap() error
+pkg syscall (windows-386), type SysProcAttr struct, NoInheritHandles bool
+pkg syscall (windows-amd64), method (*DLLError) Unwrap() error
+pkg syscall (windows-amd64), type SysProcAttr struct, NoInheritHandles bool
+pkg testing/fstest, func TestFS(fs.FS, ...string) error
+pkg testing/fstest, method (MapFS) Glob(string) ([]string, error)
+pkg testing/fstest, method (MapFS) Open(string) (fs.File, error)
+pkg testing/fstest, method (MapFS) ReadDir(string) ([]fs.DirEntry, error)
+pkg testing/fstest, method (MapFS) ReadFile(string) ([]uint8, error)
+pkg testing/fstest, method (MapFS) Stat(string) (fs.FileInfo, error)
+pkg testing/fstest, method (MapFS) Sub(string) (fs.FS, error)
+pkg testing/fstest, type MapFS map[string]*MapFile
+pkg testing/fstest, type MapFile struct
+pkg testing/fstest, type MapFile struct, Data []uint8
+pkg testing/fstest, type MapFile struct, ModTime time.Time
+pkg testing/fstest, type MapFile struct, Mode fs.FileMode
+pkg testing/fstest, type MapFile struct, Sys interface{}
+pkg testing/iotest, func ErrReader(error) io.Reader
+pkg testing/iotest, func TestReader(io.Reader, []uint8) error
+pkg text/template, func ParseFS(fs.FS, ...string) (*Template, error)
+pkg text/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
+pkg text/template/parse, const NodeComment = 20
+pkg text/template/parse, const NodeComment NodeType
+pkg text/template/parse, const ParseComments = 1
+pkg text/template/parse, const ParseComments Mode
+pkg text/template/parse, method (*CommentNode) Copy() Node
+pkg text/template/parse, method (*CommentNode) String() string
+pkg text/template/parse, method (CommentNode) Position() Pos
+pkg text/template/parse, method (CommentNode) Type() NodeType
+pkg text/template/parse, type CommentNode struct
+pkg text/template/parse, type CommentNode struct, Text string
+pkg text/template/parse, type CommentNode struct, embedded NodeType
+pkg text/template/parse, type CommentNode struct, embedded Pos
+pkg text/template/parse, type Mode uint
+pkg text/template/parse, type Tree struct, Mode Mode
+pkg unicode, const Version = "13.0.0"
+pkg unicode, var Chorasmian *RangeTable
+pkg unicode, var Dives_Akuru *RangeTable
+pkg unicode, var Khitan_Small_Script *RangeTable
+pkg unicode, var Yezidi *RangeTable

diff --git a/api/next.txt b/api/next.txt
index 7e5378da5ee5116da6acd4fcf02faf3e4dfb7e2e..e7d6bee824fa92fb270cc1cf7b0394201ca0be1c 100644 (file)
--- a/api/next.txt
+++ b/api/next.txt
@@ -1,420 +1,3 @@
-pkg archive/zip, method (*ReadCloser) Open(string) (fs.File, error)
-pkg archive/zip, method (*Reader) Open(string) (fs.File, error)
-pkg debug/elf, const DT_ADDRRNGHI = 1879047935
-pkg debug/elf, const DT_ADDRRNGHI DynTag
-pkg debug/elf, const DT_ADDRRNGLO = 1879047680
-pkg debug/elf, const DT_ADDRRNGLO DynTag
-pkg debug/elf, const DT_AUDIT = 1879047932
-pkg debug/elf, const DT_AUDIT DynTag
-pkg debug/elf, const DT_AUXILIARY = 2147483645
-pkg debug/elf, const DT_AUXILIARY DynTag
-pkg debug/elf, const DT_CHECKSUM = 1879047672
-pkg debug/elf, const DT_CHECKSUM DynTag
-pkg debug/elf, const DT_CONFIG = 1879047930
-pkg debug/elf, const DT_CONFIG DynTag
-pkg debug/elf, const DT_DEPAUDIT = 1879047931
-pkg debug/elf, const DT_DEPAUDIT DynTag
-pkg debug/elf, const DT_FEATURE = 1879047676
-pkg debug/elf, const DT_FEATURE DynTag
-pkg debug/elf, const DT_FILTER = 2147483647
-pkg debug/elf, const DT_FILTER DynTag
-pkg debug/elf, const DT_FLAGS_1 = 1879048187
-pkg debug/elf, const DT_FLAGS_1 DynTag
-pkg debug/elf, const DT_GNU_CONFLICT = 1879047928
-pkg debug/elf, const DT_GNU_CONFLICT DynTag
-pkg debug/elf, const DT_GNU_CONFLICTSZ = 1879047670
-pkg debug/elf, const DT_GNU_CONFLICTSZ DynTag
-pkg debug/elf, const DT_GNU_HASH = 1879047925
-pkg debug/elf, const DT_GNU_HASH DynTag
-pkg debug/elf, const DT_GNU_LIBLIST = 1879047929
-pkg debug/elf, const DT_GNU_LIBLIST DynTag
-pkg debug/elf, const DT_GNU_LIBLISTSZ = 1879047671
-pkg debug/elf, const DT_GNU_LIBLISTSZ DynTag
-pkg debug/elf, const DT_GNU_PRELINKED = 1879047669
-pkg debug/elf, const DT_GNU_PRELINKED DynTag
-pkg debug/elf, const DT_MIPS_AUX_DYNAMIC = 1879048241
-pkg debug/elf, const DT_MIPS_AUX_DYNAMIC DynTag
-pkg debug/elf, const DT_MIPS_BASE_ADDRESS = 1879048198
-pkg debug/elf, const DT_MIPS_BASE_ADDRESS DynTag
-pkg debug/elf, const DT_MIPS_COMPACT_SIZE = 1879048239
-pkg debug/elf, const DT_MIPS_COMPACT_SIZE DynTag
-pkg debug/elf, const DT_MIPS_CONFLICT = 1879048200
-pkg debug/elf, const DT_MIPS_CONFLICT DynTag
-pkg debug/elf, const DT_MIPS_CONFLICTNO = 1879048203
-pkg debug/elf, const DT_MIPS_CONFLICTNO DynTag
-pkg debug/elf, const DT_MIPS_CXX_FLAGS = 1879048226
-pkg debug/elf, const DT_MIPS_CXX_FLAGS DynTag
-pkg debug/elf, const DT_MIPS_DELTA_CLASS = 1879048215
-pkg debug/elf, const DT_MIPS_DELTA_CLASS DynTag
-pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM = 1879048224
-pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM DynTag
-pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO = 1879048225
-pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO DynTag
-pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO = 1879048216
-pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO DynTag
-pkg debug/elf, const DT_MIPS_DELTA_INSTANCE = 1879048217
-pkg debug/elf, const DT_MIPS_DELTA_INSTANCE DynTag
-pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO = 1879048218
-pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO DynTag
-pkg debug/elf, const DT_MIPS_DELTA_RELOC = 1879048219
-pkg debug/elf, const DT_MIPS_DELTA_RELOC DynTag
-pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO = 1879048220
-pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO DynTag
-pkg debug/elf, const DT_MIPS_DELTA_SYM = 1879048221
-pkg debug/elf, const DT_MIPS_DELTA_SYM DynTag
-pkg debug/elf, const DT_MIPS_DELTA_SYM_NO = 1879048222
-pkg debug/elf, const DT_MIPS_DELTA_SYM_NO DynTag
-pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN = 1879048235
-pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN DynTag
-pkg debug/elf, const DT_MIPS_FLAGS = 1879048197
-pkg debug/elf, const DT_MIPS_FLAGS DynTag
-pkg debug/elf, const DT_MIPS_GOTSYM = 1879048211
-pkg debug/elf, const DT_MIPS_GOTSYM DynTag
-pkg debug/elf, const DT_MIPS_GP_VALUE = 1879048240
-pkg debug/elf, const DT_MIPS_GP_VALUE DynTag
-pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX = 1879048231
-pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX DynTag
-pkg debug/elf, const DT_MIPS_HIPAGENO = 1879048212
-pkg debug/elf, const DT_MIPS_HIPAGENO DynTag
-pkg debug/elf, const DT_MIPS_ICHECKSUM = 1879048195
-pkg debug/elf, const DT_MIPS_ICHECKSUM DynTag
-pkg debug/elf, const DT_MIPS_INTERFACE = 1879048234
-pkg debug/elf, const DT_MIPS_INTERFACE DynTag
-pkg debug/elf, const DT_MIPS_INTERFACE_SIZE = 1879048236
-pkg debug/elf, const DT_MIPS_INTERFACE_SIZE DynTag
-pkg debug/elf, const DT_MIPS_IVERSION = 1879048196
-pkg debug/elf, const DT_MIPS_IVERSION DynTag
-pkg debug/elf, const DT_MIPS_LIBLIST = 1879048201
-pkg debug/elf, const DT_MIPS_LIBLIST DynTag
-pkg debug/elf, const DT_MIPS_LIBLISTNO = 1879048208
-pkg debug/elf, const DT_MIPS_LIBLISTNO DynTag
-pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX = 1879048229
-pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX DynTag
-pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX = 1879048230
-pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX DynTag
-pkg debug/elf, const DT_MIPS_LOCAL_GOTNO = 1879048202
-pkg debug/elf, const DT_MIPS_LOCAL_GOTNO DynTag
-pkg debug/elf, const DT_MIPS_MSYM = 1879048199
-pkg debug/elf, const DT_MIPS_MSYM DynTag
-pkg debug/elf, const DT_MIPS_OPTIONS = 1879048233
-pkg debug/elf, const DT_MIPS_OPTIONS DynTag
-pkg debug/elf, const DT_MIPS_PERF_SUFFIX = 1879048238
-pkg debug/elf, const DT_MIPS_PERF_SUFFIX DynTag
-pkg debug/elf, const DT_MIPS_PIXIE_INIT = 1879048227
-pkg debug/elf, const DT_MIPS_PIXIE_INIT DynTag
-pkg debug/elf, const DT_MIPS_PLTGOT = 1879048242
-pkg debug/elf, const DT_MIPS_PLTGOT DynTag
-pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX = 1879048232
-pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX DynTag
-pkg debug/elf, const DT_MIPS_RLD_MAP = 1879048214
-pkg debug/elf, const DT_MIPS_RLD_MAP DynTag
-pkg debug/elf, const DT_MIPS_RLD_MAP_REL = 1879048245
-pkg debug/elf, const DT_MIPS_RLD_MAP_REL DynTag
-pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 1879048237
-pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR DynTag
-pkg debug/elf, const DT_MIPS_RLD_VERSION = 1879048193
-pkg debug/elf, const DT_MIPS_RLD_VERSION DynTag
-pkg debug/elf, const DT_MIPS_RWPLT = 1879048244
-pkg debug/elf, const DT_MIPS_RWPLT DynTag
-pkg debug/elf, const DT_MIPS_SYMBOL_LIB = 1879048228
-pkg debug/elf, const DT_MIPS_SYMBOL_LIB DynTag
-pkg debug/elf, const DT_MIPS_SYMTABNO = 1879048209
-pkg debug/elf, const DT_MIPS_SYMTABNO DynTag
-pkg debug/elf, const DT_MIPS_TIME_STAMP = 1879048194
-pkg debug/elf, const DT_MIPS_TIME_STAMP DynTag
-pkg debug/elf, const DT_MIPS_UNREFEXTNO = 1879048210
-pkg debug/elf, const DT_MIPS_UNREFEXTNO DynTag
-pkg debug/elf, const DT_MOVEENT = 1879047674
-pkg debug/elf, const DT_MOVEENT DynTag
-pkg debug/elf, const DT_MOVESZ = 1879047675
-pkg debug/elf, const DT_MOVESZ DynTag
-pkg debug/elf, const DT_MOVETAB = 1879047934
-pkg debug/elf, const DT_MOVETAB DynTag
-pkg debug/elf, const DT_PLTPAD = 1879047933
-pkg debug/elf, const DT_PLTPAD DynTag
-pkg debug/elf, const DT_PLTPADSZ = 1879047673
-pkg debug/elf, const DT_PLTPADSZ DynTag
-pkg debug/elf, const DT_POSFLAG_1 = 1879047677
-pkg debug/elf, const DT_POSFLAG_1 DynTag
-pkg debug/elf, const DT_PPC64_GLINK = 1879048192
-pkg debug/elf, const DT_PPC64_GLINK DynTag
-pkg debug/elf, const DT_PPC64_OPD = 1879048193
-pkg debug/elf, const DT_PPC64_OPD DynTag
-pkg debug/elf, const DT_PPC64_OPDSZ = 1879048194
-pkg debug/elf, const DT_PPC64_OPDSZ DynTag
-pkg debug/elf, const DT_PPC64_OPT = 1879048195
-pkg debug/elf, const DT_PPC64_OPT DynTag
-pkg debug/elf, const DT_PPC_GOT = 1879048192
-pkg debug/elf, const DT_PPC_GOT DynTag
-pkg debug/elf, const DT_PPC_OPT = 1879048193
-pkg debug/elf, const DT_PPC_OPT DynTag
-pkg debug/elf, const DT_RELACOUNT = 1879048185
-pkg debug/elf, const DT_RELACOUNT DynTag
-pkg debug/elf, const DT_RELCOUNT = 1879048186
-pkg debug/elf, const DT_RELCOUNT DynTag
-pkg debug/elf, const DT_SPARC_REGISTER = 1879048193
-pkg debug/elf, const DT_SPARC_REGISTER DynTag
-pkg debug/elf, const DT_SYMINENT = 1879047679
-pkg debug/elf, const DT_SYMINENT DynTag
-pkg debug/elf, const DT_SYMINFO = 1879047935
-pkg debug/elf, const DT_SYMINFO DynTag
-pkg debug/elf, const DT_SYMINSZ = 1879047678
-pkg debug/elf, const DT_SYMINSZ DynTag
-pkg debug/elf, const DT_SYMTAB_SHNDX = 34
-pkg debug/elf, const DT_SYMTAB_SHNDX DynTag
-pkg debug/elf, const DT_TLSDESC_GOT = 1879047927
-pkg debug/elf, const DT_TLSDESC_GOT DynTag
-pkg debug/elf, const DT_TLSDESC_PLT = 1879047926
-pkg debug/elf, const DT_TLSDESC_PLT DynTag
-pkg debug/elf, const DT_USED = 2147483646
-pkg debug/elf, const DT_USED DynTag
-pkg debug/elf, const DT_VALRNGHI = 1879047679
-pkg debug/elf, const DT_VALRNGHI DynTag
-pkg debug/elf, const DT_VALRNGLO = 1879047424
-pkg debug/elf, const DT_VALRNGLO DynTag
-pkg debug/elf, const DT_VERDEF = 1879048188
-pkg debug/elf, const DT_VERDEF DynTag
-pkg debug/elf, const DT_VERDEFNUM = 1879048189
-pkg debug/elf, const DT_VERDEFNUM DynTag
-pkg debug/elf, const PT_AARCH64_ARCHEXT = 1879048192
-pkg debug/elf, const PT_AARCH64_ARCHEXT ProgType
-pkg debug/elf, const PT_AARCH64_UNWIND = 1879048193
-pkg debug/elf, const PT_AARCH64_UNWIND ProgType
-pkg debug/elf, const PT_ARM_ARCHEXT = 1879048192
-pkg debug/elf, const PT_ARM_ARCHEXT ProgType
-pkg debug/elf, const PT_ARM_EXIDX = 1879048193
-pkg debug/elf, const PT_ARM_EXIDX ProgType
-pkg debug/elf, const PT_GNU_EH_FRAME = 1685382480
-pkg debug/elf, const PT_GNU_EH_FRAME ProgType
-pkg debug/elf, const PT_GNU_MBIND_HI = 1685386580
-pkg debug/elf, const PT_GNU_MBIND_HI ProgType
-pkg debug/elf, const PT_GNU_MBIND_LO = 1685382485
-pkg debug/elf, const PT_GNU_MBIND_LO ProgType
-pkg debug/elf, const PT_GNU_PROPERTY = 1685382483
-pkg debug/elf, const PT_GNU_PROPERTY ProgType
-pkg debug/elf, const PT_GNU_RELRO = 1685382482
-pkg debug/elf, const PT_GNU_RELRO ProgType
-pkg debug/elf, const PT_GNU_STACK = 1685382481
-pkg debug/elf, const PT_GNU_STACK ProgType
-pkg debug/elf, const PT_MIPS_ABIFLAGS = 1879048195
-pkg debug/elf, const PT_MIPS_ABIFLAGS ProgType
-pkg debug/elf, const PT_MIPS_OPTIONS = 1879048194
-pkg debug/elf, const PT_MIPS_OPTIONS ProgType
-pkg debug/elf, const PT_MIPS_REGINFO = 1879048192
-pkg debug/elf, const PT_MIPS_REGINFO ProgType
-pkg debug/elf, const PT_MIPS_RTPROC = 1879048193
-pkg debug/elf, const PT_MIPS_RTPROC ProgType
-pkg debug/elf, const PT_OPENBSD_BOOTDATA = 1705253862
-pkg debug/elf, const PT_OPENBSD_BOOTDATA ProgType
-pkg debug/elf, const PT_OPENBSD_RANDOMIZE = 1705237478
-pkg debug/elf, const PT_OPENBSD_RANDOMIZE ProgType
-pkg debug/elf, const PT_OPENBSD_WXNEEDED = 1705237479
-pkg debug/elf, const PT_OPENBSD_WXNEEDED ProgType
-pkg debug/elf, const PT_PAX_FLAGS = 1694766464
-pkg debug/elf, const PT_PAX_FLAGS ProgType
-pkg debug/elf, const PT_S390_PGSTE = 1879048192
-pkg debug/elf, const PT_S390_PGSTE ProgType
-pkg debug/elf, const PT_SUNWSTACK = 1879048187
-pkg debug/elf, const PT_SUNWSTACK ProgType
-pkg debug/elf, const PT_SUNW_EH_FRAME = 1685382480
-pkg debug/elf, const PT_SUNW_EH_FRAME ProgType
-pkg embed, method (FS) Open(string) (fs.File, error)
-pkg embed, method (FS) ReadDir(string) ([]fs.DirEntry, error)
-pkg embed, method (FS) ReadFile(string) ([]uint8, error)
-pkg embed, type FS struct
-pkg flag, func Func(string, string, func(string) error)
-pkg flag, method (*FlagSet) Func(string, string, func(string) error)
-pkg go/build, type Package struct, EmbedPatterns []string
-pkg go/build, type Package struct, IgnoredOtherFiles []string
-pkg go/build, type Package struct, TestEmbedPatterns []string
-pkg go/build, type Package struct, XTestEmbedPatterns []string
-pkg html/template, func ParseFS(fs.FS, ...string) (*Template, error)
-pkg html/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
-pkg io, func NopCloser(Reader) ReadCloser
-pkg io, func ReadAll(Reader) ([]uint8, error)
-pkg io, type ReadSeekCloser interface { Close, Read, Seek }
-pkg io, type ReadSeekCloser interface, Close() error
-pkg io, type ReadSeekCloser interface, Read([]uint8) (int, error)
-pkg io, type ReadSeekCloser interface, Seek(int64, int) (int64, error)
-pkg io, var Discard Writer
-pkg io/fs, const ModeAppend = 1073741824
-pkg io/fs, const ModeAppend FileMode
-pkg io/fs, const ModeCharDevice = 2097152
-pkg io/fs, const ModeCharDevice FileMode
-pkg io/fs, const ModeDevice = 67108864
-pkg io/fs, const ModeDevice FileMode
-pkg io/fs, const ModeDir = 2147483648
-pkg io/fs, const ModeDir FileMode
-pkg io/fs, const ModeExclusive = 536870912
-pkg io/fs, const ModeExclusive FileMode
-pkg io/fs, const ModeIrregular = 524288
-pkg io/fs, const ModeIrregular FileMode
-pkg io/fs, const ModeNamedPipe = 33554432
-pkg io/fs, const ModeNamedPipe FileMode
-pkg io/fs, const ModePerm = 511
-pkg io/fs, const ModePerm FileMode
-pkg io/fs, const ModeSetgid = 4194304
-pkg io/fs, const ModeSetgid FileMode
-pkg io/fs, const ModeSetuid = 8388608
-pkg io/fs, const ModeSetuid FileMode
-pkg io/fs, const ModeSocket = 16777216
-pkg io/fs, const ModeSocket FileMode
-pkg io/fs, const ModeSticky = 1048576
-pkg io/fs, const ModeSticky FileMode
-pkg io/fs, const ModeSymlink = 134217728
-pkg io/fs, const ModeSymlink FileMode
-pkg io/fs, const ModeTemporary = 268435456
-pkg io/fs, const ModeTemporary FileMode
-pkg io/fs, const ModeType = 2401763328
-pkg io/fs, const ModeType FileMode
-pkg io/fs, func Glob(FS, string) ([]string, error)
-pkg io/fs, func ReadDir(FS, string) ([]DirEntry, error)
-pkg io/fs, func ReadFile(FS, string) ([]uint8, error)
-pkg io/fs, func Stat(FS, string) (FileInfo, error)
-pkg io/fs, func ValidPath(string) bool
-pkg io/fs, method (*PathError) Error() string
-pkg io/fs, method (*PathError) Timeout() bool
-pkg io/fs, method (*PathError) Unwrap() error
-pkg io/fs, method (FileMode) IsDir() bool
-pkg io/fs, method (FileMode) IsRegular() bool
-pkg io/fs, method (FileMode) Perm() FileMode
-pkg io/fs, method (FileMode) String() string
-pkg io/fs, method (FileMode) Type() FileMode
-pkg io/fs, type DirEntry interface { Info, IsDir, Name, Type }
-pkg io/fs, type DirEntry interface, Info() (FileInfo, error)
-pkg io/fs, type DirEntry interface, IsDir() bool
-pkg io/fs, type DirEntry interface, Name() string
-pkg io/fs, type DirEntry interface, Type() FileMode
-pkg io/fs, type FS interface { Open }
-pkg io/fs, type FS interface, Open(string) (File, error)
-pkg io/fs, type File interface { Close, Read, Stat }
-pkg io/fs, type File interface, Close() error
-pkg io/fs, type File interface, Read([]uint8) (int, error)
-pkg io/fs, type File interface, Stat() (FileInfo, error)
-pkg io/fs, type FileInfo interface { IsDir, ModTime, Mode, Name, Size, Sys }
-pkg io/fs, type FileInfo interface, IsDir() bool
-pkg io/fs, type FileInfo interface, ModTime() time.Time
-pkg io/fs, type FileInfo interface, Mode() FileMode
-pkg io/fs, type FileInfo interface, Name() string
-pkg io/fs, type FileInfo interface, Size() int64
-pkg io/fs, type FileInfo interface, Sys() interface{}
-pkg io/fs, type FileMode uint32
-pkg io/fs, type GlobFS interface { Glob, Open }
-pkg io/fs, type GlobFS interface, Glob(string) ([]string, error)
-pkg io/fs, type GlobFS interface, Open(string) (File, error)
-pkg io/fs, type PathError struct
-pkg io/fs, type PathError struct, Err error
-pkg io/fs, type PathError struct, Op string
-pkg io/fs, type PathError struct, Path string
-pkg io/fs, type ReadDirFS interface { Open, ReadDir }
-pkg io/fs, type ReadDirFS interface, Open(string) (File, error)
-pkg io/fs, type ReadDirFS interface, ReadDir(string) ([]DirEntry, error)
-pkg io/fs, type ReadDirFile interface { Close, Read, ReadDir, Stat }
-pkg io/fs, type ReadDirFile interface, Close() error
-pkg io/fs, type ReadDirFile interface, Read([]uint8) (int, error)
-pkg io/fs, type ReadDirFile interface, ReadDir(int) ([]DirEntry, error)
-pkg io/fs, type ReadDirFile interface, Stat() (FileInfo, error)
-pkg io/fs, type ReadFileFS interface { Open, ReadFile }
-pkg io/fs, type ReadFileFS interface, Open(string) (File, error)
-pkg io/fs, type ReadFileFS interface, ReadFile(string) ([]uint8, error)
-pkg io/fs, type StatFS interface { Open, Stat }
-pkg io/fs, type StatFS interface, Open(string) (File, error)
-pkg io/fs, type StatFS interface, Stat(string) (FileInfo, error)
-pkg io/fs, var ErrClosed error
-pkg io/fs, var ErrExist error
-pkg io/fs, var ErrInvalid error
-pkg io/fs, var ErrNotExist error
-pkg io/fs, var ErrPermission error
-pkg log, func Default() *Logger
-pkg net, var ErrClosed error
-pkg net/http, func FS(fs.FS) FileSystem
-pkg net/http, type Transport struct, GetProxyConnectHeader func(context.Context, *url.URL, string) (Header, error)
-pkg os, const ModeAppend fs.FileMode
-pkg os, const ModeCharDevice fs.FileMode
-pkg os, const ModeDevice fs.FileMode
-pkg os, const ModeDir fs.FileMode
-pkg os, const ModeExclusive fs.FileMode
-pkg os, const ModeIrregular fs.FileMode
-pkg os, const ModeNamedPipe fs.FileMode
-pkg os, const ModePerm fs.FileMode
-pkg os, const ModeSetgid fs.FileMode
-pkg os, const ModeSetuid fs.FileMode
-pkg os, const ModeSocket fs.FileMode
-pkg os, const ModeSticky fs.FileMode
-pkg os, const ModeSymlink fs.FileMode
-pkg os, const ModeTemporary fs.FileMode
-pkg os, const ModeType fs.FileMode
-pkg os, func Chmod(string, fs.FileMode) error
-pkg os, func DirFS(string) fs.FS
-pkg os, func Lstat(string) (fs.FileInfo, error)
-pkg os, func Mkdir(string, fs.FileMode) error
-pkg os, func MkdirAll(string, fs.FileMode) error
-pkg os, func OpenFile(string, int, fs.FileMode) (*File, error)
-pkg os, func SameFile(fs.FileInfo, fs.FileInfo) bool
-pkg os, func Stat(string) (fs.FileInfo, error)
-pkg os, method (*File) Chmod(fs.FileMode) error
-pkg os, method (*File) ReadDir(int) ([]fs.DirEntry, error)
-pkg os, method (*File) Readdir(int) ([]fs.FileInfo, error)
-pkg os, method (*File) Stat() (fs.FileInfo, error)
-pkg os, type DirEntry = fs.DirEntry
-pkg os, type FileInfo = fs.FileInfo
-pkg os, type FileMode = fs.FileMode
-pkg os, type PathError = fs.PathError
-pkg os/signal, func NotifyContext(context.Context, ...os.Signal) (context.Context, context.CancelFunc)
-pkg runtime/metrics, const KindBad = 0
-pkg runtime/metrics, const KindBad ValueKind
-pkg runtime/metrics, const KindFloat64 = 2
-pkg runtime/metrics, const KindFloat64 ValueKind
-pkg runtime/metrics, const KindFloat64Histogram = 3
-pkg runtime/metrics, const KindFloat64Histogram ValueKind
-pkg runtime/metrics, const KindUint64 = 1
-pkg runtime/metrics, const KindUint64 ValueKind
-pkg runtime/metrics, func All() []Description
-pkg runtime/metrics, func Read([]Sample)
-pkg runtime/metrics, method (Value) Float64() float64
-pkg runtime/metrics, method (Value) Float64Histogram() *Float64Histogram
-pkg runtime/metrics, method (Value) Kind() ValueKind
-pkg runtime/metrics, method (Value) Uint64() uint64
-pkg runtime/metrics, type Description struct
-pkg runtime/metrics, type Description struct, Cumulative bool
-pkg runtime/metrics, type Description struct, Description string
-pkg runtime/metrics, type Description struct, Kind ValueKind
-pkg runtime/metrics, type Description struct, Name string
-pkg runtime/metrics, type Description struct, StopTheWorld bool
-pkg runtime/metrics, type Float64Histogram struct
-pkg runtime/metrics, type Float64Histogram struct, Buckets []float64
-pkg runtime/metrics, type Float64Histogram struct, Counts []uint64
-pkg runtime/metrics, type Sample struct
-pkg runtime/metrics, type Sample struct, Name string
-pkg runtime/metrics, type Sample struct, Value Value
-pkg runtime/metrics, type Value struct
-pkg runtime/metrics, type ValueKind int
-pkg syscall (linux-386), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-386), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-386), func Setegid(int) error
-pkg syscall (linux-386), func Seteuid(int) error
-pkg syscall (linux-386-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-386-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-386-cgo), func Setegid(int) error
-pkg syscall (linux-386-cgo), func Seteuid(int) error
-pkg syscall (linux-amd64), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-amd64), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-amd64), func Setegid(int) error
-pkg syscall (linux-amd64), func Seteuid(int) error
-pkg syscall (linux-amd64-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-amd64-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-amd64-cgo), func Setegid(int) error
-pkg syscall (linux-amd64-cgo), func Seteuid(int) error
-pkg syscall (linux-arm), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-arm), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-arm), func Setegid(int) error
-pkg syscall (linux-arm), func Seteuid(int) error
-pkg syscall (linux-arm-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-arm-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (linux-arm-cgo), func Setegid(int) error
-pkg syscall (linux-arm-cgo), func Seteuid(int) error
-pkg syscall (windows-386), func RtlGenRandom(*uint8, uint32) error
-pkg syscall (windows-amd64), func RtlGenRandom(*uint8, uint32) error
 pkg testing, func Fuzz(func(*F)) FuzzResult
 pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalFuzzTarget, []InternalExample) *M
 pkg testing, func RunFuzzTargets(func(string, string) (bool, error), []InternalFuzzTarget) bool
@@ -448,38 +31,3 @@ pkg testing, type FuzzResult struct, T time.Duration
 pkg testing, type InternalFuzzTarget struct
 pkg testing, type InternalFuzzTarget struct, Fn func(*F)
 pkg testing, type InternalFuzzTarget struct, Name string
-pkg testing/fstest, func TestFS(fs.FS, ...string) error
-pkg testing/fstest, method (MapFS) Glob(string) ([]string, error)
-pkg testing/fstest, method (MapFS) Open(string) (fs.File, error)
-pkg testing/fstest, method (MapFS) ReadDir(string) ([]fs.DirEntry, error)
-pkg testing/fstest, method (MapFS) ReadFile(string) ([]uint8, error)
-pkg testing/fstest, method (MapFS) Stat(string) (fs.FileInfo, error)
-pkg testing/fstest, type MapFS map[string]*MapFile
-pkg testing/fstest, type MapFile struct
-pkg testing/fstest, type MapFile struct, Data []uint8
-pkg testing/fstest, type MapFile struct, ModTime time.Time
-pkg testing/fstest, type MapFile struct, Mode fs.FileMode
-pkg testing/fstest, type MapFile struct, Sys interface{}
-pkg testing/iotest, func ErrReader(error) io.Reader
-pkg testing/iotest, func TestReader(io.Reader, []uint8) error
-pkg text/template, func ParseFS(fs.FS, ...string) (*Template, error)
-pkg text/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
-pkg text/template/parse, const NodeComment = 20
-pkg text/template/parse, const NodeComment NodeType
-pkg text/template/parse, const ParseComments = 1
-pkg text/template/parse, const ParseComments Mode
-pkg text/template/parse, method (*CommentNode) Copy() Node
-pkg text/template/parse, method (*CommentNode) String() string
-pkg text/template/parse, method (CommentNode) Position() Pos
-pkg text/template/parse, method (CommentNode) Type() NodeType
-pkg text/template/parse, type CommentNode struct
-pkg text/template/parse, type CommentNode struct, Text string
-pkg text/template/parse, type CommentNode struct, embedded NodeType
-pkg text/template/parse, type CommentNode struct, embedded Pos
-pkg text/template/parse, type Mode uint
-pkg text/template/parse, type Tree struct, Mode Mode
-pkg unicode, const Version = "13.0.0"
-pkg unicode, var Chorasmian *RangeTable
-pkg unicode, var Dives_Akuru *RangeTable
-pkg unicode, var Khitan_Small_Script *RangeTable
-pkg unicode, var Yezidi *RangeTable

diff --git a/doc/articles/go_command.html b/doc/articles/go_command.html
deleted file mode 100644 (file)
index 5b6fd4d..0000000
--- a/doc/articles/go_command.html
+++ /dev/null
@@ -1,254 +0,0 @@
-<!--{
-       "title": "About the go command"
-}-->
-
-<p>The Go distribution includes a command, named
-"<code><a href="/cmd/go/">go</a></code>", that
-automates the downloading, building, installation, and testing of Go packages
-and commands.  This document talks about why we wrote a new command, what it
-is, what it's not, and how to use it.</p>
-
-<h2>Motivation</h2>
-
-<p>You might have seen early Go talks in which Rob Pike jokes that the idea
-for Go arose while waiting for a large Google server to compile.  That
-really was the motivation for Go: to build a language that worked well
-for building the large software that Google writes and runs. It was
-clear from the start that such a language must provide a way to
-express dependencies between code libraries clearly, hence the package
-grouping and the explicit import blocks.  It was also clear from the
-start that you might want arbitrary syntax for describing the code
-being imported; this is why import paths are string literals.</p>
-
-<p>An explicit goal for Go from the beginning was to be able to build Go
-code using only the information found in the source itself, not
-needing to write a makefile or one of the many modern replacements for
-makefiles.  If Go needed a configuration file to explain how to build
-your program, then Go would have failed.</p>
-
-<p>At first, there was no Go compiler, and the initial development
-focused on building one and then building libraries for it. For
-expedience, we postponed the automation of building Go code by using
-make and writing makefiles.  When compiling a single package involved
-multiple invocations of the Go compiler, we even used a program to
-write the makefiles for us.  You can find it if you dig through the
-repository history.</p>
-
-<p>The purpose of the new go command is our return to this ideal, that Go
-programs should compile without configuration or additional effort on
-the part of the developer beyond writing the necessary import
-statements.</p>
-
-<h2>Configuration versus convention</h2>
-
-<p>The way to achieve the simplicity of a configuration-free system is to
-establish conventions. The system works only to the extent that those conventions
-are followed. When we first launched Go, many people published packages that
-had to be installed in certain places, under certain names, using certain build
-tools, in order to be used. That's understandable: that's the way it works in
-most other languages. Over the last few years we consistently reminded people
-about the <code>goinstall</code> command
-(now replaced by <a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies"><code>go get</code></a>)
-and its conventions: first, that the import path is derived in a known way from
-the URL of the source code; second, that the place to store the sources in
-the local file system is derived in a known way from the import path; third,
-that each directory in a source tree corresponds to a single package; and
-fourth, that the package is built using only information in the source code.
-Today, the vast majority of packages follow these conventions.
-The Go ecosystem is simpler and more powerful as a result.</p>
-
-<p>We received many requests to allow a makefile in a package directory to
-provide just a little extra configuration beyond what's in the source code.
-But that would have introduced new rules. Because we did not accede to such
-requests, we were able to write the go command and eliminate our use of make
-or any other build system.</p>
-
-<p>It is important to understand that the go command is not a general
-build tool. It cannot be configured and it does not attempt to build
-anything but Go packages.  These are important simplifying
-assumptions: they simplify not only the implementation but also, more
-important, the use of the tool itself.</p>
-
-<h2>Go's conventions</h2>
-
-<p>The <code>go</code> command requires that code adheres to a few key,
-well-established conventions.</p>
-
-<p>First, the import path is derived in a known way from the URL of the
-source code.  For Bitbucket, GitHub, Google Code, and Launchpad, the
-root directory of the repository is identified by the repository's
-main URL, without the <code>http://</code> prefix.  Subdirectories are named by
-adding to that path.
-For example, the Go example programs are obtained by running</p>
-
-<pre>
-git clone https://github.com/golang/example
-</pre>
-
-<p>and thus the import path for the root directory of that repository is
-"<code>github.com/golang/example</code>".
-The <a href="https://godoc.org/github.com/golang/example/stringutil">stringutil</a>
-package is stored in a subdirectory, so its import path is
-"<code>github.com/golang/example/stringutil</code>".</p>
-
-<p>These paths are on the long side, but in exchange we get an
-automatically managed name space for import paths and the ability for
-a tool like the go command to look at an unfamiliar import path and
-deduce where to obtain the source code.</p>
-
-<p>Second, the place to store sources in the local file system is derived
-in a known way from the import path, specifically
-<code>$GOPATH/src/&lt;import-path&gt;</code>.
-If unset, <code>$GOPATH</code> defaults to a subdirectory
-named <code>go</code> in the user's home directory.
-If <code>$GOPATH</code> is set to a list of paths, the go command tries
-<code>&lt;dir&gt;/src/&lt;import-path&gt;</code> for each of the directories in
-that list.
-</p>
-
-<p>Each of those trees contains, by convention, a top-level directory named
-"<code>bin</code>", for holding compiled executables, and a top-level directory
-named "<code>pkg</code>", for holding compiled packages that can be imported,
-and the "<code>src</code>" directory, for holding package source files.
-Imposing this structure lets us keep each of these directory trees
-self-contained: the compiled form and the sources are always near each
-other.</p>
-
-<p>These naming conventions also let us work in the reverse direction,
-from a directory name to its import path. This mapping is important
-for many of the go command's subcommands, as we'll see below.</p>
-
-<p>Third, each directory in a source tree corresponds to a single
-package. By restricting a directory to a single package, we don't have
-to create hybrid import paths that specify first the directory and
-then the package within that directory.  Also, most file management
-tools and UIs work on  directories as fundamental units.  Tying the
-fundamental Go unit&mdash;the package&mdash;to file system structure means
-that file system tools become Go package tools.  Copying, moving, or
-deleting a package corresponds to copying, moving, or deleting a
-directory.</p>
-
-<p>Fourth, each package is built using only the information present in
-the source files.  This makes it much more likely that the tool will
-be able to adapt to changing build environments and conditions. For
-example, if we allowed extra configuration such as compiler flags or
-command line recipes, then that configuration would need to be updated
-each time the build tools changed; it would also be inherently tied
-to the use of a specific toolchain.</p>
-
-<h2>Getting started with the go command</h2>
-
-<p>Finally, a quick tour of how to use the go command.
-As mentioned above, the default <code>$GOPATH</code> on Unix is <code>$HOME/go</code>.
-We'll store our programs there.
-To use a different location, you can set <code>$GOPATH</code>;
-see <a href="/doc/code.html">How to Write Go Code</a> for details.
-
-<p>We first add some source code.  Suppose we want to use
-the indexing library from the codesearch project along with a left-leaning
-red-black tree.  We can install both with the "<code>go get</code>"
-subcommand:</p>
-
-<pre>
-$ go get github.com/google/codesearch/index
-$ go get github.com/petar/GoLLRB/llrb
-$
-</pre>
-
-<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
-which contains the two directories
-<code>src/github.com/google/codesearch/index/</code> and
-<code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
-packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>
-
-<p>Because we used version control systems (Mercurial and Git) to check
-out the sources, the source tree also contains the other files in the
-corresponding repositories, such as related packages. The "<code>go list</code>"
-subcommand lists the import paths corresponding to its arguments, and
-the pattern "<code>./...</code>" means start in the current directory
-("<code>./</code>") and find all packages below that directory
-("<code>...</code>"):</p>
-
-<pre>
-$ cd $HOME/go/src
-$ go list ./...
-github.com/google/codesearch/cmd/cgrep
-github.com/google/codesearch/cmd/cindex
-github.com/google/codesearch/cmd/csearch
-github.com/google/codesearch/index
-github.com/google/codesearch/regexp
-github.com/google/codesearch/sparse
-github.com/petar/GoLLRB/example
-github.com/petar/GoLLRB/llrb
-$
-</pre>
-
-<p>We can also test those packages:</p>
-
-<pre>
-$ go test ./...
-?      github.com/google/codesearch/cmd/cgrep  [no test files]
-?      github.com/google/codesearch/cmd/cindex [no test files]
-?      github.com/google/codesearch/cmd/csearch        [no test files]
-ok     github.com/google/codesearch/index      0.203s
-ok     github.com/google/codesearch/regexp     0.017s
-?      github.com/google/codesearch/sparse     [no test files]
-?       github.com/petar/GoLLRB/example          [no test files]
-ok      github.com/petar/GoLLRB/llrb             0.231s
-$
-</pre>
-
-<p>If a go subcommand is invoked with no paths listed, it operates on the
-current directory:</p>
-
-<pre>
-$ cd github.com/google/codesearch/regexp
-$ go list
-github.com/google/codesearch/regexp
-$ go test -v
-=== RUN   TestNstateEnc
---- PASS: TestNstateEnc (0.00s)
-=== RUN   TestMatch
---- PASS: TestMatch (0.00s)
-=== RUN   TestGrep
---- PASS: TestGrep (0.00s)
-PASS
-ok     github.com/google/codesearch/regexp     0.018s
-$ go install
-$
-</pre>
-
-<p>That "<code>go install</code>" subcommand installs the latest copy of the
-package into the pkg directory. Because the go command can analyze the
-dependency graph, "<code>go install</code>" also installs any packages that
-this package imports but that are out of date, recursively.</p>
-
-<p>Notice that "<code>go install</code>" was able to determine the name of the
-import path for the package in the current directory, because of the convention
-for directory naming.  It would be a little more convenient if we could pick
-the name of the directory where we kept source code, and we probably wouldn't
-pick such a long name, but that ability would require additional configuration
-and complexity in the tool. Typing an extra directory name or two is a small
-price to pay for the increased simplicity and power.</p>
-
-<h2>Limitations</h2>
-
-<p>As mentioned above, the go command is not a general-purpose build
-tool.
-In particular, it does not have any facility for generating Go
-source files <em>during</em> a build, although it does provide
-<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
-<code>generate</code></a>,
-which can automate the creation of Go files <em>before</em> the build.
-For more advanced build setups, you may need to write a
-makefile (or a configuration file for the build tool of your choice)
-to run whatever tool creates the Go files and then check those generated source files
-into your repository. This is more work for you, the package author,
-but it is significantly less work for your users, who can use
-"<code>go get</code>" without needing to obtain and build
-any additional tools.</p>
-
-<h2>More information</h2>
-
-<p>For more information, read <a href="/doc/code.html">How to Write Go Code</a>
-and see the <a href="/cmd/go/">go command documentation</a>.</p>

diff --git a/doc/articles/index.html b/doc/articles/index.html
deleted file mode 100644 (file)
index 9ddd669..0000000
--- a/doc/articles/index.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<!--{
-       "Title": "/doc/articles/"
-}-->
-
-<p>
-See the <a href="/doc/#articles">Documents page</a> and the
-<a href="/blog/index">Blog index</a> for a complete list of Go articles.
-</p>

diff --git a/doc/articles/race_detector.html b/doc/articles/race_detector.html
deleted file mode 100644 (file)
index 09188c1..0000000
--- a/doc/articles/race_detector.html
+++ /dev/null
@@ -1,440 +0,0 @@
-<!--{
-       "Title": "Data Race Detector",
-       "Template": true
-}-->
-
-<h2 id="Introduction">Introduction</h2>
-
-<p>
-Data races are among the most common and hardest to debug types of bugs in concurrent systems.
-A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.
-See the <a href="/ref/mem/">The Go Memory Model</a> for details.
-</p>
-
-<p>
-Here is an example of a data race that can lead to crashes and memory corruption:
-</p>
-
-<pre>
-func main() {
-       c := make(chan bool)
-       m := make(map[string]string)
-       go func() {
-               m["1"] = "a" // First conflicting access.
-               c &lt;- true
-       }()
-       m["2"] = "b" // Second conflicting access.
-       &lt;-c
-       for k, v := range m {
-               fmt.Println(k, v)
-       }
-}
-</pre>
-
-<h2 id="Usage">Usage</h2>
-
-<p>
-To help diagnose such bugs, Go includes a built-in data race detector.
-To use it, add the <code>-race</code> flag to the go command:
-</p>
-
-<pre>
-$ go test -race mypkg    // to test the package
-$ go run -race mysrc.go  // to run the source file
-$ go build -race mycmd   // to build the command
-$ go install -race mypkg // to install the package
-</pre>
-
-<h2 id="Report_Format">Report Format</h2>
-
-<p>
-When the race detector finds a data race in the program, it prints a report.
-The report contains stack traces for conflicting accesses, as well as stacks where the involved goroutines were created.
-Here is an example:
-</p>
-
-<pre>
-WARNING: DATA RACE
-Read by goroutine 185:
-  net.(*pollServer).AddFD()
-      src/net/fd_unix.go:89 +0x398
-  net.(*pollServer).WaitWrite()
-      src/net/fd_unix.go:247 +0x45
-  net.(*netFD).Write()
-      src/net/fd_unix.go:540 +0x4d4
-  net.(*conn).Write()
-      src/net/net.go:129 +0x101
-  net.func·060()
-      src/net/timeout_test.go:603 +0xaf
-
-Previous write by goroutine 184:
-  net.setWriteDeadline()
-      src/net/sockopt_posix.go:135 +0xdf
-  net.setDeadline()
-      src/net/sockopt_posix.go:144 +0x9c
-  net.(*conn).SetDeadline()
-      src/net/net.go:161 +0xe3
-  net.func·061()
-      src/net/timeout_test.go:616 +0x3ed
-
-Goroutine 185 (running) created at:
-  net.func·061()
-      src/net/timeout_test.go:609 +0x288
-
-Goroutine 184 (running) created at:
-  net.TestProlongTimeout()
-      src/net/timeout_test.go:618 +0x298
-  testing.tRunner()
-      src/testing/testing.go:301 +0xe8
-</pre>
-
-<h2 id="Options">Options</h2>
-
-<p>
-The <code>GORACE</code> environment variable sets race detector options.
-The format is:
-</p>
-
-<pre>
-GORACE="option1=val1 option2=val2"
-</pre>
-
-<p>
-The options are:
-</p>
-
-<ul>
-<li>
-<code>log_path</code> (default <code>stderr</code>): The race detector writes
-its report to a file named <code>log_path.<em>pid</em></code>.
-The special names <code>stdout</code>
-and <code>stderr</code> cause reports to be written to standard output and
-standard error, respectively.
-</li>
-
-<li>
-<code>exitcode</code> (default <code>66</code>): The exit status to use when
-exiting after a detected race.
-</li>
-
-<li>
-<code>strip_path_prefix</code> (default <code>""</code>): Strip this prefix
-from all reported file paths, to make reports more concise.
-</li>
-
-<li>
-<code>history_size</code> (default <code>1</code>): The per-goroutine memory
-access history is <code>32K * 2**history_size elements</code>.
-Increasing this value can avoid a "failed to restore the stack" error in reports, at the
-cost of increased memory usage.
-</li>
-
-<li>
-<code>halt_on_error</code> (default <code>0</code>): Controls whether the program
-exits after reporting first data race.
-</li>
-
-<li>
-<code>atexit_sleep_ms</code> (default <code>1000</code>): Amount of milliseconds
-to sleep in the main goroutine before exiting.
-</li>
-</ul>
-
-<p>
-Example:
-</p>
-
-<pre>
-$ GORACE="log_path=/tmp/race/report strip_path_prefix=/my/go/sources/" go test -race
-</pre>
-
-<h2 id="Excluding_Tests">Excluding Tests</h2>
-
-<p>
-When you build with <code>-race</code> flag, the <code>go</code> command defines additional
-<a href="/pkg/go/build/#hdr-Build_Constraints">build tag</a> <code>race</code>.
-You can use the tag to exclude some code and tests when running the race detector.
-Some examples:
-</p>
-
-<pre>
-// +build !race
-
-package foo
-
-// The test contains a data race. See issue 123.
-func TestFoo(t *testing.T) {
-       // ...
-}
-
-// The test fails under the race detector due to timeouts.
-func TestBar(t *testing.T) {
-       // ...
-}
-
-// The test takes too long under the race detector.
-func TestBaz(t *testing.T) {
-       // ...
-}
-</pre>
-
-<h2 id="How_To_Use">How To Use</h2>
-
-<p>
-To start, run your tests using the race detector (<code>go test -race</code>).
-The race detector only finds races that happen at runtime, so it can't find
-races in code paths that are not executed.
-If your tests have incomplete coverage,
-you may find more races by running a binary built with <code>-race</code> under a realistic
-workload.
-</p>
-
-<h2 id="Typical_Data_Races">Typical Data Races</h2>
-
-<p>
-Here are some typical data races.  All of them can be detected with the race detector.
-</p>
-
-<h3 id="Race_on_loop_counter">Race on loop counter</h3>
-
-<pre>
-func main() {
-       var wg sync.WaitGroup
-       wg.Add(5)
-       for i := 0; i < 5; i++ {
-               go func() {
-                       fmt.Println(i) // Not the 'i' you are looking for.
-                       wg.Done()
-               }()
-       }
-       wg.Wait()
-}
-</pre>
-
-<p>
-The variable <code>i</code> in the function literal is the same variable used by the loop, so
-the read in the goroutine races with the loop increment.
-(This program typically prints 55555, not 01234.)
-The program can be fixed by making a copy of the variable:
-</p>
-
-<pre>
-func main() {
-       var wg sync.WaitGroup
-       wg.Add(5)
-       for i := 0; i < 5; i++ {
-               go func(j int) {
-                       fmt.Println(j) // Good. Read local copy of the loop counter.
-                       wg.Done()
-               }(i)
-       }
-       wg.Wait()
-}
-</pre>
-
-<h3 id="Accidentally_shared_variable">Accidentally shared variable</h3>
-
-<pre>
-// ParallelWrite writes data to file1 and file2, returns the errors.
-func ParallelWrite(data []byte) chan error {
-       res := make(chan error, 2)
-       f1, err := os.Create("file1")
-       if err != nil {
-               res &lt;- err
-       } else {
-               go func() {
-                       // This err is shared with the main goroutine,
-                       // so the write races with the write below.
-                       _, err = f1.Write(data)
-                       res &lt;- err
-                       f1.Close()
-               }()
-       }
-       f2, err := os.Create("file2") // The second conflicting write to err.
-       if err != nil {
-               res &lt;- err
-       } else {
-               go func() {
-                       _, err = f2.Write(data)
-                       res &lt;- err
-                       f2.Close()
-               }()
-       }
-       return res
-}
-</pre>
-
-<p>
-The fix is to introduce new variables in the goroutines (note the use of <code>:=</code>):
-</p>
-
-<pre>
-                       ...
-                       _, err := f1.Write(data)
-                       ...
-                       _, err := f2.Write(data)
-                       ...
-</pre>
-
-<h3 id="Unprotected_global_variable">Unprotected global variable</h3>
-
-<p>
-If the following code is called from several goroutines, it leads to races on the <code>service</code> map.
-Concurrent reads and writes of the same map are not safe:
-</p>
-
-<pre>
-var service map[string]net.Addr
-
-func RegisterService(name string, addr net.Addr) {
-       service[name] = addr
-}
-
-func LookupService(name string) net.Addr {
-       return service[name]
-}
-</pre>
-
-<p>
-To make the code safe, protect the accesses with a mutex:
-</p>
-
-<pre>
-var (
-       service   map[string]net.Addr
-       serviceMu sync.Mutex
-)
-
-func RegisterService(name string, addr net.Addr) {
-       serviceMu.Lock()
-       defer serviceMu.Unlock()
-       service[name] = addr
-}
-
-func LookupService(name string) net.Addr {
-       serviceMu.Lock()
-       defer serviceMu.Unlock()
-       return service[name]
-}
-</pre>
-
-<h3 id="Primitive_unprotected_variable">Primitive unprotected variable</h3>
-
-<p>
-Data races can happen on variables of primitive types as well (<code>bool</code>, <code>int</code>, <code>int64</code>, etc.),
-as in this example:
-</p>
-
-<pre>
-type Watchdog struct{ last int64 }
-
-func (w *Watchdog) KeepAlive() {
-       w.last = time.Now().UnixNano() // First conflicting access.
-}
-
-func (w *Watchdog) Start() {
-       go func() {
-               for {
-                       time.Sleep(time.Second)
-                       // Second conflicting access.
-                       if w.last < time.Now().Add(-10*time.Second).UnixNano() {
-                               fmt.Println("No keepalives for 10 seconds. Dying.")
-                               os.Exit(1)
-                       }
-               }
-       }()
-}
-</pre>
-
-<p>
-Even such "innocent" data races can lead to hard-to-debug problems caused by
-non-atomicity of the memory accesses,
-interference with compiler optimizations,
-or reordering issues accessing processor memory .
-</p>
-
-<p>
-A typical fix for this race is to use a channel or a mutex.
-To preserve the lock-free behavior, one can also use the
-<a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package.
-</p>
-
-<pre>
-type Watchdog struct{ last int64 }
-
-func (w *Watchdog) KeepAlive() {
-       atomic.StoreInt64(&amp;w.last, time.Now().UnixNano())
-}
-
-func (w *Watchdog) Start() {
-       go func() {
-               for {
-                       time.Sleep(time.Second)
-                       if atomic.LoadInt64(&amp;w.last) < time.Now().Add(-10*time.Second).UnixNano() {
-                               fmt.Println("No keepalives for 10 seconds. Dying.")
-                               os.Exit(1)
-                       }
-               }
-       }()
-}
-</pre>
-
-<h3 id="Unsynchronized_send_and_close_operations">Unsynchronized send and close operations</h3>
-
-<p>
-As this example demonstrates, unsynchronized send and close operations
-on the same channel can also be a race condition:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-// The race detector cannot derive the happens before relation
-// for the following send and close operations. These two operations
-// are unsynchronized and happen concurrently.
-go func() { c <- struct{}{} }()
-close(c)
-</pre>
-
-<p>
-According to the Go memory model, a send on a channel happens before
-the corresponding receive from that channel completes. To synchronize
-send and close operations, use a receive operation that guarantees
-the send is done before the close:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-go func() { c <- struct{}{} }()
-<-c
-close(c)
-</pre>
-
-<h2 id="Supported_Systems">Supported Systems</h2>
-
-<p>
-  The race detector runs on
-  <code>linux/amd64</code>, <code>linux/ppc64le</code>,
-  <code>linux/arm64</code>, <code>freebsd/amd64</code>,
-  <code>netbsd/amd64</code>, <code>darwin/amd64</code>,
-  <code>darwin/arm64</code>, and <code>windows/amd64</code>.
-</p>
-
-<h2 id="Runtime_Overheads">Runtime Overhead</h2>
-
-<p>
-The cost of race detection varies by program, but for a typical program, memory
-usage may increase by 5-10x and execution time by 2-20x.
-</p>
-
-<p>
-The race detector currently allocates an extra 8 bytes per <code>defer</code>
-and <code>recover</code> statement. Those extra allocations <a
-href="https://golang.org/issue/26813">are not recovered until the goroutine
-exits</a>. This means that if you have a long-running goroutine that is
-periodically issuing <code>defer</code> and <code>recover</code> calls,
-the program memory usage may grow without bound. These memory allocations
-will not show up in the output of <code>runtime.ReadMemStats</code> or
-<code>runtime/pprof</code>.
-</p>

diff --git a/doc/articles/wiki/edit.html b/doc/articles/wiki/edit.html
deleted file mode 100644 (file)
index 044c3be..0000000
--- a/doc/articles/wiki/edit.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<h1>Editing {{.Title}}</h1>
-
-<form action="/save/{{.Title}}" method="POST">
-<div><textarea name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea></div>
-<div><input type="submit" value="Save"></div>
-</form>

diff --git a/doc/articles/wiki/final-noclosure.go b/doc/articles/wiki/final-noclosure.go
deleted file mode 100644 (file)
index d894e7d..0000000
--- a/doc/articles/wiki/final-noclosure.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "errors"
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-       "regexp"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title, err := getTitle(w, r)
-       if err != nil {
-               return
-       }
-       p, err := loadPage(title)
-       if err != nil {
-               http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-               return
-       }
-       renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title, err := getTitle(w, r)
-       if err != nil {
-               return
-       }
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-       title, err := getTitle(w, r)
-       if err != nil {
-               return
-       }
-       body := r.FormValue("body")
-       p := &Page{Title: title, Body: []byte(body)}
-       err = p.save()
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       t, err := template.ParseFiles(tmpl + ".html")
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       err = t.Execute(w, p)
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-       }
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func getTitle(w http.ResponseWriter, r *http.Request) (string, error) {
-       m := validPath.FindStringSubmatch(r.URL.Path)
-       if m == nil {
-               http.NotFound(w, r)
-               return "", errors.New("invalid Page Title")
-       }
-       return m[2], nil // The title is the second subexpression.
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       http.HandleFunc("/save/", saveHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/final-noerror.go b/doc/articles/wiki/final-noerror.go
deleted file mode 100644 (file)
index 250236d..0000000
--- a/doc/articles/wiki/final-noerror.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/edit/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       t, _ := template.ParseFiles("edit.html")
-       t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, _ := loadPage(title)
-       t, _ := template.ParseFiles("view.html")
-       t.Execute(w, p)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/final-parsetemplate.go b/doc/articles/wiki/final-parsetemplate.go
deleted file mode 100644 (file)
index 0b90cbd..0000000
--- a/doc/articles/wiki/final-parsetemplate.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-       "regexp"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
-       p, err := loadPage(title)
-       if err != nil {
-               http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-               return
-       }
-       renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request, title string) {
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
-       body := r.FormValue("body")
-       p := &Page{Title: title, Body: []byte(body)}
-       err := p.save()
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       t, err := template.ParseFiles(tmpl + ".html")
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       err = t.Execute(w, p)
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-       }
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-       return func(w http.ResponseWriter, r *http.Request) {
-               m := validPath.FindStringSubmatch(r.URL.Path)
-               if m == nil {
-                       http.NotFound(w, r)
-                       return
-               }
-               fn(w, r, m[2])
-       }
-}
-
-func main() {
-       http.HandleFunc("/view/", makeHandler(viewHandler))
-       http.HandleFunc("/edit/", makeHandler(editHandler))
-       http.HandleFunc("/save/", makeHandler(saveHandler))
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/final-template.go b/doc/articles/wiki/final-template.go
deleted file mode 100644 (file)
index 5028664..0000000
--- a/doc/articles/wiki/final-template.go
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/edit/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, _ := loadPage(title)
-       renderTemplate(w, "view", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/save/"):]
-       body := r.FormValue("body")
-       p := &Page{Title: title, Body: []byte(body)}
-       p.save()
-       http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       t, _ := template.ParseFiles(tmpl + ".html")
-       t.Execute(w, p)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       http.HandleFunc("/save/", saveHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/final.go b/doc/articles/wiki/final.go
deleted file mode 100644 (file)
index b1439b0..0000000
--- a/doc/articles/wiki/final.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-       "regexp"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
-       p, err := loadPage(title)
-       if err != nil {
-               http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-               return
-       }
-       renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request, title string) {
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
-       body := r.FormValue("body")
-       p := &Page{Title: title, Body: []byte(body)}
-       err := p.save()
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-var templates = template.Must(template.ParseFiles("edit.html", "view.html"))
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       err := templates.ExecuteTemplate(w, tmpl+".html", p)
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-       }
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-       return func(w http.ResponseWriter, r *http.Request) {
-               m := validPath.FindStringSubmatch(r.URL.Path)
-               if m == nil {
-                       http.NotFound(w, r)
-                       return
-               }
-               fn(w, r, m[2])
-       }
-}
-
-func main() {
-       http.HandleFunc("/view/", makeHandler(viewHandler))
-       http.HandleFunc("/edit/", makeHandler(editHandler))
-       http.HandleFunc("/save/", makeHandler(saveHandler))
-
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/final_test.go b/doc/articles/wiki/final_test.go
deleted file mode 100644 (file)
index 7644699..0000000
--- a/doc/articles/wiki/final_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "log"
-       "net"
-       "net/http"
-)
-
-func serve() error {
-       l, err := net.Listen("tcp", "127.0.0.1:0")
-       if err != nil {
-               log.Fatal(err)
-       }
-       fmt.Println(l.Addr().String())
-       s := &http.Server{}
-       return s.Serve(l)
-}

diff --git a/doc/articles/wiki/go.mod b/doc/articles/wiki/go.mod
deleted file mode 100644 (file)
index 38153ed..0000000
--- a/doc/articles/wiki/go.mod
+++ /dev/null
@@ -1,3 +0,0 @@
-module doc/articles/wiki
-
-go 1.14

diff --git a/doc/articles/wiki/http-sample.go b/doc/articles/wiki/http-sample.go
deleted file mode 100644 (file)
index 803b88c..0000000
--- a/doc/articles/wiki/http-sample.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "log"
-       "net/http"
-)
-
-func handler(w http.ResponseWriter, r *http.Request) {
-       fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
-}
-
-func main() {
-       http.HandleFunc("/", handler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/index.html b/doc/articles/wiki/index.html
deleted file mode 100644 (file)
index a74a58e..0000000
--- a/doc/articles/wiki/index.html
+++ /dev/null
@@ -1,741 +0,0 @@
-<!--{
-       "Title": "Writing Web Applications",
-       "Template": true
-}-->
-
-<h2>Introduction</h2>
-
-<p>
-Covered in this tutorial:
-</p>
-<ul>
-<li>Creating a data structure with load and save methods</li>
-<li>Using the <code>net/http</code> package to build web applications
-<li>Using the <code>html/template</code> package to process HTML templates</li>
-<li>Using the <code>regexp</code> package to validate user input</li>
-<li>Using closures</li>
-</ul>
-
-<p>
-Assumed knowledge:
-</p>
-<ul>
-<li>Programming experience</li>
-<li>Understanding of basic web technologies (HTTP, HTML)</li>
-<li>Some UNIX/DOS command-line knowledge</li>
-</ul>
-
-<h2>Getting Started</h2>
-
-<p>
-At present, you need to have a FreeBSD, Linux, OS X, or Windows machine to run Go.
-We will use <code>$</code> to represent the command prompt.
-</p>
-
-<p>
-Install Go (see the <a href="/doc/install">Installation Instructions</a>).
-</p>
-
-<p>
-Make a new directory for this tutorial inside your <code>GOPATH</code> and cd to it:
-</p>
-
-<pre>
-$ mkdir gowiki
-$ cd gowiki
-</pre>
-
-<p>
-Create a file named <code>wiki.go</code>, open it in your favorite editor, and
-add the following lines:
-</p>
-
-<pre>
-package main
-
-import (
-       "fmt"
-       "io/ioutil"
-)
-</pre>
-
-<p>
-We import the <code>fmt</code> and <code>ioutil</code> packages from the Go
-standard library. Later, as we implement additional functionality, we will
-add more packages to this <code>import</code> declaration.
-</p>
-
-<h2>Data Structures</h2>
-
-<p>
-Let's start by defining the data structures. A wiki consists of a series of
-interconnected pages, each of which has a title and a body (the page content).
-Here, we define <code>Page</code> as a struct with two fields representing
-the title and body.
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^type Page/` `/}/`}}
-
-<p>
-The type <code>[]byte</code> means "a <code>byte</code> slice".
-(See <a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and
-internals</a> for more on slices.)
-The <code>Body</code> element is a <code>[]byte</code> rather than
-<code>string</code> because that is the type expected by the <code>io</code>
-libraries we will use, as you'll see below.
-</p>
-
-<p>
-The <code>Page</code> struct describes how page data will be stored in memory.
-But what about persistent storage? We can address that by creating a
-<code>save</code> method on <code>Page</code>:
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func.*Page.*save/` `/}/`}}
-
-<p>
-This method's signature reads: "This is a method named <code>save</code> that
-takes as its receiver <code>p</code>, a pointer to <code>Page</code> . It takes
-no parameters, and returns a value of type <code>error</code>."
-</p>
-
-<p>
-This method will save the <code>Page</code>'s <code>Body</code> to a text
-file. For simplicity, we will use the <code>Title</code> as the file name.
-</p>
-
-<p>
-The <code>save</code> method returns an <code>error</code> value because
-that is the return type of <code>WriteFile</code> (a standard library function
-that writes a byte slice to a file).  The <code>save</code> method returns the
-error value, to let the application handle it should anything go wrong while
-writing the file.  If all goes well, <code>Page.save()</code> will return
-<code>nil</code> (the zero-value for pointers, interfaces, and some other
-types).
-</p>
-
-<p>
-The octal integer literal <code>0600</code>, passed as the third parameter to
-<code>WriteFile</code>, indicates that the file should be created with
-read-write permissions for the current user only. (See the Unix man page
-<code>open(2)</code> for details.)
-</p>
-
-<p>
-In addition to saving pages, we will want to load pages, too:
-</p>
-
-{{code "doc/articles/wiki/part1-noerror.go" `/^func loadPage/` `/^}/`}}
-
-<p>
-The function <code>loadPage</code> constructs the file name from the title
-parameter, reads the file's contents into a new variable <code>body</code>, and
-returns a pointer to a <code>Page</code> literal constructed with the proper
-title and body values.
-</p>
-
-<p>
-Functions can return multiple values. The standard library function
-<code>io.ReadFile</code> returns <code>[]byte</code> and <code>error</code>.
-In <code>loadPage</code>, error isn't being handled yet; the "blank identifier"
-represented by the underscore (<code>_</code>) symbol is used to throw away the
-error return value (in essence, assigning the value to nothing).
-</p>
-
-<p>
-But what happens if <code>ReadFile</code> encounters an error?  For example,
-the file might not exist. We should not ignore such errors.  Let's modify the
-function to return <code>*Page</code> and <code>error</code>.
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func loadPage/` `/^}/`}}
-
-<p>
-Callers of this function can now check the second parameter; if it is
-<code>nil</code> then it has successfully loaded a Page. If not, it will be an
-<code>error</code> that can be handled by the caller (see the
-<a href="/ref/spec#Errors">language specification</a> for details).
-</p>
-
-<p>
-At this point we have a simple data structure and the ability to save to and
-load from a file. Let's write a <code>main</code> function to test what we've
-written:
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func main/` `/^}/`}}
-
-<p>
-After compiling and executing this code, a file named <code>TestPage.txt</code>
-would be created, containing the contents of <code>p1</code>. The file would
-then be read into the struct <code>p2</code>, and its <code>Body</code> element
-printed to the screen.
-</p>
-
-<p>
-You can compile and run the program like this:
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-This is a sample Page.
-</pre>
-
-<p>
-(If you're using Windows you must type "<code>wiki</code>" without the
-"<code>./</code>" to run the program.)
-</p>
-
-<p>
-<a href="part1.go">Click here to view the code we've written so far.</a>
-</p>
-
-<h2>Introducing the <code>net/http</code> package (an interlude)</h2>
-
-<p>
-Here's a full working example of a simple web server:
-</p>
-
-{{code "doc/articles/wiki/http-sample.go"}}
-
-<p>
-The <code>main</code> function begins with a call to
-<code>http.HandleFunc</code>, which tells the <code>http</code> package to
-handle all requests to the web root (<code>"/"</code>) with
-<code>handler</code>.
-</p>
-
-<p>
-It then calls <code>http.ListenAndServe</code>, specifying that it should
-listen on port 8080 on any interface (<code>":8080"</code>). (Don't
-worry about its second parameter, <code>nil</code>, for now.)
-This function will block until the program is terminated.
-</p>
-
-<p>
-<code>ListenAndServe</code> always returns an error, since it only returns when an
-unexpected error occurs.
-In order to log that error we wrap the function call with <code>log.Fatal</code>.
-</p>
-
-<p>
-The function <code>handler</code> is of the type <code>http.HandlerFunc</code>.
-It takes an <code>http.ResponseWriter</code> and an <code>http.Request</code> as
-its arguments.
-</p>
-
-<p>
-An <code>http.ResponseWriter</code> value assembles the HTTP server's response; by writing
-to it, we send data to the HTTP client.
-</p>
-
-<p>
-An <code>http.Request</code> is a data structure that represents the client
-HTTP request. <code>r.URL.Path</code> is the path component
-of the request URL. The trailing <code>[1:]</code> means
-"create a sub-slice of <code>Path</code> from the 1st character to the end."
-This drops the leading "/" from the path name.
-</p>
-
-<p>
-If you run this program and access the URL:
-</p>
-<pre>http://localhost:8080/monkeys</pre>
-<p>
-the program would present a page containing:
-</p>
-<pre>Hi there, I love monkeys!</pre>
-
-<h2>Using <code>net/http</code> to serve wiki pages</h2>
-
-<p>
-To use the <code>net/http</code> package, it must be imported:
-</p>
-
-<pre>
-import (
-       "fmt"
-       "io/ioutil"
-       "log"
-       <b>"net/http"</b>
-)
-</pre>
-
-<p>
-Let's create a handler, <code>viewHandler</code> that will allow users to
-view a wiki page. It will handle URLs prefixed with "/view/".
-</p>
-
-{{code "doc/articles/wiki/part2.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-Again, note the use of <code>_</code> to ignore the <code>error</code>
-return value from <code>loadPage</code>. This is done here for simplicity
-and generally considered bad practice. We will attend to this later.
-</p>
-
-<p>
-First, this function extracts the page title from <code>r.URL.Path</code>,
-the path component of the request URL.
-The <code>Path</code> is re-sliced with <code>[len("/view/"):]</code> to drop
-the leading <code>"/view/"</code> component of the request path.
-This is because the path will invariably begin with <code>"/view/"</code>,
-which is not part of the page's title.
-</p>
-
-<p>
-The function then loads the page data, formats the page with a string of simple
-HTML, and writes it to <code>w</code>, the <code>http.ResponseWriter</code>.
-</p>
-
-<p>
-To use this handler, we rewrite our <code>main</code> function to
-initialize <code>http</code> using the <code>viewHandler</code> to handle
-any requests under the path <code>/view/</code>.
-</p>
-
-{{code "doc/articles/wiki/part2.go" `/^func main/` `/^}/`}}
-
-<p>
-<a href="part2.go">Click here to view the code we've written so far.</a>
-</p>
-
-<p>
-Let's create some page data (as <code>test.txt</code>), compile our code, and
-try serving a wiki page.
-</p>
-
-<p>
-Open <code>test.txt</code> file in your editor, and save the string "Hello world" (without quotes)
-in it.
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-</pre>
-
-<p>
-(If you're using Windows you must type "<code>wiki</code>" without the
-"<code>./</code>" to run the program.)
-</p>
-
-<p>
-With this web server running, a visit to <code><a
-href="http://localhost:8080/view/test">http://localhost:8080/view/test</a></code>
-should show a page titled "test" containing the words "Hello world".
-</p>
-
-<h2>Editing Pages</h2>
-
-<p>
-A wiki is not a wiki without the ability to edit pages. Let's create two new
-handlers: one named <code>editHandler</code> to display an 'edit page' form,
-and the other named <code>saveHandler</code> to save the data entered via the
-form.
-</p>
-
-<p>
-First, we add them to <code>main()</code>:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^func main/` `/^}/`}}
-
-<p>
-The function <code>editHandler</code> loads the page
-(or, if it doesn't exist, create an empty <code>Page</code> struct),
-and displays an HTML form.
-</p>
-
-{{code "doc/articles/wiki/notemplate.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-This function will work fine, but all that hard-coded HTML is ugly.
-Of course, there is a better way.
-</p>
-
-<h2>The <code>html/template</code> package</h2>
-
-<p>
-The <code>html/template</code> package is part of the Go standard library.
-We can use <code>html/template</code> to keep the HTML in a separate file,
-allowing us to change the layout of our edit page without modifying the
-underlying Go code.
-</p>
-
-<p>
-First, we must add <code>html/template</code> to the list of imports. We
-also won't be using <code>fmt</code> anymore, so we have to remove that.
-</p>
-
-<pre>
-import (
-       <b>"html/template"</b>
-       "io/ioutil"
-       "net/http"
-)
-</pre>
-
-<p>
-Let's create a template file containing the HTML form.
-Open a new file named <code>edit.html</code>, and add the following lines:
-</p>
-
-{{code "doc/articles/wiki/edit.html"}}
-
-<p>
-Modify <code>editHandler</code> to use the template, instead of the hard-coded
-HTML:
-</p>
-
-{{code "doc/articles/wiki/final-noerror.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-The function <code>template.ParseFiles</code> will read the contents of
-<code>edit.html</code> and return a <code>*template.Template</code>.
-</p>
-
-<p>
-The method <code>t.Execute</code> executes the template, writing the
-generated HTML to the <code>http.ResponseWriter</code>.
-The <code>.Title</code> and <code>.Body</code> dotted identifiers refer to
-<code>p.Title</code> and <code>p.Body</code>.
-</p>
-
-<p>
-Template directives are enclosed in double curly braces.
-The <code>printf "%s" .Body</code> instruction is a function call
-that outputs <code>.Body</code> as a string instead of a stream of bytes,
-the same as a call to <code>fmt.Printf</code>.
-The <code>html/template</code> package helps guarantee that only safe and
-correct-looking HTML is generated by template actions. For instance, it
-automatically escapes any greater than sign (<code>&gt;</code>), replacing it
-with <code>&amp;gt;</code>, to make sure user data does not corrupt the form
-HTML.
-</p>
-
-<p>
-Since we're working with templates now, let's create a template for our
-<code>viewHandler</code> called <code>view.html</code>:
-</p>
-
-{{code "doc/articles/wiki/view.html"}}
-
-<p>
-Modify <code>viewHandler</code> accordingly:
-</p>
-
-{{code "doc/articles/wiki/final-noerror.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-Notice that we've used almost exactly the same templating code in both
-handlers. Let's remove this duplication by moving the templating code
-to its own function:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func renderTemplate/` `/^}/`}}
-
-<p>
-And modify the handlers to use that function:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-template.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-If we comment out the registration of our unimplemented save handler in
-<code>main</code>, we can once again build and test our program.
-<a href="part3.go">Click here to view the code we've written so far.</a>
-</p>
-
-<h2>Handling non-existent pages</h2>
-
-<p>
-What if you visit <a href="http://localhost:8080/view/APageThatDoesntExist">
-<code>/view/APageThatDoesntExist</code></a>? You'll see a page containing
-HTML. This is because it ignores the error return value from
-<code>loadPage</code> and continues to try and fill out the template
-with no data. Instead, if the requested Page doesn't exist, it should
-redirect the client to the edit Page so the content may be created:
-</p>
-
-{{code "doc/articles/wiki/part3-errorhandling.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-The <code>http.Redirect</code> function adds an HTTP status code of
-<code>http.StatusFound</code> (302) and a <code>Location</code>
-header to the HTTP response.
-</p>
-
-<h2>Saving Pages</h2>
-
-<p>
-The function <code>saveHandler</code> will handle the submission of forms
-located on the edit pages. After uncommenting the related line in
-<code>main</code>, let's implement the handler:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func saveHandler/` `/^}/`}}
-
-<p>
-The page title (provided in the URL) and the form's only field,
-<code>Body</code>, are stored in a new <code>Page</code>.
-The <code>save()</code> method is then called to write the data to a file,
-and the client is redirected to the <code>/view/</code> page.
-</p>
-
-<p>
-The value returned by <code>FormValue</code> is of type <code>string</code>.
-We must convert that value to <code>[]byte</code> before it will fit into
-the <code>Page</code> struct. We use <code>[]byte(body)</code> to perform
-the conversion.
-</p>
-
-<h2>Error handling</h2>
-
-<p>
-There are several places in our program where errors are being ignored.  This
-is bad practice, not least because when an error does occur the program will
-have unintended behavior. A better solution is to handle the errors and return
-an error message to the user. That way if something does go wrong, the server
-will function exactly how we want and the user can be notified.
-</p>
-
-<p>
-First, let's handle the errors in <code>renderTemplate</code>:
-</p>
-
-{{code "doc/articles/wiki/final-parsetemplate.go" `/^func renderTemplate/` `/^}/`}}
-
-<p>
-The <code>http.Error</code> function sends a specified HTTP response code
-(in this case "Internal Server Error") and error message.
-Already the decision to put this in a separate function is paying off.
-</p>
-
-<p>
-Now let's fix up <code>saveHandler</code>:
-</p>
-
-{{code "doc/articles/wiki/part3-errorhandling.go" `/^func saveHandler/` `/^}/`}}
-
-<p>
-Any errors that occur during <code>p.save()</code> will be reported
-to the user.
-</p>
-
-<h2>Template caching</h2>
-
-<p>
-There is an inefficiency in this code: <code>renderTemplate</code> calls
-<code>ParseFiles</code> every time a page is rendered.
-A better approach would be to call <code>ParseFiles</code> once at program
-initialization, parsing all templates into a single <code>*Template</code>.
-Then we can use the
-<a href="/pkg/html/template/#Template.ExecuteTemplate"><code>ExecuteTemplate</code></a>
-method to render a specific template.
-</p>
-
-<p>
-First we create a global variable named <code>templates</code>, and initialize
-it with <code>ParseFiles</code>.
-</p>
-
-{{code "doc/articles/wiki/final.go" `/var templates/`}}
-
-<p>
-The function <code>template.Must</code> is a convenience wrapper that panics
-when passed a non-nil <code>error</code> value, and otherwise returns the
-<code>*Template</code> unaltered. A panic is appropriate here; if the templates
-can't be loaded the only sensible thing to do is exit the program.
-</p>
-
-<p>
-The <code>ParseFiles</code> function takes any number of string arguments that
-identify our template files, and parses those files into templates that are
-named after the base file name. If we were to add more templates to our
-program, we would add their names to the <code>ParseFiles</code> call's
-arguments.
-</p>
-
-<p>
-We then modify the <code>renderTemplate</code> function to call the
-<code>templates.ExecuteTemplate</code> method with the name of the appropriate
-template:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func renderTemplate/` `/^}/`}}
-
-<p>
-Note that the template name is the template file name, so we must
-append <code>".html"</code> to the <code>tmpl</code> argument.
-</p>
-
-<h2>Validation</h2>
-
-<p>
-As you may have observed, this program has a serious security flaw: a user
-can supply an arbitrary path to be read/written on the server. To mitigate
-this, we can write a function to validate the title with a regular expression.
-</p>
-
-<p>
-First, add <code>"regexp"</code> to the <code>import</code> list.
-Then we can create a global variable to store our validation
-expression:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^var validPath/`}}
-
-<p>
-The function <code>regexp.MustCompile</code> will parse and compile the
-regular expression, and return a <code>regexp.Regexp</code>.
-<code>MustCompile</code> is distinct from <code>Compile</code> in that it will
-panic if the expression compilation fails, while <code>Compile</code> returns
-an <code>error</code> as a second parameter.
-</p>
-
-<p>
-Now, let's write a function that uses the <code>validPath</code>
-expression to validate path and extract the page title:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/func getTitle/` `/^}/`}}
-
-<p>
-If the title is valid, it will be returned along with a <code>nil</code>
-error value. If the title is invalid, the function will write a
-"404 Not Found" error to the HTTP connection, and return an error to the
-handler. To create a new error, we have to import the <code>errors</code>
-package.
-</p>
-
-<p>
-Let's put a call to <code>getTitle</code> in each of the handlers:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-noclosure.go" `/^func editHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-noclosure.go" `/^func saveHandler/` `/^}/`}}
-
-<h2>Introducing Function Literals and Closures</h2>
-
-<p>
-Catching the error condition in each handler introduces a lot of repeated code.
-What if we could wrap each of the handlers in a function that does this
-validation and error checking? Go's
-<a href="/ref/spec#Function_literals">function
-literals</a> provide a powerful means of abstracting functionality
-that can help us here.
-</p>
-
-<p>
-First, we re-write the function definition of each of the handlers to accept
-a title string:
-</p>
-
-<pre>
-func viewHandler(w http.ResponseWriter, r *http.Request, title string)
-func editHandler(w http.ResponseWriter, r *http.Request, title string)
-func saveHandler(w http.ResponseWriter, r *http.Request, title string)
-</pre>
-
-<p>
-Now let's define a wrapper function that <i>takes a function of the above
-type</i>, and returns a function of type <code>http.HandlerFunc</code>
-(suitable to be passed to the function <code>http.HandleFunc</code>):
-</p>
-
-<pre>
-func makeHandler(fn func (http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-       return func(w http.ResponseWriter, r *http.Request) {
-               // Here we will extract the page title from the Request,
-               // and call the provided handler 'fn'
-       }
-}
-</pre>
-
-<p>
-The returned function is called a closure because it encloses values defined
-outside of it. In this case, the variable <code>fn</code> (the single argument
-to <code>makeHandler</code>) is enclosed by the closure. The variable
-<code>fn</code> will be one of our save, edit, or view handlers.
-</p>
-
-<p>
-Now we can take the code from <code>getTitle</code> and use it here
-(with some minor modifications):
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func makeHandler/` `/^}/`}}
-
-<p>
-The closure returned by <code>makeHandler</code> is a function that takes
-an <code>http.ResponseWriter</code> and <code>http.Request</code> (in other
-words, an <code>http.HandlerFunc</code>).
-The closure extracts the <code>title</code> from the request path, and
-validates it with the <code>validPath</code> regexp. If the
-<code>title</code> is invalid, an error will be written to the
-<code>ResponseWriter</code> using the <code>http.NotFound</code> function.
-If the <code>title</code> is valid, the enclosed handler function
-<code>fn</code> will be called with the <code>ResponseWriter</code>,
-<code>Request</code>, and <code>title</code> as arguments.
-</p>
-
-<p>
-Now we can wrap the handler functions with <code>makeHandler</code> in
-<code>main</code>, before they are registered with the <code>http</code>
-package:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func main/` `/^}/`}}
-
-<p>
-Finally we remove the calls to <code>getTitle</code> from the handler functions,
-making them much simpler:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final.go" `/^func editHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final.go" `/^func saveHandler/` `/^}/`}}
-
-<h2>Try it out!</h2>
-
-<p>
-<a href="final.go">Click here to view the final code listing.</a>
-</p>
-
-<p>
-Recompile the code, and run the app:
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-</pre>
-
-<p>
-Visiting <a href="http://localhost:8080/view/ANewPage">http://localhost:8080/view/ANewPage</a>
-should present you with the page edit form. You should then be able to
-enter some text, click 'Save', and be redirected to the newly created page.
-</p>
-
-<h2>Other tasks</h2>
-
-<p>
-Here are some simple tasks you might want to tackle on your own:
-</p>
-
-<ul>
-<li>Store templates in <code>tmpl/</code> and page data in <code>data/</code>.
-<li>Add a handler to make the web root redirect to
-       <code>/view/FrontPage</code>.</li>
-<li>Spruce up the page templates by making them valid HTML and adding some
-       CSS rules.</li>
-<li>Implement inter-page linking by converting instances of
-       <code>[PageName]</code> to <br>
-       <code>&lt;a href="/view/PageName"&gt;PageName&lt;/a&gt;</code>.
-       (hint: you could use <code>regexp.ReplaceAllFunc</code> to do this)
-       </li>
-</ul>

diff --git a/doc/articles/wiki/notemplate.go b/doc/articles/wiki/notemplate.go
deleted file mode 100644 (file)
index 4b358f2..0000000
--- a/doc/articles/wiki/notemplate.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, _ := loadPage(title)
-       fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/edit/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       fmt.Fprintf(w, "<h1>Editing %s</h1>"+
-               "<form action=\"/save/%s\" method=\"POST\">"+
-               "<textarea name=\"body\">%s</textarea><br>"+
-               "<input type=\"submit\" value=\"Save\">"+
-               "</form>",
-               p.Title, p.Title, p.Body)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/part1-noerror.go b/doc/articles/wiki/part1-noerror.go
deleted file mode 100644 (file)
index 913c6dc..0000000
--- a/doc/articles/wiki/part1-noerror.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "io/ioutil"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) *Page {
-       filename := title + ".txt"
-       body, _ := ioutil.ReadFile(filename)
-       return &Page{Title: title, Body: body}
-}
-
-func main() {
-       p1 := &Page{Title: "TestPage", Body: []byte("This is a sample page.")}
-       p1.save()
-       p2 := loadPage("TestPage")
-       fmt.Println(string(p2.Body))
-}

diff --git a/doc/articles/wiki/part1.go b/doc/articles/wiki/part1.go
deleted file mode 100644 (file)
index 2ff1abd..0000000
--- a/doc/articles/wiki/part1.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "io/ioutil"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func main() {
-       p1 := &Page{Title: "TestPage", Body: []byte("This is a sample Page.")}
-       p1.save()
-       p2, _ := loadPage("TestPage")
-       fmt.Println(string(p2.Body))
-}

diff --git a/doc/articles/wiki/part2.go b/doc/articles/wiki/part2.go
deleted file mode 100644 (file)
index db92f4c..0000000
--- a/doc/articles/wiki/part2.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "fmt"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, _ := loadPage(title)
-       fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/part3-errorhandling.go b/doc/articles/wiki/part3-errorhandling.go
deleted file mode 100644 (file)
index 2c8b42d..0000000
--- a/doc/articles/wiki/part3-errorhandling.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       t, _ := template.ParseFiles(tmpl + ".html")
-       t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-               return
-       }
-       renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/edit/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/save/"):]
-       body := r.FormValue("body")
-       p := &Page{Title: title, Body: []byte(body)}
-       err := p.save()
-       if err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       http.HandleFunc("/save/", saveHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/part3.go b/doc/articles/wiki/part3.go
deleted file mode 100644 (file)
index 437ea33..0000000
--- a/doc/articles/wiki/part3.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-       "html/template"
-       "io/ioutil"
-       "log"
-       "net/http"
-)
-
-type Page struct {
-       Title string
-       Body  []byte
-}
-
-func (p *Page) save() error {
-       filename := p.Title + ".txt"
-       return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-       filename := title + ".txt"
-       body, err := ioutil.ReadFile(filename)
-       if err != nil {
-               return nil, err
-       }
-       return &Page{Title: title, Body: body}, nil
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-       t, _ := template.ParseFiles(tmpl + ".html")
-       t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/view/"):]
-       p, _ := loadPage(title)
-       renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-       title := r.URL.Path[len("/edit/"):]
-       p, err := loadPage(title)
-       if err != nil {
-               p = &Page{Title: title}
-       }
-       renderTemplate(w, "edit", p)
-}
-
-func main() {
-       http.HandleFunc("/view/", viewHandler)
-       http.HandleFunc("/edit/", editHandler)
-       //http.HandleFunc("/save/", saveHandler)
-       log.Fatal(http.ListenAndServe(":8080", nil))
-}

diff --git a/doc/articles/wiki/test_Test.txt.good b/doc/articles/wiki/test_Test.txt.good
deleted file mode 100644 (file)
index f0eec86..0000000
--- a/doc/articles/wiki/test_Test.txt.good
+++ /dev/null
@@ -1 +0,0 @@
-some content
\ No newline at end of file

diff --git a/doc/articles/wiki/test_edit.good b/doc/articles/wiki/test_edit.good
deleted file mode 100644 (file)
index 36c6dbb..0000000
--- a/doc/articles/wiki/test_edit.good
+++ /dev/null
@@ -1,6 +0,0 @@
-<h1>Editing Test</h1>
-
-<form action="/save/Test" method="POST">
-<div><textarea name="body" rows="20" cols="80"></textarea></div>
-<div><input type="submit" value="Save"></div>
-</form>

diff --git a/doc/articles/wiki/test_view.good b/doc/articles/wiki/test_view.good
deleted file mode 100644 (file)
index 07e8edb..0000000
--- a/doc/articles/wiki/test_view.good
+++ /dev/null
@@ -1,5 +0,0 @@
-<h1>Test</h1>
-
-<p>[<a href="/edit/Test">edit</a>]</p>
-
-<div>some content</div>

diff --git a/doc/articles/wiki/view.html b/doc/articles/wiki/view.html
deleted file mode 100644 (file)
index b1e87ef..0000000
--- a/doc/articles/wiki/view.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<h1>{{.Title}}</h1>
-
-<p>[<a href="/edit/{{.Title}}">edit</a>]</p>
-
-<div>{{printf "%s" .Body}}</div>

diff --git a/doc/articles/wiki/wiki_test.go b/doc/articles/wiki/wiki_test.go
deleted file mode 100644 (file)
index 1d976fd..0000000
--- a/doc/articles/wiki/wiki_test.go
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main_test
-
-import (
-       "bytes"
-       "fmt"
-       "io/ioutil"
-       "net/http"
-       "os"
-       "os/exec"
-       "path/filepath"
-       "strings"
-       "testing"
-)
-
-func TestSnippetsCompile(t *testing.T) {
-       if testing.Short() {
-               t.Skip("skipping slow builds in short mode")
-       }
-
-       goFiles, err := filepath.Glob("*.go")
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       for _, f := range goFiles {
-               if strings.HasSuffix(f, "_test.go") {
-                       continue
-               }
-               f := f
-               t.Run(f, func(t *testing.T) {
-                       t.Parallel()
-
-                       cmd := exec.Command("go", "build", "-o", os.DevNull, f)
-                       out, err := cmd.CombinedOutput()
-                       if err != nil {
-                               t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-                       }
-               })
-       }
-}
-
-func TestWikiServer(t *testing.T) {
-       must := func(err error) {
-               if err != nil {
-                       t.Helper()
-                       t.Fatal(err)
-               }
-       }
-
-       dir, err := ioutil.TempDir("", t.Name())
-       must(err)
-       defer os.RemoveAll(dir)
-
-       // We're testing a walkthrough example of how to write a server.
-       //
-       // That server hard-codes a port number to make the walkthrough simpler, but
-       // we can't assume that the hard-coded port is available on an arbitrary
-       // builder. So we'll patch out the hard-coded port, and replace it with a
-       // function that writes the server's address to stdout
-       // so that we can read it and know where to send the test requests.
-
-       finalGo, err := ioutil.ReadFile("final.go")
-       must(err)
-       const patchOld = `log.Fatal(http.ListenAndServe(":8080", nil))`
-       patched := bytes.ReplaceAll(finalGo, []byte(patchOld), []byte(`log.Fatal(serve())`))
-       if bytes.Equal(patched, finalGo) {
-               t.Fatalf("Can't patch final.go: %q not found.", patchOld)
-       }
-       must(ioutil.WriteFile(filepath.Join(dir, "final_patched.go"), patched, 0644))
-
-       // Build the server binary from the patched sources.
-       // The 'go' command requires that they all be in the same directory.
-       // final_test.go provides the implemtation for our serve function.
-       must(copyFile(filepath.Join(dir, "final_srv.go"), "final_test.go"))
-       cmd := exec.Command("go", "build",
-               "-o", filepath.Join(dir, "final.exe"),
-               filepath.Join(dir, "final_patched.go"),
-               filepath.Join(dir, "final_srv.go"))
-       out, err := cmd.CombinedOutput()
-       if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-       }
-
-       // Run the server in our temporary directory so that it can
-       // write its content there. It also needs a couple of template files,
-       // and looks for them in the same directory.
-       must(copyFile(filepath.Join(dir, "edit.html"), "edit.html"))
-       must(copyFile(filepath.Join(dir, "view.html"), "view.html"))
-       cmd = exec.Command(filepath.Join(dir, "final.exe"))
-       cmd.Dir = dir
-       stderr := bytes.NewBuffer(nil)
-       cmd.Stderr = stderr
-       stdout, err := cmd.StdoutPipe()
-       must(err)
-       must(cmd.Start())
-
-       defer func() {
-               cmd.Process.Kill()
-               err := cmd.Wait()
-               if stderr.Len() > 0 {
-                       t.Logf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, stderr)
-               }
-       }()
-
-       var addr string
-       if _, err := fmt.Fscanln(stdout, &addr); err != nil || addr == "" {
-               t.Fatalf("Failed to read server address: %v", err)
-       }
-
-       // The server is up and has told us its address.
-       // Make sure that its HTTP API works as described in the article.
-
-       r, err := http.Get(fmt.Sprintf("http://%s/edit/Test", addr))
-       must(err)
-       responseMustMatchFile(t, r, "test_edit.good")
-
-       r, err = http.Post(fmt.Sprintf("http://%s/save/Test", addr),
-               "application/x-www-form-urlencoded",
-               strings.NewReader("body=some%20content"))
-       must(err)
-       responseMustMatchFile(t, r, "test_view.good")
-
-       gotTxt, err := ioutil.ReadFile(filepath.Join(dir, "Test.txt"))
-       must(err)
-       wantTxt, err := ioutil.ReadFile("test_Test.txt.good")
-       must(err)
-       if !bytes.Equal(wantTxt, gotTxt) {
-               t.Fatalf("Test.txt differs from expected after posting to /save.\ngot:\n%s\nwant:\n%s", gotTxt, wantTxt)
-       }
-
-       r, err = http.Get(fmt.Sprintf("http://%s/view/Test", addr))
-       must(err)
-       responseMustMatchFile(t, r, "test_view.good")
-}
-
-func responseMustMatchFile(t *testing.T, r *http.Response, filename string) {
-       t.Helper()
-
-       defer r.Body.Close()
-       body, err := ioutil.ReadAll(r.Body)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       wantBody, err := ioutil.ReadFile(filename)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       if !bytes.Equal(body, wantBody) {
-               t.Fatalf("%v: body does not match %s.\ngot:\n%s\nwant:\n%s", r.Request.URL, filename, body, wantBody)
-       }
-}
-
-func copyFile(dst, src string) error {
-       buf, err := ioutil.ReadFile(src)
-       if err != nil {
-               return err
-       }
-       return ioutil.WriteFile(dst, buf, 0644)
-}

diff --git a/doc/asm.html b/doc/asm.html
index cc8598aeff80426fc7debb706d8c6bea58fd1cd8..7173d9bd514fb2c5ecc3417cffa1a6d84feba4f2 100644 (file)
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -464,6 +464,57 @@ Function is the top of the call stack. Traceback should stop at this function.
 </li>
 </ul>
 
+<h3 id="data-offsets">Interacting with Go types and constants</h3>
+
+<p>
+If a package has any .s files, then <code>go build</code> will direct
+the compiler to emit a special header called <code>go_asm.h</code>,
+which the .s files can then <code>#include</code>.
+The file contains symbolic <code>#define</code> constants for the
+offsets of Go struct fields, the sizes of Go struct types, and most
+Go <code>const</code> declarations defined in the current package.
+Go assembly should avoid making assumptions about the layout of Go
+types and instead use these constants.
+This improves the readability of assembly code, and keeps it robust to
+changes in data layout either in the Go type definitions or in the
+layout rules used by the Go compiler.
+</p>
+
+<p>
+Constants are of the form <code>const_<i>name</i></code>.
+For example, given the Go declaration <code>const bufSize =
+1024</code>, assembly code can refer to the value of this constant
+as <code>const_bufSize</code>.
+</p>
+
+<p>
+Field offsets are of the form <code><i>type</i>_<i>field</i></code>.
+Struct sizes are of the form <code><i>type</i>__size</code>.
+For example, consider the following Go definition:
+</p>
+
+<pre>
+type reader struct {
+       buf [bufSize]byte
+       r   int
+}
+</pre>
+
+<p>
+Assembly can refer to the size of this struct
+as <code>reader__size</code> and the offsets of the two fields
+as <code>reader_buf</code> and <code>reader_r</code>.
+Hence, if register <code>R1</code> contains a pointer to
+a <code>reader</code>, assembly can reference the <code>r</code> field
+as <code>reader_r(R1)</code>.
+</p>
+
+<p>
+If any of these <code>#define</code> names are ambiguous (for example,
+a struct with a <code>_size</code> field), <code>#include
+"go_asm.h"</code> will fail with a "redefinition of macro" error.
+</p>
+
 <h3 id="runtime">Runtime Coordination</h3>
 
 <p>
@@ -615,21 +666,15 @@ Here follow some descriptions of key Go-specific details for the supported archi
 <p>
 The runtime pointer to the <code>g</code> structure is maintained
 through the value of an otherwise unused (as far as Go is concerned) register in the MMU.
-An OS-dependent macro <code>get_tls</code> is defined for the assembler if the source is
-in the <code>runtime</code> package and includes a special header, <code>go_tls.h</code>:
+In the runtime package, assembly code can include <code>go_tls.h</code>, which defines
+an OS- and architecture-dependent macro <code>get_tls</code> for accessing this register.
+The <code>get_tls</code> macro takes one argument, which is the register to load the
+<code>g</code> pointer into.
 </p>
 
-<pre>
-#include "go_tls.h"
-</pre>
-
 <p>
-Within the runtime, the <code>get_tls</code> macro loads its argument register
-with a pointer to the <code>g</code> pointer, and the <code>g</code> struct
-contains the <code>m</code> pointer.
-There's another special header containing the offsets for each
-element of <code>g</code>, called <code>go_asm.h</code>.
-The sequence to load <code>g</code> and <code>m</code> using <code>CX</code> looks like this:
+For example, the sequence to load <code>g</code> and <code>m</code>
+using <code>CX</code> looks like this:
 </p>
 
 <pre>
@@ -642,8 +687,7 @@ MOVL        g_m(AX), BX   // Move g.m into BX.
 </pre>
 
 <p>
-Note: The code above works only in the <code>runtime</code> package, while <code>go_tls.h</code> also
-applies to <a href="#arm">arm</a>, <a href="#amd64">amd64</a> and amd64p32, and <code>go_asm.h</code> applies to all architectures.
+The <code>get_tls</code> macro is also defined on <a href="#amd64">amd64</a>.
 </p>
 
 <p>

diff --git a/doc/cmd.html b/doc/cmd.html
deleted file mode 100644 (file)
index c3bd918..0000000
--- a/doc/cmd.html
+++ /dev/null
@@ -1,100 +0,0 @@
-<!--{
-       "Title": "Command Documentation",
-       "Path":  "/doc/cmd"
-}-->
-
-<p>
-There is a suite of programs to build and process Go source code.
-Instead of being run directly, programs in the suite are usually invoked
-by the <a href="/cmd/go/">go</a> program.
-</p>
-
-<p>
-The most common way to run these programs is as a subcommand of the go program,
-for instance as <code>go fmt</code>. Run like this, the command operates on
-complete packages of Go source code, with the go program invoking the
-underlying binary with arguments appropriate to package-level processing.
-</p>
-
-<p>
-The programs can also be run as stand-alone binaries, with unmodified arguments,
-using the go <code>tool</code> subcommand, such as <code>go tool cgo</code>.
-For most commands this is mainly useful for debugging.
-Some of the commands, such as <code>pprof</code>, are accessible only through
-the go <code>tool</code> subcommand.
-</p>
-
-<p>
-Finally the <code>fmt</code> and <code>godoc</code> commands are installed
-as regular binaries called <code>gofmt</code> and <code>godoc</code> because
-they are so often referenced.
-</p>
-
-<p>
-Click on the links for more documentation, invocation methods, and usage details.
-</p>
-
-<table class="dir">
-<tr>
-<th>Name</th>
-<th>&nbsp;&nbsp;&nbsp;&nbsp;</th>
-<th>Synopsis</th>
-</tr>
-
-<tr>
-<td><a href="/cmd/go/">go</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>
-The <code>go</code> program manages Go source code and runs the other
-commands listed here.
-See the command docs for usage
-details.
-</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/cgo/">cgo</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Cgo enables the creation of Go packages that call C code.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/cover/">cover</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Cover is a program for creating and analyzing the coverage profiles
-generated by <code>"go test -coverprofile"</code>.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/fix/">fix</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Fix finds Go programs that use old features of the language and libraries
-and rewrites them to use newer ones.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/gofmt/">fmt</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Fmt formats Go packages, it is also available as an independent <a href="/cmd/gofmt/">
-gofmt</a> command with more general options.</td>
-</tr>
-
-<tr>
-<td><a href="//godoc.org/golang.org/x/tools/cmd/godoc/">godoc</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Godoc extracts and generates documentation for Go packages.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/vet/">vet</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Vet examines Go source code and reports suspicious constructs, such as Printf
-calls whose arguments do not align with the format string.</td>
-</tr>
-
-</table>
-
-<p>
-This is an abridged list. See the <a href="/cmd/">full command reference</a>
-for documentation of the compilers and more.
-</p>

diff --git a/doc/codewalk/codewalk.css b/doc/codewalk/codewalk.css
deleted file mode 100644 (file)
index a0814e4..0000000
--- a/doc/codewalk/codewalk.css
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
-   Copyright 2010 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.
-*/
-
-#codewalk-main {
-  text-align: left;
-  width: 100%;
-  overflow: auto;
-}
-
-#code-display {
-  border: 0;
-  width: 100%;
-}
-
-.setting {
-  font-size: 8pt;
-  color: #888888;
-  padding: 5px;
-}
-
-.hotkey {
-  text-decoration: underline;
-}
-
-/* Style for Comments (the left-hand column) */
-
-#comment-column {
-  margin: 0pt;
-  width: 30%;
-}
-
-#comment-column.right {
-  float: right;
-}
-
-#comment-column.left {
-  float: left;
-}
-
-#comment-area {
-  overflow-x: hidden;
-  overflow-y: auto;
-}
-
-.comment {
-  cursor: pointer;
-  font-size: 16px;
-  border: 2px solid #ba9836;
-  margin-bottom: 10px;
-  margin-right: 10px;  /* yes, for both .left and .right */
-}
-
-.comment:last-child {
-  margin-bottom: 0px;
-}
-
-.right .comment {
-  margin-left: 10px;
-}
-
-.right .comment.first {
-}
-
-.right .comment.last {
-}
-
-.left .comment.first {
-}
-
-.left .comment.last {
-}
-
-.comment.selected {
-  border-color: #99b2cb;
-}
-
-.right .comment.selected {
-  border-left-width: 12px;
-  margin-left: 0px;
-}
-
-.left .comment.selected {
-  border-right-width: 12px;
-  margin-right: 0px;
-}
-
-.comment-link {
-  display: none;
-}
-
-.comment-title {
-  font-size: small;
-  font-weight: bold;
-  background-color: #fffff0;
-  padding-right: 10px;
-  padding-left: 10px;
-  padding-top: 5px;
-  padding-bottom: 5px;
-}
-
-.right .comment-title {
-}
-
-.left .comment-title {
-}
-
-.comment.selected .comment-title {
-  background-color: #f8f8ff;
-}
-
-.comment-text {
-  overflow: auto;
-  padding-left: 10px;
-  padding-right: 10px;
-  padding-top: 10px;
-  padding-bottom: 5px;
-  font-size: small;
-  line-height: 1.3em;
-}
-
-.comment-text p {
-  margin-top: 0em;
-  margin-bottom: 0.5em;
-}
-
-.comment-text p:last-child {
-  margin-bottom: 0em;
-}
-
-.file-name {
-  font-size: x-small;
-  padding-top: 0px;
-  padding-bottom: 5px;
-}
-
-.hidden-filepaths .file-name {
-  display: none;
-}
-
-.path-dir {
-  color: #555;
-}
-
-.path-file {
-  color: #555;
-}
-
-
-/* Style for Code (the right-hand column) */
-
-/* Wrapper for the code column to make widths get calculated correctly */
-#code-column {
-  display: block;
-  position: relative;
-  margin: 0pt;
-  width: 70%;
-}
-
-#code-column.left {
-  float: left;
-}
-
-#code-column.right {
-  float: right;
-}
-
-#code-area {
-  background-color: #f8f8ff;
-  border: 2px solid #99b2cb;
-  padding: 5px;
-}
-
-.left #code-area {
-  margin-right: -1px;
-}
-
-.right #code-area {
-  margin-left: -1px;
-}
-
-#code-header {
-  margin-bottom: 5px;
-}
-
-#code {
-  background-color: white;
-}
-
-code {
-  font-size: 100%;
-}
-
-.codewalkhighlight {
-  font-weight: bold;
-  background-color: #f8f8ff;
-}
-
-#code-display {
-  margin-top: 0px;
-  margin-bottom: 0px;
-}
-
-#sizer {
-  position: absolute;
-  cursor: col-resize;
-  left: 0px;
-  top: 0px;
-  width: 8px;
-}
-
-/* Style for options (bottom strip) */
-
-#code-options {
-  display: none;
-}
-
-#code-options > span {
-  padding-right: 20px;
-}
-
-#code-options .selected {
-  border-bottom: 1px dotted;
-}
-
-#comment-options {
-  text-align: center;
-}
-
-div#content {
-  padding-bottom: 0em;
-}

diff --git a/doc/codewalk/codewalk.js b/doc/codewalk/codewalk.js
deleted file mode 100644 (file)
index 4f59a8f..0000000
--- a/doc/codewalk/codewalk.js
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/**
- * A class to hold information about the Codewalk Viewer.
- * @param {jQuery} context The top element in whose context the viewer should
- *     operate.  It will not touch any elements above this one.
- * @constructor
- */
- var CodewalkViewer = function(context) {
-  this.context = context;
-
-  /**
-   * The div that contains all of the comments and their controls.
-   */
-  this.commentColumn = this.context.find('#comment-column');
-
-  /**
-   * The div that contains the comments proper.
-   */
-  this.commentArea = this.context.find('#comment-area');
-
-  /**
-   * The div that wraps the iframe with the code, as well as the drop down menu
-   * listing the different files.
-   * @type {jQuery}
-   */
-  this.codeColumn = this.context.find('#code-column');
-
-  /**
-   * The div that contains the code but excludes the options strip.
-   * @type {jQuery}
-   */
-  this.codeArea = this.context.find('#code-area');
-
-  /**
-   * The iframe that holds the code (from Sourcerer).
-   * @type {jQuery}
-   */
-  this.codeDisplay = this.context.find('#code-display');
-
-  /**
-   * The overlaid div used as a grab handle for sizing the code/comment panes.
-   * @type {jQuery}
-   */
-  this.sizer = this.context.find('#sizer');
-
-  /**
-   * The full-screen overlay that ensures we don't lose track of the mouse
-   * while dragging.
-   * @type {jQuery}
-   */
-  this.overlay = this.context.find('#overlay');
-
-  /**
-   * The hidden input field that we use to hold the focus so that we can detect
-   * shortcut keypresses.
-   * @type {jQuery}
-   */
-  this.shortcutInput = this.context.find('#shortcut-input');
-
-  /**
-   * The last comment that was selected.
-   * @type {jQuery}
-   */
-  this.lastSelected = null;
-};
-
-/**
- * Minimum width of the comments or code pane, in pixels.
- * @type {number}
- */
-CodewalkViewer.MIN_PANE_WIDTH = 200;
-
-/**
- * Navigate the code iframe to the given url and update the code popout link.
- * @param {string} url The target URL.
- * @param {Object} opt_window Window dependency injection for testing only.
- */
-CodewalkViewer.prototype.navigateToCode = function(url, opt_window) {
-  if (!opt_window) opt_window = window;
-  // Each iframe is represented by two distinct objects in the DOM:  an iframe
-  // object and a window object.  These do not expose the same capabilities.
-  // Here we need to get the window representation to get the location member,
-  // so we access it directly through window[] since jQuery returns the iframe
-  // representation.
-  // We replace location rather than set so as not to create a history for code
-  // navigation.
-  opt_window['code-display'].location.replace(url);
-  var k = url.indexOf('&');
-  if (k != -1) url = url.slice(0, k);
-  k = url.indexOf('fileprint=');
-  if (k != -1) url = url.slice(k+10, url.length);
-  this.context.find('#code-popout-link').attr('href', url);
-};
-
-/**
- * Selects the first comment from the list and forces a refresh of the code
- * view.
- */
-CodewalkViewer.prototype.selectFirstComment = function() {
-  // TODO(rsc): handle case where there are no comments
-  var firstSourcererLink = this.context.find('.comment:first');
-  this.changeSelectedComment(firstSourcererLink);
-};
-
-/**
- * Sets the target on all links nested inside comments to be _blank.
- */
-CodewalkViewer.prototype.targetCommentLinksAtBlank = function() {
-  this.context.find('.comment a[href], #description a[href]').each(function() {
-    if (!this.target) this.target = '_blank';
-  });
-};
-
-/**
- * Installs event handlers for all the events we care about.
- */
-CodewalkViewer.prototype.installEventHandlers = function() {
-  var self = this;
-
-  this.context.find('.comment')
-      .click(function(event) {
-        if (jQuery(event.target).is('a[href]')) return true;
-        self.changeSelectedComment(jQuery(this));
-        return false;
-      });
-
-  this.context.find('#code-selector')
-      .change(function() {self.navigateToCode(jQuery(this).val());});
-
-  this.context.find('#description-table .quote-feet.setting')
-      .click(function() {self.toggleDescription(jQuery(this)); return false;});
-
-  this.sizer
-      .mousedown(function(ev) {self.startSizerDrag(ev); return false;});
-  this.overlay
-      .mouseup(function(ev) {self.endSizerDrag(ev); return false;})
-      .mousemove(function(ev) {self.handleSizerDrag(ev); return false;});
-
-  this.context.find('#prev-comment')
-      .click(function() {
-          self.changeSelectedComment(self.lastSelected.prev()); return false;
-      });
-
-  this.context.find('#next-comment')
-      .click(function() {
-          self.changeSelectedComment(self.lastSelected.next()); return false;
-      });
-
-  // Workaround for Firefox 2 and 3, which steal focus from the main document
-  // whenever the iframe content is (re)loaded.  The input field is not shown,
-  // but is a way for us to bring focus back to a place where we can detect
-  // keypresses.
-  this.context.find('#code-display')
-      .load(function(ev) {self.shortcutInput.focus();});
-
-  jQuery(document).keypress(function(ev) {
-    switch(ev.which) {
-      case 110:  // 'n'
-          self.changeSelectedComment(self.lastSelected.next());
-          return false;
-      case 112:  // 'p'
-          self.changeSelectedComment(self.lastSelected.prev());
-          return false;
-      default:  // ignore
-    }
-  });
-
-  window.onresize = function() {self.updateHeight();};
-};
-
-/**
- * Starts dragging the pane sizer.
- * @param {Object} ev The mousedown event that started us dragging.
- */
-CodewalkViewer.prototype.startSizerDrag = function(ev) {
-  this.initialCodeWidth = this.codeColumn.width();
-  this.initialCommentsWidth = this.commentColumn.width();
-  this.initialMouseX = ev.pageX;
-  this.overlay.show();
-};
-
-/**
- * Handles dragging the pane sizer.
- * @param {Object} ev The mousemove event updating dragging position.
- */
-CodewalkViewer.prototype.handleSizerDrag = function(ev) {
-  var delta = ev.pageX - this.initialMouseX;
-  if (this.codeColumn.is('.right')) delta = -delta;
-  var proposedCodeWidth = this.initialCodeWidth + delta;
-  var proposedCommentWidth = this.initialCommentsWidth - delta;
-  var mw = CodewalkViewer.MIN_PANE_WIDTH;
-  if (proposedCodeWidth < mw) delta = mw - this.initialCodeWidth;
-  if (proposedCommentWidth < mw) delta = this.initialCommentsWidth - mw;
-  proposedCodeWidth = this.initialCodeWidth + delta;
-  proposedCommentWidth = this.initialCommentsWidth - delta;
-  // If window is too small, don't even try to resize.
-  if (proposedCodeWidth < mw || proposedCommentWidth < mw) return;
-  this.codeColumn.width(proposedCodeWidth);
-  this.commentColumn.width(proposedCommentWidth);
-  this.options.codeWidth = parseInt(
-      this.codeColumn.width() /
-      (this.codeColumn.width() + this.commentColumn.width()) * 100);
-  this.context.find('#code-column-width').text(this.options.codeWidth + '%');
-};
-
-/**
- * Ends dragging the pane sizer.
- * @param {Object} ev The mouseup event that caused us to stop dragging.
- */
-CodewalkViewer.prototype.endSizerDrag = function(ev) {
-  this.overlay.hide();
-  this.updateHeight();
-};
-
-/**
- * Toggles the Codewalk description between being shown and hidden.
- * @param {jQuery} target The target that was clicked to trigger this function.
- */
-CodewalkViewer.prototype.toggleDescription = function(target) {
-  var description = this.context.find('#description');
-  description.toggle();
-  target.find('span').text(description.is(':hidden') ? 'show' : 'hide');
-  this.updateHeight();
-};
-
-/**
- * Changes the side of the window on which the code is shown and saves the
- * setting in a cookie.
- * @param {string?} codeSide The side on which the code should be, either
- *     'left' or 'right'.
- */
-CodewalkViewer.prototype.changeCodeSide = function(codeSide) {
-  var commentSide = codeSide == 'left' ? 'right' : 'left';
-  this.context.find('#set-code-' + codeSide).addClass('selected');
-  this.context.find('#set-code-' + commentSide).removeClass('selected');
-  // Remove previous side class and add new one.
-  this.codeColumn.addClass(codeSide).removeClass(commentSide);
-  this.commentColumn.addClass(commentSide).removeClass(codeSide);
-  this.sizer.css(codeSide, 'auto').css(commentSide, 0);
-  this.options.codeSide = codeSide;
-};
-
-/**
- * Adds selected class to newly selected comment, removes selected style from
- * previously selected comment, changes drop down options so that the correct
- * file is selected, and updates the code popout link.
- * @param {jQuery} target The target that was clicked to trigger this function.
- */
-CodewalkViewer.prototype.changeSelectedComment = function(target) {
-  var currentFile = target.find('.comment-link').attr('href');
-  if (!currentFile) return;
-
-  if (!(this.lastSelected && this.lastSelected.get(0) === target.get(0))) {
-    if (this.lastSelected) this.lastSelected.removeClass('selected');
-    target.addClass('selected');
-    this.lastSelected = target;
-    var targetTop = target.position().top;
-    var parentTop = target.parent().position().top;
-    if (targetTop + target.height() > parentTop + target.parent().height() ||
-        targetTop < parentTop) {
-      var delta = targetTop - parentTop;
-      target.parent().animate(
-          {'scrollTop': target.parent().scrollTop() + delta},
-          Math.max(delta / 2, 200), 'swing');
-    }
-    var fname = currentFile.match(/(?:select=|fileprint=)\/[^&]+/)[0];
-    fname = fname.slice(fname.indexOf('=')+2, fname.length);
-    this.context.find('#code-selector').val(fname);
-    this.context.find('#prev-comment').toggleClass(
-        'disabled', !target.prev().length);
-    this.context.find('#next-comment').toggleClass(
-        'disabled', !target.next().length);
-  }
-
-  // Force original file even if user hasn't changed comments since they may
-  // have navigated away from it within the iframe without us knowing.
-  this.navigateToCode(currentFile);
-};
-
-/**
- * Updates the viewer by changing the height of the comments and code so that
- * they fit within the height of the window.  The function is typically called
- * after the user changes the window size.
- */
-CodewalkViewer.prototype.updateHeight = function() {
-  var windowHeight = jQuery(window).height() - 5  // GOK
-  var areaHeight = windowHeight - this.codeArea.offset().top
-  var footerHeight = this.context.find('#footer').outerHeight(true)
-  this.commentArea.height(areaHeight - footerHeight - this.context.find('#comment-options').outerHeight(true))
-  var codeHeight = areaHeight - footerHeight - 15  // GOK
-  this.codeArea.height(codeHeight)
-  this.codeDisplay.height(codeHeight - this.codeDisplay.offset().top + this.codeArea.offset().top);
-  this.sizer.height(codeHeight);
-};
-
-window.initFuncs.push(function() {
-  var viewer = new CodewalkViewer(jQuery('#codewalk-main'));
-  viewer.selectFirstComment();
-  viewer.targetCommentLinksAtBlank();
-  viewer.installEventHandlers();
-  viewer.updateHeight();
-});

diff --git a/doc/codewalk/codewalk.xml b/doc/codewalk/codewalk.xml
deleted file mode 100644 (file)
index 34e6e91..0000000
--- a/doc/codewalk/codewalk.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<codewalk title="How to Write a Codewalk">
-
-<step title="Introduction" src="doc/codewalk/codewalk.xml">
-       A codewalk is a guided tour through a piece of code.
-       It consists of a sequence of steps, each typically explaining
-       a highlighted section of code.
-       <br/><br/>
-       
-       The <a href="/cmd/godoc">godoc</a> web server translates
-       an XML file like the one in the main window pane into the HTML
-       page that you're viewing now.
-       <br/><br/>
-       
-       The codewalk with URL path <code>/doc/codewalk/</code><i>name</i>
-       is loaded from the input file <code>$GOROOT/doc/codewalk/</code><i>name</i><code>.xml</code>.
-       <br/><br/>
-       
-       This codewalk explains how to write a codewalk by examining
-       its own source code,
-       <code><a href="/doc/codewalk/codewalk.xml">$GOROOT/doc/codewalk/codewalk.xml</a></code>,
-       shown in the main window pane to the left.      
-</step>
-
-<step title="Title" src="doc/codewalk/codewalk.xml:/title=/">
-       The codewalk input file is an XML file containing a single
-       <code>&lt;codewalk&gt;</code> element.
-       That element's <code>title</code> attribute gives the title
-       that is used both on the codewalk page and in the codewalk list.
-</step>
-
-<step title="Steps" src="doc/codewalk/codewalk.xml:/&lt;step/,/step&gt;/">
-       Each step in the codewalk is a <code>&lt;step&gt;</code> element 
-       nested inside the main <code>&lt;codewalk&gt;</code>.
-       The step element's <code>title</code> attribute gives the step's title,
-       which is shown in a shaded bar above the main step text.
-       The element's <code>src</code> attribute specifies the source
-       code to show in the main window pane and, optionally, a range of 
-       lines to highlight.
-       <br/><br/>
-       
-       The first step in this codewalk does not highlight any lines:
-       its <code>src</code> is just a file name.
-</step>
-
-<step title="Specifying a source line" src='doc/codewalk/codewalk.xml:/title="Title"/'>
-       The most complex part of the codewalk specification is
-       saying what lines to highlight.
-       Instead of ordinary line numbers,
-       the codewalk uses an address syntax that makes it possible
-       to describe the match by its content.
-       As the file gets edited, this descriptive address has a better
-       chance to continue to refer to the right section of the file.
-       <br/><br/>
-
-       To specify a source line, use a <code>src</code> attribute of the form
-       <i>filename</i><code>:</code><i>address</i>,
-       where <i>address</i> is an address in the syntax used by the text editors <i>sam</i> and <i>acme</i>.
-       <br/><br/>
-       
-       The simplest address is a single regular expression.
-       The highlighted line in the main window pane shows that the
-       address for the &ldquo;Title&rdquo; step was <code>/title=/</code>,
-       which matches the first instance of that <a href="/pkg/regexp">regular expression</a> (<code>title=</code>) in the file.
-</step>
-
-<step title="Specifying a source range" src='doc/codewalk/codewalk.xml:/title="Steps"/'>
-       To highlight a range of source lines, the simplest address to use is
-       a pair of regular expressions
-       <code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>.
-       The highlight begins with the line containing the first match for <i>regexp1</i>
-       and ends with the line containing the first match for <i>regexp2</i>
-       after the end of the match for <i>regexp1</i>.
-       Ignoring the HTML quoting, 
-       The line containing the first match for <i>regexp1</i> will be the first one highlighted,
-       and the line containing the first match for <i>regexp2</i>.
-       <br/><br/>
-       
-       The address <code>/&lt;step/,/step&gt;/</code> looks for the first instance of
-       <code>&lt;step</code> in the file, and then starting after that point,
-       looks for the first instance of <code>step&gt;</code>.
-       (Click on the &ldquo;Steps&rdquo; step above to see the highlight in action.)
-       Note that the <code>&lt;</code> and <code>&gt;</code> had to be written
-       using XML escapes in order to be valid XML.
-</step>
-
-<step title="Advanced addressing" src="doc/codewalk/codewalk.xml:/Advanced/,/step&gt;/">
-       The <code>/</code><i>regexp</i><code>/</code>
-       and <code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>
-       forms suffice for most highlighting.
-       <br/><br/>
-
-       The full address syntax is summarized in this table
-       (an excerpt of Table II from
-       <a href="https://9p.io/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
-       <br/><br/>
-
-       <table>
-       <tr><td colspan="2"><b>Simple addresses</b></td></tr>
-       <tr><td><code>#</code><i>n</i></td>
-           <td>The empty string after character <i>n</i></td></tr>
-       <tr><td><i>n</i></td>
-           <td>Line <i>n</i></td></tr>
-       <tr><td><code>/</code><i>regexp</i><code>/</code></td>
-           <td>The first following match of the regular expression</td></tr>
-       <!-- not supported (yet?)
-       <tr><td><code>–/</code><i>regexp</i><code>/</code></td>
-           <td>The first previous match of the regular expression</td></tr>
-       -->
-       <tr><td><code>$</code></td>
-           <td>The null string at the end of the file</td></tr>
-
-       <tr><td colspan="2"><b>Compound addresses</b></td></tr>
-       <tr><td><i>a1</i><code>+</code><i>a2</i></td>
-           <td>The address <i>a2</i> evaluated starting at the right of <i>a1</i></td></tr>
-       <tr><td><i>a1</i><code>-</code><i>a2</i></td>
-           <td>The address <i>a2</i> evaluated in the reverse direction starting at the left of <i>a1</i></td></tr>
-       <tr><td><i>a1</i><code>,</code><i>a2</i></td>
-           <td>From the left of <i>a1</i> to the right of <i>a2</i> (default <code>0,$</code>).</td></tr>
-       </table>
-</step>
-
-
-       
-</codewalk>

diff --git a/doc/codewalk/codewalk_test.go b/doc/codewalk/codewalk_test.go
deleted file mode 100644 (file)
index 31f078a..0000000
--- a/doc/codewalk/codewalk_test.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main_test
-
-import (
-       "bytes"
-       "os"
-       "os/exec"
-       "strings"
-       "testing"
-)
-
-// TestMarkov tests the code dependency of markov.xml.
-func TestMarkov(t *testing.T) {
-       cmd := exec.Command("go", "run", "markov.go")
-       cmd.Stdin = strings.NewReader("foo")
-       cmd.Stderr = bytes.NewBuffer(nil)
-       out, err := cmd.Output()
-       if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-       }
-
-       if !bytes.Equal(out, []byte("foo\n")) {
-               t.Fatalf(`%s with input "foo" did not output "foo":\n%s`, strings.Join(cmd.Args, " "), out)
-       }
-}
-
-// TestPig tests the code dependency of functions.xml.
-func TestPig(t *testing.T) {
-       cmd := exec.Command("go", "run", "pig.go")
-       cmd.Stderr = bytes.NewBuffer(nil)
-       out, err := cmd.Output()
-       if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-       }
-
-       const want = "Wins, losses staying at k = 100: 210/990 (21.2%), 780/990 (78.8%)\n"
-       if !bytes.Contains(out, []byte(want)) {
-               t.Fatalf(`%s: unexpected output\ngot:\n%s\nwant output containing:\n%s`, strings.Join(cmd.Args, " "), out, want)
-       }
-}
-
-// TestURLPoll tests the code dependency of sharemem.xml.
-func TestURLPoll(t *testing.T) {
-       cmd := exec.Command("go", "build", "-o", os.DevNull, "urlpoll.go")
-       out, err := cmd.CombinedOutput()
-       if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-       }
-}

diff --git a/doc/codewalk/functions.xml b/doc/codewalk/functions.xml
deleted file mode 100644 (file)
index db518dc..0000000
--- a/doc/codewalk/functions.xml
+++ /dev/null
@@ -1,105 +0,0 @@
-<codewalk title="First-Class Functions in Go">
-
-<step title="Introduction" src="doc/codewalk/pig.go">
-       Go supports first class functions, higher-order functions, user-defined
-       function types, function literals, closures, and multiple return values.
-  <br/><br/>
-
-       This rich feature set supports a functional programming style in a strongly
-       typed language.
-       <br/><br/>
-
-       In this codewalk we will look at a simple program that simulates a dice game
-       called <a href="http://en.wikipedia.org/wiki/Pig_(dice)">Pig</a> and evaluates
-       basic strategies.
-</step>
-
-<step title="Game overview" src="doc/codewalk/pig.go:/\/\/ A score/,/thisTurn int\n}/">
-  Pig is a two-player game played with a 6-sided die.  Each turn, you may roll or stay.
-       <ul>
-               <li> If you roll a 1, you lose all points for your turn and play passes to
-                       your opponent.  Any other roll adds its value to your turn score.  </li>
-               <li> If you stay, your turn score is added to your total score, and play passes
-                       to your opponent.  </li>
-       </ul>
-       
-       The first person to reach 100 total points wins.
-       <br/><br/>
-
-       The <code>score</code> type stores the scores of the current and opposing
-       players, in addition to the points accumulated during the current turn.
-</step>
-
-<step title="User-defined function types" src="doc/codewalk/pig.go:/\/\/ An action/,/bool\)/">
-       In Go, functions can be passed around just like any other value. A function's
-       type signature describes the types of its arguments and return values.
-       <br/><br/>
-
-       The <code>action</code> type is a function that takes a <code>score</code>
-       and returns the resulting <code>score</code> and whether the current turn is
-       over.
-       <br/><br/>
-
-  If the turn is over, the <code>player</code> and <code>opponent</code> fields
-  in the resulting <code>score</code> should be swapped, as it is now the other player's
-  turn.
-</step>
-
-<step title="Multiple return values" src="doc/codewalk/pig.go:/\/\/ roll returns/,/true\n}/">
-       Go functions can return multiple values.  
-       <br/><br/>
-
-       The functions <code>roll</code> and <code>stay</code> each return a pair of
-       values.  They also match the <code>action</code> type signature.  These
-       <code>action</code> functions define the rules of Pig.
-</step>
-
-<step title="Higher-order functions" src="doc/codewalk/pig.go:/\/\/ A strategy/,/action\n/">
-       A function can use other functions as arguments and return values.
-       <br/><br/>
-
-  A <code>strategy</code> is a function that takes a <code>score</code> as input
-  and returns an <code>action</code> to perform.  <br/>
-  (Remember, an <code>action</code> is itself a function.)
-</step>
-
-<step title="Function literals and closures" src="doc/codewalk/pig.go:/return func/,/return roll\n\t}/">
-       Anonymous functions can be declared in Go, as in this example.  Function
-       literals are closures: they inherit the scope of the function in which they
-       are declared.
-       <br/><br/>
-
-       One basic strategy in Pig is to continue rolling until you have accumulated at
-       least k points in a turn, and then stay.  The argument <code>k</code> is
-       enclosed by this function literal, which matches the <code>strategy</code> type
-       signature.
-</step>
-
-<step title="Simulating games" src="doc/codewalk/pig.go:/\/\/ play/,/currentPlayer\n}/">
-  We simulate a game of Pig by calling an <code>action</code> to update the
-  <code>score</code> until one player reaches 100 points.  Each
-  <code>action</code> is selected by calling the <code>strategy</code> function
-  associated with the current player.
-</step>
-
-<step title="Simulating a tournament" src="doc/codewalk/pig.go:/\/\/ roundRobin/,/gamesPerStrategy\n}/">
-       The <code>roundRobin</code> function simulates a tournament and tallies wins.
-       Each strategy plays each other strategy <code>gamesPerSeries</code> times.
-</step>
-       
-<step title="Variadic function declarations" src="doc/codewalk/pig.go:/\/\/ ratioS/,/string {/">
-       Variadic functions like <code>ratioString</code> take a variable number of
-       arguments.  These arguments are available as a slice inside the function.
-</step>
-
-<step title="Simulation results" src="doc/codewalk/pig.go:/func main/,/\n}/">
-       The <code>main</code> function defines 100 basic strategies, simulates a round
-       robin tournament, and then prints the win/loss record of each strategy.
-       <br/><br/>
-
-       Among these strategies, staying at 25 is best, but the <a
-       href="http://www.google.com/search?q=optimal+play+pig">optimal strategy for
-       Pig</a> is much more complex.
-</step>
-
-</codewalk>

diff --git a/doc/codewalk/markov.go b/doc/codewalk/markov.go
deleted file mode 100644 (file)
index 5f62e05..0000000
--- a/doc/codewalk/markov.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Generating random text: a Markov chain algorithm
-
-Based on the program presented in the "Design and Implementation" chapter
-of The Practice of Programming (Kernighan and Pike, Addison-Wesley 1999).
-See also Computer Recreations, Scientific American 260, 122 - 125 (1989).
-
-A Markov chain algorithm generates text by creating a statistical model of
-potential textual suffixes for a given prefix. Consider this text:
-
-       I am not a number! I am a free man!
-
-Our Markov chain algorithm would arrange this text into this set of prefixes
-and suffixes, or "chain": (This table assumes a prefix length of two words.)
-
-       Prefix       Suffix
-
-       "" ""        I
-       "" I         am
-       I am         a
-       I am         not
-       a free       man!
-       am a         free
-       am not       a
-       a number!    I
-       number! I    am
-       not a        number!
-
-To generate text using this table we select an initial prefix ("I am", for
-example), choose one of the suffixes associated with that prefix at random
-with probability determined by the input statistics ("a"),
-and then create a new prefix by removing the first word from the prefix
-and appending the suffix (making the new prefix is "am a"). Repeat this process
-until we can't find any suffixes for the current prefix or we exceed the word
-limit. (The word limit is necessary as the chain table may contain cycles.)
-
-Our version of this program reads text from standard input, parsing it into a
-Markov chain, and writes generated text to standard output.
-The prefix and output lengths can be specified using the -prefix and -words
-flags on the command-line.
-*/
-package main
-
-import (
-       "bufio"
-       "flag"
-       "fmt"
-       "io"
-       "math/rand"
-       "os"
-       "strings"
-       "time"
-)
-
-// Prefix is a Markov chain prefix of one or more words.
-type Prefix []string
-
-// String returns the Prefix as a string (for use as a map key).
-func (p Prefix) String() string {
-       return strings.Join(p, " ")
-}
-
-// Shift removes the first word from the Prefix and appends the given word.
-func (p Prefix) Shift(word string) {
-       copy(p, p[1:])
-       p[len(p)-1] = word
-}
-
-// Chain contains a map ("chain") of prefixes to a list of suffixes.
-// A prefix is a string of prefixLen words joined with spaces.
-// A suffix is a single word. A prefix can have multiple suffixes.
-type Chain struct {
-       chain     map[string][]string
-       prefixLen int
-}
-
-// NewChain returns a new Chain with prefixes of prefixLen words.
-func NewChain(prefixLen int) *Chain {
-       return &Chain{make(map[string][]string), prefixLen}
-}
-
-// Build reads text from the provided Reader and
-// parses it into prefixes and suffixes that are stored in Chain.
-func (c *Chain) Build(r io.Reader) {
-       br := bufio.NewReader(r)
-       p := make(Prefix, c.prefixLen)
-       for {
-               var s string
-               if _, err := fmt.Fscan(br, &s); err != nil {
-                       break
-               }
-               key := p.String()
-               c.chain[key] = append(c.chain[key], s)
-               p.Shift(s)
-       }
-}
-
-// Generate returns a string of at most n words generated from Chain.
-func (c *Chain) Generate(n int) string {
-       p := make(Prefix, c.prefixLen)
-       var words []string
-       for i := 0; i < n; i++ {
-               choices := c.chain[p.String()]
-               if len(choices) == 0 {
-                       break
-               }
-               next := choices[rand.Intn(len(choices))]
-               words = append(words, next)
-               p.Shift(next)
-       }
-       return strings.Join(words, " ")
-}
-
-func main() {
-       // Register command-line flags.
-       numWords := flag.Int("words", 100, "maximum number of words to print")
-       prefixLen := flag.Int("prefix", 2, "prefix length in words")
-
-       flag.Parse()                     // Parse command-line flags.
-       rand.Seed(time.Now().UnixNano()) // Seed the random number generator.
-
-       c := NewChain(*prefixLen)     // Initialize a new Chain.
-       c.Build(os.Stdin)             // Build chains from standard input.
-       text := c.Generate(*numWords) // Generate text.
-       fmt.Println(text)             // Write text to standard output.
-}

diff --git a/doc/codewalk/markov.xml b/doc/codewalk/markov.xml
deleted file mode 100644 (file)
index 7e44840..0000000
--- a/doc/codewalk/markov.xml
+++ /dev/null
@@ -1,307 +0,0 @@
-<!--
-Copyright 2011 The Go Authors. All rights reserved.
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file.
--->
-
-<codewalk title="Generating arbitrary text: a Markov chain algorithm">
-
-<step title="Introduction" src="doc/codewalk/markov.go:/Generating/,/line\./">
-       This codewalk describes a program that generates random text using
-       a Markov chain algorithm. The package comment describes the algorithm
-       and the operation of the program. Please read it before continuing.
-</step>
-
-<step title="Modeling Markov chains" src="doc/codewalk/markov.go:/     chain/">
-       A chain consists of a prefix and a suffix. Each prefix is a set
-       number of words, while a suffix is a single word.
-       A prefix can have an arbitrary number of suffixes.
-       To model this data, we use a <code>map[string][]string</code>.
-       Each map key is a prefix (a <code>string</code>) and its values are
-       lists of suffixes (a slice of strings, <code>[]string</code>).
-       <br/><br/>
-       Here is the example table from the package comment
-       as modeled by this data structure:
-       <pre>
-map[string][]string{
-       " ":          {"I"},
-       " I":         {"am"},
-       "I am":       {"a", "not"},
-       "a free":     {"man!"},
-       "am a":       {"free"},
-       "am not":     {"a"},
-       "a number!":  {"I"},
-       "number! I":  {"am"},
-       "not a":      {"number!"},
-}</pre>
-       While each prefix consists of multiple words, we
-       store prefixes in the map as a single <code>string</code>.
-       It would seem more natural to store the prefix as a
-       <code>[]string</code>, but we can't do this with a map because the
-       key type of a map must implement equality (and slices do not).
-       <br/><br/>
-       Therefore, in most of our code we will model prefixes as a
-       <code>[]string</code> and join the strings together with a space
-       to generate the map key:
-       <pre>
-Prefix               Map key
-
-[]string{"", ""}     " "
-[]string{"", "I"}    " I"
-[]string{"I", "am"}  "I am"
-</pre>
-</step>
-
-<step title="The Chain struct" src="doc/codewalk/markov.go:/type Chain/,/}/">
-       The complete state of the chain table consists of the table itself and
-       the word length of the prefixes. The <code>Chain</code> struct stores
-       this data.
-</step>
-
-<step title="The NewChain constructor function" src="doc/codewalk/markov.go:/func New/,/\n}/">
-       The <code>Chain</code> struct has two unexported fields (those that
-       do not begin with an upper case character), and so we write a
-       <code>NewChain</code> constructor function that initializes the
-       <code>chain</code> map with <code>make</code> and sets the
-       <code>prefixLen</code> field.
-       <br/><br/>
-       This is constructor function is not strictly necessary as this entire
-       program is within a single package (<code>main</code>) and therefore
-       there is little practical difference between exported and unexported
-       fields. We could just as easily write out the contents of this function
-       when we want to construct a new Chain.
-       But using these unexported fields is good practice; it clearly denotes
-       that only methods of Chain and its constructor function should access
-       those fields. Also, structuring <code>Chain</code> like this means we
-       could easily move it into its own package at some later date.
-</step>
-
-<step title="The Prefix type" src="doc/codewalk/markov.go:/type Prefix/">
-       Since we'll be working with prefixes often, we define a
-       <code>Prefix</code> type with the concrete type <code>[]string</code>.
-       Defining a named type clearly allows us to be explicit when we are
-       working with a prefix instead of just a <code>[]string</code>.
-       Also, in Go we can define methods on any named type (not just structs),
-       so we can add methods that operate on <code>Prefix</code> if we need to.
-</step>
-
-<step title="The String method" src="doc/codewalk/markov.go:/func[^\n]+String/,/}/">
-       The first method we define on <code>Prefix</code> is
-       <code>String</code>. It returns a <code>string</code> representation
-       of a <code>Prefix</code> by joining the slice elements together with
-       spaces. We will use this method to generate keys when working with
-       the chain map.
-</step>
-
-<step title="Building the chain" src="doc/codewalk/markov.go:/func[^\n]+Build/,/\n}/">
-       The <code>Build</code> method reads text from an <code>io.Reader</code>
-       and parses it into prefixes and suffixes that are stored in the
-       <code>Chain</code>.
-       <br/><br/>
-       The <code><a href="/pkg/io/#Reader">io.Reader</a></code> is an
-       interface type that is widely used by the standard library and
-       other Go code. Our code uses the
-       <code><a href="/pkg/fmt/#Fscan">fmt.Fscan</a></code> function, which
-       reads space-separated values from an <code>io.Reader</code>.
-       <br/><br/>
-       The <code>Build</code> method returns once the <code>Reader</code>'s
-       <code>Read</code> method returns <code>io.EOF</code> (end of file)
-       or some other read error occurs.
-</step>
-
-<step title="Buffering the input" src="doc/codewalk/markov.go:/bufio\.NewReader/">
-       This function does many small reads, which can be inefficient for some
-       <code>Readers</code>. For efficiency we wrap the provided
-       <code>io.Reader</code> with
-       <code><a href="/pkg/bufio/">bufio.NewReader</a></code> to create a
-       new <code>io.Reader</code> that provides buffering.
-</step>
-
-<step title="The Prefix variable" src="doc/codewalk/markov.go:/make\(Prefix/">
-       At the top of the function we make a <code>Prefix</code> slice
-       <code>p</code> using the <code>Chain</code>'s <code>prefixLen</code>
-       field as its length.
-       We'll use this variable to hold the current prefix and mutate it with
-       each new word we encounter.
-</step>
-
-<step title="Scanning words" src="doc/codewalk/markov.go:/var s string/,/\n            }/">
-       In our loop we read words from the <code>Reader</code> into a
-       <code>string</code> variable <code>s</code> using
-       <code>fmt.Fscan</code>. Since <code>Fscan</code> uses space to
-       separate each input value, each call will yield just one word
-       (including punctuation), which is exactly what we need.
-       <br/><br/>
-       <code>Fscan</code> returns an error if it encounters a read error
-       (<code>io.EOF</code>, for example) or if it can't scan the requested
-       value (in our case, a single string). In either case we just want to
-       stop scanning, so we <code>break</code> out of the loop.
-</step>
-
-<step title="Adding a prefix and suffix to the chain" src="doc/codewalk/markov.go:/    key/,/key\], s\)">
-       The word stored in <code>s</code> is a new suffix. We add the new
-       prefix/suffix combination to the <code>chain</code> map by computing
-       the map key with <code>p.String</code> and appending the suffix
-       to the slice stored under that key.
-       <br/><br/>
-       The built-in <code>append</code> function appends elements to a slice
-       and allocates new storage when necessary. When the provided slice is
-       <code>nil</code>, <code>append</code> allocates a new slice.
-       This behavior conveniently ties in with the semantics of our map:
-       retrieving an unset key returns the zero value of the value type and
-       the zero value of <code>[]string</code> is <code>nil</code>.
-       When our program encounters a new prefix (yielding a <code>nil</code>
-       value in the map) <code>append</code> will allocate a new slice.
-       <br/><br/>
-       For more information about the <code>append</code> function and slices
-       in general see the
-       <a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and internals</a> article.
-</step>
-
-<step title="Pushing the suffix onto the prefix" src="doc/codewalk/markov.go:/p\.Shift/">
-       Before reading the next word our algorithm requires us to drop the
-       first word from the prefix and push the current suffix onto the prefix.
-       <br/><br/>
-       When in this state
-       <pre>
-p == Prefix{"I", "am"}
-s == "not" </pre>
-       the new value for <code>p</code> would be
-       <pre>
-p == Prefix{"am", "not"}</pre>
-       This operation is also required during text generation so we put
-       the code to perform this mutation of the slice inside a method on
-       <code>Prefix</code> named <code>Shift</code>.
-</step>
-
-<step title="The Shift method" src="doc/codewalk/markov.go:/func[^\n]+Shift/,/\n}/">
-       The <code>Shift</code> method uses the built-in <code>copy</code>
-       function to copy the last len(p)-1 elements of <code>p</code> to
-       the start of the slice, effectively moving the elements
-       one index to the left (if you consider zero as the leftmost index).
-       <pre>
-p := Prefix{"I", "am"}
-copy(p, p[1:])
-// p == Prefix{"am", "am"}</pre>
-       We then assign the provided <code>word</code> to the last index
-       of the slice:
-       <pre>
-// suffix == "not"
-p[len(p)-1] = suffix
-// p == Prefix{"am", "not"}</pre>
-</step>
-
-<step title="Generating text" src="doc/codewalk/markov.go:/func[^\n]+Generate/,/\n}/">
-       The <code>Generate</code> method is similar to <code>Build</code>
-       except that instead of reading words from a <code>Reader</code>
-       and storing them in a map, it reads words from the map and
-       appends them to a slice (<code>words</code>).
-       <br/><br/>
-       <code>Generate</code> uses a conditional for loop to generate
-       up to <code>n</code> words.
-</step>
-
-<step title="Getting potential suffixes" src="doc/codewalk/markov.go:/choices/,/}\n/">
-       At each iteration of the loop we retrieve a list of potential suffixes
-       for the current prefix. We access the <code>chain</code> map at key
-       <code>p.String()</code> and assign its contents to <code>choices</code>.
-       <br/><br/>
-       If <code>len(choices)</code> is zero we break out of the loop as there
-       are no potential suffixes for that prefix.
-       This test also works if the key isn't present in the map at all:
-       in that case, <code>choices</code> will be <code>nil</code> and the
-       length of a <code>nil</code> slice is zero.
-</step>
-
-<step title="Choosing a suffix at random" src="doc/codewalk/markov.go:/next := choices/,/Shift/">
-       To choose a suffix we use the
-       <code><a href="/pkg/math/rand/#Intn">rand.Intn</a></code> function.
-       It returns a random integer up to (but not including) the provided
-       value. Passing in <code>len(choices)</code> gives us a random index
-       into the full length of the list.
-       <br/><br/>
-       We use that index to pick our new suffix, assign it to
-       <code>next</code> and append it to the <code>words</code> slice.
-       <br/><br/>
-       Next, we <code>Shift</code> the new suffix onto the prefix just as
-       we did in the <code>Build</code> method.
-</step>
-
-<step title="Returning the generated text" src="doc/codewalk/markov.go:/Join\(words/">
-       Before returning the generated text as a string, we use the
-       <code>strings.Join</code> function to join the elements of
-       the <code>words</code> slice together, separated by spaces.
-</step>
-
-<step title="Command-line flags" src="doc/codewalk/markov.go:/Register command-line flags/,/prefixLen/">
-       To make it easy to tweak the prefix and generated text lengths we
-       use the <code><a href="/pkg/flag/">flag</a></code> package to parse
-       command-line flags.
-       <br/><br/>
-       These calls to <code>flag.Int</code> register new flags with the
-       <code>flag</code> package. The arguments to <code>Int</code> are the
-       flag name, its default value, and a description. The <code>Int</code>
-       function returns a pointer to an integer that will contain the
-       user-supplied value (or the default value if the flag was omitted on
-       the command-line).
-</step>
-
-<step title="Program set up" src="doc/codewalk/markov.go:/flag.Parse/,/rand.Seed/">
-       The <code>main</code> function begins by parsing the command-line
-       flags with <code>flag.Parse</code> and seeding the <code>rand</code>
-       package's random number generator with the current time.
-       <br/><br/>
-       If the command-line flags provided by the user are invalid the
-       <code>flag.Parse</code> function will print an informative usage
-       message and terminate the program.
-</step>
-
-<step title="Creating and building a new Chain" src="doc/codewalk/markov.go:/c := NewChain/,/c\.Build/">
-       To create the new <code>Chain</code> we call <code>NewChain</code>
-       with the value of the <code>prefix</code> flag.
-       <br/><br/>
-       To build the chain we call <code>Build</code> with
-       <code>os.Stdin</code> (which implements <code>io.Reader</code>) so
-       that it will read its input from standard input.
-</step>
-
-<step title="Generating and printing text" src="doc/codewalk/markov.go:/c\.Generate/,/fmt.Println/">
-       Finally, to generate text we call <code>Generate</code> with
-       the value of the <code>words</code> flag and assigning the result
-       to the variable <code>text</code>.
-       <br/><br/>
-       Then we call <code>fmt.Println</code> to write the text to standard
-       output, followed by a carriage return.
-</step>
-
-<step title="Using this program" src="doc/codewalk/markov.go">
-       To use this program, first build it with the
-       <a href="/cmd/go/">go</a> command:
-       <pre>
-$ go build markov.go</pre>
-       And then execute it while piping in some input text:
-       <pre>
-$ echo "a man a plan a canal panama" \
-       | ./markov -prefix=1
-a plan a man a plan a canal panama</pre>
-       Here's a transcript of generating some text using the Go distribution's
-       README file as source material:
-       <pre>
-$ ./markov -words=10 &lt; $GOROOT/README
-This is the source code repository for the Go source
-$ ./markov -prefix=1 -words=10 &lt; $GOROOT/README
-This is the go directory (the one containing this README).
-$ ./markov -prefix=1 -words=10 &lt; $GOROOT/README
-This is the variable if you have just untarred a</pre>
-</step>
-
-<step title="An exercise for the reader" src="doc/codewalk/markov.go">
-       The <code>Generate</code> function does a lot of allocations when it
-       builds the <code>words</code> slice. As an exercise, modify it to
-       take an <code>io.Writer</code> to which it incrementally writes the
-       generated text with <code>Fprint</code>.
-       Aside from being more efficient this makes <code>Generate</code>
-       more symmetrical to <code>Build</code>.
-</step>
-
-</codewalk>

diff --git a/doc/codewalk/pig.go b/doc/codewalk/pig.go
deleted file mode 100644 (file)
index 941daae..0000000
--- a/doc/codewalk/pig.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "math/rand"
-)
-
-const (
-       win            = 100 // The winning score in a game of Pig
-       gamesPerSeries = 10  // The number of games per series to simulate
-)
-
-// A score includes scores accumulated in previous turns for each player,
-// as well as the points scored by the current player in this turn.
-type score struct {
-       player, opponent, thisTurn int
-}
-
-// An action transitions stochastically to a resulting score.
-type action func(current score) (result score, turnIsOver bool)
-
-// roll returns the (result, turnIsOver) outcome of simulating a die roll.
-// If the roll value is 1, then thisTurn score is abandoned, and the players'
-// roles swap.  Otherwise, the roll value is added to thisTurn.
-func roll(s score) (score, bool) {
-       outcome := rand.Intn(6) + 1 // A random int in [1, 6]
-       if outcome == 1 {
-               return score{s.opponent, s.player, 0}, true
-       }
-       return score{s.player, s.opponent, outcome + s.thisTurn}, false
-}
-
-// stay returns the (result, turnIsOver) outcome of staying.
-// thisTurn score is added to the player's score, and the players' roles swap.
-func stay(s score) (score, bool) {
-       return score{s.opponent, s.player + s.thisTurn, 0}, true
-}
-
-// A strategy chooses an action for any given score.
-type strategy func(score) action
-
-// stayAtK returns a strategy that rolls until thisTurn is at least k, then stays.
-func stayAtK(k int) strategy {
-       return func(s score) action {
-               if s.thisTurn >= k {
-                       return stay
-               }
-               return roll
-       }
-}
-
-// play simulates a Pig game and returns the winner (0 or 1).
-func play(strategy0, strategy1 strategy) int {
-       strategies := []strategy{strategy0, strategy1}
-       var s score
-       var turnIsOver bool
-       currentPlayer := rand.Intn(2) // Randomly decide who plays first
-       for s.player+s.thisTurn < win {
-               action := strategies[currentPlayer](s)
-               s, turnIsOver = action(s)
-               if turnIsOver {
-                       currentPlayer = (currentPlayer + 1) % 2
-               }
-       }
-       return currentPlayer
-}
-
-// roundRobin simulates a series of games between every pair of strategies.
-func roundRobin(strategies []strategy) ([]int, int) {
-       wins := make([]int, len(strategies))
-       for i := 0; i < len(strategies); i++ {
-               for j := i + 1; j < len(strategies); j++ {
-                       for k := 0; k < gamesPerSeries; k++ {
-                               winner := play(strategies[i], strategies[j])
-                               if winner == 0 {
-                                       wins[i]++
-                               } else {
-                                       wins[j]++
-                               }
-                       }
-               }
-       }
-       gamesPerStrategy := gamesPerSeries * (len(strategies) - 1) // no self play
-       return wins, gamesPerStrategy
-}
-
-// ratioString takes a list of integer values and returns a string that lists
-// each value and its percentage of the sum of all values.
-// e.g., ratios(1, 2, 3) = "1/6 (16.7%), 2/6 (33.3%), 3/6 (50.0%)"
-func ratioString(vals ...int) string {
-       total := 0
-       for _, val := range vals {
-               total += val
-       }
-       s := ""
-       for _, val := range vals {
-               if s != "" {
-                       s += ", "
-               }
-               pct := 100 * float64(val) / float64(total)
-               s += fmt.Sprintf("%d/%d (%0.1f%%)", val, total, pct)
-       }
-       return s
-}
-
-func main() {
-       strategies := make([]strategy, win)
-       for k := range strategies {
-               strategies[k] = stayAtK(k + 1)
-       }
-       wins, games := roundRobin(strategies)
-
-       for k := range strategies {
-               fmt.Printf("Wins, losses staying at k =% 4d: %s\n",
-                       k+1, ratioString(wins[k], games-wins[k]))
-       }
-}

diff --git a/doc/codewalk/popout.png b/doc/codewalk/popout.png
deleted file mode 100644 (file)
index 9c0c236..0000000
Binary files a/doc/codewalk/popout.png and /dev/null differ

diff --git a/doc/codewalk/sharemem.xml b/doc/codewalk/sharemem.xml
deleted file mode 100644 (file)
index 8b47f12..0000000
--- a/doc/codewalk/sharemem.xml
+++ /dev/null
@@ -1,181 +0,0 @@
-<codewalk title="Share Memory By Communicating">
-
-<step title="Introduction" src="doc/codewalk/urlpoll.go">
-Go's approach to concurrency differs from the traditional use of
-threads and shared memory. Philosophically, it can be summarized:
-<br/><br/>
-<i>Don't communicate by sharing memory; share memory by communicating.</i>
-<br/><br/>
-Channels allow you to pass references to data structures between goroutines.
-If you consider this as passing around ownership of the data (the ability to
-read and write it), they become a powerful and expressive synchronization 
-mechanism.
-<br/><br/>
-In this codewalk we will look at a simple program that polls a list of
-URLs, checking their HTTP response codes and periodically printing their state.
-</step>
-
-<step title="State type" src="doc/codewalk/urlpoll.go:/State/,/}/">
-The State type represents the state of a URL.
-<br/><br/>
-The Pollers send State values to the StateMonitor,
-which maintains a map of the current state of each URL.
-</step>
-
-<step title="Resource type" src="doc/codewalk/urlpoll.go:/Resource/,/}/">
-A Resource represents the state of a URL to be polled: the URL itself
-and the number of errors encountered since the last successful poll.
-<br/><br/>
-When the program starts, it allocates one Resource for each URL.
-The main goroutine and the Poller goroutines send the Resources to
-each other on channels.
-</step>
-
-<step title="Poller function" src="doc/codewalk/urlpoll.go:/func Poller/,/\n}/">
-Each Poller receives Resource pointers from an input channel.
-In this program, the convention is that sending a Resource pointer on
-a channel passes ownership of the underlying data from the sender
-to the receiver.  Because of this convention, we know that
-no two goroutines will access this Resource at the same time.
-This means we don't have to worry about locking to prevent concurrent 
-access to these data structures.
-<br/><br/>
-The Poller processes the Resource by calling its Poll method.
-<br/><br/>
-It sends a State value to the status channel, to inform the StateMonitor
-of the result of the Poll.
-<br/><br/>
-Finally, it sends the Resource pointer to the out channel. This can be
-interpreted as the Poller saying &quot;I'm done with this Resource&quot; and 
-returning ownership of it to the main goroutine. 
-<br/><br/>
-Several goroutines run Pollers, processing Resources in parallel.
-</step>
-
-<step title="The Poll method" src="doc/codewalk/urlpoll.go:/Poll executes/,/\n}/">
-The Poll method (of the Resource type) performs an HTTP HEAD request
-for the Resource's URL and returns the HTTP response's status code.
-If an error occurs, Poll logs the message to standard error and returns the 
-error string instead.
-</step>
-
-<step title="main function" src="doc/codewalk/urlpoll.go:/func main/,/\n}/">
-The main function starts the Poller and StateMonitor goroutines
-and then loops passing completed Resources back to the pending
-channel after appropriate delays.
-</step>
-
-<step title="Creating channels" src="doc/codewalk/urlpoll.go:/Create our/,/complete/">
-First, main makes two channels of *Resource, pending and complete.
-<br/><br/>
-Inside main, a new goroutine sends one Resource per URL to pending
-and the main goroutine receives completed Resources from complete.
-<br/><br/>
-The pending and complete channels are passed to each of the Poller
-goroutines, within which they are known as in and out. 
-</step>
-
-<step title="Initializing StateMonitor" src="doc/codewalk/urlpoll.go:/Launch the StateMonitor/,/statusInterval/">
-StateMonitor will initialize and launch a goroutine that stores the state 
-of each Resource. We will look at this function in detail later. 
-<br/><br/>
-For now, the important thing to note is that it returns a channel of State, 
-which is saved as status and passed to the Poller goroutines.
-</step>
-
-<step title="Launching Poller goroutines" src="doc/codewalk/urlpoll.go:/Launch some Poller/,/}/">
-Now that it has the necessary channels, main launches a number of
-Poller goroutines, passing the channels as arguments.
-The channels provide the means of communication between the main, Poller, and 
-StateMonitor goroutines.
-</step>
-
-<step title="Send Resources to pending" src="doc/codewalk/urlpoll.go:/Send some Resources/,/}\(\)/">
-To add the initial work to the system, main starts a new goroutine
-that allocates and sends one Resource per URL to pending.
-<br/><br/>
-The new goroutine is necessary because unbuffered channel sends and
-receives are synchronous. That means these channel sends will block until
-the Pollers are ready to read from pending.
-<br/><br/>
-Were these sends performed in the main goroutine with fewer Pollers than 
-channel sends, the program would reach a deadlock situation, because
-main would not yet be receiving from complete.
-<br/><br/>
-Exercise for the reader: modify this part of the program to read a list of
-URLs from a file. (You may want to move this goroutine into its own
-named function.)
-</step>
-
-<step title="Main Event Loop" src="doc/codewalk/urlpoll.go:/range complete/,/\n        }/">
-When a Poller is done with a Resource, it sends it on the complete channel.
-This loop receives those Resource pointers from complete.
-For each received Resource, it starts a new goroutine calling
-the Resource's Sleep method.  Using a new goroutine for each
-ensures that the sleeps can happen in parallel.
-<br/><br/>
-Note that any single Resource pointer may only be sent on either pending or
-complete at any one time. This ensures that a Resource is either being
-handled by a Poller goroutine or sleeping, but never both simultaneously.  
-In this way, we share our Resource data by communicating.
-</step>
-
-<step title="The Sleep method" src="doc/codewalk/urlpoll.go:/Sleep/,/\n}/">
-Sleep calls time.Sleep to pause before sending the Resource to done.
-The pause will either be of a fixed length (pollInterval) plus an
-additional delay proportional to the number of sequential errors (r.errCount).
-<br/><br/>
-This is an example of a typical Go idiom: a function intended to run inside 
-a goroutine takes a channel, upon which it sends its return value 
-(or other indication of completed state).
-</step>
-
-<step title="StateMonitor" src="doc/codewalk/urlpoll.go:/StateMonitor/,/\n}/">
-The StateMonitor receives State values on a channel and periodically
-outputs the state of all Resources being polled by the program.
-</step>
-
-<step title="The updates channel" src="doc/codewalk/urlpoll.go:/updates :=/">
-The variable updates is a channel of State, on which the Poller goroutines
-send State values.
-<br/><br/>
-This channel is returned by the function.
-</step>
-
-<step title="The urlStatus map" src="doc/codewalk/urlpoll.go:/urlStatus/">
-The variable urlStatus is a map of URLs to their most recent status. 
-</step>
-
-<step title="The Ticker object" src="doc/codewalk/urlpoll.go:/ticker/">
-A time.Ticker is an object that repeatedly sends a value on a channel at a 
-specified interval. 
-<br/><br/>
-In this case, ticker triggers the printing of the current state to 
-standard output every updateInterval nanoseconds.
-</step>
-
-<step title="The StateMonitor goroutine" src="doc/codewalk/urlpoll.go:/go func/,/}\(\)/">
-StateMonitor will loop forever, selecting on two channels: 
-ticker.C and update. The select statement blocks until one of its 
-communications is ready to proceed.
-<br/><br/>
-When StateMonitor receives a tick from ticker.C, it calls logState to
-print the current state.  When it receives a State update from updates,
-it records the new status in the urlStatus map.
-<br/><br/>
-Notice that this goroutine owns the urlStatus data structure,
-ensuring that it can only be accessed sequentially. 
-This prevents memory corruption issues that might arise from parallel reads 
-and/or writes to a shared map.
-</step>
-
-<step title="Conclusion" src="doc/codewalk/urlpoll.go">
-In this codewalk we have explored a simple example of using Go's concurrency
-primitives to share memory through communication.
-<br/><br/>
-This should provide a starting point from which to explore the ways in which
-goroutines and channels can be used to write expressive and concise concurrent
-programs.
-</step>
-       
-</codewalk>

diff --git a/doc/codewalk/urlpoll.go b/doc/codewalk/urlpoll.go
deleted file mode 100644 (file)
index 1fb9958..0000000
--- a/doc/codewalk/urlpoll.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "log"
-       "net/http"
-       "time"
-)
-
-const (
-       numPollers     = 2                // number of Poller goroutines to launch
-       pollInterval   = 60 * time.Second // how often to poll each URL
-       statusInterval = 10 * time.Second // how often to log status to stdout
-       errTimeout     = 10 * time.Second // back-off timeout on error
-)
-
-var urls = []string{
-       "http://www.google.com/",
-       "http://golang.org/",
-       "http://blog.golang.org/",
-}
-
-// State represents the last-known state of a URL.
-type State struct {
-       url    string
-       status string
-}
-
-// StateMonitor maintains a map that stores the state of the URLs being
-// polled, and prints the current state every updateInterval nanoseconds.
-// It returns a chan State to which resource state should be sent.
-func StateMonitor(updateInterval time.Duration) chan<- State {
-       updates := make(chan State)
-       urlStatus := make(map[string]string)
-       ticker := time.NewTicker(updateInterval)
-       go func() {
-               for {
-                       select {
-                       case <-ticker.C:
-                               logState(urlStatus)
-                       case s := <-updates:
-                               urlStatus[s.url] = s.status
-                       }
-               }
-       }()
-       return updates
-}
-
-// logState prints a state map.
-func logState(s map[string]string) {
-       log.Println("Current state:")
-       for k, v := range s {
-               log.Printf(" %s %s", k, v)
-       }
-}
-
-// Resource represents an HTTP URL to be polled by this program.
-type Resource struct {
-       url      string
-       errCount int
-}
-
-// Poll executes an HTTP HEAD request for url
-// and returns the HTTP status string or an error string.
-func (r *Resource) Poll() string {
-       resp, err := http.Head(r.url)
-       if err != nil {
-               log.Println("Error", r.url, err)
-               r.errCount++
-               return err.Error()
-       }
-       r.errCount = 0
-       return resp.Status
-}
-
-// Sleep sleeps for an appropriate interval (dependent on error state)
-// before sending the Resource to done.
-func (r *Resource) Sleep(done chan<- *Resource) {
-       time.Sleep(pollInterval + errTimeout*time.Duration(r.errCount))
-       done <- r
-}
-
-func Poller(in <-chan *Resource, out chan<- *Resource, status chan<- State) {
-       for r := range in {
-               s := r.Poll()
-               status <- State{r.url, s}
-               out <- r
-       }
-}
-
-func main() {
-       // Create our input and output channels.
-       pending, complete := make(chan *Resource), make(chan *Resource)
-
-       // Launch the StateMonitor.
-       status := StateMonitor(statusInterval)
-
-       // Launch some Poller goroutines.
-       for i := 0; i < numPollers; i++ {
-               go Poller(pending, complete, status)
-       }
-
-       // Send some Resources to the pending queue.
-       go func() {
-               for _, url := range urls {
-                       pending <- &Resource{url: url}
-               }
-       }()
-
-       for r := range complete {
-               go r.Sleep(pending)
-       }
-}

diff --git a/doc/contribute.html b/doc/contribute.html
deleted file mode 100644 (file)
index f297477..0000000
--- a/doc/contribute.html
+++ /dev/null
@@ -1,1294 +0,0 @@
-<!--{
-       "Title": "Contribution Guide"
-}-->
-
-<p>
-The Go project welcomes all contributors.
-</p>
-
-<p>
-This document is a guide to help you through the process
-of contributing to the Go project, which is a little different
-from that used by other open source projects.
-We assume you have a basic understanding of Git and Go.
-</p>
-
-<p>
-In addition to the information here, the Go community maintains a
-<a href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
-Feel free to contribute to the wiki as you learn the review process.
-</p>
-
-<p>
-Note that the <code>gccgo</code> front end lives elsewhere;
-see <a href="gccgo_contribute.html">Contributing to gccgo</a>.
-</p>
-
-<h2 id="contributor">Becoming a contributor</h2>
-
-<h3 id="contrib_overview">Overview</h3>
-
-<p>
-The first step is registering as a Go contributor and configuring your environment.
-Here is a checklist of the required steps to follow:
-</p>
-
-<ul>
-<li>
-<b>Step 0</b>: Decide on a single Google Account you will be using to contribute to Go.
-Use that account for all the following steps and make sure that <code>git</code>
-is configured to create commits with that account's e-mail address.
-</li>
-<li>
-<b>Step 1</b>: <a href="https://cla.developers.google.com/clas">Sign and submit</a> a
-CLA (Contributor License Agreement).
-</li>
-<li>
-<b>Step 2</b>: Configure authentication credentials for the Go Git repository.
-Visit <a href="https://go.googlesource.com">go.googlesource.com</a>, click
-"Generate Password" in the page's top right menu bar, and follow the
-instructions.
-</li>
-<li>
-<b>Step 3</b>: Register for Gerrit, the code review tool used by the Go team,
-by <a href="https://go-review.googlesource.com/login/">visiting this page</a>.
-The CLA and the registration need to be done only once for your account.
-</li>
-<li>
-<b>Step 4</b>: Install <code>git-codereview</code> by running
-<code>go get -u golang.org/x/review/git-codereview</code>
-</li>
-</ul>
-
-<p>
-If you prefer, there is an automated tool that walks through these steps.
-Just run:
-</p>
-
-<pre>
-$ go get -u golang.org/x/tools/cmd/go-contrib-init
-$ cd /code/to/edit
-$ go-contrib-init
-</pre>
-
-<p>
-The rest of this chapter elaborates on these instructions.
-If you have completed the steps above (either manually or through the tool), jump to
-<a href="#before_contributing">Before contributing code</a>.
-</p>
-
-<h3 id="google_account">Step 0: Select a Google Account</h3>
-
-<p>
-A contribution to Go is made through a Google account with a specific
-e-mail address.
-Make sure to use the same account throughout the process and
-for all your subsequent contributions.
-You may need to decide whether to use a personal address or a corporate address.
-The choice will depend on who
-will own the copyright for the code that you will be writing
-and submitting.
-You might want to discuss this topic with your employer before deciding which
-account to use.
-</p>
-
-<p>
-Google accounts can either be Gmail e-mail accounts, G Suite organization accounts, or
-accounts associated with an external e-mail address.
-For instance, if you need to use
-an existing corporate e-mail that is not managed through G Suite, you can create
-an account associated
-<a href="https://accounts.google.com/SignUpWithoutGmail">with your existing
-e-mail address</a>.
-</p>
-
-<p>
-You also need to make sure that your Git tool is configured to create commits
-using your chosen e-mail address.
-You can either configure Git globally
-(as a default for all projects), or locally (for a single specific project).
-You can check the current configuration with this command:
-</p>
-
-<pre>
-$ git config --global user.email  # check current global config
-$ git config user.email           # check current local config
-</pre>
-
-<p>
-To change the configured address:
-</p>
-
-<pre>
-$ git config --global user.email name@example.com   # change global config
-$ git config user.email name@example.com            # change local config
-</pre>
-
-
-<h3 id="cla">Step 1: Contributor License Agreement</h3>
-
-<p>
-Before sending your first change to the Go project
-you must have completed one of the following two CLAs.
-Which CLA you should sign depends on who owns the copyright to your work.
-</p>
-
-<ul>
-<li>
-If you are the copyright holder, you will need to agree to the
-<a href="https://developers.google.com/open-source/cla/individual">individual
-contributor license agreement</a>, which can be completed online.
-</li>
-<li>
-If your organization is the copyright holder, the organization
-will need to agree to the
-<a href="https://developers.google.com/open-source/cla/corporate">corporate
-contributor license agreement</a>.<br>
-</li>
-</ul>
-
-<p>
-You can check your currently signed agreements and sign new ones at
-the <a href="https://cla.developers.google.com/clas?pli=1&amp;authuser=1">Google Developers
-Contributor License Agreements</a> website.
-If the copyright holder for your contribution has already completed the
-agreement in connection with another Google open source project,
-it does not need to be completed again.
-</p>
-
-<p>
-If the copyright holder for the code you are submitting changes&mdash;for example,
-if you start contributing code on behalf of a new company&mdash;please send mail
-to the <a href="mailto:golang-dev@googlegroups.com"><code>golang-dev</code>
-mailing list</a>.
-This will let us know the situation so we can make sure an appropriate agreement is
-completed and update the <code>AUTHORS</code> file.
-</p>
-
-
-<h3 id="config_git_auth">Step 2: Configure git authentication</h3>
-
-<p>
-The main Go repository is located at
-<a href="https://go.googlesource.com">go.googlesource.com</a>,
-a Git server hosted by Google.
-Authentication on the web server is made through your Google account, but
-you also need to configure <code>git</code> on your computer to access it.
-Follow these steps:
-</p>
-
-<ol>
-<li>
-Visit <a href="https://go.googlesource.com">go.googlesource.com</a>
-and click on "Generate Password" in the page's top right menu bar.
-You will be redirected to accounts.google.com to sign in.
-</li>
-<li>
-After signing in, you will be taken to a page with the title "Configure Git".
-This page contains a personalized script that when run locally will configure Git
-to hold your unique authentication key.
-This key is paired with one that is generated and stored on the server,
-analogous to how SSH keys work.
-</li>
-<li>
-Copy and run this script locally in your terminal to store your secret
-authentication token in a <code>.gitcookies</code> file.
-If you are using a Windows computer and running <code>cmd</code>,
-you should instead follow the instructions in the yellow box to run the command;
-otherwise run the regular script.
-</li>
-</ol>
-
-<h3 id="auth">Step 3: Create a Gerrit account </h3>
-
-<p>
-Gerrit is an open-source tool used by Go maintainers to discuss and review
-code submissions.
-</p>
-
-<p>
-To register your account, visit <a href="https://go-review.googlesource.com/login/">
-go-review.googlesource.com/login/</a> and sign in once using the same Google Account you used above.
-</p>
-
-<h3 id="git-codereview_install">Step 4: Install the git-codereview command</h3>
-
-<p>
-Changes to Go must be reviewed before they are accepted, no matter who makes the change.
-A custom <code>git</code> command called <code>git-codereview</code>
-simplifies sending changes to Gerrit.
-</p>
-
-<p>
-Install the <code>git-codereview</code> command by running,
-</p>
-
-<pre>
-$ go get -u golang.org/x/review/git-codereview
-</pre>
-
-<p>
-Make sure <code>git-codereview</code> is installed in your shell path, so that the
-<code>git</code> command can find it.
-Check that
-</p>
-
-<pre>
-$ git codereview help
-</pre>
-
-<p>
-prints help text, not an error. If it prints an error, make sure that
-<code>$GOPATH/bin</code> is in your <code>$PATH</code>.
-</p>
-
-<p>
-On Windows, when using git-bash you must make sure that
-<code>git-codereview.exe</code> is in your <code>git</code> exec-path.
-Run <code>git --exec-path</code> to discover the right location then create a
-symbolic link or just copy the executable from <code>$GOPATH/bin</code> to this
-directory.
-</p>
-
-
-<h2 id="before_contributing">Before contributing code</h2>
-
-<p>
-The project welcomes code patches, but to make sure things are well
-coordinated you should discuss any significant change before starting
-the work.
-It's recommended that you signal your intention to contribute in the
-issue tracker, either by <a href="https://golang.org/issue/new">filing
-a new issue</a> or by claiming
-an <a href="https://golang.org/issues">existing one</a>.
-</p>
-
-<h3 id="where">Where to contribute</h3>
-
-<p>
-The Go project consists of the main
-<a href="https://go.googlesource.com/go">go</a> repository, which contains the
-source code for the Go language, as well as many golang.org/x/... repostories.
-These contain the various tools and infrastructure that support Go. For
-example, <a href="https://go.googlesource.com/pkgsite">golang.org/x/pkgsite</a>
-is for <a href="https://pkg.go.dev">pkg.go.dev</a>,
-<a href="https://go.googlesource.com/playground">golang.org/x/playground</a>
-is for the Go playground, and
-<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> contains
-a variety of Go tools, including the Go language server,
-<a href="https://golang.org/s/gopls">gopls</a>. You can see a
-list of all the golang.org/x/... repositories on
-<a href="https://go.googlesource.com">go.googlesource.com</a>.
-</p>
-
-<h3 id="check_tracker">Check the issue tracker</h3>
-
-<p>
-Whether you already know what contribution to make, or you are searching for
-an idea, the <a href="https://github.com/golang/go/issues">issue tracker</a> is
-always the first place to go.
-Issues are triaged to categorize them and manage the workflow.
-</p>
-
-<p>
-The majority of the golang.org/x/... repos also use the main Go
-issue tracker. However, a few of these repositories manage their issues
-separately, so please be sure to check the right tracker for the repository to
-which you would like to contribute.
-</p>
-
-<p>
-Most issues will be marked with one of the following workflow labels:
-</p>
-
-<ul>
-       <li>
-       <b>NeedsInvestigation</b>: The issue is not fully understood
-       and requires analysis to understand the root cause.
-       </li>
-       <li>
-       <b>NeedsDecision</b>: the issue is relatively well understood, but the
-       Go team hasn't yet decided the best way to address it.
-       It would be better to wait for a decision before writing code.
-       If you are interested in working on an issue in this state,
-       feel free to "ping" maintainers in the issue's comments
-       if some time has passed without a decision.
-       </li>
-       <li>
-       <b>NeedsFix</b>: the issue is fully understood and code can be written
-       to fix it.
-       </li>
-</ul>
-
-<p>
-You can use GitHub's search functionality to find issues to help out with. Examples:
-</p>
-
-<ul>
-       <li>
-       Issues that need investigation: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsInvestigation"><code>is:issue is:open label:NeedsInvestigation</code></a>
-       </li>
-       <li>
-       Issues that need a fix: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix"><code>is:issue is:open label:NeedsFix</code></a>
-       </li>
-       <li>
-       Issues that need a fix and have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix "golang.org/cl"</code></a>
-       </li>
-       <li>
-       Issues that need a fix and do not have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+NOT+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix NOT "golang.org/cl"</code></a>
-       </li>
-</ul>
-
-<h3 id="design">Open an issue for any new problem</h3>
-
-<p>
-Excluding very trivial changes, all contributions should be connected
-to an existing issue.
-Feel free to open one and discuss your plans.
-This process gives everyone a chance to validate the design,
-helps prevent duplication of effort,
-and ensures that the idea fits inside the goals for the language and tools.
-It also checks that the design is sound before code is written;
-the code review tool is not the place for high-level discussions.
-</p>
-
-<p>
-When planning work, please note that the Go project follows a <a
-href="https://golang.org/wiki/Go-Release-Cycle">six-month development cycle</a>
-for the main Go repository. The latter half of each cycle is a three-month
-feature freeze during which only bug fixes and documentation updates are
-accepted. New contributions can be sent during a feature freeze, but they will
-not be merged until the freeze is over. The freeze applies to the entire main
-repository as well as to the code in golang.org/x/... repositories that is
-needed to build the binaries included in the release. See the lists of packages
-vendored into
-<a href="https://github.com/golang/go/blob/master/src/vendor/modules.txt">the standard library</a>
-and the <a href="https://github.com/golang/go/blob/master/src/cmd/vendor/modules.txt"><code>go</code> command</a>.
-</p>
-
-<p>
-Significant changes to the language, libraries, or tools must go
-through the
-<a href="https://golang.org/s/proposal-process">change proposal process</a>
-before they can be accepted.
-</p>
-
-<p>
-Sensitive security-related issues (only!) should be reported to <a href="mailto:security@golang.org">security@golang.org</a>.
-</p>
-
-<h2 id="sending_a_change_github">Sending a change via GitHub</h2>
-
-<p>
-First-time contributors that are already familiar with the
-<a href="https://guides.github.com/introduction/flow/">GitHub flow</a>
-are encouraged to use the same process for Go contributions.
-Even though Go
-maintainers use Gerrit for code review, a bot called Gopherbot has been created to sync
-GitHub pull requests to Gerrit.
-</p>
-
-<p>
-Open a pull request as you normally would.
-Gopherbot will create a corresponding Gerrit change and post a link to
-it on your GitHub pull request; updates to the pull request will also
-get reflected in the Gerrit change.
-When somebody comments on the change, their comment will be also
-posted in your pull request, so you will get a notification.
-</p>
-
-<p>
-Some things to keep in mind:
-</p>
-
-<ul>
-<li>
-To update the pull request with new code, just push it to the branch; you can either
-add more commits, or rebase and force-push (both styles are accepted).
-</li>
-<li>
-If the request is accepted, all commits will be squashed, and the final
-commit description will be composed by concatenating the pull request's
-title and description.
-The individual commits' descriptions will be discarded.
-See <a href="#commit_messages">Writing good commit messages</a> for some
-suggestions.
-</li>
-<li>
-Gopherbot is unable to sync line-by-line codereview into GitHub: only the
-contents of the overall comment on the request will be synced.
-Remember you can always visit Gerrit to see the fine-grained review.
-</li>
-</ul>
-
-<h2 id="sending_a_change_gerrit">Sending a change via Gerrit</h2>
-
-<p>
-It is not possible to fully sync Gerrit and GitHub, at least at the moment,
-so we recommend learning Gerrit.
-It's different but powerful and familiarity with it will help you understand
-the flow.
-</p>
-
-<h3 id="gerrit_overview">Overview</h3>
-
-<p>
-This is an overview of the overall process:
-</p>
-
-<ul>
-<li>
-<b>Step 1:</b> Clone the source code from <code>go.googlesource.com</code> and
-make sure it's stable by compiling and testing it once.
-
-<p>If you're making a change to the
-<a href="https://go.googlesource.com/go">main Go repository</a>:</p>
-
-<pre>
-$ git clone https://go.googlesource.com/go
-$ cd go/src
-$ ./all.bash                                # compile and test
-</pre>
-
-<p>
-If you're making a change to one of the golang.org/x/... repositories
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
-in this example):
-</p>
-
-<pre>
-$ git clone https://go.googlesource.com/tools
-$ cd tools
-$ go test ./...                             # compile and test
-</pre>
-</li>
-
-<li>
-<b>Step 2:</b> Prepare changes in a new branch, created from the master branch.
-To commit the changes, use <code>git</code> <code>codereview</code> <code>change</code>; that
-will create or amend a single commit in the branch.
-<pre>
-$ git checkout -b mybranch
-$ [edit files...]
-$ git add [files...]
-$ git codereview change   # create commit in the branch
-$ [edit again...]
-$ git add [files...]
-$ git codereview change   # amend the existing commit with new changes
-$ [etc.]
-</pre>
-</li>
-
-<li>
-<b>Step 3:</b> Test your changes, either by running the tests in the package
-you edited or by re-running <code>all.bash</code>.
-
-<p>In the main Go repository:</p>
-<pre>
-$ ./all.bash    # recompile and test
-</pre>
-
-<p>In a golang.org/x/... repository:</p>
-<pre>
-$ go test ./... # recompile and test
-</pre>
-</li>
-
-<li>
-<b>Step 4:</b> Send the changes for review to Gerrit using <code>git</code>
-<code>codereview</code> <code>mail</code> (which doesn't use e-mail, despite the name).
-<pre>
-$ git codereview mail     # send changes to Gerrit
-</pre>
-</li>
-
-<li>
-<b>Step 5:</b> After a review, apply changes to the same single commit
-and mail them to Gerrit again:
-<pre>
-$ [edit files...]
-$ git add [files...]
-$ git codereview change   # update same commit
-$ git codereview mail     # send to Gerrit again
-</pre>
-</li>
-</ul>
-
-<p>
-The rest of this section describes these steps in more detail.
-</p>
-
-
-<h3 id="checkout_go">Step 1: Clone the source code</h3>
-
-<p>
-In addition to a recent Go installation, you need to have a local copy of the source
-checked out from the correct repository.
-You can check out the Go source repo onto your local file system anywhere
-you want as long as it's outside your <code>GOPATH</code>.
-Clone from <code>go.googlesource.com</code> (not GitHub):
-</p>
-
-<p>Main Go repository:</p>
-<pre>
-$ git clone https://go.googlesource.com/go
-$ cd go
-</pre>
-
-<p>golang.org/x/... repository</p>
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> in this example):
-<pre>
-$ git clone https://go.googlesource.com/tools
-$ cd tools
-</pre>
-
-<h3 id="make_branch">Step 2: Prepare changes in a new branch</h3>
-
-<p>
-Each Go change must be made in a separate branch, created from the master branch.
-You can use
-the normal <code>git</code> commands to create a branch and add changes to the
-staging area:
-</p>
-
-<pre>
-$ git checkout -b mybranch
-$ [edit files...]
-$ git add [files...]
-</pre>
-
-<p>
-To commit changes, instead of <code>git commit</code>, use <code>git codereview change</code>.
-</p>
-
-<pre>
-$ git codereview change
-(open $EDITOR)
-</pre>
-
-<p>
-You can edit the commit description in your favorite editor as usual.
-The  <code>git</code> <code>codereview</code> <code>change</code> command
-will automatically add a unique Change-Id line near the bottom.
-That line is used by Gerrit to match successive uploads of the same change.
-Do not edit or delete it.
-A Change-Id looks like this:
-</p>
-
-<pre>
-Change-Id: I2fbdbffb3aab626c4b6f56348861b7909e3e8990
-</pre>
-
-<p>
-The tool also checks that you've
-run <code>go</code> <code>fmt</code> over the source code, and that
-the commit message follows the <a href="#commit_messages">suggested format</a>.
-</p>
-
-<p>
-If you need to edit the files again, you can stage the new changes and
-re-run <code>git</code> <code>codereview</code> <code>change</code>: each subsequent
-run will amend the existing commit while preserving the Change-Id.
-</p>
-
-<p>
-Make sure that you always keep a single commit in each branch.
-If you add more
-commits by mistake, you can use <code>git</code> <code>rebase</code> to
-<a href="https://stackoverflow.com/questions/31668794/squash-all-your-commits-in-one-before-a-pull-request-in-github">squash them together</a>
-into a single one.
-</p>
-
-
-<h3 id="testing">Step 3: Test your changes</h3>
-
-<p>
-You've <a href="code.html">written and tested your code</a>, but
-before sending code out for review, run <i>all the tests for the whole
-tree</i> to make sure the changes don't break other packages or programs.
-</p>
-
-<h4 id="test-gorepo">In the main Go repository</h4>
-
-<p>This can be done by running <code>all.bash</code>:</p>
-
-<pre>
-$ cd go/src
-$ ./all.bash
-</pre>
-
-<p>
-(To build under Windows use <code>all.bat</code>)
-</p>
-
-<p>
-After running for a while and printing a lot of testing output, the command should finish
-by printing,
-</p>
-
-<pre>
-ALL TESTS PASSED
-</pre>
-
-<p>
-You can use <code>make.bash</code> instead of <code>all.bash</code>
-to just build the compiler and the standard library without running the test suite.
-Once the <code>go</code> tool is built, it will be installed as <code>bin/go</code>
-under the directory in which you cloned the Go repository, and you can
-run it directly from there.
-See also
-the section on how to <a href="#quick_test">test your changes quickly</a>.
-</p>
-
-<h4 id="test-xrepo">In the golang.org/x/... repositories</h4>
-
-<p>
-Run the tests for the entire repository
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
-in this example):
-</p>
-
-<pre>
-$ cd tools
-$ go test ./...
-</pre>
-
-<p>
-If you're concerned about the build status,
-you can check the <a href="https://build.golang.org">Build Dashboard</a>.
-Test failures may also be caught by the TryBots in code review.
-</p>
-
-<p>
-Some repositories, like
-<a href="https://go.googlesource.com/vscode-go">golang.org/x/vscode-go</a> will
-have different testing infrastructures, so always check the documentation
-for the repository in which you are working. The README file in the root of the
-repository will usually have this information.
-</p>
-
-<h3 id="mail">Step 4: Send changes for review</h3>
-
-<p>
-Once the change is ready and tested over the whole tree, send it for review.
-This is done with the <code>mail</code> sub-command which, despite its name, doesn't
-directly mail anything; it just sends the change to Gerrit:
-</p>
-
-<pre>
-$ git codereview mail
-</pre>
-
-<p>
-Gerrit assigns your change a number and URL, which <code>git</code> <code>codereview</code> <code>mail</code> will print, something like:
-</p>
-
-<pre>
-remote: New Changes:
-remote:   https://go-review.googlesource.com/99999 math: improved Sin, Cos and Tan precision for very large arguments
-</pre>
-
-<p>
-If you get an error instead, check the
-<a href="#troubleshooting_mail">Troubleshooting mail errors</a> section.
-</p>
-
-<p>
-If your change relates to an open GitHub issue and you have followed the <a href="#commit_messages">
-suggested commit message format</a>, the issue will be updated in a few minutes by a bot,
-linking your Gerrit change to it in the comments.
-</p>
-
-
-<h3 id="revise">Step 5: Revise changes after a review</h3>
-
-<p>
-Go maintainers will review your code on Gerrit, and you will get notifications via e-mail.
-You can see the review on Gerrit and comment on them there.
-You can also reply
-<a href="https://gerrit-review.googlesource.com/Documentation/intro-user.html#reply-by-email">using e-mail</a>
-if you prefer.
-</p>
-
-<p>
-If you need to revise your change after the review, edit the files in
-the same branch you previously created, add them to the Git staging
-area, and then amend the commit with
-<code>git</code> <code>codereview</code> <code>change</code>:
-</p>
-
-<pre>
-$ git codereview change     # amend current commit
-(open $EDITOR)
-$ git codereview mail       # send new changes to Gerrit
-</pre>
-
-<p>
-If you don't need to change the commit description, just save and exit from the editor.
-Remember not to touch the special Change-Id line.
-</p>
-
-<p>
-Again, make sure that you always keep a single commit in each branch.
-If you add more
-commits by mistake, you can use <code>git rebase</code> to
-<a href="https://stackoverflow.com/questions/31668794/squash-all-your-commits-in-one-before-a-pull-request-in-github">squash them together</a>
-into a single one.
-</p>
-
-<h2 id="commit_messages">Good commit messages</h2>
-
-<p>
-Commit messages in Go follow a specific set of conventions,
-which we discuss in this section.
-</p>
-
-<p>
-Here is an example of a good one:
-</p>
-
-<pre>
-math: improve Sin, Cos and Tan precision for very large arguments
-
-The existing implementation has poor numerical properties for
-large arguments, so use the McGillicutty algorithm to improve
-accuracy above 1e10.
-
-The algorithm is described at https://wikipedia.org/wiki/McGillicutty_Algorithm
-
-Fixes #159
-</pre>
-
-<h3 id="first_line">First line</h3>
-
-<p>
-The first line of the change description is conventionally a short one-line
-summary of the change, prefixed by the primary affected package.
-</p>
-
-<p>
-A rule of thumb is that it should be written so to complete the sentence
-"This change modifies Go to _____."
-That means it does not start with a capital letter, is not a complete sentence,
-and actually summarizes the result of the change.
-</p>
-
-<p>
-Follow the first line by a blank line.
-</p>
-
-<h3 id="main_content">Main content</h3>
-
-<p>
-The rest of the description elaborates and should provide context for the
-change and explain what it does.
-Write in complete sentences with correct punctuation, just like
-for your comments in Go.
-Don't use HTML, Markdown, or any other markup language.
-</p>
-
-<p>
-Add any relevant information, such as benchmark data if the change
-affects performance.
-The <a href="https://godoc.org/golang.org/x/perf/cmd/benchstat">benchstat</a>
-tool is conventionally used to format
-benchmark data for change descriptions.
-</p>
-
-<h3 id="ref_issues">Referencing issues</h3>
-
-<p>
-The special notation "Fixes #12345" associates the change with issue 12345 in the
-<a href="https://golang.org/issue/12345">Go issue tracker</a>.
-When this change is eventually applied, the issue
-tracker will automatically mark the issue as fixed.
-</p>
-
-<p>
-If the change is a partial step towards the resolution of the issue,
-write "Updates #12345" instead.
-This will leave a comment in the issue linking back to the change in
-Gerrit, but it will not close the issue when the change is applied.
-</p>
-
-<p>
-If you are sending a change against a golang.org/x/... repository, you must use
-the fully-qualified syntax supported by GitHub to make sure the change is
-linked to the issue in the main repository, not the x/ repository.
-Most issues are tracked in the main repository's issue tracker.
-The correct form is "Fixes golang/go#159".
-</p>
-
-
-<h2 id="review">The review process</h2>
-
-<p>
-This section explains the review process in detail and how to approach
-reviews after a change has been mailed.
-</p>
-
-
-<h3 id="mistakes">Common beginner mistakes</h3>
-
-<p>
-When a change is sent to Gerrit, it is usually triaged within a few days.
-A maintainer will have a look and provide some initial review that for first-time
-contributors usually focuses on basic cosmetics and common mistakes.
-These include things like:
-</p>
-
-<ul>
-<li>
-Commit message not following the <a href="#commit_messages">suggested
-format</a>.
-</li>
-
-<li>
-The lack of a linked GitHub issue.
-The vast majority of changes
-require a linked issue that describes the bug or the feature that the change
-fixes or implements, and consensus should have been reached on the tracker
-before proceeding with it.
-Gerrit reviews do not discuss the merit of the change,
-just its implementation.
-<br>
-Only trivial or cosmetic changes will be accepted without an associated issue.
-</li>
-
-<li>
-Change sent during the freeze phase of the development cycle, when the tree
-is closed for general changes.
-In this case,
-a maintainer might review the code with a line such as <code>R=go1.12</code>,
-which means that it will be reviewed later when the tree opens for a new
-development window.
-You can add <code>R=go1.XX</code> as a comment yourself
-if you know that it's not the correct time frame for the change.
-</li>
-</ul>
-
-<h3 id="trybots">Trybots</h3>
-
-<p>
-After an initial reading of your change, maintainers will trigger trybots,
-a cluster of servers that will run the full test suite on several different
-architectures.
-Most trybots complete in a few minutes, at which point a link will
-be posted in Gerrit where you can see the results.
-</p>
-
-<p>
-If the trybot run fails, follow the link and check the full logs of the
-platforms on which the tests failed.
-Try to understand what broke, update your patch to fix it, and upload again.
-Maintainers will trigger a new trybot run to see
-if the problem was fixed.
-</p>
-
-<p>
-Sometimes, the tree can be broken on some platforms for a few hours; if
-the failure reported by the trybot doesn't seem related to your patch, go to the
-<a href="https://build.golang.org">Build Dashboard</a> and check if the same
-failure appears in other recent commits on the same platform.
-In this case,
-feel free to write a comment in Gerrit to mention that the failure is
-unrelated to your change, to help maintainers understand the situation.
-</p>
-
-<h3 id="reviews">Reviews</h3>
-
-<p>
-The Go community values very thorough reviews.
-Think of each review comment like a ticket: you are expected to somehow "close" it
-by acting on it, either by implementing the suggestion or convincing the
-reviewer otherwise.
-</p>
-
-<p>
-After you update the change, go through the review comments and make sure
-to reply to every one.
-You can click the "Done" button to reply
-indicating that you've implemented the reviewer's suggestion; otherwise,
-click on "Reply" and explain why you have not, or what you have done instead.
-</p>
-
-<p>
-It is perfectly normal for changes to go through several round of reviews,
-with one or more reviewers making new comments every time
-and then waiting for an updated change before reviewing again.
-This cycle happens even for experienced contributors, so
-don't be discouraged by it.
-</p>
-
-<h3 id="votes">Voting conventions</h3>
-
-<p>
-As they near a decision, reviewers will make a "vote" on your change.
-The Gerrit voting system involves an integer in the range -2 to +2:
-</p>
-
-<ul>
-       <li>
-       <b>+2</b> The change is approved for being merged.
-       Only Go maintainers can cast a +2 vote.
-       </li>
-       <li>
-       <b>+1</b> The change looks good, but either the reviewer is requesting
-       minor changes before approving it, or they are not a maintainer and cannot
-       approve it, but would like to encourage an approval.
-       </li>
-       <li>
-       <b>-1</b> The change is not good the way it is but might be fixable.
-       A -1 vote will always have a comment explaining why the change is unacceptable.
-       </li>
-       <li>
-       <b>-2</b> The change is blocked by a maintainer and cannot be approved.
-       Again, there will be a comment explaining the decision.
-       </li>
-</ul>
-
-<p>
-At least two maintainers must approve of the change, and at least one
-of those maintainers must +2 the change.
-The second maintainer may cast a vote of Trust+1, meaning that the
-change looks basically OK, but that the maintainer hasn't done the
-detailed review required for a +2 vote.
-</p>
-
-<h3 id="submit">Submitting an approved change</h3>
-
-<p>
-After the code has been +2'ed and Trust+1'ed, an approver will
-apply it to the master branch using the Gerrit user interface.
-This is called "submitting the change".
-</p>
-
-<p>
-The two steps (approving and submitting) are separate because in some cases maintainers
-may want to approve it but not to submit it right away (for instance,
-the tree could be temporarily frozen).
-</p>
-
-<p>
-Submitting a change checks it into the repository.
-The change description will include a link to the code review,
-which will be updated with a link to the change
-in the repository.
-Since the method used to integrate the changes is Git's "Cherry Pick",
-the commit hashes in the repository will be changed by
-the submit operation.
-</p>
-
-<p>
-If your change has been approved for a few days without being
-submitted, feel free to write a comment in Gerrit requesting
-submission.
-</p>
-
-
-<h3 id="more_information">More information</h3>
-
-<p>
-In addition to the information here, the Go community maintains a <a
-href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
-Feel free to contribute to this page as you learn more about the review process.
-</p>
-
-
-
-<h2 id="advanced_topics">Miscellaneous topics</h2>
-
-<p>
-This section collects a number of other comments that are
-outside the issue/edit/code review/submit process itself.
-</p>
-
-
-<h3 id="copyright">Copyright headers</h3>
-
-<p>
-Files in the Go repository don't list author names, both to avoid clutter
-and to avoid having to keep the lists up to date.
-Instead, your name will appear in the
-<a href="https://golang.org/change">change log</a> and in the <a
-href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file and perhaps the <a
-href="/AUTHORS"><code>AUTHORS</code></a> file.
-These files are automatically generated from the commit logs periodically.
-The <a href="/AUTHORS"><code>AUTHORS</code></a> file defines who &ldquo;The Go
-Authors&rdquo;&mdash;the copyright holders&mdash;are.
-</p>
-
-<p>
-New files that you contribute should use the standard copyright header:
-</p>
-
-<pre>
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-</pre>
-
-<p>
-(Use the current year if you're reading this in 2021 or beyond.)
-Files in the repository are copyrighted the year they are added.
-Do not update the copyright year on files that you change.
-</p>
-
-
-
-
-<h3 id="troubleshooting_mail">Troubleshooting mail errors</h3>
-
-<p>
-The most common way that the <code>git</code> <code>codereview</code> <code>mail</code>
-command fails is because the e-mail address in the commit does not match the one
-that you used during <a href="#google_account">the registration process</a>.
-
-<br>
-If you see something like...
-</p>
-
-<pre>
-remote: Processing changes: refs: 1, done
-remote:
-remote: ERROR:  In commit ab13517fa29487dcf8b0d48916c51639426c5ee9
-remote: ERROR:  author email address XXXXXXXXXXXXXXXXXXX
-remote: ERROR:  does not match your user account.
-</pre>
-
-<p>
-you need to configure Git for this repository to use the
-e-mail address that you registered with.
-To change the e-mail address to ensure this doesn't happen again, run:
-</p>
-
-<pre>
-$ git config user.email email@address.com
-</pre>
-
-<p>
-Then change the commit to use this alternative e-mail address with this command:
-</p>
-
-<pre>
-$ git commit --amend --author="Author Name &lt;email@address.com&gt;"
-</pre>
-
-<p>
-Then retry by running:
-</p>
-
-<pre>
-$ git codereview mail
-</pre>
-
-
-<h3 id="quick_test">Quickly testing your changes</h3>
-
-<p>
-Running <code>all.bash</code> for every single change to the code tree
-is burdensome.
-Even though it is strongly suggested to run it before
-sending a change, during the normal development cycle you may want
-to compile and test only the package you are developing.
-</p>
-
-<ul>
-<li>
-In general, you can run <code>make.bash</code> instead of <code>all.bash</code>
-to only rebuild the Go tool chain without running the whole test suite.
-Or you
-can run <code>run.bash</code> to only run the whole test suite without rebuilding
-the tool chain.
-You can think of <code>all.bash</code> as <code>make.bash</code>
-followed by <code>run.bash</code>.
-</li>
-
-<li>
-In this section, we'll call the directory into which you cloned the Go repository <code>$GODIR</code>.
-The <code>go</code> tool built by <code>$GODIR/src/make.bash</code> will be installed
-in <code>$GODIR/bin/go</code> and you
-can invoke it to test your code.
-For instance, if you
-have modified the compiler and you want to test how it affects the
-test suite of your own project, just run <code>go</code> <code>test</code>
-using it:
-
-<pre>
-$ cd &lt;MYPROJECTDIR&gt;
-$ $GODIR/bin/go test
-</pre>
-</li>
-
-<li>
-If you're changing the standard library, you probably don't need to rebuild
-the compiler: you can just run the tests for the package you've changed.
-You can do that either with the Go version you normally use, or
-with the Go compiler built from your clone (which is
-sometimes required because the standard library code you're modifying
-might require a newer version than the stable one you have installed).
-
-<pre>
-$ cd $GODIR/src/hash/sha1
-$ [make changes...]
-$ $GODIR/bin/go test .
-</pre>
-</li>
-
-<li>
-If you're modifying the compiler itself, you can just recompile
-the <code>compile</code> tool (which is the internal binary invoked
-by <code>go</code> <code>build</code> to compile each single package).
-After that, you will want to test it by compiling or running something.
-
-<pre>
-$ cd $GODIR/src
-$ [make changes...]
-$ $GODIR/bin/go install cmd/compile
-$ $GODIR/bin/go build [something...]   # test the new compiler
-$ $GODIR/bin/go run [something...]     # test the new compiler
-$ $GODIR/bin/go test [something...]    # test the new compiler
-</pre>
-
-The same applies to other internal tools of the Go tool chain,
-such as <code>asm</code>, <code>cover</code>, <code>link</code>, and so on.
-Just recompile and install the tool using <code>go</code>
-<code>install</code> <code>cmd/&lt;TOOL&gt;</code> and then use
-the built Go binary to test it.
-</li>
-
-<li>
-In addition to the standard per-package tests, there is a top-level
-test suite in <code>$GODIR/test</code> that contains
-several black-box and regression tests.
-The test suite is run
-by <code>all.bash</code> but you can also run it manually:
-
-<pre>
-$ cd $GODIR/test
-$ $GODIR/bin/go run run.go
-</pre>
-</ul>
-
-
-<h3 id="cc">Specifying a reviewer / CCing others</h3>
-
-<p>
-Unless explicitly told otherwise, such as in the discussion leading
-up to sending in the change, it's better not to specify a reviewer.
-All changes are automatically CC'ed to the
-<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
-mailing list.
-If this is your first ever change, there may be a moderation
-delay before it appears on the mailing list, to prevent spam.
-</p>
-
-<p>
-You can specify a reviewer or CC interested parties
-using the <code>-r</code> or <code>-cc</code> options.
-Both accept a comma-separated list of e-mail addresses:
-</p>
-
-<pre>
-$ git codereview mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
-</pre>
-
-
-<h3 id="sync">Synchronize your client</h3>
-
-<p>
-While you were working, others might have submitted changes to the repository.
-To update your local branch, run
-</p>
-
-<pre>
-$ git codereview sync
-</pre>
-
-<p>
-(Under the covers this runs
-<code>git</code> <code>pull</code> <code>-r</code>.)
-</p>
-
-
-<h3 id="download">Reviewing code by others</h3>
-
-<p>
-As part of the review process reviewers can propose changes directly (in the
-GitHub workflow this would be someone else attaching commits to a pull request).
-
-You can import these changes proposed by someone else into your local Git repository.
-On the Gerrit review page, click the "Download ▼" link in the upper right
-corner, copy the "Checkout" command and run it from your local Git repo.
-It will look something like this:
-</p>
-
-<pre>
-$ git fetch https://go.googlesource.com/review refs/changes/21/13245/1 &amp;&amp; git checkout FETCH_HEAD
-</pre>
-
-<p>
-To revert, change back to the branch you were working in.
-</p>
-
-
-<h3 id="git-config">Set up git aliases</h3>
-
-<p>
-The <code>git-codereview</code> command can be run directly from the shell
-by typing, for instance,
-</p>
-
-<pre>
-$ git codereview sync
-</pre>
-
-<p>
-but it is more convenient to set up aliases for <code>git-codereview</code>'s own
-subcommands, so that the above becomes,
-</p>
-
-<pre>
-$ git sync
-</pre>
-
-<p>
-The <code>git-codereview</code> subcommands have been chosen to be distinct from
-Git's own, so it's safe to define these aliases.
-To install them, copy this text into your
-Git configuration file (usually <code>.gitconfig</code> in your home directory):
-</p>
-
-<pre>
-[alias]
-       change = codereview change
-       gofmt = codereview gofmt
-       mail = codereview mail
-       pending = codereview pending
-       submit = codereview submit
-       sync = codereview sync
-</pre>
-
-
-<h3 id="multiple_changes">Sending multiple dependent changes</h3>
-
-<p>
-Advanced users may want to stack up related commits in a single branch.
-Gerrit allows for changes to be dependent on each other, forming such a dependency chain.
-Each change will need to be approved and submitted separately but the dependency
-will be visible to reviewers.
-</p>
-
-<p>
-To send out a group of dependent changes, keep each change as a different commit under
-the same branch, and then run:
-</p>
-
-<pre>
-$ git codereview mail HEAD
-</pre>
-
-<p>
-Make sure to explicitly specify <code>HEAD</code>, which is usually not required when sending
-single changes. More details can be found in the <a href="https://pkg.go.dev/golang.org/x/review/git-codereview?tab=doc#hdr-Multiple_Commit_Work_Branches">git-codereview documentation</a>.
-</p>

diff --git a/doc/debugging_with_gdb.html b/doc/debugging_with_gdb.html
deleted file mode 100644 (file)
index e1fb292..0000000
--- a/doc/debugging_with_gdb.html
+++ /dev/null
@@ -1,554 +0,0 @@
-<!--{
-       "Title": "Debugging Go Code with GDB",
-       "Path": "/doc/gdb"
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<i>
-<p>
-The following instructions apply to the standard toolchain
-(the <code>gc</code> Go compiler and tools).
-Gccgo has native gdb support.
-</p>
-<p>
-Note that 
-<a href="https://github.com/go-delve/delve">Delve</a> is a better
-alternative to GDB when debugging Go programs built with the standard
-toolchain. It understands the Go runtime, data structures, and
-expressions better than GDB. Delve currently supports Linux, OSX,
-and Windows on <code>amd64</code>.
-For the most up-to-date list of supported platforms, please see
-<a href="https://github.com/go-delve/delve/tree/master/Documentation/installation">
- the Delve documentation</a>.
-</p>
-</i>
-
-<p>
-GDB does not understand Go programs well.
-The stack management, threading, and runtime contain aspects that differ
-enough from the execution model GDB expects that they can confuse
-the debugger and cause incorrect results even when the program is
-compiled with gccgo.
-As a consequence, although GDB can be useful in some situations (e.g.,
-debugging Cgo code, or debugging the runtime itself), it is not
-a reliable debugger for Go programs, particularly heavily concurrent
-ones.  Moreover, it is not a priority for the Go project to address
-these issues, which are difficult.
-</p>
-
-<p>
-In short, the instructions below should be taken only as a guide to how
-to use GDB when it works, not as a guarantee of success.
-
-Besides this overview you might want to consult the
-<a href="https://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
-</p>
-
-<p>
-</p>
-
-<h2 id="Introduction">Introduction</h2>
-
-<p>
-When you compile and link your Go programs with the <code>gc</code> toolchain
-on Linux, macOS, FreeBSD or NetBSD, the resulting binaries contain DWARFv4
-debugging information that recent versions (&ge;7.5) of the GDB debugger can
-use to inspect a live process or a core dump.
-</p>
-
-<p>
-Pass the <code>'-w'</code> flag to the linker to omit the debug information
-(for example, <code>go</code> <code>build</code> <code>-ldflags=-w</code> <code>prog.go</code>).
-</p>
-
-<p>
-The code generated by the <code>gc</code> compiler includes inlining of
-function invocations and registerization of variables. These optimizations
-can sometimes make debugging with <code>gdb</code> harder.
-If you find that you need to disable these optimizations,
-build your program using <code>go</code> <code>build</code> <code>-gcflags=all="-N -l"</code>.
-</p>
-
-<p>
-If you want to use gdb to inspect a core dump, you can trigger a dump
-on a program crash, on systems that permit it, by setting
-<code>GOTRACEBACK=crash</code> in the environment (see the
-<a href="/pkg/runtime/#hdr-Environment_Variables"> runtime package
-documentation</a> for more info).
-</p>
-
-<h3 id="Common_Operations">Common Operations</h3>
-
-<ul>
-<li>
-Show file and line number for code, set breakpoints and disassemble:
-<pre>(gdb) <b>list</b>
-(gdb) <b>list <i>line</i></b>
-(gdb) <b>list <i>file.go</i>:<i>line</i></b>
-(gdb) <b>break <i>line</i></b>
-(gdb) <b>break <i>file.go</i>:<i>line</i></b>
-(gdb) <b>disas</b></pre>
-</li>
-<li>
-Show backtraces and unwind stack frames:
-<pre>(gdb) <b>bt</b>
-(gdb) <b>frame <i>n</i></b></pre>
-</li>
-<li>
-Show the name, type and location on the stack frame of local variables,
-arguments and return values:
-<pre>(gdb) <b>info locals</b>
-(gdb) <b>info args</b>
-(gdb) <b>p variable</b>
-(gdb) <b>whatis variable</b></pre>
-</li>
-<li>
-Show the name, type and location of global variables:
-<pre>(gdb) <b>info variables <i>regexp</i></b></pre>
-</li>
-</ul>
-
-
-<h3 id="Go_Extensions">Go Extensions</h3>
-
-<p>
-A recent extension mechanism to GDB allows it to load extension scripts for a
-given binary. The toolchain uses this to extend GDB with a handful of
-commands to inspect internals of the runtime code (such as goroutines) and to
-pretty print the built-in map, slice and channel types.
-</p>
-
-<ul>
-<li>
-Pretty printing a string, slice, map, channel or interface:
-<pre>(gdb) <b>p <i>var</i></b></pre>
-</li>
-<li>
-A $len() and $cap() function for strings, slices and maps:
-<pre>(gdb) <b>p $len(<i>var</i>)</b></pre>
-</li>
-<li>
-A function to cast interfaces to their dynamic types:
-<pre>(gdb) <b>p $dtype(<i>var</i>)</b>
-(gdb) <b>iface <i>var</i></b></pre>
-<p class="detail"><b>Known issue:</b> GDB can’t automatically find the dynamic
-type of an interface value if its long name differs from its short name
-(annoying when printing stacktraces, the pretty printer falls back to printing
-the short type name and a pointer).</p>
-</li>
-<li>
-Inspecting goroutines:
-<pre>(gdb) <b>info goroutines</b>
-(gdb) <b>goroutine <i>n</i> <i>cmd</i></b>
-(gdb) <b>help goroutine</b></pre>
-For example:
-<pre>(gdb) <b>goroutine 12 bt</b></pre>
-You can inspect all goroutines by passing <code>all</code> instead of a specific goroutine's ID.
-For example:
-<pre>(gdb) <b>goroutine all bt</b></pre>
-</li>
-</ul>
-
-<p>
-If you'd like to see how this works, or want to extend it, take a look at <a
-href="/src/runtime/runtime-gdb.py">src/runtime/runtime-gdb.py</a> in
-the Go source distribution. It depends on some special magic types
-(<code>hash&lt;T,U&gt;</code>) and variables (<code>runtime.m</code> and
-<code>runtime.g</code>) that the linker
-(<a href="/src/cmd/link/internal/ld/dwarf.go">src/cmd/link/internal/ld/dwarf.go</a>) ensures are described in
-the DWARF code.
-</p>
-
-<p>
-If you're interested in what the debugging information looks like, run
-<code>objdump</code> <code>-W</code> <code>a.out</code> and browse through the <code>.debug_*</code>
-sections.
-</p>
-
-
-<h3 id="Known_Issues">Known Issues</h3>
-
-<ol>
-<li>String pretty printing only triggers for type string, not for types derived
-from it.</li>
-<li>Type information is missing for the C parts of the runtime library.</li>
-<li>GDB does not understand Go’s name qualifications and treats
-<code>"fmt.Print"</code> as an unstructured literal with a <code>"."</code>
-that needs to be quoted.  It objects even more strongly to method names of
-the form <code>pkg.(*MyType).Meth</code>.
-<li>As of Go 1.11, debug information is compressed by default.
-Older versions of gdb, such as the one available by default on MacOS,
-do not understand the compression.
-You can generate uncompressed debug information by using <code>go
-build -ldflags=-compressdwarf=false</code>.
-(For convenience you can put the <code>-ldflags</code> option in
-the <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code>
-environment variable</a> so that you don't have to specify it each time.)
-</li>
-</ol>
-
-<h2 id="Tutorial">Tutorial</h2>
-
-<p>
-In this tutorial we will inspect the binary of the
-<a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
-change to <code>$GOROOT/src/regexp</code> and run <code>go</code> <code>test</code> <code>-c</code>.
-This should produce an executable file named <code>regexp.test</code>.
-</p>
-
-
-<h3 id="Getting_Started">Getting Started</h3>
-
-<p>
-Launch GDB, debugging <code>regexp.test</code>:
-</p>
-
-<pre>
-$ <b>gdb regexp.test</b>
-GNU gdb (GDB) 7.2-gg8
-Copyright (C) 2010 Free Software Foundation, Inc.
-License GPLv  3+: GNU GPL version 3 or later &lt;http://gnu.org/licenses/gpl.html&gt;
-Type "show copying" and "show warranty" for licensing/warranty details.
-This GDB was configured as "x86_64-linux".
-
-Reading symbols from  /home/user/go/src/regexp/regexp.test...
-done.
-Loading Go Runtime support.
-(gdb) 
-</pre>
-
-<p>
-The message "Loading Go Runtime support" means that GDB loaded the
-extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
-</p>
-
-<p>
-To help GDB find the Go runtime sources and the accompanying support script,
-pass your <code>$GOROOT</code> with the <code>'-d'</code> flag:
-</p>
-
-<pre>
-$ <b>gdb regexp.test -d $GOROOT</b>
-</pre>
-
-<p>
-If for some reason GDB still can't find that directory or that script, you can load
-it by hand by telling gdb (assuming you have the go sources in
-<code>~/go/</code>):
-</p>
-
-<pre>
-(gdb) <b>source ~/go/src/runtime/runtime-gdb.py</b>
-Loading Go Runtime support.
-</pre>
-
-<h3 id="Inspecting_the_source">Inspecting the source</h3>
-
-<p>
-Use the <code>"l"</code> or <code>"list"</code> command to inspect source code.
-</p>
-
-<pre>
-(gdb) <b>l</b>
-</pre>
-
-<p>
-List a specific part of the source parameterizing <code>"list"</code> with a
-function name (it must be qualified with its package name).
-</p>
-
-<pre>
-(gdb) <b>l main.main</b>
-</pre>
-
-<p>
-List a specific file and line number:
-</p>
-
-<pre>
-(gdb) <b>l regexp.go:1</b>
-(gdb) <i># Hit enter to repeat last command. Here, this lists next 10 lines.</i>
-</pre>
-
-
-<h3 id="Naming">Naming</h3>
-
-<p>
-Variable and function names must be qualified with the name of the packages
-they belong to. The <code>Compile</code> function from the <code>regexp</code>
-package is known to GDB as <code>'regexp.Compile'</code>. 
-</p>
-
-<p>
-Methods must be qualified with the name of their receiver types. For example,
-the <code>*Regexp</code> type’s <code>String</code> method is known as
-<code>'regexp.(*Regexp).String'</code>.
-</p>
-
-<p>
-Variables that shadow other variables are magically suffixed with a number in the debug info.
-Variables referenced by closures will appear as pointers magically prefixed with '&amp;'.
-</p>
-
-<h3 id="Setting_breakpoints">Setting breakpoints</h3>
-
-<p>
-Set a breakpoint at the <code>TestFind</code> function:
-</p>
-
-<pre>
-(gdb) <b>b 'regexp.TestFind'</b>
-Breakpoint 1 at 0x424908: file /home/user/go/src/regexp/find_test.go, line 148.
-</pre>
-
-<p>
-Run the program:
-</p>
-
-<pre>
-(gdb) <b>run</b>
-Starting program: /home/user/go/src/regexp/regexp.test
-
-Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
-148    func TestFind(t *testing.T) {
-</pre>
-
-<p>
-Execution has paused at the breakpoint.
-See which goroutines are running, and what they're doing:
-</p>
-
-<pre>
-(gdb) <b>info goroutines</b>
-  1  waiting runtime.gosched
-* 13  running runtime.goexit
-</pre>
-
-<p>
-the one marked with the <code>*</code> is the current goroutine.
-</p>
-
-<h3 id="Inspecting_the_stack">Inspecting the stack</h3>
-
-<p>
-Look at the stack trace for where we’ve paused the program:
-</p>
-
-<pre>
-(gdb) <b>bt</b>  <i># backtrace</i>
-#0  regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
-#1  0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/testing/testing.go:156
-#2  0x000000000040df64 in runtime.initdone () at /home/user/go/src/runtime/proc.c:242
-#3  0x000000f8404a89c0 in ?? ()
-#4  0x0000000000573720 in ?? ()
-#5  0x0000000000000000 in ?? ()
-</pre>
-
-<p>
-The other goroutine, number 1, is stuck in <code>runtime.gosched</code>, blocked on a channel receive:
-</p>
-
-<pre>
-(gdb) <b>goroutine 1 bt</b>
-#0  0x000000000040facb in runtime.gosched () at /home/user/go/src/runtime/proc.c:873
-#1  0x00000000004031c9 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
- at  /home/user/go/src/runtime/chan.c:342
-#2  0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/runtime/chan.c:423
-#3  0x000000000043075b in testing.RunTests (matchString={void (struct string, struct string, bool *, error *)}
- 0x7ffff7f9ef60, tests=  []testing.InternalTest = {...}) at /home/user/go/src/testing/testing.go:201
-#4  0x00000000004302b1 in testing.Main (matchString={void (struct string, struct string, bool *, error *)} 
- 0x7ffff7f9ef80, tests= []testing.InternalTest = {...}, benchmarks= []testing.InternalBenchmark = {...})
-at /home/user/go/src/testing/testing.go:168
-#5  0x0000000000400dc1 in main.main () at /home/user/go/src/regexp/_testmain.go:98
-#6  0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/runtime/amd64/asm.s:78
-#7  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
-#8  0x0000000000000000 in ?? ()
-</pre>
-
-<p>
-The stack frame shows we’re currently executing the <code>regexp.TestFind</code> function, as expected.
-</p>
-
-<pre>
-(gdb) <b>info frame</b>
-Stack level 0, frame at 0x7ffff7f9ff88:
- rip = 0x425530 in regexp.TestFind (/home/user/go/src/regexp/find_test.go:148); 
-    saved rip 0x430233
- called by frame at 0x7ffff7f9ffa8
- source language minimal.
- Arglist at 0x7ffff7f9ff78, args: t=0xf840688b60
- Locals at 0x7ffff7f9ff78, Previous frame's sp is 0x7ffff7f9ff88
- Saved registers:
-  rip at 0x7ffff7f9ff80
-</pre>
-
-<p>
-The command <code>info</code> <code>locals</code> lists all variables local to the function and their values, but is a bit
-dangerous to use, since it will also try to print uninitialized variables. Uninitialized slices may cause gdb to try
-to print arbitrary large arrays.
-</p>
-
-<p>
-The function’s arguments:
-</p>
-
-<pre>
-(gdb) <b>info args</b>
-t = 0xf840688b60
-</pre>
-
-<p>
-When printing the argument, notice that it’s a pointer to a
-<code>Regexp</code> value. Note that GDB has incorrectly put the <code>*</code>
-on the right-hand side of the type name and made up a 'struct' keyword, in traditional C style.
-</p>
-
-<pre>
-(gdb) <b>p re</b>
-(gdb) p t
-$1 = (struct testing.T *) 0xf840688b60
-(gdb) p t
-$1 = (struct testing.T *) 0xf840688b60
-(gdb) p *t
-$2 = {errors = "", failed = false, ch = 0xf8406f5690}
-(gdb) p *t-&gt;ch
-$3 = struct hchan&lt;*testing.T&gt;
-</pre>
-
-<p>
-That <code>struct</code> <code>hchan&lt;*testing.T&gt;</code> is the
-runtime-internal representation of a channel. It is currently empty,
-or gdb would have pretty-printed its contents.
-</p>
-
-<p>
-Stepping forward:
-</p>
-
-<pre>
-(gdb) <b>n</b>  <i># execute next line</i>
-149             for _, test := range findTests {
-(gdb)    <i># enter is repeat</i>
-150                     re := MustCompile(test.pat)
-(gdb) <b>p test.pat</b>
-$4 = ""
-(gdb) <b>p re</b>
-$5 = (struct regexp.Regexp *) 0xf84068d070
-(gdb) <b>p *re</b>
-$6 = {expr = "", prog = 0xf840688b80, prefix = "", prefixBytes =  []uint8, prefixComplete = true, 
-  prefixRune = 0, cond = 0 '\000', numSubexp = 0, longest = false, mu = {state = 0, sema = 0}, 
-  machine =  []*regexp.machine}
-(gdb) <b>p *re->prog</b>
-$7 = {Inst =  []regexp/syntax.Inst = {{Op = 5 '\005', Out = 0, Arg = 0, Rune =  []int}, {Op = 
-    6 '\006', Out = 2, Arg = 0, Rune =  []int}, {Op = 4 '\004', Out = 0, Arg = 0, Rune =  []int}}, 
-  Start = 1, NumCap = 2}
-</pre>
-
-
-<p>
-We can step into the <code>String</code>function call with <code>"s"</code>:
-</p>
-
-<pre>
-(gdb) <b>s</b>
-regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/regexp/regexp.go:97
-97      func (re *Regexp) String() string {
-</pre>
-
-<p>
-Get a stack trace to see where we are:
-</p>
-
-<pre>
-(gdb) <b>bt</b>
-#0  regexp.(*Regexp).String (re=0xf84068d070, noname=void)
-    at /home/user/go/src/regexp/regexp.go:97
-#1  0x0000000000425615 in regexp.TestFind (t=0xf840688b60)
-    at /home/user/go/src/regexp/find_test.go:151
-#2  0x0000000000430233 in testing.tRunner (t=0xf840688b60, test=0x5747b8)
-    at /home/user/go/src/testing/testing.go:156
-#3  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
-....
-</pre>
-
-<p>
-Look at the source code:
-</p>
-
-<pre>
-(gdb) <b>l</b>
-92              mu      sync.Mutex
-93              machine []*machine
-94      }
-95
-96      // String returns the source text used to compile the regular expression.
-97      func (re *Regexp) String() string {
-98              return re.expr
-99      }
-100
-101     // Compile parses a regular expression and returns, if successful,
-</pre>
-
-<h3 id="Pretty_Printing">Pretty Printing</h3>
-
-<p>
-GDB's pretty printing mechanism is triggered by regexp matches on type names.  An example for slices:
-</p>
-
-<pre>
-(gdb) <b>p utf</b>
-$22 =  []uint8 = {0 '\000', 0 '\000', 0 '\000', 0 '\000'}
-</pre>
-
-<p>
-Since slices, arrays and strings are not C pointers, GDB can't interpret the subscripting operation for you, but
-you can look inside the runtime representation to do that (tab completion helps here):
-</p>
-<pre>
-
-(gdb) <b>p slc</b>
-$11 =  []int = {0, 0}
-(gdb) <b>p slc-&gt;</b><i>&lt;TAB&gt;</i>
-array  slc    len    
-(gdb) <b>p slc->array</b>
-$12 = (int *) 0xf84057af00
-(gdb) <b>p slc->array[1]</b>
-$13 = 0</pre>
-
-
-
-<p>
-The extension functions $len and $cap work on strings, arrays and slices:
-</p>
-
-<pre>
-(gdb) <b>p $len(utf)</b>
-$23 = 4
-(gdb) <b>p $cap(utf)</b>
-$24 = 4
-</pre>
-
-<p>
-Channels and maps are 'reference' types, which gdb shows as pointers to C++-like types <code>hash&lt;int,string&gt;*</code>.  Dereferencing will trigger prettyprinting
-</p>
-
-<p>
-Interfaces are represented in the runtime as a pointer to a type descriptor and a pointer to a value.  The Go GDB runtime extension decodes this and automatically triggers pretty printing for the runtime type.  The extension function <code>$dtype</code> decodes the dynamic type for you (examples are taken from a breakpoint at <code>regexp.go</code> line 293.)
-</p>
-
-<pre>
-(gdb) <b>p i</b>
-$4 = {str = "cbb"}
-(gdb) <b>whatis i</b>
-type = regexp.input
-(gdb) <b>p $dtype(i)</b>
-$26 = (struct regexp.inputBytes *) 0xf8400b4930
-(gdb) <b>iface i</b>
-regexp.input: struct regexp.inputBytes *
-</pre>

diff --git a/doc/diagnostics.html b/doc/diagnostics.html
deleted file mode 100644 (file)
index 438cdce..0000000
--- a/doc/diagnostics.html
+++ /dev/null
@@ -1,472 +0,0 @@
-<!--{
-       "Title": "Diagnostics",
-       "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-The Go ecosystem provides a large suite of APIs and tools to
-diagnose logic and performance problems in Go programs. This page
-summarizes the available tools and helps Go users pick the right one
-for their specific problem.
-</p>
-
-<p>
-Diagnostics solutions can be categorized into the following groups:
-</p>
-
-<ul>
-<li><strong>Profiling</strong>: Profiling tools analyze the complexity and costs of a
-Go program such as its memory usage and frequently called
-functions to identify the expensive sections of a Go program.</li>
-<li><strong>Tracing</strong>: Tracing is a way to instrument code to analyze latency
-throughout the lifecycle of a call or user request. Traces provide an
-overview of how much latency each component contributes to the overall
-latency in a system. Traces can span multiple Go processes.</li>
-<li><strong>Debugging</strong>: Debugging allows us to pause a Go program and examine
-its execution. Program state and flow can be verified with debugging.</li>
-<li><strong>Runtime statistics and events</strong>: Collection and analysis of runtime stats and events
-provides a high-level overview of the health of Go programs. Spikes/dips of metrics
-helps us to identify changes in throughput, utilization, and performance.</li>
-</ul>
-
-<p>
-Note: Some diagnostics tools may interfere with each other. For example, precise
-memory profiling skews CPU profiles and goroutine blocking profiling affects scheduler
-trace. Use tools in isolation to get more precise info.
-</p>
-
-<h2 id="profiling">Profiling</h2>
-
-<p>
-Profiling is useful for identifying expensive or frequently called sections
-of code. The Go runtime provides <a href="https://golang.org/pkg/runtime/pprof/">
-profiling data</a> in the format expected by the
-<a href="https://github.com/google/pprof/blob/master/doc/README.md">pprof visualization tool</a>.
-The profiling data can be collected during testing
-via <code>go</code> <code>test</code> or endpoints made available from the <a href="/pkg/net/http/pprof/">
-net/http/pprof</a> package. Users need to collect the profiling data and use pprof tools to filter
-and visualize the top code paths.
-</p>
-
-<p>Predefined profiles provided by the <a href="/pkg/runtime/pprof">runtime/pprof</a> package:</p>
-
-<ul>
-<li>
-<strong>cpu</strong>: CPU profile determines where a program spends
-its time while actively consuming CPU cycles (as opposed to while sleeping or waiting for I/O).
-</li>
-<li>
-<strong>heap</strong>: Heap profile reports memory allocation samples;
-used to monitor current and historical memory usage, and to check for memory leaks.
-</li>
-<li>
-<strong>threadcreate</strong>: Thread creation profile reports the sections
-of the program that lead the creation of new OS threads.
-</li>
-<li>
-<strong>goroutine</strong>: Goroutine profile reports the stack traces of all current goroutines.
-</li>
-<li>
-<strong>block</strong>: Block profile shows where goroutines block waiting on synchronization
-primitives (including timer channels). Block profile is not enabled by default;
-use <code>runtime.SetBlockProfileRate</code> to enable it.
-</li>
-<li>
-<strong>mutex</strong>: Mutex profile reports the lock contentions. When you think your
-CPU is not fully utilized due to a mutex contention, use this profile. Mutex profile
-is not enabled by default, see <code>runtime.SetMutexProfileFraction</code> to enable it.
-</li>
-</ul>
-
-
-<p><strong>What other profilers can I use to profile Go programs?</strong></p>
-
-<p>
-On Linux, <a href="https://perf.wiki.kernel.org/index.php/Tutorial">perf tools</a>
-can be used for profiling Go programs. Perf can profile
-and unwind cgo/SWIG code and kernel, so it can be useful to get insights into
-native/kernel performance bottlenecks. On macOS,
-<a href="https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/">Instruments</a>
-suite can be used profile Go programs.
-</p>
-
-<p><strong>Can I profile my production services?</strong></p>
-
-<p>Yes. It is safe to profile programs in production, but enabling
-some profiles (e.g. the CPU profile) adds cost. You should expect to
-see performance downgrade. The performance penalty can be estimated
-by measuring the overhead of the profiler before turning it on in
-production.
-</p>
-
-<p>
-You may want to periodically profile your production services.
-Especially in a system with many replicas of a single process, selecting
-a random replica periodically is a safe option.
-Select a production process, profile it for
-X seconds for every Y seconds and save the results for visualization and
-analysis; then repeat periodically. Results may be manually and/or automatically
-reviewed to find problems.
-Collection of profiles can interfere with each other,
-so it is recommended to collect only a single profile at a time.
-</p>
-
-<p>
-<strong>What are the best ways to visualize the profiling data?</strong>
-</p>
-
-<p>
-The Go tools provide text, graph, and <a href="http://valgrind.org/docs/manual/cl-manual.html">callgrind</a>
-visualization of the profile data using
-<code><a href="https://github.com/google/pprof/blob/master/doc/README.md">go tool pprof</a></code>.
-Read <a href="https://blog.golang.org/profiling-go-programs">Profiling Go programs</a>
-to see them in action.
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-text.png">
-<br>
-<small>Listing of the most expensive calls as text.</small>
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-dot.png">
-<br>
-<small>Visualization of the most expensive calls as a graph.</small>
-</p>
-
-<p>Weblist view displays the expensive parts of the source line by line in
-an HTML page. In the following example, 530ms is spent in the
-<code>runtime.concatstrings</code> and cost of each line is presented
-in the listing.</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-weblist.png">
-<br>
-<small>Visualization of the most expensive calls as weblist.</small>
-</p>
-
-<p>
-Another way to visualize profile data is a <a href="http://www.brendangregg.com/flamegraphs.html">flame graph</a>.
-Flame graphs allow you to move in a specific ancestry path, so you can zoom
-in/out of specific sections of code.
-The <a href="https://github.com/google/pprof">upstream pprof</a>
-has support for flame graphs.
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/flame.png">
-<br>
-<small>Flame graphs offers visualization to spot the most expensive code-paths.</small>
-</p>
-
-<p><strong>Am I restricted to the built-in profiles?</strong></p>
-
-<p>
-Additionally to what is provided by the runtime, Go users can create
-their custom profiles via <a href="/pkg/runtime/pprof/#Profile">pprof.Profile</a>
-and use the existing tools to examine them.
-</p>
-
-<p><strong>Can I serve the profiler handlers (/debug/pprof/...) on a different path and port?</strong></p>
-
-<p>
-Yes. The <code>net/http/pprof</code> package registers its handlers to the default
-mux by default, but you can also register them yourself by using the handlers
-exported from the package.
-</p>
-
-<p>
-For example, the following example will serve the pprof.Profile
-handler on :7777 at /custom_debug_path/profile:
-</p>
-
-<p>
-<pre>
-package main
-
-import (
-       "log"
-       "net/http"
-       "net/http/pprof"
-)
-
-func main() {
-       mux := http.NewServeMux()
-       mux.HandleFunc("/custom_debug_path/profile", pprof.Profile)
-       log.Fatal(http.ListenAndServe(":7777", mux))
-}
-</pre>
-</p>
-
-<h2 id="tracing">Tracing</h2>
-
-<p>
-Tracing is a way to instrument code to analyze latency throughout the
-lifecycle of a chain of calls. Go provides
-<a href="https://godoc.org/golang.org/x/net/trace">golang.org/x/net/trace</a>
-package as a minimal tracing backend per Go node and provides a minimal
-instrumentation library with a simple dashboard. Go also provides
-an execution tracer to trace the runtime events within an interval.
-</p>
-
-<p>Tracing enables us to:</p>
-
-<ul>
-<li>Instrument and analyze application latency in a Go process.</li>
-<li>Measure the cost of specific calls in a long chain of calls.</li>
-<li>Figure out the utilization and performance improvements.
-Bottlenecks are not always obvious without tracing data.</li>
-</ul>
-
-<p>
-In monolithic systems, it's relatively easy to collect diagnostic data
-from the building blocks of a program. All modules live within one
-process and share common resources to report logs, errors, and other
-diagnostic information. Once your system grows beyond a single process and
-starts to become distributed, it becomes harder to follow a call starting
-from the front-end web server to all of its back-ends until a response is
-returned back to the user. This is where distributed tracing plays a big
-role to instrument and analyze your production systems.
-</p>
-
-<p>
-Distributed tracing is a way to instrument code to analyze latency throughout
-the lifecycle of a user request. When a system is distributed and when
-conventional profiling and debugging tools don’t scale, you might want
-to use distributed tracing tools to analyze the performance of your user
-requests and RPCs.
-</p>
-
-<p>Distributed tracing enables us to:</p>
-
-<ul>
-<li>Instrument and profile application latency in a large system.</li>
-<li>Track all RPCs within the lifecycle of a user request and see integration issues
-that are only visible in production.</li>
-<li>Figure out performance improvements that can be applied to our systems.
-Many bottlenecks are not obvious before the collection of tracing data.</li>
-</ul>
-
-<p>The Go ecosystem provides various distributed tracing libraries per tracing system
-and backend-agnostic ones.</p>
-
-
-<p><strong>Is there a way to automatically intercept each function call and create traces?</strong></p>
-
-<p>
-Go doesn’t provide a way to automatically intercept every function call and create
-trace spans. You need to manually instrument your code to create, end, and annotate spans.
-</p>
-
-<p><strong>How should I propagate trace headers in Go libraries?</strong></p>
-
-<p>
-You can propagate trace identifiers and tags in the
-<a href="/pkg/context#Context"><code>context.Context</code></a>.
-There is no canonical trace key or common representation of trace headers
-in the industry yet. Each tracing provider is responsible for providing propagation
-utilities in their Go libraries.
-</p>
-
-<p>
-<strong>What other low-level events from the standard library or
-runtime can be included in a trace?</strong>
-</p>
-
-<p>
-The standard library and runtime are trying to expose several additional APIs
-to notify on low level internal events. For example,
-<a href="/pkg/net/http/httptrace#ClientTrace"><code>httptrace.ClientTrace</code></a>
-provides APIs to follow low-level events in the life cycle of an outgoing request.
-There is an ongoing effort to retrieve low-level runtime events from
-the runtime execution tracer and allow users to define and record their user events.
-</p>
-
-<h2 id="debugging">Debugging</h2>
-
-<p>
-Debugging is the process of identifying why a program misbehaves.
-Debuggers allow us to understand a program’s execution flow and current state.
-There are several styles of debugging; this section will only focus on attaching
-a debugger to a program and core dump debugging.
-</p>
-
-<p>Go users mostly use the following debuggers:</p>
-
-<ul>
-<li>
-<a href="https://github.com/derekparker/delve">Delve</a>:
-Delve is a debugger for the Go programming language. It has
-support for Go’s runtime concepts and built-in types. Delve is
-trying to be a fully featured reliable debugger for Go programs.
-</li>
-<li>
-<a href="https://golang.org/doc/gdb">GDB</a>:
-Go provides GDB support via the standard Go compiler and Gccgo.
-The stack management, threading, and runtime contain aspects that differ
-enough from the execution model GDB expects that they can confuse the
-debugger, even when the program is compiled with gccgo. Even though
-GDB can be used to debug Go programs, it is not ideal and may
-create confusion.
-</li>
-</ul>
-
-<p><strong>How well do debuggers work with Go programs?</strong></p>
-
-<p>
-The <code>gc</code> compiler performs optimizations such as
-function inlining and variable registerization. These optimizations
-sometimes make debugging with debuggers harder. There is an ongoing
-effort to improve the quality of the DWARF information generated for
-optimized binaries. Until those improvements are available, we recommend
-disabling optimizations when building the code being debugged. The following
-command builds a package with no compiler optimizations:
-
-<p>
-<pre>
-$ go build -gcflags=all="-N -l"
-</pre>
-</p>
-
-As part of the improvement effort, Go 1.10 introduced a new compiler
-flag <code>-dwarflocationlists</code>. The flag causes the compiler to
-add location lists that helps debuggers work with optimized binaries.
-The following command builds a package with optimizations but with
-the DWARF location lists:
-
-<p>
-<pre>
-$ go build -gcflags="-dwarflocationlists=true"
-</pre>
-</p>
-
-<p><strong>What’s the recommended debugger user interface?</strong></p>
-
-<p>
-Even though both delve and gdb provides CLIs, most editor integrations
-and IDEs provides debugging-specific user interfaces.
-</p>
-
-<p><strong>Is it possible to do postmortem debugging with Go programs?</strong></p>
-
-<p>
-A core dump file is a file that contains the memory dump of a running
-process and its process status. It is primarily used for post-mortem
-debugging of a program and to understand its state
-while it is still running. These two cases make debugging of core
-dumps a good diagnostic aid to postmortem and analyze production
-services. It is possible to obtain core files from Go programs and
-use delve or gdb to debug, see the
-<a href="https://golang.org/wiki/CoreDumpDebugging">core dump debugging</a>
-page for a step-by-step guide.
-</p>
-
-<h2 id="runtime">Runtime statistics and events</h2>
-
-<p>
-The runtime provides stats and reporting of internal events for
-users to diagnose performance and utilization problems at the
-runtime level.
-</p>
-
-<p>
-Users can monitor these stats to better understand the overall
-health and performance of Go programs.
-Some frequently monitored stats and states:
-</p>
-
-<ul>
-<li><code><a href="/pkg/runtime/#ReadMemStats">runtime.ReadMemStats</a></code>
-reports the metrics related to heap
-allocation and garbage collection. Memory stats are useful for
-monitoring how much memory resources a process is consuming,
-whether the process can utilize memory well, and to catch
-memory leaks.</li>
-<li><code><a href="/pkg/runtime/debug/#ReadGCStats">debug.ReadGCStats</a></code>
-reads statistics about garbage collection.
-It is useful to see how much of the resources are spent on GC pauses.
-It also reports a timeline of garbage collector pauses and pause time percentiles.</li>
-<li><code><a href="/pkg/runtime/debug/#Stack">debug.Stack</a></code>
-returns the current stack trace. Stack trace
-is useful to see how many goroutines are currently running,
-what they are doing, and whether they are blocked or not.</li>
-<li><code><a href="/pkg/runtime/debug/#WriteHeapDump">debug.WriteHeapDump</a></code>
-suspends the execution of all goroutines
-and allows you to dump the heap to a file. A heap dump is a
-snapshot of a Go process' memory at a given time. It contains all
-allocated objects as well as goroutines, finalizers, and more.</li>
-<li><code><a href="/pkg/runtime#NumGoroutine">runtime.NumGoroutine</a></code>
-returns the number of current goroutines.
-The value can be monitored to see whether enough goroutines are
-utilized, or to detect goroutine leaks.</li>
-</ul>
-
-<h3 id="execution-tracer">Execution tracer</h3>
-
-<p>Go comes with a runtime execution tracer to capture a wide range
-of runtime events. Scheduling, syscall, garbage collections,
-heap size, and other events are collected by runtime and available
-for visualization by the go tool trace. Execution tracer is a tool
-to detect latency and utilization problems. You can examine how well
-the CPU is utilized, and when networking or syscalls are a cause of
-preemption for the goroutines.</p>
-
-<p>Tracer is useful to:</p>
-<ul>
-<li>Understand how your goroutines execute.</li>
-<li>Understand some of the core runtime events such as GC runs.</li>
-<li>Identify poorly parallelized execution.</li>
-</ul>
-
-<p>However, it is not great for identifying hot spots such as
-analyzing the cause of excessive memory or CPU usage.
-Use profiling tools instead first to address them.</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/tracer-lock.png">
-</p>
-
-<p>Above, the go tool trace visualization shows the execution started
-fine, and then it became serialized. It suggests that there might
-be lock contention for a shared resource that creates a bottleneck.</p>
-
-<p>See <a href="https://golang.org/cmd/trace/"><code>go</code> <code>tool</code> <code>trace</code></a>
-to collect and analyze runtime traces.
-</p>
-
-<h3 id="godebug">GODEBUG</h3>
-
-<p>Runtime also emits events and information if
-<a href="https://golang.org/pkg/runtime/#hdr-Environment_Variables">GODEBUG</a>
-environmental variable is set accordingly.</p>
-
-<ul>
-<li>GODEBUG=gctrace=1 prints garbage collector events at
-each collection, summarizing the amount of memory collected
-and the length of the pause.</li>
-<li>GODEBUG=inittrace=1 prints a summary of execution time and memory allocation
-information for completed package initialization work.</li>
-<li>GODEBUG=schedtrace=X prints scheduling events every X milliseconds.</li>
-</ul>
-
-<p>The GODEBUG environmental variable can be used to disable use of
-instruction set extensions in the standard library and runtime.</p>
-
-<ul>
-<li>GODEBUG=cpu.all=off disables the use of all optional
-instruction set extensions.</li>
-<li>GODEBUG=cpu.<em>extension</em>=off disables use of instructions from the
-specified instruction set extension.<br>
-<em>extension</em> is the lower case name for the instruction set extension
-such as <em>sse41</em> or <em>avx</em>.</li>
-</ul>

diff --git a/doc/editors.html b/doc/editors.html
deleted file mode 100644 (file)
index 7a46fb7..0000000
--- a/doc/editors.html
+++ /dev/null
@@ -1,35 +0,0 @@
-<!--{
-       "Title": "Editor plugins and IDEs",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-  This document lists commonly used editor plugins and IDEs from the Go ecosystem
-  that make Go development more productive and seamless.
-  A comprehensive list of editor support and IDEs for Go development is available at
-  <a href="https://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
-</p>
-
-<h2 id="options">Options</h2>
-<p>
-The Go ecosystem provides a variety of editor plugins and IDEs to enhance your day-to-day
-editing, navigation, testing, and debugging experience.
-</p>
-
-<ul>
-<li><a href="https://github.com/fatih/vim-go">vim</a>: vim-go plugin provides Go programming language support</li>
-<li><a href="https://marketplace.visualstudio.com/items?itemName=golang.go">Visual Studio Code</a>:
-Go extension provides support for the Go programming language</li>
-<li><a href="https://www.jetbrains.com/go">GoLand</a>: GoLand is distributed either as a standalone IDE
-or as a plugin for IntelliJ IDEA Ultimate</li>
-<li><a href="https://atom.io/packages/go-plus">Atom</a>: Go-Plus is an Atom package that provides enhanced Go support</li>
-</ul>
-
-<p>
-Note that these are only a few top solutions; a more comprehensive
-community-maintained list of
-<a href="https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins">IDEs and text editor plugins</a>
-is available at the Wiki.
-</p>

diff --git a/doc/effective_go.html b/doc/effective_go.html
deleted file mode 100644 (file)
index 7620402..0000000
--- a/doc/effective_go.html
+++ /dev/null
@@ -1,3673 +0,0 @@
-<!--{
-       "Title": "Effective Go",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-Go is a new language.  Although it borrows ideas from
-existing languages,
-it has unusual properties that make effective Go programs
-different in character from programs written in its relatives.
-A straightforward translation of a C++ or Java program into Go
-is unlikely to produce a satisfactory result&mdash;Java programs
-are written in Java, not Go.
-On the other hand, thinking about the problem from a Go
-perspective could produce a successful but quite different
-program.
-In other words,
-to write Go well, it's important to understand its properties
-and idioms.
-It's also important to know the established conventions for
-programming in Go, such as naming, formatting, program
-construction, and so on, so that programs you write
-will be easy for other Go programmers to understand.
-</p>
-
-<p>
-This document gives tips for writing clear, idiomatic Go code.
-It augments the <a href="/ref/spec">language specification</a>,
-the <a href="//tour.golang.org/">Tour of Go</a>,
-and <a href="/doc/code.html">How to Write Go Code</a>,
-all of which you
-should read first.
-</p>
-
-<h3 id="examples">Examples</h3>
-
-<p>
-The <a href="/src/">Go package sources</a>
-are intended to serve not
-only as the core library but also as examples of how to
-use the language.
-Moreover, many of the packages contain working, self-contained
-executable examples you can run directly from the
-<a href="//golang.org">golang.org</a> web site, such as
-<a href="//golang.org/pkg/strings/#example_Map">this one</a> (if
-necessary, click on the word "Example" to open it up).
-If you have a question about how to approach a problem or how something
-might be implemented, the documentation, code and examples in the
-library can provide answers, ideas and
-background.
-</p>
-
-
-<h2 id="formatting">Formatting</h2>
-
-<p>
-Formatting issues are the most contentious
-but the least consequential.
-People can adapt to different formatting styles
-but it's better if they don't have to, and
-less time is devoted to the topic
-if everyone adheres to the same style.
-The problem is how to approach this Utopia without a long
-prescriptive style guide.
-</p>
-
-<p>
-With Go we take an unusual
-approach and let the machine
-take care of most formatting issues.
-The <code>gofmt</code> program
-(also available as <code>go fmt</code>, which
-operates at the package level rather than source file level)
-reads a Go program
-and emits the source in a standard style of indentation
-and vertical alignment, retaining and if necessary
-reformatting comments.
-If you want to know how to handle some new layout
-situation, run <code>gofmt</code>; if the answer doesn't
-seem right, rearrange your program (or file a bug about <code>gofmt</code>),
-don't work around it.
-</p>
-
-<p>
-As an example, there's no need to spend time lining up
-the comments on the fields of a structure.
-<code>Gofmt</code> will do that for you.  Given the
-declaration
-</p>
-
-<pre>
-type T struct {
-    name string // name of the object
-    value int // its value
-}
-</pre>
-
-<p>
-<code>gofmt</code> will line up the columns:
-</p>
-
-<pre>
-type T struct {
-    name    string // name of the object
-    value   int    // its value
-}
-</pre>
-
-<p>
-All Go code in the standard packages has been formatted with <code>gofmt</code>.
-</p>
-
-
-<p>
-Some formatting details remain.  Very briefly:
-</p>
-
-<dl>
-    <dt>Indentation</dt>
-    <dd>We use tabs for indentation and <code>gofmt</code> emits them by default.
-    Use spaces only if you must.
-    </dd>
-    <dt>Line length</dt>
-    <dd>
-    Go has no line length limit.  Don't worry about overflowing a punched card.
-    If a line feels too long, wrap it and indent with an extra tab.
-    </dd>
-    <dt>Parentheses</dt>
-    <dd>
-    Go needs fewer parentheses than C and Java: control structures (<code>if</code>,
-    <code>for</code>, <code>switch</code>) do not have parentheses in
-    their syntax.
-    Also, the operator precedence hierarchy is shorter and clearer, so
-<pre>
-x&lt;&lt;8 + y&lt;&lt;16
-</pre>
-    means what the spacing implies, unlike in the other languages.
-    </dd>
-</dl>
-
-<h2 id="commentary">Commentary</h2>
-
-<p>
-Go provides C-style <code>/* */</code> block comments
-and C++-style <code>//</code> line comments.
-Line comments are the norm;
-block comments appear mostly as package comments, but
-are useful within an expression or to disable large swaths of code.
-</p>
-
-<p>
-The program—and web server—<code>godoc</code> processes
-Go source files to extract documentation about the contents of the
-package.
-Comments that appear before top-level declarations, with no intervening newlines,
-are extracted along with the declaration to serve as explanatory text for the item.
-The nature and style of these comments determines the
-quality of the documentation <code>godoc</code> produces.
-</p>
-
-<p>
-Every package should have a <i>package comment</i>, a block
-comment preceding the package clause.
-For multi-file packages, the package comment only needs to be
-present in one file, and any one will do.
-The package comment should introduce the package and
-provide information relevant to the package as a whole.
-It will appear first on the <code>godoc</code> page and
-should set up the detailed documentation that follows.
-</p>
-
-<pre>
-/*
-Package regexp implements a simple library for regular expressions.
-
-The syntax of the regular expressions accepted is:
-
-    regexp:
-        concatenation { '|' concatenation }
-    concatenation:
-        { closure }
-    closure:
-        term [ '*' | '+' | '?' ]
-    term:
-        '^'
-        '$'
-        '.'
-        character
-        '[' [ '^' ] character-ranges ']'
-        '(' regexp ')'
-*/
-package regexp
-</pre>
-
-<p>
-If the package is simple, the package comment can be brief.
-</p>
-
-<pre>
-// Package path implements utility routines for
-// manipulating slash-separated filename paths.
-</pre>
-
-<p>
-Comments do not need extra formatting such as banners of stars.
-The generated output may not even be presented in a fixed-width font, so don't depend
-on spacing for alignment&mdash;<code>godoc</code>, like <code>gofmt</code>,
-takes care of that.
-The comments are uninterpreted plain text, so HTML and other
-annotations such as <code>_this_</code> will reproduce <i>verbatim</i> and should
-not be used.
-One adjustment <code>godoc</code> does do is to display indented
-text in a fixed-width font, suitable for program snippets.
-The package comment for the
-<a href="/pkg/fmt/"><code>fmt</code> package</a> uses this to good effect.
-</p>
-
-<p>
-Depending on the context, <code>godoc</code> might not even
-reformat comments, so make sure they look good straight up:
-use correct spelling, punctuation, and sentence structure,
-fold long lines, and so on.
-</p>
-
-<p>
-Inside a package, any comment immediately preceding a top-level declaration
-serves as a <i>doc comment</i> for that declaration.
-Every exported (capitalized) name in a program should
-have a doc comment.
-</p>
-
-<p>
-Doc comments work best as complete sentences, which allow
-a wide variety of automated presentations.
-The first sentence should be a one-sentence summary that
-starts with the name being declared.
-</p>
-
-<pre>
-// Compile parses a regular expression and returns, if successful,
-// a Regexp that can be used to match against text.
-func Compile(str string) (*Regexp, error) {
-</pre>
-
-<p>
-If every doc comment begins with the name of the item it describes,
-you can use the <a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
-subcommand of the <a href="/cmd/go/">go</a> tool
-and run the output through <code>grep</code>.
-Imagine you couldn't remember the name "Compile" but were looking for
-the parsing function for regular expressions, so you ran
-the command,
-</p>
-
-<pre>
-$ go doc -all regexp | grep -i parse
-</pre>
-
-<p>
-If all the doc comments in the package began, "This function...", <code>grep</code>
-wouldn't help you remember the name. But because the package starts each
-doc comment with the name, you'd see something like this,
-which recalls the word you're looking for.
-</p>
-
-<pre>
-$ go doc -all regexp | grep -i parse
-    Compile parses a regular expression and returns, if successful, a Regexp
-    MustCompile is like Compile but panics if the expression cannot be parsed.
-    parsed. It simplifies safe initialization of global variables holding
-$
-</pre>
-
-<p>
-Go's declaration syntax allows grouping of declarations.
-A single doc comment can introduce a group of related constants or variables.
-Since the whole declaration is presented, such a comment can often be perfunctory.
-</p>
-
-<pre>
-// Error codes returned by failures to parse an expression.
-var (
-    ErrInternal      = errors.New("regexp: internal error")
-    ErrUnmatchedLpar = errors.New("regexp: unmatched '('")
-    ErrUnmatchedRpar = errors.New("regexp: unmatched ')'")
-    ...
-)
-</pre>
-
-<p>
-Grouping can also indicate relationships between items,
-such as the fact that a set of variables is protected by a mutex.
-</p>
-
-<pre>
-var (
-    countLock   sync.Mutex
-    inputCount  uint32
-    outputCount uint32
-    errorCount  uint32
-)
-</pre>
-
-<h2 id="names">Names</h2>
-
-<p>
-Names are as important in Go as in any other language.
-They even have semantic effect:
-the visibility of a name outside a package is determined by whether its
-first character is upper case.
-It's therefore worth spending a little time talking about naming conventions
-in Go programs.
-</p>
-
-
-<h3 id="package-names">Package names</h3>
-
-<p>
-When a package is imported, the package name becomes an accessor for the
-contents.  After
-</p>
-
-<pre>
-import "bytes"
-</pre>
-
-<p>
-the importing package can talk about <code>bytes.Buffer</code>.  It's
-helpful if everyone using the package can use the same name to refer to
-its contents, which implies that the package name should be good:
-short, concise, evocative.  By convention, packages are given
-lower case, single-word names; there should be no need for underscores
-or mixedCaps.
-Err on the side of brevity, since everyone using your
-package will be typing that name.
-And don't worry about collisions <i>a priori</i>.
-The package name is only the default name for imports; it need not be unique
-across all source code, and in the rare case of a collision the
-importing package can choose a different name to use locally.
-In any case, confusion is rare because the file name in the import
-determines just which package is being used.
-</p>
-
-<p>
-Another convention is that the package name is the base name of
-its source directory;
-the package in <code>src/encoding/base64</code>
-is imported as <code>"encoding/base64"</code> but has name <code>base64</code>,
-not <code>encoding_base64</code> and not <code>encodingBase64</code>.
-</p>
-
-<p>
-The importer of a package will use the name to refer to its contents,
-so exported names in the package can use that fact
-to avoid stutter.
-(Don't use the <code>import .</code> notation, which can simplify
-tests that must run outside the package they are testing, but should otherwise be avoided.)
-For instance, the buffered reader type in the <code>bufio</code> package is called <code>Reader</code>,
-not <code>BufReader</code>, because users see it as <code>bufio.Reader</code>,
-which is a clear, concise name.
-Moreover,
-because imported entities are always addressed with their package name, <code>bufio.Reader</code>
-does not conflict with <code>io.Reader</code>.
-Similarly, the function to make new instances of <code>ring.Ring</code>&mdash;which
-is the definition of a <em>constructor</em> in Go&mdash;would
-normally be called <code>NewRing</code>, but since
-<code>Ring</code> is the only type exported by the package, and since the
-package is called <code>ring</code>, it's called just <code>New</code>,
-which clients of the package see as <code>ring.New</code>.
-Use the package structure to help you choose good names.
-</p>
-
-<p>
-Another short example is <code>once.Do</code>;
-<code>once.Do(setup)</code> reads well and would not be improved by
-writing <code>once.DoOrWaitUntilDone(setup)</code>.
-Long names don't automatically make things more readable.
-A helpful doc comment can often be more valuable than an extra long name.
-</p>
-
-<h3 id="Getters">Getters</h3>
-
-<p>
-Go doesn't provide automatic support for getters and setters.
-There's nothing wrong with providing getters and setters yourself,
-and it's often appropriate to do so, but it's neither idiomatic nor necessary
-to put <code>Get</code> into the getter's name.  If you have a field called
-<code>owner</code> (lower case, unexported), the getter method should be
-called <code>Owner</code> (upper case, exported), not <code>GetOwner</code>.
-The use of upper-case names for export provides the hook to discriminate
-the field from the method.
-A setter function, if needed, will likely be called <code>SetOwner</code>.
-Both names read well in practice:
-</p>
-<pre>
-owner := obj.Owner()
-if owner != user {
-    obj.SetOwner(user)
-}
-</pre>
-
-<h3 id="interface-names">Interface names</h3>
-
-<p>
-By convention, one-method interfaces are named by
-the method name plus an -er suffix or similar modification
-to construct an agent noun: <code>Reader</code>,
-<code>Writer</code>, <code>Formatter</code>,
-<code>CloseNotifier</code> etc.
-</p>
-
-<p>
-There are a number of such names and it's productive to honor them and the function
-names they capture.
-<code>Read</code>, <code>Write</code>, <code>Close</code>, <code>Flush</code>,
-<code>String</code> and so on have
-canonical signatures and meanings.  To avoid confusion,
-don't give your method one of those names unless it
-has the same signature and meaning.
-Conversely, if your type implements a method with the
-same meaning as a method on a well-known type,
-give it the same name and signature;
-call your string-converter method <code>String</code> not <code>ToString</code>.
-</p>
-
-<h3 id="mixed-caps">MixedCaps</h3>
-
-<p>
-Finally, the convention in Go is to use <code>MixedCaps</code>
-or <code>mixedCaps</code> rather than underscores to write
-multiword names.
-</p>
-
-<h2 id="semicolons">Semicolons</h2>
-
-<p>
-Like C, Go's formal grammar uses semicolons to terminate statements,
-but unlike in C, those semicolons do not appear in the source.
-Instead the lexer uses a simple rule to insert semicolons automatically
-as it scans, so the input text is mostly free of them.
-</p>
-
-<p>
-The rule is this. If the last token before a newline is an identifier
-(which includes words like <code>int</code> and <code>float64</code>),
-a basic literal such as a number or string constant, or one of the
-tokens
-</p>
-<pre>
-break continue fallthrough return ++ -- ) }
-</pre>
-<p>
-the lexer always inserts a semicolon after the token.
-This could be summarized as, &ldquo;if the newline comes
-after a token that could end a statement, insert a semicolon&rdquo;.
-</p>
-
-<p>
-A semicolon can also be omitted immediately before a closing brace,
-so a statement such as
-</p>
-<pre>
-    go func() { for { dst &lt;- &lt;-src } }()
-</pre>
-<p>
-needs no semicolons.
-Idiomatic Go programs have semicolons only in places such as
-<code>for</code> loop clauses, to separate the initializer, condition, and
-continuation elements.  They are also necessary to separate multiple
-statements on a line, should you write code that way.
-</p>
-
-<p>
-One consequence of the semicolon insertion rules
-is that you cannot put the opening brace of a
-control structure (<code>if</code>, <code>for</code>, <code>switch</code>,
-or <code>select</code>) on the next line.  If you do, a semicolon
-will be inserted before the brace, which could cause unwanted
-effects.  Write them like this
-</p>
-
-<pre>
-if i &lt; f() {
-    g()
-}
-</pre>
-<p>
-not like this
-</p>
-<pre>
-if i &lt; f()  // wrong!
-{           // wrong!
-    g()
-}
-</pre>
-
-
-<h2 id="control-structures">Control structures</h2>
-
-<p>
-The control structures of Go are related to those of C but differ
-in important ways.
-There is no <code>do</code> or <code>while</code> loop, only a
-slightly generalized
-<code>for</code>;
-<code>switch</code> is more flexible;
-<code>if</code> and <code>switch</code> accept an optional
-initialization statement like that of <code>for</code>;
-<code>break</code> and <code>continue</code> statements
-take an optional label to identify what to break or continue;
-and there are new control structures including a type switch and a
-multiway communications multiplexer, <code>select</code>.
-The syntax is also slightly different:
-there are no parentheses
-and the bodies must always be brace-delimited.
-</p>
-
-<h3 id="if">If</h3>
-
-<p>
-In Go a simple <code>if</code> looks like this:
-</p>
-<pre>
-if x &gt; 0 {
-    return y
-}
-</pre>
-
-<p>
-Mandatory braces encourage writing simple <code>if</code> statements
-on multiple lines.  It's good style to do so anyway,
-especially when the body contains a control statement such as a
-<code>return</code> or <code>break</code>.
-</p>
-
-<p>
-Since <code>if</code> and <code>switch</code> accept an initialization
-statement, it's common to see one used to set up a local variable.
-</p>
-
-<pre>
-if err := file.Chmod(0664); err != nil {
-    log.Print(err)
-    return err
-}
-</pre>
-
-<p id="else">
-In the Go libraries, you'll find that
-when an <code>if</code> statement doesn't flow into the next statement—that is,
-the body ends in <code>break</code>, <code>continue</code>,
-<code>goto</code>, or <code>return</code>—the unnecessary
-<code>else</code> is omitted.
-</p>
-
-<pre>
-f, err := os.Open(name)
-if err != nil {
-    return err
-}
-codeUsing(f)
-</pre>
-
-<p>
-This is an example of a common situation where code must guard against a
-sequence of error conditions.  The code reads well if the
-successful flow of control runs down the page, eliminating error cases
-as they arise.  Since error cases tend to end in <code>return</code>
-statements, the resulting code needs no <code>else</code> statements.
-</p>
-
-<pre>
-f, err := os.Open(name)
-if err != nil {
-    return err
-}
-d, err := f.Stat()
-if err != nil {
-    f.Close()
-    return err
-}
-codeUsing(f, d)
-</pre>
-
-
-<h3 id="redeclaration">Redeclaration and reassignment</h3>
-
-<p>
-An aside: The last example in the previous section demonstrates a detail of how the
-<code>:=</code> short declaration form works.
-The declaration that calls <code>os.Open</code> reads,
-</p>
-
-<pre>
-f, err := os.Open(name)
-</pre>
-
-<p>
-This statement declares two variables, <code>f</code> and <code>err</code>.
-A few lines later, the call to <code>f.Stat</code> reads,
-</p>
-
-<pre>
-d, err := f.Stat()
-</pre>
-
-<p>
-which looks as if it declares <code>d</code> and <code>err</code>.
-Notice, though, that <code>err</code> appears in both statements.
-This duplication is legal: <code>err</code> is declared by the first statement,
-but only <em>re-assigned</em> in the second.
-This means that the call to <code>f.Stat</code> uses the existing
-<code>err</code> variable declared above, and just gives it a new value.
-</p>
-
-<p>
-In a <code>:=</code> declaration a variable <code>v</code> may appear even
-if it has already been declared, provided:
-</p>
-
-<ul>
-<li>this declaration is in the same scope as the existing declaration of <code>v</code>
-(if <code>v</code> is already declared in an outer scope, the declaration will create a new variable §),</li>
-<li>the corresponding value in the initialization is assignable to <code>v</code>, and</li>
-<li>there is at least one other variable that is created by the declaration.</li>
-</ul>
-
-<p>
-This unusual property is pure pragmatism,
-making it easy to use a single <code>err</code> value, for example,
-in a long <code>if-else</code> chain.
-You'll see it used often.
-</p>
-
-<p>
-§ It's worth noting here that in Go the scope of function parameters and return values
-is the same as the function body, even though they appear lexically outside the braces
-that enclose the body.
-</p>
-
-<h3 id="for">For</h3>
-
-<p>
-The Go <code>for</code> loop is similar to&mdash;but not the same as&mdash;C's.
-It unifies <code>for</code>
-and <code>while</code> and there is no <code>do-while</code>.
-There are three forms, only one of which has semicolons.
-</p>
-<pre>
-// Like a C for
-for init; condition; post { }
-
-// Like a C while
-for condition { }
-
-// Like a C for(;;)
-for { }
-</pre>
-
-<p>
-Short declarations make it easy to declare the index variable right in the loop.
-</p>
-<pre>
-sum := 0
-for i := 0; i &lt; 10; i++ {
-    sum += i
-}
-</pre>
-
-<p>
-If you're looping over an array, slice, string, or map,
-or reading from a channel, a <code>range</code> clause can
-manage the loop.
-</p>
-<pre>
-for key, value := range oldMap {
-    newMap[key] = value
-}
-</pre>
-
-<p>
-If you only need the first item in the range (the key or index), drop the second:
-</p>
-<pre>
-for key := range m {
-    if key.expired() {
-        delete(m, key)
-    }
-}
-</pre>
-
-<p>
-If you only need the second item in the range (the value), use the <em>blank identifier</em>, an underscore, to discard the first:
-</p>
-<pre>
-sum := 0
-for _, value := range array {
-    sum += value
-}
-</pre>
-
-<p>
-The blank identifier has many uses, as described in <a href="#blank">a later section</a>.
-</p>
-
-<p>
-For strings, the <code>range</code> does more work for you, breaking out individual
-Unicode code points by parsing the UTF-8.
-Erroneous encodings consume one byte and produce the
-replacement rune U+FFFD.
-(The name (with associated builtin type) <code>rune</code> is Go terminology for a
-single Unicode code point.
-See <a href="/ref/spec#Rune_literals">the language specification</a>
-for details.)
-The loop
-</p>
-<pre>
-for pos, char := range "日本\x80語" { // \x80 is an illegal UTF-8 encoding
-    fmt.Printf("character %#U starts at byte position %d\n", char, pos)
-}
-</pre>
-<p>
-prints
-</p>
-<pre>
-character U+65E5 '日' starts at byte position 0
-character U+672C '本' starts at byte position 3
-character U+FFFD '�' starts at byte position 6
-character U+8A9E '語' starts at byte position 7
-</pre>
-
-<p>
-Finally, Go has no comma operator and <code>++</code> and <code>--</code>
-are statements not expressions.
-Thus if you want to run multiple variables in a <code>for</code>
-you should use parallel assignment (although that precludes <code>++</code> and <code>--</code>).
-</p>
-<pre>
-// Reverse a
-for i, j := 0, len(a)-1; i &lt; j; i, j = i+1, j-1 {
-    a[i], a[j] = a[j], a[i]
-}
-</pre>
-
-<h3 id="switch">Switch</h3>
-
-<p>
-Go's <code>switch</code> is more general than C's.
-The expressions need not be constants or even integers,
-the cases are evaluated top to bottom until a match is found,
-and if the <code>switch</code> has no expression it switches on
-<code>true</code>.
-It's therefore possible&mdash;and idiomatic&mdash;to write an
-<code>if</code>-<code>else</code>-<code>if</code>-<code>else</code>
-chain as a <code>switch</code>.
-</p>
-
-<pre>
-func unhex(c byte) byte {
-    switch {
-    case '0' &lt;= c &amp;&amp; c &lt;= '9':
-        return c - '0'
-    case 'a' &lt;= c &amp;&amp; c &lt;= 'f':
-        return c - 'a' + 10
-    case 'A' &lt;= c &amp;&amp; c &lt;= 'F':
-        return c - 'A' + 10
-    }
-    return 0
-}
-</pre>
-
-<p>
-There is no automatic fall through, but cases can be presented
-in comma-separated lists.
-</p>
-<pre>
-func shouldEscape(c byte) bool {
-    switch c {
-    case ' ', '?', '&amp;', '=', '#', '+', '%':
-        return true
-    }
-    return false
-}
-</pre>
-
-<p>
-Although they are not nearly as common in Go as some other C-like
-languages, <code>break</code> statements can be used to terminate
-a <code>switch</code> early.
-Sometimes, though, it's necessary to break out of a surrounding loop,
-not the switch, and in Go that can be accomplished by putting a label
-on the loop and "breaking" to that label.
-This example shows both uses.
-</p>
-
-<pre>
-Loop:
-       for n := 0; n &lt; len(src); n += size {
-               switch {
-               case src[n] &lt; sizeOne:
-                       if validateOnly {
-                               break
-                       }
-                       size = 1
-                       update(src[n])
-
-               case src[n] &lt; sizeTwo:
-                       if n+1 &gt;= len(src) {
-                               err = errShortInput
-                               break Loop
-                       }
-                       if validateOnly {
-                               break
-                       }
-                       size = 2
-                       update(src[n] + src[n+1]&lt;&lt;shift)
-               }
-       }
-</pre>
-
-<p>
-Of course, the <code>continue</code> statement also accepts an optional label
-but it applies only to loops.
-</p>
-
-<p>
-To close this section, here's a comparison routine for byte slices that uses two
-<code>switch</code> statements:
-</p>
-<pre>
-// Compare returns an integer comparing the two byte slices,
-// lexicographically.
-// The result will be 0 if a == b, -1 if a &lt; b, and +1 if a &gt; b
-func Compare(a, b []byte) int {
-    for i := 0; i &lt; len(a) &amp;&amp; i &lt; len(b); i++ {
-        switch {
-        case a[i] &gt; b[i]:
-            return 1
-        case a[i] &lt; b[i]:
-            return -1
-        }
-    }
-    switch {
-    case len(a) &gt; len(b):
-        return 1
-    case len(a) &lt; len(b):
-        return -1
-    }
-    return 0
-}
-</pre>
-
-<h3 id="type_switch">Type switch</h3>
-
-<p>
-A switch can also be used to discover the dynamic type of an interface
-variable.  Such a <em>type switch</em> uses the syntax of a type
-assertion with the keyword <code>type</code> inside the parentheses.
-If the switch declares a variable in the expression, the variable will
-have the corresponding type in each clause.
-It's also idiomatic to reuse the name in such cases, in effect declaring
-a new variable with the same name but a different type in each case.
-</p>
-<pre>
-var t interface{}
-t = functionOfSomeType()
-switch t := t.(type) {
-default:
-    fmt.Printf("unexpected type %T\n", t)     // %T prints whatever type t has
-case bool:
-    fmt.Printf("boolean %t\n", t)             // t has type bool
-case int:
-    fmt.Printf("integer %d\n", t)             // t has type int
-case *bool:
-    fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
-case *int:
-    fmt.Printf("pointer to integer %d\n", *t) // t has type *int
-}
-</pre>
-
-<h2 id="functions">Functions</h2>
-
-<h3 id="multiple-returns">Multiple return values</h3>
-
-<p>
-One of Go's unusual features is that functions and methods
-can return multiple values.  This form can be used to
-improve on a couple of clumsy idioms in C programs: in-band
-error returns such as <code>-1</code> for <code>EOF</code>
-and modifying an argument passed by address.
-</p>
-
-<p>
-In C, a write error is signaled by a negative count with the
-error code secreted away in a volatile location.
-In Go, <code>Write</code>
-can return a count <i>and</i> an error: &ldquo;Yes, you wrote some
-bytes but not all of them because you filled the device&rdquo;.
-The signature of the <code>Write</code> method on files from
-package <code>os</code> is:
-</p>
-
-<pre>
-func (file *File) Write(b []byte) (n int, err error)
-</pre>
-
-<p>
-and as the documentation says, it returns the number of bytes
-written and a non-nil <code>error</code> when <code>n</code>
-<code>!=</code> <code>len(b)</code>.
-This is a common style; see the section on error handling for more examples.
-</p>
-
-<p>
-A similar approach obviates the need to pass a pointer to a return
-value to simulate a reference parameter.
-Here's a simple-minded function to
-grab a number from a position in a byte slice, returning the number
-and the next position.
-</p>
-
-<pre>
-func nextInt(b []byte, i int) (int, int) {
-    for ; i &lt; len(b) &amp;&amp; !isDigit(b[i]); i++ {
-    }
-    x := 0
-    for ; i &lt; len(b) &amp;&amp; isDigit(b[i]); i++ {
-        x = x*10 + int(b[i]) - '0'
-    }
-    return x, i
-}
-</pre>
-
-<p>
-You could use it to scan the numbers in an input slice <code>b</code> like this:
-</p>
-
-<pre>
-    for i := 0; i &lt; len(b); {
-        x, i = nextInt(b, i)
-        fmt.Println(x)
-    }
-</pre>
-
-<h3 id="named-results">Named result parameters</h3>
-
-<p>
-The return or result "parameters" of a Go function can be given names and
-used as regular variables, just like the incoming parameters.
-When named, they are initialized to the zero values for their types when
-the function begins; if the function executes a <code>return</code> statement
-with no arguments, the current values of the result parameters are
-used as the returned values.
-</p>
-
-<p>
-The names are not mandatory but they can make code shorter and clearer:
-they're documentation.
-If we name the results of <code>nextInt</code> it becomes
-obvious which returned <code>int</code>
-is which.
-</p>
-
-<pre>
-func nextInt(b []byte, pos int) (value, nextPos int) {
-</pre>
-
-<p>
-Because named results are initialized and tied to an unadorned return, they can simplify
-as well as clarify.  Here's a version
-of <code>io.ReadFull</code> that uses them well:
-</p>
-
-<pre>
-func ReadFull(r Reader, buf []byte) (n int, err error) {
-    for len(buf) &gt; 0 &amp;&amp; err == nil {
-        var nr int
-        nr, err = r.Read(buf)
-        n += nr
-        buf = buf[nr:]
-    }
-    return
-}
-</pre>
-
-<h3 id="defer">Defer</h3>
-
-<p>
-Go's <code>defer</code> statement schedules a function call (the
-<i>deferred</i> function) to be run immediately before the function
-executing the <code>defer</code> returns.  It's an unusual but
-effective way to deal with situations such as resources that must be
-released regardless of which path a function takes to return.  The
-canonical examples are unlocking a mutex or closing a file.
-</p>
-
-<pre>
-// Contents returns the file's contents as a string.
-func Contents(filename string) (string, error) {
-    f, err := os.Open(filename)
-    if err != nil {
-        return "", err
-    }
-    defer f.Close()  // f.Close will run when we're finished.
-
-    var result []byte
-    buf := make([]byte, 100)
-    for {
-        n, err := f.Read(buf[0:])
-        result = append(result, buf[0:n]...) // append is discussed later.
-        if err != nil {
-            if err == io.EOF {
-                break
-            }
-            return "", err  // f will be closed if we return here.
-        }
-    }
-    return string(result), nil // f will be closed if we return here.
-}
-</pre>
-
-<p>
-Deferring a call to a function such as <code>Close</code> has two advantages.  First, it
-guarantees that you will never forget to close the file, a mistake
-that's easy to make if you later edit the function to add a new return
-path.  Second, it means that the close sits near the open,
-which is much clearer than placing it at the end of the function.
-</p>
-
-<p>
-The arguments to the deferred function (which include the receiver if
-the function is a method) are evaluated when the <i>defer</i>
-executes, not when the <i>call</i> executes.  Besides avoiding worries
-about variables changing values as the function executes, this means
-that a single deferred call site can defer multiple function
-executions.  Here's a silly example.
-</p>
-
-<pre>
-for i := 0; i &lt; 5; i++ {
-    defer fmt.Printf("%d ", i)
-}
-</pre>
-
-<p>
-Deferred functions are executed in LIFO order, so this code will cause
-<code>4 3 2 1 0</code> to be printed when the function returns.  A
-more plausible example is a simple way to trace function execution
-through the program.  We could write a couple of simple tracing
-routines like this:
-</p>
-
-<pre>
-func trace(s string)   { fmt.Println("entering:", s) }
-func untrace(s string) { fmt.Println("leaving:", s) }
-
-// Use them like this:
-func a() {
-    trace("a")
-    defer untrace("a")
-    // do something....
-}
-</pre>
-
-<p>
-We can do better by exploiting the fact that arguments to deferred
-functions are evaluated when the <code>defer</code> executes.  The
-tracing routine can set up the argument to the untracing routine.
-This example:
-</p>
-
-<pre>
-func trace(s string) string {
-    fmt.Println("entering:", s)
-    return s
-}
-
-func un(s string) {
-    fmt.Println("leaving:", s)
-}
-
-func a() {
-    defer un(trace("a"))
-    fmt.Println("in a")
-}
-
-func b() {
-    defer un(trace("b"))
-    fmt.Println("in b")
-    a()
-}
-
-func main() {
-    b()
-}
-</pre>
-
-<p>
-prints
-</p>
-
-<pre>
-entering: b
-in b
-entering: a
-in a
-leaving: a
-leaving: b
-</pre>
-
-<p>
-For programmers accustomed to block-level resource management from
-other languages, <code>defer</code> may seem peculiar, but its most
-interesting and powerful applications come precisely from the fact
-that it's not block-based but function-based.  In the section on
-<code>panic</code> and <code>recover</code> we'll see another
-example of its possibilities.
-</p>
-
-<h2 id="data">Data</h2>
-
-<h3 id="allocation_new">Allocation with <code>new</code></h3>
-
-<p>
-Go has two allocation primitives, the built-in functions
-<code>new</code> and <code>make</code>.
-They do different things and apply to different types, which can be confusing,
-but the rules are simple.
-Let's talk about <code>new</code> first.
-It's a built-in function that allocates memory, but unlike its namesakes
-in some other languages it does not <em>initialize</em> the memory,
-it only <em>zeros</em> it.
-That is,
-<code>new(T)</code> allocates zeroed storage for a new item of type
-<code>T</code> and returns its address, a value of type <code>*T</code>.
-In Go terminology, it returns a pointer to a newly allocated zero value of type
-<code>T</code>.
-</p>
-
-<p>
-Since the memory returned by <code>new</code> is zeroed, it's helpful to arrange
-when designing your data structures that the
-zero value of each type can be used without further initialization.  This means a user of
-the data structure can create one with <code>new</code> and get right to
-work.
-For example, the documentation for <code>bytes.Buffer</code> states that
-"the zero value for <code>Buffer</code> is an empty buffer ready to use."
-Similarly, <code>sync.Mutex</code> does not
-have an explicit constructor or <code>Init</code> method.
-Instead, the zero value for a <code>sync.Mutex</code>
-is defined to be an unlocked mutex.
-</p>
-
-<p>
-The zero-value-is-useful property works transitively. Consider this type declaration.
-</p>
-
-<pre>
-type SyncedBuffer struct {
-    lock    sync.Mutex
-    buffer  bytes.Buffer
-}
-</pre>
-
-<p>
-Values of type <code>SyncedBuffer</code> are also ready to use immediately upon allocation
-or just declaration.  In the next snippet, both <code>p</code> and <code>v</code> will work
-correctly without further arrangement.
-</p>
-
-<pre>
-p := new(SyncedBuffer)  // type *SyncedBuffer
-var v SyncedBuffer      // type  SyncedBuffer
-</pre>
-
-<h3 id="composite_literals">Constructors and composite literals</h3>
-
-<p>
-Sometimes the zero value isn't good enough and an initializing
-constructor is necessary, as in this example derived from
-package <code>os</code>.
-</p>
-
-<pre>
-func NewFile(fd int, name string) *File {
-    if fd &lt; 0 {
-        return nil
-    }
-    f := new(File)
-    f.fd = fd
-    f.name = name
-    f.dirinfo = nil
-    f.nepipe = 0
-    return f
-}
-</pre>
-
-<p>
-There's a lot of boiler plate in there.  We can simplify it
-using a <i>composite literal</i>, which is
-an expression that creates a
-new instance each time it is evaluated.
-</p>
-
-<pre>
-func NewFile(fd int, name string) *File {
-    if fd &lt; 0 {
-        return nil
-    }
-    f := File{fd, name, nil, 0}
-    return &amp;f
-}
-</pre>
-
-<p>
-Note that, unlike in C, it's perfectly OK to return the address of a local variable;
-the storage associated with the variable survives after the function
-returns.
-In fact, taking the address of a composite literal
-allocates a fresh instance each time it is evaluated,
-so we can combine these last two lines.
-</p>
-
-<pre>
-    return &amp;File{fd, name, nil, 0}
-</pre>
-
-<p>
-The fields of a composite literal are laid out in order and must all be present.
-However, by labeling the elements explicitly as <i>field</i><code>:</code><i>value</i>
-pairs, the initializers can appear in any
-order, with the missing ones left as their respective zero values.  Thus we could say
-</p>
-
-<pre>
-    return &amp;File{fd: fd, name: name}
-</pre>
-
-<p>
-As a limiting case, if a composite literal contains no fields at all, it creates
-a zero value for the type.  The expressions <code>new(File)</code> and <code>&amp;File{}</code> are equivalent.
-</p>
-
-<p>
-Composite literals can also be created for arrays, slices, and maps,
-with the field labels being indices or map keys as appropriate.
-In these examples, the initializations work regardless of the values of <code>Enone</code>,
-<code>Eio</code>, and <code>Einval</code>, as long as they are distinct.
-</p>
-
-<pre>
-a := [...]string   {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
-s := []string      {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
-m := map[int]string{Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
-</pre>
-
-<h3 id="allocation_make">Allocation with <code>make</code></h3>
-
-<p>
-Back to allocation.
-The built-in function <code>make(T, </code><i>args</i><code>)</code> serves
-a purpose different from <code>new(T)</code>.
-It creates slices, maps, and channels only, and it returns an <em>initialized</em>
-(not <em>zeroed</em>)
-value of type <code>T</code> (not <code>*T</code>).
-The reason for the distinction
-is that these three types represent, under the covers, references to data structures that
-must be initialized before use.
-A slice, for example, is a three-item descriptor
-containing a pointer to the data (inside an array), the length, and the
-capacity, and until those items are initialized, the slice is <code>nil</code>.
-For slices, maps, and channels,
-<code>make</code> initializes the internal data structure and prepares
-the value for use.
-For instance,
-</p>
-
-<pre>
-make([]int, 10, 100)
-</pre>
-
-<p>
-allocates an array of 100 ints and then creates a slice
-structure with length 10 and a capacity of 100 pointing at the first
-10 elements of the array.
-(When making a slice, the capacity can be omitted; see the section on slices
-for more information.)
-In contrast, <code>new([]int)</code> returns a pointer to a newly allocated, zeroed slice
-structure, that is, a pointer to a <code>nil</code> slice value.
-</p>
-
-<p>
-These examples illustrate the difference between <code>new</code> and
-<code>make</code>.
-</p>
-
-<pre>
-var p *[]int = new([]int)       // allocates slice structure; *p == nil; rarely useful
-var v  []int = make([]int, 100) // the slice v now refers to a new array of 100 ints
-
-// Unnecessarily complex:
-var p *[]int = new([]int)
-*p = make([]int, 100, 100)
-
-// Idiomatic:
-v := make([]int, 100)
-</pre>
-
-<p>
-Remember that <code>make</code> applies only to maps, slices and channels
-and does not return a pointer.
-To obtain an explicit pointer allocate with <code>new</code> or take the address
-of a variable explicitly.
-</p>
-
-<h3 id="arrays">Arrays</h3>
-
-<p>
-Arrays are useful when planning the detailed layout of memory and sometimes
-can help avoid allocation, but primarily
-they are a building block for slices, the subject of the next section.
-To lay the foundation for that topic, here are a few words about arrays.
-</p>
-
-<p>
-There are major differences between the ways arrays work in Go and C.
-In Go,
-</p>
-<ul>
-<li>
-Arrays are values. Assigning one array to another copies all the elements.
-</li>
-<li>
-In particular, if you pass an array to a function, it
-will receive a <i>copy</i> of the array, not a pointer to it.
-<li>
-The size of an array is part of its type.  The types <code>[10]int</code>
-and <code>[20]int</code> are distinct.
-</li>
-</ul>
-
-<p>
-The value property can be useful but also expensive; if you want C-like behavior and efficiency,
-you can pass a pointer to the array.
-</p>
-
-<pre>
-func Sum(a *[3]float64) (sum float64) {
-    for _, v := range *a {
-        sum += v
-    }
-    return
-}
-
-array := [...]float64{7.0, 8.5, 9.1}
-x := Sum(&amp;array)  // Note the explicit address-of operator
-</pre>
-
-<p>
-But even this style isn't idiomatic Go.
-Use slices instead.
-</p>
-
-<h3 id="slices">Slices</h3>
-
-<p>
-Slices wrap arrays to give a more general, powerful, and convenient
-interface to sequences of data.  Except for items with explicit
-dimension such as transformation matrices, most array programming in
-Go is done with slices rather than simple arrays.
-</p>
-<p>
-Slices hold references to an underlying array, and if you assign one
-slice to another, both refer to the same array.
-If a function takes a slice argument, changes it makes to
-the elements of the slice will be visible to the caller, analogous to
-passing a pointer to the underlying array.  A <code>Read</code>
-function can therefore accept a slice argument rather than a pointer
-and a count; the length within the slice sets an upper
-limit of how much data to read.  Here is the signature of the
-<code>Read</code> method of the <code>File</code> type in package
-<code>os</code>:
-</p>
-<pre>
-func (f *File) Read(buf []byte) (n int, err error)
-</pre>
-<p>
-The method returns the number of bytes read and an error value, if
-any.
-To read into the first 32 bytes of a larger buffer
-<code>buf</code>, <i>slice</i> (here used as a verb) the buffer.
-</p>
-<pre>
-    n, err := f.Read(buf[0:32])
-</pre>
-<p>
-Such slicing is common and efficient.  In fact, leaving efficiency aside for
-the moment, the following snippet would also read the first 32 bytes of the buffer.
-</p>
-<pre>
-    var n int
-    var err error
-    for i := 0; i &lt; 32; i++ {
-        nbytes, e := f.Read(buf[i:i+1])  // Read one byte.
-        n += nbytes
-        if nbytes == 0 || e != nil {
-            err = e
-            break
-        }
-    }
-</pre>
-<p>
-The length of a slice may be changed as long as it still fits within
-the limits of the underlying array; just assign it to a slice of
-itself.  The <i>capacity</i> of a slice, accessible by the built-in
-function <code>cap</code>, reports the maximum length the slice may
-assume.  Here is a function to append data to a slice.  If the data
-exceeds the capacity, the slice is reallocated.  The
-resulting slice is returned.  The function uses the fact that
-<code>len</code> and <code>cap</code> are legal when applied to the
-<code>nil</code> slice, and return 0.
-</p>
-<pre>
-func Append(slice, data []byte) []byte {
-    l := len(slice)
-    if l + len(data) &gt; cap(slice) {  // reallocate
-        // Allocate double what's needed, for future growth.
-        newSlice := make([]byte, (l+len(data))*2)
-        // The copy function is predeclared and works for any slice type.
-        copy(newSlice, slice)
-        slice = newSlice
-    }
-    slice = slice[0:l+len(data)]
-    copy(slice[l:], data)
-    return slice
-}
-</pre>
-<p>
-We must return the slice afterwards because, although <code>Append</code>
-can modify the elements of <code>slice</code>, the slice itself (the run-time data
-structure holding the pointer, length, and capacity) is passed by value.
-</p>
-
-<p>
-The idea of appending to a slice is so useful it's captured by the
-<code>append</code> built-in function.  To understand that function's
-design, though, we need a little more information, so we'll return
-to it later.
-</p>
-
-<h3 id="two_dimensional_slices">Two-dimensional slices</h3>
-
-<p>
-Go's arrays and slices are one-dimensional.
-To create the equivalent of a 2D array or slice, it is necessary to define an array-of-arrays
-or slice-of-slices, like this:
-</p>
-
-<pre>
-type Transform [3][3]float64  // A 3x3 array, really an array of arrays.
-type LinesOfText [][]byte     // A slice of byte slices.
-</pre>
-
-<p>
-Because slices are variable-length, it is possible to have each inner
-slice be a different length.
-That can be a common situation, as in our <code>LinesOfText</code>
-example: each line has an independent length.
-</p>
-
-<pre>
-text := LinesOfText{
-       []byte("Now is the time"),
-       []byte("for all good gophers"),
-       []byte("to bring some fun to the party."),
-}
-</pre>
-
-<p>
-Sometimes it's necessary to allocate a 2D slice, a situation that can arise when
-processing scan lines of pixels, for instance.
-There are two ways to achieve this.
-One is to allocate each slice independently; the other
-is to allocate a single array and point the individual slices into it.
-Which to use depends on your application.
-If the slices might grow or shrink, they should be allocated independently
-to avoid overwriting the next line; if not, it can be more efficient to construct
-the object with a single allocation.
-For reference, here are sketches of the two methods.
-First, a line at a time:
-</p>
-
-<pre>
-// Allocate the top-level slice.
-picture := make([][]uint8, YSize) // One row per unit of y.
-// Loop over the rows, allocating the slice for each row.
-for i := range picture {
-       picture[i] = make([]uint8, XSize)
-}
-</pre>
-
-<p>
-And now as one allocation, sliced into lines:
-</p>
-
-<pre>
-// Allocate the top-level slice, the same as before.
-picture := make([][]uint8, YSize) // One row per unit of y.
-// Allocate one large slice to hold all the pixels.
-pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
-// Loop over the rows, slicing each row from the front of the remaining pixels slice.
-for i := range picture {
-       picture[i], pixels = pixels[:XSize], pixels[XSize:]
-}
-</pre>
-
-<h3 id="maps">Maps</h3>
-
-<p>
-Maps are a convenient and powerful built-in data structure that associate
-values of one type (the <em>key</em>) with values of another type
-(the <em>element</em> or <em>value</em>).
-The key can be of any type for which the equality operator is defined,
-such as integers,
-floating point and complex numbers,
-strings, pointers, interfaces (as long as the dynamic type
-supports equality), structs and arrays.
-Slices cannot be used as map keys,
-because equality is not defined on them.
-Like slices, maps hold references to an underlying data structure.
-If you pass a map to a function
-that changes the contents of the map, the changes will be visible
-in the caller.
-</p>
-<p>
-Maps can be constructed using the usual composite literal syntax
-with colon-separated key-value pairs,
-so it's easy to build them during initialization.
-</p>
-<pre>
-var timeZone = map[string]int{
-    "UTC":  0*60*60,
-    "EST": -5*60*60,
-    "CST": -6*60*60,
-    "MST": -7*60*60,
-    "PST": -8*60*60,
-}
-</pre>
-<p>
-Assigning and fetching map values looks syntactically just like
-doing the same for arrays and slices except that the index doesn't
-need to be an integer.
-</p>
-<pre>
-offset := timeZone["EST"]
-</pre>
-<p>
-An attempt to fetch a map value with a key that
-is not present in the map will return the zero value for the type
-of the entries
-in the map.  For instance, if the map contains integers, looking
-up a non-existent key will return <code>0</code>.
-A set can be implemented as a map with value type <code>bool</code>.
-Set the map entry to <code>true</code> to put the value in the set, and then
-test it by simple indexing.
-</p>
-<pre>
-attended := map[string]bool{
-    "Ann": true,
-    "Joe": true,
-    ...
-}
-
-if attended[person] { // will be false if person is not in the map
-    fmt.Println(person, "was at the meeting")
-}
-</pre>
-<p>
-Sometimes you need to distinguish a missing entry from
-a zero value.  Is there an entry for <code>"UTC"</code>
-or is that 0 because it's not in the map at all?
-You can discriminate with a form of multiple assignment.
-</p>
-<pre>
-var seconds int
-var ok bool
-seconds, ok = timeZone[tz]
-</pre>
-<p>
-For obvious reasons this is called the &ldquo;comma ok&rdquo; idiom.
-In this example, if <code>tz</code> is present, <code>seconds</code>
-will be set appropriately and <code>ok</code> will be true; if not,
-<code>seconds</code> will be set to zero and <code>ok</code> will
-be false.
-Here's a function that puts it together with a nice error report:
-</p>
-<pre>
-func offset(tz string) int {
-    if seconds, ok := timeZone[tz]; ok {
-        return seconds
-    }
-    log.Println("unknown time zone:", tz)
-    return 0
-}
-</pre>
-<p>
-To test for presence in the map without worrying about the actual value,
-you can use the <a href="#blank">blank identifier</a> (<code>_</code>)
-in place of the usual variable for the value.
-</p>
-<pre>
-_, present := timeZone[tz]
-</pre>
-<p>
-To delete a map entry, use the <code>delete</code>
-built-in function, whose arguments are the map and the key to be deleted.
-It's safe to do this even if the key is already absent
-from the map.
-</p>
-<pre>
-delete(timeZone, "PDT")  // Now on Standard Time
-</pre>
-
-<h3 id="printing">Printing</h3>
-
-<p>
-Formatted printing in Go uses a style similar to C's <code>printf</code>
-family but is richer and more general. The functions live in the <code>fmt</code>
-package and have capitalized names: <code>fmt.Printf</code>, <code>fmt.Fprintf</code>,
-<code>fmt.Sprintf</code> and so on.  The string functions (<code>Sprintf</code> etc.)
-return a string rather than filling in a provided buffer.
-</p>
-<p>
-You don't need to provide a format string.  For each of <code>Printf</code>,
-<code>Fprintf</code> and <code>Sprintf</code> there is another pair
-of functions, for instance <code>Print</code> and <code>Println</code>.
-These functions do not take a format string but instead generate a default
-format for each argument. The <code>Println</code> versions also insert a blank
-between arguments and append a newline to the output while
-the <code>Print</code> versions add blanks only if the operand on neither side is a string.
-In this example each line produces the same output.
-</p>
-<pre>
-fmt.Printf("Hello %d\n", 23)
-fmt.Fprint(os.Stdout, "Hello ", 23, "\n")
-fmt.Println("Hello", 23)
-fmt.Println(fmt.Sprint("Hello ", 23))
-</pre>
-<p>
-The formatted print functions <code>fmt.Fprint</code>
-and friends take as a first argument any object
-that implements the <code>io.Writer</code> interface; the variables <code>os.Stdout</code>
-and <code>os.Stderr</code> are familiar instances.
-</p>
-<p>
-Here things start to diverge from C.  First, the numeric formats such as <code>%d</code>
-do not take flags for signedness or size; instead, the printing routines use the
-type of the argument to decide these properties.
-</p>
-<pre>
-var x uint64 = 1&lt;&lt;64 - 1
-fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x))
-</pre>
-<p>
-prints
-</p>
-<pre>
-18446744073709551615 ffffffffffffffff; -1 -1
-</pre>
-<p>
-If you just want the default conversion, such as decimal for integers, you can use
-the catchall format <code>%v</code> (for &ldquo;value&rdquo;); the result is exactly
-what <code>Print</code> and <code>Println</code> would produce.
-Moreover, that format can print <em>any</em> value, even arrays, slices, structs, and
-maps.  Here is a print statement for the time zone map defined in the previous section.
-</p>
-<pre>
-fmt.Printf("%v\n", timeZone)  // or just fmt.Println(timeZone)
-</pre>
-<p>
-which gives output:
-</p>
-<pre>
-map[CST:-21600 EST:-18000 MST:-25200 PST:-28800 UTC:0]
-</pre>
-<p>
-For maps, <code>Printf</code> and friends sort the output lexicographically by key.
-</p>
-<p>
-When printing a struct, the modified format <code>%+v</code> annotates the
-fields of the structure with their names, and for any value the alternate
-format <code>%#v</code> prints the value in full Go syntax.
-</p>
-<pre>
-type T struct {
-    a int
-    b float64
-    c string
-}
-t := &amp;T{ 7, -2.35, "abc\tdef" }
-fmt.Printf("%v\n", t)
-fmt.Printf("%+v\n", t)
-fmt.Printf("%#v\n", t)
-fmt.Printf("%#v\n", timeZone)
-</pre>
-<p>
-prints
-</p>
-<pre>
-&amp;{7 -2.35 abc   def}
-&amp;{a:7 b:-2.35 c:abc     def}
-&amp;main.T{a:7, b:-2.35, c:"abc\tdef"}
-map[string]int{"CST":-21600, "EST":-18000, "MST":-25200, "PST":-28800, "UTC":0}
-</pre>
-<p>
-(Note the ampersands.)
-That quoted string format is also available through <code>%q</code> when
-applied to a value of type <code>string</code> or <code>[]byte</code>.
-The alternate format <code>%#q</code> will use backquotes instead if possible.
-(The <code>%q</code> format also applies to integers and runes, producing a
-single-quoted rune constant.)
-Also, <code>%x</code> works on strings, byte arrays and byte slices as well as
-on integers, generating a long hexadecimal string, and with
-a space in the format (<code>%&nbsp;x</code>) it puts spaces between the bytes.
-</p>
-<p>
-Another handy format is <code>%T</code>, which prints the <em>type</em> of a value.
-</p>
-<pre>
-fmt.Printf(&quot;%T\n&quot;, timeZone)
-</pre>
-<p>
-prints
-</p>
-<pre>
-map[string]int
-</pre>
-<p>
-If you want to control the default format for a custom type, all that's required is to define
-a method with the signature <code>String() string</code> on the type.
-For our simple type <code>T</code>, that might look like this.
-</p>
-<pre>
-func (t *T) String() string {
-    return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c)
-}
-fmt.Printf("%v\n", t)
-</pre>
-<p>
-to print in the format
-</p>
-<pre>
-7/-2.35/"abc\tdef"
-</pre>
-<p>
-(If you need to print <em>values</em> of type <code>T</code> as well as pointers to <code>T</code>,
-the receiver for <code>String</code> must be of value type; this example used a pointer because
-that's more efficient and idiomatic for struct types.
-See the section below on <a href="#pointers_vs_values">pointers vs. value receivers</a> for more information.)
-</p>
-
-<p>
-Our <code>String</code> method is able to call <code>Sprintf</code> because the
-print routines are fully reentrant and can be wrapped this way.
-There is one important detail to understand about this approach,
-however: don't construct a <code>String</code> method by calling
-<code>Sprintf</code> in a way that will recur into your <code>String</code>
-method indefinitely.  This can happen if the <code>Sprintf</code>
-call attempts to print the receiver directly as a string, which in
-turn will invoke the method again.  It's a common and easy mistake
-to make, as this example shows.
-</p>
-
-<pre>
-type MyString string
-
-func (m MyString) String() string {
-    return fmt.Sprintf("MyString=%s", m) // Error: will recur forever.
-}
-</pre>
-
-<p>
-It's also easy to fix: convert the argument to the basic string type, which does not have the
-method.
-</p>
-
-<pre>
-type MyString string
-func (m MyString) String() string {
-    return fmt.Sprintf("MyString=%s", string(m)) // OK: note conversion.
-}
-</pre>
-
-<p>
-In the <a href="#initialization">initialization section</a> we'll see another technique that avoids this recursion.
-</p>
-
-<p>
-Another printing technique is to pass a print routine's arguments directly to another such routine.
-The signature of <code>Printf</code> uses the type <code>...interface{}</code>
-for its final argument to specify that an arbitrary number of parameters (of arbitrary type)
-can appear after the format.
-</p>
-<pre>
-func Printf(format string, v ...interface{}) (n int, err error) {
-</pre>
-<p>
-Within the function <code>Printf</code>, <code>v</code> acts like a variable of type
-<code>[]interface{}</code> but if it is passed to another variadic function, it acts like
-a regular list of arguments.
-Here is the implementation of the
-function <code>log.Println</code> we used above. It passes its arguments directly to
-<code>fmt.Sprintln</code> for the actual formatting.
-</p>
-<pre>
-// Println prints to the standard logger in the manner of fmt.Println.
-func Println(v ...interface{}) {
-    std.Output(2, fmt.Sprintln(v...))  // Output takes parameters (int, string)
-}
-</pre>
-<p>
-We write <code>...</code> after <code>v</code> in the nested call to <code>Sprintln</code> to tell the
-compiler to treat <code>v</code> as a list of arguments; otherwise it would just pass
-<code>v</code> as a single slice argument.
-</p>
-<p>
-There's even more to printing than we've covered here.  See the <code>godoc</code> documentation
-for package <code>fmt</code> for the details.
-</p>
-<p>
-By the way, a <code>...</code> parameter can be of a specific type, for instance <code>...int</code>
-for a min function that chooses the least of a list of integers:
-</p>
-<pre>
-func Min(a ...int) int {
-    min := int(^uint(0) &gt;&gt; 1)  // largest int
-    for _, i := range a {
-        if i &lt; min {
-            min = i
-        }
-    }
-    return min
-}
-</pre>
-
-<h3 id="append">Append</h3>
-<p>
-Now we have the missing piece we needed to explain the design of
-the <code>append</code> built-in function.  The signature of <code>append</code>
-is different from our custom <code>Append</code> function above.
-Schematically, it's like this:
-</p>
-<pre>
-func append(slice []<i>T</i>, elements ...<i>T</i>) []<i>T</i>
-</pre>
-<p>
-where <i>T</i> is a placeholder for any given type.  You can't
-actually write a function in Go where the type <code>T</code>
-is determined by the caller.
-That's why <code>append</code> is built in: it needs support from the
-compiler.
-</p>
-<p>
-What <code>append</code> does is append the elements to the end of
-the slice and return the result.  The result needs to be returned
-because, as with our hand-written <code>Append</code>, the underlying
-array may change.  This simple example
-</p>
-<pre>
-x := []int{1,2,3}
-x = append(x, 4, 5, 6)
-fmt.Println(x)
-</pre>
-<p>
-prints <code>[1 2 3 4 5 6]</code>.  So <code>append</code> works a
-little like <code>Printf</code>, collecting an arbitrary number of
-arguments.
-</p>
-<p>
-But what if we wanted to do what our <code>Append</code> does and
-append a slice to a slice?  Easy: use <code>...</code> at the call
-site, just as we did in the call to <code>Output</code> above.  This
-snippet produces identical output to the one above.
-</p>
-<pre>
-x := []int{1,2,3}
-y := []int{4,5,6}
-x = append(x, y...)
-fmt.Println(x)
-</pre>
-<p>
-Without that <code>...</code>, it wouldn't compile because the types
-would be wrong; <code>y</code> is not of type <code>int</code>.
-</p>
-
-<h2 id="initialization">Initialization</h2>
-
-<p>
-Although it doesn't look superficially very different from
-initialization in C or C++, initialization in Go is more powerful.
-Complex structures can be built during initialization and the ordering
-issues among initialized objects, even among different packages, are handled
-correctly.
-</p>
-
-<h3 id="constants">Constants</h3>
-
-<p>
-Constants in Go are just that&mdash;constant.
-They are created at compile time, even when defined as
-locals in functions,
-and can only be numbers, characters (runes), strings or booleans.
-Because of the compile-time restriction, the expressions
-that define them must be constant expressions,
-evaluatable by the compiler.  For instance,
-<code>1&lt;&lt;3</code> is a constant expression, while
-<code>math.Sin(math.Pi/4)</code> is not because
-the function call to <code>math.Sin</code> needs
-to happen at run time.
-</p>
-
-<p>
-In Go, enumerated constants are created using the <code>iota</code>
-enumerator.  Since <code>iota</code> can be part of an expression and
-expressions can be implicitly repeated, it is easy to build intricate
-sets of values.
-</p>
-{{code "/doc/progs/eff_bytesize.go" `/^type ByteSize/` `/^\)/`}}
-<p>
-The ability to attach a method such as <code>String</code> to any
-user-defined type makes it possible for arbitrary values to format themselves
-automatically for printing.
-Although you'll see it most often applied to structs, this technique is also useful for
-scalar types such as floating-point types like <code>ByteSize</code>.
-</p>
-{{code "/doc/progs/eff_bytesize.go" `/^func.*ByteSize.*String/` `/^}/`}}
-<p>
-The expression <code>YB</code> prints as <code>1.00YB</code>,
-while <code>ByteSize(1e13)</code> prints as <code>9.09TB</code>.
-</p>
-
-<p>
-The use here of <code>Sprintf</code>
-to implement <code>ByteSize</code>'s <code>String</code> method is safe
-(avoids recurring indefinitely) not because of a conversion but
-because it calls <code>Sprintf</code> with <code>%f</code>,
-which is not a string format: <code>Sprintf</code> will only call
-the <code>String</code> method when it wants a string, and <code>%f</code>
-wants a floating-point value.
-</p>
-
-<h3 id="variables">Variables</h3>
-
-<p>
-Variables can be initialized just like constants but the
-initializer can be a general expression computed at run time.
-</p>
-<pre>
-var (
-    home   = os.Getenv("HOME")
-    user   = os.Getenv("USER")
-    gopath = os.Getenv("GOPATH")
-)
-</pre>
-
-<h3 id="init">The init function</h3>
-
-<p>
-Finally, each source file can define its own niladic <code>init</code> function to
-set up whatever state is required.  (Actually each file can have multiple
-<code>init</code> functions.)
-And finally means finally: <code>init</code> is called after all the
-variable declarations in the package have evaluated their initializers,
-and those are evaluated only after all the imported packages have been
-initialized.
-</p>
-<p>
-Besides initializations that cannot be expressed as declarations,
-a common use of <code>init</code> functions is to verify or repair
-correctness of the program state before real execution begins.
-</p>
-
-<pre>
-func init() {
-    if user == "" {
-        log.Fatal("$USER not set")
-    }
-    if home == "" {
-        home = "/home/" + user
-    }
-    if gopath == "" {
-        gopath = home + "/go"
-    }
-    // gopath may be overridden by --gopath flag on command line.
-    flag.StringVar(&amp;gopath, "gopath", gopath, "override default GOPATH")
-}
-</pre>
-
-<h2 id="methods">Methods</h2>
-
-<h3 id="pointers_vs_values">Pointers vs. Values</h3>
-<p>
-As we saw with <code>ByteSize</code>,
-methods can be defined for any named type (except a pointer or an interface);
-the receiver does not have to be a struct.
-</p>
-<p>
-In the discussion of slices above, we wrote an <code>Append</code>
-function.  We can define it as a method on slices instead.  To do
-this, we first declare a named type to which we can bind the method, and
-then make the receiver for the method a value of that type.
-</p>
-<pre>
-type ByteSlice []byte
-
-func (slice ByteSlice) Append(data []byte) []byte {
-    // Body exactly the same as the Append function defined above.
-}
-</pre>
-<p>
-This still requires the method to return the updated slice.  We can
-eliminate that clumsiness by redefining the method to take a
-<i>pointer</i> to a <code>ByteSlice</code> as its receiver, so the
-method can overwrite the caller's slice.
-</p>
-<pre>
-func (p *ByteSlice) Append(data []byte) {
-    slice := *p
-    // Body as above, without the return.
-    *p = slice
-}
-</pre>
-<p>
-In fact, we can do even better.  If we modify our function so it looks
-like a standard <code>Write</code> method, like this,
-</p>
-<pre>
-func (p *ByteSlice) Write(data []byte) (n int, err error) {
-    slice := *p
-    // Again as above.
-    *p = slice
-    return len(data), nil
-}
-</pre>
-<p>
-then the type <code>*ByteSlice</code> satisfies the standard interface
-<code>io.Writer</code>, which is handy.  For instance, we can
-print into one.
-</p>
-<pre>
-    var b ByteSlice
-    fmt.Fprintf(&amp;b, "This hour has %d days\n", 7)
-</pre>
-<p>
-We pass the address of a <code>ByteSlice</code>
-because only <code>*ByteSlice</code> satisfies <code>io.Writer</code>.
-The rule about pointers vs. values for receivers is that value methods
-can be invoked on pointers and values, but pointer methods can only be
-invoked on pointers.
-</p>
-
-<p>
-This rule arises because pointer methods can modify the receiver; invoking
-them on a value would cause the method to receive a copy of the value, so
-any modifications would be discarded.
-The language therefore disallows this mistake.
-There is a handy exception, though. When the value is addressable, the
-language takes care of the common case of invoking a pointer method on a
-value by inserting the address operator automatically.
-In our example, the variable <code>b</code> is addressable, so we can call
-its <code>Write</code> method with just <code>b.Write</code>. The compiler
-will rewrite that to <code>(&amp;b).Write</code> for us.
-</p>
-
-<p>
-By the way, the idea of using <code>Write</code> on a slice of bytes
-is central to the implementation of <code>bytes.Buffer</code>.
-</p>
-
-<h2 id="interfaces_and_types">Interfaces and other types</h2>
-
-<h3 id="interfaces">Interfaces</h3>
-<p>
-Interfaces in Go provide a way to specify the behavior of an
-object: if something can do <em>this</em>, then it can be used
-<em>here</em>.  We've seen a couple of simple examples already;
-custom printers can be implemented by a <code>String</code> method
-while <code>Fprintf</code> can generate output to anything
-with a <code>Write</code> method.
-Interfaces with only one or two methods are common in Go code, and are
-usually given a name derived from the method, such as <code>io.Writer</code>
-for something that implements <code>Write</code>.
-</p>
-<p>
-A type can implement multiple interfaces.
-For instance, a collection can be sorted
-by the routines in package <code>sort</code> if it implements
-<code>sort.Interface</code>, which contains <code>Len()</code>,
-<code>Less(i, j int) bool</code>, and <code>Swap(i, j int)</code>,
-and it could also have a custom formatter.
-In this contrived example <code>Sequence</code> satisfies both.
-</p>
-{{code "/doc/progs/eff_sequence.go" `/^type/` "$"}}
-
-<h3 id="conversions">Conversions</h3>
-
-<p>
-The <code>String</code> method of <code>Sequence</code> is recreating the
-work that <code>Sprint</code> already does for slices.
-(It also has complexity O(N²), which is poor.) We can share the
-effort (and also speed it up) if we convert the <code>Sequence</code> to a plain
-<code>[]int</code> before calling <code>Sprint</code>.
-</p>
-<pre>
-func (s Sequence) String() string {
-    s = s.Copy()
-    sort.Sort(s)
-    return fmt.Sprint([]int(s))
-}
-</pre>
-<p>
-This method is another example of the conversion technique for calling
-<code>Sprintf</code> safely from a <code>String</code> method.
-Because the two types (<code>Sequence</code> and <code>[]int</code>)
-are the same if we ignore the type name, it's legal to convert between them.
-The conversion doesn't create a new value, it just temporarily acts
-as though the existing value has a new type.
-(There are other legal conversions, such as from integer to floating point, that
-do create a new value.)
-</p>
-<p>
-It's an idiom in Go programs to convert the
-type of an expression to access a different
-set of methods. As an example, we could use the existing
-type <code>sort.IntSlice</code> to reduce the entire example
-to this:
-</p>
-<pre>
-type Sequence []int
-
-// Method for printing - sorts the elements before printing
-func (s Sequence) String() string {
-    s = s.Copy()
-    sort.IntSlice(s).Sort()
-    return fmt.Sprint([]int(s))
-}
-</pre>
-<p>
-Now, instead of having <code>Sequence</code> implement multiple
-interfaces (sorting and printing), we're using the ability of a data item to be
-converted to multiple types (<code>Sequence</code>, <code>sort.IntSlice</code>
-and <code>[]int</code>), each of which does some part of the job.
-That's more unusual in practice but can be effective.
-</p>
-
-<h3 id="interface_conversions">Interface conversions and type assertions</h3>
-
-<p>
-<a href="#type_switch">Type switches</a> are a form of conversion: they take an interface and, for
-each case in the switch, in a sense convert it to the type of that case.
-Here's a simplified version of how the code under <code>fmt.Printf</code> turns a value into
-a string using a type switch.
-If it's already a string, we want the actual string value held by the interface, while if it has a
-<code>String</code> method we want the result of calling the method.
-</p>
-
-<pre>
-type Stringer interface {
-    String() string
-}
-
-var value interface{} // Value provided by caller.
-switch str := value.(type) {
-case string:
-    return str
-case Stringer:
-    return str.String()
-}
-</pre>
-
-<p>
-The first case finds a concrete value; the second converts the interface into another interface.
-It's perfectly fine to mix types this way.
-</p>
-
-<p>
-What if there's only one type we care about? If we know the value holds a <code>string</code>
-and we just want to extract it?
-A one-case type switch would do, but so would a <em>type assertion</em>.
-A type assertion takes an interface value and extracts from it a value of the specified explicit type.
-The syntax borrows from the clause opening a type switch, but with an explicit
-type rather than the <code>type</code> keyword:
-</p>
-
-<pre>
-value.(typeName)
-</pre>
-
-<p>
-and the result is a new value with the static type <code>typeName</code>.
-That type must either be the concrete type held by the interface, or a second interface
-type that the value can be converted to.
-To extract the string we know is in the value, we could write:
-</p>
-
-<pre>
-str := value.(string)
-</pre>
-
-<p>
-But if it turns out that the value does not contain a string, the program will crash with a run-time error.
-To guard against that, use the "comma, ok" idiom to test, safely, whether the value is a string:
-</p>
-
-<pre>
-str, ok := value.(string)
-if ok {
-    fmt.Printf("string value is: %q\n", str)
-} else {
-    fmt.Printf("value is not a string\n")
-}
-</pre>
-
-<p>
-If the type assertion fails, <code>str</code> will still exist and be of type string, but it will have
-the zero value, an empty string.
-</p>
-
-<p>
-As an illustration of the capability, here's an <code>if</code>-<code>else</code>
-statement that's equivalent to the type switch that opened this section.
-</p>
-
-<pre>
-if str, ok := value.(string); ok {
-    return str
-} else if str, ok := value.(Stringer); ok {
-    return str.String()
-}
-</pre>
-
-<h3 id="generality">Generality</h3>
-<p>
-If a type exists only to implement an interface and will
-never have exported methods beyond that interface, there is
-no need to export the type itself.
-Exporting just the interface makes it clear the value has no
-interesting behavior beyond what is described in the
-interface.
-It also avoids the need to repeat the documentation
-on every instance of a common method.
-</p>
-<p>
-In such cases, the constructor should return an interface value
-rather than the implementing type.
-As an example, in the hash libraries
-both <code>crc32.NewIEEE</code> and <code>adler32.New</code>
-return the interface type <code>hash.Hash32</code>.
-Substituting the CRC-32 algorithm for Adler-32 in a Go program
-requires only changing the constructor call;
-the rest of the code is unaffected by the change of algorithm.
-</p>
-<p>
-A similar approach allows the streaming cipher algorithms
-in the various <code>crypto</code> packages to be
-separated from the block ciphers they chain together.
-The <code>Block</code> interface
-in the <code>crypto/cipher</code> package specifies the
-behavior of a block cipher, which provides encryption
-of a single block of data.
-Then, by analogy with the <code>bufio</code> package,
-cipher packages that implement this interface
-can be used to construct streaming ciphers, represented
-by the <code>Stream</code> interface, without
-knowing the details of the block encryption.
-</p>
-<p>
-The  <code>crypto/cipher</code> interfaces look like this:
-</p>
-<pre>
-type Block interface {
-    BlockSize() int
-    Encrypt(dst, src []byte)
-    Decrypt(dst, src []byte)
-}
-
-type Stream interface {
-    XORKeyStream(dst, src []byte)
-}
-</pre>
-
-<p>
-Here's the definition of the counter mode (CTR) stream,
-which turns a block cipher into a streaming cipher; notice
-that the block cipher's details are abstracted away:
-</p>
-
-<pre>
-// NewCTR returns a Stream that encrypts/decrypts using the given Block in
-// counter mode. The length of iv must be the same as the Block's block size.
-func NewCTR(block Block, iv []byte) Stream
-</pre>
-<p>
-<code>NewCTR</code> applies not
-just to one specific encryption algorithm and data source but to any
-implementation of the <code>Block</code> interface and any
-<code>Stream</code>.  Because they return
-interface values, replacing CTR
-encryption with other encryption modes is a localized change.  The constructor
-calls must be edited, but because the surrounding code must treat the result only
-as a <code>Stream</code>, it won't notice the difference.
-</p>
-
-<h3 id="interface_methods">Interfaces and methods</h3>
-<p>
-Since almost anything can have methods attached, almost anything can
-satisfy an interface.  One illustrative example is in the <code>http</code>
-package, which defines the <code>Handler</code> interface.  Any object
-that implements <code>Handler</code> can serve HTTP requests.
-</p>
-<pre>
-type Handler interface {
-    ServeHTTP(ResponseWriter, *Request)
-}
-</pre>
-<p>
-<code>ResponseWriter</code> is itself an interface that provides access
-to the methods needed to return the response to the client.
-Those methods include the standard <code>Write</code> method, so an
-<code>http.ResponseWriter</code> can be used wherever an <code>io.Writer</code>
-can be used.
-<code>Request</code> is a struct containing a parsed representation
-of the request from the client.
-</p>
-<p>
-For brevity, let's ignore POSTs and assume HTTP requests are always
-GETs; that simplification does not affect the way the handlers are set up.
-Here's a trivial implementation of a handler to count the number of times
-the page is visited.
-</p>
-<pre>
-// Simple counter server.
-type Counter struct {
-    n int
-}
-
-func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-    ctr.n++
-    fmt.Fprintf(w, "counter = %d\n", ctr.n)
-}
-</pre>
-<p>
-(Keeping with our theme, note how <code>Fprintf</code> can print to an
-<code>http.ResponseWriter</code>.)
-In a real server, access to <code>ctr.n</code> would need protection from
-concurrent access.
-See the <code>sync</code> and <code>atomic</code> packages for suggestions.
-</p>
-<p>
-For reference, here's how to attach such a server to a node on the URL tree.
-</p>
-<pre>
-import "net/http"
-...
-ctr := new(Counter)
-http.Handle("/counter", ctr)
-</pre>
-<p>
-But why make <code>Counter</code> a struct?  An integer is all that's needed.
-(The receiver needs to be a pointer so the increment is visible to the caller.)
-</p>
-<pre>
-// Simpler counter server.
-type Counter int
-
-func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-    *ctr++
-    fmt.Fprintf(w, "counter = %d\n", *ctr)
-}
-</pre>
-<p>
-What if your program has some internal state that needs to be notified that a page
-has been visited?  Tie a channel to the web page.
-</p>
-<pre>
-// A channel that sends a notification on each visit.
-// (Probably want the channel to be buffered.)
-type Chan chan *http.Request
-
-func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-    ch &lt;- req
-    fmt.Fprint(w, "notification sent")
-}
-</pre>
-<p>
-Finally, let's say we wanted to present on <code>/args</code> the arguments
-used when invoking the server binary.
-It's easy to write a function to print the arguments.
-</p>
-<pre>
-func ArgServer() {
-    fmt.Println(os.Args)
-}
-</pre>
-<p>
-How do we turn that into an HTTP server?  We could make <code>ArgServer</code>
-a method of some type whose value we ignore, but there's a cleaner way.
-Since we can define a method for any type except pointers and interfaces,
-we can write a method for a function.
-The <code>http</code> package contains this code:
-</p>
-<pre>
-// The HandlerFunc type is an adapter to allow the use of
-// ordinary functions as HTTP handlers.  If f is a function
-// with the appropriate signature, HandlerFunc(f) is a
-// Handler object that calls f.
-type HandlerFunc func(ResponseWriter, *Request)
-
-// ServeHTTP calls f(w, req).
-func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
-    f(w, req)
-}
-</pre>
-<p>
-<code>HandlerFunc</code> is a type with a method, <code>ServeHTTP</code>,
-so values of that type can serve HTTP requests.  Look at the implementation
-of the method: the receiver is a function, <code>f</code>, and the method
-calls <code>f</code>.  That may seem odd but it's not that different from, say,
-the receiver being a channel and the method sending on the channel.
-</p>
-<p>
-To make <code>ArgServer</code> into an HTTP server, we first modify it
-to have the right signature.
-</p>
-<pre>
-// Argument server.
-func ArgServer(w http.ResponseWriter, req *http.Request) {
-    fmt.Fprintln(w, os.Args)
-}
-</pre>
-<p>
-<code>ArgServer</code> now has same signature as <code>HandlerFunc</code>,
-so it can be converted to that type to access its methods,
-just as we converted <code>Sequence</code> to <code>IntSlice</code>
-to access <code>IntSlice.Sort</code>.
-The code to set it up is concise:
-</p>
-<pre>
-http.Handle("/args", http.HandlerFunc(ArgServer))
-</pre>
-<p>
-When someone visits the page <code>/args</code>,
-the handler installed at that page has value <code>ArgServer</code>
-and type <code>HandlerFunc</code>.
-The HTTP server will invoke the method <code>ServeHTTP</code>
-of that type, with <code>ArgServer</code> as the receiver, which will in turn call
-<code>ArgServer</code> (via the invocation <code>f(w, req)</code>
-inside <code>HandlerFunc.ServeHTTP</code>).
-The arguments will then be displayed.
-</p>
-<p>
-In this section we have made an HTTP server from a struct, an integer,
-a channel, and a function, all because interfaces are just sets of
-methods, which can be defined for (almost) any type.
-</p>
-
-<h2 id="blank">The blank identifier</h2>
-
-<p>
-We've mentioned the blank identifier a couple of times now, in the context of
-<a href="#for"><code>for</code> <code>range</code> loops</a>
-and <a href="#maps">maps</a>.
-The blank identifier can be assigned or declared with any value of any type, with the
-value discarded harmlessly.
-It's a bit like writing to the Unix <code>/dev/null</code> file:
-it represents a write-only value
-to be used as a place-holder
-where a variable is needed but the actual value is irrelevant.
-It has uses beyond those we've seen already.
-</p>
-
-<h3 id="blank_assign">The blank identifier in multiple assignment</h3>
-
-<p>
-The use of a blank identifier in a <code>for</code> <code>range</code> loop is a
-special case of a general situation: multiple assignment.
-</p>
-
-<p>
-If an assignment requires multiple values on the left side,
-but one of the values will not be used by the program,
-a blank identifier on the left-hand-side of
-the assignment avoids the need
-to create a dummy variable and makes it clear that the
-value is to be discarded.
-For instance, when calling a function that returns
-a value and an error, but only the error is important,
-use the blank identifier to discard the irrelevant value.
-</p>
-
-<pre>
-if _, err := os.Stat(path); os.IsNotExist(err) {
-       fmt.Printf("%s does not exist\n", path)
-}
-</pre>
-
-<p>
-Occasionally you'll see code that discards the error value in order
-to ignore the error; this is terrible practice. Always check error returns;
-they're provided for a reason.
-</p>
-
-<pre>
-// Bad! This code will crash if path does not exist.
-fi, _ := os.Stat(path)
-if fi.IsDir() {
-    fmt.Printf("%s is a directory\n", path)
-}
-</pre>
-
-<h3 id="blank_unused">Unused imports and variables</h3>
-
-<p>
-It is an error to import a package or to declare a variable without using it.
-Unused imports bloat the program and slow compilation,
-while a variable that is initialized but not used is at least
-a wasted computation and perhaps indicative of a
-larger bug.
-When a program is under active development, however,
-unused imports and variables often arise and it can
-be annoying to delete them just to have the compilation proceed,
-only to have them be needed again later.
-The blank identifier provides a workaround.
-</p>
-<p>
-This half-written program has two unused imports
-(<code>fmt</code> and <code>io</code>)
-and an unused variable (<code>fd</code>),
-so it will not compile, but it would be nice to see if the
-code so far is correct.
-</p>
-{{code "/doc/progs/eff_unused1.go" `/package/` `$`}}
-<p>
-To silence complaints about the unused imports, use a
-blank identifier to refer to a symbol from the imported package.
-Similarly, assigning the unused variable <code>fd</code>
-to the blank identifier will silence the unused variable error.
-This version of the program does compile.
-</p>
-{{code "/doc/progs/eff_unused2.go" `/package/` `$`}}
-
-<p>
-By convention, the global declarations to silence import errors
-should come right after the imports and be commented,
-both to make them easy to find and as a reminder to clean things up later.
-</p>
-
-<h3 id="blank_import">Import for side effect</h3>
-
-<p>
-An unused import like <code>fmt</code> or <code>io</code> in the
-previous example should eventually be used or removed:
-blank assignments identify code as a work in progress.
-But sometimes it is useful to import a package only for its
-side effects, without any explicit use.
-For example, during its <code>init</code> function,
-the <code><a href="/pkg/net/http/pprof/">net/http/pprof</a></code>
-package registers HTTP handlers that provide
-debugging information. It has an exported API, but
-most clients need only the handler registration and
-access the data through a web page.
-To import the package only for its side effects, rename the package
-to the blank identifier:
-</p>
-<pre>
-import _ "net/http/pprof"
-</pre>
-<p>
-This form of import makes clear that the package is being
-imported for its side effects, because there is no other possible
-use of the package: in this file, it doesn't have a name.
-(If it did, and we didn't use that name, the compiler would reject the program.)
-</p>
-
-<h3 id="blank_implements">Interface checks</h3>
-
-<p>
-As we saw in the discussion of <a href="#interfaces_and_types">interfaces</a> above,
-a type need not declare explicitly that it implements an interface.
-Instead, a type implements the interface just by implementing the interface's methods.
-In practice, most interface conversions are static and therefore checked at compile time.
-For example, passing an <code>*os.File</code> to a function
-expecting an <code>io.Reader</code> will not compile unless
-<code>*os.File</code> implements the <code>io.Reader</code> interface.
-</p>
-
-<p>
-Some interface checks do happen at run-time, though.
-One instance is in the <code><a href="/pkg/encoding/json/">encoding/json</a></code>
-package, which defines a <code><a href="/pkg/encoding/json/#Marshaler">Marshaler</a></code>
-interface. When the JSON encoder receives a value that implements that interface,
-the encoder invokes the value's marshaling method to convert it to JSON
-instead of doing the standard conversion.
-The encoder checks this property at run time with a <a href="#interface_conversions">type assertion</a> like:
-</p>
-
-<pre>
-m, ok := val.(json.Marshaler)
-</pre>
-
-<p>
-If it's necessary only to ask whether a type implements an interface, without
-actually using the interface itself, perhaps as part of an error check, use the blank
-identifier to ignore the type-asserted value:
-</p>
-
-<pre>
-if _, ok := val.(json.Marshaler); ok {
-    fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
-}
-</pre>
-
-<p>
-One place this situation arises is when it is necessary to guarantee within the package implementing the type that
-it actually satisfies the interface.
-If a type—for example,
-<code><a href="/pkg/encoding/json/#RawMessage">json.RawMessage</a></code>—needs
-a custom JSON representation, it should implement
-<code>json.Marshaler</code>, but there are no static conversions that would
-cause the compiler to verify this automatically.
-If the type inadvertently fails to satisfy the interface, the JSON encoder will still work,
-but will not use the custom implementation.
-To guarantee that the implementation is correct,
-a global declaration using the blank identifier can be used in the package:
-</p>
-<pre>
-var _ json.Marshaler = (*RawMessage)(nil)
-</pre>
-<p>
-In this declaration, the assignment involving a conversion of a
-<code>*RawMessage</code> to a <code>Marshaler</code>
-requires that <code>*RawMessage</code> implements <code>Marshaler</code>,
-and that property will be checked at compile time.
-Should the <code>json.Marshaler</code> interface change, this package
-will no longer compile and we will be on notice that it needs to be updated.
-</p>
-
-<p>
-The appearance of the blank identifier in this construct indicates that
-the declaration exists only for the type checking,
-not to create a variable.
-Don't do this for every type that satisfies an interface, though.
-By convention, such declarations are only used
-when there are no static conversions already present in the code,
-which is a rare event.
-</p>
-
-
-<h2 id="embedding">Embedding</h2>
-
-<p>
-Go does not provide the typical, type-driven notion of subclassing,
-but it does have the ability to &ldquo;borrow&rdquo; pieces of an
-implementation by <em>embedding</em> types within a struct or
-interface.
-</p>
-<p>
-Interface embedding is very simple.
-We've mentioned the <code>io.Reader</code> and <code>io.Writer</code> interfaces before;
-here are their definitions.
-</p>
-<pre>
-type Reader interface {
-    Read(p []byte) (n int, err error)
-}
-
-type Writer interface {
-    Write(p []byte) (n int, err error)
-}
-</pre>
-<p>
-The <code>io</code> package also exports several other interfaces
-that specify objects that can implement several such methods.
-For instance, there is <code>io.ReadWriter</code>, an interface
-containing both <code>Read</code> and <code>Write</code>.
-We could specify <code>io.ReadWriter</code> by listing the
-two methods explicitly, but it's easier and more evocative
-to embed the two interfaces to form the new one, like this:
-</p>
-<pre>
-// ReadWriter is the interface that combines the Reader and Writer interfaces.
-type ReadWriter interface {
-    Reader
-    Writer
-}
-</pre>
-<p>
-This says just what it looks like: A <code>ReadWriter</code> can do
-what a <code>Reader</code> does <em>and</em> what a <code>Writer</code>
-does; it is a union of the embedded interfaces.
-Only interfaces can be embedded within interfaces.
-</p>
-<p>
-The same basic idea applies to structs, but with more far-reaching
-implications.  The <code>bufio</code> package has two struct types,
-<code>bufio.Reader</code> and <code>bufio.Writer</code>, each of
-which of course implements the analogous interfaces from package
-<code>io</code>.
-And <code>bufio</code> also implements a buffered reader/writer,
-which it does by combining a reader and a writer into one struct
-using embedding: it lists the types within the struct
-but does not give them field names.
-</p>
-<pre>
-// ReadWriter stores pointers to a Reader and a Writer.
-// It implements io.ReadWriter.
-type ReadWriter struct {
-    *Reader  // *bufio.Reader
-    *Writer  // *bufio.Writer
-}
-</pre>
-<p>
-The embedded elements are pointers to structs and of course
-must be initialized to point to valid structs before they
-can be used.
-The <code>ReadWriter</code> struct could be written as
-</p>
-<pre>
-type ReadWriter struct {
-    reader *Reader
-    writer *Writer
-}
-</pre>
-<p>
-but then to promote the methods of the fields and to
-satisfy the <code>io</code> interfaces, we would also need
-to provide forwarding methods, like this:
-</p>
-<pre>
-func (rw *ReadWriter) Read(p []byte) (n int, err error) {
-    return rw.reader.Read(p)
-}
-</pre>
-<p>
-By embedding the structs directly, we avoid this bookkeeping.
-The methods of embedded types come along for free, which means that <code>bufio.ReadWriter</code>
-not only has the methods of <code>bufio.Reader</code> and <code>bufio.Writer</code>,
-it also satisfies all three interfaces:
-<code>io.Reader</code>,
-<code>io.Writer</code>, and
-<code>io.ReadWriter</code>.
-</p>
-<p>
-There's an important way in which embedding differs from subclassing.  When we embed a type,
-the methods of that type become methods of the outer type,
-but when they are invoked the receiver of the method is the inner type, not the outer one.
-In our example, when the <code>Read</code> method of a <code>bufio.ReadWriter</code> is
-invoked, it has exactly the same effect as the forwarding method written out above;
-the receiver is the <code>reader</code> field of the <code>ReadWriter</code>, not the
-<code>ReadWriter</code> itself.
-</p>
-<p>
-Embedding can also be a simple convenience.
-This example shows an embedded field alongside a regular, named field.
-</p>
-<pre>
-type Job struct {
-    Command string
-    *log.Logger
-}
-</pre>
-<p>
-The <code>Job</code> type now has the <code>Print</code>, <code>Printf</code>, <code>Println</code>
-and other
-methods of <code>*log.Logger</code>.  We could have given the <code>Logger</code>
-a field name, of course, but it's not necessary to do so.  And now, once
-initialized, we can
-log to the <code>Job</code>:
-</p>
-<pre>
-job.Println("starting now...")
-</pre>
-<p>
-The <code>Logger</code> is a regular field of the <code>Job</code> struct,
-so we can initialize it in the usual way inside the constructor for <code>Job</code>, like this,
-</p>
-<pre>
-func NewJob(command string, logger *log.Logger) *Job {
-    return &amp;Job{command, logger}
-}
-</pre>
-<p>
-or with a composite literal,
-</p>
-<pre>
-job := &amp;Job{command, log.New(os.Stderr, "Job: ", log.Ldate)}
-</pre>
-<p>
-If we need to refer to an embedded field directly, the type name of the field,
-ignoring the package qualifier, serves as a field name, as it did
-in the <code>Read</code> method of our <code>ReadWriter</code> struct.
-Here, if we needed to access the
-<code>*log.Logger</code> of a <code>Job</code> variable <code>job</code>,
-we would write <code>job.Logger</code>,
-which would be useful if we wanted to refine the methods of <code>Logger</code>.
-</p>
-<pre>
-func (job *Job) Printf(format string, args ...interface{}) {
-    job.Logger.Printf("%q: %s", job.Command, fmt.Sprintf(format, args...))
-}
-</pre>
-<p>
-Embedding types introduces the problem of name conflicts but the rules to resolve
-them are simple.
-First, a field or method <code>X</code> hides any other item <code>X</code> in a more deeply
-nested part of the type.
-If <code>log.Logger</code> contained a field or method called <code>Command</code>, the <code>Command</code> field
-of <code>Job</code> would dominate it.
-</p>
-<p>
-Second, if the same name appears at the same nesting level, it is usually an error;
-it would be erroneous to embed <code>log.Logger</code> if the <code>Job</code> struct
-contained another field or method called <code>Logger</code>.
-However, if the duplicate name is never mentioned in the program outside the type definition, it is OK.
-This qualification provides some protection against changes made to types embedded from outside; there
-is no problem if a field is added that conflicts with another field in another subtype if neither field
-is ever used.
-</p>
-
-
-<h2 id="concurrency">Concurrency</h2>
-
-<h3 id="sharing">Share by communicating</h3>
-
-<p>
-Concurrent programming is a large topic and there is space only for some
-Go-specific highlights here.
-</p>
-<p>
-Concurrent programming in many environments is made difficult by the
-subtleties required to implement correct access to shared variables.  Go encourages
-a different approach in which shared values are passed around on channels
-and, in fact, never actively shared by separate threads of execution.
-Only one goroutine has access to the value at any given time.
-Data races cannot occur, by design.
-To encourage this way of thinking we have reduced it to a slogan:
-</p>
-<blockquote>
-Do not communicate by sharing memory;
-instead, share memory by communicating.
-</blockquote>
-<p>
-This approach can be taken too far.  Reference counts may be best done
-by putting a mutex around an integer variable, for instance.  But as a
-high-level approach, using channels to control access makes it easier
-to write clear, correct programs.
-</p>
-<p>
-One way to think about this model is to consider a typical single-threaded
-program running on one CPU. It has no need for synchronization primitives.
-Now run another such instance; it too needs no synchronization.  Now let those
-two communicate; if the communication is the synchronizer, there's still no need
-for other synchronization.  Unix pipelines, for example, fit this model
-perfectly.  Although Go's approach to concurrency originates in Hoare's
-Communicating Sequential Processes (CSP),
-it can also be seen as a type-safe generalization of Unix pipes.
-</p>
-
-<h3 id="goroutines">Goroutines</h3>
-
-<p>
-They're called <em>goroutines</em> because the existing
-terms&mdash;threads, coroutines, processes, and so on&mdash;convey
-inaccurate connotations.  A goroutine has a simple model: it is a
-function executing concurrently with other goroutines in the same
-address space.  It is lightweight, costing little more than the
-allocation of stack space.
-And the stacks start small, so they are cheap, and grow
-by allocating (and freeing) heap storage as required.
-</p>
-<p>
-Goroutines are multiplexed onto multiple OS threads so if one should
-block, such as while waiting for I/O, others continue to run.  Their
-design hides many of the complexities of thread creation and
-management.
-</p>
-<p>
-Prefix a function or method call with the <code>go</code>
-keyword to run the call in a new goroutine.
-When the call completes, the goroutine
-exits, silently.  (The effect is similar to the Unix shell's
-<code>&amp;</code> notation for running a command in the
-background.)
-</p>
-<pre>
-go list.Sort()  // run list.Sort concurrently; don't wait for it.
-</pre>
-<p>
-A function literal can be handy in a goroutine invocation.
-</p>
-<pre>
-func Announce(message string, delay time.Duration) {
-    go func() {
-        time.Sleep(delay)
-        fmt.Println(message)
-    }()  // Note the parentheses - must call the function.
-}
-</pre>
-<p>
-In Go, function literals are closures: the implementation makes
-sure the variables referred to by the function survive as long as they are active.
-</p>
-<p>
-These examples aren't too practical because the functions have no way of signaling
-completion.  For that, we need channels.
-</p>
-
-<h3 id="channels">Channels</h3>
-
-<p>
-Like maps, channels are allocated with <code>make</code>, and
-the resulting value acts as a reference to an underlying data structure.
-If an optional integer parameter is provided, it sets the buffer size for the channel.
-The default is zero, for an unbuffered or synchronous channel.
-</p>
-<pre>
-ci := make(chan int)            // unbuffered channel of integers
-cj := make(chan int, 0)         // unbuffered channel of integers
-cs := make(chan *os.File, 100)  // buffered channel of pointers to Files
-</pre>
-<p>
-Unbuffered channels combine communication&mdash;the exchange of a value&mdash;with
-synchronization&mdash;guaranteeing that two calculations (goroutines) are in
-a known state.
-</p>
-<p>
-There are lots of nice idioms using channels.  Here's one to get us started.
-In the previous section we launched a sort in the background. A channel
-can allow the launching goroutine to wait for the sort to complete.
-</p>
-<pre>
-c := make(chan int)  // Allocate a channel.
-// Start the sort in a goroutine; when it completes, signal on the channel.
-go func() {
-    list.Sort()
-    c &lt;- 1  // Send a signal; value does not matter.
-}()
-doSomethingForAWhile()
-&lt;-c   // Wait for sort to finish; discard sent value.
-</pre>
-<p>
-Receivers always block until there is data to receive.
-If the channel is unbuffered, the sender blocks until the receiver has
-received the value.
-If the channel has a buffer, the sender blocks only until the
-value has been copied to the buffer; if the buffer is full, this
-means waiting until some receiver has retrieved a value.
-</p>
-<p>
-A buffered channel can be used like a semaphore, for instance to
-limit throughput.  In this example, incoming requests are passed
-to <code>handle</code>, which sends a value into the channel, processes
-the request, and then receives a value from the channel
-to ready the &ldquo;semaphore&rdquo; for the next consumer.
-The capacity of the channel buffer limits the number of
-simultaneous calls to <code>process</code>.
-</p>
-<pre>
-var sem = make(chan int, MaxOutstanding)
-
-func handle(r *Request) {
-    sem &lt;- 1    // Wait for active queue to drain.
-    process(r)  // May take a long time.
-    &lt;-sem       // Done; enable next request to run.
-}
-
-func Serve(queue chan *Request) {
-    for {
-        req := &lt;-queue
-        go handle(req)  // Don't wait for handle to finish.
-    }
-}
-</pre>
-
-<p>
-Once <code>MaxOutstanding</code> handlers are executing <code>process</code>,
-any more will block trying to send into the filled channel buffer,
-until one of the existing handlers finishes and receives from the buffer.
-</p>
-
-<p>
-This design has a problem, though: <code>Serve</code>
-creates a new goroutine for
-every incoming request, even though only <code>MaxOutstanding</code>
-of them can run at any moment.
-As a result, the program can consume unlimited resources if the requests come in too fast.
-We can address that deficiency by changing <code>Serve</code> to
-gate the creation of the goroutines.
-Here's an obvious solution, but beware it has a bug we'll fix subsequently:
-</p>
-
-<pre>
-func Serve(queue chan *Request) {
-    for req := range queue {
-        sem &lt;- 1
-        go func() {
-            process(req) // Buggy; see explanation below.
-            &lt;-sem
-        }()
-    }
-}</pre>
-
-<p>
-The bug is that in a Go <code>for</code> loop, the loop variable
-is reused for each iteration, so the <code>req</code>
-variable is shared across all goroutines.
-That's not what we want.
-We need to make sure that <code>req</code> is unique for each goroutine.
-Here's one way to do that, passing the value of <code>req</code> as an argument
-to the closure in the goroutine:
-</p>
-
-<pre>
-func Serve(queue chan *Request) {
-    for req := range queue {
-        sem &lt;- 1
-        go func(req *Request) {
-            process(req)
-            &lt;-sem
-        }(req)
-    }
-}</pre>
-
-<p>
-Compare this version with the previous to see the difference in how
-the closure is declared and run.
-Another solution is just to create a new variable with the same
-name, as in this example:
-</p>
-
-<pre>
-func Serve(queue chan *Request) {
-    for req := range queue {
-        req := req // Create new instance of req for the goroutine.
-        sem &lt;- 1
-        go func() {
-            process(req)
-            &lt;-sem
-        }()
-    }
-}</pre>
-
-<p>
-It may seem odd to write
-</p>
-
-<pre>
-req := req
-</pre>
-
-<p>
-but it's legal and idiomatic in Go to do this.
-You get a fresh version of the variable with the same name, deliberately
-shadowing the loop variable locally but unique to each goroutine.
-</p>
-
-<p>
-Going back to the general problem of writing the server,
-another approach that manages resources well is to start a fixed
-number of <code>handle</code> goroutines all reading from the request
-channel.
-The number of goroutines limits the number of simultaneous
-calls to <code>process</code>.
-This <code>Serve</code> function also accepts a channel on which
-it will be told to exit; after launching the goroutines it blocks
-receiving from that channel.
-</p>
-
-<pre>
-func handle(queue chan *Request) {
-    for r := range queue {
-        process(r)
-    }
-}
-
-func Serve(clientRequests chan *Request, quit chan bool) {
-    // Start handlers
-    for i := 0; i &lt; MaxOutstanding; i++ {
-        go handle(clientRequests)
-    }
-    &lt;-quit  // Wait to be told to exit.
-}
-</pre>
-
-<h3 id="chan_of_chan">Channels of channels</h3>
-<p>
-One of the most important properties of Go is that
-a channel is a first-class value that can be allocated and passed
-around like any other.  A common use of this property is
-to implement safe, parallel demultiplexing.
-</p>
-<p>
-In the example in the previous section, <code>handle</code> was
-an idealized handler for a request but we didn't define the
-type it was handling.  If that type includes a channel on which
-to reply, each client can provide its own path for the answer.
-Here's a schematic definition of type <code>Request</code>.
-</p>
-<pre>
-type Request struct {
-    args        []int
-    f           func([]int) int
-    resultChan  chan int
-}
-</pre>
-<p>
-The client provides a function and its arguments, as well as
-a channel inside the request object on which to receive the answer.
-</p>
-<pre>
-func sum(a []int) (s int) {
-    for _, v := range a {
-        s += v
-    }
-    return
-}
-
-request := &amp;Request{[]int{3, 4, 5}, sum, make(chan int)}
-// Send request
-clientRequests &lt;- request
-// Wait for response.
-fmt.Printf("answer: %d\n", &lt;-request.resultChan)
-</pre>
-<p>
-On the server side, the handler function is the only thing that changes.
-</p>
-<pre>
-func handle(queue chan *Request) {
-    for req := range queue {
-        req.resultChan &lt;- req.f(req.args)
-    }
-}
-</pre>
-<p>
-There's clearly a lot more to do to make it realistic, but this
-code is a framework for a rate-limited, parallel, non-blocking RPC
-system, and there's not a mutex in sight.
-</p>
-
-<h3 id="parallel">Parallelization</h3>
-<p>
-Another application of these ideas is to parallelize a calculation
-across multiple CPU cores.  If the calculation can be broken into
-separate pieces that can execute independently, it can be parallelized,
-with a channel to signal when each piece completes.
-</p>
-<p>
-Let's say we have an expensive operation to perform on a vector of items,
-and that the value of the operation on each item is independent,
-as in this idealized example.
-</p>
-<pre>
-type Vector []float64
-
-// Apply the operation to v[i], v[i+1] ... up to v[n-1].
-func (v Vector) DoSome(i, n int, u Vector, c chan int) {
-    for ; i &lt; n; i++ {
-        v[i] += u.Op(v[i])
-    }
-    c &lt;- 1    // signal that this piece is done
-}
-</pre>
-<p>
-We launch the pieces independently in a loop, one per CPU.
-They can complete in any order but it doesn't matter; we just
-count the completion signals by draining the channel after
-launching all the goroutines.
-</p>
-<pre>
-const numCPU = 4 // number of CPU cores
-
-func (v Vector) DoAll(u Vector) {
-    c := make(chan int, numCPU)  // Buffering optional but sensible.
-    for i := 0; i &lt; numCPU; i++ {
-        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
-    }
-    // Drain the channel.
-    for i := 0; i &lt; numCPU; i++ {
-        &lt;-c    // wait for one task to complete
-    }
-    // All done.
-}
-</pre>
-<p>
-Rather than create a constant value for numCPU, we can ask the runtime what
-value is appropriate.
-The function <code><a href="/pkg/runtime#NumCPU">runtime.NumCPU</a></code>
-returns the number of hardware CPU cores in the machine, so we could write
-</p>
-<pre>
-var numCPU = runtime.NumCPU()
-</pre>
-<p>
-There is also a function
-<code><a href="/pkg/runtime#GOMAXPROCS">runtime.GOMAXPROCS</a></code>,
-which reports (or sets)
-the user-specified number of cores that a Go program can have running
-simultaneously.
-It defaults to the value of <code>runtime.NumCPU</code> but can be
-overridden by setting the similarly named shell environment variable
-or by calling the function with a positive number.  Calling it with
-zero just queries the value.
-Therefore if we want to honor the user's resource request, we should write
-</p>
-<pre>
-var numCPU = runtime.GOMAXPROCS(0)
-</pre>
-<p>
-Be sure not to confuse the ideas of concurrency—structuring a program
-as independently executing components—and parallelism—executing
-calculations in parallel for efficiency on multiple CPUs.
-Although the concurrency features of Go can make some problems easy
-to structure as parallel computations, Go is a concurrent language,
-not a parallel one, and not all parallelization problems fit Go's model.
-For a discussion of the distinction, see the talk cited in
-<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">this
-blog post</a>.
-
-<h3 id="leaky_buffer">A leaky buffer</h3>
-
-<p>
-The tools of concurrent programming can even make non-concurrent
-ideas easier to express.  Here's an example abstracted from an RPC
-package.  The client goroutine loops receiving data from some source,
-perhaps a network.  To avoid allocating and freeing buffers, it keeps
-a free list, and uses a buffered channel to represent it.  If the
-channel is empty, a new buffer gets allocated.
-Once the message buffer is ready, it's sent to the server on
-<code>serverChan</code>.
-</p>
-<pre>
-var freeList = make(chan *Buffer, 100)
-var serverChan = make(chan *Buffer)
-
-func client() {
-    for {
-        var b *Buffer
-        // Grab a buffer if available; allocate if not.
-        select {
-        case b = &lt;-freeList:
-            // Got one; nothing more to do.
-        default:
-            // None free, so allocate a new one.
-            b = new(Buffer)
-        }
-        load(b)              // Read next message from the net.
-        serverChan &lt;- b      // Send to server.
-    }
-}
-</pre>
-<p>
-The server loop receives each message from the client, processes it,
-and returns the buffer to the free list.
-</p>
-<pre>
-func server() {
-    for {
-        b := &lt;-serverChan    // Wait for work.
-        process(b)
-        // Reuse buffer if there's room.
-        select {
-        case freeList &lt;- b:
-            // Buffer on free list; nothing more to do.
-        default:
-            // Free list full, just carry on.
-        }
-    }
-}
-</pre>
-<p>
-The client attempts to retrieve a buffer from <code>freeList</code>;
-if none is available, it allocates a fresh one.
-The server's send to <code>freeList</code> puts <code>b</code> back
-on the free list unless the list is full, in which case the
-buffer is dropped on the floor to be reclaimed by
-the garbage collector.
-(The <code>default</code> clauses in the <code>select</code>
-statements execute when no other case is ready,
-meaning that the <code>selects</code> never block.)
-This implementation builds a leaky bucket free list
-in just a few lines, relying on the buffered channel and
-the garbage collector for bookkeeping.
-</p>
-
-<h2 id="errors">Errors</h2>
-
-<p>
-Library routines must often return some sort of error indication to
-the caller.
-As mentioned earlier, Go's multivalue return makes it
-easy to return a detailed error description alongside the normal
-return value.
-It is good style to use this feature to provide detailed error information.
-For example, as we'll see, <code>os.Open</code> doesn't
-just return a <code>nil</code> pointer on failure, it also returns an
-error value that describes what went wrong.
-</p>
-
-<p>
-By convention, errors have type <code>error</code>,
-a simple built-in interface.
-</p>
-<pre>
-type error interface {
-    Error() string
-}
-</pre>
-<p>
-A library writer is free to implement this interface with a
-richer model under the covers, making it possible not only
-to see the error but also to provide some context.
-As mentioned, alongside the usual <code>*os.File</code>
-return value, <code>os.Open</code> also returns an
-error value.
-If the file is opened successfully, the error will be <code>nil</code>,
-but when there is a problem, it will hold an
-<code>os.PathError</code>:
-</p>
-<pre>
-// PathError records an error and the operation and
-// file path that caused it.
-type PathError struct {
-    Op string    // "open", "unlink", etc.
-    Path string  // The associated file.
-    Err error    // Returned by the system call.
-}
-
-func (e *PathError) Error() string {
-    return e.Op + " " + e.Path + ": " + e.Err.Error()
-}
-</pre>
-<p>
-<code>PathError</code>'s <code>Error</code> generates
-a string like this:
-</p>
-<pre>
-open /etc/passwx: no such file or directory
-</pre>
-<p>
-Such an error, which includes the problematic file name, the
-operation, and the operating system error it triggered, is useful even
-if printed far from the call that caused it;
-it is much more informative than the plain
-"no such file or directory".
-</p>
-
-<p>
-When feasible, error strings should identify their origin, such as by having
-a prefix naming the operation or package that generated the error.  For example, in package
-<code>image</code>, the string representation for a decoding error due to an
-unknown format is "image: unknown format".
-</p>
-
-<p>
-Callers that care about the precise error details can
-use a type switch or a type assertion to look for specific
-errors and extract details.  For <code>PathErrors</code>
-this might include examining the internal <code>Err</code>
-field for recoverable failures.
-</p>
-
-<pre>
-for try := 0; try &lt; 2; try++ {
-    file, err = os.Create(filename)
-    if err == nil {
-        return
-    }
-    if e, ok := err.(*os.PathError); ok &amp;&amp; e.Err == syscall.ENOSPC {
-        deleteTempFiles()  // Recover some space.
-        continue
-    }
-    return
-}
-</pre>
-
-<p>
-The second <code>if</code> statement here is another <a href="#interface_conversions">type assertion</a>.
-If it fails, <code>ok</code> will be false, and <code>e</code>
-will be <code>nil</code>.
-If it succeeds,  <code>ok</code> will be true, which means the
-error was of type <code>*os.PathError</code>, and then so is <code>e</code>,
-which we can examine for more information about the error.
-</p>
-
-<h3 id="panic">Panic</h3>
-
-<p>
-The usual way to report an error to a caller is to return an
-<code>error</code> as an extra return value.  The canonical
-<code>Read</code> method is a well-known instance; it returns a byte
-count and an <code>error</code>.  But what if the error is
-unrecoverable?  Sometimes the program simply cannot continue.
-</p>
-
-<p>
-For this purpose, there is a built-in function <code>panic</code>
-that in effect creates a run-time error that will stop the program
-(but see the next section).  The function takes a single argument
-of arbitrary type&mdash;often a string&mdash;to be printed as the
-program dies.  It's also a way to indicate that something impossible has
-happened, such as exiting an infinite loop.
-</p>
-
-
-<pre>
-// A toy implementation of cube root using Newton's method.
-func CubeRoot(x float64) float64 {
-    z := x/3   // Arbitrary initial value
-    for i := 0; i &lt; 1e6; i++ {
-        prevz := z
-        z -= (z*z*z-x) / (3*z*z)
-        if veryClose(z, prevz) {
-            return z
-        }
-    }
-    // A million iterations has not converged; something is wrong.
-    panic(fmt.Sprintf("CubeRoot(%g) did not converge", x))
-}
-</pre>
-
-<p>
-This is only an example but real library functions should
-avoid <code>panic</code>.  If the problem can be masked or worked
-around, it's always better to let things continue to run rather
-than taking down the whole program.  One possible counterexample
-is during initialization: if the library truly cannot set itself up,
-it might be reasonable to panic, so to speak.
-</p>
-
-<pre>
-var user = os.Getenv("USER")
-
-func init() {
-    if user == "" {
-        panic("no value for $USER")
-    }
-}
-</pre>
-
-<h3 id="recover">Recover</h3>
-
-<p>
-When <code>panic</code> is called, including implicitly for run-time
-errors such as indexing a slice out of bounds or failing a type
-assertion, it immediately stops execution of the current function
-and begins unwinding the stack of the goroutine, running any deferred
-functions along the way.  If that unwinding reaches the top of the
-goroutine's stack, the program dies.  However, it is possible to
-use the built-in function <code>recover</code> to regain control
-of the goroutine and resume normal execution.
-</p>
-
-<p>
-A call to <code>recover</code> stops the unwinding and returns the
-argument passed to <code>panic</code>.  Because the only code that
-runs while unwinding is inside deferred functions, <code>recover</code>
-is only useful inside deferred functions.
-</p>
-
-<p>
-One application of <code>recover</code> is to shut down a failing goroutine
-inside a server without killing the other executing goroutines.
-</p>
-
-<pre>
-func server(workChan &lt;-chan *Work) {
-    for work := range workChan {
-        go safelyDo(work)
-    }
-}
-
-func safelyDo(work *Work) {
-    defer func() {
-        if err := recover(); err != nil {
-            log.Println("work failed:", err)
-        }
-    }()
-    do(work)
-}
-</pre>
-
-<p>
-In this example, if <code>do(work)</code> panics, the result will be
-logged and the goroutine will exit cleanly without disturbing the
-others.  There's no need to do anything else in the deferred closure;
-calling <code>recover</code> handles the condition completely.
-</p>
-
-<p>
-Because <code>recover</code> always returns <code>nil</code> unless called directly
-from a deferred function, deferred code can call library routines that themselves
-use <code>panic</code> and <code>recover</code> without failing.  As an example,
-the deferred function in <code>safelyDo</code> might call a logging function before
-calling <code>recover</code>, and that logging code would run unaffected
-by the panicking state.
-</p>
-
-<p>
-With our recovery pattern in place, the <code>do</code>
-function (and anything it calls) can get out of any bad situation
-cleanly by calling <code>panic</code>.  We can use that idea to
-simplify error handling in complex software.  Let's look at an
-idealized version of a <code>regexp</code> package, which reports
-parsing errors by calling <code>panic</code> with a local
-error type.  Here's the definition of <code>Error</code>,
-an <code>error</code> method, and the <code>Compile</code> function.
-</p>
-
-<pre>
-// Error is the type of a parse error; it satisfies the error interface.
-type Error string
-func (e Error) Error() string {
-    return string(e)
-}
-
-// error is a method of *Regexp that reports parsing errors by
-// panicking with an Error.
-func (regexp *Regexp) error(err string) {
-    panic(Error(err))
-}
-
-// Compile returns a parsed representation of the regular expression.
-func Compile(str string) (regexp *Regexp, err error) {
-    regexp = new(Regexp)
-    // doParse will panic if there is a parse error.
-    defer func() {
-        if e := recover(); e != nil {
-            regexp = nil    // Clear return value.
-            err = e.(Error) // Will re-panic if not a parse error.
-        }
-    }()
-    return regexp.doParse(str), nil
-}
-</pre>
-
-<p>
-If <code>doParse</code> panics, the recovery block will set the
-return value to <code>nil</code>&mdash;deferred functions can modify
-named return values.  It will then check, in the assignment
-to <code>err</code>, that the problem was a parse error by asserting
-that it has the local type <code>Error</code>.
-If it does not, the type assertion will fail, causing a run-time error
-that continues the stack unwinding as though nothing had interrupted
-it.
-This check means that if something unexpected happens, such
-as an index out of bounds, the code will fail even though we
-are using <code>panic</code> and <code>recover</code> to handle
-parse errors.
-</p>
-
-<p>
-With error handling in place, the <code>error</code> method (because it's a
-method bound to a type, it's fine, even natural, for it to have the same name
-as the builtin <code>error</code> type)
-makes it easy to report parse errors without worrying about unwinding
-the parse stack by hand:
-</p>
-
-<pre>
-if pos == 0 {
-    re.error("'*' illegal at start of expression")
-}
-</pre>
-
-<p>
-Useful though this pattern is, it should be used only within a package.
-<code>Parse</code> turns its internal <code>panic</code> calls into
-<code>error</code> values; it does not expose <code>panics</code>
-to its client.  That is a good rule to follow.
-</p>
-
-<p>
-By the way, this re-panic idiom changes the panic value if an actual
-error occurs.  However, both the original and new failures will be
-presented in the crash report, so the root cause of the problem will
-still be visible.  Thus this simple re-panic approach is usually
-sufficient&mdash;it's a crash after all&mdash;but if you want to
-display only the original value, you can write a little more code to
-filter unexpected problems and re-panic with the original error.
-That's left as an exercise for the reader.
-</p>
-
-
-<h2 id="web_server">A web server</h2>
-
-<p>
-Let's finish with a complete Go program, a web server.
-This one is actually a kind of web re-server.
-Google provides a service at <code>chart.apis.google.com</code>
-that does automatic formatting of data into charts and graphs.
-It's hard to use interactively, though,
-because you need to put the data into the URL as a query.
-The program here provides a nicer interface to one form of data: given a short piece of text,
-it calls on the chart server to produce a QR code, a matrix of boxes that encode the
-text.
-That image can be grabbed with your cell phone's camera and interpreted as,
-for instance, a URL, saving you typing the URL into the phone's tiny keyboard.
-</p>
-<p>
-Here's the complete program.
-An explanation follows.
-</p>
-{{code "/doc/progs/eff_qr.go" `/package/` `$`}}
-<p>
-The pieces up to <code>main</code> should be easy to follow.
-The one flag sets a default HTTP port for our server.  The template
-variable <code>templ</code> is where the fun happens. It builds an HTML template
-that will be executed by the server to display the page; more about
-that in a moment.
-</p>
-<p>
-The <code>main</code> function parses the flags and, using the mechanism
-we talked about above, binds the function <code>QR</code> to the root path
-for the server.  Then <code>http.ListenAndServe</code> is called to start the
-server; it blocks while the server runs.
-</p>
-<p>
-<code>QR</code> just receives the request, which contains form data, and
-executes the template on the data in the form value named <code>s</code>.
-</p>
-<p>
-The template package <code>html/template</code> is powerful;
-this program just touches on its capabilities.
-In essence, it rewrites a piece of HTML text on the fly by substituting elements derived
-from data items passed to <code>templ.Execute</code>, in this case the
-form value.
-Within the template text (<code>templateStr</code>),
-double-brace-delimited pieces denote template actions.
-The piece from <code>{{html "{{if .}}"}}</code>
-to <code>{{html "{{end}}"}}</code> executes only if the value of the current data item, called <code>.</code> (dot),
-is non-empty.
-That is, when the string is empty, this piece of the template is suppressed.
-</p>
-<p>
-The two snippets <code>{{html "{{.}}"}}</code> say to show the data presented to
-the template—the query string—on the web page.
-The HTML template package automatically provides appropriate escaping so the
-text is safe to display.
-</p>
-<p>
-The rest of the template string is just the HTML to show when the page loads.
-If this is too quick an explanation, see the <a href="/pkg/html/template/">documentation</a>
-for the template package for a more thorough discussion.
-</p>
-<p>
-And there you have it: a useful web server in a few lines of code plus some
-data-driven HTML text.
-Go is powerful enough to make a lot happen in a few lines.
-</p>
-
-<!--
-TODO
-<pre>
-verifying implementation
-type Color uint32
-
-// Check that Color implements image.Color and image.Image
-var _ image.Color = Black
-var _ image.Image = Black
-</pre>
--->

diff --git a/doc/gccgo_contribute.html b/doc/gccgo_contribute.html
deleted file mode 100644 (file)
index 395902d..0000000
--- a/doc/gccgo_contribute.html
+++ /dev/null
@@ -1,112 +0,0 @@
-<!--{
-       "Title": "Contributing to the gccgo frontend"
-}-->
-
-<h2>Introduction</h2>
-
-<p>
-These are some notes on contributing to the gccgo frontend for GCC.
-For information on contributing to parts of Go other than gccgo,
-see <a href="/doc/contribute.html">Contributing to the Go project</a>.  For
-information on building gccgo for yourself,
-see <a href="/doc/gccgo_install.html">Setting up and using gccgo</a>.
-For more of the gritty details on the process of doing development
-with the gccgo frontend,
-see <a href="https://go.googlesource.com/gofrontend/+/master/HACKING">the
-file HACKING</a> in the gofrontend repository.
-</p>
-
-<h2>Legal Prerequisites</h2>
-
-<p>
-You must follow the <a href="/doc/contribute.html#copyright">Go copyright
-rules</a> for all changes to the gccgo frontend and the associated
-libgo library.  Code that is part of GCC rather than gccgo must follow
-the general <a href="https://gcc.gnu.org/contribute.html">GCC
-contribution rules</a>.
-</p>
-
-<h2>Code</h2>
-
-<p>
-The master sources for the gccgo frontend may be found at
-<a href="https://go.googlesource.com/gofrontend">https://go.googlesource.com/gofrontend</a>.
-They are mirrored
-at <a href="https://github.com/golang/gofrontend">https://github.com/golang/gofrontend</a>.
-The master sources are not buildable by themselves, but only in
-conjunction with GCC (in the future, other compilers may be
-supported).  Changes made to the gccgo frontend are also applied to
-the GCC source code repository hosted at <code>gcc.gnu.org</code>.  In
-the <code>gofrontend</code> repository, the <code>go</code> directory
-is mirrored to the <code>gcc/go/gofrontend</code> directory in the GCC
-repository, and the <code>gofrontend</code> <code>libgo</code>
-directory is mirrored to the GCC <code>libgo</code> directory.  In
-addition, the <code>test</code> directory
-from <a href="//go.googlesource.com/go">the main Go repository</a>
-is mirrored to the <code>gcc/testsuite/go.test/test</code> directory
-in the GCC repository.
-</p>
-
-<p>
-Changes to these directories always flow from the master sources to
-the GCC repository.  The files should never be changed in the GCC
-repository except by changing them in the master sources and mirroring
-them.
-</p>
-
-<p>
-The gccgo frontend is written in C++.
-It follows the GNU and GCC coding standards for C++.
-In writing code for the frontend, follow the formatting of the
-surrounding code.
-Almost all GCC-specific code is not in the frontend proper and is
-instead in the GCC sources in the <code>gcc/go</code> directory.
-</p>
-
-<p>
-The run-time library for gccgo is mostly the same as the library
-in <a href="//go.googlesource.com/go">the main Go repository</a>.
-The library code in the Go repository is periodically merged into
-the <code>libgo/go</code> directory of the <code>gofrontend</code> and
-then the GCC repositories, using the shell
-script <code>libgo/merge.sh</code>.  Accordingly, most library changes
-should be made in the main Go repository.  The files outside
-of <code>libgo/go</code> are gccgo-specific; that said, some of the
-files in <code>libgo/runtime</code> are based on files
-in <code>src/runtime</code> in the main Go repository.
-</p>
-
-<h2>Testing</h2>
-
-<p>
-All patches must be tested.  A patch that introduces new failures is
-not acceptable.
-</p>
-
-<p>
-To run the gccgo test suite, run <code>make check-go</code> in your
-build directory.  This will run various tests
-under <code>gcc/testsuite/go.*</code> and will also run
-the <code>libgo</code> testsuite.  This copy of the tests from the
-main Go repository is run using the DejaGNU script found
-in <code>gcc/testsuite/go.test/go-test.exp</code>.
-</p>
-
-<p>
-Most new tests should be submitted to the main Go repository for later
-mirroring into the GCC repository.  If there is a need for specific
-tests for gccgo, they should go in
-the <code>gcc/testsuite/go.go-torture</code>
-or <code>gcc/testsuite/go.dg</code> directories in the GCC repository.
-</p>
-
-<h2>Submitting Changes</h2>
-
-<p>
-Changes to the Go frontend should follow the same process as for the
-main Go repository, only for the <code>gofrontend</code> project and
-the <code>gofrontend-dev@googlegroups.com</code> mailing list
-rather than the <code>go</code> project and the
-<code>golang-dev@googlegroups.com</code> mailing list.  Those changes
-will then be merged into the GCC sources.
-</p>

diff --git a/doc/gccgo_install.html b/doc/gccgo_install.html
deleted file mode 100644 (file)
index c478a9e..0000000
--- a/doc/gccgo_install.html
+++ /dev/null
@@ -1,533 +0,0 @@
-<!--{
-       "Title": "Setting up and using gccgo",
-       "Path": "/doc/install/gccgo"
-}-->
-
-<p>
-This document explains how to use gccgo, a compiler for
-the Go language. The gccgo compiler is a new frontend
-for GCC, the widely used GNU compiler. Although the
-frontend itself is under a BSD-style license, gccgo is
-normally used as part of GCC and is then covered by
-the <a href="https://www.gnu.org/licenses/gpl.html">GNU General Public
-License</a> (the license covers gccgo itself as part of GCC; it
-does not cover code generated by gccgo).
-</p>
-
-<p>
-Note that gccgo is not the <code>gc</code> compiler; see
-the <a href="/doc/install.html">Installing Go</a> instructions for that
-compiler.
-</p>
-
-<h2 id="Releases">Releases</h2>
-
-<p>
-The simplest way to install gccgo is to install a GCC binary release
-built to include Go support. GCC binary releases are available from
-<a href="https://gcc.gnu.org/install/binaries.html">various
-websites</a> and are typically included as part of GNU/Linux
-distributions. We expect that most people who build these binaries
-will include Go support.
-</p>
-
-<p>
-The GCC 4.7.1 release and all later 4.7 releases include a complete
-<a href="/doc/go1.html">Go 1</a> compiler and libraries.
-</p>
-
-<p>
-Due to timing, the GCC 4.8.0 and 4.8.1 releases are close to but not
-identical to Go 1.1. The GCC 4.8.2 release includes a complete Go
-1.1.2 implementation.
-</p>
-
-<p>
-The GCC 4.9 releases include a complete Go 1.2 implementation.
-</p>
-
-<p>
-The GCC 5 releases include a complete implementation of the Go 1.4
-user libraries. The Go 1.4 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 6 releases include a complete implementation of the Go 1.6.1
-user libraries. The Go 1.6 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 7 releases include a complete implementation of the Go 1.8.1
-user libraries. As with earlier releases, the Go 1.8 runtime is not
-fully merged, but that should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 8 releases include a complete implementation of the Go 1.10.1
-release. The Go 1.10 runtime has now been fully merged into the GCC
-development sources, and concurrent garbage collection is fully
-supported.
-</p>
-
-<p>
-The GCC 9 releases include a complete implementation of the Go 1.12.2
-release.
-</p>
-
-<h2 id="Source_code">Source code</h2>
-
-<p>
-If you cannot use a release, or prefer to build gccgo for yourself, the
-gccgo source code is accessible via Git. The GCC web site has
-<a href="https://gcc.gnu.org/git.html">instructions for getting the GCC
-source code</a>. The gccgo source code is included. As a convenience, a
-stable version of the Go support is available in the
-<code>devel/gccgo</code> branch of the main GCC code repository:
-<code>git://gcc.gnu.org/git/gcc.git</code>.
-This branch is periodically updated with stable Go compiler sources.
-</p>
-
-<p>
-Note that although <code>gcc.gnu.org</code> is the most convenient way
-to get the source code for the Go frontend, it is not where the master
-sources live. If you want to contribute changes to the Go frontend
-compiler, see <a href="/doc/gccgo_contribute.html">Contributing to
-gccgo</a>.
-</p>
-
-
-<h2 id="Building">Building</h2>
-
-<p>
-Building gccgo is just like building GCC
-with one or two additional options. See
-the <a href="https://gcc.gnu.org/install/">instructions on the gcc web
-site</a>. When you run <code>configure</code>, add the
-option <code>--enable-languages=c,c++,go</code> (along with other
-languages you may want to build). If you are targeting a 32-bit x86,
-then you will want to build gccgo to default to
-supporting locked compare and exchange instructions; do this by also
-using the <code>configure</code> option <code>--with-arch=i586</code>
-(or a newer architecture, depending on where you need your programs to
-run). If you are targeting a 64-bit x86, but sometimes want to use
-the <code>-m32</code> option, then use the <code>configure</code>
-option <code>--with-arch-32=i586</code>.
-</p>
-
-<h3 id="Gold">Gold</h3>
-
-<p>
-On x86 GNU/Linux systems the gccgo compiler is able to
-use a small discontiguous stack for goroutines. This permits programs
-to run many more goroutines, since each goroutine can use a relatively
-small stack. Doing this requires using the gold linker version 2.22
-or later. You can either install GNU binutils 2.22 or later, or you
-can build gold yourself.
-</p>
-
-<p>
-To build gold yourself, build the GNU binutils,
-using <code>--enable-gold=default</code> when you run
-the <code>configure</code> script. Before building, you must install
-the flex and bison packages. A typical sequence would look like
-this (you can replace <code>/opt/gold</code> with any directory to
-which you have write access):
-</p>
-
-<pre>
-git clone git://sourceware.org/git/binutils-gdb.git
-mkdir binutils-objdir
-cd binutils-objdir
-../binutils-gdb/configure --enable-gold=default --prefix=/opt/gold
-make
-make install
-</pre>
-
-<p>
-However you install gold, when you configure gccgo, use the
-option <code>--with-ld=<var>GOLD_BINARY</var></code>.
-</p>
-
-<h3 id="Prerequisites">Prerequisites</h3>
-
-<p>
-A number of prerequisites are required to build GCC, as
-described on
-the <a href="https://gcc.gnu.org/install/prerequisites.html">gcc web
-site</a>. It is important to install all the prerequisites before
-running the gcc <code>configure</code> script.
-The prerequisite libraries can be conveniently downloaded using the
-script <code>contrib/download_prerequisites</code> in the GCC sources.
-
-<h3 id="Build_commands">Build commands</h3>
-
-<p>
-Once all the prerequisites are installed, then a typical build and
-install sequence would look like this (only use
-the <code>--with-ld</code> option if you are using the gold linker as
-described above):
-</p>
-
-<pre>
-git clone --branch devel/gccgo git://gcc.gnu.org/git/gcc.git gccgo
-mkdir objdir
-cd objdir
-../gccgo/configure --prefix=/opt/gccgo --enable-languages=c,c++,go --with-ld=/opt/gold/bin/ld
-make
-make install
-</pre>
-
-<h2 id="Using_gccgo">Using gccgo</h2>
-
-<p>
-The gccgo compiler works like other gcc frontends. As of GCC 5 the gccgo
-installation also includes a version of the <code>go</code> command,
-which may be used to build Go programs as described at
-<a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
-</p>
-
-<p>
-To compile a file without using the <code>go</code> command:
-</p>
-
-<pre>
-gccgo -c file.go
-</pre>
-
-<p>
-That produces <code>file.o</code>. To link files together to form an
-executable:
-</p>
-
-<pre>
-gccgo -o file file.o
-</pre>
-
-<p>
-To run the resulting file, you will need to tell the program where to
-find the compiled Go packages. There are a few ways to do this:
-</p>
-
-<ul>
-<li>
-<p>
-Set the <code>LD_LIBRARY_PATH</code> environment variable:
-</p>
-
-<pre>
-LD_LIBRARY_PATH=${prefix}/lib/gcc/MACHINE/VERSION
-[or]
-LD_LIBRARY_PATH=${prefix}/lib64/gcc/MACHINE/VERSION
-export LD_LIBRARY_PATH
-</pre>
-
-<p>
-Here <code>${prefix}</code> is the <code>--prefix</code> option used
-when building gccgo. For a binary install this is
-normally <code>/usr</code>. Whether to use <code>lib</code>
-or <code>lib64</code> depends on the target.
-Typically <code>lib64</code> is correct for x86_64 systems,
-and <code>lib</code> is correct for other systems. The idea is to
-name the directory where <code>libgo.so</code> is found.
-</p>
-
-</li>
-
-<li>
-<p>
-Passing a <code>-Wl,-R</code> option when you link (replace lib with
-lib64 if appropriate for your system):
-</p>
-
-<pre>
-go build -gccgoflags -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
-[or]
-gccgo -o file file.o -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
-</pre>
-</li>
-
-<li>
-<p>
-Use the <code>-static-libgo</code> option to link statically against
-the compiled packages.
-</p>
-</li>
-
-<li>
-<p>
-Use the <code>-static</code> option to do a fully static link (the
-default for the <code>gc</code> compiler).
-</p>
-</li>
-</ul>
-
-<h2 id="Options">Options</h2>
-
-<p>
-The gccgo compiler supports all GCC options
-that are language independent, notably the <code>-O</code>
-and <code>-g</code> options.
-</p>
-
-<p>
-The <code>-fgo-pkgpath=PKGPATH</code> option may be used to set a
-unique prefix for the package being compiled.
-This option is automatically used by the go command, but you may want
-to use it if you invoke gccgo directly.
-This option is intended for use with large
-programs that contain many packages, in order to allow multiple
-packages to use the same identifier as the package name.
-The <code>PKGPATH</code> may be any string; a good choice for the
-string is the path used to import the package.
-</p>
-
-<p>
-The <code>-I</code> and <code>-L</code> options, which are synonyms
-for the compiler, may be used to set the search path for finding
-imports.
-These options are not needed if you build with the go command.
-</p>
-
-<h2 id="Imports">Imports</h2>
-
-<p>
-When you compile a file that exports something, the export
-information will be stored directly in the object file.
-If you build with gccgo directly, rather than with the go command,
-then when you import a package, you must tell gccgo how to find the
-file.
-</p>
-
-<p>
-When you import the package <var>FILE</var> with gccgo,
-it will look for the import data in the following files, and use the
-first one that it finds.
-
-<ul>
-<li><code><var>FILE</var>.gox</code>
-<li><code>lib<var>FILE</var>.so</code>
-<li><code>lib<var>FILE</var>.a</code>
-<li><code><var>FILE</var>.o</code>
-</ul>
-
-<p>
-<code><var>FILE</var>.gox</code>, when used, will typically contain
-nothing but export data. This can be generated from
-<code><var>FILE</var>.o</code> via
-</p>
-
-<pre>
-objcopy -j .go_export FILE.o FILE.gox
-</pre>
-
-<p>
-The gccgo compiler will look in the current
-directory for import files. In more complex scenarios you
-may pass the <code>-I</code> or <code>-L</code> option to
-gccgo. Both options take directories to search. The
-<code>-L</code> option is also passed to the linker.
-</p>
-
-<p>
-The gccgo compiler does not currently (2015-06-15) record
-the file name of imported packages in the object file. You must
-arrange for the imported data to be linked into the program.
-Again, this is not necessary when building with the go command.
-</p>
-
-<pre>
-gccgo -c mypackage.go              # Exports mypackage
-gccgo -c main.go                   # Imports mypackage
-gccgo -o main main.o mypackage.o   # Explicitly links with mypackage.o
-</pre>
-
-<h2 id="Debugging">Debugging</h2>
-
-<p>
-If you use the <code>-g</code> option when you compile, you can run
-<code>gdb</code> on your executable. The debugger has only limited
-knowledge about Go. You can set breakpoints, single-step,
-etc. You can print variables, but they will be printed as though they
-had C/C++ types. For numeric types this doesn't matter. Go strings
-and interfaces will show up as two-element structures. Go
-maps and channels are always represented as C pointers to run-time
-structures.
-</p>
-
-<h2 id="C_Interoperability">C Interoperability</h2>
-
-<p>
-When using gccgo there is limited interoperability with C,
-or with C++ code compiled using <code>extern "C"</code>.
-</p>
-
-<h3 id="Types">Types</h3>
-
-<p>
-Basic types map directly: an <code>int32</code> in Go is
-an <code>int32_t</code> in C, an <code>int64</code> is
-an <code>int64_t</code>, etc.
-The Go type <code>int</code> is an integer that is the same size as a
-pointer, and as such corresponds to the C type <code>intptr_t</code>.
-Go <code>byte</code> is equivalent to C <code>unsigned char</code>.
-Pointers in Go are pointers in C.
-A Go <code>struct</code> is the same as C <code>struct</code> with the
-same fields and types.
-</p>
-
-<p>
-The Go <code>string</code> type is currently defined as a two-element
-structure (this is <b style="color: red;">subject to change</b>):
-</p>
-
-<pre>
-struct __go_string {
-  const unsigned char *__data;
-  intptr_t __length;
-};
-</pre>
-
-<p>
-You can't pass arrays between C and Go. However, a pointer to an
-array in Go is equivalent to a C pointer to the
-equivalent of the element type.
-For example, Go <code>*[10]int</code> is equivalent to C <code>int*</code>,
-assuming that the C pointer does point to 10 elements.
-</p>
-
-<p>
-A slice in Go is a structure. The current definition is
-(this is <b style="color: red;">subject to change</b>):
-</p>
-
-<pre>
-struct __go_slice {
-  void *__values;
-  intptr_t __count;
-  intptr_t __capacity;
-};
-</pre>
-
-<p>
-The type of a Go function is a pointer to a struct (this is
-<b style="color: red;">subject to change</b>). The first field in the
-struct points to the code of the function, which will be equivalent to
-a pointer to a C function whose parameter types are equivalent, with
-an additional trailing parameter. The trailing parameter is the
-closure, and the argument to pass is a pointer to the Go function
-struct.
-
-When a Go function returns more than one value, the C function returns
-a struct. For example, these functions are roughly equivalent:
-</p>
-
-<pre>
-func GoFunction(int) (int, float64)
-struct { int i; float64 f; } CFunction(int, void*)
-</pre>
-
-<p>
-Go <code>interface</code>, <code>channel</code>, and <code>map</code>
-types have no corresponding C type (<code>interface</code> is a
-two-element struct and <code>channel</code> and <code>map</code> are
-pointers to structs in C, but the structs are deliberately undocumented). C
-<code>enum</code> types correspond to some integer type, but precisely
-which one is difficult to predict in general; use a cast. C <code>union</code>
-types have no corresponding Go type. C <code>struct</code> types containing
-bitfields have no corresponding Go type. C++ <code>class</code> types have
-no corresponding Go type.
-</p>
-
-<p>
-Memory allocation is completely different between C and Go, as Go uses
-garbage collection. The exact guidelines in this area are undetermined,
-but it is likely that it will be permitted to pass a pointer to allocated
-memory from C to Go. The responsibility of eventually freeing the pointer
-will remain with C side, and of course if the C side frees the pointer
-while the Go side still has a copy the program will fail. When passing a
-pointer from Go to C, the Go function must retain a visible copy of it in
-some Go variable. Otherwise the Go garbage collector may delete the
-pointer while the C function is still using it.
-</p>
-
-<h3 id="Function_names">Function names</h3>
-
-<p>
-Go code can call C functions directly using a Go extension implemented
-in gccgo: a function declaration may be preceded by
-<code>//extern NAME</code>. For example, here is how the C function
-<code>open</code> can be declared in Go:
-</p>
-
-<pre>
-//extern open
-func c_open(name *byte, mode int, perm int) int
-</pre>
-
-<p>
-The C function naturally expects a NUL-terminated string, which in
-Go is equivalent to a pointer to an array (not a slice!) of
-<code>byte</code> with a terminating zero byte. So a sample call
-from Go would look like (after importing the <code>syscall</code> package):
-</p>
-
-<pre>
-var name = [4]byte{'f', 'o', 'o', 0};
-i := c_open(&amp;name[0], syscall.O_RDONLY, 0);
-</pre>
-
-<p>
-(this serves as an example only, to open a file in Go please use Go's
-<code>os.Open</code> function instead).
-</p>
-
-<p>
-Note that if the C function can block, such as in a call
-to <code>read</code>, calling the C function may block the Go program.
-Unless you have a clear understanding of what you are doing, all calls
-between C and Go should be implemented through cgo or SWIG, as for
-the <code>gc</code> compiler.
-</p>
-
-<p>
-The name of Go functions accessed from C is subject to change. At present
-the name of a Go function that does not have a receiver is
-<code>prefix.package.Functionname</code>. The prefix is set by
-the <code>-fgo-prefix</code> option used when the package is compiled;
-if the option is not used, the default is <code>go</code>.
-To call the function from C you must set the name using
-a GCC extension.
-</p>
-
-<pre>
-extern int go_function(int) __asm__ ("myprefix.mypackage.Function");
-</pre>
-
-<h3 id="Automatic_generation_of_Go_declarations_from_C_source_code">
-Automatic generation of Go declarations from C source code</h3>
-
-<p>
-The Go version of GCC supports automatically generating
-Go declarations from C code. The facility is rather awkward, and most
-users should use the <a href="/cmd/cgo">cgo</a> program with
-the <code>-gccgo</code> option instead.
-</p>
-
-<p>
-Compile your C code as usual, and add the option
-<code>-fdump-go-spec=<var>FILENAME</var></code>. This will create the
-file <code><var>FILENAME</var></code> as a side effect of the
-compilation. This file will contain Go declarations for the types,
-variables and functions declared in the C code. C types that can not
-be represented in Go will be recorded as comments in the Go code. The
-generated file will not have a <code>package</code> declaration, but
-can otherwise be compiled directly by gccgo.
-</p>
-
-<p>
-This procedure is full of unstated caveats and restrictions and we make no
-guarantee that it will not change in the future. It is more useful as a
-starting point for real Go code than as a regular procedure.
-</p>

diff --git a/doc/go-logo-black.png b/doc/go-logo-black.png
deleted file mode 100644 (file)
index 3077ebd..0000000
Binary files a/doc/go-logo-black.png and /dev/null differ

diff --git a/doc/go-logo-blue.png b/doc/go-logo-blue.png
deleted file mode 100644 (file)
index 8d43a56..0000000
Binary files a/doc/go-logo-blue.png and /dev/null differ

diff --git a/doc/go-logo-white.png b/doc/go-logo-white.png
deleted file mode 100644 (file)
index fa29169..0000000
Binary files a/doc/go-logo-white.png and /dev/null differ

diff --git a/doc/go1.1.html b/doc/go1.1.html
deleted file mode 100644 (file)
index f615c97..0000000
--- a/doc/go1.1.html
+++ /dev/null
@@ -1,1099 +0,0 @@
-<!--{
-       "Title": "Go 1.1 Release Notes",
-       "Path":  "/doc/go1.1",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.1</h2>
-
-<p>
-The release of <a href="/doc/go1.html">Go version 1</a> (Go 1 or Go 1.0 for short)
-in March of 2012 introduced a new period
-of stability in the Go language and libraries.
-That stability has helped nourish a growing community of Go users
-and systems around the world.
-Several "point" releases since
-then—1.0.1, 1.0.2, and 1.0.3—have been issued.
-These point releases fixed known bugs but made
-no non-critical changes to the implementation.
-</p>
-
-<p>
-This new release, Go 1.1, keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a> but adds a couple of significant
-(backwards-compatible, of course) language changes, has a long list
-of (again, compatible) library changes, and
-includes major work on the implementation of the compilers,
-libraries, and run-time.
-The focus is on performance.
-Benchmarking is an inexact science at best, but we see significant,
-sometimes dramatic speedups for many of our test programs.
-We trust that many of our users' programs will also see improvements
-just by updating their Go installation and recompiling.
-</p>
-
-<p>
-This document summarizes the changes between Go 1 and Go 1.1.
-Very little if any code will need modification to run with Go 1.1,
-although a couple of rare error cases surface with this release
-and need to be addressed if they arise.
-Details appear below; see the discussion of
-<a href="#int">64-bit ints</a> and <a href="#unicode_literals">Unicode literals</a>
-in particular.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-<a href="/doc/go1compat.html">The Go compatibility document</a> promises
-that programs written to the Go 1 language specification will continue to operate,
-and those promises are maintained.
-In the interest of firming up the specification, though, there are
-details about some error cases that have been clarified.
-There are also some new language features.
-</p>
-
-<h3 id="divzero">Integer division by zero</h3>
-
-<p>
-In Go 1, integer division by a constant zero produced a run-time panic:
-</p>
-
-<pre>
-func f(x int) int {
-       return x/0
-}
-</pre>
-
-<p>
-In Go 1.1, an integer division by constant zero is not a legal program, so it is a compile-time error.
-</p>
-
-<h3 id="unicode_literals">Surrogates in Unicode literals</h3>
-
-<p>
-The definition of string and rune literals has been refined to exclude surrogate halves from the
-set of valid Unicode code points.
-See the <a href="#unicode">Unicode</a> section for more information.
-</p>
-
-<h3 id="method_values">Method values</h3>
-
-<p>
-Go 1.1 now implements
-<a href="/ref/spec#Method_values">method values</a>,
-which are functions that have been bound to a specific receiver value.
-For instance, given a
-<a href="/pkg/bufio/#Writer"><code>Writer</code></a>
-value <code>w</code>,
-the expression
-<code>w.Write</code>,
-a method value, is a function that will always write to <code>w</code>; it is equivalent to
-a function literal closing over <code>w</code>:
-</p>
-
-<pre>
-func (p []byte) (n int, err error) {
-       return w.Write(p)
-}
-</pre>
-
-<p>
-Method values are distinct from method expressions, which generate functions
-from methods of a given type; the method expression <code>(*bufio.Writer).Write</code>
-is equivalent to a function with an extra first argument, a receiver of type
-<code>(*bufio.Writer)</code>:
-</p>
-
-<pre>
-func (w *bufio.Writer, p []byte) (n int, err error) {
-       return w.Write(p)
-}
-</pre>
-
-<p>
-<em>Updating</em>: No existing code is affected; the change is strictly backward-compatible.
-</p>
-
-<h3 id="return">Return requirements</h3>
-
-<p>
-Before Go 1.1, a function that returned a value needed an explicit "return"
-or call to <code>panic</code> at
-the end of the function; this was a simple way to make the programmer
-be explicit about the meaning of the function. But there are many cases
-where a final "return" is clearly unnecessary, such as a function with
-only an infinite "for" loop.
-</p>
-
-<p>
-In Go 1.1, the rule about final "return" statements is more permissive.
-It introduces the concept of a
-<a href="/ref/spec#Terminating_statements"><em>terminating statement</em></a>,
-a statement that is guaranteed to be the last one a function executes.
-Examples include
-"for" loops with no condition and "if-else"
-statements in which each half ends in a "return".
-If the final statement of a function can be shown <em>syntactically</em> to
-be a terminating statement, no final "return" statement is needed.
-</p>
-
-<p>
-Note that the rule is purely syntactic: it pays no attention to the values in the
-code and therefore requires no complex analysis.
-</p>
-
-<p>
-<em>Updating</em>: The change is backward-compatible, but existing code
-with superfluous "return" statements and calls to <code>panic</code> may
-be simplified manually.
-Such code can be identified by <code>go vet</code>.
-</p>
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-The GCC release schedule does not coincide with the Go release schedule, so some skew is inevitable in
-<code>gccgo</code>'s releases.
-The 4.8.0 version of GCC shipped in March, 2013 and includes a nearly-Go 1.1 version of <code>gccgo</code>.
-Its library is a little behind the release, but the biggest difference is that method values are not implemented.
-Sometime around July 2013, we expect 4.8.2 of GCC to ship with a <code>gccgo</code>
-providing a complete Go 1.1 implementation.
-</p>
-
-<h3 id="gc_flag">Command-line flag parsing</h3>
-
-<p>
-In the gc toolchain, the compilers and linkers now use the
-same command-line flag parsing rules as the Go flag package, a departure
-from the traditional Unix flag parsing. This may affect scripts that invoke
-the tool directly.
-For example,
-<code>go tool 6c -Fw -Dfoo</code> must now be written
-<code>go tool 6c -F -w -D foo</code>.
-</p>
-
-<h3 id="int">Size of int on 64-bit platforms</h3>
-
-<p>
-The language allows the implementation to choose whether the <code>int</code> type and
-<code>uint</code> types are 32 or 64 bits. Previous Go implementations made <code>int</code>
-and <code>uint</code> 32 bits on all systems. Both the gc and gccgo implementations
-now make
-<code>int</code> and <code>uint</code> 64 bits on 64-bit platforms such as AMD64/x86-64.
-Among other things, this enables the allocation of slices with
-more than 2 billion elements on 64-bit platforms.
-</p>
-
-<p>
-<em>Updating</em>:
-Most programs will be unaffected by this change.
-Because Go does not allow implicit conversions between distinct
-<a href="/ref/spec#Numeric_types">numeric types</a>,
-no programs will stop compiling due to this change.
-However, programs that contain implicit assumptions
-that <code>int</code> is only 32 bits may change behavior.
-For example, this code prints a positive number on 64-bit systems and
-a negative one on 32-bit systems:
-</p>
-
-<pre>
-x := ^uint32(0) // x is 0xffffffff
-i := int(x)     // i is -1 on 32-bit systems, 0xffffffff on 64-bit
-fmt.Println(i)
-</pre>
-
-<p>Portable code intending 32-bit sign extension (yielding <code>-1</code> on all systems)
-would instead say:
-</p>
-
-<pre>
-i := int(int32(x))
-</pre>
-
-<h3 id="heap">Heap size on 64-bit architectures</h3>
-
-<p>
-On 64-bit architectures, the maximum heap size has been enlarged substantially,
-from a few gigabytes to several tens of gigabytes.
-(The exact details depend on the system and may change.)
-</p>
-
-<p>
-On 32-bit architectures, the heap size has not changed.
-</p>
-
-<p>
-<em>Updating</em>:
-This change should have no effect on existing programs beyond allowing them
-to run with larger heaps.
-</p>
-
-<h3 id="unicode">Unicode</h3>
-
-<p>
-To make it possible to represent code points greater than 65535 in UTF-16,
-Unicode defines <em>surrogate halves</em>,
-a range of code points to be used only in the assembly of large values, and only in UTF-16.
-The code points in that surrogate range are illegal for any other purpose.
-In Go 1.1, this constraint is honored by the compiler, libraries, and run-time:
-a surrogate half is illegal as a rune value, when encoded as UTF-8, or when
-encoded in isolation as UTF-16.
-When encountered, for example in converting from a rune to UTF-8, it is
-treated as an encoding error and will yield the replacement rune,
-<a href="/pkg/unicode/utf8/#RuneError"><code>utf8.RuneError</code></a>,
-U+FFFD.
-</p>
-
-<p>
-This program,
-</p>
-
-<pre>
-import "fmt"
-
-func main() {
-    fmt.Printf("%+q\n", string(0xD800))
-}
-</pre>
-
-<p>
-printed <code>"\ud800"</code> in Go 1.0, but prints <code>"\ufffd"</code> in Go 1.1.
-</p>
-
-<p>
-Surrogate-half Unicode values are now illegal in rune and string constants, so constants such as
-<code>'\ud800'</code> and <code>"\ud800"</code> are now rejected by the compilers.
-When written explicitly as UTF-8 encoded bytes,
-such strings can still be created, as in <code>"\xed\xa0\x80"</code>.
-However, when such a string is decoded as a sequence of runes, as in a range loop, it will yield only <code>utf8.RuneError</code>
-values.
-</p>
-
-<p>
-The Unicode byte order mark U+FEFF, encoded in UTF-8, is now permitted as the first
-character of a Go source file.
-Even though its appearance in the byte-order-free UTF-8 encoding is clearly unnecessary,
-some editors add the mark as a kind of "magic number" identifying a UTF-8 encoded file.
-</p>
-
-<p>
-<em>Updating</em>:
-Most programs will be unaffected by the surrogate change.
-Programs that depend on the old behavior should be modified to avoid the issue.
-The byte-order-mark change is strictly backward-compatible.
-</p>
-
-<h3 id="race">Race detector</h3>
-
-<p>
-A major addition to the tools is a <em>race detector</em>, a way to
-find bugs in programs caused by concurrent access of the same
-variable, where at least one of the accesses is a write.
-This new facility is built into the <code>go</code> tool.
-For now, it is only available on Linux, Mac OS X, and Windows systems with
-64-bit x86 processors.
-To enable it, set the <code>-race</code> flag when building or testing your program
-(for instance, <code>go test -race</code>).
-The race detector is documented in <a href="/doc/articles/race_detector.html">a separate article</a>.
-</p>
-
-<h3 id="gc_asm">The gc assemblers</h3>
-
-<p>
-Due to the change of the <a href="#int"><code>int</code></a> to 64 bits and
-a new internal <a href="//golang.org/s/go11func">representation of functions</a>,
-the arrangement of function arguments on the stack has changed in the gc toolchain.
-Functions written in assembly will need to be revised at least
-to adjust frame pointer offsets.
-</p>
-
-<p>
-<em>Updating</em>:
-The <code>go vet</code> command now checks that functions implemented in assembly
-match the Go function prototypes they implement.
-</p>
-
-<h3 id="gocmd">Changes to the go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go</code></a> command has acquired several
-changes intended to improve the experience for new Go users.
-</p>
-
-<p>
-First, when compiling, testing, or running Go code, the <code>go</code> command will now give more detailed error messages,
-including a list of paths searched, when a package cannot be located.
-</p>
-
-<pre>
-$ go build foo/quxx
-can't load package: package foo/quxx: cannot find package "foo/quxx" in any of:
-        /home/you/go/src/pkg/foo/quxx (from $GOROOT)
-        /home/you/src/foo/quxx (from $GOPATH)
-</pre>
-
-<p>
-Second, the <code>go get</code> command no longer allows <code>$GOROOT</code>
-as the default destination when downloading package source.
-To use the <code>go get</code>
-command, a <a href="/doc/code.html#GOPATH">valid <code>$GOPATH</code></a> is now required.
-</p>
-
-<pre>
-$ GOPATH= go get code.google.com/p/foo/quxx
-package code.google.com/p/foo/quxx: cannot download, $GOPATH not set. For more details see: go help gopath
-</pre>
-
-<p>
-Finally, as a result of the previous change, the <code>go get</code> command will also fail
-when <code>$GOPATH</code> and <code>$GOROOT</code> are set to the same value.
-</p>
-
-<pre>
-$ GOPATH=$GOROOT go get code.google.com/p/foo/quxx
-warning: GOPATH set to GOROOT (/home/you/go) has no effect
-package code.google.com/p/foo/quxx: cannot download, $GOPATH must not be set to $GOROOT. For more details see: go help gopath
-</pre>
-
-<h3 id="gotest">Changes to the go test command</h3>
-
-<p>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
-command no longer deletes the binary when run with profiling enabled,
-to make it easier to analyze the profile.
-The implementation sets the <code>-c</code> flag automatically, so after running,
-</p>
-
-<pre>
-$ go test -cpuprofile cpuprof.out mypackage
-</pre>
-
-<p>
-the file <code>mypackage.test</code> will be left in the directory where <code>go test</code> was run.
-</p>
-
-<p>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
-command can now generate profiling information
-that reports where goroutines are blocked, that is,
-where they tend to stall waiting for an event such as a channel communication.
-The information is presented as a
-<em>blocking profile</em>
-enabled with the
-<code>-blockprofile</code>
-option of
-<code>go test</code>.
-Run <code>go help test</code> for more information.
-</p>
-
-<h3 id="gofix">Changes to the go fix command</h3>
-
-<p>
-The <a href="/cmd/fix/"><code>fix</code></a> command, usually run as
-<code>go fix</code>, no longer applies fixes to update code from
-before Go 1 to use Go 1 APIs.
-To update pre-Go 1 code to Go 1.1, use a Go 1.0 toolchain
-to convert the code to Go 1.0 first.
-</p>
-
-<h3 id="tags">Build constraints</h3>
-
-<p>
-The "<code>go1.1</code>" tag has been added to the list of default
-<a href="/pkg/go/build/#hdr-Build_Constraints">build constraints</a>.
-This permits packages to take advantage of the new features in Go 1.1 while
-remaining compatible with earlier versions of Go.
-</p>
-
-<p>
-To build a file only with Go 1.1 and above, add this build constraint:
-</p>
-
-<pre>
-// +build go1.1
-</pre>
-
-<p>
-To build a file only with Go 1.0.x, use the converse constraint:
-</p>
-
-<pre>
-// +build !go1.1
-</pre>
-
-<h3 id="platforms">Additional platforms</h3>
-
-<p>
-The Go 1.1 toolchain adds experimental support for <code>freebsd/arm</code>,
-<code>netbsd/386</code>, <code>netbsd/amd64</code>, <code>netbsd/arm</code>,
-<code>openbsd/386</code> and <code>openbsd/amd64</code> platforms.
-</p>
-
-<p>
-An ARMv6 or later processor is required for <code>freebsd/arm</code> or
-<code>netbsd/arm</code>.
-</p>
-
-<p>
-Go 1.1 adds experimental support for <code>cgo</code> on <code>linux/arm</code>.
-</p>
-
-<h3 id="crosscompile">Cross compilation</h3>
-
-<p>
-When cross-compiling, the <code>go</code> tool will disable <code>cgo</code>
-support by default.
-</p>
-
-<p>
-To explicitly enable <code>cgo</code>, set <code>CGO_ENABLED=1</code>.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-The performance of code compiled with the Go 1.1 gc tool suite should be noticeably
-better for most Go programs.
-Typical improvements relative to Go 1.0 seem to be about 30%-40%, sometimes
-much more, but occasionally less or even non-existent.
-There are too many small performance-driven tweaks through the tools and libraries
-to list them all here, but the following major changes are worth noting:
-</p>
-
-<ul>
-<li>The gc compilers generate better code in many cases, most noticeably for
-floating point on the 32-bit Intel architecture.</li>
-<li>The gc compilers do more in-lining, including for some operations
-in the run-time such as <a href="/pkg/builtin/#append"><code>append</code></a>
-and interface conversions.</li>
-<li>There is a new implementation of Go maps with significant reduction in
-memory footprint and CPU time.</li>
-<li>The garbage collector has been made more parallel, which can reduce
-latencies for programs running on multiple CPUs.</li>
-<li>The garbage collector is also more precise, which costs a small amount of
-CPU time but can reduce the size of the heap significantly, especially
-on 32-bit architectures.</li>
-<li>Due to tighter coupling of the run-time and network libraries, fewer
-context switches are required on network operations.</li>
-</ul>
-
-<h2 id="library">Changes to the standard library</h2>
-
-<h3 id="bufio_scanner">bufio.Scanner</h3>
-
-<p>
-The various routines to scan textual input in the
-<a href="/pkg/bufio/"><code>bufio</code></a>
-package,
-<a href="/pkg/bufio/#Reader.ReadBytes"><code>ReadBytes</code></a>,
-<a href="/pkg/bufio/#Reader.ReadString"><code>ReadString</code></a>
-and particularly
-<a href="/pkg/bufio/#Reader.ReadLine"><code>ReadLine</code></a>,
-are needlessly complex to use for simple purposes.
-In Go 1.1, a new type,
-<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a>,
-has been added to make it easier to do simple tasks such as
-read the input as a sequence of lines or space-delimited words.
-It simplifies the problem by terminating the scan on problematic
-input such as pathologically long lines, and having a simple
-default: line-oriented input, with each line stripped of its terminator.
-Here is code to reproduce the input a line at a time:
-</p>
-
-<pre>
-scanner := bufio.NewScanner(os.Stdin)
-for scanner.Scan() {
-    fmt.Println(scanner.Text()) // Println will add back the final '\n'
-}
-if err := scanner.Err(); err != nil {
-    fmt.Fprintln(os.Stderr, "reading standard input:", err)
-}
-</pre>
-
-<p>
-Scanning behavior can be adjusted through a function to control subdividing the input
-(see the documentation for <a href="/pkg/bufio/#SplitFunc"><code>SplitFunc</code></a>),
-but for tough problems or the need to continue past errors, the older interface
-may still be required.
-</p>
-
-<h3 id="net">net</h3>
-
-<p>
-The protocol-specific resolvers in the <a href="/pkg/net/"><code>net</code></a> package were formerly
-lax about the network name passed in.
-Although the documentation was clear
-that the only valid networks for
-<a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>
-are <code>"tcp"</code>,
-<code>"tcp4"</code>, and <code>"tcp6"</code>, the Go 1.0 implementation silently accepted any string.
-The Go 1.1 implementation returns an error if the network is not one of those strings.
-The same is true of the other protocol-specific resolvers <a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
-<a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
-<a href="/pkg/net/#ResolveUnixAddr"><code>ResolveUnixAddr</code></a>.
-</p>
-
-<p>
-The previous implementation of
-<a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
-returned a
-<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a> as
-a representation of the connection endpoint.
-The Go 1.1 implementation instead returns a
-<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
-to allow reading and writing
-with its
-<a href="/pkg/net/#UnixConn.ReadFrom"><code>ReadFrom</code></a>
-and
-<a href="/pkg/net/#UnixConn.WriteTo"><code>WriteTo</code></a>
-methods.
-</p>
-
-<p>
-The data structures
-<a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
-<a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>, and
-<a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>
-add a new string field called <code>Zone</code>.
-Code using untagged composite literals (e.g. <code>net.TCPAddr{ip, port}</code>)
-instead of tagged literals (<code>net.TCPAddr{IP: ip, Port: port}</code>)
-will break due to the new field.
-The Go 1 compatibility rules allow this change: client code must use tagged literals to avoid such breakages.
-</p>
-
-<p>
-<em>Updating</em>:
-To correct breakage caused by the new struct field,
-<code>go fix</code> will rewrite code to add tags for these types.
-More generally, <code>go vet</code> will identify composite literals that
-should be revised to use field tags.
-</p>
-
-<h3 id="reflect">reflect</h3>
-
-<p>
-The <a href="/pkg/reflect/"><code>reflect</code></a> package has several significant additions.
-</p>
-
-<p>
-It is now possible to run a "select" statement using
-the <code>reflect</code> package; see the description of
-<a href="/pkg/reflect/#Select"><code>Select</code></a>
-and
-<a href="/pkg/reflect/#SelectCase"><code>SelectCase</code></a>
-for details.
-</p>
-
-<p>
-The new method
-<a href="/pkg/reflect/#Value.Convert"><code>Value.Convert</code></a>
-(or
-<a href="/pkg/reflect/#Type"><code>Type.ConvertibleTo</code></a>)
-provides functionality to execute a Go conversion or type assertion operation
-on a
-<a href="/pkg/reflect/#Value"><code>Value</code></a>
-(or test for its possibility).
-</p>
-
-<p>
-The new function
-<a href="/pkg/reflect/#MakeFunc"><code>MakeFunc</code></a>
-creates a wrapper function to make it easier to call a function with existing
-<a href="/pkg/reflect/#Value"><code>Values</code></a>,
-doing the standard Go conversions among the arguments, for instance
-to pass an actual <code>int</code> to a formal <code>interface{}</code>.
-</p>
-
-<p>
-Finally, the new functions
-<a href="/pkg/reflect/#ChanOf"><code>ChanOf</code></a>,
-<a href="/pkg/reflect/#MapOf"><code>MapOf</code></a>
-and
-<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a>
-construct new
-<a href="/pkg/reflect/#Type"><code>Types</code></a>
-from existing types, for example to construct the type <code>[]T</code> given
-only <code>T</code>.
-</p>
-
-
-<h3 id="time">time</h3>
-<p>
-On FreeBSD, Linux, NetBSD, OS X and OpenBSD, previous versions of the
-<a href="/pkg/time/"><code>time</code></a> package
-returned times with microsecond precision.
-The Go 1.1 implementation on these
-systems now returns times with nanosecond precision.
-Programs that write to an external format with microsecond precision
-and read it back, expecting to recover the original value, will be affected
-by the loss of precision.
-There are two new methods of <a href="/pkg/time/#Time"><code>Time</code></a>,
-<a href="/pkg/time/#Time.Round"><code>Round</code></a>
-and
-<a href="/pkg/time/#Time.Truncate"><code>Truncate</code></a>,
-that can be used to remove precision from a time before passing it to
-external storage.
-</p>
-
-<p>
-The new method
-<a href="/pkg/time/#Time.YearDay"><code>YearDay</code></a>
-returns the one-indexed integral day number of the year specified by the time value.
-</p>
-
-<p>
-The
-<a href="/pkg/time/#Timer"><code>Timer</code></a>
-type has a new method
-<a href="/pkg/time/#Timer.Reset"><code>Reset</code></a>
-that modifies the timer to expire after a specified duration.
-</p>
-
-<p>
-Finally, the new function
-<a href="/pkg/time/#ParseInLocation"><code>ParseInLocation</code></a>
-is like the existing
-<a href="/pkg/time/#Parse"><code>Parse</code></a>
-but parses the time in the context of a location (time zone), ignoring
-time zone information in the parsed string.
-This function addresses a common source of confusion in the time API.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that needs to read and write times using an external format with
-lower precision should be modified to use the new methods.
-</p>
-
-<h3 id="exp_old">Exp and old subtrees moved to go.exp and go.text subrepositories</h3>
-
-<p>
-To make it easier for binary distributions to access them if desired, the <code>exp</code>
-and <code>old</code> source subtrees, which are not included in binary distributions,
-have been moved to the new <code>go.exp</code> subrepository at
-<code>code.google.com/p/go.exp</code>. To access the <code>ssa</code> package,
-for example, run
-</p>
-
-<pre>
-$ go get code.google.com/p/go.exp/ssa
-</pre>
-
-<p>
-and then in Go source,
-</p>
-
-<pre>
-import "code.google.com/p/go.exp/ssa"
-</pre>
-
-<p>
-The old package <code>exp/norm</code> has also been moved, but to a new repository
-<code>go.text</code>, where the Unicode APIs and other text-related packages will
-be developed.
-</p>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-There are three new packages.
-</p>
-
-<ul>
-<li>
-The <a href="/pkg/go/format/"><code>go/format</code></a> package provides
-a convenient way for a program to access the formatting capabilities of the
-<a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
-It has two functions,
-<a href="/pkg/go/format/#Node"><code>Node</code></a> to format a Go parser
-<a href="/pkg/go/ast/#Node"><code>Node</code></a>,
-and
-<a href="/pkg/go/format/#Source"><code>Source</code></a>
-to reformat arbitrary Go source code into the standard format as provided by the
-<a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
-</li>
-
-<li>
-The <a href="/pkg/net/http/cookiejar/"><code>net/http/cookiejar</code></a> package provides the basics for managing HTTP cookies.
-</li>
-
-<li>
-The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package provides low-level facilities for data race detection.
-It is internal to the race detector and does not otherwise export any user-visible functionality.
-</li>
-</ul>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-<li>
-The <a href="/pkg/bytes/"><code>bytes</code></a> package has two new functions,
-<a href="/pkg/bytes/#TrimPrefix"><code>TrimPrefix</code></a>
-and
-<a href="/pkg/bytes/#TrimSuffix"><code>TrimSuffix</code></a>,
-with self-evident properties.
-Also, the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
-has a new method
-<a href="/pkg/bytes/#Buffer.Grow"><code>Grow</code></a> that
-provides some control over memory allocation inside the buffer.
-Finally, the
-<a href="/pkg/bytes/#Reader"><code>Reader</code></a> type now has a
-<a href="/pkg/strings/#Reader.WriteTo"><code>WriteTo</code></a> method
-so it implements the
-<a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
-</li>
-
-<li>
-The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package has
-a new <a href="/pkg/compress/gzip/#Writer.Flush"><code>Flush</code></a>
-method for its
-<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a>
-type that flushes its underlying <code>flate.Writer</code>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/hmac/"><code>crypto/hmac</code></a> package has a new function,
-<a href="/pkg/crypto/hmac/#Equal"><code>Equal</code></a>, to compare two MACs.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-now supports PEM blocks (see
-<a href="/pkg/crypto/x509/#DecryptPEMBlock"><code>DecryptPEMBlock</code></a> for instance),
-and a new function
-<a href="/pkg/crypto/x509/#ParseECPrivateKey"><code>ParseECPrivateKey</code></a> to parse elliptic curve private keys.
-</li>
-
-<li>
-The <a href="/pkg/database/sql/"><code>database/sql</code></a> package
-has a new
-<a href="/pkg/database/sql/#DB.Ping"><code>Ping</code></a>
-method for its
-<a href="/pkg/database/sql/#DB"><code>DB</code></a>
-type that tests the health of the connection.
-</li>
-
-<li>
-The <a href="/pkg/database/sql/driver/"><code>database/sql/driver</code></a> package
-has a new
-<a href="/pkg/database/sql/driver/#Queryer"><code>Queryer</code></a>
-interface that a
-<a href="/pkg/database/sql/driver/#Conn"><code>Conn</code></a>
-may implement to improve performance.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package's
-<a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
-has a new method
-<a href="/pkg/encoding/json/#Decoder.Buffered"><code>Buffered</code></a>
-to provide access to the remaining data in its buffer,
-as well as a new method
-<a href="/pkg/encoding/json/#Decoder.UseNumber"><code>UseNumber</code></a>
-to unmarshal a value into the new type
-<a href="/pkg/encoding/json/#Number"><code>Number</code></a>,
-a string, rather than a float64.
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
-has a new function,
-<a href="/pkg/encoding/xml/#EscapeText"><code>EscapeText</code></a>,
-which writes escaped XML output,
-and a method on
-<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>,
-<a href="/pkg/encoding/xml/#Encoder.Indent"><code>Indent</code></a>,
-to specify indented output.
-</li>
-
-<li>
-In the <a href="/pkg/go/ast/"><code>go/ast</code></a> package, a
-new type <a href="/pkg/go/ast/#CommentMap"><code>CommentMap</code></a>
-and associated methods makes it easier to extract and process comments in Go programs.
-</li>
-
-<li>
-In the <a href="/pkg/go/doc/"><code>go/doc</code></a> package,
-the parser now keeps better track of stylized annotations such as <code>TODO(joe)</code>
-throughout the code,
-information that the <a href="/cmd/godoc/"><code>godoc</code></a>
-command can filter or present according to the value of the <code>-notes</code> flag.
-</li>
-
-<li>
-The undocumented and only partially implemented "noescape" feature of the
-<a href="/pkg/html/template/"><code>html/template</code></a>
-package has been removed; programs that depend on it will break.
-</li>
-
-<li>
-The <a href="/pkg/image/jpeg/"><code>image/jpeg</code></a> package now
-reads progressive JPEG files and handles a few more subsampling configurations.
-</li>
-
-<li>
-The <a href="/pkg/io/"><code>io</code></a> package now exports the
-<a href="/pkg/io/#ByteWriter"><code>io.ByteWriter</code></a> interface to capture the common
-functionality of writing a byte at a time.
-It also exports a new error, <a href="/pkg/io/#ErrNoProgress"><code>ErrNoProgress</code></a>,
-used to indicate a <code>Read</code> implementation is looping without delivering data.
-</li>
-
-<li>
-The <a href="/pkg/log/syslog/"><code>log/syslog</code></a> package now provides better support
-for OS-specific logging features.
-</li>
-
-<li>
-The <a href="/pkg/math/big/"><code>math/big</code></a> package's
-<a href="/pkg/math/big/#Int"><code>Int</code></a> type
-now has methods
-<a href="/pkg/math/big/#Int.MarshalJSON"><code>MarshalJSON</code></a>
-and
-<a href="/pkg/math/big/#Int.UnmarshalJSON"><code>UnmarshalJSON</code></a>
-to convert to and from a JSON representation.
-Also,
-<a href="/pkg/math/big/#Int"><code>Int</code></a>
-can now convert directly to and from a <code>uint64</code> using
-<a href="/pkg/math/big/#Int.Uint64"><code>Uint64</code></a>
-and
-<a href="/pkg/math/big/#Int.SetUint64"><code>SetUint64</code></a>,
-while
-<a href="/pkg/math/big/#Rat"><code>Rat</code></a>
-can do the same with <code>float64</code> using
-<a href="/pkg/math/big/#Rat.Float64"><code>Float64</code></a>
-and
-<a href="/pkg/math/big/#Rat.SetFloat64"><code>SetFloat64</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/mime/multipart/"><code>mime/multipart</code></a> package
-has a new method for its
-<a href="/pkg/mime/multipart/#Writer"><code>Writer</code></a>,
-<a href="/pkg/mime/multipart/#Writer.SetBoundary"><code>SetBoundary</code></a>,
-to define the boundary separator used to package the output.
-The <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a> also now
-transparently decodes any <code>quoted-printable</code> parts and removes
-the <code>Content-Transfer-Encoding</code> header when doing so.
-</li>
-
-<li>
-The
-<a href="/pkg/net/"><code>net</code></a> package's
-<a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
-function has changed return types: it now returns a
-<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
-rather than a
-<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>, which was
-clearly a mistake in Go 1.0.
-Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package includes a new type,
-<a href="/pkg/net/#Dialer"><code>Dialer</code></a>, to supply options to
-<a href="/pkg/net/#Dialer.Dial"><code>Dial</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package adds support for
-link-local IPv6 addresses with zone qualifiers, such as <code>fe80::1%lo0</code>.
-The address structures <a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
-<a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>, and
-<a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>
-record the zone in a new field, and functions that expect string forms of these addresses, such as
-<a href="/pkg/net/#Dial"><code>Dial</code></a>,
-<a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
-<a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
-<a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>,
-now accept the zone-qualified form.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package adds
-<a href="/pkg/net/#LookupNS"><code>LookupNS</code></a> to its suite of resolving functions.
-<code>LookupNS</code> returns the <a href="/pkg/net/#NS">NS records</a> for a host name.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package adds protocol-specific
-packet reading and writing methods to
-<a href="/pkg/net/#IPConn"><code>IPConn</code></a>
-(<a href="/pkg/net/#IPConn.ReadMsgIP"><code>ReadMsgIP</code></a>
-and <a href="/pkg/net/#IPConn.WriteMsgIP"><code>WriteMsgIP</code></a>) and
-<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>
-(<a href="/pkg/net/#UDPConn.ReadMsgUDP"><code>ReadMsgUDP</code></a> and
-<a href="/pkg/net/#UDPConn.WriteMsgUDP"><code>WriteMsgUDP</code></a>).
-These are specialized versions of <a href="/pkg/net/#PacketConn"><code>PacketConn</code></a>'s
-<code>ReadFrom</code> and <code>WriteTo</code> methods that provide access to out-of-band data associated
-with the packets.
- </li>
-
- <li>
-The <a href="/pkg/net/"><code>net</code></a> package adds methods to
-<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to allow closing half of the connection
-(<a href="/pkg/net/#UnixConn.CloseRead"><code>CloseRead</code></a> and
-<a href="/pkg/net/#UnixConn.CloseWrite"><code>CloseWrite</code></a>),
-matching the existing methods of <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package includes several new additions.
-<a href="/pkg/net/http/#ParseTime"><code>ParseTime</code></a> parses a time string, trying
-several common HTTP time formats.
-The <a href="/pkg/net/http/#Request.PostFormValue"><code>PostFormValue</code></a> method of
-<a href="/pkg/net/http/#Request"><code>Request</code></a> is like
-<a href="/pkg/net/http/#Request.FormValue"><code>FormValue</code></a> but ignores URL parameters.
-The <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a> interface provides a mechanism
-for a server handler to discover when a client has disconnected.
-The <code>ServeMux</code> type now has a
-<a href="/pkg/net/http/#ServeMux.Handler"><code>Handler</code></a> method to access a path's
-<code>Handler</code> without executing it.
-The <code>Transport</code> can now cancel an in-flight request with
-<a href="/pkg/net/http/#Transport.CancelRequest"><code>CancelRequest</code></a>.
-Finally, the Transport is now more aggressive at closing TCP connections when
-a <a href="/pkg/net/http/#Response"><code>Response.Body</code></a> is closed before
-being fully consumed.
-</li>
-
-<li>
-The <a href="/pkg/net/mail/"><code>net/mail</code></a> package has two new functions,
-<a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a> and
-<a href="/pkg/net/mail/#ParseAddressList"><code>ParseAddressList</code></a>,
-to parse RFC 5322-formatted mail addresses into
-<a href="/pkg/net/mail/#Address"><code>Address</code></a> structures.
-</li>
-
-<li>
-The <a href="/pkg/net/smtp/"><code>net/smtp</code></a> package's
-<a href="/pkg/net/smtp/#Client"><code>Client</code></a> type has a new method,
-<a href="/pkg/net/smtp/#Client.Hello"><code>Hello</code></a>,
-which transmits a <code>HELO</code> or <code>EHLO</code> message to the server.
-</li>
-
-<li>
-The <a href="/pkg/net/textproto/"><code>net/textproto</code></a> package
-has two new functions,
-<a href="/pkg/net/textproto/#TrimBytes"><code>TrimBytes</code></a> and
-<a href="/pkg/net/textproto/#TrimString"><code>TrimString</code></a>,
-which do ASCII-only trimming of leading and trailing spaces.
-</li>
-
-<li>
-The new method <a href="/pkg/os/#FileMode.IsRegular"><code>os.FileMode.IsRegular</code></a> makes it easy to ask if a file is a plain file.
-</li>
-
-<li>
-The <a href="/pkg/os/signal/"><code>os/signal</code></a> package has a new function,
-<a href="/pkg/os/signal/#Stop"><code>Stop</code></a>, which stops the package delivering
-any further signals to the channel.
-</li>
-
-<li>
-The <a href="/pkg/regexp/"><code>regexp</code></a> package
-now supports Unix-original leftmost-longest matches through the
-<a href="/pkg/regexp/#Regexp.Longest"><code>Regexp.Longest</code></a>
-method, while
-<a href="/pkg/regexp/#Regexp.Split"><code>Regexp.Split</code></a> slices
-strings into pieces based on separators defined by the regular expression.
-</li>
-
-<li>
-The <a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package
-has three new functions regarding memory usage.
-The <a href="/pkg/runtime/debug/#FreeOSMemory"><code>FreeOSMemory</code></a>
-function triggers a run of the garbage collector and then attempts to return unused
-memory to the operating system;
-the <a href="/pkg/runtime/debug/#ReadGCStats"><code>ReadGCStats</code></a>
-function retrieves statistics about the collector; and
-<a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
-provides a programmatic way to control how often the collector runs,
-including disabling it altogether.
-</li>
-
-<li>
-The <a href="/pkg/sort/"><code>sort</code></a> package has a new function,
-<a href="/pkg/sort/#Reverse"><code>Reverse</code></a>.
-Wrapping the argument of a call to
-<a href="/pkg/sort/#Sort"><code>sort.Sort</code></a>
-with a call to <code>Reverse</code> causes the sort order to be reversed.
-</li>
-
-<li>
-The <a href="/pkg/strings/"><code>strings</code></a> package has two new functions,
-<a href="/pkg/strings/#TrimPrefix"><code>TrimPrefix</code></a>
-and
-<a href="/pkg/strings/#TrimSuffix"><code>TrimSuffix</code></a>
-with self-evident properties, and the new method
-<a href="/pkg/strings/#Reader.WriteTo"><code>Reader.WriteTo</code></a> so the
-<a href="/pkg/strings/#Reader"><code>Reader</code></a>
-type now implements the
-<a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
-</li>
-
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package's
-<a href="/pkg/syscall/#Fchflags"><code>Fchflags</code></a> function on various BSDs
-(including Darwin) has changed signature.
-It now takes an int as the first parameter instead of a string.
-Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
-</li>
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package also has received many updates
-to make it more inclusive of constants and system calls for each supported operating system.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package now automates the generation of allocation
-statistics in tests and benchmarks using the new
-<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a> function. And the
-<a href="/pkg/testing/#B.ReportAllocs"><code>ReportAllocs</code></a>
-method on <a href="/pkg/testing/#B"><code>testing.B</code></a> will enable printing of
-memory allocation statistics for the calling benchmark. It also introduces the
-<a href="/pkg/testing/#BenchmarkResult.AllocsPerOp"><code>AllocsPerOp</code></a> method of
-<a href="/pkg/testing/#BenchmarkResult"><code>BenchmarkResult</code></a>.
-There is also a new
-<a href="/pkg/testing/#Verbose"><code>Verbose</code></a> function to test the state of the <code>-v</code>
-command-line flag,
-and a new
-<a href="/pkg/testing/#B.Skip"><code>Skip</code></a> method of
-<a href="/pkg/testing/#B"><code>testing.B</code></a> and
-<a href="/pkg/testing/#T"><code>testing.T</code></a>
-to simplify skipping an inappropriate test.
-</li>
-
-<li>
-In the <a href="/pkg/text/template/"><code>text/template</code></a>
-and
-<a href="/pkg/html/template/"><code>html/template</code></a> packages,
-templates can now use parentheses to group the elements of pipelines, simplifying the construction of complex pipelines.
-Also, as part of the new parser, the
-<a href="/pkg/text/template/parse/#Node"><code>Node</code></a> interface got two new methods to provide
-better error reporting.
-Although this violates the Go 1 compatibility rules,
-no existing code should be affected because this interface is explicitly intended only to be used
-by the
-<a href="/pkg/text/template/"><code>text/template</code></a>
-and
-<a href="/pkg/html/template/"><code>html/template</code></a>
-packages and there are safeguards to guarantee that.
-</li>
-
-<li>
-The implementation of the <a href="/pkg/unicode/"><code>unicode</code></a> package has been updated to Unicode version 6.2.0.
-</li>
-
-<li>
-In the <a href="/pkg/unicode/utf8/"><code>unicode/utf8</code></a> package,
-the new function <a href="/pkg/unicode/utf8/#ValidRune"><code>ValidRune</code></a> reports whether the rune is a valid Unicode code point.
-To be valid, a rune must be in range and not be a surrogate half.
-</li>
-</ul>

diff --git a/doc/go1.10.html b/doc/go1.10.html
deleted file mode 100644 (file)
index 853f874..0000000
--- a/doc/go1.10.html
+++ /dev/null
@@ -1,1448 +0,0 @@
-<!--{
-       "Title": "Go 1.10 Release Notes",
-       "Path":  "/doc/go1.10",
-       "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.10</h2>
-
-<p>
-The latest Go release, version 1.10, arrives six months after <a href="go1.9">Go 1.9</a>.
-Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-This release improves <a href="#build">caching of built packages</a>,
-adds <a href="#test">caching of successful test results</a>,
-runs <a href="#test-vet">vet automatically during tests</a>,
-and
-permits <a href="#cgo">passing string values directly between Go and C using cgo</a>.
-A new <a href="#cgo">hard-coded set of safe compiler options</a> may cause
-unexpected <a href="https://golang.org/s/invalidflag"><code>invalid
-flag</code></a> errors in code that built successfully with older
-releases.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-There are no significant changes to the language specification.
-</p>
-
-<p><!-- CL 60230 -->
-A corner case involving shifts of untyped constants has been clarified,
-and as a result the compilers have been updated to allow the index expression
-<code>x[1.0</code>&nbsp;<code>&lt;&lt;</code>&nbsp;<code>s]</code> where <code>s</code> is an unsigned integer;
-the <a href="/pkg/go/types/">go/types</a> package already did.
-</p>
-
-<p><!-- CL 73233 -->
-The grammar for method expressions has been updated to relax the
-syntax to allow any type expression as a receiver;
-this matches what the compilers were already implementing.
-For example, <code>struct{io.Reader}.Read</code> is a valid, if unusual,
-method expression that the compilers already accepted and is
-now permitted by the language grammar.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-There are no new supported operating systems or processor architectures in this release.
-Most of the work has focused on strengthening the support for existing ports,
-in particular <a href="#asm">new instructions in the assembler</a>
-and improvements to the code generated by the compilers.
-</p>
-
-<p id="freebsd">
-As <a href="go1.9#freebsd">announced in the Go 1.9 release notes</a>,
-Go 1.10 now requires FreeBSD 10.3 or later;
-support for FreeBSD 9.3 has been removed.
-</p>
-
-<p id="netbsd">
-Go now runs on NetBSD again but requires the unreleased NetBSD 8.
-Only <code>GOARCH</code> <code>amd64</code> and <code>386</code> have
-been fixed. The <code>arm</code> port is still broken.
-</p>
-
-<p id="mips">
-On 32-bit MIPS systems, the new environment variable settings
-<code>GOMIPS=hardfloat</code> (the default) and
-<code>GOMIPS=softfloat</code> select whether to use
-hardware instructions or software emulation for floating-point computations.
-</p>
-
-<p id="openbsd">
-Go 1.10 is the last release that will run on OpenBSD 6.0.
-Go 1.11 will require OpenBSD 6.2.
-</p>
-
-<p id="darwin">
-Go 1.10 is the last release that will run on OS X 10.8 Mountain Lion or OS X 10.9 Mavericks.
-Go 1.11 will require OS X 10.10 Yosemite or later.
-</p>
-
-<p id="windows">
-Go 1.10 is the last release that will run on Windows XP or Windows Vista.
-Go 1.11 will require Windows 7 or later.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="goroot">Default GOROOT &amp; GOTMPDIR</h3>
-
-<p>
-If the environment variable <code>$GOROOT</code> is unset,
-the go tool previously used the default <code>GOROOT</code>
-set during toolchain compilation.
-Now, before falling back to that default, the go tool attempts to
-deduce <code>GOROOT</code> from its own executable path.
-This allows binary distributions to be unpacked anywhere in the
-file system and then be used without setting <code>GOROOT</code>
-explicitly.
-</p>
-
-<p>
-By default, the go tool creates its temporary files and directories
-in the system temporary directory (for example, <code>$TMPDIR</code> on Unix).
-If the new environment variable <code>$GOTMPDIR</code> is set,
-the go tool will creates its temporary files and directories in that directory instead.
-</p>
-
-<h3 id="build">Build &amp; Install</h3>
-
-<p>
-The <code>go</code>&nbsp;<code>build</code> command now detects out-of-date packages
-purely based on the content of source files, specified build flags, and metadata stored in the compiled packages.
-Modification times are no longer consulted or relevant.
-The old advice to add <code>-a</code> to force a rebuild in cases where
-the modification times were misleading for one reason or another
-(for example, changes in build flags) is no longer necessary:
-builds now always detect when packages must be rebuilt.
-(If you observe otherwise, please file a bug.)
-</p>
-
-<p>
-The <code>go</code>&nbsp;<code>build</code> <code>-asmflags</code>, <code>-gcflags</code>, <code>-gccgoflags</code>, and <code>-ldflags</code> options
-now apply by default only to the packages listed directly on the command line.
-For example, <code>go</code> <code>build</code> <code>-gcflags=-m</code> <code>mypkg</code>
-passes the compiler the <code>-m</code> flag when building <code>mypkg</code>
-but not its dependencies.
-The new, more general form <code>-asmflags=pattern=flags</code> (and similarly for the others)
-applies the <code>flags</code> only to the packages matching the pattern.
-For example: <code>go</code> <code>install</code> <code>-ldflags=cmd/gofmt=-X=main.version=1.2.3</code> <code>cmd/...</code>
-installs all the commands matching <code>cmd/...</code> but only applies the <code>-X</code> option
-to the linker flags for <code>cmd/gofmt</code>.
-For more details, see <a href="/cmd/go/#hdr-Compile_packages_and_dependencies"><code>go</code> <code>help</code> <code>build</code></a>.
-</p>
-
-<p>
-The <code>go</code>&nbsp;<code>build</code> command now maintains a cache of
-recently built packages, separate from the installed packages in <code>$GOROOT/pkg</code> or <code>$GOPATH/pkg</code>.
-The effect of the cache should be to speed builds that do not explicitly install packages
-or when switching between different copies of source code (for example, when changing
-back and forth between different branches in a version control system).
-The old advice to add the <code>-i</code> flag for speed, as in <code>go</code> <code>build</code> <code>-i</code>
-or <code>go</code> <code>test</code> <code>-i</code>,
-is no longer necessary: builds run just as fast without <code>-i</code>.
-For more details, see <a href="/cmd/go/#hdr-Build_and_test_caching"><code>go</code> <code>help</code> <code>cache</code></a>.
-</p>
-
-<p>
-The <code>go</code>&nbsp;<code>install</code> command now installs only the
-packages and commands listed directly on the command line.
-For example, <code>go</code> <code>install</code> <code>cmd/gofmt</code>
-installs the gofmt program but not any of the packages on which it depends.
-The new build cache makes future commands still run as quickly as if the
-dependencies had been installed.
-To force the installation of dependencies, use the new
-<code>go</code> <code>install</code> <code>-i</code> flag.
-Installing dependency packages should not be necessary in general,
-and the very concept of installed packages may disappear in a future release.
-</p>
-
-<p>
-Many details of the <code>go</code>&nbsp;<code>build</code> implementation have changed to support these improvements.
-One new requirement implied by these changes is that
-binary-only packages must now declare accurate import blocks in their
-stub source code, so that those imports can be made available when
-linking a program using the binary-only package.
-For more details, see <a href="/cmd/go/#hdr-File_types"><code>go</code> <code>help</code> <code>filetype</code></a>.
-</p>
-
-<h3 id="test">Test</h3>
-
-<p>
-The <code>go</code>&nbsp;<code>test</code> command now caches test results:
-if the test executable and command line match a previous run
-and the files and environment variables consulted by that run
-have not changed either, <code>go</code> <code>test</code> will print
-the previous test output, replacing the elapsed time with the string “(cached).”
-Test caching applies only to successful test results;
-only to <code>go</code> <code>test</code>
-commands with an explicit list of packages; and
-only to command lines using a subset of the
-<code>-cpu</code>, <code>-list</code>, <code>-parallel</code>,
-<code>-run</code>, <code>-short</code>, and <code>-v</code> test flags.
-The idiomatic way to bypass test caching is to use <code>-count=1</code>.
-</p>
-
-<p id="test-vet">
-The <code>go</code>&nbsp;<code>test</code> command now automatically runs
-<code>go</code> <code>vet</code> on the package being tested,
-to identify significant problems before running the test.
-Any such problems are treated like build errors and prevent execution of the test.
-Only a high-confidence subset of the available <code>go</code> <code>vet</code>
-checks are enabled for this automatic check.
-To disable the running of <code>go</code> <code>vet</code>, use
-<code>go</code> <code>test</code> <code>-vet=off</code>.
-</p>
-
-<p>
-The <code>go</code> <code>test</code> <code>-coverpkg</code> flag now
-interprets its argument as a comma-separated list of patterns to match against
-the dependencies of each test, not as a list of packages to load anew.
-For example, <code>go</code> <code>test</code> <code>-coverpkg=all</code>
-is now a meaningful way to run a test with coverage enabled for the test package
-and all its dependencies.
-Also, the <code>go</code> <code>test</code> <code>-coverprofile</code> option is now
-supported when running multiple tests.
-</p>
-
-<p>
-In case of failure due to timeout, tests are now more likely to write their profiles before exiting.
-</p>
-
-<p>
-The <code>go</code>&nbsp;<code>test</code> command now always
-merges the standard output and standard error from a given test binary execution
-and writes both to <code>go</code> <code>test</code>'s standard output.
-In past releases, <code>go</code> <code>test</code> only applied this
-merging most of the time.
-</p>
-
-<p>
-The <code>go</code>&nbsp;<code>test</code> <code>-v</code> output
-now includes <code>PAUSE</code> and <code>CONT</code> status update
-lines to mark when <a href="/pkg/testing/#T.Parallel">parallel tests</a> pause and continue.
-</p>
-
-<p>
-The new <code>go</code> <code>test</code> <code>-failfast</code> flag
-disables running additional tests after any test fails.
-Note that tests running in parallel with the failing test are allowed to complete.
-</p>
-
-<p>
-Finally, the new <code>go</code> <code>test</code> <code>-json</code> flag
-filters test output through the new command
-<code>go</code> <code>tool</code> <code>test2json</code>
-to produce a machine-readable JSON-formatted description of test execution.
-This allows the creation of rich presentations of test execution
-in IDEs and other tools.
-</p>
-
-
-<p>
-For more details about all these changes,
-see <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>help</code> <code>test</code></a>
-and the <a href="/cmd/test2json/">test2json documentation</a>.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-Options specified by cgo using <code>#cgo CFLAGS</code> and the like
-are now checked against a list of permitted options.
-This closes a security hole in which a downloaded package uses
-compiler options like
-<span style="white-space: nowrap"><code>-fplugin</code></span>
-to run arbitrary code on the machine where it is being built.
-This can cause a build error such as <code>invalid flag in #cgo CFLAGS</code>.
-For more background, and how to handle this error, see
-<a href="https://golang.org/s/invalidflag">https://golang.org/s/invalidflag</a>.
-</p>
-
-<p>
-Cgo now implements a C typedef like “<code>typedef</code> <code>X</code> <code>Y</code>” using a Go type alias,
-so that Go code may use the types <code>C.X</code> and <code>C.Y</code> interchangeably.
-It also now supports the use of niladic function-like macros.
-Also, the documentation has been updated to clarify that
-Go structs and Go arrays are not supported in the type signatures of cgo-exported functions.
-</p>
-
-<p>
-Cgo now supports direct access to Go string values from C.
-Functions in the C preamble may use the type <code>_GoString_</code>
-to accept a Go string as an argument.
-C code may call <code>_GoStringLen</code> and <code>_GoStringPtr</code>
-for direct access to the contents of the string.
-A value of type <code>_GoString_</code>
-may be passed in a call to an exported Go function that takes an argument of Go type <code>string</code>.
-</p>
-
-<p>
-During toolchain bootstrap, the environment variables <code>CC</code> and <code>CC_FOR_TARGET</code> specify
-the default C compiler that the resulting toolchain will use for host and target builds, respectively.
-However, if the toolchain will be used with multiple targets, it may be necessary to specify a different C compiler for each
-(for example, a different compiler for <code>darwin/arm64</code> versus <code>linux/ppc64le</code>).
-The new set of environment variables <code>CC_FOR_<i>goos</i>_<i>goarch</i></code>
-allows specifying a different default C compiler for each target.
-Note that these variables only apply during toolchain bootstrap,
-to set the defaults used by the resulting toolchain.
-Later <code>go</code> <code>build</code> commands use the <code>CC</code> environment
-variable or else the built-in default.
-</p>
-
-<p>
-Cgo now translates some C types that would normally map to a pointer
-type in Go, to a <code>uintptr</code> instead. These types include
-the <code>CFTypeRef</code> hierarchy in Darwin's CoreFoundation
-framework and the <code>jobject</code> hierarchy in Java's JNI
-interface.
-</p>
-
-<p>
-These types must be <code>uintptr</code> on the Go side because they
-would otherwise confuse the Go garbage collector; they are sometimes
-not really pointers but data structures encoded in a pointer-sized integer.
-Pointers to Go memory must not be stored in these <code>uintptr</code> values.
-</p>
-
-<p>
-Because of this change, values of the affected types need to be
-zero-initialized with the constant <code>0</code> instead of the
-constant <code>nil</code>. Go 1.10 provides <code>gofix</code>
-modules to help with that rewrite:
-</p>
-
-<pre>
-go tool fix -r cftype &lt;pkg&gt;
-go tool fix -r jni &lt;pkg&gt;
-</pre>
-
-<p>
-For more details, see the <a href="/cmd/cgo/">cgo documentation</a>.
-</p>
-
-<h3 id="doc">Doc</h3>
-
-<p>
-The <code>go</code>&nbsp;<code>doc</code> tool now adds functions returning slices of <code>T</code> or <code>*T</code>
-to the display of type <code>T</code>, similar to the existing behavior for functions returning single <code>T</code> or <code>*T</code> results.
-For example:
-</p>
-
-<pre>
-$ go doc mail.Address
-package mail // import "net/mail"
-
-type Address struct {
-       Name    string
-       Address string
-}
-    Address represents a single mail address.
-
-func ParseAddress(address string) (*Address, error)
-func ParseAddressList(list string) ([]*Address, error)
-func (a *Address) String() string
-$
-</pre>
-
-<p>
-Previously, <code>ParseAddressList</code> was only shown in the package overview (<code>go</code> <code>doc</code> <code>mail</code>).
-</p>
-
-<h3 id="fix">Fix</h3>
-
-<p>
-The <code>go</code>&nbsp;<code>fix</code> tool now replaces imports of <code>"golang.org/x/net/context"</code>
-with <code>"context"</code>.
-(Forwarding aliases in the former make it completely equivalent to the latter when using Go 1.9 or later.)
-</p>
-
-<h3 id="get">Get</h3>
-
-<p>
-The <code>go</code>&nbsp;<code>get</code> command now supports Fossil source code repositories.
-</p>
-
-<h3 id="pprof">Pprof</h3>
-
-<p>
-The blocking and mutex profiles produced by the <code>runtime/pprof</code> package
-now include symbol information, so they can be viewed
-in <code>go</code> <code>tool</code> <code>pprof</code>
-without the binary that produced the profile.
-(All other profile types were changed to include symbol information in Go 1.9.)
-</p>
-
-<p>
-The <a href="/cmd/pprof/"><code>go</code>&nbsp;<code>tool</code>&nbsp;<code>pprof</code></a>
-profile visualizer has been updated to git version 9e20b5b (2017-11-08)
-from <a href="https://github.com/google/pprof">github.com/google/pprof</a>,
-which includes an updated web interface.
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<p>
-The <a href="/cmd/vet/"><code>go</code>&nbsp;<code>vet</code></a> command now always has access to
-complete, up-to-date type information when checking packages, even for packages using cgo or vendored imports.
-The reports should be more accurate as a result.
-Note that only <code>go</code>&nbsp;<code>vet</code> has access to this information;
-the more low-level <code>go</code>&nbsp;<code>tool</code>&nbsp;<code>vet</code> does not
-and should be avoided except when working on <code>vet</code> itself.
-(As of Go 1.9, <code>go</code>&nbsp;<code>vet</code> provides access to all the same flags as
-<code>go</code>&nbsp;<code>tool</code>&nbsp;<code>vet</code>.)
-</p>
-
-<h3 id="diag">Diagnostics</h3>
-
-<p>
-This release includes a new <a href="/doc/diagnostics.html">overview of available Go program diagnostic tools</a>.
-</p>
-
-<h3 id="gofmt">Gofmt</h3>
-
-<p>
-Two minor details of the default formatting of Go source code have changed.
-First, certain complex three-index slice expressions previously formatted like
-<code>x[i+1</code>&nbsp;<code>:</code>&nbsp;<code>j:k]</code> and now
-format with more consistent spacing: <code>x[i+1</code>&nbsp;<code>:</code>&nbsp;<code>j</code>&nbsp;<code>:</code>&nbsp;<code>k]</code>.
-Second, single-method interface literals written on a single line,
-which are sometimes used in type assertions,
-are no longer split onto multiple lines.
-</p>
-
-<p>
-Note that these kinds of minor updates to gofmt are expected from time to time.
-In general, we recommend against building systems that check that source code
-matches the output of a specific version of gofmt.
-For example, a continuous integration test that fails if any code already checked into
-a repository is not “properly formatted” is inherently fragile and not recommended.
-</p>
-
-<p>
-If multiple programs must agree about which version of gofmt is used to format a source file,
-we recommend that they do this by arranging to invoke the same gofmt binary.
-For example, in the Go open source repository, our Git pre-commit hook is written in Go
-and could import <code>go/format</code> directly, but instead it invokes the <code>gofmt</code>
-binary found in the current path, so that the pre-commit hook need not be recompiled
-each time <code>gofmt</code> changes.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-The compiler includes many improvements to the performance of generated code,
-spread fairly evenly across the supported architectures.
-</p>
-
-<p>
-The DWARF debug information recorded in binaries has been improved in a few ways:
-constant values are now recorded;
-line number information is more accurate, making source-level stepping through a program work better;
-and each package is now presented as its own DWARF compilation unit.
-</p>
-
-<p>
-The various <a href="https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGhFDelrAP0NqSS_00RgZQ/edit">build modes</a>
-have been ported to more systems.
-Specifically, <code>c-shared</code> now works on <code>linux/ppc64le</code>, <code>windows/386</code>, and <code>windows/amd64</code>;
-<code>pie</code> now works on <code>darwin/amd64</code> and also forces the use of external linking on all systems;
-and <code>plugin</code> now works on <code>linux/ppc64le</code> and <code>darwin/amd64</code>.
-</p>
-
-<p>
-The <code>linux/ppc64le</code> port now requires the use of external linking
-with any programs that use cgo, even uses by the standard library.
-</p>
-
-<h3 id="asm">Assembler</h3>
-
-<p>
-For the ARM 32-bit port, the assembler now supports the instructions
-<code><small>BFC</small></code>,
-<code><small>BFI</small></code>,
-<code><small>BFX</small></code>,
-<code><small>BFXU</small></code>,
-<code><small>FMULAD</small></code>,
-<code><small>FMULAF</small></code>,
-<code><small>FMULSD</small></code>,
-<code><small>FMULSF</small></code>,
-<code><small>FNMULAD</small></code>,
-<code><small>FNMULAF</small></code>,
-<code><small>FNMULSD</small></code>,
-<code><small>FNMULSF</small></code>,
-<code><small>MULAD</small></code>,
-<code><small>MULAF</small></code>,
-<code><small>MULSD</small></code>,
-<code><small>MULSF</small></code>,
-<code><small>NMULAD</small></code>,
-<code><small>NMULAF</small></code>,
-<code><small>NMULD</small></code>,
-<code><small>NMULF</small></code>,
-<code><small>NMULSD</small></code>,
-<code><small>NMULSF</small></code>,
-<code><small>XTAB</small></code>,
-<code><small>XTABU</small></code>,
-<code><small>XTAH</small></code>,
-and
-<code><small>XTAHU</small></code>.
-</p>
-
-<p>
-For the ARM 64-bit port, the assembler now supports the
-<code><small>VADD</small></code>,
-<code><small>VADDP</small></code>,
-<code><small>VADDV</small></code>,
-<code><small>VAND</small></code>,
-<code><small>VCMEQ</small></code>,
-<code><small>VDUP</small></code>,
-<code><small>VEOR</small></code>,
-<code><small>VLD1</small></code>,
-<code><small>VMOV</small></code>,
-<code><small>VMOVI</small></code>,
-<code><small>VMOVS</small></code>,
-<code><small>VORR</small></code>,
-<code><small>VREV32</small></code>,
-and
-<code><small>VST1</small></code>
-instructions.
-</p>
-
-<p>
-For the PowerPC 64-bit port, the assembler now supports the POWER9 instructions
-<code><small>ADDEX</small></code>,
-<code><small>CMPEQB</small></code>,
-<code><small>COPY</small></code>,
-<code><small>DARN</small></code>,
-<code><small>LDMX</small></code>,
-<code><small>MADDHD</small></code>,
-<code><small>MADDHDU</small></code>,
-<code><small>MADDLD</small></code>,
-<code><small>MFVSRLD</small></code>,
-<code><small>MTVSRDD</small></code>,
-<code><small>MTVSRWS</small></code>,
-<code><small>PASTECC</small></code>,
-<code><small>VCMPNEZB</small></code>,
-<code><small>VCMPNEZBCC</small></code>,
-and
-<code><small>VMSUMUDM</small></code>.
-</p>
-
-<p>
-For the S390X port, the assembler now supports the
-<code><small>TMHH</small></code>,
-<code><small>TMHL</small></code>,
-<code><small>TMLH</small></code>,
-and
-<code><small>TMLL</small></code>
-instructions.
-</p>
-
-<p>
-For the X86 64-bit port, the assembler now supports 359 new instructions,
-including the full AVX, AVX2, BMI, BMI2, F16C, FMA3, SSE2, SSE3, SSSE3, SSE4.1, and SSE4.2 extension sets.
-The assembler also no longer implements <code><small>MOVL</small></code>&nbsp;<code><small>$0,</small></code>&nbsp;<code><small>AX</small></code>
-as an <code><small>XORL</small></code> instruction,
-to avoid clearing the condition flags unexpectedly.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-Due to the alignment of Go's semiannual release schedule with GCC's
-annual release schedule,
-GCC release 7 contains the Go 1.8.3 version of gccgo.
-We expect that the next release, GCC 8, will contain the Go 1.10
-version of gccgo.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p>
-The behavior of nested calls to
-<a href="/pkg/runtime/#LockOSThread"><code>LockOSThread</code></a> and
-<a href="/pkg/runtime/#UnlockOSThread"><code>UnlockOSThread</code></a>
-has changed.
-These functions control whether a goroutine is locked to a specific operating system thread,
-so that the goroutine only runs on that thread, and the thread only runs that goroutine.
-Previously, calling <code>LockOSThread</code> more than once in a row
-was equivalent to calling it once, and a single <code>UnlockOSThread</code>
-always unlocked the thread.
-Now, the calls nest: if <code>LockOSThread</code> is called multiple times,
-<code>UnlockOSThread</code> must be called the same number of times
-in order to unlock the thread.
-Existing code that was careful not to nest these calls will remain correct.
-Existing code that incorrectly assumed the calls nested will become correct.
-Most uses of these functions in public Go source code falls into the second category.
-</p>
-
-<p>
-Because one common use of <code>LockOSThread</code> and <code>UnlockOSThread</code>
-is to allow Go code to reliably modify thread-local state (for example, Linux or Plan 9 name spaces),
-the runtime now treats locked threads as unsuitable for reuse or for creating new threads.
-</p>
-
-<p>
-Stack traces no longer include implicit wrapper functions (previously marked <code>&lt;autogenerated&gt;</code>),
-unless a fault or panic happens in the wrapper itself.
-As a result, skip counts passed to functions like <a href="/pkg/runtime/#Caller"><code>Caller</code></a>
-should now always match the structure of the code as written, rather than depending on
-optimization decisions and implementation details.
-</p>
-
-<p>
-The garbage collector has been modified to reduce its impact on allocation latency.
-It now uses a smaller fraction of the overall CPU when running, but it may run more of the time.
-The total CPU consumed by the garbage collector has not changed significantly.
-</p>
-
-<p>
-The <a href="/pkg/runtime/#GOROOT"><code>GOROOT</code></a> function
-now defaults (when the <code>$GOROOT</code> environment variable is not set)
-to the <code>GOROOT</code> or <code>GOROOT_FINAL</code> in effect
-at the time the calling program was compiled.
-Previously it used the <code>GOROOT</code> or <code>GOROOT_FINAL</code> in effect
-at the time the toolchain that compiled the calling program was compiled.
-</p>
-
-<p>
-There is no longer a limit on the <a href="/pkg/runtime/#GOMAXPROCS"><code>GOMAXPROCS</code></a> setting.
-(In Go 1.9 the limit was 1024.)
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise
-statements about performance are difficult to make.  Most programs
-should run a bit faster, due to speedups in the garbage collector,
-better generated code, and optimizations in the core library.
-</p>
-
-<h2 id="gc">Garbage Collector</h2>
-
-<p>
-Many applications should experience significantly lower allocation latency and overall performance overhead when the garbage collector is active.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<p>
-All of the changes to the standard library are minor.
-The changes in <a href="#bytes">bytes</a>
-and <a href="#net/url">net/url</a> are the most likely to require updating of existing programs.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-As always, there are various minor changes and updates to the library,
-made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-in mind.
-</p>
-
-<dl id="archive/tar"><dt><a href="/pkg/archive/tar/">archive/tar</a></dt>
-<dd>
-<p>
-In general, the handling of special header formats is significantly improved and expanded.
-</p>
-<p>
-<a href="/pkg/archive/tar/#FileInfoHeader"><code>FileInfoHeader</code></a> has always
-recorded the Unix UID and GID numbers from its <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a> argument
-(specifically, from the system-dependent information returned by the <code>FileInfo</code>'s <code>Sys</code> method)
-in the returned <a href="/pkg/archive/tar/#Header"><code>Header</code></a>.
-Now it also records the user and group names corresponding to those IDs,
-as well as the major and minor device numbers for device files.
-</p>
-<p>
-The new <a href="/pkg/archive/tar/#Header"><code>Header.Format</code></a> field
-of type <a href="/pkg/archive/tar/#Format"><code>Format</code></a>
-controls which tar header format the <a href="/pkg/archive/tar/#Writer"><code>Writer</code></a> uses.
-The default, as before, is to select the most widely-supported header type
-that can encode the fields needed by the header (USTAR if possible, or else PAX if possible, or else GNU).
-The <a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> sets <code>Header.Format</code> for each header it reads.
-</p>
-<p>
-<code>Reader</code> and the <code>Writer</code> now support arbitrary PAX records,
-using the new <a href="/pkg/archive/tar/#Header"><code>Header.PAXRecords</code></a> field,
-a generalization of the existing <code>Xattrs</code> field.
-</p>
-<p>
-The <code>Reader</code> no longer insists that the file name or link name in GNU headers
-be valid UTF-8.
-</p>
-<p>
-When writing PAX- or GNU-format headers, the <code>Writer</code> now includes
-the <code>Header.AccessTime</code> and <code>Header.ChangeTime</code> fields (if set).
-When writing PAX-format headers, the times include sub-second precision.
-</p>
-</dl>
-
-<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
-<dd>
-<p>
-Go 1.10 adds more complete support for times and character set encodings in ZIP archives.
-</p>
-<p>
-The original ZIP format used the standard MS-DOS encoding of year, month, day, hour, minute, and second into fields in two 16-bit values.
-That encoding cannot represent time zones or odd seconds, so multiple extensions have been
-introduced to allow richer encodings.
-In Go 1.10, the <a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> and <a href="/pkg/archive/zip/#Writer"><code>Writer</code></a>
-now support the widely-understood Info-Zip extension that encodes the time separately in the 32-bit Unix “seconds since epoch” form.
-The <a href="/pkg/archive/zip/#FileHeader"><code>FileHeader</code></a>'s new <code>Modified</code> field of type <a href="/pkg/time/#Time"><code>time.Time</code></a>
-obsoletes the <code>ModifiedTime</code> and <code>ModifiedDate</code> fields, which continue to hold the MS-DOS encoding.
-The <code>Reader</code> and <code>Writer</code> now adopt the common
-convention that a ZIP archive storing a time zone-independent Unix time
-also stores the local time in the MS-DOS field,
-so that the time zone offset can be inferred.
-For compatibility, the <a href="/pkg/archive/zip/#FileHeader.ModTime"><code>ModTime</code></a> and
-<a href="/pkg/archive/zip/#FileHeader.SetModTime"><code>SetModTime</code></a> methods
-behave the same as in earlier releases; new code should use <code>Modified</code> directly.
-</p>
-<p>
-The header for each file in a ZIP archive has a flag bit indicating whether
-the name and comment fields are encoded as UTF-8, as opposed to a system-specific default encoding.
-In Go 1.8 and earlier, the <code>Writer</code> never set the UTF-8 bit.
-In Go 1.9, the <code>Writer</code> changed to set the UTF-8 bit almost always.
-This broke the creation of ZIP archives containing Shift-JIS file names.
-In Go 1.10, the <code>Writer</code> now sets the UTF-8 bit only when
-both the name and the comment field are valid UTF-8 and at least one is non-ASCII.
-Because non-ASCII encodings very rarely look like valid UTF-8, the new
-heuristic should be correct nearly all the time.
-Setting a <code>FileHeader</code>'s new <code>NonUTF8</code> field to true
-disables the heuristic entirely for that file.
-</p>
-<p>
-The <code>Writer</code> also now supports setting the end-of-central-directory record's comment field,
-by calling the <code>Writer</code>'s new <a href="/pkg/archive/zip/#Writer.SetComment"><code>SetComment</code></a> method.
-</p>
-</dl>
-
-<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
-<dd>
-<p>
-The new <a href="/pkg/bufio/#Reader.Size"><code>Reader.Size</code></a>
-and <a href="/pkg/bufio/#Writer.Size"><code>Writer.Size</code></a>
-methods report the <code>Reader</code> or <code>Writer</code>'s underlying buffer size.
-</p>
-</dl>
-
-<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
-<dd>
-<p>
-The
-<a href="/pkg/bytes/#Fields"><code>Fields</code></a>,
-<a href="/pkg/bytes/#FieldsFunc"><code>FieldsFunc</code></a>,
-<a href="/pkg/bytes/#Split"><code>Split</code></a>,
-and
-<a href="/pkg/bytes/#SplitAfter"><code>SplitAfter</code></a>
-functions have always returned subslices of their inputs.
-Go 1.10 changes each returned subslice to have capacity equal to its length,
-so that appending to one cannot overwrite adjacent data in the original input.
-</p>
-</dl>
-
-<dl id="crypto/cipher"><dt><a href="/pkg/crypto/cipher/">crypto/cipher</a></dt>
-<dd>
-<p>
-<a href="/pkg/crypto/cipher/#NewOFB"><code>NewOFB</code></a> now panics if given
-an initialization vector of incorrect length, like the other constructors in the
-package always have.
-(Previously it returned a nil <code>Stream</code> implementation.)
-</p>
-</dl>
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-<dd>
-<p>
-The TLS server now advertises support for SHA-512 signatures when using TLS 1.2.
-The server already supported the signatures, but some clients would not select
-them unless explicitly advertised.
-</p>
-</dl>
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-<dd>
-<p>
-<a href="/pkg/crypto/x509/#Certificate.Verify"><code>Certificate.Verify</code></a>
-now enforces the name constraints for all
-names contained in the certificate, not just the one name that a client has asked about.
-Extended key usage restrictions are similarly now checked all at once.
-As a result, after a certificate has been validated, now it can be trusted in its entirety.
-It is no longer necessary to revalidate the certificate for each additional name
-or key usage.
-</p>
-
-<p>
-Parsed certificates also now report URI names and IP, email, and URI constraints, using the new
-<a href="/pkg/crypto/x509/#Certificate"><code>Certificate</code></a> fields
-<code>URIs</code>, <code>PermittedIPRanges</code>, <code>ExcludedIPRanges</code>,
-<code>PermittedEmailAddresses</code>, <code>ExcludedEmailAddresses</code>,
-<code>PermittedURIDomains</code>, and <code>ExcludedURIDomains</code>. Certificates with
-invalid values for those fields are now rejected.
-</p>
-
-<p>
-The new <a href="/pkg/crypto/x509/#MarshalPKCS1PublicKey"><code>MarshalPKCS1PublicKey</code></a>
-and <a href="/pkg/crypto/x509/#ParsePKCS1PublicKey"><code>ParsePKCS1PublicKey</code></a>
-functions convert an RSA public key to and from PKCS#1-encoded form.
-</p>
-
-<p>
-The new <a href="/pkg/crypto/x509/#MarshalPKCS8PrivateKey"><code>MarshalPKCS8PrivateKey</code></a>
-function converts a private key to PKCS#8-encoded form.
-(<a href="/pkg/crypto/x509/#ParsePKCS8PrivateKey"><code>ParsePKCS8PrivateKey</code></a>
-has existed since Go 1.)
-</p>
-</dl>
-
-<dl id="crypto/x509/pkix"><dt><a href="/pkg/crypto/x509/pkix/">crypto/x509/pkix</a></dt>
-<dd>
-<p>
-<a href="/pkg/crypto/x509/pkix/#Name"><code>Name</code></a> now implements a
-<a href="/pkg/crypto/x509/pkix/#Name.String"><code>String</code></a> method that
-formats the X.509 distinguished name in the standard RFC 2253 format.
-</p>
-</dl>
-
-<dl id="database/sql/driver"><dt><a href="/pkg/database/sql/driver/">database/sql/driver</a></dt>
-<dd>
-<p>
-Drivers that currently hold on to the destination buffer provided by
-<a href="/pkg/database/sql/driver/#Rows.Next"><code>driver.Rows.Next</code></a> should ensure they no longer
-write to a buffer assigned to the destination array outside of that call.
-Drivers must be careful that underlying buffers are not modified when closing
-<a href="/pkg/database/sql/driver/#Rows"><code>driver.Rows</code></a>.
-</p>
-<p>
-Drivers that want to construct a <a href="/pkg/database/sql/#DB"><code>sql.DB</code></a> for
-their clients can now implement the <a href="/pkg/database/sql/driver/#Connector"><code>Connector</code></a> interface
-and call the new <a href="/pkg/database/sql/#OpenDB"><code>sql.OpenDB</code></a> function,
-instead of needing to encode all configuration into a string
-passed to  <a href="/pkg/database/sql/#Open"><code>sql.Open</code></a>.
-</p>
-<p>
-Drivers that want to parse the configuration string only once per <code>sql.DB</code>
-instead of once per <a href="/pkg/database/sql/#Conn"><code>sql.Conn</code></a>,
-or that want access to each <code>sql.Conn</code>'s underlying context,
-can make their <a href="/pkg/database/sql/driver/#Driver"><code>Driver</code></a>
-implementations also implement <a href="/pkg/database/sql/driver/#DriverContext"><code>DriverContext</code></a>'s
-new <code>OpenConnector</code> method.
-</p>
-<p>
-Drivers that implement <a href="/pkg/database/sql/driver/#ExecerContext"><code>ExecerContext</code></a>
-no longer need to implement <a href="/pkg/database/sql/driver/#Execer"><code>Execer</code></a>;
-similarly, drivers that implement <a href="/pkg/database/sql/driver/#QueryerContext"><code>QueryerContext</code></a>
-no longer need to implement <a href="/pkg/database/sql/driver/#Queryer"><code>Queryer</code></a>.
-Previously, even if the context-based interfaces were implemented they were ignored
-unless the non-context-based interfaces were also implemented.
-</p>
-<p>
-To allow drivers to better isolate different clients using a cached driver connection in succession,
-if a <a href="/pkg/database/sql/driver/#Conn"><code>Conn</code></a> implements the new
-<a href="/pkg/database/sql/driver/#SessionResetter"><code>SessionResetter</code></a> interface,
-<code>database/sql</code> will now call <code>ResetSession</code> before
-reusing the <code>Conn</code> for a new client.
-</p>
-</dl>
-
-<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
-<dd>
-<p>
-This release adds 348 new relocation constants divided between the relocation types
-<a href="/pkg/debug/elf/#R_386"><code>R_386</code></a>,
-<a href="/pkg/debug/elf/#R_AARCH64"><code>R_AARCH64</code></a>,
-<a href="/pkg/debug/elf/#R_ARM"><code>R_ARM</code></a>,
-<a href="/pkg/debug/elf/#R_PPC64"><code>R_PPC64</code></a>,
-and
-<a href="/pkg/debug/elf/#R_X86_64"><code>R_X86_64</code></a>.
-</p>
-</dl>
-
-<dl id="debug/macho"><dt><a href="/pkg/debug/macho/">debug/macho</a></dt>
-<dd>
-<p>
-Go 1.10 adds support for reading relocations from Mach-O sections,
-using the <a href="/pkg/debug/macho#Section"><code>Section</code></a> struct's new <code>Relocs</code> field
-and the new <a href="/pkg/debug/macho/#Reloc"><code>Reloc</code></a>,
-<a href="/pkg/debug/macho/#RelocTypeARM"><code>RelocTypeARM</code></a>,
-<a href="/pkg/debug/macho/#RelocTypeARM64"><code>RelocTypeARM64</code></a>,
-<a href="/pkg/debug/macho/#RelocTypeGeneric"><code>RelocTypeGeneric</code></a>,
-and
-<a href="/pkg/debug/macho/#RelocTypeX86_64"><code>RelocTypeX86_64</code></a>
-types and associated constants.
-</p>
-<p>
-Go 1.10 also adds support for the <code>LC_RPATH</code> load command,
-represented by the types
-<a href="/pkg/debug/macho/#RpathCmd"><code>RpathCmd</code></a> and
-<a href="/pkg/debug/macho/#Rpath"><code>Rpath</code></a>,
-and new <a href="/pkg/debug/macho/#pkg-constants">named constants</a>
-for the various flag bits found in headers.
-</p>
-</dl>
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-<dd>
-<p>
-<a href="/pkg/encoding/asn1/#Marshal"><code>Marshal</code></a> now correctly encodes
-strings containing asterisks as type UTF8String instead of PrintableString,
-unless the string is in a struct field with a tag forcing the use of PrintableString.
-<code>Marshal</code> also now respects struct tags containing <code>application</code> directives.
-</p>
-<p>
-The new <a href="/pkg/encoding/asn1/#MarshalWithParams"><code>MarshalWithParams</code></a>
-function marshals its argument as if the additional params were its associated
-struct field tag.
-</p>
-<p>
-<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now respects
-struct field tags using the <code>explicit</code> and <code>tag</code>
-directives.
-</p>
-<p>
-Both <code>Marshal</code> and <code>Unmarshal</code> now support a new struct field tag
-<code>numeric</code>, indicating an ASN.1 NumericString.
-</p>
-</dl>
-
-<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
-<dd>
-<p>
-<a href="/pkg/encoding/csv/#Reader"><code>Reader</code></a> now disallows the use of
-nonsensical <code>Comma</code> and <code>Comment</code> settings,
-such as NUL, carriage return, newline, invalid runes, and the Unicode replacement character,
-or setting <code>Comma</code> and <code>Comment</code> equal to each other.
-</p>
-<p>
-In the case of a syntax error in a CSV record that spans multiple input lines, <code>Reader</code>
-now reports the line on which the record started in the <a href="/pkg/encoding/csv/#ParseError"><code>ParseError</code></a>'s new <code>StartLine</code> field.
-</p>
-</dl>
-
-<dl id="encoding/hex"><dt><a href="/pkg/encoding/hex/">encoding/hex</a></dt>
-<dd>
-<p>
-The new functions
-<a href="/pkg/encoding/hex/#NewEncoder"><code>NewEncoder</code></a>
-and
-<a href="/pkg/encoding/hex/#NewDecoder"><code>NewDecoder</code></a>
-provide streaming conversions to and from hexadecimal,
-analogous to equivalent functions already in
-<a href="/pkg/encoding/base32/">encoding/base32</a>
-and
-<a href="/pkg/encoding/base64/">encoding/base64</a>.
-</p>
-
-<p>
-When the functions
-<a href="/pkg/encoding/hex/#Decode"><code>Decode</code></a>
-and
-<a href="/pkg/encoding/hex/#DecodeString"><code>DecodeString</code></a>
-encounter malformed input,
-they now return the number of bytes already converted
-along with the error.
-Previously they always returned a count of 0 with any error.
-</p>
-</dl>
-
-<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-<dd>
-<p>
-The <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
-adds a new method
-<a href="/pkg/encoding/json/#Decoder.DisallowUnknownFields"><code>DisallowUnknownFields</code></a>
-that causes it to report inputs with unknown JSON fields as a decoding error.
-(The default behavior has always been to discard unknown fields.)
-</p>
-
-<p>
-As a result of <a href="#reflect">fixing a reflect bug</a>,
-<a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>
-can no longer decode into fields inside
-embedded pointers to unexported struct types,
-because it cannot initialize the unexported embedded pointer
-to point at fresh storage.
-<code>Unmarshal</code> now returns an error in this case.
-</p>
-</dl>
-
-<dl id="encoding/pem"><dt><a href="/pkg/encoding/pem/">encoding/pem</a></dt>
-<dd>
-<p>
-<a href="/pkg/encoding/pem/#Encode"><code>Encode</code></a>
-and
-<a href="/pkg/encoding/pem/#EncodeToMemory"><code>EncodeToMemory</code></a>
-no longer generate partial output when presented with a
-block that is impossible to encode as PEM data.
-</p>
-</dl>
-
-<dl id="encoding/xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
-<dd>
-<p>
-The new function
-<a href="/pkg/encoding/xml/#NewTokenDecoder"><code>NewTokenDecoder</code></a>
-is like
-<a href="/pkg/encoding/xml/#NewDecoder"><code>NewDecoder</code></a>
-but creates a decoder reading from a <a href="/pkg/encoding/xml/#TokenReader"><code>TokenReader</code></a>
-instead of an XML-formatted byte stream.
-This is meant to enable the construction of XML stream transformers in client libraries.
-</p>
-</dl>
-
-<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
-<dd>
-<p>
-The default
-<a href="/pkg/flag/#Usage"><code>Usage</code></a> function now prints
-its first line of output to
-<code>CommandLine.Output()</code>
-instead of assuming <code>os.Stderr</code>,
-so that the usage message is properly redirected for
-clients using <code>CommandLine.SetOutput</code>.
-</p>
-<p>
-<a href="/pkg/flag/#PrintDefaults"><code>PrintDefaults</code></a> now
-adds appropriate indentation after newlines in flag usage strings,
-so that multi-line usage strings display nicely.
-</p>
-<p>
-<a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a> adds new methods
-<a href="/pkg/flag/#FlagSet.ErrorHandling"><code>ErrorHandling</code></a>,
-<a href="/pkg/flag/#FlagSet.Name"><code>Name</code></a>,
-and
-<a href="/pkg/flag/#FlagSet.Output"><code>Output</code></a>,
-to retrieve the settings passed to
-<a href="/pkg/flag/#NewFlagSet"><code>NewFlagSet</code></a>
-and
-<a href="/pkg/flag/#FlagSet.SetOutput"><code>FlagSet.SetOutput</code></a>.
-</p>
-</dl>
-
-<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-<dd>
-<p>
-To support the <a href="#doc">doc change</a> described above,
-functions returning slices of <code>T</code>, <code>*T</code>, <code>**T</code>, and so on
-are now reported in <code>T</code>'s <a href="/pkg/go/doc/#Type"><code>Type</code></a>'s <code>Funcs</code> list,
-instead of in the <a href="/pkg/go/doc/#Package"><code>Package</code></a>'s <code>Funcs</code> list.
-</p>
-</dl>
-
-<dl id="go/importer"><dt><a href="/pkg/go/importer/">go/importer</a></dt>
-<dd>
-<p>
-The <a href="/pkg/go/importer/#For"><code>For</code></a> function now accepts a non-nil lookup argument.
-</p>
-</dl>
-
-<dl id="go/printer"><dt><a href="/pkg/go/printer/">go/printer</a></dt>
-<dd>
-<p>
-The changes to the default formatting of Go source code
-discussed in the <a href="#gofmt">gofmt section</a> above
-are implemented in the <a href="/pkg/go/printer/">go/printer</a> package
-and also affect the output of the higher-level <a href="/pkg/go/format/">go/format</a> package.
-</p>
-</dl>
-
-<dl id="hash"><dt><a href="/pkg/hash/">hash</a></dt>
-<dd>
-<p>
-Implementations of the <a href="/pkg/hash/#Hash"><code>Hash</code></a> interface are now
-encouraged to implement <a href="/pkg/encoding/#BinaryMarshaler"><code>encoding.BinaryMarshaler</code></a>
-and <a href="/pkg/encoding/#BinaryUnmarshaler"><code>encoding.BinaryUnmarshaler</code></a>
-to allow saving and recreating their internal state,
-and all implementations in the standard library
-(<a href="/pkg/hash/crc32/">hash/crc32</a>, <a href="/pkg/crypto/sha256/">crypto/sha256</a>, and so on)
-now implement those interfaces.
-</p>
-</dl>
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-<dd>
-<p>
-The new <a href="/pkg/html/template#Srcset"><code>Srcset</code></a> content
-type allows for proper handling of values within the
-<a href="https://w3c.github.io/html/semantics-embedded-content.html#element-attrdef-img-srcset"><code>srcset</code></a>
-attribute of <code>img</code> tags.
-</p>
-</dl>
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-<dd>
-<p>
-<a href="/pkg/math/big/#Int"><code>Int</code></a> now supports conversions to and from bases 2 through 62
-in its <a href="/pkg/math/big/#Int.SetString"><code>SetString</code></a> and <a href="/pkg/math/big/#Text"><code>Text</code></a> methods.
-(Previously it only allowed bases 2 through 36.)
-The value of the constant <code>MaxBase</code> has been updated.
-</p>
-<p>
-<a href="/pkg/math/big/#Int"><code>Int</code></a> adds a new
-<a href="/pkg/math/big/#CmpAbs"><code>CmpAbs</code></a> method
-that is like <a href="/pkg/math/big/#Cmp"><code>Cmp</code></a> but
-compares only the absolute values (not the signs) of its arguments.
-</p>
-<p>
-<a href="/pkg/math/big/#Float"><code>Float</code></a> adds a new
-<a href="/pkg/math/big/#Float.Sqrt"><code>Sqrt</code></a> method to
-compute square roots.
-</p>
-</dl>
-
-<dl id="math/cmplx"><dt><a href="/pkg/math/cmplx/">math/cmplx</a></dt>
-<dd>
-<p>
-Branch cuts and other boundary cases in
-<a href="/pkg/math/cmplx/#Asin"><code>Asin</code></a>,
-<a href="/pkg/math/cmplx/#Asinh"><code>Asinh</code></a>,
-<a href="/pkg/math/cmplx/#Atan"><code>Atan</code></a>,
-and
-<a href="/pkg/math/cmplx/#Sqrt"><code>Sqrt</code></a>
-have been corrected to match the definitions used in the C99 standard.
-</p>
-</dl>
-
-<dl id="math/rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
-<dd>
-<p>
-The new <a href="/pkg/math/rand/#Shuffle"><code>Shuffle</code></a> function and corresponding
-<a href="/pkg/math/rand/#Rand.Shuffle"><code>Rand.Shuffle</code></a> method
-shuffle an input sequence.
-</p>
-</dl>
-
-<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
-<dd>
-<p>
-The new functions
-<a href="/pkg/math/#Round"><code>Round</code></a>
-and
-<a href="/pkg/math/#RoundToEven"><code>RoundToEven</code></a>
-round their arguments to the nearest floating-point integer;
-<code>Round</code> rounds a half-integer to its larger integer neighbor (away from zero)
-while <code>RoundToEven</code> rounds a half-integer to its even integer neighbor.
-</p>
-
-<p>
-The new functions
-<a href="/pkg/math/#Erfinv"><code>Erfinv</code></a>
-and
-<a href="/pkg/math/#Erfcinv"><code>Erfcinv</code></a>
-compute the inverse error function and the
-inverse complementary error function.
-</p>
-</dl>
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-<dd>
-<p>
-<a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>
-now accepts parts with empty filename attributes.
-</p>
-</dl>
-
-<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
-<dd>
-<p>
-<a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a> now discards
-invalid attribute values; previously it returned those values as empty strings.
-</p>
-</dl>
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-<dd>
-<p>
-The <a href="/pkg/net/#Conn"><code>Conn</code></a> and
-<a href="/pkg/net/#Conn"><code>Listener</code></a> implementations
-in this package now guarantee that when <code>Close</code> returns,
-the underlying file descriptor has been closed.
-(In earlier releases, if the <code>Close</code> stopped pending I/O
-in other goroutines, the closing of the file descriptor could happen in one of those
-goroutines shortly after <code>Close</code> returned.)
-</p>
-
-<p>
-<a href="/pkg/net/#TCPListener"><code>TCPListener</code></a> and
-<a href="/pkg/net/#UnixListener"><code>UnixListener</code></a>
-now implement
-<a href="/pkg/syscall/#Conn"><code>syscall.Conn</code></a>,
-to allow setting options on the underlying file descriptor
-using <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn.Control</code></a>.
-</p>
-
-<p>
-The <code>Conn</code> implementations returned by <a href="/pkg/net/#Pipe"><code>Pipe</code></a>
-now support setting read and write deadlines.
-</p>
-
-<p>
-The <a href="/pkg/net/#IPConn.ReadMsgIP"><code>IPConn.ReadMsgIP</code></a>,
-<a href="/pkg/net/#IPConn.WriteMsgIP"><code>IPConn.WriteMsgIP</code></a>,
-<a href="/pkg/net/#UDPConn.ReadMsgUDP"><code>UDPConn.ReadMsgUDP</code></a>,
-and
-<a href="/pkg/net/#UDPConn.WriteMsgUDP"><code>UDPConn.WriteMsgUDP</code></a>,
-methods are now implemented on Windows.
-</p>
-</dl>
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-<dd>
-<p>
-On the client side, an HTTP proxy (most commonly configured by
-<a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>)
-can now be specified as an <code>https://</code> URL,
-meaning that the client connects to the proxy over HTTPS before issuing a standard, proxied HTTP request.
-(Previously, HTTP proxy URLs were required to begin with <code>http://</code> or <code>socks5://</code>.)
-</p>
-<p>
-On the server side, <a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> and its single-file equivalent <a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a>
-now apply <code>If-Range</code> checks to <code>HEAD</code> requests.
-<code>FileServer</code> also now reports directory read failures to the <a href="/pkg/net/http/#Server"><code>Server</code></a>'s <code>ErrorLog</code>.
-The content-serving handlers also now omit the <code>Content-Type</code> header when serving zero-length content.
-</p>
-<p>
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>'s <code>WriteHeader</code> method now panics
-if passed an invalid (non-3-digit) status code.
-</p>
-<p>
-<!-- CL 46631 -->
-The <code>Server</code> will no longer add an implicit Content-Type when a <code>Handler</code> does not write any output.
-</p>
-<p>
-<a href="/pkg/net/http/#Redirect"><code>Redirect</code></a> now sets the <code>Content-Type</code> header before writing its HTTP response.
-</p>
-</dl>
-
-<dl id="net/mail"><dt><a href="/pkg/net/mail/">net/mail</a></dt>
-<dd>
-<p>
-<a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a> and
-<a href="/pkg/net/mail/#ParseAddressList"><code>ParseAddressList</code></a>
-now support a variety of obsolete address formats.
-</p>
-</dl>
-
-<dl id="net/smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
-<dd>
-<p>
-The <a href="/pkg/net/smtp/#Client"><code>Client</code></a> adds a new
-<a href="/pkg/net/smtp/#Client.Noop"><code>Noop</code></a> method,
-to test whether the server is still responding.
-It also now defends against possible SMTP injection in the inputs
-to the <a href="/pkg/net/smtp/#Client.Hello"><code>Hello</code></a>
-and <a href="/pkg/net/smtp/#Client.Verify"><code>Verify</code></a> methods.
-</p>
-</dl>
-
-<dl id="net/textproto"><dt><a href="/pkg/net/textproto/">net/textproto</a></dt>
-<dd>
-<p>
-<a href="/pkg/net/textproto/#ReadMIMEHeader"><code>ReadMIMEHeader</code></a>
-now rejects any header that begins with a continuation (indented) header line.
-Previously a header with an indented first line was treated as if the first line
-were not indented.
-</p>
-</dl>
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-<dd>
-<p>
-<a href="/pkg/net/url/#ResolveReference"><code>ResolveReference</code></a>
-now preserves multiple leading slashes in the target URL.
-Previously it rewrote multiple leading slashes to a single slash,
-which resulted in the <a href="/pkg/net/http/#Client"><code>http.Client</code></a>
-following certain redirects incorrectly.
-</p>
-<p>
-For example, this code's output has changed:
-</p>
-<pre>
-base, _ := url.Parse("http://host//path//to/page1")
-target, _ := url.Parse("page2")
-fmt.Println(base.ResolveReference(target))
-</pre>
-<p>
-Note the doubled slashes around <code>path</code>.
-In Go 1.9 and earlier, the resolved URL was <code>http://host/path//to/page2</code>:
-the doubled slash before <code>path</code> was incorrectly rewritten
-to a single slash, while the doubled slash after <code>path</code> was
-correctly preserved.
-Go 1.10 preserves both doubled slashes, resolving to <code>http://host//path//to/page2</code>
-as required by <a href="https://tools.ietf.org/html/rfc3986#section-5.2">RFC 3986</a>.
-</p>
-
-<p>This change may break existing buggy programs that unintentionally
-construct a base URL with a leading doubled slash in the path and inadvertently
-depend on <code>ResolveReference</code> to correct that mistake.
-For example, this can happen if code adds a host prefix
-like <code>http://host/</code> to a path like <code>/my/api</code>,
-resulting in a URL with a doubled slash: <code>http://host//my/api</code>.
-</p>
-
-<p>
-<a href="/pkg/net/url/#UserInfo"><code>UserInfo</code></a>'s methods
-now treat a nil receiver as equivalent to a pointer to a zero <code>UserInfo</code>.
-Previously, they panicked.
-</p>
-</dl>
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-<dd>
-<p>
-<a href="/pkg/os/#File"><code>File</code></a> adds new methods
-<a href="/pkg/os/#File.SetDeadline"><code>SetDeadline</code></a>,
-<a href="/pkg/os/#File.SetReadDeadline"><code>SetReadDeadline</code></a>,
-and
-<a href="/pkg/os/#File.SetWriteDeadline"><code>SetWriteDeadline</code></a>
-that allow setting I/O deadlines when the
-underlying file descriptor supports non-blocking I/O operations.
-The definition of these methods matches those in <a href="/pkg/net/#Conn"><code>net.Conn</code></a>.
-If an I/O method fails due to missing a deadline, it will return a
-timeout error; the
-new <a href="/pkg/os/#IsTimeout"><code>IsTimeout</code></a> function
-reports whether an error represents a timeout.
-</p>
-
-<p>
-Also matching <code>net.Conn</code>,
-<code>File</code>'s
-<a href="/pkg/os/#File.Close"><code>Close</code></a> method
-now guarantee that when <code>Close</code> returns,
-the underlying file descriptor has been closed.
-(In earlier releases,
-if the <code>Close</code> stopped pending I/O
-in other goroutines, the closing of the file descriptor could happen in one of those
-goroutines shortly after <code>Close</code> returned.)
-</p>
-
-<p>
-On BSD, macOS, and Solaris systems,
-<a href="/pkg/os/#Chtimes"><code>Chtimes</code></a>
-now supports setting file times with nanosecond precision
-(assuming the underlying file system can represent them).
-</p>
-</dl>
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-<dd>
-<p>
-The <a href="/pkg/reflect/#Copy"><code>Copy</code></a> function now allows copying
-from a string into a byte array or byte slice, to match the
-<a href="/pkg/builtin/#copy">built-in copy function</a>.
-</p>
-
-<p>
-In structs, embedded pointers to unexported struct types were
-previously incorrectly reported with an empty <code>PkgPath</code>
-in the corresponding <a href="/pkg/reflect/#StructField">StructField</a>,
-with the result that for those fields,
-and <a href="/pkg/reflect/#Value.CanSet"><code>Value.CanSet</code></a>
-incorrectly returned true and
-<a href="/pkg/reflect/#Value.Set"><code>Value.Set</code></a>
-incorrectly succeeded.
-The underlying metadata has been corrected;
-for those fields,
-<code>CanSet</code> now correctly returns false
-and <code>Set</code> now correctly panics.
-This may affect reflection-based unmarshalers
-that could previously unmarshal into such fields
-but no longer can.
-For example, see the <a href="#encoding/json"><code>encoding/json</code> notes</a>.
-</p>
-</dl>
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-<dd>
-<p>
-As <a href="#pprof">noted above</a>, the blocking and mutex profiles
-now include symbol information so that they can be viewed without needing
-the binary that generated them.
-</p>
-</dl>
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-<dd>
-<p>
-<a href="/pkg/strconv/#ParseUint"><code>ParseUint</code></a> now returns
-the maximum magnitude integer of the appropriate size
-with any <code>ErrRange</code> error, as it was already documented to do.
-Previously it returned 0 with <code>ErrRange</code> errors.
-</p>
-</dl>
-
-<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
-<dd>
-<p>
-A new type
-<a href="/pkg/strings/#Builder"><code>Builder</code></a> is a replacement for
-<a href="/pkg/bytes/#Buffer"><code>bytes.Buffer</code></a> for the use case of
-accumulating text into a <code>string</code> result.
-The <code>Builder</code>'s API is a restricted subset of <code>bytes.Buffer</code>'s
-that allows it to safely avoid making a duplicate copy of the data
-during the <a href="/pkg/strings/#Builder.String"><code>String</code></a> method.
-</p>
-</dl>
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-<dd>
-<p>
-On Windows,
-the new <a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a> field <code>Token</code>,
-of type <a href="/pkg/syscall/#Token"><code>Token</code></a> allows the creation of a process that
-runs as another user during <a href="/pkg/syscall/#StartProcess"><code>StartProcess</code></a>
-(and therefore also during <a href="/pkg/os/#StartProcess"><code>os.StartProcess</code></a> and
-<a href="/pkg/os/exec/#Cmd.Start"><code>exec.Cmd.Start</code></a>).
-The new function <a href="/pkg/syscall/#CreateProcessAsUser"><code>CreateProcessAsUser</code></a>
-gives access to the underlying system call.
-</p>
-
-<p>
-On BSD, macOS, and Solaris systems, <a href="/pkg/syscall/#UtimesNano"><code>UtimesNano</code></a>
-is now implemented.
-</p>
-</dl>
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-<dd>
-<p>
-<a href="/pkg/time/#LoadLocation"><code>LoadLocation</code></a> now uses the directory
-or uncompressed zip file named by the <code>$ZONEINFO</code>
-environment variable before looking in the default system-specific list of
-known installation locations or in <code>$GOROOT/lib/time/zoneinfo.zip</code>.
-</p>
-<p>
-The new function <a href="/pkg/time/#LoadLocationFromTZData"><code>LoadLocationFromTZData</code></a>
-allows conversion of IANA time zone file data to a <a href="/pkg/time/#Location"><code>Location</code></a>.
-</p>
-</dl>
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-<dd>
-<p>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-support throughout the system has been upgraded from Unicode 9.0 to
-<a href="http://www.unicode.org/versions/Unicode10.0.0/">Unicode 10.0</a>,
-which adds 8,518 new characters, including four new scripts, one new property,
-a Bitcoin currency symbol, and 56 new emoji.
-</p>
-</dl>

diff --git a/doc/go1.11.html b/doc/go1.11.html
deleted file mode 100644 (file)
index 483ecd8..0000000
--- a/doc/go1.11.html
+++ /dev/null
@@ -1,934 +0,0 @@
-<!--{
-       "Title": "Go 1.11 Release Notes",
-       "Path":  "/doc/go1.11",
-       "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.11</h2>
-
-<p>
-  The latest Go release, version 1.11, arrives six months after <a href="go1.10">Go 1.10</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language specification.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p> <!-- CL 94255, CL 115038, etc -->
-  As <a href="go1.10#ports">announced in the Go 1.10 release notes</a>, Go 1.11 now requires
-  OpenBSD 6.2 or later, macOS 10.10 Yosemite or later, or Windows 7 or later;
-  support for previous versions of these operating systems has been removed.
-</p>
-
-<p> <!-- CL 121657 -->
-  Go 1.11 supports the upcoming OpenBSD 6.4 release. Due to changes in
-  the OpenBSD kernel, older versions of Go will not work on OpenBSD 6.4.
-</p>
-
-<p>
-  There are <a href="https://golang.org/issue/25206">known issues</a> with NetBSD on i386 hardware.
-</p>
-
-<p><!-- CL 107935 -->
-  The race detector is now supported on <code>linux/ppc64le</code>
-  and, to a lesser extent, on <code>netbsd/amd64</code>. The NetBSD race detector support
-  has <a href="https://golang.org/issue/26403">known issues</a>.
-</p>
-
-<p><!-- CL 109255 -->
-  The memory sanitizer (<code>-msan</code>) is now supported on <code>linux/arm64</code>.
-</p>
-
-<p><!-- CL 93875 -->
-  The build modes <code>c-shared</code> and <code>c-archive</code> are now supported on
-  <code>freebsd/amd64</code>.
-</p>
-
-<p id="mips"><!-- CL 108475 -->
-  On 64-bit MIPS systems, the new environment variable settings
-  <code>GOMIPS64=hardfloat</code> (the default) and
-  <code>GOMIPS64=softfloat</code> select whether to use
-  hardware instructions or software emulation for floating-point computations.
-  For 32-bit systems, the environment variable is still <code>GOMIPS</code>,
-  as <a href="go1.10#mips">added in Go 1.10</a>.
-</p>
-
-<p><!-- CL 107475 -->
-  On soft-float ARM systems (<code>GOARM=5</code>), Go now uses a more
-  efficient software floating point interface. This is transparent to
-  Go code, but ARM assembly that uses floating-point instructions not
-  guarded on GOARM will break and must be ported to
-  the <a href="https://golang.org/cl/107475">new interface</a>.
-</p>
-
-<p><!-- CL 94076 -->
-  Go 1.11 on ARMv7 no longer requires a Linux kernel configured
-  with <code>KUSER_HELPERS</code>. This setting is enabled in default
-  kernel configurations, but is sometimes disabled in stripped-down
-  configurations.
-</p>
-
-<h3 id="wasm">WebAssembly</h3>
-<p>
-  Go 1.11 adds an experimental port to <a href="https://webassembly.org">WebAssembly</a>
-  (<code>js/wasm</code>).
-</p>
-<p>
-  Go programs currently compile to one WebAssembly module that
-  includes the Go runtime for goroutine scheduling, garbage
-  collection, maps, etc.
-  As a result, the resulting size is at minimum around
-  2 MB, or 500 KB compressed. Go programs can call into JavaScript
-  using the new experimental
-  <a href="/pkg/syscall/js/"><code>syscall/js</code></a> package.
-  Binary size and interop with other languages has not yet been a
-  priority but may be addressed in future releases.
-</p>
-<p>
-  As a result of the addition of the new <code>GOOS</code> value
-  "<code>js</code>" and <code>GOARCH</code> value "<code>wasm</code>",
-  Go files named <code>*_js.go</code> or <code>*_wasm.go</code> will
-  now be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
-  tools</a> except when those GOOS/GOARCH values are being used.
-  If you have existing filenames matching those patterns, you will need to rename them.
-</p>
-<p>
-  More information can be found on the
-  <a href="https://golang.org/wiki/WebAssembly">WebAssembly wiki page</a>.
-</p>
-
-<h3 id="riscv">RISC-V GOARCH values reserved</h3>
-<p><!-- CL 106256 -->
-  The main Go compiler does not yet support the RISC-V architecture <!-- is gonna change everything -->
-  but we've reserved the <code>GOARCH</code> values
-  "<code>riscv</code>" and "<code>riscv64</code>", as used by Gccgo,
-  which does support RISC-V. This means that Go files
-  named <code>*_riscv.go</code> will now also
-  be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
-  tools</a> except when those GOOS/GOARCH values are being used.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="modules">Modules, package versioning, and dependency management</h3>
-<p>
-  Go 1.11 adds preliminary support for a <a href="/cmd/go/#hdr-Modules__module_versions__and_more">new concept called “modules,”</a>
-  an alternative to GOPATH with integrated support for versioning and
-  package distribution.
-  Using modules, developers are no longer confined to working inside GOPATH,
-  version dependency information is explicit yet lightweight,
-  and builds are more reliable and reproducible.
-</p>
-
-<p>
-  Module support is considered experimental.
-  Details are likely to change in response to feedback from Go 1.11 users,
-  and we have more tools planned.
-  Although the details of module support may change, projects that convert
-  to modules using Go 1.11 will continue to work with Go 1.12 and later.
-  If you encounter bugs using modules,
-  please <a href="https://golang.org/issue/new">file issues</a>
-  so we can fix them. For more information, see the
-  <a href="/cmd/go#hdr-Modules__module_versions__and_more"><code>go</code> command documentation</a>.
-</p>
-
-<h3 id="importpath">Import path restriction</h3>
-
-<p>
-  Because Go module support assigns special meaning to the
-  <code>@</code> symbol in command line operations,
-  the <code>go</code> command now disallows the use of
-  import paths containing <code>@</code> symbols.
-  Such import paths were never allowed by <code>go</code> <code>get</code>,
-  so this restriction can only affect users building
-  custom GOPATH trees by other means.
-</p>
-
-<h3 id="gopackages">Package loading</h3>
-
-<p>
-  The new package
-  <a href="https://godoc.org/golang.org/x/tools/go/packages"><code>golang.org/x/tools/go/packages</code></a>
-  provides a simple API for locating and loading packages of Go source code.
-  Although not yet part of the standard library, for many tasks it
-  effectively replaces the <a href="/pkg/go/build"><code>go/build</code></a>
-  package, whose API is unable to fully support modules.
-  Because it runs an external query command such as
-  <a href="/cmd/go/#hdr-List_packages"><code>go list</code></a>
-  to obtain information about Go packages, it enables the construction of
-  analysis tools that work equally well with alternative build systems
-  such as <a href="https://bazel.build">Bazel</a>
-  and <a href="https://buckbuild.com">Buck</a>.
-</p>
-
-<h3 id="gocache">Build cache requirement</h3>
-
-<p>
-  Go 1.11 will be the last release to support setting the environment
-  variable <code>GOCACHE=off</code> to disable the
-  <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a>,
-  introduced in Go 1.10.
-  Starting in Go 1.12, the build cache will be required,
-  as a step toward eliminating <code>$GOPATH/pkg</code>.
-  The module and package loading support described above
-  already require that the build cache be enabled.
-  If you have disabled the build cache to avoid problems you encountered,
-  please <a href="https://golang.org/issue/new">file an issue</a> to let us know about them.
-</p>
-
-<h3 id="compiler">Compiler toolchain</h3>
-
-<p><!-- CL 109918 -->
-  More functions are now eligible for inlining by default, including
-  functions that call <code>panic</code>.
-</p>
-
-<p><!-- CL 97375 -->
-  The compiler toolchain now supports column information
-  in <a href="/cmd/compile/#hdr-Compiler_Directives">line
-  directives</a>.
-</p>
-
-<p><!-- CL 106797 -->
-  A new package export data format has been introduced.
-  This should be transparent to end users, except for speeding up
-  build times for large Go projects.
-  If it does cause problems, it can be turned off again by
-  passing <code>-gcflags=all=-iexport=false</code> to
-  the <code>go</code> tool when building a binary.
-</p>
-
-<p><!-- CL 100459 -->
-  The compiler now rejects unused variables declared in a type switch
-  guard, such as <code>x</code> in the following example:
-</p>
-<pre>
-func f(v interface{}) {
-       switch x := v.(type) {
-       }
-}
-</pre>
-<p>
-  This was already rejected by both <code>gccgo</code>
-  and <a href="/pkg/go/types/">go/types</a>.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p><!-- CL 113315 -->
-  The assembler for <code>amd64</code> now accepts AVX512 instructions.
-</p>
-
-<h3 id="debugging">Debugging</h3>
-
-<p><!-- CL 100738, CL 93664 -->
-  The compiler now produces significantly more accurate debug
-  information for optimized binaries, including variable location
-  information, line numbers, and breakpoint locations.
-
-  This should make it possible to debug binaries
-  compiled <em>without</em> <code>-N</code>&nbsp;<code>-l</code>.
-
-  There are still limitations to the quality of the debug information,
-  some of which are fundamental, and some of which will continue to
-  improve with future releases.
-</p>
-
-<p><!-- CL 118276 -->
-  DWARF sections are now compressed by default because of the expanded
-  and more accurate debug information produced by the compiler.
-
-  This is transparent to most ELF tools (such as debuggers on Linux
-  and *BSD) and is supported by the Delve debugger on all platforms,
-  but has limited support in the native tools on macOS and Windows.
-
-  To disable DWARF compression,
-  pass <code>-ldflags=-compressdwarf=false</code> to
-  the <code>go</code> tool when building a binary.
-</p>
-
-<p><!-- CL 109699 -->
-  Go 1.11 adds experimental support for calling Go functions from
-  within a debugger.
-
-  This is useful, for example, to call <code>String</code> methods
-  when paused at a breakpoint.
-
-  This is currently only supported by Delve (version 1.1.0 and up).
-</p>
-
-<h3 id="test">Test</h3>
-
-<p>
-  Since Go 1.10, the <code>go</code>&nbsp;<code>test</code> command runs
-  <code>go</code>&nbsp;<code>vet</code> on the package being tested,
-  to identify problems before running the test. Since <code>vet</code>
-  typechecks the code with <a href="/pkg/go/types/">go/types</a>
-  before running, tests that do not typecheck will now fail.
-
-  In particular, tests that contain an unused variable inside a
-  closure compiled with Go 1.10, because the Go compiler incorrectly
-  accepted them (<a href="https://golang.org/issues/3059">Issue #3059</a>),
-  but will now fail, since <code>go/types</code> correctly reports an
-  "unused variable" error in this case.
-</p>
-
-<p><!-- CL 102696 -->
-  The <code>-memprofile</code> flag
-  to <code>go</code>&nbsp;<code>test</code> now defaults to the
-  "allocs" profile, which records the total bytes allocated since the
-  test began (including garbage-collected bytes).
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<p><!-- CL 108555 -->
-  The <a href="/cmd/vet/"><code>go</code>&nbsp;<code>vet</code></a>
-  command now reports a fatal error when the package under analysis
-  does not typecheck. Previously, a type checking error simply caused
-  a warning to be printed, and <code>vet</code> to exit with status 1.
-</p>
-
-<p><!-- CL 108559 -->
-  Additionally, <a href="/cmd/vet"><code>go</code>&nbsp;<code>vet</code></a>
-  has become more robust when format-checking <code>printf</code> wrappers.
-  Vet now detects the mistake in this example:
-</p>
-
-<pre>
-func wrapper(s string, args ...interface{}) {
-       fmt.Printf(s, args...)
-}
-
-func main() {
-       wrapper("%s", 42)
-}
-</pre>
-
-<h3 id="trace">Trace</h3>
-
-<p><!-- CL 63274 -->
-  With the new <code>runtime/trace</code>
-  package's <a href="/pkg/runtime/trace/#hdr-User_annotation">user
-  annotation API</a>, users can record application-level information
-  in execution traces and create groups of related goroutines.
-  The <code>go</code>&nbsp;<code>tool</code>&nbsp;<code>trace</code>
-  command visualizes this information in the trace view and the new
-  user task/region analysis page.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-Since Go 1.10, cgo has translated some C pointer types to the Go
-type <code>uintptr</code>. These types include
-the <code>CFTypeRef</code> hierarchy in Darwin's CoreFoundation
-framework and the <code>jobject</code> hierarchy in Java's JNI
-interface. In Go 1.11, several improvements have been made to the code
-that detects these types. Code that uses these types may need some
-updating. See the <a href="go1.10.html#cgo">Go 1.10 release notes</a> for
-details. <!-- CL 126275, CL 127156, CL 122217, CL 122575, CL 123177 -->
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p><!-- CL 126656 -->
-  The environment variable <code>GOFLAGS</code> may now be used
-  to set default flags for the <code>go</code> command.
-  This is useful in certain situations.
-  Linking can be noticeably slower on underpowered systems due to DWARF,
-  and users may want to set <code>-ldflags=-w</code> by default.
-  For modules, some users and CI systems will want vendoring always,
-  so they should set <code>-mod=vendor</code> by default.
-  For more information, see the <a href="/cmd/go/#hdr-Environment_variables"><code>go</code>
-  command documentation</a>.
-</p>
-
-<h3 id="godoc">Godoc</h3>
-
-<p>
-  Go 1.11 will be the last release to support <code>godoc</code>'s command-line interface.
-  In future releases, <code>godoc</code> will only be a web server. Users should use
-  <code>go</code> <code>doc</code> for command-line help output instead.
-</p>
-
-<p><!-- CL 85396, CL 124495 -->
-  The <code>godoc</code> web server now shows which version of Go introduced
-  new API features. The initial Go version of types, funcs, and methods are shown
-  right-aligned. For example, see <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a>, with "1.11"
-  on the right side. For struct fields, inline comments are added when the struct field was
-  added in a Go version other than when the type itself was introduced.
-  For a struct field example, see
-  <a href="/pkg/net/http/httptrace/#ClientTrace.Got1xxResponse"><code>ClientTrace.Got1xxResponse</code></a>.
-</p>
-
-<h3 id="gofmt">Gofmt</h3>
-
-<p>
-  One minor detail of the default formatting of Go source code has changed.
-  When formatting expression lists with inline comments, the comments were
-  aligned according to a heuristic.
-  However, in some cases the alignment would be split up too easily, or
-  introduce too much whitespace.
-  The heuristic has been changed to behave better for human-written code.
-</p>
-
-<p>
-  Note that these kinds of minor updates to gofmt are expected from time to
-  time.
-  In general, systems that need consistent formatting of Go source code should
-  use a specific version of the <code>gofmt</code> binary.
-  See the <a href="/pkg/go/format/">go/format</a> package documentation for more
-  information.
-</p>
-
-<h3 id="run">Run</h3>
-
-<p>
-  <!-- CL 109341 -->
-  The <a href="/cmd/go/"><code>go</code>&nbsp;<code>run</code></a>
-  command now allows a single import path, a directory name or a
-  pattern matching a single package.
-  This allows <code>go</code>&nbsp;<code>run</code>&nbsp;<code>pkg</code> or <code>go</code>&nbsp;<code>run</code>&nbsp;<code>dir</code>, most importantly <code>go</code>&nbsp;<code>run</code>&nbsp;<code>.</code>
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 85887 -->
-  The runtime now uses a sparse heap layout so there is no longer a
-  limit to the size of the Go heap (previously, the limit was 512GiB).
-  This also fixes rare "address space conflict" failures in mixed Go/C
-  binaries or binaries compiled with <code>-race</code>.
-</p>
-
-<p><!-- CL 108679, CL 106156 -->
-  On macOS and iOS, the runtime now uses <code>libSystem.dylib</code> instead of
-  calling the kernel directly. This should make Go binaries more
-  compatible with future versions of macOS and iOS.
-  The <a href="/pkg/syscall">syscall</a> package still makes direct
-  system calls; fixing this is planned for a future release.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise
-statements about performance are difficult to make.  Most programs
-should run a bit faster, due to better generated code and
-optimizations in the core library.
-</p>
-
-<p><!-- CL 74851 -->
-There were multiple performance changes to the <code>math/big</code>
-package as well as many changes across the tree specific to <code>GOARCH=arm64</code>.
-</p>
-
-<h3 id="performance-compiler">Compiler toolchain</h3>
-
-<p><!-- CL 110055 -->
-  The compiler now optimizes map clearing operations of the form:
-</p>
-<pre>
-for k := range m {
-       delete(m, k)
-}
-</pre>
-
-<p><!-- CL 109517 -->
-  The compiler now optimizes slice extension of the form
-  <code>append(s,</code>&nbsp;<code>make([]T,</code>&nbsp;<code>n)...)</code>.
-</p>
-
-<p><!-- CL 100277, CL 105635, CL 109776 -->
-  The compiler now performs significantly more aggressive bounds-check
-  and branch elimination. Notably, it now recognizes transitive
-  relations, so if <code>i&lt;j</code> and <code>j&lt;len(s)</code>,
-  it can use these facts to eliminate the bounds check
-  for <code>s[i]</code>. It also understands simple arithmetic such
-  as <code>s[i-10]</code> and can recognize more inductive cases in
-  loops. Furthermore, the compiler now uses bounds information to more
-  aggressively optimize shift operations.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<p>
-  All of the changes to the standard library are minor.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<!-- CL 115095: https://golang.org/cl/115095: yes (`go test pkg` now always builds pkg even if there are no test files): cmd/go: output coverage report even if there are no test files -->
-<!-- CL 110395: https://golang.org/cl/110395: cmd/go, cmd/compile: use Windows response files to avoid arg length limits -->
-<!-- CL 112436: https://golang.org/cl/112436: cmd/pprof: add readline support similar to upstream -->
-
-
-<dl id="crypto"><dt><a href="/pkg/crypto/">crypto</a></dt>
-  <dd>
-    <p><!-- CL 64451 -->
-      Certain crypto operations, including
-      <a href="/pkg/crypto/ecdsa/#Sign"><code>ecdsa.Sign</code></a>,
-      <a href="/pkg/crypto/rsa/#EncryptPKCS1v15"><code>rsa.EncryptPKCS1v15</code></a> and
-      <a href="/pkg/crypto/rsa/#GenerateKey"><code>rsa.GenerateKey</code></a>,
-      now randomly read an extra byte of randomness to ensure tests don't rely on internal behavior.
-    </p>
-
-</dl><!-- crypto -->
-
-<dl id="crypto/cipher"><dt><a href="/pkg/crypto/cipher/">crypto/cipher</a></dt>
-  <dd>
-    <p><!-- CL 48510, CL 116435 -->
-      The new function <a href="/pkg/crypto/cipher/#NewGCMWithTagSize"><code>NewGCMWithTagSize</code></a>
-      implements Galois Counter Mode with non-standard tag lengths for compatibility with existing cryptosystems.
-    </p>
-
-</dl><!-- crypto/cipher -->
-
-<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
-  <dd>
-    <p><!-- CL 103876 -->
-      <a href="/pkg/crypto/rsa/#PublicKey"><code>PublicKey</code></a> now implements a
-      <a href="/pkg/crypto/rsa/#PublicKey.Size"><code>Size</code></a> method that
-      returns the modulus size in bytes.
-    </p>
-
-</dl><!-- crypto/rsa -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 85115 -->
-      <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>'s new
-      <a href="/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial"><code>ExportKeyingMaterial</code></a>
-      method allows exporting keying material bound to the
-      connection according to RFC 5705.
-    </p>
-
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 123355, CL 123695 -->
-      The deprecated, legacy behavior of treating the <code>CommonName</code> field as
-      a hostname when no Subject Alternative Names are present is now disabled when the CN is not a
-      valid hostname.
-      The <code>CommonName</code> can be completely ignored by adding the experimental value
-      <code>x509ignoreCN=1</code> to the <code>GODEBUG</code> environment variable.
-      When the CN is ignored, certificates without SANs validate under chains with name constraints
-      instead of returning <code>NameConstraintsWithoutSANs</code>.
-    </p>
-
-    <p><!-- CL 113475 -->
-      Extended key usage restrictions are again checked only if they appear in the <code>KeyUsages</code>
-      field of <a href="/pkg/crypto/x509/#VerifyOptions"><code>VerifyOptions</code></a>, instead of always being checked.
-      This matches the behavior of Go 1.9 and earlier.
-    </p>
-
-    <p><!-- CL 102699 -->
-      The value returned by <a href="/pkg/crypto/x509/#SystemCertPool"><code>SystemCertPool</code></a>
-      is now cached and might not reflect system changes between invocations.
-    </p>
-
-</dl><!-- crypto/x509 -->
-
-<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
-  <dd>
-    <p><!-- CL 112115 -->
-      More <a href="/pkg/debug/elf/#ELFOSABI_NONE"><code>ELFOSABI</code></a>
-      and <a href="/pkg/debug/elf/#EM_NONE"><code>EM</code></a>
-      constants have been added.
-    </p>
-
-</dl><!-- debug/elf -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 110561 -->
-      <code>Marshal</code> and <code><a href="/pkg/encoding/asn1/#Unmarshal">Unmarshal</a></code>
-      now support "private" class annotations for fields.
-    </p>
-
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
-  <dd>
-    <p><!-- CL 112516 -->
-      The decoder now consistently
-      returns <code>io.ErrUnexpectedEOF</code> for an incomplete
-      chunk. Previously it would return <code>io.EOF</code> in some
-      cases.
-    </p>
-
-</dl><!-- encoding/base32 -->
-
-<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
-  <dd>
-    <p><!-- CL 99696 -->
-      The <code>Reader</code> now rejects attempts to set
-      the <a href="/pkg/encoding/csv/#Reader.Comma"><code>Comma</code></a>
-      field to a double-quote character, as double-quote characters
-      already have a special meaning in CSV.
-    </p>
-
-</dl><!-- encoding/csv -->
-
-<!-- CL 100235 was reverted -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 121815 -->
-      The package has changed its behavior when a typed interface
-      value is passed to an implicit escaper function. Previously such
-      a value was written out as (an escaped form)
-      of <code>&lt;nil&gt;</code>. Now such values are ignored, just
-      as an untyped <code>nil</code> value is (and always has been)
-      ignored.
-    </p>
-
-</dl><!-- html/template -->
-
-<dl id="image/gif"><dt><a href="/pkg/image/gif/">image/gif</a></dt>
-  <dd>
-    <p><!-- CL 93076 -->
-      Non-looping animated GIFs are now supported. They are denoted by having a
-      <code><a href="/pkg/image/gif/#GIF.LoopCount">LoopCount</a></code> of -1.
-    </p>
-
-</dl><!-- image/gif -->
-
-<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
-  <dd>
-    <p><!-- CL 105675 -->
-      The <code><a href="/pkg/io/ioutil/#TempFile">TempFile</a></code>
-      function now supports specifying where the random characters in
-      the filename are placed. If the <code>prefix</code> argument
-      includes a "<code>*</code>", the random string replaces the
-      "<code>*</code>". For example, a <code>prefix</code> argument of "<code>myname.*.bat</code>" will
-      result in a random filename such as
-      "<code>myname.123456.bat</code>". If no "<code>*</code>" is
-      included the old behavior is retained, and the random digits are
-      appended to the end.
-    </p>
-
-</dl><!-- io/ioutil -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-
-    <p><!-- CL 108996 -->
-      <a href="/pkg/math/big/#Int.ModInverse"><code>ModInverse</code></a> now returns nil when g and n are not relatively prime. The result was previously undefined.
-    </p>
-
-</dl><!-- math/big -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p><!-- CL 121055 -->
-      The handling of form-data with missing/empty file names has been
-      restored to the behavior in Go 1.9: in the
-      <a href="/pkg/mime/multipart/#Form"><code>Form</code></a> for
-      the form-data part the value is available in
-      the <code>Value</code> field rather than the <code>File</code>
-      field. In Go releases 1.10 through 1.10.3 a form-data part with
-      a missing/empty file name and a non-empty "Content-Type" field
-      was stored in the <code>File</code> field.  This change was a
-      mistake in 1.10 and has been reverted to the 1.9 behavior.
-    </p>
-
-</dl><!-- mime/multipart -->
-
-<dl id="mime/quotedprintable"><dt><a href="/pkg/mime/quotedprintable/">mime/quotedprintable</a></dt>
-  <dd>
-    <p><!-- CL 121095 -->
-      To support invalid input found in the wild, the package now
-      permits non-ASCII bytes but does not validate their encoding.
-    </p>
-
-</dl><!-- mime/quotedprintable -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 72810 -->
-      The new <a href="/pkg/net/#ListenConfig"><code>ListenConfig</code></a> type and the new
-      <a href="/pkg/net/#Dialer.Control"><code>Dialer.Control</code></a> field permit
-      setting socket options before accepting and creating connections, respectively.
-    </p>
-
-    <p><!-- CL 76391 -->
-      The <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a> <code>Read</code>
-      and <code>Write</code> methods now work correctly on Windows.
-    </p>
-
-    <p><!-- CL 107715 -->
-      The <code>net</code> package now automatically uses the
-      <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a>
-      on Linux when copying data between TCP connections in
-      <a href="/pkg/net/#TCPConn.ReadFrom"><code>TCPConn.ReadFrom</code></a>, as called by
-      <a href="/pkg/io/#Copy"><code>io.Copy</code></a>. The result is faster, more efficient TCP proxying.
-    </p>
-
-    <p><!-- CL 108297 -->
-      The <a href="/pkg/net/#TCPConn.File"><code>TCPConn.File</code></a>,
-      <a href="/pkg/net/#UDPConn.File"><code>UDPConn.File</code></a>,
-      <a href="/pkg/net/#UnixCOnn.File"><code>UnixConn.File</code></a>,
-      and <a href="/pkg/net/#IPConn.File"><code>IPConn.File</code></a>
-      methods no longer put the returned <code>*os.File</code> into
-      blocking mode.
-    </p>
-
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 71272 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> type has a
-      new <a href="/pkg/net/http/#Transport.MaxConnsPerHost"><code>MaxConnsPerHost</code></a>
-      option that permits limiting the maximum number of connections
-      per host.
-    </p>
-
-    <p><!-- CL 79919 -->
-      The <a href="/pkg/net/http/#Cookie"><code>Cookie</code></a> type has a new
-      <a href="/pkg/net/http/#Cookie.SameSite"><code>SameSite</code></a> field
-      (of new type also named
-      <a href="/pkg/net/http/#SameSite"><code>SameSite</code></a>) to represent the new cookie attribute recently supported by most browsers.
-      The <code>net/http</code>'s <code>Transport</code> does not use the <code>SameSite</code>
-      attribute itself, but the package supports parsing and serializing the
-      attribute for browsers to use.
-    </p>
-
-    <p><!-- CL 81778 -->
-      It is no longer allowed to reuse a <a href="/pkg/net/http/#Server"><code>Server</code></a>
-      after a call to
-      <a href="/pkg/net/http/#Server.Shutdown"><code>Shutdown</code></a> or
-      <a href="/pkg/net/http/#Server.Close"><code>Close</code></a>. It was never officially supported
-      in the past and had often surprising behavior. Now, all future calls to the server's <code>Serve</code>
-      methods will return errors after a shutdown or close.
-    </p>
-
-    <!-- CL 89275 was reverted before Go 1.11 -->
-
-    <p><!-- CL 93296 -->
-      The constant <code>StatusMisdirectedRequest</code> is now defined for HTTP status code 421.
-    </p>
-
-    <p><!-- CL 123875 -->
-      The HTTP server will no longer cancel contexts or send on
-      <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-      channels upon receiving pipelined HTTP/1.1 requests. Browsers do
-      not use HTTP pipelining, but some clients (such as
-      Debian's <code>apt</code>) may be configured to do so.
-    </p>
-
-    <p><!-- CL 115255 -->
-      <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>, which is used by the
-      <a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>, now
-      supports CIDR notation and ports in the <code>NO_PROXY</code> environment variable.
-    </p>
-
-</dl><!-- net/http -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 77410 -->
-      The
-      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      has a new
-      <a href="/pkg/net/http/httputil/#ReverseProxy.ErrorHandler"><code>ErrorHandler</code></a>
-      option to permit changing how errors are handled.
-    </p>
-
-    <p><!-- CL 115135 -->
-      The <code>ReverseProxy</code> now also passes
-      "<code>TE:</code>&nbsp;<code>trailers</code>" request headers
-      through to the backend, as required by the gRPC protocol.
-    </p>
-
-</dl><!-- net/http/httputil -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 78835 -->
-      The new <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a> function
-      returns the default root directory to use for user-specific cached data.
-    </p>
-
-    <p><!-- CL 94856 -->
-      The new <a href="/pkg/os/#ModeIrregular"><code>ModeIrregular</code></a>
-      is a <a href="/pkg/os/#FileMode"><code>FileMode</code></a> bit to represent
-      that a file is not a regular file, but nothing else is known about it, or that
-      it's not a socket, device, named pipe, symlink, or other file type for which
-      Go has a defined mode bit.
-    </p>
-
-    <p><!-- CL 99337 -->
-      <a href="/pkg/os/#Symlink"><code>Symlink</code></a> now works
-      for unprivileged users on Windows 10 on machines with Developer
-      Mode enabled.
-    </p>
-
-    <p><!-- CL 100077 -->
-      When a non-blocking descriptor is passed
-      to <a href="/pkg/os#NewFile"><code>NewFile</code></a>, the
-      resulting <code>*File</code> will be kept in non-blocking
-      mode. This means that I/O for that <code>*File</code> will use
-      the runtime poller rather than a separate thread, and that
-      the <a href="/pkg/os/#File.SetDeadline"><code>SetDeadline</code></a>
-      methods will work.
-    </p>
-
-</dl><!-- os -->
-
-<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
-  <dd>
-    <p><!-- CL 108376 -->
-      The new <a href="/pkg/os/signal/#Ignored"><code>Ignored</code></a> function reports
-      whether a signal is currently ignored.
-    </p>
-
-</dl><!-- os/signal -->
-
-<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
-  <dd>
-    <p><!-- CL 92456 -->
-      The <code>os/user</code> package can now be built in pure Go
-      mode using the build tag "<code>osusergo</code>",
-      independent of the use of the environment
-      variable <code>CGO_ENABLED=0</code>. Previously the only way to use
-      the package's pure Go implementation was to disable <code>cgo</code>
-      support across the entire program.
-    </p>
-
-</dl><!-- os/user -->
-
-<!-- CL 101715 was reverted -->
-
-<dl id="pkg-runtime"><dt id="runtime-again"><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-
-    <p><!-- CL 70993 -->
-      Setting the <code>GODEBUG=tracebackancestors=<em>N</em></code>
-      environment variable now extends tracebacks with the stacks at
-      which goroutines were created, where <em>N</em> limits the
-      number of ancestor goroutines to report.
-    </p>
-
-</dl><!-- runtime -->
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 102696 -->
-      This release adds a new "allocs" profile type that profiles
-      total number of bytes allocated since the program began
-      (including garbage-collected bytes). This is identical to the
-      existing "heap" profile viewed in <code>-alloc_space</code> mode.
-      Now <code>go test -memprofile=...</code> reports an "allocs" profile
-      instead of "heap" profile.
-    </p>
-
-</dl><!-- runtime/pprof -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 87095 -->
-      The mutex profile now includes reader/writer contention
-      for <a href="/pkg/sync/#RWMutex"><code>RWMutex</code></a>.
-      Writer/writer contention was already included in the mutex
-      profile.
-    </p>
-
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 106275 -->
-      On Windows, several fields were changed from <code>uintptr</code> to a new
-      <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Pointer"><code>Pointer</code></a>
-      type to avoid problems with Go's garbage collector. The same change was made
-      to the <a href="https://godoc.org/golang.org/x/sys/windows"><code>golang.org/x/sys/windows</code></a>
-      package. For any code affected, users should first migrate away from the <code>syscall</code>
-      package to the <code>golang.org/x/sys/windows</code> package, and then change
-      to using the <code>Pointer</code>, while obeying the
-      <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code> conversion rules</a>.
-    </p>
-
-    <p><!-- CL 118658 -->
-      On Linux, the <code>flags</code> parameter to
-      <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Faccessat"><code>Faccessat</code></a>
-      is now implemented just as in glibc. In earlier Go releases the
-      flags parameter was ignored.
-    </p>
-
-    <p><!-- CL 118658 -->
-      On Linux, the <code>flags</code> parameter to
-      <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Fchmodat"><code>Fchmodat</code></a>
-      is now validated. Linux's <code>fchmodat</code> doesn't support the <code>flags</code> parameter
-      so we now mimic glibc's behavior and return an error if it's non-zero.
-    </p>
-
-</dl><!-- syscall -->
-
-<dl id="text/scanner"><dt><a href="/pkg/text/scanner/">text/scanner</a></dt>
-  <dd>
-    <p><!-- CL 112037 -->
-      The <a href="/pkg/text/scanner/#Scanner.Scan"><code>Scanner.Scan</code></a> method now returns
-      the <a href="/pkg/text/scanner/#RawString"><code>RawString</code></a> token
-      instead of <a href="/pkg/text/scanner/#String"><code>String</code></a>
-      for raw string literals.
-    </p>
-
-</dl><!-- text/scanner -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 84480 -->
-      Modifying template variables via assignments is now permitted via the <code>=</code> token:
-    </p>
-    <pre>
-  {{"{{"}} $v := "init" {{"}}"}}
-  {{"{{"}} if true {{"}}"}}
-    {{"{{"}} $v = "changed" {{"}}"}}
-  {{"{{"}} end {{"}}"}}
-  v: {{"{{"}} $v {{"}}"}} {{"{{"}}/* "changed" */{{"}}"}}</pre>
-
-    <p><!-- CL 95215 -->
-      In previous versions untyped <code>nil</code> values passed to
-      template functions were ignored. They are now passed as normal
-      arguments.
-    </p>
-
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 98157 -->
-         Parsing of timezones denoted by sign and offset is now
-         supported. In previous versions, numeric timezone names
-         (such as <code>+03</code>) were not considered valid, and only
-         three-letter abbreviations (such as <code>MST</code>) were accepted
-         when expecting a timezone name.
-    </p>
-</dl><!-- time -->

diff --git a/doc/go1.12.html b/doc/go1.12.html
deleted file mode 100644 (file)
index a8b0c87..0000000
--- a/doc/go1.12.html
+++ /dev/null
@@ -1,949 +0,0 @@
-<!--{
-        "Title": "Go 1.12 Release Notes",
-        "Path":  "/doc/go1.12",
-        "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.12</h2>
-
-<p>
-  The latest Go release, version 1.12, arrives six months after <a href="go1.11">Go 1.11</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language specification.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p><!-- CL 138675 -->
-  The race detector is now supported on <code>linux/arm64</code>.
-</p>
-
-<p id="freebsd">
-  Go 1.12 is the last release that is supported on FreeBSD 10.x, which has
-  already reached end-of-life. Go 1.13 will require FreeBSD 11.2+ or FreeBSD
-  12.0+.
-  FreeBSD 12.0+ requires a kernel with the COMPAT_FREEBSD11 option set (this is the default).
-</p>
-
-<p><!-- CL 146898 -->
-  cgo is now supported on <code>linux/ppc64</code>.
-</p>
-
-<p id="hurd"><!-- CL 146023 -->
-  <code>hurd</code> is now a recognized value for <code>GOOS</code>, reserved
-  for the GNU/Hurd system for use with <code>gccgo</code>.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p>
-  Go's new <code>windows/arm</code> port supports running Go on Windows 10
-  IoT Core on 32-bit ARM chips such as the Raspberry Pi 3.
-</p>
-
-<h3 id="aix">AIX</h3>
-
-<p>
-  Go now supports AIX 7.2 and later on POWER8 architectures (<code>aix/ppc64</code>). External linking, cgo, pprof and the race detector aren't yet supported.
-</p>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  Go 1.12 is the last release that will run on macOS 10.10 Yosemite.
-  Go 1.13 will require macOS 10.11 El Capitan or later.
-</p>
-
-<p><!-- CL 141639 -->
-  <code>libSystem</code> is now used when making syscalls on Darwin,
-  ensuring forward-compatibility with future versions of macOS and iOS.
-  <!-- CL 153338 -->
-  The switch to <code>libSystem</code> triggered additional App Store
-  checks for private API usage. Since it is considered private,
-  <code>syscall.Getdirentries</code> now always fails with
-  <code>ENOSYS</code> on iOS.
-  Additionally, <a href="/pkg/syscall/#Setrlimit"><code>syscall.Setrlimit</code></a>
-  reports <code>invalid</code> <code>argument</code> in places where it historically
-  succeeded. These consequences are not specific to Go and users should expect
-  behavioral parity with <code>libSystem</code>'s implementation going forward.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="vet"><code>go tool vet</code> no longer supported</h3>
-
-<p>
-  The <code>go vet</code> command has been rewritten to serve as the
-  base for a range of different source code analysis tools. See
-  the <a href="https://godoc.org/golang.org/x/tools/go/analysis">golang.org/x/tools/go/analysis</a>
-  package for details. A side-effect is that <code>go tool vet</code>
-  is no longer supported. External tools that use <code>go tool
-  vet</code> must be changed to use <code>go
-  vet</code>. Using <code>go vet</code> instead of <code>go tool
-  vet</code> should work with all supported versions of Go.
-</p>
-
-<p>
-  As part of this change, the experimental <code>-shadow</code> option
-  is no longer available with <code>go vet</code>. Checking for
-  variable shadowing may now be done using
-<pre>
-go get -u golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
-go vet -vettool=$(which shadow)
-</pre>
-</p>
-
-<h3 id="tour">Tour</h3>
-
-<p> <!-- CL 152657 -->
-The Go tour is no longer included in the main binary distribution. To
-run the tour locally, instead of running <code>go</code> <code>tool</code> <code>tour</code>,
-manually install it:
-<pre>
-go get -u golang.org/x/tour
-tour
-</pre>
-</p>
-
-<h3 id="gocache">Build cache requirement</h3>
-
-<p>
-  The <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a> is now
-  required as a step toward eliminating
-  <code>$GOPATH/pkg</code>. Setting the environment variable
-  <code>GOCACHE=off</code> will cause <code>go</code> commands that write to the
-  cache to fail.
-</p>
-
-<h3 id="binary-only">Binary-only packages</h3>
-
-<p>
-  Go 1.12 is the last release that will support binary-only packages.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-       Go 1.12 will translate the C type <code>EGLDisplay</code> to the Go type <code>uintptr</code>.
-       This change is similar to how Go 1.10 and newer treats Darwin's CoreFoundation
-       and Java's JNI types. See the
-       <a href="/cmd/cgo/#hdr-Special_cases">cgo documentation</a>
-       for more information.
-</p>
-
-<p><!-- CL 152657 -->
-  Mangled C names are no longer accepted in packages that use Cgo. Use the Cgo
-  names instead. For example, use the documented cgo name <code>C.char</code>
-  rather than the mangled name <code>_Ctype_char</code> that cgo generates.
-</p>
-
-<h3 id="modules">Modules</h3>
-
-<p><!-- CL 148517 -->
-  When <code>GO111MODULE</code> is set to <code>on</code>, the <code>go</code>
-  command now supports module-aware operations outside of a module directory,
-  provided that those operations do not need to resolve import paths relative to
-  the current directory or explicitly edit the <code>go.mod</code> file.
-  Commands such as <code>go</code> <code>get</code>,
-  <code>go</code> <code>list</code>, and
-  <code>go</code> <code>mod</code> <code>download</code> behave as if in a
-  module with initially-empty requirements.
-  In this mode, <code>go</code> <code>env</code> <code>GOMOD</code> reports
-  the system's null device (<code>/dev/null</code> or <code>NUL</code>).
-</p>
-
-<p><!-- CL 146382 -->
-  <code>go</code> commands that download and extract modules are now safe to
-  invoke concurrently.
-  The module cache (<code>GOPATH/pkg/mod</code>) must reside in a filesystem that
-  supports file locking.
-</p>
-
-<p><!-- CL 147282, 147281 -->
-  The <code>go</code> directive in a <code>go.mod</code> file now indicates the
-  version of the language used by the files within that module.
-  It will be set to the current release
-  (<code>go</code> <code>1.12</code>) if no existing version is
-  present.
-  If the <code>go</code> directive for a module specifies a
-  version <em>newer</em> than the toolchain in use, the <code>go</code> command
-  will attempt to build the packages regardless, and will note the mismatch only if
-  that build fails.
-</p>
-
-<p><!-- CL 147282, 147281 -->
-  This changed use of the <code>go</code> directive means that if you
-  use Go 1.12 to build a module, thus recording <code>go 1.12</code>
-  in the <code>go.mod</code> file, you will get an error when
-  attempting to build the same module with Go 1.11 through Go 1.11.3.
-  Go 1.11.4 or later will work fine, as will releases older than Go 1.11.
-  If you must use Go 1.11 through 1.11.3, you can avoid the problem by
-  setting the language version to 1.11, using the Go 1.12 go tool,
-  via <code>go mod edit -go=1.11</code>.
-</p>
-
-<p><!-- CL 152739 -->
-  When an import cannot be resolved using the active modules,
-  the <code>go</code> command will now try to use the modules mentioned in the
-  main module's <code>replace</code> directives before consulting the module
-  cache and the usual network sources.
-  If a matching replacement is found but the <code>replace</code> directive does
-  not specify a version, the <code>go</code> command uses a pseudo-version
-  derived from the zero <code>time.Time</code> (such
-  as <code>v0.0.0-00010101000000-000000000000</code>).
-</p>
-
-<h3 id="compiler">Compiler toolchain</h3>
-
-<p><!-- CL 134155, 134156 -->
-  The compiler's live variable analysis has improved. This may mean that
-  finalizers will be executed sooner in this release than in previous
-  releases. If that is a problem, consider the appropriate addition of a
-  <a href="/pkg/runtime/#KeepAlive"><code>runtime.KeepAlive</code></a> call.
-</p>
-
-<p><!-- CL 147361 -->
-  More functions are now eligible for inlining by default, including
-  functions that do nothing but call another function.
-  This extra inlining makes it additionally important to use
-  <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-  instead of iterating over the result of
-  <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a> directly.
-<pre>
-// Old code which no longer works correctly (it will miss inlined call frames).
-var pcs [10]uintptr
-n := runtime.Callers(1, pcs[:])
-for _, pc := range pcs[:n] {
-       f := runtime.FuncForPC(pc)
-       if f != nil {
-               fmt.Println(f.Name())
-       }
-}
-</pre>
-<pre>
-// New code which will work correctly.
-var pcs [10]uintptr
-n := runtime.Callers(1, pcs[:])
-frames := runtime.CallersFrames(pcs[:n])
-for {
-       frame, more := frames.Next()
-       fmt.Println(frame.Function)
-       if !more {
-               break
-       }
-}
-</pre>
-</p>
-
-<p><!-- CL 153477 -->
-  Wrappers generated by the compiler to implement method expressions
-  are no longer reported
-  by <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-  and <a href="/pkg/runtime/#Stack"><code>runtime.Stack</code></a>. They
-  are also not printed in panic stack traces.
-
-  This change aligns the <code>gc</code> toolchain to match
-  the <code>gccgo</code> toolchain, which already elided such wrappers
-  from stack traces.
-
-  Clients of these APIs might need to adjust for the missing
-  frames. For code that must interoperate between 1.11 and 1.12
-  releases, you can replace the method expression <code>x.M</code>
-  with the function literal <code>func (...) { x.M(...) } </code>.
-</p>
-
-<p><!-- CL 144340 -->
-  The compiler now accepts a <code>-lang</code> flag to set the Go language
-  version to use. For example, <code>-lang=go1.8</code> causes the compiler to
-  emit an error if the program uses type aliases, which were added in Go 1.9.
-  Language changes made before Go 1.12 are not consistently enforced.
-</p>
-
-<p><!-- CL 147160 -->
-  The compiler toolchain now uses different conventions to call Go
-  functions and assembly functions. This should be invisible to users,
-  except for calls that simultaneously cross between Go and
-  assembly <em>and</em> cross a package boundary. If linking results
-  in an error like "relocation target not defined for ABIInternal (but
-  is defined for ABI0)", please refer to the
-  <a href="https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md#compatibility">compatibility section</a>
-  of the ABI design document.
-</p>
-
-<p><!-- CL 145179 -->
-  There have been many improvements to the DWARF debug information
-  produced by the compiler, including improvements to argument
-  printing and variable location information.
-</p>
-
-<p><!-- CL 61511 -->
-  Go programs now also maintain stack frame pointers on <code>linux/arm64</code>
-  for the benefit of profiling tools like <code>perf</code>. The frame pointer
-  maintenance has a small run-time overhead that varies but averages around 3%.
-  To build a toolchain that does not use frame pointers, set
-  <code>GOEXPERIMENT=noframepointer</code> when running <code>make.bash</code>.
-</p>
-
-<p><!-- CL 142717 -->
-  The obsolete "safe" compiler mode (enabled by the <code>-u</code> gcflag) has been removed.
-</p>
-
-<h3 id="godoc"><code>godoc</code> and <code>go</code> <code>doc</code></h3>
-
-<p>
-  In Go 1.12, <code>godoc</code> no longer has a command-line interface and
-  is only a web server. Users should use <code>go</code> <code>doc</code>
-  for command-line help output instead. Go 1.12 is the last release that will
-  include the <code>godoc</code> webserver; in Go 1.13 it will be available
-  via <code>go</code> <code>get</code>.
-</p>
-
-<p><!-- CL 141977 -->
-  <code>go</code> <code>doc</code> now supports the <code>-all</code> flag,
-  which will cause it to print all exported APIs and their documentation,
-  as the <code>godoc</code> command line used to do.
-</p>
-
-<p><!-- CL 140959 -->
-  <code>go</code> <code>doc</code> also now includes the <code>-src</code> flag,
-  which will show the target's source code.
-</p>
-
-<h3 id="trace">Trace</h3>
-
-<p><!-- CL 60790 -->
-  The trace tool now supports plotting mutator utilization curves,
-  including cross-references to the execution trace. These are useful
-  for analyzing the impact of the garbage collector on application
-  latency and throughput.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p><!-- CL 147218 -->
-  On <code>arm64</code>, the platform register was renamed from
-  <code>R18</code> to <code>R18_PLATFORM</code> to prevent accidental
-  use, as the OS could choose to reserve this register.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 138959 -->
-  Go 1.12 significantly improves the performance of sweeping when a
-  large fraction of the heap remains live. This reduces allocation
-  latency immediately following a garbage collection.
-</p>
-
-<p><!-- CL 139719 -->
-  The Go runtime now releases memory back to the operating system more
-  aggressively, particularly in response to large allocations that
-  can't reuse existing heap space.
-</p>
-
-<p><!-- CL 146342, CL 146340, CL 146345, CL 146339, CL 146343, CL 146337, CL 146341, CL 146338 -->
-  The Go runtime's timer and deadline code is faster and scales better
-  with higher numbers of CPUs. In particular, this improves the
-  performance of manipulating network connection deadlines.
-</p>
-
-<p><!-- CL 135395 -->
-  On Linux, the runtime now uses <code>MADV_FREE</code> to release unused
-  memory. This is more efficient but may result in higher reported
-  RSS. The kernel will reclaim the unused data when it is needed.
-  To revert to the Go 1.11 behavior (<code>MADV_DONTNEED</code>), set the
-  environment variable <code>GODEBUG=madvdontneed=1</code>.
-</p>
-
-<p><!-- CL 149578 -->
-  Adding cpu.<em>extension</em>=off to the
-  <a href="/doc/diagnostics.html#godebug">GODEBUG</a> environment
-  variable now disables the use of optional CPU instruction
-  set extensions in the standard library and runtime. This is not
-  yet supported on Windows.
-</p>
-
-<p><!-- CL 158337 -->
-  Go 1.12 improves the accuracy of memory profiles by fixing
-  overcounting of large heap allocations.
-</p>
-
-<p><!-- CL 159717 -->
-  Tracebacks, <code>runtime.Caller</code>,
-  and <code>runtime.Callers</code> no longer include
-  compiler-generated initialization functions.  Doing a traceback
-  during the initialization of a global variable will now show a
-  function named <code>PKG.init.ializers</code>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="tls_1_3">TLS 1.3</h3>
-
-<p>
-  Go 1.12 adds opt-in support for TLS 1.3 in the <code>crypto/tls</code> package as
-  specified by <a href="https://www.rfc-editor.org/info/rfc8446">RFC 8446</a>. It can
-  be enabled by adding the value <code>tls13=1</code> to the <code>GODEBUG</code>
-  environment variable. It will be enabled by default in Go 1.13.
-</p>
-
-<p>
-  To negotiate TLS 1.3, make sure you do not set an explicit <code>MaxVersion</code> in
-  <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> and run your program with
-  the environment variable <code>GODEBUG=tls13=1</code> set.
-</p>
-
-<p>
-  All TLS 1.2 features except <code>TLSUnique</code> in
-  <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-  and renegotiation are available in TLS 1.3 and provide equivalent or
-  better security and performance. Note that even though TLS 1.3 is backwards
-  compatible with previous versions, certain legacy systems might not work
-  correctly when attempting to negotiate it. RSA certificate keys too small
-  to be secure (including 512-bit keys) will not work with TLS 1.3.
-</p>
-
-<p>
-  TLS 1.3 cipher suites are not configurable. All supported cipher suites are
-  safe, and if <code>PreferServerCipherSuites</code> is set in
-  <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> the preference order
-  is based on the available hardware.
-</p>
-
-<p>
-  Early data (also called "0-RTT mode") is not currently supported as a
-  client or server. Additionally, a Go 1.12 server does not support skipping
-  unexpected early data if a client sends it. Since TLS 1.3 0-RTT mode
-  involves clients keeping state regarding which servers support 0-RTT,
-  a Go 1.12 server cannot be part of a load-balancing pool where some other
-  servers do support 0-RTT. If switching a domain from a server that supported
-  0-RTT to a Go 1.12 server, 0-RTT would have to be disabled for at least the
-  lifetime of the issued session tickets before the switch to ensure
-  uninterrupted operation.
-</p>
-
-<p>
-  In TLS 1.3 the client is the last one to speak in the handshake, so if it causes
-  an error to occur on the server, it will be returned on the client by the first
-  <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>, not by
-  <a href="/pkg/crypto/tls/#Conn.Handshake"><code>Handshake</code></a>. For
-  example, that will be the case if the server rejects the client certificate.
-  Similarly, session tickets are now post-handshake messages, so are only
-  received by the client upon its first
-  <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<!-- TODO: CL 115677: https://golang.org/cl/115677: cmd/vet: check embedded field tags too -->
-
-<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
-  <dd>
-    <p><!-- CL 149297 -->
-      <code>Reader</code>'s <a href="/pkg/bufio/#Reader.UnreadRune"><code>UnreadRune</code></a> and
-      <a href="/pkg/bufio/#Reader.UnreadByte"><code>UnreadByte</code></a> methods will now return an error
-      if they are called after <a href="/pkg/bufio/#Reader.Peek"><code>Peek</code></a>.
-    </p>
-
-</dl><!-- bufio -->
-
-<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
-  <dd>
-    <p><!-- CL 137855 -->
-      The new function <a href="/pkg/bytes/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
-      a byte slice with all non-overlapping instances of a value replaced by another.
-    </p>
-
-    <p><!-- CL 145098 -->
-      A pointer to a zero-value <a href="/pkg/bytes/#Reader"><code>Reader</code></a> is now
-      functionally equivalent to <a href="/pkg/bytes/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
-      Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
-    </p>
-
-</dl><!-- bytes -->
-
-<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
-  <dd>
-    <p><!-- CL 139419 -->
-      A warning will now be printed to standard error the first time
-      <code>Reader.Read</code> is blocked for more than 60 seconds waiting
-      to read entropy from the kernel.
-    </p>
-
-    <p><!-- CL 120055 -->
-      On FreeBSD, <code>Reader</code> now uses the <code>getrandom</code>
-      system call if available, <code>/dev/urandom</code> otherwise.
-    </p>
-
-</dl><!-- crypto/rand -->
-
-<dl id="crypto/rc4"><dt><a href="/pkg/crypto/rc4/">crypto/rc4</a></dt>
-  <dd>
-    <p><!-- CL 130397 -->
-      This release removes the assembly implementations, leaving only
-      the pure Go version. The Go compiler generates code that is
-      either slightly better or slightly worse, depending on the exact
-      CPU. RC4 is insecure and should only be used for compatibility
-      with legacy systems.
-    </p>
-
-</dl><!-- crypto/rc4 -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 143177 -->
-      If a client sends an initial message that does not look like TLS, the server
-      will no longer reply with an alert, and it will expose the underlying
-      <code>net.Conn</code> in the new field <code>Conn</code> of
-      <a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>.
-    </p>
-
-</dl><!-- crypto/tls -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 145738 -->
-      A query cursor can now be obtained by passing a
-      <a href="/pkg/database/sql/#Rows"><code>*Rows</code></a>
-      value to the <a href="/pkg/database/sql/#Row.Scan"><code>Row.Scan</code></a> method.
-    </p>
-
-</dl><!-- database/sql -->
-
-<dl id="expvar"><dt><a href="/pkg/expvar/">expvar</a></dt>
-  <dd>
-    <p><!-- CL 139537 -->
-      The new <a href="/pkg/expvar/#Map.Delete"><code>Delete</code></a> method allows
-      for deletion of key/value pairs from a <a href="/pkg/expvar/#Map"><code>Map</code></a>.
-    </p>
-
-</dl><!-- expvar -->
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 142737 -->
-      Maps are now printed in key-sorted order to ease testing. The ordering rules are:
-      <ul>
-        <li>When applicable, nil compares low
-        <li>ints, floats, and strings order by <
-        <li>NaN compares less than non-NaN floats
-        <li>bool compares false before true
-        <li>Complex compares real, then imaginary
-        <li>Pointers compare by machine address
-        <li>Channel values compare by machine address
-        <li>Structs compare each field in turn
-        <li>Arrays compare each element in turn
-        <li>Interface values compare first by <code>reflect.Type</code> describing the concrete type
-            and then by concrete value as described in the previous rules.
-      </ul>
-    </p>
-
-    <p><!-- CL 129777 -->
-      When printing maps, non-reflexive key values like <code>NaN</code> were previously
-      displayed as <code>&lt;nil&gt;</code>. As of this release, the correct values are printed.
-    </p>
-
-</dl><!-- fmt -->
-
-<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-  <dd>
-    <p><!-- CL 140958 -->
-      To address some outstanding issues in <a href="/cmd/doc/"><code>cmd/doc</code></a>,
-      this package has a new <a href="/pkg/go/doc/#Mode"><code>Mode</code></a> bit,
-      <code>PreserveAST</code>, which controls whether AST data is cleared.
-    </p>
-
-</dl><!-- go/doc -->
-
-<dl id="go/token"><dt><a href="/pkg/go/token/">go/token</a></dt>
-  <dd>
-    <p><!-- CL 134075 -->
-      The <a href="/pkg/go/token#File"><code>File</code></a> type has a new
-      <a href="/pkg/go/token#File.LineStart"><code>LineStart</code></a> field,
-      which returns the position of the start of a given line. This is especially useful
-      in programs that occasionally handle non-Go files, such as assembly, but wish to use
-      the <code>token.Pos</code> mechanism to identify file positions.
-    </p>
-
-</dl><!-- go/token -->
-
-<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
-  <dd>
-    <p><!-- CL 118755 -->
-      The <a href="/pkg/image/#RegisterFormat"><code>RegisterFormat</code></a> function is now safe for concurrent use.
-    </p>
-
-</dl><!-- image -->
-
-<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
-  <dd>
-    <p><!-- CL 134235 -->
-      Paletted images with fewer than 16 colors now encode to smaller outputs.
-    </p>
-
-</dl><!-- image/png -->
-
-<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
-  <dd>
-    <p><!-- CL 139457 -->
-      The new <a href="/pkg/io#StringWriter"><code>StringWriter</code></a> interface wraps the
-      <a href="/pkg/io/#WriteString"><code>WriteString</code></a> function.
-    </p>
-
-</dl><!-- io -->
-
-<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
-  <dd>
-    <p><!-- CL 153059 -->
-      The functions
-      <a href="/pkg/math/#Sin"><code>Sin</code></a>,
-      <a href="/pkg/math/#Cos"><code>Cos</code></a>,
-      <a href="/pkg/math/#Tan"><code>Tan</code></a>,
-      and <a href="/pkg/math/#Sincos"><code>Sincos</code></a> now
-      apply Payne-Hanek range reduction to huge arguments. This
-      produces more accurate answers, but they will not be bit-for-bit
-      identical with the results in earlier releases.
-    </p>
-</dl><!-- math -->
-
-<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
-  <dd>
-    <p><!-- CL 123157 -->
-    New extended precision operations <a href="/pkg/math/bits/#Add"><code>Add</code></a>, <a href="/pkg/math/bits/#Sub"><code>Sub</code></a>, <a href="/pkg/math/bits/#Mul"><code>Mul</code></a>, and <a href="/pkg/math/bits/#Div"><code>Div</code></a> are available in <code>uint</code>, <code>uint32</code>, and <code>uint64</code> versions.
-    </p>
-
-</dl><!-- math/bits -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 146659 -->
-      The
-      <a href="/pkg/net/#Dialer.DualStack"><code>Dialer.DualStack</code></a> setting is now ignored and deprecated;
-      RFC 6555 Fast Fallback ("Happy Eyeballs") is now enabled by default. To disable, set
-      <a href="/pkg/net/#Dialer.FallbackDelay"><code>Dialer.FallbackDelay</code></a> to a negative value.
-    </p>
-
-    <p><!-- CL 107196 -->
-      Similarly, TCP keep-alives are now enabled by default if
-      <a href="/pkg/net/#Dialer.KeepAlive"><code>Dialer.KeepAlive</code></a> is zero.
-      To disable, set it to a negative value.
-    </p>
-
-    <p><!-- CL 113997 -->
-      On Linux, the <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a> is now used when copying from a
-      <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to a
-      <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
-    </p>
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 143177 -->
-      The HTTP server now rejects misdirected HTTP requests to HTTPS servers with a plaintext "400 Bad Request" response.
-    </p>
-
-    <p><!-- CL 130115 -->
-      The new <a href="/pkg/net/http/#Client.CloseIdleConnections"><code>Client.CloseIdleConnections</code></a>
-      method calls the <code>Client</code>'s underlying <code>Transport</code>'s <code>CloseIdleConnections</code>
-      if it has one.
-    </p>
-
-    <p><!-- CL 145398 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer rejects HTTP responses which declare
-      HTTP Trailers but don't use chunked encoding. Instead, the declared trailers are now just ignored.
-    </p>
-
-    <p><!-- CL 152080 --> <!-- CL 151857 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer handles <code>MAX_CONCURRENT_STREAMS</code> values
-      advertised from HTTP/2 servers as strictly as it did during Go 1.10 and Go 1.11. The default behavior is now back
-      to how it was in Go 1.9: each connection to a server can have up to <code>MAX_CONCURRENT_STREAMS</code> requests
-      active and then new TCP connections are created as needed. In Go 1.10 and Go 1.11 the <code>http2</code> package
-      would block and wait for requests to finish instead of creating new connections.
-      To get the stricter behavior back, import the
-      <a href="https://godoc.org/golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a> package
-      directly and set
-      <a href="https://godoc.org/golang.org/x/net/http2#Transport.StrictMaxConcurrentStreams"><code>Transport.StrictMaxConcurrentStreams</code></a> to
-      <code>true</code>.
-    </p>
-
-</dl><!-- net/http -->
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-    <p><!-- CL 159157, CL 160178 -->
-      <a href="/pkg/net/url/#Parse"><code>Parse</code></a>,
-      <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>,
-      and
-      <a href="/pkg/net/url/#URL.Parse"><code>URL.Parse</code></a>
-      now return an
-      error for URLs containing ASCII control characters, which includes NULL,
-      tab, and newlines.
-    </p>
-
-</dl><!-- net/url -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 146437 -->
-      The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> now automatically
-      proxies WebSocket requests.
-    </p>
-
-</dl><!-- net/http/httputil -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 125443 -->
-      The new <a href="/pkg/os/#ProcessState.ExitCode"><code>ProcessState.ExitCode</code></a> method
-      returns the process's exit code.
-    </p>
-
-    <p><!-- CL 135075 -->
-      <code>ModeCharDevice</code> has been added to the <code>ModeType</code> bitmask, allowing for
-      <code>ModeDevice | ModeCharDevice</code> to be recovered when masking a
-      <a href="/pkg/os/#FileMode"><code>FileMode</code></a> with <code>ModeType</code>.
-    </p>
-
-    <p><!-- CL 139418 -->
-      The new function <a href="/pkg/os/#UserHomeDir"><code>UserHomeDir</code></a> returns the
-      current user's home directory.
-    </p>
-
-    <p><!-- CL 146020 -->
-      <a href="/pkg/os/#RemoveAll"><code>RemoveAll</code></a> now supports paths longer than 4096 characters
-      on most Unix systems.
-    </p>
-
-    <p><!-- CL 130676 -->
-      <a href="/pkg/os/#File.Sync"><code>File.Sync</code></a> now uses <code>F_FULLFSYNC</code> on macOS
-      to correctly flush the file contents to permanent storage.
-      This may cause the method to run more slowly than in previous releases.
-    </p>
-
-    <p><!--CL 155517 -->
-      <a href="/pkg/os/#File"><code>File</code></a> now supports
-      a <a href="/pkg/os/#File.SyscallConn"><code>SyscallConn</code></a>
-      method returning
-      a <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a>
-      interface value. This may be used to invoke system-specific
-      operations on the underlying file descriptor.
-    </p>
-
-</dl><!-- os -->
-
-<dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
-  <dd>
-    <p><!-- CL 145220 -->
-      The <a href="/pkg/path/filepath/#IsAbs"><code>IsAbs</code></a> function now returns true when passed
-      a reserved filename on Windows such as <code>NUL</code>.
-      <a href="https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#naming-conventions">List of reserved names.</a>
-    </p>
-
-</dl><!-- path/filepath -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 33572 -->
-      A new <a href="/pkg/reflect#MapIter"><code>MapIter</code></a> type is
-      an iterator for ranging over a map. This type is exposed through the
-      <a href="/pkg/reflect#Value"><code>Value</code></a> type's new
-      <a href="/pkg/reflect#Value.MapRange"><code>MapRange</code></a> method.
-      This follows the same iteration semantics as a range statement, with <code>Next</code>
-      to advance the iterator, and <code>Key</code>/<code>Value</code> to access each entry.
-    </p>
-
-</dl><!-- reflect -->
-
-<dl id="regexp"><dt><a href="/pkg/regexp/">regexp</a></dt>
-  <dd>
-    <p><!-- CL 139784 -->
-      <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> is no longer necessary
-      to avoid lock contention, so it has been given a partial deprecation comment.
-      <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a>
-      may still be appropriate if the reason for its use is to make two copies with
-      different <a href="/pkg/regexp/#Regexp.Longest"><code>Longest</code></a> settings.
-    </p>
-
-</dl><!-- regexp -->
-
-<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
-  <dd>
-    <p><!-- CL 144220 -->
-      A new <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a> type
-      exposes the build information read from the running binary, available only in
-      binaries built with module support. This includes the main package path, main
-      module information, and the module dependencies. This type is given through the
-      <a href="/pkg/runtime/debug/#ReadBuildInfo"><code>ReadBuildInfo</code></a> function
-      on <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a>.
-    </p>
-
-</dl><!-- runtime/debug -->
-
-<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
-  <dd>
-    <p><!-- CL 137855 -->
-      The new function <a href="/pkg/strings/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
-      a string with all non-overlapping instances of a value replaced by another.
-    </p>
-
-    <p><!-- CL 145098 -->
-      A pointer to a zero-value <a href="/pkg/strings/#Reader"><code>Reader</code></a> is now
-      functionally equivalent to <a href="/pkg/strings/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
-      Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
-    </p>
-
-    <p><!-- CL 122835 -->
-      The new <a href="/pkg/strings/#Builder.Cap"><code>Builder.Cap</code></a> method returns the capacity of the builder's underlying byte slice.
-    </p>
-
-    <p><!-- CL 131495 -->
-      The character mapping functions <a href="/pkg/strings/#Map"><code>Map</code></a>,
-      <a href="/pkg/strings/#Title"><code>Title</code></a>,
-      <a href="/pkg/strings/#ToLower"><code>ToLower</code></a>,
-      <a href="/pkg/strings/#ToLowerSpecial"><code>ToLowerSpecial</code></a>,
-      <a href="/pkg/strings/#ToTitle"><code>ToTitle</code></a>,
-      <a href="/pkg/strings/#ToTitleSpecial"><code>ToTitleSpecial</code></a>,
-      <a href="/pkg/strings/#ToUpper"><code>ToUpper</code></a>, and
-      <a href="/pkg/strings/#ToUpperSpecial"><code>ToUpperSpecial</code></a>
-      now always guarantee to return valid UTF-8. In earlier releases, if the input was invalid UTF-8 but no character replacements
-      needed to be applied, these routines incorrectly returned the invalid UTF-8 unmodified.
-    </p>
-
-</dl><!-- strings -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 138595 -->
-      64-bit inodes are now supported on FreeBSD 12. Some types have been adjusted accordingly.
-    </p>
-
-    <p><!-- CL 125456 -->
-      The Unix socket
-      (<a href="https://blogs.msdn.microsoft.com/commandline/2017/12/19/af_unix-comes-to-windows/"><code>AF_UNIX</code></a>)
-      address family is now supported for compatible versions of Windows.
-    </p>
-
-    <p><!-- CL 147117 -->
-      The new function  <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Syscall18"><code>Syscall18</code></a>
-      has been introduced for Windows, allowing for calls with up to 18 arguments.
-    </p>
-
-</dl><!-- syscall -->
-
-<dl id="syscall/js"><dt><a href="/pkg/syscall/js/">syscall/js</a></dt>
-  <dd>
-    <p><!-- CL 153559 -->
-    <p>
-      The <code>Callback</code> type and <code>NewCallback</code> function have been renamed;
-      they are now called
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Func"><code>Func</code></a> and
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#FuncOf"><code>FuncOf</code></a>, respectively.
-      This is a breaking change, but WebAssembly support is still experimental
-      and not yet subject to the
-      <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code using the
-      old names will need to be updated.
-    </p>
-
-    <p><!-- CL 141644 -->
-      If a type implements the new
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Wrapper"><code>Wrapper</code></a>
-      interface,
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#ValueOf"><code>ValueOf</code></a>
-      will use it to return the JavaScript value for that type.
-    </p>
-
-    <p><!-- CL 143137 -->
-      The meaning of the zero
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
-      has changed. It now represents the JavaScript <code>undefined</code> value
-      instead of the number zero.
-      This is a breaking change, but WebAssembly support is still experimental
-      and not yet subject to the
-      <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code relying on
-      the zero <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
-      to mean the number zero will need to be updated.
-    </p>
-
-    <p><!-- CL 144384 -->
-      The new
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value.Truthy"><code>Value.Truthy</code></a>
-      method reports the
-      <a href="https://developer.mozilla.org/en-US/docs/Glossary/Truthy">JavaScript "truthiness"</a>
-      of a given value.
-    </p>
-
-</dl><!-- syscall/js -->
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 139258 -->
-    The <a href="/cmd/go/#hdr-Testing_flags"><code>-benchtime</code></a> flag now supports setting an explicit iteration count instead of a time when the value ends with an "<code>x</code>". For example, <code>-benchtime=100x</code> runs the benchmark 100 times.
-    </p>
-
-</dl><!-- testing -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 142217 -->
-      When executing a template, long context values are no longer truncated in errors.
-    </p>
-    <p>
-      <code>executing "tmpl" at <.very.deep.context.v...>: map has no entry for key "notpresent"</code>
-    </p>
-    <p>
-      is now
-    </p>
-    <p>
-      <code>executing "tmpl" at <.very.deep.context.value.notpresent>: map has no entry for key "notpresent"</code>
-    </p>
-
-  <dd>
-    <p><!-- CL 143097 -->
-      If a user-defined function called by a template panics, the
-      panic is now caught and returned as an error by
-      the <code>Execute</code> or <code>ExecuteTemplate</code> method.
-    </p>
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 151299 -->
-      The time zone database in <code>$GOROOT/lib/time/zoneinfo.zip</code>
-      has been updated to version 2018i. Note that this ZIP file is
-      only used if a time zone database is not provided by the operating
-      system.
-    </p>
-
-</dl><!-- time -->
-
-<dl id="unsafe"><dt><a href="/pkg/unsafe/">unsafe</a></dt>
-  <dd>
-    <p><!-- CL 146058 -->
-      It is invalid to convert a nil <code>unsafe.Pointer</code> to <code>uintptr</code> and back with arithmetic.
-      (This was already invalid, but will now cause the compiler to misbehave.)
-    </p>
-
-</dl><!-- unsafe -->

diff --git a/doc/go1.13.html b/doc/go1.13.html
deleted file mode 100644 (file)
index 8f4035d..0000000
--- a/doc/go1.13.html
+++ /dev/null
@@ -1,1066 +0,0 @@
-<!--{
-        "Title": "Go 1.13 Release Notes",
-        "Path":  "/doc/go1.13",
-        "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.13</h2>
-
-<p>
-  The latest Go release, version 1.13, arrives six months after <a href="go1.12">Go 1.12</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-  As of Go 1.13, the go command by default downloads and authenticates
-  modules using the Go module mirror and Go checksum database run by Google. See
-  <a href="https://proxy.golang.org/privacy">https://proxy.golang.org/privacy</a>
-  for privacy information about these services and the
-  <a href="/cmd/go/#hdr-Module_downloading_and_verification">go command documentation</a>
-  for configuration details including how to disable the use of these servers or use
-  different ones. If you depend on non-public modules, see the
-  <a href="/cmd/go/#hdr-Module_configuration_for_non_public_modules">documentation for configuring your environment</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  Per the <a href="https://github.com/golang/proposal/blob/master/design/19308-number-literals.md">number literal proposal</a>,
-  Go 1.13 supports a more uniform and modernized set of number literal prefixes.
-  <ul>
-    <li>
-      <a href="/ref/spec#Integer_literals">Binary integer literals</a>:
-      The prefix <code>0b</code> or <code>0B</code> indicates a binary integer literal
-      such as <code>0b1011</code>.
-    </li>
-
-    <li>
-      <a href="/ref/spec#Integer_literals">Octal integer literals</a>:
-      The prefix <code>0o</code> or <code>0O</code> indicates an octal integer literal
-      such as <code>0o660</code>.
-      The existing octal notation indicated by a leading <code>0</code> followed by
-      octal digits remains valid.
-    </li>
-
-    <li>
-      <a href="/ref/spec#Floating-point_literals">Hexadecimal floating point literals</a>:
-      The prefix <code>0x</code> or <code>0X</code> may now be used to express the mantissa of a
-      floating-point number in hexadecimal format such as <code>0x1.0p-1021</code>.
-      A hexadecimal floating-point number must always have an exponent, written as the letter
-      <code>p</code> or <code>P</code> followed by an exponent in decimal. The exponent scales
-      the mantissa by 2 to the power of the exponent.
-    </li>
-
-    <li>
-      <a href="/ref/spec#Imaginary_literals">Imaginary literals</a>:
-      The imaginary suffix <code>i</code> may now be used with any (binary, decimal, hexadecimal)
-      integer or floating-point literal.
-    </li>
-
-    <li>
-      Digit separators:
-      The digits of any number literal may now be separated (grouped) using underscores, such as
-      in <code>1_000_000</code>, <code>0b_1010_0110</code>, or <code>3.1415_9265</code>.
-      An underscore may appear between any two digits or the literal prefix and the first digit.
-    </li>
-  </ul>
-</p>
-
-<p>
-  Per the <a href="https://github.com/golang/proposal/blob/master/design/19113-signed-shift-counts.md">signed shift counts proposal</a>
-  Go 1.13 removes the restriction that a <a href="/ref/spec#Operators">shift count</a>
-  must be unsigned. This change eliminates the need for many artificial <code>uint</code> conversions,
-  solely introduced to satisfy this (now removed) restriction of the <code>&lt;&lt;</code> and <code>&gt;&gt;</code> operators.
-</p>
-
-<p>
-  These language changes were implemented by changes to the compiler, and corresponding internal changes to the library
-  packages <code><a href="#go/scanner">go/scanner</a></code> and
-  <code><a href="#text/scanner">text/scanner</a></code> (number literals),
-  and <code><a href="#go/types">go/types</a></code> (signed shift counts).
-</p>
-
-<p>
-  If your code uses modules and your <code>go.mod</code> files specifies a language version, be sure
-  it is set to at least <code>1.13</code> to get access to these language changes.
-  You can do this by editing the <code>go.mod</code> file directly, or you can run
-  <code>go mod edit -go=1.13</code>.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p id="nacl">
-  Go 1.13 is the last release that will run on Native Client (NaCl).
-</p>
-
-<p><!-- CL 170119, CL 168882 -->
-  For <code>GOARCH=wasm</code>, the new environment variable <code>GOWASM</code> takes a comma-separated list of experimental features that the binary gets compiled with.
-  The valid values are documented <a href="/cmd/go/#hdr-Environment_variables">here</a>.
-</p>
-
-<h3 id="aix">AIX</h3>
-
-<p><!-- CL 164003, CL 169120 -->
-  AIX on PPC64 (<code>aix/ppc64</code>) now supports cgo, external
-  linking, and the <code>c-archive</code> and <code>pie</code> build
-  modes.
-</p>
-
-<h3 id="android">Android</h3>
-
-<p><!-- CL 170127 -->
-  Go programs are now compatible with Android 10.
-</p>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  As <a href="go1.12#darwin">announced</a> in the Go 1.12 release notes,
-  Go 1.13 now requires macOS 10.11 El Capitan or later;
-  support for previous versions has been discontinued.
-</p>
-
-<h3 id="freebsd">FreeBSD</h3>
-
-<p>
-  As <a href="go1.12#freebsd">announced</a> in the Go 1.12 release notes,
-  Go 1.13 now requires FreeBSD 11.2 or later;
-  support for previous versions has been discontinued.
-  FreeBSD 12.0 or later requires a kernel with the <code>COMPAT_FREEBSD11</code>
-  option set (this is the default).
-</p>
-
-<h3 id="illumos">Illumos</h3>
-
-<p><!-- CL 174457 -->
-  Go now supports Illumos with <code>GOOS=illumos</code>.
-  The <code>illumos</code> build tag implies the <code>solaris</code>
-  build tag.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p><!-- CL 178977 -->
-  The Windows version specified by internally-linked Windows binaries
-  is now Windows 7 rather than NT 4.0. This was already the minimum
-  required version for Go, but can affect the behavior of system calls
-  that have a backwards-compatibility mode. These will now behave as
-  documented. Externally-linked binaries (any program using cgo) have
-  always specified a more recent Windows version.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="modules">Modules</h3>
-
-<h4 id="proxy-vars">Environment variables</h4>
-
-<p><!-- CL 176580 -->
-  The <a href="/cmd/go/#hdr-Module_support"><code>GO111MODULE</code></a>
-  environment variable continues to default to <code>auto</code>, but
-  the <code>auto</code> setting now activates the module-aware mode of
-  the <code>go</code> command whenever the current working directory contains,
-  or is below a directory containing, a <code>go.mod</code> file — even if the
-  current directory is within <code>GOPATH/src</code>. This change simplifies
-  the migration of existing code within <code>GOPATH/src</code> and the ongoing
-  maintenance of module-aware packages alongside non-module-aware importers.
-</p>
-
-<p><!-- CL 181719 -->
-  The new
-  <a href="/cmd/go/#hdr-Module_configuration_for_non_public_modules"><code>GOPRIVATE</code></a>
-  environment variable indicates module paths that are not publicly available.
-  It serves as the default value for the lower-level <code>GONOPROXY</code>
-  and <code>GONOSUMDB</code> variables, which provide finer-grained control over
-  which modules are fetched via proxy and verified using the checksum database.
-</p>
-
-<p><!-- CL 173441, CL 177958 -->
-  The <a href="/cmd/go/#hdr-Module_downloading_and_verification"><code>GOPROXY</code>
-  environment variable</a> may now be set to a comma-separated list of proxy
-  URLs or the special token <code>direct</code>, and
-  its <a href="#introduction">default value</a> is
-  now <code>https://proxy.golang.org,direct</code>. When resolving a package
-  path to its containing module, the <code>go</code> command will try all
-  candidate module paths on each proxy in the list in succession. An unreachable
-  proxy or HTTP status code other than 404 or 410 terminates the search without
-  consulting the remaining proxies.
-</p>
-
-<p>
-  The new
-  <a href="/cmd/go/#hdr-Module_authentication_failures"><code>GOSUMDB</code></a>
-  environment variable identifies the name, and optionally the public key and
-  server URL, of the database to consult for checksums of modules that are not
-  yet listed in the main module's <code>go.sum</code> file.
-  If <code>GOSUMDB</code> does not include an explicit URL, the URL is chosen by
-  probing the <code>GOPROXY</code> URLs for an endpoint indicating support for
-  the checksum database, falling back to a direct connection to the named
-  database if it is not supported by any proxy. If <code>GOSUMDB</code> is set
-  to <code>off</code>, the checksum database is not consulted and only the
-  existing checksums in the <code>go.sum</code> file are verified.
-</p>
-
-<p>
-  Users who cannot reach the default proxy and checksum database (for example,
-  due to a firewalled or sandboxed configuration) may disable their use by
-  setting <code>GOPROXY</code> to <code>direct</code>, and/or
-  <code>GOSUMDB</code> to <code>off</code>.
-  <a href="#go-env-w"><code>go</code> <code>env</code> <code>-w</code></a>
-  can be used to set the default values for these variables independent of
-  platform:
-</p>
-<pre>
-go env -w GOPROXY=direct
-go env -w GOSUMDB=off
-</pre>
-
-<h4 id="go-get"><code>go</code> <code>get</code></h4>
-
-<p><!-- CL 174099 -->
-  In module-aware mode,
-  <a href="/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them"><code>go</code> <code>get</code></a>
-  with the <code>-u</code> flag now updates a smaller set of modules that is
-  more consistent with the set of packages updated by
-  <code>go</code> <code>get</code> <code>-u</code> in GOPATH mode.
-  <code>go</code> <code>get</code> <code>-u</code> continues to update the
-  modules and packages named on the command line, but additionally updates only
-  the modules containing the packages <em>imported by</em> the named packages,
-  rather than the transitive module requirements of the modules containing the
-  named packages.
-</p>
-
-<p>
-  Note in particular that <code>go</code> <code>get</code> <code>-u</code>
-  (without additional arguments) now updates only the transitive imports of the
-  package in the current directory. To instead update all of the packages
-  transitively imported by the main module (including test dependencies), use
-  <code>go</code> <code>get</code> <code>-u</code> <code>all</code>.
-</p>
-
-<p><!-- CL 177879 -->
-  As a result of the above changes to
-  <code>go</code> <code>get</code> <code>-u</code>, the
-  <code>go</code> <code>get</code> subcommand no longer supports
-  the <code>-m</code> flag, which caused <code>go</code> <code>get</code> to
-  stop before loading packages. The <code>-d</code> flag remains supported, and
-  continues to cause <code>go</code> <code>get</code> to stop after downloading
-  the source code needed to build dependencies of the named packages.
-</p>
-
-<p><!-- CL 177677 -->
-  By default, <code>go</code> <code>get</code> <code>-u</code> in module mode
-  upgrades only non-test dependencies, as in GOPATH mode. It now also accepts
-  the <code>-t</code> flag, which (as in GOPATH mode)
-  causes <code>go</code> <code>get</code> to include the packages imported
-  by <em>tests of</em> the packages named on the command line.
-</p>
-
-<p><!-- CL 167747 -->
-  In module-aware mode, the <code>go</code> <code>get</code> subcommand now
-  supports the version suffix <code>@patch</code>. The <code>@patch</code>
-  suffix indicates that the named module, or module containing the named
-  package, should be updated to the highest patch release with the same
-  major and minor versions as the version found in the build list.
-</p>
-
-<p><!-- CL 184440 -->
-  If a module passed as an argument to <code>go</code> <code>get</code>
-  without a version suffix is already required at a newer version than the
-  latest released version, it will remain at the newer version. This is
-  consistent with the behavior of the <code>-u</code> flag for module
-  dependencies. This prevents unexpected downgrades from pre-release versions.
-  The new version suffix <code>@upgrade</code> explicitly requests this
-  behavior. <code>@latest</code> explicitly requests the latest version
-  regardless of the current version.
-</p>
-
-<h4 id="version-validation">Version validation</h4><!-- CL 181881 -->
-
-<p>
-  When extracting a module from a version control system, the <code>go</code>
-  command now performs additional validation on the requested version string.
-</p>
-
-<p>
-  The <code>+incompatible</code> version annotation bypasses the requirement
-  of <a href="/cmd/go/#hdr-Module_compatibility_and_semantic_versioning">semantic
-  import versioning</a> for repositories that predate the introduction of
-  modules. The <code>go</code> command now verifies that such a version does not
-  include an explicit <code>go.mod</code> file.
-</p>
-
-<p>
-  The <code>go</code> command now verifies the mapping
-  between <a href="/cmd/go/#hdr-Pseudo_versions">pseudo-versions</a> and
-  version-control metadata. Specifically:
-  <ul>
-    <li>The version prefix must be of the form <code>vX.0.0</code>, or derived
-    from a tag on an ancestor of the named revision, or derived from a tag that
-    includes <a href="https://semver.org/#spec-item-10">build metadata</a> on
-    the named revision itself.</li>
-
-    <li>The date string must match the UTC timestamp of the revision.</li>
-
-    <li>The short name of the revision must use the same number of characters as
-    what the <code>go</code> command would generate. (For SHA-1 hashes as used
-    by <code>git</code>, a 12-digit prefix.)</li>
-  </ul>
-</p>
-
-<p>
-  If a <code>require</code> directive in the
-  <a href="/cmd/go/#hdr-The_main_module_and_the_build_list">main module</a> uses
-  an invalid pseudo-version, it can usually be corrected by redacting the
-  version to just the commit hash and re-running a <code>go</code> command, such
-  as <code>go</code> <code>list</code> <code>-m</code> <code>all</code>
-  or <code>go</code> <code>mod</code> <code>tidy</code>. For example,
-</p>
-<pre>require github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c</pre>
-<p>can be redacted to</p>
-<pre>require github.com/docker/docker e7b5f7dbe98c</pre>
-<p>which currently resolves to</p>
-<pre>require github.com/docker/docker v0.7.3-0.20190319215453-e7b5f7dbe98c</pre>
-
-<p>
-  If one of the transitive dependencies of the main module requires an invalid
-  version or pseudo-version, the invalid version can be replaced with a valid
-  one using a
-  <a href="/cmd/go/#hdr-The_go_mod_file"><code>replace</code> directive</a> in
-  the <code>go.mod</code> file of the main module. If the replacement is a
-  commit hash, it will be resolved to the appropriate pseudo-version as above.
-  For example,
-</p>
-<pre>replace github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c => github.com/docker/docker e7b5f7dbe98c</pre>
-<p>currently resolves to</p>
-<pre>replace github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c => github.com/docker/docker v0.7.3-0.20190319215453-e7b5f7dbe98c</pre>
-
-<h3 id="go-command">Go command</h3>
-
-<p id="go-env-w"><!-- CL 171137 -->
-  The <a href="/cmd/go/#hdr-Environment_variables"><code>go</code> <code>env</code></a>
-  command now accepts a <code>-w</code> flag to set the per-user default value
-  of an environment variable recognized by the
-  <code>go</code> command, and a corresponding <code>-u</code> flag to unset a
-  previously-set default. Defaults set via
-  <code>go</code> <code>env</code> <code>-w</code> are stored in the
-  <code>go/env</code> file within
-  <a href="/pkg/os/#UserConfigDir"><code>os.UserConfigDir()</code></a>.
-</p>
-
-<p id="go-version-exe"><!-- CL 173343 -->
-  The <a href="/cmd/go/#hdr-Print_Go_version">
-  <code>go</code> <code>version</code></a> command now accepts arguments naming
-  executables and directories. When invoked on an executable,
-  <code>go</code> <code>version</code> prints the version of Go used to build
-  the executable. If the <code>-m</code> flag is used,
-  <code>go</code> <code>version</code> prints the executable's embedded module
-  version information, if available. When invoked on a directory,
-  <code>go</code> <code>version</code> prints information about executables
-  contained in the directory and its subdirectories.
-</p>
-
-<p id="trimpath"><!-- CL 173345 -->
-  The new <a href="/cmd/go/#hdr-Compile_packages_and_dependencies"><code>go</code>
-  <code>build</code> flag</a> <code>-trimpath</code> removes all file system paths
-  from the compiled executable, to improve build reproducibility.
-</p>
-
-<p id="o-dir"><!-- CL 167679 -->
-  If the <code>-o</code> flag passed to <code>go</code> <code>build</code>
-  refers to an existing directory, <code>go</code> <code>build</code> will now
-  write executable files within that directory for <code>main</code> packages
-  matching its package arguments.
-</p>
-
-<p id="comma-separated-tags"><!-- CL 173438 -->
-  The <code>go</code> <code>build</code> flag <code>-tags</code> now takes a
-  comma-separated list of build tags, to allow for multiple tags in
-  <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code></a>. The
-  space-separated form is deprecated but still recognized and will be maintained.
-</p>
-
-<p id="go-generate-tag"><!-- CL 175983 -->
-  <a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
-  <code>generate</code></a> now sets the <code>generate</code> build tag so that
-  files may be searched for directives but ignored during build.
-</p>
-
-<p id="binary-only"><!-- CL 165746 -->
-  As <a href="/doc/go1.12#binary-only">announced</a> in the Go 1.12 release
-  notes, binary-only packages are no longer supported. Building a binary-only
-  package (marked with a <code>//go:binary-only-package</code> comment) now
-  results in an error.
-</p>
-
-<h3 id="compiler">Compiler toolchain</h3>
-
-<p><!-- CL 170448 -->
-  The compiler has a new implementation of escape analysis that is
-  more precise. For most Go code should be an improvement (in other
-  words, more Go variables and expressions allocated on the stack
-  instead of heap). However, this increased precision may also break
-  invalid code that happened to work before (for example, code that
-  violates
-  the <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code>
-  safety rules</a>). If you notice any regressions that appear
-  related, the old escape analysis pass can be re-enabled
-  with <code>go</code> <code>build</code> <code>-gcflags=all=-newescape=false</code>.
-  The option to use the old escape analysis will be removed in a
-  future release.
-</p>
-
-<p><!-- CL 161904 -->
-  The compiler no longer emits floating point or complex constants
-  to <code>go_asm.h</code> files. These have always been emitted in a
-  form that could not be used as numeric constant in assembly code.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p><!-- CL 157001 -->
-  The assembler now supports many of the atomic instructions
-  introduced in ARM v8.1.
-</p>
-
-<h3 id="gofmt">gofmt</h3>
-
-<p>
-  <code>gofmt</code> (and with that <code>go fmt</code>) now canonicalizes
-  number literal prefixes and exponents to use lower-case letters, but
-  leaves hexadecimal digits alone. This improves readability when using the new octal prefix
-  (<code>0O</code> becomes <code>0o</code>), and the rewrite is applied consistently.
-  <code>gofmt</code> now also removes unnecessary leading zeroes from a decimal integer
-  imaginary literal. (For backwards-compatibility, an integer imaginary literal
-  starting with <code>0</code> is considered a decimal, not an octal number.
-  Removing superfluous leading zeroes avoids potential confusion.)
-  For instance, <code>0B1010</code>, <code>0XabcDEF</code>, <code>0O660</code>,
-  <code>1.2E3</code>, and <code>01i</code> become <code>0b1010</code>, <code>0xabcDEF</code>,
-  <code>0o660</code>, <code>1.2e3</code>, and <code>1i</code> after applying <code>gofmt</code>.
-</p>
-
-<h3 id="godoc"><code>godoc</code> and <code>go</code> <code>doc</code></h3>
-
-<p><!-- CL 174322 -->
-  The <code>godoc</code> webserver is no longer included in the main binary distribution.
-  To run the <code>godoc</code> webserver locally, manually install it first:
-<pre>
-go get golang.org/x/tools/cmd/godoc
-godoc
-</pre>
-</p>
-
-<p><!-- CL 177797 -->
-  The
-  <a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go</code> <code>doc</code></a>
-  command now always includes the package clause in its output, except for
-  commands. This replaces the previous behavior where a heuristic was used,
-  causing the package clause to be omitted under certain conditions.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 161477 -->
-  Out of range panic messages now include the index that was out of
-  bounds and the length (or capacity) of the slice. For
-  example, <code>s[3]</code> on a slice of length 1 will panic with
-  "runtime error: index out of range [3] with length 1".
-</p>
-
-<p><!-- CL 171758 -->
-  This release improves performance of most uses of <code>defer</code>
-  by 30%.
-</p>
-
-<p><!-- CL 142960 -->
-  The runtime is now more aggressive at returning memory to the
-  operating system to make it available to co-tenant applications.
-  Previously, the runtime could retain memory for five or more minutes
-  following a spike in the heap size. It will now begin returning it
-  promptly after the heap shrinks. However, on many OSes, including
-  Linux, the OS itself reclaims memory lazily, so process RSS will not
-  decrease until the system is under memory pressure.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="tls_1_3">TLS 1.3</h3>
-
-<p>
-  As announced in Go 1.12, Go 1.13 enables support for TLS 1.3 in the
-  <code>crypto/tls</code> package by default. It can be disabled by adding the
-  value <code>tls13=0</code> to the <code>GODEBUG</code>
-  environment variable. The opt-out will be removed in Go 1.14.
-</p>
-
-<p>
-  See <a href="/doc/go1.12#tls_1_3">the Go 1.12 release notes</a> for important
-  compatibility information.
-</p>
-
-<h3 id="crypto/ed25519"><a href="/pkg/crypto/ed25519/">crypto/ed25519</a></h3>
-
-<p><!-- CL 174945, 182698 -->
-  The new <a href="/pkg/crypto/ed25519/"><code>crypto/ed25519</code></a>
-  package implements the Ed25519 signature
-  scheme. This functionality was previously provided by the
-  <a href="https://godoc.org/golang.org/x/crypto/ed25519"><code>golang.org/x/crypto/ed25519</code></a>
-  package, which becomes a wrapper for
-  <code>crypto/ed25519</code> when used with Go 1.13+.
-</p>
-
-<h3 id="error_wrapping">Error wrapping</h3>
-
-<p><!-- CL 163558, 176998 -->
-  Go 1.13 contains support for error wrapping, as first proposed in
-  the <a href="https://go.googlesource.com/proposal/+/master/design/29934-error-values.md">
-  Error Values proposal</a> and discussed on <a href="https://golang.org/issue/29934">the
-  associated issue</a>.
-</p>
-<p>
-  An error <code>e</code> can <em>wrap</em> another error <code>w</code> by providing
-  an <code>Unwrap</code> method that returns <code>w</code>. Both <code>e</code>
-  and <code>w</code> are available to programs, allowing <code>e</code> to provide
-  additional context to <code>w</code> or to reinterpret it while still allowing
-  programs to make decisions based on <code>w</code>.
-</p>
-<p>
-  To support wrapping, <a href="#fmt"><code>fmt.Errorf</code></a> now has a <code>%w</code>
-  verb for creating wrapped errors, and three new functions in
-  the <a href="#errors"><code>errors</code></a> package (
-  <a href="/pkg/errors/#Unwrap"><code>errors.Unwrap</code></a>,
-  <a href="/pkg/errors/#Is"><code>errors.Is</code></a> and
-  <a href="/pkg/errors/#As"><code>errors.As</code></a>) simplify unwrapping
-  and inspecting wrapped errors.
-</p>
-<p>
-  For more information, read the <a href="/pkg/errors/"><code>errors</code> package
-  documentation</a>, or see
-  the <a href="https://golang.org/wiki/ErrorValueFAQ">Error Value FAQ</a>.
-  There will soon be a blog post as well.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
-  <dd>
-    <p>
-      The new <a href="/pkg/bytes/#ToValidUTF8"><code>ToValidUTF8</code></a> function returns a
-      copy of a given byte slice with each run of invalid UTF-8 byte sequences replaced by a given slice.
-    </p>
-
-</dl><!-- bytes -->
-
-<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
-  <dd>
-    <p><!-- CL 169080 -->
-    The formatting of contexts returned by <a href="/pkg/context/#WithValue"><code>WithValue</code></a> no longer depends on <code>fmt</code> and will not stringify in the same way. Code that depends on the exact previous stringification might be affected.
-    </p>
-
-</dl><!-- context -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p>
-      Support for SSL version 3.0 (SSLv3) <a href="https://golang.org/issue/32716">
-      is now deprecated and will be removed in Go 1.14</a>. Note that SSLv3 is the
-      <a href="https://tools.ietf.org/html/rfc7568">cryptographically broken</a>
-      protocol predating TLS.
-    </p>
-
-    <p>
-      SSLv3 was always disabled by default, other than in Go 1.12, when it was
-      mistakenly enabled by default server-side. It is now again disabled by
-      default. (SSLv3 was never supported client-side.)
-    </p>
-
-    <p><!-- CL 177698 -->
-      Ed25519 certificates are now supported in TLS versions 1.2 and 1.3.
-    </p>
-
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 175478 -->
-      Ed25519 keys are now supported in certificates and certificate requests
-      according to <a href="https://www.rfc-editor.org/info/rfc8410">RFC 8410</a>, as well as by the
-      <a href="/pkg/crypto/x509/#ParsePKCS8PrivateKey"><code>ParsePKCS8PrivateKey</code></a>,
-      <a href="/pkg/crypto/x509/#MarshalPKCS8PrivateKey"><code>MarshalPKCS8PrivateKey</code></a>,
-      and <a href="/pkg/crypto/x509/#ParsePKIXPublicKey"><code>ParsePKIXPublicKey</code></a> functions.
-    </p>
-
-    <p><!-- CL 169238 -->
-      The paths searched for system roots now include <code>/etc/ssl/cert.pem</code>
-      to support the default location in Alpine Linux 3.7+.
-    </p>
-
-</dl><!-- crypto/x509 -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 170699 -->
-      The new <a href="/pkg/database/sql/#NullTime"><code>NullTime</code></a> type represents a <code>time.Time</code> that may be null.
-    </p>
-
-    <p><!-- CL 174178 -->
-      The new  <a href="/pkg/database/sql/#NullInt32"><code>NullInt32</code></a> type represents an <code>int32</code> that may be null.
-    </p>
-
-</dl><!-- database/sql -->
-
-<dl id="debug/dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
-  <dd>
-    <p><!-- CL 158797 -->
-      The <a href="/pkg/debug/dwarf/#Data.Type"><code>Data.Type</code></a>
-      method no longer panics if it encounters an unknown DWARF tag in
-      the type graph. Instead, it represents that component of the
-      type with
-      an <a href="/pkg/debug/dwarf/#UnsupportedType"><code>UnsupportedType</code></a>
-      object.
-    </p>
-
-</dl><!-- debug/dwarf -->
-
-<dl id="errors"><dt><a href="/pkg/errors/">errors</a></dt>
-  <dd>
-    <!-- CL 163558 -->
-    <p>
-      The new function <a href="/pkg/errors/#As"><code>As</code></a> finds the first
-      error in a given error’s chain (sequence of wrapped errors)
-      that matches a given target’s type, and if so, sets the target to that error value.
-    </p>
-    <p>
-      The new function <a href="/pkg/errors/#Is"><code>Is</code></a> reports whether a given error value matches an
-      error in another’s chain.
-    </p>
-    <p>
-      The new function <a href="/pkg/errors/#Unwrap"><code>Unwrap</code></a> returns the result of calling
-      <code>Unwrap</code> on a given error, if one exists.
-    </p>
-
-</dl><!-- errors -->
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <!-- CL 160245 -->
-    <p>
-      The printing verbs <code>%x</code> and <code>%X</code> now format floating-point and
-      complex numbers in hexadecimal notation, in lower-case and upper-case respectively.
-    </p>
-
-    <!-- CL 160246 -->
-    <p>
-      The new printing verb <code>%O</code> formats integers in base 8, emitting the <code>0o</code> prefix.
-    </p>
-
-    <!-- CL 160247 -->
-    <p>
-      The scanner now accepts hexadecimal floating-point values, digit-separating underscores
-      and leading <code>0b</code> and <code>0o</code> prefixes.
-      See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-    <!-- CL 176998 -->
-    <p>The <a href="/pkg/fmt/#Errorf"><code>Errorf</code></a> function
-      has a new verb, <code>%w</code>, whose operand must be an error.
-      The error returned from <code>Errorf</code> will have an
-      <code>Unwrap</code> method which returns the operand of <code>%w</code>.
-    </p>
-
-</dl><!-- fmt -->
-
-
-<dl id="go/scanner"><dt><a href="/pkg/go/scanner/">go/scanner</a></dt>
-  <dd>
-    <p><!-- CL 175218 -->
-      The scanner has been updated to recognize the new Go number literals, specifically
-      binary literals with <code>0b</code>/<code>0B</code> prefix, octal literals with <code>0o</code>/<code>0O</code> prefix,
-      and floating-point numbers with hexadecimal mantissa. The imaginary suffix <code>i</code> may now be used with any number
-      literal, and underscores may used as digit separators for grouping.
-      See the <a href="#language">Changes to the language</a> for details.
-  </p>
-
-  </dl><!-- go/scanner -->
-
-<dl id="go/types"><dt><a href="/pkg/go/types/">go/types</a></dt>
-  <dd>
-    <p>
-      The type-checker has been updated to follow the new rules for integer shifts.
-      See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-</dl><!-- go/types -->
-
-
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 175218 -->
-      When using a <code>&lt;script&gt;</code> tag with "module" set as the
-      type attribute, code will now be interpreted as <a href="https://html.spec.whatwg.org/multipage/scripting.html#the-script-element:module-script-2">JavaScript module script</a>.
-    </p>
-
-</dl><!-- html/template -->
-
-<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
-  <dd>
-    <p><!-- CL 168920 -->
-      The new <a href="/pkg/log/#Writer"><code>Writer</code></a> function returns the output destination for the standard logger.
-    </p>
-
-</dl><!-- log -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 160682 -->
-      The new <a href="/pkg/math/big/#Rat.SetUint64"><code>Rat.SetUint64</code></a> method sets the <code>Rat</code> to a <code>uint64</code> value.
-    </p>
-
-    <p><!-- CL 166157 -->
-      For <a href="/pkg/math/big/#Float.Parse"><code>Float.Parse</code></a>, if base is 0, underscores
-      may be used between digits for readability.
-      See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-    <p><!-- CL 166157 -->
-      For <a href="/pkg/math/big/#Int.SetString"><code>Int.SetString</code></a>, if base is 0, underscores
-      may be used between digits for readability.
-      See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-    <p><!-- CL 168237 -->
-      <a href="/pkg/math/big/#Rat.SetString"><code>Rat.SetString</code></a> now accepts non-decimal floating point representations.
-    </p>
-
-</dl><!-- math/big -->
-
-<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
-  <dd>
-    <p><!-- CL 178177 -->
-      The execution time of <a href="/pkg/math/bits/#Add"><code>Add</code></a>,
-      <a href="/pkg/math/bits/#Sub"><code>Sub</code></a>,
-      <a href="/pkg/math/bits/#Mul"><code>Mul</code></a>,
-      <a href="/pkg/math/bits/#RotateLeft"><code>RotateLeft</code></a>, and
-      <a href="/pkg/math/bits/#ReverseBytes"><code>ReverseBytes</code></a> is now
-      guaranteed to be independent of the inputs.
-    </p>
-
-</dl><!-- math/bits -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 156366 -->
-      On Unix systems where <code>use-vc</code> is set in <code>resolv.conf</code>, TCP is used for DNS resolution.
-    </p>
-
-    <p><!-- CL 170678 -->
-      The new field <a href="/pkg/net/#ListenConfig.KeepAlive"><code>ListenConfig.KeepAlive</code></a>
-      specifies the keep-alive period for network connections accepted by the listener.
-      If this field is 0 (the default) TCP keep-alives will be enabled.
-      To disable them, set it to a negative value.
-    </p>
-    <p>
-      Note that the error returned from I/O on a connection that was
-      closed by a keep-alive timeout will have a
-      <code>Timeout</code> method that returns <code>true</code> if called.
-      This can make a keep-alive error difficult to distinguish from
-      an error returned due to a missed deadline as set by the
-      <a href="/pkg/net/#Conn"><code>SetDeadline</code></a>
-      method and similar methods.
-      Code that uses deadlines and checks for them with
-      the <code>Timeout</code> method or
-      with <a href="/pkg/os/#IsTimeout"><code>os.IsTimeout</code></a>
-      may want to disable keep-alives, or
-      use <code>errors.Is(syscall.ETIMEDOUT)</code> (on Unix systems)
-      which will return true for a keep-alive timeout and false for a
-      deadline timeout.
-    </p>
-
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 76410 -->
-      The new fields <a href="/pkg/net/http/#Transport.WriteBufferSize"><code>Transport.WriteBufferSize</code></a>
-      and <a href="/pkg/net/http/#Transport.ReadBufferSize"><code>Transport.ReadBufferSize</code></a>
-      allow one to specify the sizes of the write and read buffers for a <a href="/pkg/net/http/#Transport"><code>Transport</code></a>.
-      If either field is zero, a default size of 4KB is used.
-    </p>
-
-    <p><!-- CL 130256 -->
-      The new field <a href="/pkg/net/http/#Transport.ForceAttemptHTTP2"><code>Transport.ForceAttemptHTTP2</code></a>
-      controls whether HTTP/2 is enabled when a non-zero <code>Dial</code>, <code>DialTLS</code>, or <code>DialContext</code>
-      func or <code>TLSClientConfig</code> is provided.
-    </p>
-
-    <p><!-- CL 140357 -->
-      <a href="/pkg/net/http/#Transport.MaxConnsPerHost"><code>Transport.MaxConnsPerHost</code></a> now works
-      properly with HTTP/2.
-    </p>
-
-    <p><!-- CL 154383 -->
-      <a href="/pkg/net/http/#TimeoutHandler"><code>TimeoutHandler</code></a>'s
-      <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a> now implements the
-      <a href="/pkg/net/http/#Pusher"><code>Pusher</code></a> interface.
-    </p>
-
-    <p><!-- CL 157339 -->
-      The <code>StatusCode</code> <code>103</code> <code>"Early Hints"</code> has been added.
-    </p>
-
-    <p><!-- CL 163599 -->
-    <a href="/pkg/net/http/#Transport"><code>Transport</code></a> now uses the <a href="/pkg/net/http/#Request.Body"><code>Request.Body</code></a>'s
-    <a href="/pkg/io/#ReaderFrom"><code>io.ReaderFrom</code></a> implementation if available, to optimize writing the body.
-    </p>
-
-    <p><!-- CL 167017 -->
-      On encountering unsupported transfer-encodings, <a href="/pkg/net/http/#Server"><code>http.Server</code></a> now
-      returns a "501 Unimplemented" status as mandated by the HTTP specification <a href="https://tools.ietf.org/html/rfc7230#section-3.3.1">RFC 7230 Section 3.3.1</a>.
-    </p>
-
-    <p><!-- CL 167681 -->
-      The new <a href="/pkg/net/http/#Server"><code>Server</code></a> fields
-      <a href="/pkg/net/http/#Server.BaseContext"><code>BaseContext</code></a> and
-      <a href="/pkg/net/http/#Server.ConnContext"><code>ConnContext</code></a>
-      allow finer control over the <a href="/pkg/context/#Context"><code>Context</code></a> values provided to requests and connections.
-    </p>
-
-    <p><!-- CL 167781 -->
-      <a href="/pkg/net/http/#DetectContentType"><code>http.DetectContentType</code></a> now correctly detects RAR signatures, and can now also detect RAR v5 signatures.
-    </p>
-
-    <p><!-- CL 173658 -->
-      The new <a href="/pkg/net/http/#Header"><code>Header</code></a> method
-      <a href="/pkg/net/http/#Header.Clone"><code>Clone</code></a> returns a copy of the receiver.
-    </p>
-
-    <p><!-- CL 174324 -->
-      A new function <a href="/pkg/net/http/#NewRequestWithContext"><code>NewRequestWithContext</code></a> has been added and it
-      accepts a <a href="/pkg/context/#Context"><code>Context</code></a> that controls the entire lifetime of
-      the created outgoing <a href="/pkg/net/http/#Request"><code>Request</code></a>, suitable for use with
-      <a href="/pkg/net/http/#Client.Do"><code>Client.Do</code></a> and <a href="/pkg/net/http/#Transport.RoundTrip"><code>Transport.RoundTrip</code></a>.
-    </p>
-
-    <p><!-- CL 179457 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer logs errors when servers
-      gracefully shut down idle connections using a <code>"408 Request Timeout"</code> response.
-    </p>
-
-</dl><!-- net/http -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 160877 -->
-      The new <a href="/pkg/os/#UserConfigDir"><code>UserConfigDir</code></a> function
-      returns the default directory to use for user-specific configuration data.
-    </p>
-
-    <p><!-- CL 166578 -->
-      If a <a href="/pkg/os/#File"><code>File</code></a> is opened using the O_APPEND flag, its
-      <a href="/pkg/os/#File.WriteAt"><code>WriteAt</code></a> method will always return an error.
-    </p>
-
-</dl><!-- os -->
-
-<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
-  <dd>
-    <p><!-- CL 174318 -->
-      On Windows, the environment for a <a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a> always inherits the
-      <code>%SYSTEMROOT%</code> value of the parent process unless the
-      <a href="/pkg/os/exec/#Cmd.Env"><code>Cmd.Env</code></a> field includes an explicit value for it.
-    </p>
-
-</dl><!-- os/exec -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 171337 -->
-      The new <a href="/pkg/reflect/#Value.IsZero"><code>Value.IsZero</code></a> method reports whether a <code>Value</code> is the zero value for its type.
-    </p>
-
-    <p><!-- CL 174531 -->
-      The <a href="/pkg/reflect/#MakeFunc"><code>MakeFunc</code></a> function now allows assignment conversions on returned values, instead of requiring exact type match. This is particularly useful when the type being returned is an interface type, but the value actually returned is a concrete value implementing that type.
-    </p>
-
-</dl><!-- reflect -->
-
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p> <!-- CL 167780 -->
-      Tracebacks, <a href="/pkg/runtime/#Caller"><code>runtime.Caller</code></a>,
-      and <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a> now refer to the function that
-      initializes the global variables of <code>PKG</code>
-      as <code>PKG.init</code> instead of <code>PKG.init.ializers</code>.
-    </p>
-
-</dl><!-- runtime -->
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p><!-- CL 160243 -->
-       For <a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
-       <a href="/pkg/strconv/#ParseInt"><code>strconv.ParseInt</code></a>
-       and <a href="/pkg/strconv/#ParseUint"><code>strconv.ParseUint</code></a>,
-       if base is 0, underscores may be used between digits for readability.
-       See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-</dl><!-- strconv -->
-
-<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
-  <dd>
-    <p><!-- CL 142003 -->
-      The new <a href="/pkg/strings/#ToValidUTF8"><code>ToValidUTF8</code></a> function returns a
-      copy of a given string with each run of invalid UTF-8 byte sequences replaced by a given string.
-    </p>
-
-</dl><!-- strings -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 148958, CL 148959, CL 152697, CL 152698 -->
-      The fast paths of <a href="/pkg/sync/#Mutex.Lock"><code>Mutex.Lock</code></a>, <a href="/pkg/sync/#Mutex.Unlock"><code>Mutex.Unlock</code></a>,
-      <a href="/pkg/sync/#RWMutex.Lock"><code>RWMutex.Lock</code></a>, <a href="/pkg/sync/#Mutex.RUnlock"><code>RWMutex.RUnlock</code></a>, and
-      <a href="/pkg/sync/#Once.Do"><code>Once.Do</code></a> are now inlined in their callers.
-      For the uncontended cases on amd64, these changes make <a href="/pkg/sync/#Once.Do"><code>Once.Do</code></a> twice as fast, and the
-      <a href="/pkg/sync/#Mutex"><code>Mutex</code></a>/<a href="/pkg/sync/#RWMutex"><code>RWMutex</code></a> methods up to 10% faster.
-    </p>
-
-    <p><!-- CL 166960 -->
-      Large <a href="/pkg/sync/#Pool"><code>Pool</code></a> no longer increase stop-the-world pause times.
-    </p>
-
-    <p><!-- CL 166961 -->
-      <code>Pool</code> no longer needs to be completely repopulated after every GC. It now retains some objects across GCs,
-      as opposed to releasing all objects, reducing load spikes for heavy users of <code>Pool</code>.
-    </p>
-
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 168479 -->
-      Uses of <code>_getdirentries64</code> have been removed from
-      Darwin builds, to allow Go binaries to be uploaded to the macOS
-      App Store.
-    </p>
-
-    <p><!-- CL 174197 -->
-      The new <code>ProcessAttributes</code> and <code>ThreadAttributes</code> fields in
-      <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> have been introduced for Windows,
-      exposing security settings when creating new processes.
-    </p>
-
-    <p><!-- CL 174320 -->
-      <code>EINVAL</code> is no longer returned in zero
-      <a href="/pkg/syscall/?GOOS=windows#Chmod"><code>Chmod</code></a> mode on Windows.
-    </p>
-
-    <p><!-- CL 191337 -->
-      Values of type <code>Errno</code> can be tested against error values in
-      the <code>os</code> package,
-      like <a href="/pkg/os/#ErrExist"><code>ErrExist</code></a>, using
-      <a href="/pkg/errors/#Is"><code>errors.Is</code></a>.
-    </p>
-
-</dl><!-- syscall -->
-
-<dl id="syscall/js"><dt><a href="/pkg/syscall/js/">syscall/js</a></dt>
-  <dd>
-    <p><!-- CL 177537 -->
-      <code>TypedArrayOf</code> has been replaced by
-      <a href="/pkg/syscall/js/#CopyBytesToGo"><code>CopyBytesToGo</code></a> and
-      <a href="/pkg/syscall/js/#CopyBytesToJS"><code>CopyBytesToJS</code></a> for copying bytes
-      between a byte slice and a <code>Uint8Array</code>.
-    </p>
-
-</dl><!-- syscall/js -->
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 112155 -->
-      When running benchmarks, <a href="/pkg/testing/#B.N"><code>B.N</code></a> is no longer rounded.
-    </p>
-
-    <p><!-- CL 166717 -->
-      The new method <a href="/pkg/testing/#B.ReportMetric"><code>B.ReportMetric</code></a> lets users report
-      custom benchmark metrics and override built-in metrics.
-    </p>
-
-    <p><!-- CL 173722 -->
-      Testing flags are now registered in the new <a href="/pkg/testing/#Init"><code>Init</code></a> function,
-      which is invoked by the generated <code>main</code> function for the test.
-      As a result, testing flags are now only registered when running a test binary,
-      and packages that call <code>flag.Parse</code> during package initialization may cause tests to fail.
-    </p>
-
-</dl><!-- testing -->
-
-<dl id="text/scanner"><dt><a href="/pkg/text/scanner/">text/scanner</a></dt>
-  <dd>
-    <p><!-- CL 183077 -->
-      The scanner has been updated to recognize the new Go number literals, specifically
-      binary literals with <code>0b</code>/<code>0B</code> prefix, octal literals with <code>0o</code>/<code>0O</code> prefix,
-      and floating-point numbers with hexadecimal mantissa.
-      Also, the new <a href="/pkg/text/scanner/#AllowDigitSeparators"><code>AllowDigitSeparators</code></a>
-      mode allows number literals to contain underscores as digit separators (off by default for backwards-compatibility).
-      See the <a href="#language">Changes to the language</a> for details.
-    </p>
-
-</dl><!-- text/scanner -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 161762 -->
-      The new <a href="/pkg/text/template/#hdr-Functions">slice function</a>
-      returns the result of slicing its first argument by the following arguments.
-    </p>
-
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 122876 -->
-      Day-of-year is now supported by <a href="/pkg/time/#Time.Format"><code>Format</code></a>
-      and <a href="/pkg/time/#Parse"><code>Parse</code></a>.
-    </p>
-
-    <p><!-- CL 167387 -->
-      The new <a href="/pkg/time/#Duration"><code>Duration</code></a> methods
-      <a href="/pkg/time/#Duration.Microseconds"><code>Microseconds</code></a> and
-      <a href="/pkg/time/#Duration.Milliseconds"><code>Milliseconds</code></a> return
-      the duration as an integer count of their respectively named units.
-    </p>
-
-</dl><!-- time -->
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-  <dd>
-    <p>
-      The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-      support throughout the system has been upgraded from Unicode 10.0 to
-      <a href="http://www.unicode.org/versions/Unicode11.0.0/">Unicode 11.0</a>,
-      which adds 684 new characters, including seven new scripts, and 66 new emoji.
-    </p>
-
-</dl><!-- unicode -->

diff --git a/doc/go1.14.html b/doc/go1.14.html
deleted file mode 100644 (file)
index 410e0cb..0000000
--- a/doc/go1.14.html
+++ /dev/null
@@ -1,924 +0,0 @@
-<!--{
-        "Title": "Go 1.14 Release Notes",
-        "Path":  "/doc/go1.14"
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.14</h2>
-
-<p>
-  The latest Go release, version 1.14, arrives six months after <a href="go1.13">Go 1.13</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-  Module support in the <code>go</code> command is now ready for production use,
-  and we encourage all users to <a href="https://blog.golang.org/migrating-to-go-modules">migrate to Go
-  modules for dependency management</a>. If you are unable to migrate due to a problem in the Go
-  toolchain, please ensure that the problem has an
-  <a href="https://golang.org/issue?q=is%3Aissue+is%3Aopen+label%3Amodules">open issue</a>
-  filed. (If the issue is not on the <code>Go1.15</code> milestone, please let us
-  know why it prevents you from migrating so that we can prioritize it
-  appropriately.)
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  Per the <a href="https://github.com/golang/proposal/blob/master/design/6977-overlapping-interfaces.md">overlapping interfaces proposal</a>,
-  Go 1.14 now permits embedding of interfaces with overlapping method sets:
-  methods from an embedded interface may have the same names and identical signatures
-  as methods already present in the (embedding) interface. This solves problems that typically
-  (but not exclusively) occur with diamond-shaped embedding graphs.
-  Explicitly declared methods in an interface must remain
-  <a href="https://tip.golang.org/ref/spec#Uniqueness_of_identifiers">unique</a>, as before.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  Go 1.14 is the last release that will run on macOS 10.11 El Capitan.
-  Go 1.15 will require macOS 10.12 Sierra or later.
-</p>
-
-<p><!-- golang.org/issue/34749 -->
-  Go 1.14 is the last Go release to support 32-bit binaries on
-  macOS (the <code>darwin/386</code> port). They are no longer
-  supported by macOS, starting with macOS 10.15 (Catalina).
-  Go continues to support the 64-bit <code>darwin/amd64</code> port.
-</p>
-
-<p><!-- golang.org/issue/34751 -->
-  Go 1.14 will likely be the last Go release to support 32-bit
-  binaries on iOS, iPadOS, watchOS, and tvOS
-  (the <code>darwin/arm</code> port). Go continues to support the
-  64-bit <code>darwin/arm64</code> port.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p><!-- CL 203601 -->
-  Go binaries on Windows now
-  have <a href="https://docs.microsoft.com/en-us/windows/win32/memory/data-execution-prevention">DEP
-  (Data Execution Prevention)</a> enabled.
-</p>
-
-<p><!-- CL 202439 -->
-  On Windows, creating a file
-  via <a href="/pkg/os#CreateFile"><code>os.OpenFile</code></a> with
-  the <a href="/pkg/os/#O_CREATE"><code>os.O_CREATE</code></a> flag, or
-  via <a href="/pkg/syscall#Open"><code>syscall.Open</code></a> with
-  the <a href="/pkg/syscall#O_CREAT"><code>syscall.O_CREAT</code></a>
-  flag, will now create the file as read-only if the
-  bit <code>0o200</code> (owner write permission) is not set in the
-  permission argument. This makes the behavior on Windows more like
-  that on Unix systems.
-</p>
-
-<h3 id="wasm">WebAssembly</h3>
-
-<p><!-- CL 203600 -->
-  JavaScript values referenced from Go via <code>js.Value</code>
-  objects can now be garbage collected.
-</p>
-
-<p><!-- CL 203600 -->
-  <code>js.Value</code> values can no longer be compared using
-  the <code>==</code> operator, and instead must be compared using
-  their <code>Equal</code> method.
-</p>
-
-<p><!-- CL 203600 -->
-  <code>js.Value</code> now
-  has <code>IsUndefined</code>, <code>IsNull</code>,
-  and <code>IsNaN</code> methods.
-</p>
-
-<h3 id="riscv">RISC-V</h3>
-
-<p><!-- Issue 27532 -->
-  Go 1.14 contains experimental support for 64-bit RISC-V on Linux
-  (<code>GOOS=linux</code>, <code>GOARCH=riscv64</code>). Be aware
-  that performance, assembly syntax stability, and possibly
-  correctness are a work in progress.
-</p>
-
-<h3 id="freebsd">FreeBSD</h3>
-
-<p><!-- CL 199919 -->
-  Go now supports the 64-bit ARM architecture on FreeBSD 12.0 or later (the
-  <code>freebsd/arm64</code> port).
-</p>
-
-<h3 id="nacl">Native Client (NaCl)</h3>
-
-<p><!-- golang.org/issue/30439 -->
-  As <a href="go1.13#ports">announced</a> in the Go 1.13 release notes,
-  Go 1.14 drops support for the Native Client platform (<code>GOOS=nacl</code>).
-</p>
-
-<h3 id="illumos">Illumos</h3>
-
-<p><!-- CL 203758 -->
-  The runtime now respects zone CPU caps
-  (the <code>zone.cpu-cap</code> resource control)
-  for <code>runtime.NumCPU</code> and the default value
-  of <code>GOMAXPROCS</code>.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="go-command">Go command</h3>
-
-<h4 id="vendor">Vendoring</h4>
-<!-- golang.org/issue/33848 -->
-
-<p>
-  When the main module contains a top-level <code>vendor</code> directory and
-  its <code>go.mod</code> file specifies <code>go</code> <code>1.14</code> or
-  higher, the <code>go</code> command now defaults to <code>-mod=vendor</code>
-  for operations that accept that flag. A new value for that flag,
-  <code>-mod=mod</code>, causes the <code>go</code> command to instead load
-  modules from the module cache (as when no <code>vendor</code> directory is
-  present).
-</p>
-
-<p>
-  When <code>-mod=vendor</code> is set (explicitly or by default), the
-  <code>go</code> command now verifies that the main module's
-  <code>vendor/modules.txt</code> file is consistent with its
-  <code>go.mod</code> file.
-</p>
-
-<p>
-  <code>go</code> <code>list</code> <code>-m</code> no longer silently omits
-  transitive dependencies that do not provide packages in
-  the <code>vendor</code> directory. It now fails explicitly if
-  <code>-mod=vendor</code> is set and information is requested for a module not
-  mentioned in <code>vendor/modules.txt</code>.
-</p>
-
-<h4 id="go-flags">Flags</h4>
-
-<p><!-- golang.org/issue/32502, golang.org/issue/30345 -->
-  The <code>go</code> <code>get</code> command no longer accepts
-  the <code>-mod</code> flag. Previously, the flag's setting either
-  <a href="https://golang.org/issue/30345">was ignored</a> or
-  <a href="https://golang.org/issue/32502">caused the build to fail</a>.
-</p>
-
-<p><!-- golang.org/issue/33326 -->
-  <code>-mod=readonly</code> is now set by default when the <code>go.mod</code>
-  file is read-only and no top-level <code>vendor</code> directory is present.
-</p>
-
-<p><!-- golang.org/issue/31481 -->
-  <code>-modcacherw</code> is a new flag that instructs the <code>go</code>
-  command to leave newly-created directories in the module cache at their
-  default permissions rather than making them read-only.
-  The use of this flag makes it more likely that tests or other tools will
-  accidentally add files not included in the module's verified checksum.
-  However, it allows the use of <code>rm</code> <code>-rf</code>
-  (instead of <code>go</code> <code>clean</code> <code>-modcache</code>)
-  to remove the module cache.
-</p>
-
-<p><!-- golang.org/issue/34506 -->
-  <code>-modfile=file</code> is a new flag that instructs the <code>go</code>
-  command to read (and possibly write) an alternate <code>go.mod</code> file
-  instead of the one in the module root directory. A file
-  named <code>go.mod</code> must still be present in order to determine the
-  module root directory, but it is not accessed. When <code>-modfile</code> is
-  specified, an alternate <code>go.sum</code> file is also used: its path is
-  derived from the <code>-modfile</code> flag by trimming the <code>.mod</code>
-  extension and appending <code>.sum</code>.
-</p>
-
-<h4 id="go-env-vars">Environment variables</h4>
-
-<p><!-- golang.org/issue/32966 -->
-  <code>GOINSECURE</code> is a new environment variable that instructs
-  the <code>go</code> command to not require an HTTPS connection, and to skip
-  certificate validation, when fetching certain modules directly from their
-  origins. Like the existing <code>GOPRIVATE</code> variable, the value
-  of <code>GOINSECURE</code> is a comma-separated list of glob patterns.
-</p>
-
-<h4 id="commands-outside-modules">Commands outside modules</h4>
-
-<p><!-- golang.org/issue/32027 -->
-  When module-aware mode is enabled explicitly (by setting
-  <code>GO111MODULE=on</code>), most module commands have more
-  limited functionality if no <code>go.mod</code> file is present. For
-  example, <code>go</code> <code>build</code>,
-  <code>go</code> <code>run</code>, and other build commands can only build
-  packages in the standard library and packages specified as <code>.go</code>
-  files on the command line.
-</p>
-
-<p>
-  Previously, the <code>go</code> command would resolve each package path
-  to the latest version of a module but would not record the module path
-  or version. This resulted in <a href="https://golang.org/issue/32027">slow,
-  non-reproducible builds</a>.
-</p>
-
-<p>
-  <code>go</code> <code>get</code> continues to work as before, as do
-  <code>go</code> <code>mod</code> <code>download</code> and
-  <code>go</code> <code>list</code> <code>-m</code> with explicit versions.
-</p>
-
-<h4 id="incompatible-versions"><code>+incompatible</code> versions</h4>
-<!-- golang.org/issue/34165 -->
-
-<p>
-  If the latest version of a module contains a <code>go.mod</code> file,
-  <code>go</code> <code>get</code> will no longer upgrade to an
-  <a href="/cmd/go/#hdr-Module_compatibility_and_semantic_versioning">incompatible</a>
-  major version of that module unless such a version is requested explicitly
-  or is already required.
-  <code>go</code> <code>list</code> also omits incompatible major versions
-  for such a module when fetching directly from version control, but may
-  include them if reported by a proxy.
-</p>
-
-
-<h4 id="go.mod"><code>go.mod</code> file maintenance</h4>
-<!-- golang.org/issue/34822 -->
-
-<p>
-  <code>go</code> commands other than
-  <code>go</code> <code>mod</code> <code>tidy</code> no longer
-  remove a <code>require</code> directive that specifies a version of an indirect dependency
-  that is already implied by other (transitive) dependencies of the main
-  module.
-</p>
-
-<p>
-  <code>go</code> commands other than
-  <code>go</code> <code>mod</code> <code>tidy</code> no longer
-  edit the <code>go.mod</code> file if the changes are only cosmetic.
-</p>
-
-<p>
-  When <code>-mod=readonly</code> is set, <code>go</code> commands will no
-  longer fail due to a missing <code>go</code> directive or an erroneous
-  <code>//&nbsp;indirect</code> comment.
-</p>
-
-<h4 id="module-downloading">Module downloading</h4>
-
-<p><!-- golang.org/issue/26092 -->
-  The <code>go</code> command now supports Subversion repositories in module mode.
-</p>
-
-<p><!-- golang.org/issue/30748 -->
-  The <code>go</code> command now includes snippets of plain-text error messages
-  from module proxies and other HTTP servers.
-  An error message will only be shown if it is valid UTF-8 and consists of only
-  graphic characters and spaces.
-</p>
-
-<h4 id="go-test">Testing</h4>
-
-<p><!-- golang.org/issue/24929 -->
-  <code>go test -v</code> now streams <code>t.Log</code> output as it happens,
-  rather than at the end of all tests.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 190098 -->
-  This release improves the performance of most uses
-  of <code>defer</code> to incur almost zero overhead compared to
-  calling the deferred function directly.
-  As a result, <code>defer</code> can now be used in
-  performance-critical code without overhead concerns.
-</p>
-
-<p><!-- CL 201760, CL 201762 and many others -->
-  Goroutines are now asynchronously preemptible.
-  As a result, loops without function calls no longer potentially
-  deadlock the scheduler or significantly delay garbage collection.
-  This is supported on all platforms except <code>windows/arm</code>,
-  <code>darwin/arm</code>, <code>js/wasm</code>, and
-  <code>plan9/*</code>.
-</p>
-
-<p>
-  A consequence of the implementation of preemption is that on Unix
-  systems, including Linux and macOS systems, programs built with Go
-  1.14 will receive more signals than programs built with earlier
-  releases.
-  This means that programs that use packages
-  like <a href="/pkg/syscall/"><code>syscall</code></a>
-  or <a href="https://godoc.org/golang.org/x/sys/unix"><code>golang.org/x/sys/unix</code></a>
-  will see more slow system calls fail with <code>EINTR</code> errors.
-  Those programs will have to handle those errors in some way, most
-  likely looping to try the system call again.  For more
-  information about this
-  see <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>man
-  7 signal</code></a> for Linux systems or similar documentation for
-  other systems.
-</p>
-
-<p><!-- CL 201765, CL 195701 and many others -->
-  The page allocator is more efficient and incurs significantly less
-  lock contention at high values of <code>GOMAXPROCS</code>.
-  This is most noticeable as lower latency and higher throughput for
-  large allocations being done in parallel and at a high rate.
-</p>
-
-<p><!-- CL 171844 and many others -->
-  Internal timers, used by
-  <a href="/pkg/time/#After"><code>time.After</code></a>,
-  <a href="/pkg/time/#Tick"><code>time.Tick</code></a>,
-  <a href="/pkg/net/#Conn"><code>net.Conn.SetDeadline</code></a>,
-  and friends, are more efficient, with less lock contention and fewer
-  context switches.
-  This is a performance improvement that should not cause any user
-  visible changes.
-</p>
-
-<h2 id="compiler">Compiler</h2>
-
-<p><!-- CL 162237 -->
-  This release adds <code>-d=checkptr</code> as a compile-time option
-  for adding instrumentation to check that Go code is following
-  <code>unsafe.Pointer</code> safety rules dynamically.
-  This option is enabled by default (except on Windows) with
-  the <code>-race</code> or <code>-msan</code> flags, and can be
-  disabled with <code>-gcflags=all=-d=checkptr=0</code>.
-  Specifically, <code>-d=checkptr</code> checks the following:
-</p>
-
-<ol>
-  <li>
-    When converting <code>unsafe.Pointer</code> to <code>*T</code>,
-    the resulting pointer must be aligned appropriately
-    for <code>T</code>.
-  </li>
-  <li>
-    If the result of pointer arithmetic points into a Go heap object,
-    one of the <code>unsafe.Pointer</code>-typed operands must point
-    into the same object.
-  </li>
-</ol>
-
-<p>
-  Using <code>-d=checkptr</code> is not currently recommended on
-  Windows because it causes false alerts in the standard library.
-</p>
-
-<p><!-- CL 204338 -->
-  The compiler can now emit machine-readable logs of key optimizations
-  using the <code>-json</code> flag, including inlining, escape
-  analysis, bounds-check elimination, and nil-check elimination.
-</p>
-
-<p><!-- CL 196959 -->
-  Detailed escape analysis diagnostics (<code>-m=2</code>) now work again.
-  This had been dropped from the new escape analysis implementation in
-  the previous release.
-</p>
-
-<p><!-- CL 196217 -->
-  All Go symbols in macOS binaries now begin with an underscore,
-  following platform conventions.
-</p>
-
-<p><!-- CL 202117 -->
-  This release includes experimental support for compiler-inserted
-  coverage instrumentation for fuzzing.
-  See <a href="https://golang.org/issue/14565">issue 14565</a> for more
-  details.
-  This API may change in future releases.
-</p>
-
-<p><!-- CL 174704 --><!-- CL 196784 -->
-  Bounds check elimination now uses information from slice creation and can
-  eliminate checks for indexes with types smaller than <code>int</code>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="hash/maphash">New byte sequence hashing package</h3>
-
-<p> <!-- golang.org/issue/28322, CL 186877 -->
-  Go 1.14 includes a new package,
-  <a href="/pkg/hash/maphash/"><code>hash/maphash</code></a>,
-  which provides hash functions on byte sequences.
-  These hash functions are intended to be used to implement hash tables or
-  other data structures that need to map arbitrary strings or byte
-  sequences to a uniform distribution on unsigned 64-bit integers.
-</p>
-<p>
-  The hash functions are collision-resistant but not cryptographically secure.
-</p>
-<p>
-  The hash value of a given byte sequence is consistent within a
-  single process, but will be different in different processes.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 191976 -->
-      Support for SSL version 3.0 (SSLv3) has been removed. Note that SSLv3 is the
-      <a href="https://tools.ietf.org/html/rfc7568">cryptographically broken</a>
-      protocol predating TLS.
-    </p>
-
-    <p><!-- CL 191999 -->
-      TLS 1.3 can't be disabled via the <code>GODEBUG</code> environment
-      variable anymore. Use the
-      <a href="/pkg/crypto/tls/#Config.MaxVersion"><code>Config.MaxVersion</code></a>
-      field to configure TLS versions.
-    </p>
-
-    <p><!-- CL 205059 -->
-      When multiple certificate chains are provided through the
-      <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a>
-      field, the first one compatible with the peer is now automatically
-      selected. This allows for example providing an ECDSA and an RSA
-      certificate, and letting the package automatically select the best one.
-      Note that the performance of this selection is going to be poor unless the
-      <a href="/pkg/crypto/tls/#Certificate.Leaf"><code>Certificate.Leaf</code></a>
-      field is set. The
-      <a href="/pkg/crypto/tls/#Config.NameToCertificate"><code>Config.NameToCertificate</code></a>
-      field, which only supports associating a single certificate with
-      a give name, is now deprecated and should be left as <code>nil</code>.
-      Similarly the
-      <a href="/pkg/crypto/tls/#Config.BuildNameToCertificate"><code>Config.BuildNameToCertificate</code></a>
-      method, which builds the <code>NameToCertificate</code> field
-      from the leaf certificates, is now deprecated and should not be
-      called.
-    </p>
-
-    <p><!-- CL 175517 -->
-      The new <a href="/pkg/crypto/tls/#CipherSuites"><code>CipherSuites</code></a>
-      and <a href="/pkg/crypto/tls/#InsecureCipherSuites"><code>InsecureCipherSuites</code></a>
-      functions return a list of currently implemented cipher suites.
-      The new <a href="/pkg/crypto/tls/#CipherSuiteName"><code>CipherSuiteName</code></a>
-      function returns a name for a cipher suite ID.
-    </p>
-
-    <p><!-- CL 205058, 205057 -->
-      The new <a href="/pkg/crypto/tls/#ClientHelloInfo.SupportsCertificate">
-      <code>(*ClientHelloInfo).SupportsCertificate</code></a> and
-      <a href="/pkg/crypto/tls/#CertificateRequestInfo.SupportsCertificate">
-      <code>(*CertificateRequestInfo).SupportsCertificate</code></a>
-      methods expose whether a peer supports a certain certificate.
-    </p>
-
-    <p><!-- CL 174329 -->
-      The <code>tls</code> package no longer supports the legacy Next Protocol
-      Negotiation (NPN) extension and now only supports ALPN. In previous
-      releases it supported both. There are no API changes and applications
-      should function identically as before. Most other clients and servers have
-      already removed NPN support in favor of the standardized ALPN.
-    </p>
-
-    <p><!-- CL 205063, 205062 -->
-      RSA-PSS signatures are now used when supported in TLS 1.2 handshakes. This
-      won't affect most applications, but custom
-      <a href="/pkg/crypto/tls/#Certificate.PrivateKey"><code>Certificate.PrivateKey</code></a>
-      implementations that don't support RSA-PSS signatures will need to use the new
-      <a href="/pkg/crypto/tls/#Certificate.SupportedSignatureAlgorithms">
-      <code>Certificate.SupportedSignatureAlgorithms</code></a>
-      field to disable them.
-    </p>
-
-    <p><!-- CL 205059, 205059 -->
-      <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a> and
-      <a href="/pkg/crypto/tls/#Config.GetCertificate"><code>Config.GetCertificate</code></a>
-      can now both be nil if
-      <a href="/pkg/crypto/tls/#Config.GetConfigForClient"><code>Config.GetConfigForClient</code></a>
-      is set. If the callbacks return neither certificates nor an error, the
-      <code>unrecognized_name</code> is now sent.
-    </p>
-
-    <p><!-- CL 205058 -->
-      The new <a href="/pkg/crypto/tls/#CertificateRequestInfo.Version"><code>CertificateRequestInfo.Version</code></a>
-      field provides the TLS version to client certificates callbacks.
-    </p>
-
-    <p><!-- CL 205068 -->
-      The new <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</code> and
-      <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256</code> constants use
-      the final names for the cipher suites previously referred to as
-      <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305</code> and
-      <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305</code>.
-    </p>
-  </dd>
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 204046 -->
-      <a href="/pkg/crypto/x509/#Certificate.CreateCRL"><code>Certificate.CreateCRL</code></a>
-      now supports Ed25519 issuers.
-    </p>
-  </dd>
-</dl>
-
-<dl id="debug/dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
-  <dd>
-    <p><!-- CL 175138 -->
-      The <code>debug/dwarf</code> package now supports reading DWARF
-      version 5.
-    </p>
-    <p>
-      The new
-      method <a href="/pkg/debug/dwarf/#Data.AddSection"><code>(*Data).AddSection</code></a>
-      supports adding arbitrary new DWARF sections from the input file
-      to the DWARF <code>Data</code>.
-    </p>
-
-    <p><!-- CL 192698 -->
-      The new
-      method <a href="/pkg/debug/dwarf/#Reader.ByteOrder"><code>(*Reader).ByteOrder</code></a>
-      returns the byte order of the current compilation unit.
-      This may be used to interpret attributes that are encoded in the
-      native ordering, such as location descriptions.
-    </p>
-
-    <p><!-- CL 192699 -->
-      The new
-      method <a href="/pkg/debug/dwarf/#LineReader.Files"><code>(*LineReader).Files</code></a>
-      returns the file name table from a line reader.
-      This may be used to interpret the value of DWARF attributes such
-      as <code>AttrDeclFile</code>.
-    </p>
-  </dd>
-</dl><!-- debug/dwarf -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 126624 -->
-      <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a>
-      now supports ASN.1 string type BMPString, represented by the new
-      <a href="/pkg/encoding/asn1/#TagBMPString"><code>TagBMPString</code></a>
-      constant.
-    </p>
-  </dd>
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-  <dd>
-    <p><!-- CL 200677 -->
-      The <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
-      type supports a new
-      method <a href="/pkg/encoding/json/#Decoder.InputOffset"><code>InputOffset</code></a>
-      that returns the input stream byte offset of the current
-      decoder position.
-    </p>
-
-    <p><!-- CL 200217 -->
-      <a href="/pkg/encoding/json/#Compact"><code>Compact</code></a> no longer
-      escapes the <code>U+2028</code> and <code>U+2029</code> characters, which
-      was never a documented feature. For proper escaping, see <a
-      href="/pkg/encoding/json/#HTMLEscape"><code>HTMLEscape</code></a>.
-    </p>
-
-    <p><!-- CL 195045 -->
-      <a href="/pkg/encoding/json/#Number"><code>Number</code></a> no longer
-      accepts invalid numbers, to follow the documented behavior more closely.
-      If a program needs to accept invalid numbers like the empty string,
-      consider wrapping the type with <a href="/pkg/encoding/json/#Unmarshaler"><code>Unmarshaler</code></a>.
-    </p>
-
-    <p><!-- CL 200237 -->
-      <a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>
-      can now support map keys with string underlying type which implement
-      <a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
-    </p>
-  </dd>
-</dl><!-- encoding/json -->
-
-<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
-  <dd>
-    <p><!-- CL 203820, 211657 -->
-      The <a href="/pkg/go/build/#Context"><code>Context</code></a>
-      type has a new field <code>Dir</code> which may be used to set
-      the working directory for the build.
-      The default is the current directory of the running process.
-      In module mode, this is used to locate the main module.
-    </p>
-  </dd>
-</dl><!-- go/build -->
-
-<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-  <dd>
-    <p><!-- CL 204830 -->
-      The new
-      function <a href="/pkg/go/doc/#NewFromFiles"><code>NewFromFiles</code></a>
-      computes package documentation from a list
-      of <code>*ast.File</code>'s and associates examples with the
-      appropriate package elements.
-      The new information is available in a new <code>Examples</code>
-      field
-      in the <a href="/pkg/go/doc/#Package"><code>Package</code></a>, <a href="/pkg/go/doc/#Type"><code>Type</code></a>,
-      and <a href="/pkg/go/doc/#Func"><code>Func</code></a> types, and a
-      new <a href="/pkg/go/doc/#Example.Suffix"><code>Suffix</code></a>
-      field in
-      the <a href="/pkg/go/doc/#Example"><code>Example</code></a>
-      type.
-    </p>
-  </dd>
-</dl><!-- go/doc -->
-
-<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
-  <dd>
-    <p><!-- CL 198488 -->
-      <a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a> can now create directories
-      whose names have predictable prefixes and suffixes.
-      As with <a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>, if the pattern
-      contains a '*', the random string replaces the last '*'.
-    </p>
-  </dd>
-</dl>
-
-<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
-  <dd>
-    <p><!-- CL 186182 -->
-      The
-      new <a href="https://tip.golang.org/pkg/log/#pkg-constants"><code>Lmsgprefix</code></a>
-      flag may be used to tell the logging functions to emit the
-      optional output prefix immediately before the log message rather
-      than at the start of the line.
-    </p>
-  </dd>
-</dl><!-- log -->
-
-<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
-  <dd>
-    <p><!-- CL 127458 -->
-      The new <a href="/pkg/math/#FMA"><code>FMA</code></a> function
-      computes <code>x*y+z</code> in floating point with no
-      intermediate rounding of the <code>x*y</code>
-      computation. Several architectures implement this computation
-      using dedicated hardware instructions for additional performance.
-    </p>
-  </dd>
-</dl><!-- math -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 164972 -->
-      The <a href="/pkg/math/big/#Int.GCD"><code>GCD</code></a> method
-      now allows the inputs <code>a</code> and <code>b</code> to be
-      zero or negative.
-    </p>
-  </dd>
-</dl><!-- math/big -->
-
-<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
-  <dd>
-    <p><!-- CL 197838 -->
-      The new functions
-      <a href="/pkg/math/bits/#Rem"><code>Rem</code></a>,
-      <a href="/pkg/math/bits/#Rem32"><code>Rem32</code></a>, and
-      <a href="/pkg/math/bits/#Rem64"><code>Rem64</code></a>
-      support computing a remainder even when the quotient overflows.
-    </p>
-  </dd>
-</dl><!-- math/bits -->
-
-<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
-  <dd>
-    <p><!-- CL 186927 -->
-      The default type of <code>.js</code> and <code>.mjs</code> files
-      is now <code>text/javascript</code> rather
-      than <code>application/javascript</code>.
-      This is in accordance
-      with <a href="https://datatracker.ietf.org/doc/draft-ietf-dispatch-javascript-mjs/">an
-      IETF draft</a> that treats <code>application/javascript</code> as obsolete.
-    </p>
-  </dd>
-</dl><!-- mime -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p>
-      The
-      new <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>
-      method <a href="/pkg/mime/multipart/#Reader.NextRawPart"><code>NextRawPart</code></a>
-      supports fetching the next MIME part without transparently
-      decoding <code>quoted-printable</code> data.
-    </p>
-  </dd>
-</dl><!-- mime/multipart -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 200760 -->
-      The new <a href="/pkg/net/http/#Header"><code>Header</code></a>
-      method <a href="/pkg/net/http/#Header.Values"><code>Values</code></a>
-      can be used to fetch all values associated with a
-      canonicalized key.
-    </p>
-
-    <p><!-- CL 61291 -->
-      The
-      new <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-      field <a href="/pkg/net/http/#Transport.DialTLSContext"><code>DialTLSContext</code></a>
-      can be used to specify an optional dial function for creating
-      TLS connections for non-proxied HTTPS requests.
-      This new field can be used instead
-      of <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a>,
-      which is now considered deprecated; <code>DialTLS</code> will
-      continue to work, but new code should
-      use <code>DialTLSContext</code>, which allows the transport to
-      cancel dials as soon as they are no longer needed.
-    </p>
-
-    <p><!-- CL 192518, CL 194218 -->
-      On Windows, <a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> now correctly
-      serves files larger than 2GB.
-    </p>
-  </dd>
-</dl><!-- net/http -->
-
-<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
-  <dd>
-    <p><!-- CL 201557 -->
-      The
-      new <a href="/pkg/net/http/httptest/#Server"><code>Server</code></a>
-      field <a href="/pkg/net/http/httptest/#Server.EnableHTTP2"><code>EnableHTTP2</code></a>
-      supports enabling HTTP/2 on the test server.
-    </p>
-  </dd>
-</dl><!-- net/http/httptest -->
-
-<dl id="net/textproto"><dt><a href="/pkg/net/textproto/">net/textproto</a></dt>
-  <dd>
-    <p><!-- CL 200760 -->
-      The
-      new <a href="/pkg/net/textproto/#MIMEHeader"><code>MIMEHeader</code></a>
-      method <a href="/pkg/net/textproto/#MIMEHeader.Values"><code>Values</code></a>
-      can be used to fetch all values associated with a canonicalized
-      key.
-    </p>
-  </dd>
-</dl><!-- net/textproto -->
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-    <p><!-- CL 185117 -->
-      When parsing of a URL fails
-      (for example by <a href="/pkg/net/url/#Parse"><code>Parse</code></a>
-      or <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>),
-      the resulting <a href="/pkg/net/url/#Error.Error"><code>Error</code></a> message
-      will now quote the unparsable URL.
-      This provides clearer structure and consistency with other parsing errors.
-    </p>
-  </dd>
-</dl><!-- net/url -->
-
-<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
-  <dd>
-    <p><!-- CL 187739 -->
-      On Windows,
-      the <code>CTRL_CLOSE_EVENT</code>, <code>CTRL_LOGOFF_EVENT</code>,
-      and <code>CTRL_SHUTDOWN_EVENT</code> events now generate
-      a <code>syscall.SIGTERM</code> signal, similar to how Control-C
-      and Control-Break generate a <code>syscall.SIGINT</code> signal.
-    </p>
-  </dd>
-</dl><!-- os/signal -->
-
-<dl id="plugin"><dt><a href="/pkg/plugin/">plugin</a></dt>
-  <dd>
-    <p><!-- CL 191617 -->
-      The <code>plugin</code> package now supports <code>freebsd/amd64</code>.
-    </p>
-  </dd>
-</dl><!-- plugin -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 85661 -->
-      <a href="/pkg/reflect#StructOf"><code>StructOf</code></a> now
-      supports creating struct types with unexported fields, by
-      setting the <code>PkgPath</code> field in
-      a <code>StructField</code> element.
-    </p>
-  </dd>
-</dl><!-- reflect -->
-
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p><!-- CL 200081 -->
-      <code>runtime.Goexit</code> can no longer be aborted by a
-      recursive <code>panic</code>/<code>recover</code>.
-    </p>
-
-    <p><!-- CL 188297, CL 191785 -->
-      On macOS, <code>SIGPIPE</code> is no longer forwarded to signal
-      handlers installed before the Go runtime is initialized.
-      This is necessary because macOS delivers <code>SIGPIPE</code>
-      <a href="https://golang.org/issue/33384">to the main thread</a>
-      rather than the thread writing to the closed pipe.
-    </p>
-  </dd>
-</dl><!-- runtime -->
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 204636, 205097 -->
-    The generated profile no longer includes the pseudo-PCs used for inline
-    marks. Symbol information of inlined functions is encoded in
-    <a href="https://github.com/google/pprof/blob/5e96527/proto/profile.proto#L177-L184">the format</a>
-    the pprof tool expects. This is a fix for the regression introduced
-    during recent releases.
-    </p>
-  </dd>
-</dl><!-- runtime/pprof -->
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p>
-      The <a href="/pkg/strconv/#NumError"><code>NumError</code></a>
-      type now has
-      an <a href="/pkg/strconv/#NumError.Unwrap"><code>Unwrap</code></a>
-      method that may be used to retrieve the reason that a conversion
-      failed.
-      This supports using <code>NumError</code> values
-      with <a href="/pkg/errors/#Is"><code>errors.Is</code></a> to see
-      if the underlying error
-      is <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrRange</code></a>
-      or <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrSyntax</code></a>.
-    </p>
-  </dd>
-</dl><!-- strconv -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 200577 -->
-      Unlocking a highly contended <code>Mutex</code> now directly
-      yields the CPU to the next goroutine waiting for
-      that <code>Mutex</code>. This significantly improves the
-      performance of highly contended mutexes on high CPU count
-      machines.
-    </p>
-  </dd>
-</dl><!-- sync -->
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 201359 -->
-       The testing package now supports cleanup functions, called after
-       a test or benchmark has finished, by calling
-       <a href="/pkg/testing#T.Cleanup"><code>T.Cleanup</code></a> or
-       <a href="/pkg/testing#B.Cleanup"><code>B.Cleanup</code></a> respectively.
-    </p>
-  </dd>
-</dl><!-- testing -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 206124 -->
-      The text/template package now correctly reports errors when a
-      parenthesized argument is used as a function.
-      This most commonly shows up in erroneous cases like
-      <code>{{if (eq .F "a") or (eq .F "b")}}</code>.
-      This should be written as <code>{{if or (eq .F "a") (eq .F "b")}}</code>.
-      The erroneous case never worked as expected, and will now be
-      reported with an error <code>can't give argument to non-function</code>.
-    </p>
-  </dd>
-</dl><!-- text/template -->
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-  <dd>
-    <p>
-      The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-      support throughout the system has been upgraded from Unicode 11.0 to
-      <a href="https://www.unicode.org/versions/Unicode12.0.0/">Unicode 12.0</a>,
-      which adds 554 new characters, including four new scripts, and 61 new emoji.
-    </p>
-  </dd>
-</dl><!-- unicode -->

diff --git a/doc/go1.15.html b/doc/go1.15.html
deleted file mode 100644 (file)
index c691bf3..0000000
--- a/doc/go1.15.html
+++ /dev/null
@@ -1,1051 +0,0 @@
-<!--{
-        "Title": "Go 1.15 Release Notes",
-        "Path":  "/doc/go1.15"
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.15</h2>
-
-<p>
-  The latest Go release, version 1.15, arrives six months after <a href="go1.14">Go 1.14</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-  Go 1.15 includes <a href="#linker">substantial improvements to the linker</a>,
-  improves <a href="#runtime">allocation for small objects at high core counts</a>, and
-  deprecates <a href="#commonname">X.509 CommonName</a>.
-  <code>GOPROXY</code> now supports skipping proxies that return errors and
-  a new <a href="#time/tzdata">embedded tzdata package</a> has been added.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  As <a href="go1.14#darwin">announced</a> in the Go 1.14 release
-  notes, Go 1.15 requires macOS 10.12 Sierra or later; support for
-  previous versions has been discontinued.
-</p>
-
-<p> <!-- golang.org/issue/37610, golang.org/issue/37611, CL 227582, and CL 227198  -->
-  As <a href="/doc/go1.14#darwin">announced</a> in the Go 1.14 release
-  notes, Go 1.15 drops support for 32-bit binaries on macOS, iOS,
-  iPadOS, watchOS, and tvOS (the <code>darwin/386</code>
-  and <code>darwin/arm</code> ports). Go continues to support the
-  64-bit <code>darwin/amd64</code> and <code>darwin/arm64</code> ports.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p> <!-- CL 214397 and CL 230217 -->
-  Go now generates Windows ASLR executables when <code>-buildmode=pie</code>
-  cmd/link flag is provided. Go command uses <code>-buildmode=pie</code>
-  by default on Windows.
-</p>
-
-<p><!-- CL 227003 -->
-  The <code>-race</code> and <code>-msan</code> flags now always
-  enable <code>-d=checkptr</code>, which checks uses
-  of <code>unsafe.Pointer</code>. This was previously the case on all
-  OSes except Windows.
-</p>
-
-<p><!-- CL 211139 -->
-  Go-built DLLs no longer cause the process to exit when it receives a
-  signal (such as Ctrl-C at a terminal).
-</p>
-
-<h3 id="android">Android</h3>
-
-<p> <!-- CL 235017, golang.org/issue/38838 -->
-  When linking binaries for Android, Go 1.15 explicitly selects
-  the <code>lld</code> linker available in recent versions of the NDK.
-  The <code>lld</code> linker avoids crashes on some devices, and is
-  planned to become the default NDK linker in a future NDK version.
-</p>
-
-<h3 id="openbsd">OpenBSD</h3>
-
-<p><!-- CL 234381 -->
-  Go 1.15 adds support for OpenBSD 6.7 on <code>GOARCH=arm</code>
-  and <code>GOARCH=arm64</code>. Previous versions of Go already
-  supported OpenBSD 6.7 on <code>GOARCH=386</code>
-  and <code>GOARCH=amd64</code>.
-</p>
-
-<h3 id="riscv">RISC-V</h3>
-
-<p> <!-- CL 226400, CL 226206, and others -->
-  There has been progress in improving the stability and performance
-  of the 64-bit RISC-V port on Linux (<code>GOOS=linux</code>,
-  <code>GOARCH=riscv64</code>). It also now supports asynchronous
-  preemption.
-</p>
-
-<h3 id="386">386</h3>
-
-<p><!-- golang.org/issue/40255 -->
-  Go 1.15 is the last release to support x87-only floating-point
-  hardware (<code>GO386=387</code>). Future releases will require at
-  least SSE2 support on 386, raising Go's
-  minimum <code>GOARCH=386</code> requirement to the Intel Pentium 4
-  (released in 2000) or AMD Opteron/Athlon 64 (released in 2003).
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="go-command">Go command</h3>
-
-<p><!-- golang.org/issue/37367 -->
-  The <code>GOPROXY</code> environment variable now supports skipping proxies
-  that return errors. Proxy URLs may now be separated with either commas
-  (<code>,</code>) or pipe characters (<code>|</code>). If a proxy URL is
-  followed by a comma, the <code>go</code> command will only try the next proxy
-  in the list after a 404 or 410 HTTP response. If a proxy URL is followed by a
-  pipe character, the <code>go</code> command will try the next proxy in the
-  list after any error. Note that the default value of <code>GOPROXY</code>
-  remains <code>https://proxy.golang.org,direct</code>, which does not fall
-  back to <code>direct</code> in case of errors.
-</p>
-
-<h4 id="go-test"><code>go</code> <code>test</code></h4>
-
-<p><!-- https://golang.org/issue/36134 -->
-  Changing the <code>-timeout</code> flag now invalidates cached test results. A
-  cached result for a test run with a long timeout will no longer count as
-  passing when <code>go</code> <code>test</code> is re-invoked with a short one.
-</p>
-
-<h4 id="go-flag-parsing">Flag parsing</h4>
-
-<p><!-- https://golang.org/cl/211358 -->
-  Various flag parsing issues in <code>go</code> <code>test</code> and
-  <code>go</code> <code>vet</code> have been fixed. Notably, flags specified
-  in <code>GOFLAGS</code> are handled more consistently, and
-  the <code>-outputdir</code> flag now interprets relative paths relative to the
-  working directory of the <code>go</code> command (rather than the working
-  directory of each individual test).
-</p>
-
-<h4 id="module-cache">Module cache</h4>
-
-<p><!-- https://golang.org/cl/219538 -->
-  The location of the module cache may now be set with
-  the <code>GOMODCACHE</code> environment variable. The default value of
-  <code>GOMODCACHE</code> is <code>GOPATH[0]/pkg/mod</code>, the location of the
-  module cache before this change.
-</p>
-
-<p><!-- https://golang.org/cl/221157 -->
-  A workaround is now available for Windows "Access is denied" errors in
-  <code>go</code> commands that access the module cache, caused by external
-  programs concurrently scanning the file system (see
-  <a href="https://golang.org/issue/36568">issue #36568</a>). The workaround is
-  not enabled by default because it is not safe to use when Go versions lower
-  than 1.14.2 and 1.13.10 are running concurrently with the same module cache.
-  It can be enabled by explicitly setting the environment variable
-  <code>GODEBUG=modcacheunzipinplace=1</code>.
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<h4 id="vet-string-int">New warning for string(x)</h4>
-
-<p><!-- CL 212919, 232660 -->
-  The vet tool now warns about conversions of the
-  form <code>string(x)</code> where <code>x</code> has an integer type
-  other than <code>rune</code> or <code>byte</code>.
-  Experience with Go has shown that many conversions of this form
-  erroneously assume that <code>string(x)</code> evaluates to the
-  string representation of the integer <code>x</code>.
-  It actually evaluates to a string containing the UTF-8 encoding of
-  the value of <code>x</code>.
-  For example, <code>string(9786)</code> does not evaluate to the
-  string <code>"9786"</code>; it evaluates to the
-  string <code>"\xe2\x98\xba"</code>, or <code>"☺"</code>.
-</p>
-
-<p>
-  Code that is using <code>string(x)</code> correctly can be rewritten
-  to <code>string(rune(x))</code>.
-  Or, in some cases, calling <code>utf8.EncodeRune(buf, x)</code> with
-  a suitable byte slice <code>buf</code> may be the right solution.
-  Other code should most likely use <code>strconv.Itoa</code>
-  or <code>fmt.Sprint</code>.
-</p>
-
-<p>
-  This new vet check is enabled by default when
-  using <code>go</code> <code>test</code>.
-</p>
-
-<p>
-  We are considering prohibiting the conversion in a future release of Go.
-  That is, the language would change to only
-  permit <code>string(x)</code> for integer <code>x</code> when the
-  type of <code>x</code> is <code>rune</code> or <code>byte</code>.
-  Such a language change would not be backward compatible.
-  We are using this vet check as a first trial step toward changing
-  the language.
-</p>
-
-<h4 id="vet-impossible-interface">New warning for impossible interface conversions</h4>
-
-<p><!-- CL 218779, 232660 -->
-  The vet tool now warns about type assertions from one interface type
-  to another interface type when the type assertion will always fail.
-  This will happen if both interface types implement a method with the
-  same name but with a different type signature.
-</p>
-
-<p>
-  There is no reason to write a type assertion that always fails, so
-  any code that triggers this vet check should be rewritten.
-</p>
-
-<p>
-  This new vet check is enabled by default when
-  using <code>go</code> <code>test</code>.
-</p>
-
-<p>
-  We are considering prohibiting impossible interface type assertions
-  in a future release of Go.
-  Such a language change would not be backward compatible.
-  We are using this vet check as a first trial step toward changing
-  the language.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 221779 -->
-  If <code>panic</code> is invoked with a value whose type is derived from any
-  of: <code>bool</code>, <code>complex64</code>, <code>complex128</code>, <code>float32</code>, <code>float64</code>,
-  <code>int</code>, <code>int8</code>, <code>int16</code>, <code>int32</code>, <code>int64</code>, <code>string</code>,
-  <code>uint</code>, <code>uint8</code>, <code>uint16</code>, <code>uint32</code>, <code>uint64</code>, <code>uintptr</code>,
-  then the value will be printed, instead of just its address.
-  Previously, this was only true for values of exactly these types.
-</p>
-
-<p><!-- CL 228900 -->
-  On a Unix system, if the <code>kill</code> command
-  or <code>kill</code> system call is used to send
-  a <code>SIGSEGV</code>, <code>SIGBUS</code>,
-  or <code>SIGFPE</code> signal to a Go program, and if the signal
-  is not being handled via
-  <a href="/pkg/os/signal/#Notify"><code>os/signal.Notify</code></a>,
-  the Go program will now reliably crash with a stack trace.
-  In earlier releases the behavior was unpredictable.
-</p>
-
-<p><!-- CL 221182, CL 229998 -->
-  Allocation of small objects now performs much better at high core
-  counts, and has lower worst-case latency.
-</p>
-
-<p><!-- CL 216401 -->
-  Converting a small integer value into an interface value no longer
-  causes allocation.
-</p>
-
-<p><!-- CL 216818 -->
-  Non-blocking receives on closed channels now perform as well as
-  non-blocking receives on open channels.
-</p>
-
-<h2 id="compiler">Compiler</h2>
-
-<p><!-- CL 229578 -->
-  Package <code>unsafe</code>'s <a href="/pkg/unsafe/#Pointer">safety
-  rules</a> allow converting an <code>unsafe.Pointer</code>
-  into <code>uintptr</code> when calling certain
-  functions. Previously, in some cases, the compiler allowed multiple
-  chained conversions (for example, <code>syscall.Syscall(…,</code>
-  <code>uintptr(uintptr(ptr)),</code> <code>…)</code>). The compiler
-  now requires exactly one conversion. Code that used multiple
-  conversions should be updated to satisfy the safety rules.
-</p>
-
-<p><!-- CL 230544, CL 231397 -->
-  Go 1.15 reduces typical binary sizes by around 5% compared to Go
-  1.14 by eliminating certain types of GC metadata and more
-  aggressively eliminating unused type metadata.
-</p>
-
-<p><!-- CL 219357, CL 231600 -->
-  The toolchain now mitigates
-  <a href="https://www.intel.com/content/www/us/en/support/articles/000055650/processors.html">Intel
-  CPU erratum SKX102</a> on <code>GOARCH=amd64</code> by aligning
-  functions to 32 byte boundaries and padding jump instructions. While
-  this padding increases binary sizes, this is more than made up for
-  by the binary size improvements mentioned above.
-</p>
-
-<p><!-- CL 222661 -->
-  Go 1.15 adds a <code>-spectre</code> flag to both the
-  compiler and the assembler, to allow enabling Spectre mitigations.
-  These should almost never be needed and are provided mainly as a
-  “defense in depth” mechanism.
-  See the <a href="https://github.com/golang/go/wiki/Spectre">Spectre wiki page</a> for details.
-</p>
-
-<p><!-- CL 228578 -->
-  The compiler now rejects <code>//go:</code> compiler directives that
-  have no meaning for the declaration they are applied to with a
-  "misplaced compiler directive" error. Such misapplied directives
-  were broken before, but were silently ignored by the compiler.
-</p>
-
-<p><!-- CL 206658, CL 205066 -->
-  The compiler's <code>-json</code> optimization logging now reports
-  large (>= 128 byte) copies and includes explanations of escape
-  analysis decisions.
-</p>
-
-<h2 id="linker">Linker</h2>
-
-<p>
-  This release includes substantial improvements to the Go linker,
-  which reduce linker resource usage (both time and memory) and
-  improve code robustness/maintainability.
-</p>
-
-<p>
-  For a representative set of large Go programs, linking is 20% faster
-  and requires 30% less memory on average, for <code>ELF</code>-based
-  OSes (Linux, FreeBSD, NetBSD, OpenBSD, Dragonfly, and Solaris)
-  running on <code>amd64</code> architectures, with more modest
-  improvements for other architecture/OS combinations.
-</p>
-
-<p>
-  The key contributors to better linker performance are a newly
-  redesigned object file format, and a revamping of internal
-  phases to increase concurrency (for example, applying relocations to
-  symbols in parallel). Object files in Go 1.15 are slightly larger
-  than their 1.14 equivalents.
-</p>
-
-<p>
-  These changes are part of a multi-release project
-  to <a href="https://golang.org/s/better-linker">modernize the Go
-  linker</a>, meaning that there will be additional linker
-  improvements expected in future releases.
-</p>
-
-<p><!-- CL 207877 -->
-  The linker now defaults to internal linking mode
-  for <code>-buildmode=pie</code> on
-  <code>linux/amd64</code> and <code>linux/arm64</code>, so these
-  configurations no longer require a C linker. External linking
-  mode (which was the default in Go 1.14 for
-  <code>-buildmode=pie</code>) can still be requested with
-  <code>-ldflags=-linkmode=external</code> flag.
-</p>
-
-<h2 id="objdump">Objdump</h2>
-
-<p><!-- CL 225459 -->
-  The <a href="/cmd/objdump/">objdump</a> tool now supports
-  disassembling in GNU assembler syntax with the <code>-gnu</code>
-  flag.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="time/tzdata">New embedded tzdata package</h3>
-
-<p> <!-- CL 224588 -->
-  Go 1.15 includes a new package,
-  <a href="/pkg/time/tzdata/"><code>time/tzdata</code></a>,
-  that permits embedding the timezone database into a program.
-  Importing this package (as <code>import _ "time/tzdata"</code>)
-  permits the program to find timezone information even if the
-  timezone database is not available on the local system.
-  You can also embed the timezone database by building
-  with <code>-tags timetzdata</code>.
-  Either approach increases the size of the program by about 800 KB.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p><!-- CL 235817 -->
-  Go 1.15 will translate the C type <code>EGLConfig</code> to the
-  Go type <code>uintptr</code>. This change is similar to how Go
-  1.12 and newer treats <code>EGLDisplay</code>, Darwin's CoreFoundation and
-  Java's JNI types. See the <a href="/cmd/cgo/#hdr-Special_cases">cgo
-  documentation</a> for more information.
-</p>
-
-<h3 id="commonname">X.509 CommonName deprecation</h3>
-
-<p><!-- CL 231379 -->
-  The deprecated, legacy behavior of treating the <code>CommonName</code>
-  field on X.509 certificates as a host name when no Subject Alternative Names
-  are present is now disabled by default. It can be temporarily re-enabled by
-  adding the value <code>x509ignoreCN=0</code> to the <code>GODEBUG</code>
-  environment variable.
-</p>
-
-<p>
-  Note that if the <code>CommonName</code> is an invalid host name, it's always
-  ignored, regardless of <code>GODEBUG</code> settings. Invalid names include
-  those with any characters other than letters, digits, hyphens and underscores,
-  and those with empty labels or trailing dots.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
-  <dd>
-    <p><!-- CL 225357, CL 225557 -->
-      When a <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> is
-      used with an invalid
-      <a href="/pkg/io/#Reader"><code>io.Reader</code></a> that
-      incorrectly returns a negative number from <code>Read</code>,
-      the <code>Scanner</code> will no longer panic, but will instead
-      return the new error
-      <a href="/pkg/bufio/#ErrBadReadCount"><code>ErrBadReadCount</code></a>.
-    </p>
-  </dd>
-</dl><!-- bufio -->
-
-<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
-  <dd>
-    <p><!-- CL 223777 -->
-      Creating a derived <code>Context</code> using a nil parent is now explicitly
-      disallowed. Any attempt to do so with the
-      <a href="/pkg/context/#WithValue"><code>WithValue</code></a>,
-      <a href="/pkg/context/#WithDeadline"><code>WithDeadline</code></a>, or
-      <a href="/pkg/context/#WithCancel"><code>WithCancel</code></a> functions
-      will cause a panic.
-    </p>
-  </dd>
-</dl><!-- context -->
-
-<dl id="crypto"><dt><a href="/pkg/crypto/">crypto</a></dt>
-  <dd>
-    <p><!-- CL 231417, CL 225460 -->
-      The <code>PrivateKey</code> and <code>PublicKey</code> types in the
-      <a href="/pkg/crypto/rsa/"><code>crypto/rsa</code></a>,
-      <a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
-      <a href="/pkg/crypto/ed25519/"><code>crypto/ed25519</code></a> packages
-      now have an <code>Equal</code> method to compare keys for equivalence
-      or to make type-safe interfaces for public keys. The method signature
-      is compatible with
-      <a href="https://pkg.go.dev/github.com/google/go-cmp/cmp#Equal"><code>go-cmp</code>'s
-      definition of equality</a>.
-    </p>
-
-    <p><!-- CL 224937 -->
-      <a href="/pkg/crypto/#Hash"><code>Hash</code></a> now implements
-      <a href="/pkg/fmt/#Stringer"><code>fmt.Stringer</code></a>.
-    </p>
-  </dd>
-</dl><!-- crypto -->
-
-<dl id="crypto/ecdsa"><dt><a href="/pkg/crypto/ecdsa/">crypto/ecdsa</a></dt>
-  <dd>
-    <p><!-- CL 217940 -->
-      The new <a href="/pkg/crypto/ecdsa/#SignASN1"><code>SignASN1</code></a>
-      and <a href="/pkg/crypto/ecdsa/#VerifyASN1"><code>VerifyASN1</code></a>
-      functions allow generating and verifying ECDSA signatures in the standard
-      ASN.1 DER encoding.
-    </p>
-  </dd>
-</dl><!-- crypto/ecdsa -->
-
-<dl id="crypto/elliptic"><dt><a href="/pkg/crypto/elliptic/">crypto/elliptic</a></dt>
-  <dd>
-    <p><!-- CL 202819 -->
-      The new <a href="/pkg/crypto/elliptic/#MarshalCompressed"><code>MarshalCompressed</code></a>
-      and <a href="/pkg/crypto/elliptic/#UnmarshalCompressed"><code>UnmarshalCompressed</code></a>
-      functions allow encoding and decoding NIST elliptic curve points in compressed format.
-    </p>
-  </dd>
-</dl><!-- crypto/elliptic -->
-
-<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
-  <dd>
-    <p><!-- CL 226203 -->
-      <a href="/pkg/crypto/rsa/#VerifyPKCS1v15"><code>VerifyPKCS1v15</code></a>
-      now rejects invalid short signatures with missing leading zeroes, according to RFC 8017.
-    </p>
-  </dd>
-</dl><!-- crypto/rsa -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 214977 -->
-      The new
-      <a href="/pkg/crypto/tls/#Dialer"><code>Dialer</code></a>
-      type and its
-      <a href="/pkg/crypto/tls/#Dialer.DialContext"><code>DialContext</code></a>
-      method permit using a context to both connect and handshake with a TLS server.
-    </p>
-
-    <p><!-- CL 229122 -->
-      The new
-      <a href="/pkg/crypto/tls/#Config.VerifyConnection"><code>VerifyConnection</code></a>
-      callback on the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> type
-      allows custom verification logic for every connection. It has access to the
-      <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-      which includes peer certificates, SCTs, and stapled OCSP responses.
-    </p>
-
-    <p><!-- CL 230679 -->
-      Auto-generated session ticket keys are now automatically rotated every 24 hours,
-      with a lifetime of 7 days, to limit their impact on forward secrecy.
-    </p>
-
-    <p><!-- CL 231317 -->
-      Session ticket lifetimes in TLS 1.2 and earlier, where the session keys
-      are reused for resumed connections, are now limited to 7 days, also to
-      limit their impact on forward secrecy.
-    </p>
-
-    <p><!-- CL 231038 -->
-      The client-side downgrade protection checks specified in RFC 8446 are now
-      enforced. This has the potential to cause connection errors for clients
-      encountering middleboxes that behave like unauthorized downgrade attacks.
-    </p>
-
-    <p><!-- CL 208226 -->
-      <a href="/pkg/crypto/tls/#SignatureScheme"><code>SignatureScheme</code></a>,
-      <a href="/pkg/crypto/tls/#CurveID"><code>CurveID</code></a>, and
-      <a href="/pkg/crypto/tls/#ClientAuthType"><code>ClientAuthType</code></a>
-      now implement <a href="/pkg/fmt/#Stringer"><code>fmt.Stringer</code></a>.
-    </p>
-
-    <p><!-- CL 236737 -->
-      The <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-      fields <code>OCSPResponse</code> and <code>SignedCertificateTimestamps</code>
-      are now repopulated on client-side resumed connections.
-    </p>
-
-    <p><!-- CL 227840 -->
-      <a href="/pkg/crypto/tls/#Conn"><code>tls.Conn</code></a>
-      now returns an opaque error on permanently broken connections, wrapping
-      the temporary
-      <a href="/pkg/net/http/#Error"><code>net.Error</code></a>. To access the
-      original <code>net.Error</code>, use
-      <a href="/pkg/errors/#As"><code>errors.As</code></a> (or
-      <a href="/pkg/errors/#Unwrap"><code>errors.Unwrap</code></a>) instead of a
-      type assertion.
-    </p>
-  </dd>
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 231378, CL 231380, CL 231381 -->
-      If either the name on the certificate or the name being verified (with
-      <a href="/pkg/crypto/x509/#VerifyOptions.DNSName"><code>VerifyOptions.DNSName</code></a>
-      or <a href="/pkg/crypto/x509/#Certificate.VerifyHostname"><code>VerifyHostname</code></a>)
-      are invalid, they will now be compared case-insensitively without further
-      processing (without honoring wildcards or stripping trailing dots).
-      Invalid names include those with any characters other than letters,
-      digits, hyphens and underscores, those with empty labels, and names on
-      certificates with trailing dots.
-    </p>
-
-    <p><!-- CL 217298 -->
-      The new <a href="/pkg/crypto/x509/#CreateRevocationList"><code>CreateRevocationList</code></a>
-      function and <a href="/pkg/crypto/x509/#RevocationList"><code>RevocationList</code></a> type
-      allow creating RFC 5280-compliant X.509 v2 Certificate Revocation Lists.
-    </p>
-
-    <p><!-- CL 227098 -->
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      now automatically generates the <code>SubjectKeyId</code> if the template
-      is a CA and doesn't explicitly specify one.
-    </p>
-
-    <p><!-- CL 228777 -->
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      now returns an error if the template specifies <code>MaxPathLen</code> but is not a CA.
-    </p>
-
-    <p><!-- CL 205237 -->
-      On Unix systems other than macOS, the <code>SSL_CERT_DIR</code>
-      environment variable can now be a colon-separated list.
-    </p>
-
-    <p><!-- CL 227037 -->
-      On macOS, binaries are now always linked against
-      <code>Security.framework</code> to extract the system trust roots,
-      regardless of whether cgo is available. The resulting behavior should be
-      more consistent with the OS verifier.
-    </p>
-  </dd>
-</dl><!-- crypto/x509 -->
-
-<dl id="crypto/x509/pkix"><dt><a href="/pkg/crypto/x509/pkix/">crypto/x509/pkix</a></dt>
-  <dd>
-    <p><!-- CL 229864, CL 240543 -->
-      <a href="/pkg/crypto/x509/pkix/#Name.String"><code>Name.String</code></a>
-      now prints non-standard attributes from
-      <a href="/pkg/crypto/x509/pkix/#Name.Names"><code>Names</code></a> if
-      <a href="/pkg/crypto/x509/pkix/#Name.ExtraNames"><code>ExtraNames</code></a> is nil.
-    </p>
-  </dd>
-</dl><!-- crypto/x509/pkix -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 145758 -->
-      The new <a href="/pkg/database/sql/#DB.SetConnMaxIdleTime"><code>DB.SetConnMaxIdleTime</code></a>
-      method allows removing a connection from the connection pool after
-      it has been idle for a period of time, without regard to the total
-      lifespan of the connection.  The <a href="/pkg/database/sql/#DBStats.MaxIdleTimeClosed"><code>DBStats.MaxIdleTimeClosed</code></a>
-      field shows the total number of connections closed due to
-      <code>DB.SetConnMaxIdleTime</code>.
-    </p>
-
-    <p><!-- CL 214317 -->
-      The new <a href="/pkg/database/sql/#Row.Err"><code>Row.Err</code></a> getter
-      allows checking for query errors without calling
-      <code>Row.Scan</code>.
-    </p>
-  </dd>
-</dl><!-- database/sql -->
-
-<dl id="database/sql/driver"><dt><a href="/pkg/database/sql/driver/">database/sql/driver</a></dt>
-  <dd>
-    <p><!-- CL 174122 -->
-      The new <a href="/pkg/database/sql/driver/#Validator"><code>Validator</code></a>
-      interface may be implemented by <code>Conn</code> to allow drivers
-      to signal if a connection is valid or if it should be discarded.
-    </p>
-  </dd>
-</dl><!-- database/sql/driver -->
-
-<dl id="debug/pe"><dt><a href="/pkg/debug/pe/">debug/pe</a></dt>
-  <dd>
-    <p><!-- CL 222637 -->
-      The package now defines the
-      <code>IMAGE_FILE</code>, <code>IMAGE_SUBSYSTEM</code>,
-      and <code>IMAGE_DLLCHARACTERISTICS</code> constants used by the
-      PE file format.
-    </p>
-  </dd>
-</dl><!-- debug/pe -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 226984 -->
-      <a href="/pkg/encoding/asn1/#Marshal"><code>Marshal</code></a> now sorts the components
-      of SET OF according to X.690 DER.
-    </p>
-
-    <p><!-- CL 227320 -->
-      <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects tags and
-      Object Identifiers which are not minimally encoded according to X.690 DER.
-    </p>
-  </dd>
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-  <dd>
-    <p><!-- CL 199837 -->
-      The package now has an internal limit to the maximum depth of
-      nesting when decoding. This reduces the possibility that a
-      deeply nested input could use large quantities of stack memory,
-      or even cause a "goroutine stack exceeds limit" panic.
-    </p>
-  </dd>
-</dl><!-- encoding/json -->
-
-<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
-  <dd>
-    <p><!-- CL 221427 -->
-      When the <code>flag</code> package sees <code>-h</code> or <code>-help</code>,
-      and those flags are not defined, it now prints a usage message.
-      If the <a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a> was created with
-      <a href="/pkg/flag/#ExitOnError"><code>ExitOnError</code></a>,
-      <a href="/pkg/flag/#FlagSet.Parse"><code>FlagSet.Parse</code></a> would then
-      exit with a status of 2. In this release, the exit status for <code>-h</code>
-      or <code>-help</code> has been changed to 0. In particular, this applies to
-      the default handling of command line flags.
-    </p>
-  </dd>
-</dl>
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 215001 -->
-      The printing verbs <code>%#g</code> and <code>%#G</code> now preserve
-      trailing zeros for floating-point values.
-    </p>
-  </dd>
-</dl><!-- fmt -->
-
-<dl id="go/format"><dt><a href="/pkg/go/format/">go/format</a></dt>
-  <dd>
-    <p><!-- golang.org/issue/37476, CL 231461, CL 240683 -->
-      The <a href="/pkg/go/format/#Source"><code>Source</code></a> and
-      <a href="/pkg/go/format/#Node"><code>Node</code></a> functions
-      now canonicalize number literal prefixes and exponents as part
-      of formatting Go source code. This matches the behavior of the
-      <a href="/pkg/cmd/gofmt/"><code>gofmt</code></a> command as it
-      was implemented <a href="/doc/go1.13#gofmt">since Go 1.13</a>.
-    </p>
-  </dd>
-</dl><!-- go/format -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 226097 -->
-      The package now uses Unicode escapes (<code>\uNNNN</code>) in all
-      JavaScript and JSON contexts. This fixes escaping errors in
-      <code>application/ld+json</code> and <code>application/json</code>
-      contexts.
-    </p>
-  </dd>
-</dl><!-- html/template -->
-
-<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
-  <dd>
-    <p><!-- CL 212597 -->
-      <a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a> and
-      <a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>
-      now reject patterns that contain path separators.
-      That is, calls such as <code>ioutil.TempFile("/tmp",</code> <code>"../base*")</code> will no longer succeed.
-      This prevents unintended directory traversal.
-    </p>
-  </dd>
-</dl><!-- io/ioutil -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 230397 -->
-      The new <a href="/pkg/math/big/#Int.FillBytes"><code>Int.FillBytes</code></a>
-      method allows serializing to fixed-size pre-allocated byte slices.
-    </p>
-  </dd>
-</dl><!-- math/big -->
-
-<dl id="math/cmplx"><dt><a href="/pkg/math/cmplx/">math/cmplx</a></dt>
-  <dd>
-    <p><!-- CL 220689 -->
-      The functions in this package were updated to conform to the C99 standard
-      (Annex G IEC 60559-compatible complex arithmetic) with respect to handling
-      of special arguments such as infinity, NaN and signed zero.
-    </p>
-  </dd>
-</dl><!-- math/cmplx-->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 228645 -->
-      If an I/O operation exceeds a deadline set by
-      the <a href="/pkg/net/#Conn"><code>Conn.SetDeadline</code></a>,
-      <code>Conn.SetReadDeadline</code>,
-      or <code>Conn.SetWriteDeadline</code> methods, it will now
-      return an error that is or wraps
-      <a href="/pkg/os/#ErrDeadlineExceeded"><code>os.ErrDeadlineExceeded</code></a>.
-      This may be used to reliably detect whether an error is due to
-      an exceeded deadline.
-      Earlier releases recommended calling the <code>Timeout</code>
-      method on the error, but I/O operations can return errors for
-      which <code>Timeout</code> returns <code>true</code> although a
-      deadline has not been exceeded.
-    </p>
-
-    <p><!-- CL 228641 -->
-      The new <a href="/pkg/net/#Resolver.LookupIP"><code>Resolver.LookupIP</code></a>
-      method supports IP lookups that are both network-specific and accept a context.
-    </p>
-  </dd>
-</dl>
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 231418, CL 231419 -->
-      Parsing is now stricter as a hardening measure against request smuggling attacks:
-      non-ASCII white space is no longer trimmed like SP and HTAB, and support for the
-      "<code>identity</code>" <code>Transfer-Encoding</code> was dropped.
-    </p>
-  </dd>
-</dl><!-- net/http -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 230937 -->
-      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      now supports not modifying the <code>X-Forwarded-For</code>
-      header when the incoming <code>Request.Header</code> map entry
-      for that field is <code>nil</code>.
-    </p>
-
-    <p><!-- CL 224897 -->
-      When a Switching Protocol (like WebSocket) request handled by
-      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      is canceled, the backend connection is now correctly closed.
-    </p>
-  </dd>
-</dl>
-
-<dl id="net/http/pprof"><dt><a href="/pkg/net/http/pprof/">net/http/pprof</a></dt>
-  <dd>
-    <p><!-- CL 147598, CL 229537 -->
-      All profile endpoints now support a "<code>seconds</code>" parameter. When present,
-      the endpoint profiles for the specified number of seconds and reports the difference.
-      The meaning of the "<code>seconds</code>" parameter in the <code>cpu</code> profile and
-      the trace endpoints is unchanged.
-    </p>
-  </dd>
-</dl>
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-    <p><!-- CL 227645 -->
-      The new <a href="/pkg/net/url/#URL"><code>URL</code></a> field
-      <code>RawFragment</code> and method <a href="/pkg/net/url/#URL.EscapedFragment"><code>EscapedFragment</code></a>
-      provide detail about and control over the exact encoding of a particular fragment.
-      These are analogous to
-      <code>RawPath</code> and <a href="/pkg/net/url/#URL.EscapedPath"><code>EscapedPath</code></a>.
-    </p>
-    <p><!-- CL 207082 -->
-      The new <a href="/pkg/net/url/#URL"><code>URL</code></a>
-      method <a href="/pkg/net/url/#URL.Redacted"><code>Redacted</code></a>
-      returns the URL in string form with any password replaced with <code>xxxxx</code>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL -->
-      If an I/O operation exceeds a deadline set by
-      the <a href="/pkg/os/#File.SetDeadline"><code>File.SetDeadline</code></a>,
-      <a href="/pkg/os/#File.SetReadDeadline"><code>File.SetReadDeadline</code></a>,
-      or <a href="/pkg/os/#File.SetWriteDeadline"><code>File.SetWriteDeadline</code></a>
-      methods, it will now return an error that is or wraps
-      <a href="/pkg/os/#ErrDeadlineExceeded"><code>os.ErrDeadlineExceeded</code></a>.
-      This may be used to reliably detect whether an error is due to
-      an exceeded deadline.
-      Earlier releases recommended calling the <code>Timeout</code>
-      method on the error, but I/O operations can return errors for
-      which <code>Timeout</code> returns <code>true</code> although a
-      deadline has not been exceeded.
-    </p>
-
-    <p><!-- CL 232862 -->
-      Packages <code>os</code> and <code>net</code> now automatically
-      retry system calls that fail with <code>EINTR</code>. Previously
-      this led to spurious failures, which became more common in Go
-      1.14 with the addition of asynchronous preemption. Now this is
-      handled transparently.
-    </p>
-
-    <p><!-- CL 229101 -->
-      The <a href="/pkg/os/#File"><code>os.File</code></a> type now
-      supports a <a href="/pkg/os/#File.ReadFrom"><code>ReadFrom</code></a>
-      method. This permits the use of the <code>copy_file_range</code>
-      system call on some systems when using
-      <a href="/pkg/io/#Copy"><code>io.Copy</code></a> to copy data
-      from one <code>os.File</code> to another. A consequence is that
-      <a href="/pkg/io/#CopyBuffer"><code>io.CopyBuffer</code></a>
-      will not always use the provided buffer when copying to a
-      <code>os.File</code>. If a program wants to force the use of
-      the provided buffer, it can be done by writing
-      <code>io.CopyBuffer(struct{ io.Writer }{dst}, src, buf)</code>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="plugin"><dt><a href="/pkg/plugin/">plugin</a></dt>
-  <dd>
-    <p><!-- CL 182959 -->
-      DWARF generation is now supported (and enabled by default) for <code>-buildmode=plugin</code> on macOS.
-    </p>
-  </dd>
-  <dd>
-    <p><!-- CL 191617 -->
-      Building with <code>-buildmode=plugin</code> is now supported on <code>freebsd/amd64</code>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 228902 -->
-      Package <code>reflect</code> now disallows accessing methods of all
-      non-exported fields, whereas previously it allowed accessing
-      those of non-exported, embedded fields. Code that relies on the
-      previous behavior should be updated to instead access the
-      corresponding promoted method of the enclosing variable.
-    </p>
-  </dd>
-</dl>
-
-<dl id="regexp"><dt><a href="/pkg/regexp/">regexp</a></dt>
-  <dd>
-    <p><!-- CL 187919 -->
-      The new <a href="/pkg/regexp/#Regexp.SubexpIndex"><code>Regexp.SubexpIndex</code></a>
-      method returns the index of the first subexpression with the given name
-      within the regular expression.
-    </p>
-  </dd>
-</dl><!-- regexp -->
-
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p><!-- CL 216557 -->
-      Several functions, including
-      <a href="/pkg/runtime/#ReadMemStats"><code>ReadMemStats</code></a>
-      and
-      <a href="/pkg/runtime/#GoroutineProfile"><code>GoroutineProfile</code></a>,
-      no longer block if a garbage collection is in progress.
-    </p>
-  </dd>
-</dl>
-
-<dl id="pkg-runtime-pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 189318 -->
-      The goroutine profile now includes the profile labels associated with each
-      goroutine at the time of profiling. This feature is not yet implemented for
-      the profile reported with <code>debug=2</code>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p><!-- CL 216617 -->
-      <a href="/pkg/strconv/#FormatComplex"><code>FormatComplex</code></a> and <a href="/pkg/strconv/#ParseComplex"><code>ParseComplex</code></a> are added for working with complex numbers.
-    </p>
-    <p>
-      <a href="/pkg/strconv/#FormatComplex"><code>FormatComplex</code></a> converts a complex number into a string of the form (a+bi), where a and b are the real and imaginary parts.
-    </p>
-    <p>
-      <a href="/pkg/strconv/#ParseComplex"><code>ParseComplex</code></a> converts a string into a complex number of a specified precision. <code>ParseComplex</code> accepts complex numbers in the format <code>N+Ni</code>.
-    </p>
-  </dd>
-</dl><!-- strconv -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 205899, golang.org/issue/33762 -->
-      The new method
-      <a href="/pkg/sync/#Map.LoadAndDelete"><code>Map.LoadAndDelete</code></a>
-      atomically deletes a key and returns the previous value if present.
-    </p>
-    <p><!-- CL 205899 -->
-      The method
-      <a href="/pkg/sync/#Map.Delete"><code>Map.Delete</code></a>
-      is more efficient.
-    </p>
-  </dd>
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 231638 -->
-      On Unix systems, functions that use
-      <a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a>
-      will now reject attempts to set both the <code>Setctty</code>
-      and <code>Foreground</code> fields, as they both use
-      the <code>Ctty</code> field but do so in incompatible ways.
-      We expect that few existing programs set both fields.
-    </p>
-    <p>
-      Setting the <code>Setctty</code> field now requires that the
-      <code>Ctty</code> field be set to a file descriptor number in the
-      child process, as determined by the <code>ProcAttr.Files</code> field.
-      Using a child descriptor always worked, but there were certain
-      cases where using a parent file descriptor also happened to work.
-      Some programs that set <code>Setctty</code> will need to change
-      the value of <code>Ctty</code> to use a child descriptor number.
-    </p>
-
-    <p><!-- CL 220578 -->
-      It is <a href="/pkg/syscall/#Proc.Call">now possible</a> to call
-      system calls that return floating point values
-      on <code>windows/amd64</code>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- golang.org/issue/28135 -->
-      The <code>testing.T</code> type now has a
-      <a href="/pkg/testing/#T.Deadline"><code>Deadline</code></a> method
-      that reports the time at which the test binary will have exceeded its
-      timeout.
-    </p>
-
-    <p><!-- golang.org/issue/34129 -->
-      A <code>TestMain</code> function is no longer required to call
-      <code>os.Exit</code>. If a <code>TestMain</code> function returns,
-      the test binary will call <code>os.Exit</code> with the value returned
-      by <code>m.Run</code>.
-    </p>
-
-    <p><!-- CL 226877, golang.org/issue/35998 -->
-       The new methods
-       <a href="/pkg/testing/#T.TempDir"><code>T.TempDir</code></a> and
-       <a href="/pkg/testing/#B.TempDir"><code>B.TempDir</code></a>
-       return temporary directories that are automatically cleaned up
-       at the end of the test.
-    </p>
-
-    <p><!-- CL 229085 -->
-      <code>go</code> <code>test</code> <code>-v</code> now groups output by
-      test name, rather than printing the test name on each line.
-    </p>
-  </dd>
-</dl><!-- testing -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 226097 -->
-      <a href="/pkg/text/template/#JSEscape"><code>JSEscape</code></a> now
-      consistently uses Unicode escapes (<code>\u00XX</code>), which are
-      compatible with JSON.
-    </p>
-  </dd>
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 220424, CL 217362, golang.org/issue/33184 -->
-       The new method
-       <a href="/pkg/time/#Ticker.Reset"><code>Ticker.Reset</code></a>
-       supports changing the duration of a ticker.
-    </p>
-
-    <p><!-- CL 227878 -->
-      When returning an error, <a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> now quotes the original value.
-    </p>
-  </dd>
-</dl><!-- time -->

diff --git a/doc/go1.16.html b/doc/go1.16.html
index 2ff763f9b628ee16cbbed068db3dd716b49b8a32..0beb62d160e0b98e9b0bcfd87168ce58966c931d 100644 (file)
--- a/doc/go1.16.html
+++ b/doc/go1.16.html
@@ -14,13 +14,13 @@ Do not send CLs removing the interior tags from such phrases.
   main ul li { margin: 0.5em 0; }
 </style>
 
-<h2 id="introduction">DRAFT RELEASE NOTES — Introduction to Go 1.16</h2>
+<h2 id="introduction">Introduction to Go 1.16</h2>
 
 <p>
-  <strong>
-    Go 1.16 is not yet released. These are work-in-progress
-    release notes. Go 1.16 is expected to be released in February 2021.
-  </strong>
+  The latest Go release, version 1.16, arrives six months after <a href="/doc/go1.15">Go 1.15</a>.
+  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+  We expect almost all Go programs to continue to compile and run as before.
 </p>
 
 <h2 id="language">Changes to the language</h2>
@@ -55,7 +55,9 @@ Do not send CLs removing the interior tags from such phrases.
   Go 1.16 adds an <code>ios/amd64</code> port, which targets the iOS
   simulator running on AMD64-based macOS. Previously this was
   unofficially supported through <code>darwin/amd64</code> with
-  the <code>ios</code> build tag set.
+  the <code>ios</code> build tag set. See also
+  <a href="/misc/ios/README"><code>misc/ios/README</code></a> for
+  details about how to build programs for iOS and iOS simulator.
 </p>
 
 <p><!-- golang.org/issue/23011 -->
@@ -78,6 +80,16 @@ Do not send CLs removing the interior tags from such phrases.
   support cgo.
 </p>
 
+<p><!-- golang.org/issue/36435, many CLs -->
+  On the 64-bit x86 and 64-bit ARM architectures on OpenBSD (the
+  <code>openbsd/amd64</code> and <code>openbsd/arm64</code> ports), system
+  calls are now made through <code>libc</code>, instead of directly using
+  the <code>SYSCALL</code>/<code>SVC</code> instruction. This ensures
+  forward-compatibility with future versions of OpenBSD. In particular,
+  OpenBSD 6.9 onwards will require system calls to be made through
+  <code>libc</code> for non-static Go binaries.
+</p>
+
 <h3 id="386">386</h3>
 
 <p><!-- golang.org/issue/40255, golang.org/issue/41848, CL 258957, and CL 260017 -->
@@ -144,7 +156,7 @@ Do not send CLs removing the interior tags from such phrases.
   <code>retract</code> directives may now be used in a <code>go.mod</code> file
   to indicate that certain published versions of the module should not be used
   by other modules. A module author may retract a version after a severe problem
-  is discovered or if the version was published unintentionally.<br>
+  is discovered or if the version was published unintentionally.
 </p>
 
 <p><!-- golang.org/issue/26603 -->
@@ -162,6 +174,14 @@ Do not send CLs removing the interior tags from such phrases.
   non-reproducible builds.
 </p>
 
+<p><!-- golang.org/issue/43052, golang.org/issue/43985 -->
+  In module mode, the <code>go</code> command now disallows import paths that
+  include non-ASCII characters or path elements with a leading dot character
+  (<code>.</code>). Module paths with these characters were already disallowed
+  (see <a href="/ref/mod#go-mod-file-ident">Module paths and versions</a>),
+  so this change affects only paths within module subdirectories.
+</p>
+
 <h4 id="embed">Embedding Files</h4>
 
 <p>
@@ -267,7 +287,7 @@ Do not send CLs removing the interior tags from such phrases.
   When the <code>-export</code> flag is specified, the <code>BuildID</code>
   field is now set to the build ID of the compiled package. This is equivalent
   to running <code>go</code> <code>tool</code> <code>buildid</code> on
-  <code>go</code> <code>list</code> <code>-exported</code> <code>-f</code> <code>{{.Export}</code>,
+  <code>go</code> <code>list</code> <code>-exported</code> <code>-f</code> <code>{{.Export}}</code>,
   but without the extra step.
 </p>
 
@@ -297,7 +317,7 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="vet">Vet</h3>
 
-<h4 id="vet-string-int">New warning for invalid testing.T use in
+<h4 id="vet-testing-T">New warning for invalid testing.T use in
 goroutines</h4>
 
 <p><!-- CL 235677 -->
@@ -346,6 +366,8 @@ func TestFoo(t *testing.T) {
 }
 </pre>
 
+<h4 id="vet-frame-pointer">New warning for frame pointer</h4>
+
 <p><!-- CL 248686, CL 276372 -->
   The vet tool now warns about amd64 assembly that clobbers the BP
   register (the frame pointer) without saving and restoring it,
@@ -358,6 +380,16 @@ func TestFoo(t *testing.T) {
   fixes.
 </p>
 
+<h4 id="vet-asn1-unmarshal">New warning for asn1.Unmarshal</h4>
+
+<p><!-- CL 243397 -->
+  The vet tool now warns about incorrectly passing a non-pointer or nil argument to
+  <a href="/pkg/encoding/asn1/#Unmarshal"><code>asn1.Unmarshal</code></a>.
+  This is like the existing checks for
+  <a href="/pkg/encoding/json/#Unmarshal"><code>encoding/json.Unmarshal</code></a>
+  and <a href="/pkg/encoding/xml/#Unmarshal"><code>encoding/xml.Unmarshal</code></a>.
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
@@ -379,7 +411,7 @@ func TestFoo(t *testing.T) {
   summarizing its execution time and memory allocation. This trace can
   be used to find bottlenecks or regressions in Go startup
   performance.
-  The <a href="/pkg/runtime/#hdr-Environment_Variables"><code>GODEBUG</code><
+  The <a href="/pkg/runtime/#hdr-Environment_Variables"><code>GODEBUG</code>
   documentation</a> describes the format.
 </p>
 
@@ -453,15 +485,15 @@ func TestFoo(t *testing.T) {
 
 <p>
   The new <a href="/pkg/io/fs/"><code>io/fs</code></a> package
-  defines an abstraction for read-only trees of files,
-  the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> interface,
-  and the standard library packages have
-  been adapted to make use of the interface as appropriate.
+  defines the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> interface,
+  an abstraction for read-only trees of files.
+  The standard library packages have been adapted to make use
+  of the interface as appropriate.
 </p>
 
 <p>
   On the producer side of the interface,
-  the new <a href="/pkg/embed/#FS">embed.FS</code></a> type
+  the new <a href="/pkg/embed/#FS"><code>embed.FS</code></a> type
   implements <code>fs.FS</code>, as does
   <a href="/pkg/archive/zip/#Reader"><code>zip.Reader</code></a>.
   The new <a href="/pkg/os/#DirFS"><code>os.DirFS</code></a> function
@@ -473,7 +505,7 @@ func TestFoo(t *testing.T) {
   On the consumer side,
   the new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
   function converts an <code>fs.FS</code> to an
-  <a href="/pkg/net/http/#Handler"><code>http.Handler</code></a>.
+  <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
   Also, the <a href="/pkg/html/template/"><code>html/template</code></a>
   and <a href="/pkg/text/template/"><code>text/template</code></a>
   packages’ <a href="/pkg/html/template/#ParseFS"><code>ParseFS</code></a>
@@ -491,6 +523,44 @@ func TestFoo(t *testing.T) {
   implementations.
 </p>
 
+<h3 id="ioutil">Deprecation of io/ioutil</h3>
+
+<p>
+  The <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package has
+  turned out to be a poorly defined and hard to understand collection
+  of things. All functionality provided by the package has been moved
+  to other packages. The <code>io/ioutil</code> package remains and
+  will continue to work as before, but we encourage new code to use
+  the new definitions in the <a href="/pkg/io/"><code>io</code></a> and
+  <a href="/pkg/os/"><code>os</code></a> packages.
+
+  Here is a list of the new locations of the names exported
+  by <code>io/ioutil</code>:
+  <ul>
+    <li><a href="/pkg/io/ioutil/#Discard"><code>Discard</code></a>
+      => <a href="/pkg/io/#Discard"><code>io.Discard</code></a></li>
+    <li><a href="/pkg/io/ioutil/#NopCloser"><code>NopCloser</code></a>
+      => <a href="/pkg/io/#NopCloser"><code>io.NopCloser</code></a></li>
+    <li><a href="/pkg/io/ioutil/#ReadAll"><code>ReadAll</code></a>
+      => <a href="/pkg/io/#ReadAll"><code>io.ReadAll</code></a></li>
+    <li><a href="/pkg/io/ioutil/#ReadDir"><code>ReadDir</code></a>
+      => <a href="/pkg/os/#ReadDir"><code>os.ReadDir</code></a>
+      (note: returns a slice of
+      <a href="/pkg/os/#DirEntry"><code>os.DirEntry</code></a>
+      rather than a slice of
+      <a href="/pkg/fs/#FileInfo"><code>fs.FileInfo</code></a>)
+    </li>
+    <li><a href="/pkg/io/ioutil/#ReadFile"><code>ReadFile</code></a>
+      => <a href="/pkg/os/#ReadFile"><code>os.ReadFile</code></a></li>
+    <li><a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a>
+      => <a href="/pkg/os/#MkdirTemp"><code>os.MkdirTemp</code></a></li>
+    <li><a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>
+      => <a href="/pkg/os/#CreateTemp"><code>os.CreateTemp</code></a></li>
+    <li><a href="/pkg/io/ioutil/#WriteFile"><code>WriteFile</code></a>
+      => <a href="/pkg/os/#WriteFile"><code>os.WriteFile</code></a></li>
+  </ul>
+</p>
+
 <!-- okay-after-beta1
   TODO: decide if any additional changes are worth factoring out from
   "Minor changes to the library" and highlighting in "Core library"
@@ -504,6 +574,16 @@ func TestFoo(t *testing.T) {
   in mind.
 </p>
 
+<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
+  <dd>
+    <p><!-- CL 243937 -->
+      The new <a href="/pkg/archive/zip/#Reader.Open"><code>Reader.Open</code></a>
+      method implements the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
+      interface.
+    </p>
+  </dd>
+</dl>
+
 <dl id="crypto/dsa"><dt><a href="/pkg/crypto/dsa/">crypto/dsa</a></dt>
   <dd>
     <p><!-- CL 257939 -->
@@ -539,16 +619,6 @@ func TestFoo(t *testing.T) {
       indefinitely.
     </p>
 
-    <p><!-- CL 246338 -->
-      The new <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>Conn.HandshakeContext</code></a>
-      method allows cancellation of an in-progress handshake. The provided
-      context is accessible through the new
-      <a href="/pkg/crypto/tls#ClientHelloInfo.Context"><code>ClientHelloInfo.Context</code></a>
-      and <a href="/pkg/crypto/tls#CertificateRequestInfo.Context">
-      <code>CertificateRequestInfo.Context</code></a> methods. Canceling the
-      context after the handshake has finished has no effect.
-    </p>
-
     <p><!-- CL 239748 -->
       Clients now return a handshake error if the server selects
       <a href="/pkg/crypto/tls/#ConnectionState.NegotiatedProtocol">
@@ -598,14 +668,6 @@ func TestFoo(t *testing.T) {
       a malformed certificate.
     </p>
 
-    <p><!-- CL 233163 -->
-      A number of additional fields have been added to the
-      <a href="/pkg/crypto/x509/#CertificateRequest"><code>CertificateRequest</code></a> type.
-      These fields are now parsed in <a href="/pkg/crypto/x509/#ParseCertificateRequest">
-      <code>ParseCertificateRequest</code></a> and marshalled in
-      <a href="/pkg/crypto/x509/#CreateCertificateRequest"><code>CreateCertificateRequest</code></a>.
-    </p>
-
     <p><!-- CL 257939 -->
       DSA signature verification is no longer supported. Note that DSA signature
       generation was never supported.
@@ -623,9 +685,27 @@ func TestFoo(t *testing.T) {
       method allows accessing the <a href="/pkg/crypto/x509/#SystemRootsError.Err"><code>Err</code></a>
       field through the <a href="/pkg/errors"><code>errors</code></a> package functions.
     </p>
+
+    <p><!-- CL 230025 -->
+      On Unix systems, the <code>crypto/x509</code> package is now more
+      efficient in how it stores its copy of the system cert pool.
+      Programs that use only a small number of roots will use around a
+      half megabyte less memory.
+    </p>
+
   </dd>
 </dl><!-- crypto/x509 -->
 
+<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+  <dd>
+    <p><!-- CL 255138 -->
+      More <a href="/pkg/debug/elf/#DT_NULL"><code>DT</code></a>
+      and <a href="/pkg/debug/elf/#PT_NULL"><code>PT</code></a>
+      constants have been added.
+    </p>
+  </dd>
+</dl><!-- debug/elf -->
+
 <dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1">encoding/asn1</a></dt>
   <dd>
     <p><!-- CL 255881 -->
@@ -675,12 +755,83 @@ func TestFoo(t *testing.T) {
   </dd>
 </dl><!-- flag -->
 
+<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
+  <dd>
+    <p><!-- CL 243941, CL 283636 -->
+      The <a href="/pkg/go/build/#Package"><code>Package</code></a>
+      struct has new fields that report information
+      about <code>//go:embed</code> directives in the package:
+      <a href="/pkg/go/build/#Package.EmbedPatterns"><code>EmbedPatterns</code></a>,
+      <a href="/pkg/go/build/#Package.EmbedPatternPos"><code>EmbedPatternPos</code></a>,
+      <a href="/pkg/go/build/#Package.TestEmbedPatterns"><code>TestEmbedPatterns</code></a>,
+      <a href="/pkg/go/build/#Package.TestEmbedPatternPos"><code>TestEmbedPatternPos</code></a>,
+      <a href="/pkg/go/build/#Package.XTestEmbedPatterns"><code>XTestEmbedPatterns</code></a>,
+      <a href="/pkg/go/build/#Package.XTestEmbedPatternPos"><code>XTestEmbedPatternPos</code></a>.
+    </p>
+
+    <p><!-- CL 240551 -->
+      The <a href="/pkg/go/build/#Package"><code>Package</code></a> field
+      <a href="/pkg/go/build/#Package.IgnoredGoFiles"><code>IgnoredGoFiles</code></a>
+      will no longer include files that start with "_" or ".",
+      as those files are always ignored.
+      <code>IgnoredGoFiles</code> is for files ignored because of
+      build constraints.
+    </p>
+
+    <p><!-- CL 240551 -->
+      The new <a href="/pkg/go/build/#Package"><code>Package</code></a>
+      field <a href="/pkg/go/build/#Package.IgnoredOtherFiles"><code>IgnoredOtherFiles</code></a>
+      has a list of non-Go files ignored because of build constraints.
+    </p>
+  </dd>
+</dl><!-- go/build -->
+
+<dl id="go/build/constraint"><dt><a href="/pkg/go/build/constraint/">go/build/constraint</a></dt>
+  <dd>
+    <p><!-- CL 240604 -->
+      The new
+      <a href="/pkg/go/build/constraint/"><code>go/build/constraint</code></a>
+      package parses build constraint lines, both the original
+      <code>// +build</code> syntax and the <code>//go:build</code>
+      syntax that will be introduced in Go 1.17.
+      This package exists so that tools built with Go 1.16 will be able
+      to process Go 1.17 source code.
+      See <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>
+      for details about the build constraint syntaxes and the planned
+      transition to the <code>//go:build</code> syntax.
+      Note that <code>//go:build</code> lines are <b>not</b> supported
+      in Go 1.16 and should not be introduced into Go programs yet.
+    </p>
+  </dd>
+</dl><!-- go/build/constraint -->
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+  <dd>
+    <p><!-- CL 243938 -->
+      The new <a href="/pkg/html/template/#ParseFS"><code>template.ParseFS</code></a>
+      function and <a href="/pkg/html/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
+      method are like <a href="/pkg/html/template/#ParseGlob"><code>template.ParseGlob</code></a>
+      and <a href="/pkg/html/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
+      but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
+    </p>
+  </dd>
+</dl><!-- html/template -->
+
 <dl id="io"><dt><a href="/pkg/io/">io</a></dt>
   <dd>
     <p><!-- CL 261577 -->
       The package now defines a
       <a href="/pkg/io/#ReadSeekCloser"><code>ReadSeekCloser</code></a> interface.
     </p>
+
+    <p><!-- CL 263141 -->
+      The package now defines
+      <a href="/pkg/io/#Discard"><code>Discard</code></a>,
+      <a href="/pkg/io/#NopCloser"><code>NopCloser</code></a>, and
+      <a href="/pkg/io/#ReadAll"><code>ReadAll</code></a>,
+      to be used instead of the same names in the
+      <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
+    </p>
   </dd>
 </dl><!-- io -->
 
@@ -721,8 +872,8 @@ func TestFoo(t *testing.T) {
     <p><!-- CL 250357 -->
       The case of I/O on a closed network connection, or I/O on a network
       connection that is closed before any of the I/O completes, can now
-      be detected using the new <a href="/pkg/net/#ErrClosed">ErrClosed</a> error.
-      A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
+      be detected using the new <a href="/pkg/net/#ErrClosed"><code>ErrClosed</code></a>
+      error. A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
       In earlier releases the only way to reliably detect this case was to
       match the string returned by the <code>Error</code> method
       with <code>"use of closed network connection"</code>.
@@ -771,24 +922,37 @@ func TestFoo(t *testing.T) {
       generating a SameSite key without a value.
     </p>
 
-    <p><!-- CL 246338 -->
-      The <a href="/pkg/net/http/"><code>net/http</code></a> package now passes the
-      <a href="/pkg/net/http/#Request.Context"><code>Request</code> context</a> to
-      <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>tls.Conn.HandshakeContext</code></a>
-      when performing TLS handshakes.
-    </p>
-
     <p><!-- CL 250039 -->
-      The <a href="/pkg/net/http/#Client">Client</a> now sends
+      The <a href="/pkg/net/http/#Client"><code>Client</code></a> now sends
       an explicit <code>Content-Length:</code> <code>0</code>
       header in <code>PATCH</code> requests with empty bodies,
       matching the existing behavior of <code>POST</code> and <code>PUT</code>.
     </p>
 
     <p><!-- CL 249440 -->
-      The <a href="/pkg/net/http/#ProxyFromEnvironment">ProxyFromEnvironment</a> function
-      no longer returns the setting of the <code>HTTP_PROXY</code> environment
-      variable for <code>https://</code> URLs when <code>HTTPS_PROXY</code> is unset.
+      The <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>
+      function no longer returns the setting of the <code>HTTP_PROXY</code>
+      environment variable for <code>https://</code> URLs when
+      <code>HTTPS_PROXY</code> is unset.
+    </p>
+
+    <p><!-- 259917 -->
+      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+      type has a new field
+      <a href="/pkg/net/http/#Transport.GetProxyConnectHeader"><code>GetProxyConnectHeader</code></a>
+      which may be set to a function that returns headers to send to a
+      proxy during a <code>CONNECT</code> request.
+      In effect <code>GetProxyConnectHeader</code> is a dynamic
+      version of the existing field
+      <a href="/pkg/net/http/#Transport.ProxyConnectHeader"><code>ProxyConnectHeader</code></a>;
+      if <code>GetProxyConnectHeader</code> is not <code>nil</code>,
+      then <code>ProxyConnectHeader</code> is ignored.
+    </p>
+
+    <p><!-- CL 243939 -->
+      The new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
+      function converts an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
+      to an <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
     </p>
   </dd>
 </dl><!-- net/http -->
@@ -796,7 +960,7 @@ func TestFoo(t *testing.T) {
 <dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
   <dd>
     <p><!-- CL 260637 -->
-      The <a href="/pkg/net/http/httputil/#ReverseProxy">ReverseProxy</a>
+      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
       now flushes buffered data more aggressively when proxying
       streamed responses with unknown body lengths.
     </p>
@@ -806,7 +970,7 @@ func TestFoo(t *testing.T) {
 <dl id="net/smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
   <dd>
     <p><!-- CL 247257 -->
-      The <a href="/pkg/net/smtp/#Client">Client</a>'s
+      The <a href="/pkg/net/smtp/#Client"><code>Client</code></a>'s
       <a href="/pkg/net/smtp/#Client.Mail"><code>Mail</code></a>
       method now sends the <code>SMTPUTF8</code> directive to
       servers that support it, signaling that addresses are encoded in UTF-8.
@@ -822,6 +986,52 @@ func TestFoo(t *testing.T) {
       instead of the unexported <code>errFinished</code> when the process has
       already finished.
     </p>
+
+    <p><!-- CL 261540 -->
+      The package defines a new type
+      <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>
+      as an alias for <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>.
+      The new <a href="/pkg/os/#ReadDir"><code>ReadDir</code></a>
+      function and the new
+      <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>
+      method can be used to read the contents of a directory into a
+      slice of <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>.
+      The <a href="/pkg/os/#File.Readdir"><code>File.Readdir</code></a>
+      method (note the lower case <code>d</code> in <code>dir</code>)
+      still exists, returning a slice of
+      <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>, but for
+      most programs it will be more efficient to switch to
+      <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>.
+    </p>
+
+    <p><!-- CL 263141 -->
+      The package now defines
+      <a href="/pkg/os/#CreateTemp"><code>CreateTemp</code></a>,
+      <a href="/pkg/os/#MkdirTemp"><code>MkdirTemp</code></a>,
+      <a href="/pkg/os/#ReadFile"><code>ReadFile</code></a>, and
+      <a href="/pkg/os/#WriteFile"><code>WriteFile</code></a>,
+      to be used instead of functions defined in the
+      <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
+    </p>
+
+    <p><!-- CL 243906 -->
+      The types <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>,
+      <a href="/pkg/os/#FileMode"><code>FileMode</code></a>, and
+      <a href="/pkg/os/#PathError"><code>PathError</code></a>
+      are now aliases for types of the same name in the
+      <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
+      Function signatures in the <a href="/pkg/os/"><code>os</code></a>
+      package have been updated to refer to the names in the
+      <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
+      This should not affect any existing code.
+    </p>
+
+    <p><!-- CL 243911 -->
+      The new <a href="/pkg/os/#DirFS"><code>DirFS</code></a> function
+      provides an implementation of
+      <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> backed by a tree
+      of operating system files.
+    </p>
   </dd>
 </dl><!-- os -->
 
@@ -839,9 +1049,9 @@ func TestFoo(t *testing.T) {
 <dl id="path"><dt><a href="/pkg/path/">path</a></dt>
   <dd>
     <p><!-- CL 264397, golang.org/issues/28614 -->
-      The <code>Match</code> and <code>Glob</code> functions now
-      return an error if the unmatched part of the pattern has a
-      syntax error. Previously, the functions returned early on a failed
+      The <a href="/pkg/path/#Match"><code>Match</code></a> function now
+      returns an error if the unmatched part of the pattern has a
+      syntax error. Previously, the function returned early on a failed
       match, and thus did not report any later syntax error in the
       pattern.
     </p>
@@ -850,8 +1060,24 @@ func TestFoo(t *testing.T) {
 
 <dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
   <dd>
+    <p><!-- CL 267887 -->
+      The new function
+      <a href="/pkg/path/filepath/#WalkDir"><code>WalkDir</code></a>
+      is similar to
+      <a href="/pkg/path/filepath/#Walk"><code>Walk</code></a>,
+      but is typically more efficient.
+      The function passed to <code>WalkDir</code> receives a
+      <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>
+      instead of a
+      <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>.
+      (To clarify for those who recall the <code>Walk</code> function
+      as taking an <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>,
+      <code>os.FileInfo</code> is now an alias for <code>fs.FileInfo</code>.)
+    </p>
+
     <p><!-- CL 264397, golang.org/issues/28614 -->
-      The <code>Match</code> and <code>Glob</code> functions now
+      The <a href="/pkg/path/filepath#Match"><code>Match</code></a> and
+      <a href="/pkg/path/filepath#Glob"><code>Glob</code></a> functions now
       return an error if the unmatched part of the pattern has a
       syntax error. Previously, the functions returned early on a failed
       match, and thus did not report any later syntax error in the
@@ -860,16 +1086,6 @@ func TestFoo(t *testing.T) {
   </dd>
 </dl><!-- path/filepath -->
 
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 248341, golang.org/issues/40281 -->
-      <code>StructTag</code> now allows multiple space-separated keys
-      in key:value pairs, as in <code>`json xml:"field1"`</code>
-      (equivalent to <code>`json:"field1" xml:"field1"`</code>).
-    </p>
-  </dd>
-</dl><!-- reflect -->
-
 <dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
   <dd>
     <p><!-- CL 249677 -->
@@ -907,11 +1123,11 @@ func TestFoo(t *testing.T) {
     </p>
 
     <p><!-- CL 261917 -->
-      <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> on Windows has a new NoInheritHandles field that disables inheriting handles when creating a new process.
+      <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> on Windows has a new <code>NoInheritHandles</code> field that disables inheriting handles when creating a new process.
     </p>
 
     <p><!-- CL 269761, golang.org/issue/42584 -->
-      <a href="/pkg/syscall/?GOOS=windows#DLLError"><code>DLLError</code></a> on Windows now has an Unwrap function for unwrapping its underlying error.
+      <a href="/pkg/syscall/?GOOS=windows#DLLError"><code>DLLError</code></a> on Windows now has an <code>Unwrap</code> method for unwrapping its underlying error.
     </p>
 
     <p><!-- CL 210639 -->
@@ -921,15 +1137,52 @@ func TestFoo(t *testing.T) {
       and related calls are now implemented.
       Previously, they returned an <code>syscall.EOPNOTSUPP</code> error.
     </p>
+
+    <p><!-- CL 210639 -->
+      On Linux, the new functions
+      <a href="/pkg/syscall/#AllThreadsSyscall"><code>AllThreadsSyscall</code></a>
+      and <a href="/pkg/syscall/#AllThreadsSyscall6"><code>AllThreadsSyscall6</code></a>
+      may be used to make a system call on all Go threads in the process.
+      These functions may only be used by programs that do not use cgo;
+      if a program uses cgo, they will always return
+      <a href="/pkg/syscall/#ENOTSUP"><code>syscall.ENOTSUP</code></a>.
+    </p>
   </dd>
 </dl><!-- syscall -->
 
+<dl id="testing/iotest"><dt><a href="/pkg/testing/iotest/">testing/iotest</a></dt>
+  <dd>
+    <p><!-- CL 199501 -->
+      The new
+      <a href="/pkg/testing/iotest/#ErrReader"><code>ErrReader</code></a>
+      function returns an
+      <a href="/pkg/io/#Reader"><code>io.Reader</code></a> that always
+      returns an error.
+    </p>
+
+    <p><!-- CL 243909 -->
+      The new
+      <a href="/pkg/testing/iotest/#TestReader"><code>TestReader</code></a>
+      function tests that an <a href="/pkg/io/#Reader"><code>io.Reader</code></a>
+      behaves correctly.
+    </p>
+  </dd>
+</dl><!-- testing/iotest -->
+
 <dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
   <dd>
     <p><!-- CL 254257, golang.org/issue/29770 -->
       Newlines characters are now allowed inside action delimiters,
       permitting actions to span multiple lines.
     </p>
+
+    <p><!-- CL 243938 -->
+      The new <a href="/pkg/text/template/#ParseFS"><code>template.ParseFS</code></a>
+      function and <a href="/pkg/text/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
+      method are like <a href="/pkg/text/template/#ParseGlob"><code>template.ParseGlob</code></a>
+      and <a href="/pkg/text/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
+      but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
+    </p>
   </dd>
 </dl><!-- text/template -->
 

diff --git a/doc/go1.2.html b/doc/go1.2.html
deleted file mode 100644 (file)
index 1f60514..0000000
--- a/doc/go1.2.html
+++ /dev/null
@@ -1,979 +0,0 @@
-<!--{
-       "Title": "Go 1.2 Release Notes",
-       "Path":  "/doc/go1.2",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.2</h2>
-
-<p>
-Since the release of <a href="/doc/go1.1.html">Go version 1.1</a> in April, 2013,
-the release schedule has been shortened to make the release process more efficient.
-This release, Go version 1.2 or Go 1.2 for short, arrives roughly six months after 1.1,
-while 1.1 took over a year to appear after 1.0.
-Because of the shorter time scale, 1.2 is a smaller delta than the step from 1.0 to 1.1,
-but it still has some significant developments, including
-a better scheduler and one new language feature.
-Of course, Go 1.2 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>.
-The overwhelming majority of programs built with Go 1.1 (or 1.0 for that matter)
-will run without any changes whatsoever when moved to 1.2,
-although the introduction of one restriction
-to a corner of the language may expose already-incorrect code
-(see the discussion of the <a href="#use_of_nil">use of nil</a>).
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-In the interest of firming up the specification, one corner case has been clarified,
-with consequences for programs.
-There is also one new language feature.
-</p>
-
-<h3 id="use_of_nil">Use of nil</h3>
-
-<p>
-The language now specifies that, for safety reasons,
-certain uses of nil pointers are guaranteed to trigger a run-time panic.
-For instance, in Go 1.0, given code like
-</p>
-
-<pre>
-type T struct {
-    X [1<<24]byte
-    Field int32
-}
-
-func main() {
-    var x *T
-    ...
-}
-</pre>
-
-<p>
-the <code>nil</code> pointer <code>x</code> could be used to access memory incorrectly:
-the expression <code>x.Field</code> could access memory at address <code>1<<24</code>.
-To prevent such unsafe behavior, in Go 1.2 the compilers now guarantee that any indirection through
-a nil pointer, such as illustrated here but also in nil pointers to arrays, nil interface values,
-nil slices, and so on, will either panic or return a correct, safe non-nil value.
-In short, any expression that explicitly or implicitly requires evaluation of a nil address is an error.
-The implementation may inject extra tests into the compiled program to enforce this behavior.
-</p>
-
-<p>
-Further details are in the
-<a href="//golang.org/s/go12nil">design document</a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Most code that depended on the old behavior is erroneous and will fail when run.
-Such programs will need to be updated by hand.
-</p>
-
-<h3 id="three_index">Three-index slices</h3>
-
-<p>
-Go 1.2 adds the ability to specify the capacity as well as the length when using a slicing operation
-on an existing array or slice.
-A slicing operation creates a new slice by describing a contiguous section of an already-created array or slice:
-</p>
-
-<pre>
-var array [10]int
-slice := array[2:4]
-</pre>
-
-<p>
-The capacity of the slice is the maximum number of elements that the slice may hold, even after reslicing;
-it reflects the size of the underlying array.
-In this example, the capacity of the <code>slice</code> variable is 8.
-</p>
-
-<p>
-Go 1.2 adds new syntax to allow a slicing operation to specify the capacity as well as the length.
-A second
-colon introduces the capacity value, which must be less than or equal to the capacity of the
-source slice or array, adjusted for the origin. For instance,
-</p>
-
-<pre>
-slice = array[2:4:7]
-</pre>
-
-<p>
-sets the slice to have the same length as in the earlier example but its capacity is now only 5 elements (7-2).
-It is impossible to use this new slice value to access the last three elements of the original array.
-</p>
-
-<p>
-In this three-index notation, a missing first index (<code>[:i:j]</code>) defaults to zero but the other
-two indices must always be specified explicitly.
-It is possible that future releases of Go may introduce default values for these indices.
-</p>
-
-<p>
-Further details are in the
-<a href="//golang.org/s/go12slice">design document</a>.
-</p>
-
-<p>
-<em>Updating</em>:
-This is a backwards-compatible change that affects no existing programs.
-</p>
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="preemption">Pre-emption in the scheduler</h3>
-
-<p>
-In prior releases, a goroutine that was looping forever could starve out other
-goroutines on the same thread, a serious problem when GOMAXPROCS
-provided only one user thread.
-In Go 1.2, this is partially addressed: The scheduler is invoked occasionally
-upon entry to a function.
-This means that any loop that includes a (non-inlined) function call can
-be pre-empted, allowing other goroutines to run on the same thread.
-</p>
-
-<h3 id="thread_limit">Limit on the number of threads</h3>
-
-<p>
-Go 1.2 introduces a configurable limit (default 10,000) to the total number of threads
-a single program may have in its address space, to avoid resource starvation
-issues in some environments.
-Note that goroutines are multiplexed onto threads so this limit does not directly
-limit the number of goroutines, only the number that may be simultaneously blocked
-in a system call.
-In practice, the limit is hard to reach.
-</p>
-
-<p>
-The new <a href="/pkg/runtime/debug/#SetMaxThreads"><code>SetMaxThreads</code></a> function in the
-<a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package controls the thread count limit.
-</p>
-
-<p>
-<em>Updating</em>:
-Few functions will be affected by the limit, but if a program dies because it hits the
-limit, it could be modified to call <code>SetMaxThreads</code> to set a higher count.
-Even better would be to refactor the program to need fewer threads, reducing consumption
-of kernel resources.
-</p>
-
-<h3 id="stack_size">Stack size</h3>
-
-<p>
-In Go 1.2, the minimum size of the stack when a goroutine is created has been lifted from 4KB to 8KB.
-Many programs were suffering performance problems with the old size, which had a tendency
-to introduce expensive stack-segment switching in performance-critical sections.
-The new number was determined by empirical testing.
-</p>
-
-<p>
-At the other end, the new function <a href="/pkg/runtime/debug/#SetMaxStack"><code>SetMaxStack</code></a>
-in the <a href="/pkg/runtime/debug"><code>runtime/debug</code></a> package controls
-the <em>maximum</em> size of a single goroutine's stack.
-The default is 1GB on 64-bit systems and 250MB on 32-bit systems.
-Before Go 1.2, it was too easy for a runaway recursion to consume all the memory on a machine.
-</p>
-
-<p>
-<em>Updating</em>:
-The increased minimum stack size may cause programs with many goroutines to use
-more memory. There is no workaround, but plans for future releases
-include new stack management technology that should address the problem better.
-</p>
-
-<h3 id="cgo_and_cpp">Cgo and C++</h3>
-
-<p>
-The <a href="/cmd/cgo/"><code>cgo</code></a> command will now invoke the C++
-compiler to build any pieces of the linked-to library that are written in C++;
-<a href="/cmd/cgo/">the documentation</a> has more detail.
-</p>
-
-<h3 id="go_tools_godoc">Godoc and vet moved to the go.tools subrepository</h3>
-
-<p>
-Both binaries are still included with the distribution, but the source code for the
-godoc and vet commands has moved to the
-<a href="//code.google.com/p/go.tools">go.tools</a> subrepository.
-</p>
-
-<p>
-Also, the core of the godoc program has been split into a
-<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fgodoc">library</a>,
-while the command itself is in a separate
-<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fcmd%2Fgodoc">directory</a>.
-The move allows the code to be updated easily and the separation into a library and command
-makes it easier to construct custom binaries for local sites and different deployment methods.
-</p>
-
-<p>
-<em>Updating</em>:
-Since godoc and vet are not part of the library,
-no client Go code depends on the their source and no updating is required.
-</p>
-
-<p>
-The binary distributions available from <a href="//golang.org">golang.org</a>
-include these binaries, so users of these distributions are unaffected.
-</p>
-
-<p>
-When building from source, users must use "go get" to install godoc and vet.
-(The binaries will continue to be installed in their usual locations, not
-<code>$GOPATH/bin</code>.)
-</p>
-
-<pre>
-$ go get code.google.com/p/go.tools/cmd/godoc
-$ go get code.google.com/p/go.tools/cmd/vet
-</pre>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-We expect the future GCC 4.9 release to include gccgo with full
-support for Go 1.2.
-In the current (4.8.2) release of GCC, gccgo implements Go 1.1.2.
-</p>
-
-<h3 id="gc_changes">Changes to the gc compiler and linker</h3>
-
-<p>
-Go 1.2 has several semantic changes to the workings of the gc compiler suite.
-Most users will be unaffected by them.
-</p>
-
-<p>
-The <a href="/cmd/cgo/"><code>cgo</code></a> command now
-works when C++ is included in the library being linked against.
-See the <a href="/cmd/cgo/"><code>cgo</code></a> documentation
-for details.
-</p>
-
-<p>
-The gc compiler displayed a vestigial detail of its origins when
-a program had no <code>package</code> clause: it assumed
-the file was in package <code>main</code>.
-The past has been erased, and a missing <code>package</code> clause
-is now an error.
-</p>
-
-<p>
-On the ARM, the toolchain supports "external linking", which
-is a step towards being able to build shared libraries with the gc
-toolchain and to provide dynamic linking support for environments
-in which that is necessary.
-</p>
-
-<p>
-In the runtime for the ARM, with <code>5a</code>, it used to be possible to refer
-to the runtime-internal <code>m</code> (machine) and <code>g</code>
-(goroutine) variables using <code>R9</code> and <code>R10</code> directly.
-It is now necessary to refer to them by their proper names.
-</p>
-
-<p>
-Also on the ARM, the <code>5l</code> linker (sic) now defines the
-<code>MOVBS</code> and <code>MOVHS</code> instructions
-as synonyms of <code>MOVB</code> and <code>MOVH</code>,
-to make clearer the separation between signed and unsigned
-sub-word moves; the unsigned versions already existed with a
-<code>U</code> suffix.
-</p>
-
-<h3 id="cover">Test coverage</h3>
-
-<p>
-One major new feature of <a href="/pkg/go/"><code>go test</code></a> is
-that it can now compute and, with help from a new, separately installed
-"go tool cover" program, display test coverage results.
-</p>
-
-<p>
-The cover tool is part of the
-<a href="https://code.google.com/p/go/source/checkout?repo=tools"><code>go.tools</code></a>
-subrepository.
-It can be installed by running
-</p>
-
-<pre>
-$ go get code.google.com/p/go.tools/cmd/cover
-</pre>
-
-<p>
-The cover tool does two things.
-First, when "go test" is given the <code>-cover</code> flag, it is run automatically 
-to rewrite the source for the package and insert instrumentation statements.
-The test is then compiled and run as usual, and basic coverage statistics are reported:
-</p>
-
-<pre>
-$ go test -cover fmt
-ok     fmt     0.060s  coverage: 91.4% of statements
-$
-</pre>
-
-<p>
-Second, for more detailed reports, different flags to "go test" can create a coverage profile file,
-which the cover program, invoked with "go tool cover", can then analyze.
-</p>
-
-<p>
-Details on how to generate and analyze coverage statistics can be found by running the commands
-</p>
-
-<pre>
-$ go help testflag
-$ go tool cover -help
-</pre>
-
-<h3 id="go_doc">The go doc command is deleted</h3>
-
-<p>
-The "go doc" command is deleted.
-Note that the <a href="/cmd/godoc/"><code>godoc</code></a> tool itself is not deleted,
-just the wrapping of it by the <a href="/cmd/go/"><code>go</code></a> command.
-All it did was show the documents for a package by package path,
-which godoc itself already does with more flexibility.
-It has therefore been deleted to reduce the number of documentation tools and,
-as part of the restructuring of godoc, encourage better options in future.
-</p>
-
-<p>
-<em>Updating</em>: For those who still need the precise functionality of running
-</p>
-
-<pre>
-$ go doc
-</pre>
-
-<p>
-in a directory, the behavior is identical to running
-</p>
-
-<pre>
-$ godoc .
-</pre>
-
-<h3 id="gocmd">Changes to the go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go get</code></a> command
-now has a <code>-t</code> flag that causes it to download the dependencies
-of the tests run by the package, not just those of the package itself.
-By default, as before, dependencies of the tests are not downloaded.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-There are a number of significant performance improvements in the standard library; here are a few of them.
-</p>
-
-<ul> 
-
-<li>
-The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
-decompresses about 30% faster.
-</li>
-
-<li>
-The <a href="/pkg/crypto/des/"><code>crypto/des</code></a> package
-is about five times faster.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-encodes about 30% faster.
-</li>
-
-<li>
-Networking performance on Windows and BSD systems is about 30% faster through the use
-of an integrated network poller in the runtime, similar to what was done for Linux and OS X
-in Go 1.1.
-</li>
-
-</ul>
-
-<h2 id="library">Changes to the standard library</h2>
-
-
-<h3 id="archive_tar_zip">The archive/tar and archive/zip packages</h3>
-
-<p>
-The
-<a href="/pkg/archive/tar/"><code>archive/tar</code></a>
-and
-<a href="/pkg/archive/zip/"><code>archive/zip</code></a>
-packages have had a change to their semantics that may break existing programs.
-The issue is that they both provided an implementation of the
-<a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>
-interface that was not compliant with the specification for that interface.
-In particular, their <code>Name</code> method returned the full
-path name of the entry, but the interface specification requires that
-the method return only the base name (final path element).
-</p>
-
-<p>
-<em>Updating</em>: Since this behavior was newly implemented and
-a bit obscure, it is possible that no code depends on the broken behavior.
-If there are programs that do depend on it, they will need to be identified
-and fixed manually.
-</p>
-
-<h3 id="encoding">The new encoding package</h3>
-
-<p>
-There is a new package, <a href="/pkg/encoding/"><code>encoding</code></a>,
-that defines a set of standard encoding interfaces that may be used to
-build custom marshalers and unmarshalers for packages such as
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a>,
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a>,
-and
-<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>.
-These new interfaces have been used to tidy up some implementations in
-the standard library.
-</p>
-
-<p>
-The new interfaces are called
-<a href="/pkg/encoding/#BinaryMarshaler"><code>BinaryMarshaler</code></a>,
-<a href="/pkg/encoding/#BinaryUnmarshaler"><code>BinaryUnmarshaler</code></a>,
-<a href="/pkg/encoding/#TextMarshaler"><code>TextMarshaler</code></a>,
-and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>TextUnmarshaler</code></a>.
-Full details are in the <a href="/pkg/encoding/">documentation</a> for the package
-and a separate <a href="//golang.org/s/go12encoding">design document</a>.
-</p>
-
-<h3 id="fmt_indexed_arguments">The fmt package</h3>
-
-<p>
-The <a href="/pkg/fmt/"><code>fmt</code></a> package's formatted print
-routines such as <a href="/pkg/fmt/#Printf"><code>Printf</code></a>
-now allow the data items to be printed to be accessed in arbitrary order
-by using an indexing operation in the formatting specifications.
-Wherever an argument is to be fetched from the argument list for formatting,
-either as the value to be formatted or as a width or specification integer,
-a new optional indexing notation <code>[</code><em>n</em><code>]</code>
-fetches argument <em>n</em> instead.
-The value of <em>n</em> is 1-indexed.
-After such an indexing operating, the next argument to be fetched by normal
-processing will be <em>n</em>+1.
-</p>
-
-<p>
-For example, the normal <code>Printf</code> call
-</p>
-
-<pre>
-fmt.Sprintf("%c %c %c\n", 'a', 'b', 'c')
-</pre>
-
-<p>
-would create the string <code>"a b c"</code>, but with indexing operations like this,
-</p>
-
-<pre>
-fmt.Sprintf("%[3]c %[1]c %c\n", 'a', 'b', 'c')
-</pre>
-
-<p>
-the result is "<code>"c a b"</code>. The <code>[3]</code> index accesses the third formatting
-argument, which is <code>'c'</code>, <code>[1]</code> accesses the first, <code>'a'</code>,
-and then the next fetch accesses the argument following that one, <code>'b'</code>.
-</p>
-
-<p>
-The motivation for this feature is programmable format statements to access
-the arguments in different order for localization, but it has other uses:
-</p>
-
-<pre>
-log.Printf("trace: value %v of type %[1]T\n", expensiveFunction(a.b[c]))
-</pre>
-
-<p>
-<em>Updating</em>: The change to the syntax of format specifications
-is strictly backwards compatible, so it affects no working programs.
-</p>
-
-<h3 id="text_template">The text/template and html/template packages</h3>
-
-<p>
-The
-<a href="/pkg/text/template/"><code>text/template</code></a> package
-has a couple of changes in Go 1.2, both of which are also mirrored in the
-<a href="/pkg/html/template/"><code>html/template</code></a> package.
-</p>
-
-<p>
-First, there are new default functions for comparing basic types.
-The functions are listed in this table, which shows their names and
-the associated familiar comparison operator.
-</p>
-
-<table cellpadding="0" summary="Template comparison functions">
-<tr>
-<th width="50"></th><th width="100">Name</th> <th width="50">Operator</th>
-</tr>
-<tr>
-<td></td><td><code>eq</code></td> <td><code>==</code></td>
-</tr>
-<tr>
-<td></td><td><code>ne</code></td> <td><code>!=</code></td>
-</tr>
-<tr>
-<td></td><td><code>lt</code></td> <td><code>&lt;</code></td>
-</tr>
-<tr>
-<td></td><td><code>le</code></td> <td><code>&lt;=</code></td>
-</tr>
-<tr>
-<td></td><td><code>gt</code></td> <td><code>&gt;</code></td>
-</tr>
-<tr>
-<td></td><td><code>ge</code></td> <td><code>&gt;=</code></td>
-</tr>
-</table>
-
-<p>
-These functions behave slightly differently from the corresponding Go operators.
-First, they operate only on basic types (<code>bool</code>, <code>int</code>,
-<code>float64</code>, <code>string</code>, etc.).
-(Go allows comparison of arrays and structs as well, under some circumstances.)
-Second, values can be compared as long as they are the same sort of value:
-any signed integer value can be compared to any other signed integer value for example. (Go
-does not permit comparing an <code>int8</code> and an <code>int16</code>).
-Finally, the <code>eq</code> function (only) allows comparison of the first
-argument with one or more following arguments. The template in this example,
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1 2 3 {{"}}"}} equal {{"{{"}}else{{"}}"}} not equal {{"{{"}}end{{"}}"}}
-</pre>
-
-<p>
-reports "equal" if <code>.A</code> is equal to <em>any</em> of 1, 2, or 3.
-</p>
-
-<p>
-The second change is that a small addition to the grammar makes "if else if" chains easier to write.
-Instead of writing,
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else{{"}}"}} {{"{{"}}if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}} {{"{{"}}end{{"}}"}} 
-</pre>
-
-<p>
-one can fold the second "if" into the "else" and have only one "end", like this:
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}}
-</pre>
-
-<p>
-The two forms are identical in effect; the difference is just in the syntax.
-</p>
-
-<p>
-<em>Updating</em>: Neither the "else if" change nor the comparison functions
-affect existing programs. Those that
-already define functions called <code>eq</code> and so on through a function
-map are unaffected because the associated function map will override the new
-default function definitions.
-</p>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-There are two new packages.
-</p>
-
-<ul>
-<li>
-The <a href="/pkg/encoding/"><code>encoding</code></a> package is
-<a href="#encoding">described above</a>.
-</li>
-<li>
-The <a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package
-provides standard color palettes.
-</li>
-</ul>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package
-adds the
-<a href="/pkg/archive/zip/#File.DataOffset"><code>DataOffset</code></a> accessor
-to return the offset of a file's (possibly compressed) data within the archive.
-</li>
-
-<li>
-The <a href="/pkg/bufio/"><code>bufio</code></a> package
-adds <a href="/pkg/bufio/#Reader.Reset"><code>Reset</code></a>
-methods to <a href="/pkg/bufio/#Reader"><code>Reader</code></a> and
-<a href="/pkg/bufio/#Writer"><code>Writer</code></a>.
-These methods allow the <a href="/pkg/io/#Reader"><code>Readers</code></a>
-and <a href="/pkg/io/#Writer"><code>Writers</code></a>
-to be re-used on new input and output readers and writers, saving
-allocation overhead. 
-</li>
-
-<li>
-The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
-can now decompress concatenated archives.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>
-package adds a <a href="/pkg/compress/flate/#Writer.Reset"><code>Reset</code></a> 
-method on the <a href="/pkg/compress/flate/#Writer"><code>Writer</code></a>,
-to make it possible to reduce allocation when, for instance, constructing an
-archive to hold multiple compressed files.
-</li>
-
-<li>
-The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package's
-<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a> type adds a
-<a href="/pkg/compress/gzip/#Writer.Reset"><code>Reset</code></a>
-so it may be reused.
-</li>
-
-<li>
-The <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> package's
-<a href="/pkg/compress/zlib/#Writer"><code>Writer</code></a> type adds a
-<a href="/pkg/compress/zlib/#Writer.Reset"><code>Reset</code></a>
-so it may be reused.
-</li>
-
-<li>
-The <a href="/pkg/container/heap/"><code>container/heap</code></a> package
-adds a <a href="/pkg/container/heap/#Fix"><code>Fix</code></a>
-method to provide a more efficient way to update an item's position in the heap.
-</li>
-
-<li>
-The <a href="/pkg/container/list/"><code>container/list</code></a> package
-adds the <a href="/pkg/container/list/#List.MoveBefore"><code>MoveBefore</code></a>
-and
-<a href="/pkg/container/list/#List.MoveAfter"><code>MoveAfter</code></a>
-methods, which implement the obvious rearrangement.
-</li>
-
-<li>
-The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package
-adds the a new GCM mode (Galois Counter Mode), which is almost always
-used with AES encryption.
-</li>
-
-<li>
-The 
-<a href="/pkg/crypto/md5/"><code>crypto/md5</code></a> package
-adds a new <a href="/pkg/crypto/md5/#Sum"><code>Sum</code></a> function
-to simplify hashing without sacrificing performance.
-</li>
-
-<li>
-Similarly, the 
-<a href="/pkg/crypto/md5/"><code>crypto/sha1</code></a> package
-adds a new <a href="/pkg/crypto/sha1/#Sum"><code>Sum</code></a> function.
-</li>
-
-<li>
-Also, the
-<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a> package
-adds <a href="/pkg/crypto/sha256/#Sum256"><code>Sum256</code></a>
-and <a href="/pkg/crypto/sha256/#Sum224"><code>Sum224</code></a> functions.
-</li>
-
-<li>
-Finally, the <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a> package
-adds <a href="/pkg/crypto/sha512/#Sum512"><code>Sum512</code></a> and
-<a href="/pkg/crypto/sha512/#Sum384"><code>Sum384</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-adds support for reading and writing arbitrary extensions.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package adds
-support for TLS 1.1, 1.2 and AES-GCM.
-</li>
-
-<li>
-The <a href="/pkg/database/sql/"><code>database/sql</code></a> package adds a
-<a href="/pkg/database/sql/#DB.SetMaxOpenConns"><code>SetMaxOpenConns</code></a>
-method on <a href="/pkg/database/sql/#DB"><code>DB</code></a> to limit the
-number of open connections to the database.
-</li>
-
-<li>
-The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package
-now always allows trailing commas on fields.
-</li>
-
-<li>
-The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package
-now treats channel and function fields of structures as if they were unexported,
-even if they are not. That is, it ignores them completely. Previously they would
-trigger an error, which could cause unexpected compatibility problems if an
-embedded structure added such a field.
-The package also now supports the generic <code>BinaryMarshaler</code> and
-<code>BinaryUnmarshaler</code> interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now will always escape ampersands as "\u0026" when printing strings.
-It will now accept but correct invalid UTF-8 in
-<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
-(such input was previously rejected).
-Finally, it now supports the generic encoding interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above.
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
-now allows attributes stored in pointers to be marshaled.
-It also supports the generic encoding interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above through the new
-<a href="/pkg/encoding/xml/#Marshaler"><code>Marshaler</code></a>,
-<a href="/pkg/encoding/xml/#Unmarshaler"><code>Unmarshaler</code></a>,
-and related
-<a href="/pkg/encoding/xml/#MarshalerAttr"><code>MarshalerAttr</code></a> and
-<a href="/pkg/encoding/xml/#UnmarshalerAttr"><code>UnmarshalerAttr</code></a>
-interfaces.
-The package also adds a
-<a href="/pkg/encoding/xml/#Encoder.Flush"><code>Flush</code></a> method
-to the
-<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>
-type for use by custom encoders. See the documentation for
-<a href="/pkg/encoding/xml/#Encoder.EncodeToken"><code>EncodeToken</code></a>
-to see how to use it.
-</li>
-
-<li>
-The <a href="/pkg/flag/"><code>flag</code></a> package now
-has a <a href="/pkg/flag/#Getter"><code>Getter</code></a> interface
-to allow the value of a flag to be retrieved. Due to the
-Go 1 compatibility guidelines, this method cannot be added to the existing
-<a href="/pkg/flag/#Value"><code>Value</code></a>
-interface, but all the existing standard flag types implement it.
-The package also now exports the <a href="/pkg/flag/#CommandLine"><code>CommandLine</code></a>
-flag set, which holds the flags from the command line.
-</li>
-
-<li>
-The <a href="/pkg/go/ast/"><code>go/ast</code></a> package's
-<a href="/pkg/go/ast/#SliceExpr"><code>SliceExpr</code></a> struct
-has a new boolean field, <code>Slice3</code>, which is set to true
-when representing a slice expression with three indices (two colons).
-The default is false, representing the usual two-index form.
-</li>
-
-<li>
-The <a href="/pkg/go/build/"><code>go/build</code></a> package adds
-the <code>AllTags</code> field
-to the <a href="/pkg/go/build/#Package"><code>Package</code></a> type,
-to make it easier to process build tags.
-</li>
-
-<li>
-The <a href="/pkg/image/draw/"><code>image/draw</code></a> package now
-exports an interface, <a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>,
-that wraps the standard <a href="/pkg/image/draw/#Draw"><code>Draw</code></a> method.
-The Porter-Duff operators now implement this interface, in effect binding an operation to
-the draw operator rather than providing it explicitly.
-Given a paletted image as its destination, the new
-<a href="/pkg/image/draw/#FloydSteinberg"><code>FloydSteinberg</code></a>
-implementation of the
-<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
-interface will use the Floyd-Steinberg error diffusion algorithm to draw the image.
-To create palettes suitable for such processing, the new
-<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> interface
-represents implementations of quantization algorithms that choose a palette
-given a full-color image.
-There are no implementations of this interface in the library.
-</li>
-
-<li>
-The <a href="/pkg/image/gif/"><code>image/gif</code></a> package
-can now create GIF files using the new
-<a href="/pkg/image/gif/#Encode"><code>Encode</code></a>
-and <a href="/pkg/image/gif/#EncodeAll"><code>EncodeAll</code></a>
-functions.
-Their options argument allows specification of an image
-<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> to use;
-if it is <code>nil</code>, the generated GIF will use the 
-<a href="/pkg/image/color/palette/#Plan9"><code>Plan9</code></a>
-color map (palette) defined in the new
-<a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package.
-The options also specify a
-<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
-to use to create the output image;
-if it is <code>nil</code>, Floyd-Steinberg error diffusion is used.
-</li>
-
-<li>
-The <a href="/pkg/io/#Copy"><code>Copy</code></a> method of the
-<a href="/pkg/io/"><code>io</code></a> package now prioritizes its
-arguments differently.
-If one argument implements <a href="/pkg/io/#WriterTo"><code>WriterTo</code></a>
-and the other implements <a href="/pkg/io/#ReaderFrom"><code>ReaderFrom</code></a>,
-<a href="/pkg/io/#Copy"><code>Copy</code></a> will now invoke
-<a href="/pkg/io/#WriterTo"><code>WriterTo</code></a> to do the work,
-so that less intermediate buffering is required in general.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package requires cgo by default
-because the host operating system must in general mediate network call setup.
-On some systems, though, it is possible to use the network without cgo, and useful
-to do so, for instance to avoid dynamic linking.
-The new build tag <code>netgo</code> (off by default) allows the construction of a
-<code>net</code> package in pure Go on those systems where it is possible.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package adds a new field
-<code>DualStack</code> to the <a href="/pkg/net/#Dialer"><code>Dialer</code></a>
-struct for TCP connection setup using a dual IP stack as described in
-<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package will no longer
-transmit cookies that are incorrect according to
-<a href="https://tools.ietf.org/html/rfc6265">RFC 6265</a>.
-It just logs an error and sends nothing.
-Also,
-the <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#ReadResponse"><code>ReadResponse</code></a>
-function now permits the <code>*Request</code> parameter to be <code>nil</code>,
-whereupon it assumes a GET request.
-Finally, an HTTP server will now serve HEAD
-requests transparently, without the need for special casing in handler code.
-While serving a HEAD request, writes to a 
-<a href="/pkg/net/http/#Handler"><code>Handler</code></a>'s
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
-are absorbed by the
-<a href="/pkg/net/http/#Server"><code>Server</code></a>
-and the client receives an empty body as required by the HTTP specification.
-</li>
-
-<li>
-The <a href="/pkg/os/exec/"><code>os/exec</code></a> package's 
-<a href="/pkg/os/exec/#Cmd.StdinPipe"><code>Cmd.StdinPipe</code></a> method 
-returns an <code>io.WriteCloser</code>, but has changed its concrete
-implementation from <code>*os.File</code> to an unexported type that embeds
-<code>*os.File</code>, and it is now safe to close the returned value.
-Before Go 1.2, there was an unavoidable race that this change fixes.
-Code that needs access to the methods of <code>*os.File</code> can use an
-interface type assertion, such as <code>wc.(interface{ Sync() error })</code>.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package relaxes
-the constraints on finalizer functions in
-<a href="/pkg/runtime/#SetFinalizer"><code>SetFinalizer</code></a>: the
-actual argument can now be any type that is assignable to the formal type of
-the function, as is the case for any normal function call in Go.
-</li>
-
-<li>
-The <a href="/pkg/sort/"><code>sort</code></a> package has a new
-<a href="/pkg/sort/#Stable"><code>Stable</code></a> function that implements
-stable sorting. It is less efficient than the normal sort algorithm, however.
-</li>
-
-<li>
-The <a href="/pkg/strings/"><code>strings</code></a> package adds
-an <a href="/pkg/strings/#IndexByte"><code>IndexByte</code></a>
-function for consistency with the <a href="/pkg/bytes/"><code>bytes</code></a> package.
-</li>
-
-<li>
-The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package
-adds a new set of swap functions that atomically exchange the argument with the
-value stored in the pointer, returning the old value.
-The functions are
-<a href="/pkg/sync/atomic/#SwapInt32"><code>SwapInt32</code></a>,
-<a href="/pkg/sync/atomic/#SwapInt64"><code>SwapInt64</code></a>,
-<a href="/pkg/sync/atomic/#SwapUint32"><code>SwapUint32</code></a>,
-<a href="/pkg/sync/atomic/#SwapUint64"><code>SwapUint64</code></a>,
-<a href="/pkg/sync/atomic/#SwapUintptr"><code>SwapUintptr</code></a>,
-and
-<a href="/pkg/sync/atomic/#SwapPointer"><code>SwapPointer</code></a>,
-which swaps an <code>unsafe.Pointer</code>.
-</li>
-
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package now implements
-<a href="/pkg/syscall/#Sendfile"><code>Sendfile</code></a> for Darwin.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package
-now exports the <a href="/pkg/testing/#TB"><code>TB</code></a> interface.
-It records the methods in common with the
-<a href="/pkg/testing/#T"><code>T</code></a>
-and
-<a href="/pkg/testing/#B"><code>B</code></a> types,
-to make it easier to share code between tests and benchmarks.
-Also, the
-<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
-function now quantizes the return value to an integer (although it
-still has type <code>float64</code>), to round off any error caused by
-initialization and make the result more repeatable. 
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package
-now automatically dereferences pointer values when evaluating the arguments
-to "escape" functions such as "html", to bring the behavior of such functions
-in agreement with that of other printing functions such as "printf".
-</li>
-
-<li>
-In the <a href="/pkg/time/"><code>time</code></a> package, the
-<a href="/pkg/time/#Parse"><code>Parse</code></a> function
-and
-<a href="/pkg/time/#Time.Format"><code>Format</code></a>
-method
-now handle time zone offsets with seconds, such as in the historical
-date "1871-01-01T05:33:02+00:34:08".
-Also, pattern matching in the formats for those routines is stricter: a non-lowercase letter
-must now follow the standard words such as "Jan" and "Mon".
-</li>
-
-<li>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package
-adds <a href="/pkg/unicode/#In"><code>In</code></a>,
-a nicer-to-use but equivalent version of the original
-<a href="/pkg/unicode/#IsOneOf"><code>IsOneOf</code></a>,
-to see whether a character is a member of a Unicode category.
-</li>
-
-</ul>

diff --git a/doc/go1.3.html b/doc/go1.3.html
deleted file mode 100644 (file)
index 18b3ec6..0000000
--- a/doc/go1.3.html
+++ /dev/null
@@ -1,608 +0,0 @@
-<!--{
-       "Title": "Go 1.3 Release Notes",
-       "Path":  "/doc/go1.3",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.3</h2>
-
-<p>
-The latest Go release, version 1.3, arrives six months after 1.2,
-and contains no language changes.
-It focuses primarily on implementation work, providing 
-precise garbage collection,
-a major refactoring of the compiler toolchain that results in
-faster builds, especially for large projects,
-significant performance improvements across the board,
-and support for DragonFly BSD, Solaris, Plan 9 and Google's Native Client architecture (NaCl).
-It also has an important refinement to the memory model regarding synchronization.
-As always, Go 1.3 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>,
-and almost everything 
-will continue to compile and run without change when moved to 1.3.
-</p>
-
-<h2 id="os">Changes to the supported operating systems and architectures</h2>
-
-<h3 id="win2000">Removal of support for Windows 2000</h3>
-
-<p>
-Microsoft stopped supporting Windows 2000 in 2010.
-Since it has <a href="https://codereview.appspot.com/74790043">implementation difficulties</a>
-regarding exception handling (signals in Unix terminology),
-as of Go 1.3 it is not supported by Go either.
-</p>
-
-<h3 id="dragonfly">Support for DragonFly BSD</h3>
-
-<p>
-Go 1.3 now includes experimental support for DragonFly BSD on the <code>amd64</code> (64-bit x86) and <code>386</code> (32-bit x86) architectures.
-It uses DragonFly BSD 3.6 or above.
-</p>
-
-<h3 id="freebsd">Support for FreeBSD</h3>
-
-<p>
-It was not announced at the time, but since the release of Go 1.2, support for Go on FreeBSD
-requires FreeBSD 8 or above.
-</p>
-
-<p>
-As of Go 1.3, support for Go on FreeBSD requires that the kernel be compiled with the
-<code>COMPAT_FREEBSD32</code> flag configured.
-</p>
-
-<p>
-In concert with the switch to EABI syscalls for ARM platforms, Go 1.3 will run only on FreeBSD 10.
-The x86 platforms, 386 and amd64, are unaffected.
-</p>
-
-<h3 id="nacl">Support for Native Client</h3>
-
-<p>
-Support for the Native Client virtual machine architecture has returned to Go with the 1.3 release.
-It runs on the 32-bit Intel architectures (<code>GOARCH=386</code>) and also on 64-bit Intel, but using
-32-bit pointers (<code>GOARCH=amd64p32</code>).
-There is not yet support for Native Client on ARM.
-Note that this is Native Client (NaCl), not Portable Native Client (PNaCl).
-Details about Native Client are <a href="https://developers.google.com/native-client/dev/">here</a>;
-how to set up the Go version is described <a href="//golang.org/wiki/NativeClient">here</a>.
-</p>
-
-<h3 id="netbsd">Support for NetBSD</h3>
-
-<p>
-As of Go 1.3, support for Go on NetBSD requires NetBSD 6.0 or above.
-</p>
-
-<h3 id="openbsd">Support for OpenBSD</h3>
-
-<p>
-As of Go 1.3, support for Go on OpenBSD requires OpenBSD 5.5 or above.
-</p>
-
-<h3 id="plan9">Support for Plan 9</h3>
-
-<p>
-Go 1.3 now includes experimental support for Plan 9 on the <code>386</code> (32-bit x86) architecture.
-It requires the <code>Tsemacquire</code> syscall, which has been in Plan 9 since June, 2012.
-</p>
-
-<h3 id="solaris">Support for Solaris</h3>
-
-<p>
-Go 1.3 now includes experimental support for Solaris on the <code>amd64</code> (64-bit x86) architecture.
-It requires illumos, Solaris 11 or above.
-</p>
-
-<h2 id="memory">Changes to the memory model</h2>
-
-<p>
-The Go 1.3 memory model <a href="https://codereview.appspot.com/75130045">adds a new rule</a>
-concerning sending and receiving on buffered channels,
-to make explicit that a buffered channel can be used as a simple
-semaphore, using a send into the
-channel to acquire and a receive from the channel to release.
-This is not a language change, just a clarification about an expected property of communication.
-</p>
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="stacks">Stack</h3>
-
-<p>
-Go 1.3 has changed the implementation of goroutine stacks away from the old,
-"segmented" model to a contiguous model.
-When a goroutine needs more stack
-than is available, its stack is transferred to a larger single block of memory.
-The overhead of this transfer operation amortizes well and eliminates the old "hot spot"
-problem when a calculation repeatedly steps across a segment boundary.
-Details including performance numbers are in this
-<a href="//golang.org/s/contigstacks">design document</a>.
-</p>
-
-<h3 id="garbage_collector">Changes to the garbage collector</h3>
-
-<p>
-For a while now, the garbage collector has been <em>precise</em> when examining
-values in the heap; the Go 1.3 release adds equivalent precision to values on the stack.
-This means that a non-pointer Go value such as an integer will never be mistaken for a
-pointer and prevent unused memory from being reclaimed.
-</p>
-
-<p>
-Starting with Go 1.3, the runtime assumes that values with pointer type
-contain pointers and other values do not.
-This assumption is fundamental to the precise behavior of both stack expansion
-and garbage collection.
-Programs that use <a href="/pkg/unsafe/">package unsafe</a>
-to store integers in pointer-typed values are illegal and will crash if the runtime detects the behavior.
-Programs that use <a href="/pkg/unsafe/">package unsafe</a> to store pointers
-in integer-typed values are also illegal but more difficult to diagnose during execution.
-Because the pointers are hidden from the runtime, a stack expansion or garbage collection
-may reclaim the memory they point at, creating
-<a href="//en.wikipedia.org/wiki/Dangling_pointer">dangling pointers</a>.
-</p>
-
-<p>
-<em>Updating</em>: Code that uses <code>unsafe.Pointer</code> to convert
-an integer-typed value held in memory into a pointer is illegal and must be rewritten.
-Such code can be identified by <code>go vet</code>.
-</p>
-
-<h3 id="map">Map iteration</h3>
-
-<p>
-Iterations over small maps no longer happen in a consistent order.
-Go 1 defines that &ldquo;<a href="//golang.org/ref/spec#For_statements">The iteration order over maps
-is not specified and is not guaranteed to be the same from one iteration to the next.</a>&rdquo;
-To keep code from depending on map iteration order,
-Go 1.0 started each map iteration at a random index in the map.
-A new map implementation introduced in Go 1.1 neglected to randomize
-iteration for maps with eight or fewer entries, although the iteration order
-can still vary from system to system.
-This has allowed people to write Go 1.1 and Go 1.2 programs that
-depend on small map iteration order and therefore only work reliably on certain systems.
-Go 1.3 reintroduces random iteration for small maps in order to flush out these bugs.
-</p>
-
-<p>
-<em>Updating</em>: If code assumes a fixed iteration order for small maps,
-it will break and must be rewritten not to make that assumption.
-Because only small maps are affected, the problem arises most often in tests.
-</p>
-
-<h3 id="liblink">The linker</h3>
-
-<p>
-As part of the general <a href="//golang.org/s/go13linker">overhaul</a> to
-the Go linker, the compilers and linkers have been refactored.
-The linker is still a C program, but now the instruction selection phase that
-was part of the linker has been moved to the compiler through the creation of a new
-library called <code>liblink</code>.
-By doing instruction selection only once, when the package is first compiled,
-this can speed up compilation of large projects significantly.
-</p>
-
-<p>
-<em>Updating</em>: Although this is a major internal change, it should have no
-effect on programs.
-</p>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-GCC release 4.9 will contain the Go 1.2 (not 1.3) version of gccgo.
-The release schedules for the GCC and Go projects do not coincide,
-which means that 1.3 will be available in the development branch but
-that the next GCC release, 4.10, will likely have the Go 1.4 version of gccgo.
-</p>
-
-<h3 id="gocmd">Changes to the go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>cmd/go</code></a> command has several new
-features.
-The <a href="/cmd/go/"><code>go run</code></a> and
-<a href="/cmd/go/"><code>go test</code></a> subcommands
-support a new <code>-exec</code> option to specify an alternate
-way to run the resulting binary.
-Its immediate purpose is to support NaCl.
-</p>
-
-<p>
-The test coverage support of the <a href="/cmd/go/"><code>go test</code></a>
-subcommand now automatically sets the coverage mode to <code>-atomic</code>
-when the race detector is enabled, to eliminate false reports about unsafe
-access to coverage counters.
-</p>
-
-<p>
-The <a href="/cmd/go/"><code>go test</code></a> subcommand
-now always builds the package, even if it has no test files.
-Previously, it would do nothing if no test files were present.
-</p>
-
-<p>
-The <a href="/cmd/go/"><code>go build</code></a> subcommand
-supports a new <code>-i</code> option to install dependencies
-of the specified target, but not the target itself.
-</p>
-
-<p>
-Cross compiling with <a href="/cmd/cgo/"><code>cgo</code></a> enabled
-is now supported.
-The CC_FOR_TARGET and CXX_FOR_TARGET environment
-variables are used when running all.bash to specify the cross compilers
-for C and C++ code, respectively.
-</p>
-
-<p>
-Finally, the go command now supports packages that import Objective-C
-files (suffixed <code>.m</code>) through cgo.
-</p>
-
-<h3 id="cgo">Changes to cgo</h3>
-
-<p>
-The <a href="/cmd/cgo/"><code>cmd/cgo</code></a> command,
-which processes <code>import "C"</code> declarations in Go packages,
-has corrected a serious bug that may cause some packages to stop compiling.
-Previously, all pointers to incomplete struct types translated to the Go type <code>*[0]byte</code>,
-with the effect that the Go compiler could not diagnose passing one kind of struct pointer
-to a function expecting another.
-Go 1.3 corrects this mistake by translating each different
-incomplete struct to a different named type.
-</p>
-
-<p>
-Given the C declaration <code>typedef struct S T</code> for an incomplete <code>struct S</code>,
-some Go code used this bug to refer to the types <code>C.struct_S</code> and <code>C.T</code> interchangeably.
-Cgo now explicitly allows this use, even for completed struct types.
-However, some Go code also used this bug to pass (for example) a <code>*C.FILE</code>
-from one package to another.
-This is not legal and no longer works: in general Go packages
-should avoid exposing C types and names in their APIs.
-</p>
-
-<p>
-<em>Updating</em>: Code confusing pointers to incomplete types or
-passing them across package boundaries will no longer compile
-and must be rewritten.
-If the conversion is correct and must be preserved,
-use an explicit conversion via <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code></a>.
-</p>
-
-<h3 id="swig">SWIG 3.0 required for programs that use SWIG</h3>
-
-<p>
-For Go programs that use SWIG, SWIG version 3.0 is now required.
-The <a href="/cmd/go"><code>cmd/go</code></a> command will now link the
-SWIG generated object files directly into the binary, rather than
-building and linking with a shared library.
-</p>
-
-<h3 id="gc_flag">Command-line flag parsing</h3>
-
-<p>
-In the gc toolchain, the assemblers now use the
-same command-line flag parsing rules as the Go flag package, a departure
-from the traditional Unix flag parsing.
-This may affect scripts that invoke the tool directly.
-For example,
-<code>go tool 6a -SDfoo</code> must now be written
-<code>go tool 6a -S -D foo</code>.
-(The same change was made to the compilers and linkers in <a href="/doc/go1.1#gc_flag">Go 1.1</a>.)
-</p>
-
-<h3 id="godoc">Changes to godoc</h3>
-<p>
-When invoked with the <code>-analysis</code> flag, 
-<a href="//godoc.org/golang.org/x/tools/cmd/godoc">godoc</a>
-now performs sophisticated <a href="/lib/godoc/analysis/help.html">static
-analysis</a> of the code it indexes.  
-The results of analysis are presented in both the source view and the
-package documentation view, and include the call graph of each package
-and the relationships between 
-definitions and references,
-types and their methods,
-interfaces and their implementations,
-send and receive operations on channels,
-functions and their callers, and
-call sites and their callees.
-</p>
-
-<h3 id="misc">Miscellany</h3>
-
-<p>
-The program <code>misc/benchcmp</code> that compares
-performance across benchmarking runs has been rewritten.
-Once a shell and awk script in the main repository, it is now a Go program in the <code>go.tools</code> repo.
-Documentation is <a href="//godoc.org/golang.org/x/tools/cmd/benchcmp">here</a>.
-</p>
-
-<p>
-For the few of us that build Go distributions, the tool <code>misc/dist</code> has been
-moved and renamed; it now lives in <code>misc/makerelease</code>, still in the main repository.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-The performance of Go binaries for this release has improved in many cases due to changes
-in the runtime and garbage collection, plus some changes to libraries.
-Significant instances include:
-</p>
-
-<ul> 
-
-<li>
-The runtime handles defers more efficiently, reducing the memory footprint by about two kilobytes
-per goroutine that calls defer.
-</li>
-
-<li>
-The garbage collector has been sped up, using a concurrent sweep algorithm,
-better parallelization, and larger pages.
-The cumulative effect can be a 50-70% reduction in collector pause time.
-</li>
-
-<li>
-The race detector (see <a href="/doc/articles/race_detector.html">this guide</a>)
-is now about 40% faster.
-</li>
-
-<li>
-The regular expression package <a href="/pkg/regexp/"><code>regexp</code></a>
-is now significantly faster for certain simple expressions due to the implementation of
-a second, one-pass execution engine.
-The choice of which engine to use is automatic;
-the details are hidden from the user.
-</li>
-
-</ul>
-
-<p>
-Also, the runtime now includes in stack dumps how long a goroutine has been blocked,
-which can be useful information when debugging deadlocks or performance issues.
-</p>
-
-<h2 id="library">Changes to the standard library</h2>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-A new package <a href="/pkg/debug/plan9obj/"><code>debug/plan9obj</code></a> was added to the standard library.
-It implements access to Plan 9 <a href="https://9p.io/magic/man2html/6/a.out">a.out</a> object files.
-</p>
-
-<h3 id="major_library_changes">Major changes to the library</h3>
-
-<p>
-A previous bug in <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a>
-made it possible to skip verification in TLS inadvertently.
-In Go 1.3, the bug is fixed: one must specify either ServerName or
-InsecureSkipVerify, and if ServerName is specified it is enforced.
-This may break existing code that incorrectly depended on insecure
-behavior.
-</p>
-
-<p>
-There is an important new type added to the standard library: <a href="/pkg/sync/#Pool"><code>sync.Pool</code></a>.
-It provides an efficient mechanism for implementing certain types of caches whose memory
-can be reclaimed automatically by the system.
-</p>
-
-<p>
-The <a href="/pkg/testing/"><code>testing</code></a> package's benchmarking helper,
-<a href="/pkg/testing/#B"><code>B</code></a>, now has a
-<a href="/pkg/testing/#B.RunParallel"><code>RunParallel</code></a> method
-to make it easier to run benchmarks that exercise multiple CPUs.
-</p>
-
-<p>
-<em>Updating</em>: The crypto/tls fix may break existing code, but such
-code was erroneous and should be updated.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li> In the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package,
-a new <a href="/pkg/crypto/tls/#DialWithDialer"><code>DialWithDialer</code></a>
-function lets one establish a TLS connection using an existing dialer, making it easier
-to control dial options such as timeouts.
-The package also now reports the TLS version used by the connection in the
-<a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-struct.
-</li>
-
-<li> The <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-function of the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports parsing (and elsewhere, serialization) of PKCS #10 certificate
-signature requests.
-</li>
-
-<li>
-The formatted print functions of the <code>fmt</code> package now define <code>%F</code>
-as a synonym for <code>%f</code> when printing floating-point values.
-</li>
-
-<li>
-The <a href="/pkg/math/big/"><code>math/big</code></a> package's
-<a href="/pkg/math/big/#Int"><code>Int</code></a> and
-<a href="/pkg/math/big/#Rat"><code>Rat</code></a> types
-now implement
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
-</li>
-
-<li>
-The complex power function, <a href="/pkg/math/cmplx/#Pow"><code>Pow</code></a>,
-now specifies the behavior when the first argument is zero.
-It was undefined before.
-The details are in the <a href="/pkg/math/cmplx/#Pow">documentation for the function</a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now exposes the
-properties of a TLS connection used to make a client request in the new
-<a href="/pkg/net/http/#Response"><code>Response.TLS</code></a> field.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-allows setting an optional server error logger
-with <a href="/pkg/net/http/#Server"><code>Server.ErrorLog</code></a>.
-The default is still that all errors go to stderr.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-supports disabling HTTP keep-alive connections on the server
-with <a href="/pkg/net/http/#Server.SetKeepAlivesEnabled"><code>Server.SetKeepAlivesEnabled</code></a>.
-The default continues to be that the server does keep-alive (reuses
-connections for multiple requests) by default.
-Only resource-constrained servers or those in the process of graceful
-shutdown will want to disable them.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package adds an optional
-<a href="/pkg/net/http/#Transport"><code>Transport.TLSHandshakeTimeout</code></a>
-setting to cap the amount of time HTTP client requests will wait for
-TLS handshakes to complete.
-It's now also set by default
-on <a href="/pkg/net/http#DefaultTransport"><code>DefaultTransport</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>,
-used by the HTTP client code, now
-enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
-keep-alives</a> by default.
-Other <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-values with a nil <code>Dial</code> field continue to function the same
-as before: no TCP keep-alives are used.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package
-now enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
-keep-alives</a> for incoming server requests when
-<a href="/pkg/net/http/#ListenAndServe"><code>ListenAndServe</code></a>
-or
-<a href="/pkg/net/http/#ListenAndServeTLS"><code>ListenAndServeTLS</code></a>
-are used.
-When a server is started otherwise, TCP keep-alives are not enabled.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-provides an
-optional <a href="/pkg/net/http/#Server"><code>Server.ConnState</code></a>
-callback to hook various phases of a server connection's lifecycle
-(see <a href="/pkg/net/http/#ConnState"><code>ConnState</code></a>).
-This can be used to implement rate limiting or graceful shutdown.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's HTTP
-client now has an
-optional <a href="/pkg/net/http/#Client"><code>Client.Timeout</code></a>
-field to specify an end-to-end timeout on requests made using the
-client.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
-method will now return an error if the body's <code>Content-Type</code>
-is not <code>multipart/form-data</code>.
-Prior to Go 1.3 it would silently fail and return <code>nil</code>.
-Code that relies on the previous behavior should be updated.
-</li>
-
-<li> In the <a href="/pkg/net/"><code>net</code></a> package,
-the <a href="/pkg/net/#Dialer"><code>Dialer</code></a> struct now
-has a <code>KeepAlive</code> option to specify a keep-alive period for the connection.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's 
-<a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-now closes <a href="/pkg/net/http/#Request"><code>Request.Body</code></a>
-consistently, even on error.
-</li>
-
-<li>
-The <a href="/pkg/os/exec/"><code>os/exec</code></a> package now implements
-what the documentation has always said with regard to relative paths for the binary.
-In particular, it only calls <a href="/pkg/os/exec/#LookPath"><code>LookPath</code></a>
-when the binary's file name contains no path separators.
-</li>
-
-<li>
-The <a href="/pkg/reflect/#Value.SetMapIndex"><code>SetMapIndex</code></a>
-function in the <a href="/pkg/reflect/"><code>reflect</code></a> package
-no longer panics when deleting from a <code>nil</code> map.
-</li>
-
-<li>
-If the main goroutine calls 
-<a href="/pkg/runtime/#Goexit"><code>runtime.Goexit</code></a>
-and all other goroutines finish execution, the program now always crashes,
-reporting a detected deadlock.
-Earlier versions of Go handled this situation inconsistently: most instances
-were reported as deadlocks, but some trivial cases exited cleanly instead.
-</li>
-
-<li>
-The runtime/debug package now has a new function
-<a href="/pkg/runtime/debug/#WriteHeapDump"><code>debug.WriteHeapDump</code></a>
-that writes out a description of the heap.
-</li>
-
-<li>
-The <a href="/pkg/strconv/#CanBackquote"><code>CanBackquote</code></a>
-function in the <a href="/pkg/strconv/"><code>strconv</code></a> package
-now considers the <code>DEL</code> character, <code>U+007F</code>, to be
-non-printing.
-</li>
-
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package now provides
-<a href="/pkg/syscall/#SendmsgN"><code>SendmsgN</code></a>
-as an alternate version of
-<a href="/pkg/syscall/#Sendmsg"><code>Sendmsg</code></a>
-that returns the number of bytes written.
-</li>
-
-<li>
-On Windows, the <a href="/pkg/syscall/"><code>syscall</code></a> package now
-supports the cdecl calling convention through the addition of a new function
-<a href="/pkg/syscall/#NewCallbackCDecl"><code>NewCallbackCDecl</code></a>
-alongside the existing function
-<a href="/pkg/syscall/#NewCallback"><code>NewCallback</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package now
-diagnoses tests that call <code>panic(nil)</code>, which are almost always erroneous.
-Also, tests now write profiles (if invoked with profiling flags) even on failure.
-</li>
-
-<li>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-support throughout the system has been upgraded from
-Unicode 6.2.0 to <a href="http://www.unicode.org/versions/Unicode6.3.0/">Unicode 6.3.0</a>.
-</li>
-
-</ul>

diff --git a/doc/go1.4.html b/doc/go1.4.html
deleted file mode 100644 (file)
index c8f7c9c..0000000
--- a/doc/go1.4.html
+++ /dev/null
@@ -1,896 +0,0 @@
-<!--{
-       "Title": "Go 1.4 Release Notes",
-       "Path":  "/doc/go1.4",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.4</h2>
-
-<p>
-The latest Go release, version 1.4, arrives as scheduled six months after 1.3.
-</p>
-
-<p>
-It contains only one tiny language change,
-in the form of a backwards-compatible simple variant of <code>for</code>-<code>range</code> loop,
-and a possibly breaking change to the compiler involving methods on pointers-to-pointers.
-</p>
-
-<p>
-The release focuses primarily on implementation work, improving the garbage collector
-and preparing the ground for a fully concurrent collector to be rolled out in the
-next few releases.
-Stacks are now contiguous, reallocated when necessary rather than linking on new
-"segments";
-this release therefore eliminates the notorious "hot stack split" problem.
-There are some new tools available including support in the <code>go</code> command
-for build-time source code generation.
-The release also adds support for ARM processors on Android and Native Client (NaCl)
-and for AMD64 on Plan 9.
-</p>
-
-<p>
-As always, Go 1.4 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>,
-and almost everything 
-will continue to compile and run without change when moved to 1.4.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<h3 id="forrange">For-range loops</h3>
-<p>
-Up until Go 1.3, <code>for</code>-<code>range</code> loop had two forms
-</p>
-
-<pre>
-for i, v := range x {
-       ...
-}
-</pre>
-
-<p>
-and
-</p>
-
-<pre>
-for i := range x {
-       ...
-}
-</pre>
-
-<p>
-If one was not interested in the loop values, only the iteration itself, it was still
-necessary to mention a variable (probably the <a href="/ref/spec#Blank_identifier">blank identifier</a>, as in
-<code>for</code> <code>_</code> <code>=</code> <code>range</code> <code>x</code>), because
-the form
-</p>
-
-<pre>
-for range x {
-       ...
-}
-</pre>
-
-<p>
-was not syntactically permitted.
-</p>
-
-<p>
-This situation seemed awkward, so as of Go 1.4 the variable-free form is now legal.
-The pattern arises rarely but the code can be cleaner when it does.
-</p>
-
-<p>
-<em>Updating</em>: The change is strictly backwards compatible to existing Go
-programs, but tools that analyze Go parse trees may need to be modified to accept
-this new form as the
-<code>Key</code> field of <a href="/pkg/go/ast/#RangeStmt"><code>RangeStmt</code></a>
-may now be <code>nil</code>.
-</p>
-
-<h3 id="methodonpointertopointer">Method calls on **T</h3>
-
-<p>
-Given these declarations,
-</p>
-
-<pre>
-type T int
-func (T) M() {}
-var x **T
-</pre>
-
-<p>
-both <code>gc</code> and <code>gccgo</code> accepted the method call
-</p>
-
-<pre>
-x.M()
-</pre>
-
-<p>
-which is a double dereference of the pointer-to-pointer <code>x</code>.
-The Go specification allows a single dereference to be inserted automatically,
-but not two, so this call is erroneous according to the language definition.
-It has therefore been disallowed in Go 1.4, which is a breaking change,
-although very few programs will be affected.
-</p>
-
-<p>
-<em>Updating</em>: Code that depends on the old, erroneous behavior will no longer
-compile but is easy to fix by adding an explicit dereference.
-</p>
-
-<h2 id="os">Changes to the supported operating systems and architectures</h2>
-
-<h3 id="android">Android</h3>
-
-<p>
-Go 1.4 can build binaries for ARM processors running the Android operating system.
-It can also build a <code>.so</code> library that can be loaded by an Android application
-using the supporting packages in the <a href="https://golang.org/x/mobile">mobile</a> subrepository.
-A brief description of the plans for this experimental port are available
-<a href="https://golang.org/s/go14android">here</a>.
-</p>
-
-<h3 id="naclarm">NaCl on ARM</h3>
-
-<p>
-The previous release introduced Native Client (NaCl) support for the 32-bit x86
-(<code>GOARCH=386</code>)
-and 64-bit x86 using 32-bit pointers (GOARCH=amd64p32).
-The 1.4 release adds NaCl support for ARM (GOARCH=arm).
-</p>
-
-<h3 id="plan9amd64">Plan9 on AMD64</h3>
-
-<p>
-This release adds support for the Plan 9 operating system on AMD64 processors,
-provided the kernel supports the <code>nsec</code> system call and uses 4K pages.
-</p>
-
-<h2 id="compatibility">Changes to the compatibility guidelines</h2>
-
-<p>
-The <a href="/pkg/unsafe/"><code>unsafe</code></a> package allows one
-to defeat Go's type system by exploiting internal details of the implementation
-or machine representation of data.
-It was never explicitly specified what use of <code>unsafe</code> meant
-with respect to compatibility as specified in the
-<a href="go1compat.html">Go compatibility guidelines</a>.
-The answer, of course, is that we can make no promise of compatibility
-for code that does unsafe things.
-</p>
-
-<p>
-We have clarified this situation in the documentation included in the release.
-The <a href="go1compat.html">Go compatibility guidelines</a> and the
-docs for the <a href="/pkg/unsafe/"><code>unsafe</code></a> package
-are now explicit that unsafe code is not guaranteed to remain compatible.
-</p>
-  
-<p>
-<em>Updating</em>: Nothing technical has changed; this is just a clarification
-of the documentation.
-</p>
-
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="runtime">Changes to the runtime</h3>
-
-<p>
-Prior to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
-maps, slices, strings, ...) was mostly written in C, with some assembler support.
-In 1.4, much of the code has been translated to Go so that the garbage collector can scan
-the stacks of programs in the runtime and get accurate information about what variables
-are active.
-This change was large but should have no semantic effect on programs.
-</p>
-
-<p>
-This rewrite allows the garbage collector in 1.4 to be fully precise,
-meaning that it is aware of the location of all active pointers in the program.
-This means the heap will be smaller as there will be no false positives keeping non-pointers alive.
-Other related changes also reduce the heap size, which is smaller by 10%-30% overall
-relative to the previous release.
-</p>
-
-<p>
-A consequence is that stacks are no longer segmented, eliminating the "hot split" problem.
-When a stack limit is reached, a new, larger stack is allocated, all active frames for
-the goroutine are copied there, and any pointers into the stack are updated.
-Performance can be noticeably better in some cases and is always more predictable.
-Details are available in <a href="https://golang.org/s/contigstacks">the design document</a>.
-</p>
-
-<p>
-The use of contiguous stacks means that stacks can start smaller without triggering performance issues,
-so the default starting size for a goroutine's stack in 1.4 has been reduced from 8192 bytes to 2048 bytes.
-</p>
-
-<p>
-As preparation for the concurrent garbage collector scheduled for the 1.5 release,
-writes to pointer values in the heap are now done by a function call,
-called a write barrier, rather than directly from the function updating the value.
-In this next release, this will permit the garbage collector to mediate writes to the heap while it is running.
-This change has no semantic effect on programs in 1.4, but was
-included in the release to test the compiler and the resulting performance.
-</p>
-
-<p>
-The implementation of interface values has been modified.
-In earlier releases, the interface contained a word that was either a pointer or a one-word
-scalar value, depending on the type of the concrete object stored.
-This implementation was problematical for the garbage collector,
-so as of 1.4 interface values always hold a pointer.
-In running programs, most interface values were pointers anyway,
-so the effect is minimal, but programs that store integers (for example) in
-interfaces will see more allocations.
-</p>
-
-<p>
-As of Go 1.3, the runtime crashes if it finds a memory word that should contain
-a valid pointer but instead contains an obviously invalid pointer (for example, the value 3).
-Programs that store integers in pointer values may run afoul of this check and crash.
-In Go 1.4, setting the <a href="/pkg/runtime/"><code>GODEBUG</code></a> variable
-<code>invalidptr=0</code> disables
-the crash as a workaround, but we cannot guarantee that future releases will be
-able to avoid the crash; the correct fix is to rewrite code not to alias integers and pointers.
-</p>
-
-<h3 id="asm">Assembly</h3>
-
-<p>
-The language accepted by the assemblers <code>cmd/5a</code>, <code>cmd/6a</code>
-and <code>cmd/8a</code> has had several changes,
-mostly to make it easier to deliver type information to the runtime.
-</p>
-
-<p>
-First, the <code>textflag.h</code> file that defines flags for <code>TEXT</code> directives
-has been copied from the linker source directory to a standard location so it can be
-included with the simple directive
-</p>
-
-<pre>
-#include "textflag.h"
-</pre>
-
-<p>
-The more important changes are in how assembler source can define the necessary
-type information.
-For most programs it will suffice to move data
-definitions (<code>DATA</code> and <code>GLOBL</code> directives)
-out of assembly into Go files
-and to write a Go declaration for each assembly function.
-The <a href="/doc/asm#runtime">assembly document</a> describes what to do.
-</p>
-
-<p>
-<em>Updating</em>:
-Assembly files that include <code>textflag.h</code> from its old
-location will still work, but should be updated.
-For the type information, most assembly routines will need no change,
-but all should be examined.
-Assembly source files that define data,
-functions with non-empty stack frames, or functions that return pointers
-need particular attention.
-A description of the necessary (but simple) changes
-is in the <a href="/doc/asm#runtime">assembly document</a>.
-</p>
-
-<p>
-More information about these changes is in the <a href="/doc/asm">assembly document</a>.
-</p>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-The release schedules for the GCC and Go projects do not coincide.
-GCC release 4.9 contains the Go 1.2 version of gccgo.
-The next release, GCC 5, will likely have the Go 1.4 version of gccgo.
-</p>
-
-<h3 id="internalpackages">Internal packages</h3>
-
-<p>
-Go's package system makes it easy to structure programs into components with clean boundaries,
-but there are only two forms of access: local (unexported) and global (exported).
-Sometimes one wishes to have components that are not exported,
-for instance to avoid acquiring clients of interfaces to code that is part of a public repository
-but not intended for use outside the program to which it belongs.
-</p>
-
-<p>
-The Go language does not have the power to enforce this distinction, but as of Go 1.4 the
-<a href="/cmd/go/"><code>go</code></a> command introduces
-a mechanism to define "internal" packages that may not be imported by packages outside
-the source subtree in which they reside.
-</p>
-
-<p>
-To create such a package, place it in a directory named <code>internal</code> or in a subdirectory of a directory
-named internal.
-When the <code>go</code> command sees an import of a package with <code>internal</code> in its path,
-it verifies that the package doing the import
-is within the tree rooted at the parent of the <code>internal</code> directory.
-For example, a package <code>.../a/b/c/internal/d/e/f</code>
-can be imported only by code in the directory tree rooted at <code>.../a/b/c</code>.
-It cannot be imported by code in <code>.../a/b/g</code> or in any other repository.
-</p>
-
-<p>
-For Go 1.4, the internal package mechanism is enforced for the main Go repository;
-from 1.5 and onward it will be enforced for any repository.
-</p>
-
-<p>
-Full details of the mechanism are in
-<a href="https://golang.org/s/go14internal">the design document</a>.
-</p>
-
-<h3 id="canonicalimports">Canonical import paths</h3>
-
-<p>
-Code often lives in repositories hosted by public services such as <code>github.com</code>,
-meaning that the import paths for packages begin with the name of the hosting service,
-<code>github.com/rsc/pdf</code> for example.
-One can use
-<a href="/cmd/go/#hdr-Remote_import_paths">an existing mechanism</a>
-to provide a "custom" or "vanity" import path such as
-<code>rsc.io/pdf</code>, but
-that creates two valid import paths for the package.
-That is a problem: one may inadvertently import the package through the two
-distinct paths in a single program, which is wasteful;
-miss an update to a package because the path being used is not recognized to be
-out of date;
-or break clients using the old path by moving the package to a different hosting service.
-</p>
-
-<p>
-Go 1.4 introduces an annotation for package clauses in Go source that identify a canonical
-import path for the package.
-If an import is attempted using a path that is not canonical,
-the <a href="/cmd/go/"><code>go</code></a> command
-will refuse to compile the importing package.
-</p>
-
-<p>
-The syntax is simple: put an identifying comment on the package line.
-For our example, the package clause would read:
-</p>
-
-<pre>
-package pdf // import "rsc.io/pdf"
-</pre>
-
-<p>
-With this in place,
-the <code>go</code> command will
-refuse to compile a package that imports <code>github.com/rsc/pdf</code>, 
-ensuring that the code can be moved without breaking users.
-</p>
-
-<p>
-The check is at build time, not download time, so if <code>go</code> <code>get</code>
-fails because of this check, the mis-imported package has been copied to the local machine
-and should be removed manually.
-</p>
-
-<p>
-To complement this new feature, a check has been added at update time to verify
-that the local package's remote repository matches that of its custom import.
-The <code>go</code> <code>get</code> <code>-u</code> command will fail to
-update a package if its remote repository has changed since it was first
-downloaded.
-The new <code>-f</code> flag overrides this check.
-</p>
-
-<p>
-Further information is in
-<a href="https://golang.org/s/go14customimport">the design document</a>.
-</p>
-
-<h3 id="subrepo">Import paths for the subrepositories</h3>
-
-<p>
-The Go project subrepositories (<code>code.google.com/p/go.tools</code> and so on)
-are now available under custom import paths replacing <code>code.google.com/p/go.</code> with <code>golang.org/x/</code>,
-as in <code>golang.org/x/tools</code>.
-We will add canonical import comments to the code around June 1, 2015,
-at which point Go 1.4 and later will stop accepting the old <code>code.google.com</code> paths.
-</p>
-
-<p>
-<em>Updating</em>: All code that imports from subrepositories should change
-to use the new <code>golang.org</code> paths.
-Go 1.0 and later can resolve and import the new paths, so updating will not break
-compatibility with older releases.
-Code that has not updated will stop compiling with Go 1.4 around June 1, 2015.
-</p>
-
-<h3 id="gogenerate">The go generate subcommand</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go</code></a> command has a new subcommand,
-<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go generate</code></a>,
-to automate the running of tools to generate source code before compilation.
-For example, it can be used to run the <a href="/cmd/yacc"><code>yacc</code></a>
-compiler-compiler on a <code>.y</code> file to produce the Go source file implementing the grammar,
-or to automate the generation of <code>String</code> methods for typed constants using the new
-<a href="https://godoc.org/golang.org/x/tools/cmd/stringer">stringer</a>
-tool in the <code>golang.org/x/tools</code> subrepository.
-</p>
-
-<p>
-For more information, see the 
-<a href="https://golang.org/s/go1.4-generate">design document</a>.
-</p>
-
-<h3 id="filenames">Change to file name handling</h3>
-
-<p>
-Build constraints, also known as build tags, control compilation by including or excluding files
-(see the documentation <a href="/pkg/go/build/"><code>/go/build</code></a>).
-Compilation can also be controlled by the name of the file itself by "tagging" the file with
-a suffix (before the <code>.go</code> or <code>.s</code> extension) with an underscore
-and the name of the architecture or operating system.
-For instance, the file <code>gopher_arm.go</code> will only be compiled if the target
-processor is an ARM.
-</p>
-
-<p>
-Before Go 1.4, a file called just <code>arm.go</code> was similarly tagged, but this behavior
-can break sources when new architectures are added, causing files to suddenly become tagged.
-In 1.4, therefore, a file will be tagged in this manner only if the tag (architecture or operating
-system name) is preceded by an underscore.
-</p>
-
-<p>
-<em>Updating</em>: Packages that depend on the old behavior will no longer compile correctly.
-Files with names like <code>windows.go</code> or <code>amd64.go</code> should either
-have explicit build tags added to the source or be renamed to something like
-<code>os_windows.go</code> or <code>support_amd64.go</code>.
-</p>
-
-<h3 id="gocmd">Other changes to the go command</h3>
-
-<p>
-There were a number of minor changes to the
-<a href="/cmd/go/"><code>cmd/go</code></a>
-command worth noting.
-</p>
-
-<ul>
-
-<li>
-Unless <a href="/cmd/cgo/"><code>cgo</code></a> is being used to build the package,
-the <code>go</code> command now refuses to compile C source files,
-since the relevant C compilers
-(<a href="/cmd/6c/"><code>6c</code></a> etc.)
-are intended to be removed from the installation in some future release.
-(They are used today only to build part of the runtime.)
-It is difficult to use them correctly in any case, so any extant uses are likely incorrect,
-so we have disabled them.
-</li>
-
-<li>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
-subcommand has a new flag, <code>-o</code>, to set the name of the resulting binary,
-corresponding to the same flag in other subcommands.
-The non-functional <code>-file</code> flag has been removed.
-</li>
-
-<li>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
-subcommand will compile and link all <code>*_test.go</code> files in the package,
-even when there are no <code>Test</code> functions in them. 
-It previously ignored such files.
-</li>
-
-<li>
-The behavior of the
-<a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>build</code></a>
-subcommand's
-<code>-a</code> flag has been changed for non-development installations.
-For installations running a released distribution, the <code>-a</code> flag will no longer
-rebuild the standard library and commands, to avoid overwriting the installation's files.
-</li>
-
-</ul>
-
-<h3 id="pkg">Changes to package source layout</h3>
-
-<p>
-In the main Go source repository, the source code for the packages was kept in
-the directory <code>src/pkg</code>, which made sense but differed from
-other repositories, including the Go subrepositories.
-In Go 1.4, the<code> pkg</code> level of the source tree is now gone, so for example
-the <a href="/pkg/fmt/"><code>fmt</code></a> package's source, once kept in
-directory <code>src/pkg/fmt</code>, now lives one level higher in <code>src/fmt</code>.
-</p>
-
-<p>
-<em>Updating</em>: Tools like <code>godoc</code> that discover source code
-need to know about the new location. All tools and services maintained by the Go team
-have been updated.
-</p>
-
-
-<h3 id="swig">SWIG</h3>
-
-<p>
-Due to runtime changes in this release, Go 1.4 requires SWIG 3.0.3.
-</p>
-
-<h3 id="misc">Miscellany</h3>
-
-<p>
-The standard repository's top-level <code>misc</code> directory used to contain
-Go support for editors and IDEs: plugins, initialization scripts and so on.
-Maintaining these was becoming time-consuming
-and needed external help because many of the editors listed were not used by
-members of the core team.
-It also required us to make decisions about which plugin was best for a given
-editor, even for editors we do not use.
-</p>
-
-<p>
-The Go community at large is much better suited to managing this information.
-In Go 1.4, therefore, this support has been removed from the repository.
-Instead, there is a curated, informative list of what's available on
-a <a href="//golang.org/wiki/IDEsAndTextEditorPlugins">wiki page</a>.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-Most programs will run about the same speed or slightly faster in 1.4 than in 1.3;
-some will be slightly slower.
-There are many changes, making it hard to be precise about what to expect.
-</p>
-
-<p>
-As mentioned above, much of the runtime was translated to Go from C,
-which led to some reduction in heap sizes.
-It also improved performance slightly because the Go compiler is better
-at optimization, due to things like inlining, than the C compiler used to build
-the runtime.
-</p>
-
-<p>
-The garbage collector was sped up, leading to measurable improvements for
-garbage-heavy programs.
-On the other hand, the new write barriers slow things down again, typically
-by about the same amount but, depending on their behavior, some programs
-may be somewhat slower or faster.
-</p>
-
-<p>
-Library changes that affect performance are documented below.
-</p>
-
-<h2 id="library">Changes to the standard library</h2>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-There are no new packages in this release.
-</p>
-
-<h3 id="major_library_changes">Major changes to the library</h3>
-
-<h4 id="scanner">bufio.Scanner</h4>
-
-<p>
-The <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type in the
-<a href="/pkg/bufio/"><code>bufio</code></a> package
-has had a bug fixed that may require changes to custom
-<a href="/pkg/bufio/#SplitFunc"><code>split functions</code></a>. 
-The bug made it impossible to generate an empty token at EOF; the fix
-changes the end conditions seen by the split function.
-Previously, scanning stopped at EOF if there was no more data.
-As of 1.4, the split function will be called once at EOF after input is exhausted,
-so the split function can generate a final empty token
-as the documentation already promised.
-</p>
-
-<p>
-<em>Updating</em>: Custom split functions may need to be modified to
-handle empty tokens at EOF as desired.
-</p>
-
-<h4 id="syscall">syscall</h4>
-
-<p>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package is now frozen except
-for changes needed to maintain the core repository.
-In particular, it will no longer be extended to support new or different system calls
-that are not used by the core.
-The reasons are described at length in <a href="https://golang.org/s/go1.4-syscall">a
-separate document</a>.
-</p>
-
-<p>
-A new subrepository, <a href="https://golang.org/x/sys">golang.org/x/sys</a>,
-has been created to serve as the location for new developments to support system
-calls on all kernels.
-It has a nicer structure, with three packages that each hold the implementation of
-system calls for one of
-<a href="https://godoc.org/golang.org/x/sys/unix">Unix</a>,
-<a href="https://godoc.org/golang.org/x/sys/windows">Windows</a> and
-<a href="https://godoc.org/golang.org/x/sys/plan9">Plan 9</a>.
-These packages will be curated more generously, accepting all reasonable changes
-that reflect kernel interfaces in those operating systems.
-See the documentation and the article mentioned above for more information.
-</p>
-
-<p>
-<em>Updating</em>: Existing programs are not affected as the <code>syscall</code>
-package is largely unchanged from the 1.3 release.
-Future development that requires system calls not in the <code>syscall</code> package
-should build on <code>golang.org/x/sys</code> instead.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package's
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> now supports a
-<a href="/pkg/archive/zip/#Writer.Flush"><code>Flush</code></a> method.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
-and <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a>
-packages now support a <code>Reset</code> method
-for the decompressors, allowing them to reuse buffers and improve performance.
-The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package also has a
-<a href="/pkg/compress/gzip/#Reader.Multistream"><code>Multistream</code></a> method to control support
-for multistream files.
-</li>
-
-<li>
-The <a href="/pkg/crypto/"><code>crypto</code></a> package now has a
-<a href="/pkg/crypto/#Signer"><code>Signer</code></a> interface, implemented by the
-<code>PrivateKey</code> types in
-<a href="/pkg/crypto/ecdsa"><code>crypto/ecdsa</code></a> and
-<a href="/pkg/crypto/rsa"><code>crypto/rsa</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports ALPN as defined in <a href="https://tools.ietf.org/html/rfc7301">RFC 7301</a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports programmatic selection of server certificates
-through the new <a href="/pkg/crypto/tls/#Config.CertificateForName"><code>CertificateForName</code></a> function
-of the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct.
-</li>
-
-<li>
-Also in the crypto/tls package, the server now supports 
-<a href="https://tools.ietf.org/html/draft-ietf-tls-downgrade-scsv-00">TLS_FALLBACK_SCSV</a>
-to help clients detect fallback attacks.
-(The Go client does not support fallback at all, so it is not vulnerable to
-those attacks.)
-</li>
-
-<li>
-The <a href="/pkg/database/sql/"><code>database/sql</code></a> package can now list all registered
-<a href="/pkg/database/sql/#Drivers"><code>Drivers</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a> package now supports
-<a href="/pkg/debug/dwarf/#UnspecifiedType"><code>UnspecifiedType</code></a>s.
-</li>
-
-<li>
-In the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
-optional elements with a default value will now only be omitted if they have that value.
-</li>
-
-<li>
-The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package no longer
-quotes empty strings but does quote the end-of-data marker <code>\.</code> (backslash dot).
-This is permitted by the definition of CSV and allows it to work better with Postgres.
-</li>
-
-<li>
-The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package has been rewritten to eliminate
-the use of unsafe operations, allowing it to be used in environments that do not permit use of the
-<a href="/pkg/unsafe/"><code>unsafe</code></a> package.
-For typical uses it will be 10-30% slower, but the delta is dependent on the type of the data and
-in some cases, especially involving arrays, it can be faster.
-There is no functional change.
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> can now report its input offset.
-</li>
-
-<li>
-In the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-formatting of pointers to maps has changed to be consistent with that of pointers
-to structs, arrays, and so on.
-For instance, <code>&amp;map[string]int{"one":</code> <code>1}</code> now prints by default as
-<code>&amp;map[one:</code> <code>1]</code> rather than as a hexadecimal pointer value.
-</li>
-
-<li>
-The <a href="/pkg/image/"><code>image</code></a> package's
-<a href="/pkg/image/#Image"><code>Image</code></a>
-implementations like
-<a href="/pkg/image/#RGBA"><code>RGBA</code></a> and
-<a href="/pkg/image/#Gray"><code>Gray</code></a> have specialized
-<a href="/pkg/image/#RGBA.RGBAAt"><code>RGBAAt</code></a> and
-<a href="/pkg/image/#Gray.GrayAt"><code>GrayAt</code></a> methods alongside the general
-<a href="/pkg/image/#Image.At"><code>At</code></a> method.
-</li>
-
-<li>
-The <a href="/pkg/image/png/"><code>image/png</code></a> package now has an
-<a href="/pkg/image/png/#Encoder"><code>Encoder</code></a>
-type to control the compression level used for encoding.
-</li>
-
-<li>
-The <a href="/pkg/math/"><code>math</code></a> package now has a
-<a href="/pkg/math/#Nextafter32"><code>Nextafter32</code><a/> function.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request"><code>Request</code></a> type
-has a new <a href="/pkg/net/http/#Request.BasicAuth"><code>BasicAuth</code></a> method
-that returns the username and password from authenticated requests using the
-HTTP Basic Authentication
-Scheme.
-</li>
-
-<li>The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request"><code>Transport</code></a> type
-has a new <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a> hook
-that allows customizing the behavior of outbound TLS connections.
-</li>
-
-<li>
-The <a href="/pkg/net/http/httputil/"><code>net/http/httputil</code></a> package's
-<a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> type
-has a new field,
-<a href="/pkg/net/http/#ReverseProxy.ErrorLog"><code>ErrorLog</code></a>, that
-provides user control of logging.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package
-now implements symbolic links on the Windows operating system
-through the <a href="/pkg/os/#Symlink"><code>Symlink</code></a> function.
-Other operating systems already have this functionality.
-There is also a new <a href="/pkg/os/#Unsetenv"><code>Unsetenv</code></a> function.
-</li>
-
-<li>
-The <a href="/pkg/reflect/"><code>reflect</code></a> package's
-<a href="/pkg/reflect/#Type"><code>Type</code></a> interface
-has a new method, <a href="/pkg/reflect/#type.Comparable"><code>Comparable</code></a>,
-that reports whether the type implements general comparisons.
-</li>
-
-<li>
-Also in the <a href="/pkg/reflect/"><code>reflect</code></a> package, the
-<a href="/pkg/reflect/#Value"><code>Value</code></a> interface is now three instead of four words
-because of changes to the implementation of interfaces in the runtime.
-This saves memory but has no semantic effect.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package
-now implements monotonic clocks on Windows,
-as it already did for the other systems.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package's
-<a href="/pkg/runtime/#MemStats.Mallocs"><code>Mallocs</code></a> counter
-now counts very small allocations that were missed in Go 1.3.
-This may break tests using <a href="/pkg/runtime/#ReadMemStats"><code>ReadMemStats</code></a>
-or <a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
-due to the more accurate answer.
-</li>
-
-<li>
-In the <a href="/pkg/runtime/"><code>runtime</code></a> package,
-an array <a href="/pkg/runtime/#MemStats.PauseEnd"><code>PauseEnd</code></a>
-has been added to the
-<a href="/pkg/runtime/#MemStats"><code>MemStats</code></a>
-and <a href="/pkg/runtime/#GCStats"><code>GCStats</code></a> structs.
-This array is a circular buffer of times when garbage collection pauses ended.
-The corresponding pause durations are already recorded in
-<a href="/pkg/runtime/#MemStats.PauseNs"><code>PauseNs</code></a>
-</li>
-
-<li>
-The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package
-now supports FreeBSD, which means the
-<a href="/pkg/cmd/go/"><code>go</code></a> command's <code>-race</code>
-flag now works on FreeBSD.
-</li>
-
-<li>
-The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package
-has a new type, <a href="/pkg/sync/atomic/#Value"><code>Value</code></a>.
-<code>Value</code> provides an efficient mechanism for atomic loads and
-stores of values of arbitrary type.
-</li>
-
-<li>
-In the <a href="/pkg/syscall/"><code>syscall</code></a> package's
-implementation on Linux, the
-<a href="/pkg/syscall/#Setuid"><code>Setuid</code></a>
-and <a href="/pkg/syscall/#Setgid"><code>Setgid</code></a> have been disabled
-because those system calls operate on the calling thread, not the whole process, which is
-different from other platforms and not the expected result.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package
-has a new facility to provide more control over running a set of tests.
-If the test code contains a function
-<pre>
-func TestMain(m *<a href="/pkg/testing/#M"><code>testing.M</code></a>) 
-</pre>
-
-that function will be called instead of running the tests directly.
-The <code>M</code> struct contains methods to access and run the tests.
-</li>
-
-<li>
-Also in the <a href="/pkg/testing/"><code>testing</code></a> package,
-a new <a href="/pkg/testing/#Coverage"><code>Coverage</code></a>
-function reports the current test coverage fraction,
-enabling individual tests to report how much they are contributing to the
-overall coverage.
-</li>
-
-<li>
-The <a href="/pkg/text/scanner/"><code>text/scanner</code></a> package's
-<a href="/pkg/text/scanner/#Scanner"><code>Scanner</code></a> type
-has a new function,
-<a href="/pkg/text/scanner/#Scanner.IsIdentRune"><code>IsIdentRune</code></a>,
-allowing one to control the definition of an identifier when scanning.
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package's boolean
-functions <code>eq</code>, <code>lt</code>, and so on have been generalized to allow comparison
-of signed and unsigned integers, simplifying their use in practice.
-(Previously one could only compare values of the same signedness.)
-All negative values compare less than all unsigned values.
-</li>
-
-<li>
-The <code>time</code> package now uses the standard symbol for the micro prefix,
-the micro symbol (U+00B5 'µ'), to print microsecond durations.
-<a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> still accepts <code>us</code>
-but the package no longer prints microseconds as <code>us</code>.
-<br>
-<em>Updating</em>: Code that depends on the output format of durations
-but does not use ParseDuration will need to be updated.
-</li>
-
-</ul>

diff --git a/doc/go1.5.html b/doc/go1.5.html
deleted file mode 100644 (file)
index 2c77cf4..0000000
--- a/doc/go1.5.html
+++ /dev/null
@@ -1,1310 +0,0 @@
-<!--{
-       "Title": "Go 1.5 Release Notes",
-       "Path":  "/doc/go1.5",
-       "Template": true
-}-->
-
-
-<h2 id="introduction">Introduction to Go 1.5</h2>
-
-<p>
-The latest Go release, version 1.5,
-is a significant release, including major architectural changes to the implementation.
-Despite that, we expect almost all Go programs to continue to compile and run as before,
-because the release still maintains the Go 1 <a href="/doc/go1compat.html">promise
-of compatibility</a>.
-</p>
-
-<p>
-The biggest developments in the implementation are:
-</p>
-
-<ul>
-
-<li>
-The compiler and runtime are now written entirely in Go (with a little assembler).
-C is no longer involved in the implementation, and so the C compiler that was
-once necessary for building the distribution is gone.
-</li>
-
-<li>
-The garbage collector is now <a href="https://golang.org/s/go14gc">concurrent</a> and provides dramatically lower
-pause times by running, when possible, in parallel with other goroutines.
-</li>
-
-<li>
-By default, Go programs run with <code>GOMAXPROCS</code> set to the
-number of cores available; in prior releases it defaulted to 1.
-</li>
-
-<li>
-Support for <a href="https://golang.org/s/go14internal">internal packages</a>
-is now provided for all repositories, not just the Go core.
-</li>
-
-<li>
-The <code>go</code> command now provides <a href="https://golang.org/s/go15vendor">experimental
-support</a> for "vendoring" external dependencies.
-</li>
-
-<li>
-A new <code>go tool trace</code> command supports fine-grained
-tracing of program execution.
-</li>
-
-<li>
-A new <code>go doc</code> command (distinct from <code>godoc</code>)
-is customized for command-line use.
-</li>
-
-</ul>
-
-<p>
-These and a number of other changes to the implementation and tools
-are discussed below.
-</p>
-
-<p>
-The release also contains one small language change involving map literals.
-</p>
-
-<p>
-Finally, the timing of the <a href="https://golang.org/s/releasesched">release</a>
-strays from the usual six-month interval,
-both to provide more time to prepare this major release and to shift the schedule thereafter to
-time the release dates more conveniently.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<h3 id="map_literals">Map literals</h3>
-
-<p>
-Due to an oversight, the rule that allowed the element type to be elided from slice literals was not
-applied to map keys.
-This has been <a href="/cl/2591">corrected</a> in Go 1.5.
-An example will make this clear.
-As of Go 1.5, this map literal,
-</p>
-
-<pre>
-m := map[Point]string{
-    Point{29.935523, 52.891566}:   "Persepolis",
-    Point{-25.352594, 131.034361}: "Uluru",
-    Point{37.422455, -122.084306}: "Googleplex",
-}
-</pre>
-
-<p>
-may be written as follows, without the <code>Point</code> type listed explicitly:
-</p>
-
-<pre>
-m := map[Point]string{
-    {29.935523, 52.891566}:   "Persepolis",
-    {-25.352594, 131.034361}: "Uluru",
-    {37.422455, -122.084306}: "Googleplex",
-}
-</pre>
-
-<h2 id="implementation">The Implementation</h2>
-
-<h3 id="c">No more C</h3>
-
-<p>
-The compiler and runtime are now implemented in Go and assembler, without C.
-The only C source left in the tree is related to testing or to <code>cgo</code>.
-There was a C compiler in the tree in 1.4 and earlier.
-It was used to build the runtime; a custom compiler was necessary in part to
-guarantee the C code would work with the stack management of goroutines.
-Since the runtime is in Go now, there is no need for this C compiler and it is gone.
-Details of the process to eliminate C are discussed <a href="https://golang.org/s/go13compiler">elsewhere</a>.
-</p>
-
-<p>
-The conversion from C was done with the help of custom tools created for the job.
-Most important, the compiler was actually moved by automatic translation of
-the C code into Go.
-It is in effect the same program in a different language.
-It is not a new implementation
-of the compiler so we expect the process will not have introduced new compiler
-bugs.
-An overview of this process is available in the slides for
-<a href="https://talks.golang.org/2015/gogo.slide">this presentation</a>.
-</p>
-
-<h3 id="compiler_and_tools">Compiler and tools</h3>
-
-<p>
-Independent of but encouraged by the move to Go, the names of the tools have changed.
-The old names <code>6g</code>, <code>8g</code> and so on are gone; instead there
-is just one binary, accessible as <code>go</code> <code>tool</code> <code>compile</code>,
-that compiles Go source into binaries suitable for the architecture and operating system
-specified by <code>$GOARCH</code> and <code>$GOOS</code>.
-Similarly, there is now one linker (<code>go</code> <code>tool</code> <code>link</code>)
-and one assembler (<code>go</code> <code>tool</code> <code>asm</code>).
-The linker was translated automatically from the old C implementation,
-but the assembler is a new native Go implementation discussed
-in more detail below.
-</p>
-
-<p>
-Similar to the drop of the names <code>6g</code>, <code>8g</code>, and so on,
-the output of the compiler and assembler are now given a plain <code>.o</code> suffix
-rather than <code>.8</code>, <code>.6</code>, etc.
-</p>
-
-
-<h3 id="gc">Garbage collector</h3>
-
-<p>
-The garbage collector has been re-engineered for 1.5 as part of the development
-outlined in the <a href="https://golang.org/s/go14gc">design document</a>.
-Expected latencies are much lower than with the collector
-in prior releases, through a combination of advanced algorithms,
-better <a href="https://golang.org/s/go15gcpacing">scheduling</a> of the collector,
-and running more of the collection in parallel with the user program.
-The "stop the world" phase of the collector
-will almost always be under 10 milliseconds and usually much less.
-</p>
-
-<p>
-For systems that benefit from low latency, such as user-responsive web sites,
-the drop in expected latency with the new collector may be important.
-</p>
-
-<p>
-Details of the new collector were presented in a
-<a href="https://talks.golang.org/2015/go-gc.pdf">talk</a> at GopherCon 2015.
-</p>
-
-<h3 id="runtime">Runtime</h3>
-
-<p>
-In Go 1.5, the order in which goroutines are scheduled has been changed.
-The properties of the scheduler were never defined by the language,
-but programs that depend on the scheduling order may be broken
-by this change.
-We have seen a few (erroneous) programs affected by this change.
-If you have programs that implicitly depend on the scheduling
-order, you will need to update them.
-</p>
-
-<p>
-Another potentially breaking change is that the runtime now
-sets the default number of threads to run simultaneously,
-defined by <code>GOMAXPROCS</code>, to the number
-of cores available on the CPU.
-In prior releases the default was 1.
-Programs that do not expect to run with multiple cores may
-break inadvertently.
-They can be updated by removing the restriction or by setting
-<code>GOMAXPROCS</code> explicitly.
-For a more detailed discussion of this change, see
-the <a href="https://golang.org/s/go15gomaxprocs">design document</a>.
-</p>
-
-<h3 id="build">Build</h3>
-
-<p>
-Now that the Go compiler and runtime are implemented in Go, a Go compiler
-must be available to compile the distribution from source.
-Thus, to build the Go core, a working Go distribution must already be in place.
-(Go programmers who do not work on the core are unaffected by this change.)
-Any Go 1.4 or later distribution (including <code>gccgo</code>) will serve.
-For details, see the <a href="https://golang.org/s/go15bootstrap">design document</a>.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Due mostly to the industry's move away from the 32-bit x86 architecture,
-the set of binary downloads provided is reduced in 1.5.
-A distribution for the OS X operating system is provided only for the
-<code>amd64</code> architecture, not <code>386</code>.
-Similarly, the ports for Snow Leopard (Apple OS X 10.6) still work but are no
-longer released as a download or maintained since Apple no longer maintains that version
-of the operating system.
-Also, the <code>dragonfly/386</code> port is no longer supported at all
-because DragonflyBSD itself no longer supports the 32-bit 386 architecture.
-</p>
-
-<p>
-There are however several new ports available to be built from source.
-These include <code>darwin/arm</code> and <code>darwin/arm64</code>.
-The new port <code>linux/arm64</code> is mostly in place, but <code>cgo</code>
-is only supported using external linking.
-</p>
-
-<p>
-Also available as experiments are <code>ppc64</code>
-and <code>ppc64le</code> (64-bit PowerPC, big- and little-endian).
-Both these ports support <code>cgo</code> but
-only with internal linking.
-</p>
-
-<p>
-On FreeBSD, Go 1.5 requires FreeBSD 8-STABLE+ because of its new use of the <code>SYSCALL</code> instruction.
-</p>
-
-<p>
-On NaCl, Go 1.5 requires SDK version pepper-41. Later pepper versions are not
-compatible due to the removal of the sRPC subsystem from the NaCl runtime.
-</p>
-
-<p>
-On Darwin, the use of the system X.509 certificate interface can be disabled
-with the <code>ios</code> build tag.
-</p>
-
-<p>
-The Solaris port now has full support for cgo and the packages
-<a href="/pkg/net/"><code>net</code></a> and
-<a href="/pkg/crypto/x509/"><code>crypto/x509</code></a>,
-as well as a number of other fixes and improvements.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="translate">Translating</h3>
-
-<p>
-As part of the process to eliminate C from the tree, the compiler and
-linker were translated from C to Go.
-It was a genuine (machine assisted) translation, so the new programs are essentially
-the old programs translated rather than new ones with new bugs.
-We are confident the translation process has introduced few if any new bugs,
-and in fact uncovered a number of previously unknown bugs, now fixed.
-</p>
-
-<p>
-The assembler is a new program, however; it is described below.
-</p>
-
-<h3 id="rename">Renaming</h3>
-
-<p>
-The suites of programs that were the compilers (<code>6g</code>, <code>8g</code>, etc.),
-the assemblers (<code>6a</code>, <code>8a</code>, etc.),
-and the linkers (<code>6l</code>, <code>8l</code>, etc.)
-have each been consolidated into a single tool that is configured
-by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
-The old names are gone; the new tools are available through the <code>go</code> <code>tool</code>
-mechanism as <code>go tool compile</code>,
-<code>go tool asm</code>,
-<code>and go tool link</code>.
-Also, the file suffixes <code>.6</code>, <code>.8</code>, etc. for the
-intermediate object files are also gone; now they are just plain <code>.o</code> files.
-</p>
-
-<p>
-For example, to build and link a program on amd64 for Darwin
-using the tools directly, rather than through <code>go build</code>,
-one would run:
-</p>
-
-<pre>
-$ export GOOS=darwin GOARCH=amd64
-$ go tool compile program.go
-$ go tool link program.o
-</pre>
-
-<h3 id="moving">Moving</h3>
-
-<p>
-Because the <a href="/pkg/go/types/"><code>go/types</code></a> package
-has now moved into the main repository (see below),
-the <a href="/cmd/vet"><code>vet</code></a> and
-<a href="/cmd/cover"><code>cover</code></a>
-tools have also been moved.
-They are no longer maintained in the external <code>golang.org/x/tools</code> repository,
-although (deprecated) source still resides there for compatibility with old releases.
-</p>
-
-<h3 id="compiler">Compiler</h3>
-
-<p>
-As described above, the compiler in Go 1.5 is a single Go program,
-translated from the old C source, that replaces <code>6g</code>, <code>8g</code>,
-and so on.
-Its target is configured by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
-</p>
-
-<p>
-The 1.5 compiler is mostly equivalent to the old,
-but some internal details have changed.
-One significant change is that evaluation of constants now uses
-the <a href="/pkg/math/big/"><code>math/big</code></a> package
-rather than a custom (and less well tested) implementation of high precision
-arithmetic.
-We do not expect this to affect the results.
-</p>
-
-<p>
-For the amd64 architecture only, the compiler has a new option, <code>-dynlink</code>,
-that assists dynamic linking by supporting references to Go symbols
-defined in external shared libraries.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p>
-Like the compiler and linker, the assembler in Go 1.5 is a single program
-that replaces the suite of assemblers (<code>6a</code>,
-<code>8a</code>, etc.) and the environment variables
-<code>GOARCH</code> and <code>GOOS</code>
-configure the architecture and operating system.
-Unlike the other programs, the assembler is a wholly new program
-written in Go.
-</p>
-
- <p>
-The new assembler is very nearly compatible with the previous
-ones, but there are a few changes that may affect some
-assembler source files.
-See the updated <a href="/doc/asm">assembler guide</a>
-for more specific information about these changes. In summary:
-
-</p>
-
-<p>
-First, the expression evaluation used for constants is a little
-different.
-It now uses unsigned 64-bit arithmetic and the precedence
-of operators (<code>+</code>, <code>-</code>, <code><<</code>, etc.)
-comes from Go, not C.
-We expect these changes to affect very few programs but
-manual verification may be required.
-</p>
-
-<p>
-Perhaps more important is that on machines where
-<code>SP</code> or <code>PC</code> is only an alias
-for a numbered register,
-such as <code>R13</code> for the stack pointer and
-<code>R15</code> for the hardware program counter
-on ARM,
-a reference to such a register that does not include a symbol
-is now illegal.
-For example, <code>SP</code> and <code>4(SP)</code> are
-illegal but <code>sym+4(SP)</code> is fine.
-On such machines, to refer to the hardware register use its
-true <code>R</code> name.
-</p>
-
-<p>
-One minor change is that some of the old assemblers
-permitted the notation
-</p>
-
-<pre>
-constant=value
-</pre>
-
-<p>
-to define a named constant.
-Since this is always possible to do with the traditional
-C-like <code>#define</code> notation, which is still
-supported (the assembler includes an implementation
-of a simplified C preprocessor), the feature was removed.
-</p>
-
-<h3 id="link">Linker</h3>
-
-<p>
-The linker in Go 1.5 is now one Go program,
-that replaces <code>6l</code>, <code>8l</code>, etc.
-Its operating system and instruction set are specified
-by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
-</p>
-
-<p>
-There are several other changes.
-The most significant is the addition of a <code>-buildmode</code> option that
-expands the style of linking; it now supports
-situations such as building shared libraries and allowing other languages
-to call into Go libraries.
-Some of these were outlined in a <a href="https://golang.org/s/execmodes">design document</a>.
-For a list of the available build modes and their use, run
-</p>
-
-<pre>
-$ go help buildmode
-</pre>
-
-<p>
-Another minor change is that the linker no longer records build time stamps in
-the header of Windows executables.
-Also, although this may be fixed, Windows cgo executables are missing some
-DWARF information.
-</p>
-
-<p>
-Finally, the <code>-X</code> flag, which takes two arguments,
-as in
-</p>
-
-<pre>
--X importpath.name value
-</pre>
-
-<p>
-now also accepts a more common Go flag style with a single argument
-that is itself a <code>name=value</code> pair:
-</p>
-
-<pre>
--X importpath.name=value
-</pre>
-
-<p>
-Although the old syntax still works, it is recommended that uses of this
-flag in scripts and the like be updated to the new form.
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p>
-The <a href="/cmd/go"><code>go</code></a> command's basic operation
-is unchanged, but there are a number of changes worth noting.
-</p>
-
-<p>
-The previous release introduced the idea of a directory internal to a package
-being unimportable through the <code>go</code> command.
-In 1.4, it was tested with the introduction of some internal elements
-in the core repository.
-As suggested in the <a href="https://golang.org/s/go14internal">design document</a>,
-that change is now being made available to all repositories.
-The rules are explained in the design document, but in summary any
-package in or under a directory named <code>internal</code> may
-be imported by packages rooted in the same subtree.
-Existing packages with directory elements named <code>internal</code> may be
-inadvertently broken by this change, which was why it was advertised
-in the last release.
-</p>
-
-<p>
-Another change in how packages are handled is the experimental
-addition of support for "vendoring".
-For details, see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
-and the <a href="https://golang.org/s/go15vendor">design document</a>.
-</p>
-
-<p>
-There have also been several minor changes.
-Read the <a href="/cmd/go">documentation</a> for full details.
-</p>
-
-<ul>
-
-<li>
-SWIG support has been updated such that
-<code>.swig</code> and <code>.swigcxx</code>
-now require SWIG 3.0.6 or later.
-</li>
-
-<li>
-The <code>install</code> subcommand now removes the
-binary created by the <code>build</code> subcommand
-in the source directory, if present,
-to avoid problems having two binaries present in the tree.
-</li>
-
-<li>
-The <code>std</code> (standard library) wildcard package name
-now excludes commands.
-A new <code>cmd</code> wildcard covers the commands.
-</li>
-
-<li>
-A new <code>-asmflags</code> build option
-sets flags to pass to the assembler.
-However,
-the <code>-ccflags</code> build option has been dropped;
-it was specific to the old, now deleted C compiler .
-</li>
-
-<li>
-A new <code>-buildmode</code> build option
-sets the build mode, described above.
-</li>
-
-<li>
-A new <code>-pkgdir</code> build option
-sets the location of installed package archives,
-to help isolate custom builds.
-</li>
-
-<li>
-A new <code>-toolexec</code> build option
-allows substitution of a different command to invoke
-the compiler and so on.
-This acts as a custom replacement for <code>go tool</code>.
-</li>
-
-<li>
-The <code>test</code> subcommand now has a <code>-count</code>
-flag to specify how many times to run each test and benchmark.
-The <a href="/pkg/testing/"><code>testing</code></a> package
-does the work here, through the <code>-test.count</code> flag.
-</li>
-
-<li>
-The <code>generate</code> subcommand has a couple of new features.
-The <code>-run</code> option specifies a regular expression to select which directives
-to execute; this was proposed but never implemented in 1.4.
-The executing pattern now has access to two new environment variables:
-<code>$GOLINE</code> returns the source line number of the directive
-and <code>$DOLLAR</code> expands to a dollar sign.
-</li>
-
-<li>
-The <code>get</code> subcommand now has a <code>-insecure</code>
-flag that must be enabled if fetching from an insecure repository, one that
-does not encrypt the connection.
-</li>
-
-</ul>
-
-<h3 id="vet_command">Go vet command</h3>
-
-<p>
-The <a href="/cmd/vet"><code>go tool vet</code></a> command now does
-more thorough validation of struct tags.
-</p>
-
-<h3 id="trace_command">Trace command</h3>
-
-<p>
-A new tool is available for dynamic execution tracing of Go programs.
-The usage is analogous to how the test coverage tool works.
-Generation of traces is integrated into <code>go test</code>,
-and then a separate execution of the tracing tool itself analyzes the results:
-</p>
-
-<pre>
-$ go test -trace=trace.out path/to/package
-$ go tool trace [flags] pkg.test trace.out
-</pre>
-
-<p>
-The flags enable the output to be displayed in a browser window.
-For details, run <code>go tool trace -help</code>.
-There is also a description of the tracing facility in this
-<a href="https://talks.golang.org/2015/dynamic-tools.slide">talk</a>
-from GopherCon 2015.
-</p>
-
-<h3 id="doc_command">Go doc command</h3>
-
-<p>
-A few releases back, the <code>go doc</code>
-command was deleted as being unnecessary.
-One could always run "<code>godoc .</code>" instead.
-The 1.5 release introduces a new <a href="/cmd/doc"><code>go doc</code></a>
-command with a more convenient command-line interface than
-<code>godoc</code>'s.
-It is designed for command-line usage specifically, and provides a more
-compact and focused presentation of the documentation for a package
-or its elements, according to the invocation.
-It also provides case-insensitive matching and
-support for showing the documentation for unexported symbols.
-For details run "<code>go help doc</code>".
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-When parsing <code>#cgo</code> lines,
-the invocation <code>${SRCDIR}</code> is now
-expanded into the path to the source directory.
-This allows options to be passed to the
-compiler and linker that involve file paths relative to the
-source code directory. Without the expansion the paths would be
-invalid when the current working directory changes.
-</p>
-
-<p>
-Solaris now has full cgo support.
-</p>
-
-<p>
-On Windows, cgo now uses external linking by default.
-</p>
-
-<p>
-When a C struct ends with a zero-sized field, but the struct itself is
-not zero-sized, Go code can no longer refer to the zero-sized field.
-Any such references will have to be rewritten.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-The changes are even broader ranging than usual in this release, which
-includes a new garbage collector and a conversion of the runtime to Go.
-Some programs may run faster, some slower.
-On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.5
-than they did in Go 1.4,
-while as mentioned above the garbage collector's pauses are
-dramatically shorter, and almost always under 10 milliseconds.
-</p>
-
-<p>
-Builds in Go 1.5 will be slower by a factor of about two.
-The automatic translation of the compiler and linker from C to Go resulted in
-unidiomatic Go code that performs poorly compared to well-written Go.
-Analysis tools and refactoring helped to improve the code, but much remains to be done.
-Further profiling and optimization will continue in Go 1.6 and future releases.
-For more details, see these <a href="https://talks.golang.org/2015/gogo.slide">slides</a>
-and associated <a href="https://www.youtube.com/watch?v=cF1zJYkBW4A">video</a>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="flag">Flag</h3>
-
-<p>
-The flag package's
-<a href="/pkg/flag/#PrintDefaults"><code>PrintDefaults</code></a>
-function, and method on <a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a>,
-have been modified to create nicer usage messages.
-The format has been changed to be more human-friendly and in the usage
-messages a word quoted with `backquotes` is taken to be the name of the
-flag's operand to display in the usage message.
-For instance, a flag created with the invocation,
-</p>
-
-<pre>
-cpuFlag = flag.Int("cpu", 1, "run `N` processes in parallel")
-</pre>
-
-<p>
-will show the help message,
-</p>
-
-<pre>
--cpu N
-       run N processes in parallel (default 1)
-</pre>
-
-<p>
-Also, the default is now listed only when it is not the zero value for the type.
-</p>
-
-<h3 id="math_big">Floats in math/big</h3>
-
-<p>
-The <a href="/pkg/math/big/"><code>math/big</code></a> package
-has a new, fundamental data type,
-<a href="/pkg/math/big/#Float"><code>Float</code></a>,
-which implements arbitrary-precision floating-point numbers.
-A <code>Float</code> value is represented by a boolean sign,
-a variable-length mantissa, and a 32-bit fixed-size signed exponent.
-The precision of a <code>Float</code> (the mantissa size in bits)
-can be specified explicitly or is otherwise determined by the first
-operation that creates the value.
-Once created, the size of a <code>Float</code>'s mantissa may be modified with the
-<a href="/pkg/math/big/#Float.SetPrec"><code>SetPrec</code></a> method.
-<code>Floats</code> support the concept of infinities, such as are created by
-overflow, but values that would lead to the equivalent of IEEE 754 NaNs
-trigger a panic.
-<code>Float</code> operations support all IEEE-754 rounding modes.
-When the precision is set to 24 (53) bits,
-operations that stay within the range of normalized <code>float32</code>
-(<code>float64</code>)
-values produce the same results as the corresponding IEEE-754
-arithmetic on those values.
-</p>
-
-<h3 id="go_types">Go types</h3>
-
-<p>
-The <a href="/pkg/go/types/"><code>go/types</code></a> package
-up to now has been maintained in the <code>golang.org/x</code>
-repository; as of Go 1.5 it has been relocated to the main repository.
-The code at the old location is now deprecated.
-There is also a modest API change in the package, discussed below.
-</p>
-
-<p>
-Associated with this move, the
-<a href="/pkg/go/constant/"><code>go/constant</code></a>
-package also moved to the main repository;
-it was <code>golang.org/x/tools/exact</code> before.
-The <a href="/pkg/go/importer/"><code>go/importer</code></a> package
-also moved to the main repository,
-as well as some tools described above.
-</p>
-
-<h3 id="net">Net</h3>
-
-<p>
-The DNS resolver in the net package has almost always used <code>cgo</code> to access
-the system interface.
-A change in Go 1.5 means that on most Unix systems DNS resolution
-will no longer require <code>cgo</code>, which simplifies execution
-on those platforms.
-Now, if the system's networking configuration permits, the native Go resolver
-will suffice.
-The important effect of this change is that each DNS resolution occupies a goroutine
-rather than a thread,
-so a program with multiple outstanding DNS requests will consume fewer operating
-system resources.
-</p>
-
-<p>
-The decision of how to run the resolver applies at run time, not build time.
-The <code>netgo</code> build tag that has been used to enforce the use
-of the Go resolver is no longer necessary, although it still works.
-A new <code>netcgo</code> build tag forces the use of the <code>cgo</code> resolver at
-build time.
-To force <code>cgo</code> resolution at run time set
-<code>GODEBUG=netdns=cgo</code> in the environment.
-More debug options are documented <a href="https://golang.org/cl/11584">here</a>.
-</p>
-
-<p>
-This change applies to Unix systems only.
-Windows, Mac OS X, and Plan 9 systems behave as before.
-</p>
-
-<h3 id="reflect">Reflect</h3>
-
-<p>
-The <a href="/pkg/reflect/"><code>reflect</code></a> package
-has two new functions: <a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a>
-and <a href="/pkg/reflect/#FuncOf"><code>FuncOf</code></a>.
-These functions, analogous to the extant
-<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a> function,
-create new types at runtime to describe arrays and functions.
-</p>
-
-<h3 id="hardening">Hardening</h3>
-
-<p>
-Several dozen bugs were found in the standard library
-through randomized testing with the
-<a href="https://github.com/dvyukov/go-fuzz"><code>go-fuzz</code></a> tool.
-Bugs were fixed in the
-<a href="/pkg/archive/tar/"><code>archive/tar</code></a>,
-<a href="/pkg/archive/zip/"><code>archive/zip</code></a>,
-<a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>,
-<a href="/pkg/fmt/"><code>fmt</code></a>,
-<a href="/pkg/html/template/"><code>html/template</code></a>,
-<a href="/pkg/image/gif/"><code>image/gif</code></a>,
-<a href="/pkg/image/jpeg/"><code>image/jpeg</code></a>,
-<a href="/pkg/image/png/"><code>image/png</code></a>, and
-<a href="/pkg/text/template/"><code>text/template</code></a>,
-packages.
-The fixes harden the implementation against incorrect and malicious inputs.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package's
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
-<a href="/pkg/archive/zip/#Writer.SetOffset"><code>SetOffset</code></a>
-method to specify the location within the output stream at which to write the archive.
-</li>
-
-<li>
-The <a href="/pkg/bufio/#Reader"><code>Reader</code></a> in the
-<a href="/pkg/bufio/"><code>bufio</code></a> package now has a
-<a href="/pkg/bufio/#Reader.Discard"><code>Discard</code></a>
-method to discard data from the input.
-</li>
-
-<li>
-In the <a href="/pkg/bytes/"><code>bytes</code></a> package,
-the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
-now has a <a href="/pkg/bytes/#Buffer.Cap"><code>Cap</code></a> method
-that reports the number of bytes allocated within the buffer.
-Similarly, in both the <a href="/pkg/bytes/"><code>bytes</code></a>
-and <a href="/pkg/strings/"><code>strings</code></a> packages,
-the <a href="/pkg/bytes/#Reader"><code>Reader</code></a>
-type now has a <a href="/pkg/bytes/#Reader.Size"><code>Size</code></a>
-method that reports the original length of the underlying slice or string.
-</li>
-
-<li>
-Both the <a href="/pkg/bytes/"><code>bytes</code></a> and
-<a href="/pkg/strings/"><code>strings</code></a> packages
-also now have a <a href="/pkg/bytes/#LastIndexByte"><code>LastIndexByte</code></a>
-function that locates the rightmost byte with that value in the argument.
-</li>
-
-<li>
-The <a href="/pkg/crypto/"><code>crypto</code></a> package
-has a new interface, <a href="/pkg/crypto/#Decrypter"><code>Decrypter</code></a>,
-that abstracts the behavior of a private key used in asymmetric decryption.
-</li>
-
-<li>
-In the <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package,
-the documentation for the <a href="/pkg/crypto/cipher/#Stream"><code>Stream</code></a>
-interface has been clarified regarding the behavior when the source and destination are
-different lengths.
-If the destination is shorter than the source, the method will panic.
-This is not a change in the implementation, only the documentation.
-</li>
-
-<li>
-Also in the <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package,
-there is now support for nonce lengths other than 96 bytes in AES's Galois/Counter mode (GCM),
-which some protocols require.
-</li>
-
-<li>
-In the <a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a> package,
-there is now a <code>Name</code> field in the
-<a href="/pkg/crypto/elliptic/#CurveParams"><code>CurveParams</code></a> struct,
-and the curves implemented in the package have been given names.
-These names provide a safer way to select a curve, as opposed to
-selecting its bit size, for cryptographic systems that are curve-dependent.
-</li>
-
-<li>
-Also in the <a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a> package,
-the <a href="/pkg/crypto/elliptic/#Unmarshal"><code>Unmarshal</code></a> function
-now verifies that the point is actually on the curve.
-(If it is not, the function returns nils).
-This change guards against certain attacks.
-</li>
-
-<li>
-The <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a>
-package now has support for the two truncated versions of
-the SHA-512 hash algorithm, SHA-512/224 and SHA-512/256.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-minimum protocol version now defaults to TLS 1.0.
-The old default, SSLv3, is still available through <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> if needed.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports Signed Certificate Timestamps (SCTs) as specified in RFC 6962.
-The server serves them if they are listed in the
-<a href="/pkg/crypto/tls/#Certificate"><code>Certificate</code></a> struct,
-and the client requests them and exposes them, if present,
-in its <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a> struct.
-
-<li>
-The stapled OCSP response to a <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> client connection,
-previously only available via the
-<a href="/pkg/crypto/tls/#Conn.OCSPResponse"><code>OCSPResponse</code></a> method,
-is now exposed in the <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a> struct.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> server implementation
-will now always call the
-<code>GetCertificate</code> function in
-the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct
-to select a certificate for the connection when none is supplied.
-</li>
-
-<li>
-Finally, the session ticket keys in the
-<a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-can now be changed while the server is running.
-This is done through the new
-<a href="/pkg/crypto/tls/#Config.SetSessionTicketKeys"><code>SetSessionTicketKeys</code></a>
-method of the
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a> type.
-</li>
-
-<li>
-In the <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package,
-wildcards are now accepted only in the leftmost label as defined in
-<a href="https://tools.ietf.org/html/rfc6125#section-6.4.3">the specification</a>.
-</li>
-
-<li>
-Also in the <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package,
-the handling of unknown critical extensions has been changed.
-They used to cause parse errors but now they are parsed and caused errors only
-in <a href="/pkg/crypto/x509/#Certificate.Verify"><code>Verify</code></a>.
-The new field <code>UnhandledCriticalExtensions</code> of
-<a href="/pkg/crypto/x509/#Certificate"><code>Certificate</code></a> records these extensions.
-</li>
-
-<li>
-The <a href="/pkg/database/sql/#DB"><code>DB</code></a> type of the
-<a href="/pkg/database/sql/"><code>database/sql</code></a> package
-now has a <a href="/pkg/database/sql/#DB.Stats"><code>Stats</code></a> method
-to retrieve database statistics.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a>
-package has extensive additions to better support DWARF version 4.
-See for example the definition of the new type
-<a href="/pkg/debug/dwarf/#Class"><code>Class</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a> package
-also now supports decoding of DWARF line tables.
-</li>
-
-<li>
-The <a href="/pkg/debug/elf/"><code>debug/elf</code></a>
-package now has support for the 64-bit PowerPC architecture.
-</li>
-
-<li>
-The <a href="/pkg/encoding/base64/"><code>encoding/base64</code></a> package
-now supports unpadded encodings through two new encoding variables,
-<a href="/pkg/encoding/base64/#RawStdEncoding"><code>RawStdEncoding</code></a> and
-<a href="/pkg/encoding/base64/#RawURLEncoding"><code>RawURLEncoding</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now returns an <a href="/pkg/encoding/json/#UnmarshalTypeError"><code>UnmarshalTypeError</code></a>
-if a JSON value is not appropriate for the target variable or component
-to which it is being unmarshaled.
-</li>
-
-<li>
-The <code>encoding/json</code>'s
-<a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
-type has a new method that provides a streaming interface for decoding
-a JSON document:
-<a href="/pkg/encoding/json/#Decoder.Token"><code>Token</code></a>.
-It also interoperates with the existing functionality of <code>Decode</code>,
-which will continue a decode operation already started with <code>Decoder.Token</code>.
-</li>
-
-<li>
-The <a href="/pkg/flag/"><code>flag</code></a> package
-has a new function, <a href="/pkg/flag/#UnquoteUsage"><code>UnquoteUsage</code></a>,
-to assist in the creation of usage messages using the new convention
-described above.
-</li>
-
-<li>
-In the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-a value of type <a href="/pkg/reflect/#Value"><code>Value</code></a> now
-prints what it holds, rather than use the <code>reflect.Value</code>'s <code>Stringer</code>
-method, which produces things like <code>&lt;int Value&gt;</code>.
-</li>
-
-<li>
-The <a href="/pkg/ast/#EmptyStmt"><code>EmptyStmt</code></a> type
-in the <a href="/pkg/go/ast/"><code>go/ast</code></a> package now
-has a boolean <code>Implicit</code> field that records whether the
-semicolon was implicitly added or was present in the source.
-</li>
-
-<li>
-For forward compatibility the <a href="/pkg/go/build/"><code>go/build</code></a> package
-reserves <code>GOARCH</code> values for  a number of architectures that Go might support one day.
-This is not a promise that it will.
-Also, the <a href="/pkg/go/build/#Package"><code>Package</code></a> struct
-now has a <code>PkgTargetRoot</code> field that stores the
-architecture-dependent root directory in which to install, if known.
-</li>
-
-<li>
-The (newly migrated) <a href="/pkg/go/types/"><code>go/types</code></a>
-package allows one to control the prefix attached to package-level names using
-the new <a href="/pkg/go/types/#Qualifier"><code>Qualifier</code></a>
-function type as an argument to several functions. This is an API change for
-the package, but since it is new to the core, it is not breaking the Go 1 compatibility
-rules since code that uses the package must explicitly ask for it at its new location.
-To update, run
-<a href="https://golang.org/cmd/go/#hdr-Run_go_tool_fix_on_packages"><code>go fix</code></a> on your package.
-</li>
-
-<li>
-In the <a href="/pkg/image/"><code>image</code></a> package,
-the <a href="/pkg/image/#Rectangle"><code>Rectangle</code></a> type
-now implements the <a href="/pkg/image/#Image"><code>Image</code></a> interface,
-so a <code>Rectangle</code> can serve as a mask when drawing.
-</li>
-
-<li>
-Also in the <a href="/pkg/image/"><code>image</code></a> package,
-to assist in the handling of some JPEG images,
-there is now support for 4:1:1 and 4:1:0 YCbCr subsampling and basic
-CMYK support, represented by the new <code>image.CMYK</code> struct.
-</li>
-
-<li>
-The <a href="/pkg/image/color/"><code>image/color</code></a> package
-adds basic CMYK support, through the new
-<a href="/pkg/image/color/#CMYK"><code>CMYK</code></a> struct,
-the <a href="/pkg/image/color/#CMYKModel"><code>CMYKModel</code></a> color model, and the
-<a href="/pkg/image/color/#CMYKToRGB"><code>CMYKToRGB</code></a> function, as
-needed by some JPEG images.
-</li>
-
-<li>
-Also in the <a href="/pkg/image/color/"><code>image/color</code></a> package,
-the conversion of a <a href="/pkg/image/color/#YCbCr"><code>YCbCr</code></a>
-value to <code>RGBA</code> has become more precise.
-Previously, the low 8 bits were just an echo of the high 8 bits;
-now they contain more accurate information.
-Because of the echo property of the old code, the operation
-<code>uint8(r)</code> to extract an 8-bit red value worked, but is incorrect.
-In Go 1.5, that operation may yield a different value.
-The correct code is, and always was, to select the high 8 bits:
-<code>uint8(r&gt;&gt;8)</code>.
-Incidentally, the <code>image/draw</code> package
-provides better support for such conversions; see
-<a href="https://blog.golang.org/go-imagedraw-package">this blog post</a>
-for more information.
-</li>
-
-<li>
-Finally, as of Go 1.5 the closest match check in
-<a href="/pkg/image/color/#Palette.Index"><code>Index</code></a>
-now honors the alpha channel.
-</li>
-
-<li>
-The <a href="/pkg/image/gif/"><code>image/gif</code></a> package
-includes a couple of generalizations.
-A multiple-frame GIF file can now have an overall bounds different
-from all the contained single frames' bounds.
-Also, the <a href="/pkg/image/gif/#GIF"><code>GIF</code></a> struct
-now has a <code>Disposal</code> field
-that specifies the disposal method for each frame.
-</li>
-
-<li>
-The <a href="/pkg/io/"><code>io</code></a> package
-adds a <a href="/pkg/io/#CopyBuffer"><code>CopyBuffer</code></a> function
-that is like <a href="/pkg/io/#Copy"><code>Copy</code></a> but
-uses a caller-provided buffer, permitting control of allocation and buffer size.
-</li>
-
-<li>
-The <a href="/pkg/log/"><code>log</code></a> package
-has a new <a href="/pkg/log/#LUTC"><code>LUTC</code></a> flag
-that causes time stamps to be printed in the UTC time zone.
-It also adds a <a href="/pkg/log/#Logger.SetOutput"><code>SetOutput</code></a> method
-for user-created loggers.
-</li>
-
-<li>
-In Go 1.4, <a href="/pkg/math/#Max"><code>Max</code></a> was not detecting all possible NaN bit patterns.
-This is fixed in Go 1.5, so programs that use <code>math.Max</code> on data including NaNs may behave differently,
-but now correctly according to the IEEE754 definition of NaNs.
-</li>
-
-<li>
-The <a href="/pkg/math/big/"><code>math/big</code></a> package
-adds a new <a href="/pkg/math/big/#Jacobi"><code>Jacobi</code></a>
-function for integers and a new
-<a href="/pkg/math/big/#Int.ModSqrt"><code>ModSqrt</code></a>
-method for the <a href="/pkg/math/big/#Int"><code>Int</code></a> type.
-</li>
-
-<li>
-The mime package
-adds a new <a href="/pkg/mime/#WordDecoder"><code>WordDecoder</code></a> type
-to decode MIME headers containing RFC 204-encoded words.
-It also provides <a href="/pkg/mime/#BEncoding"><code>BEncoding</code></a> and
-<a href="/pkg/mime/#QEncoding"><code>QEncoding</code></a>
-as implementations of the encoding schemes of RFC 2045 and RFC 2047.
-</li>
-
-<li>
-The <a href="/pkg/mime/"><code>mime</code></a> package also adds an
-<a href="/pkg/mime/#ExtensionsByType"><code>ExtensionsByType</code></a>
-function that returns the MIME extensions know to be associated with a given MIME type.
-</li>
-
-<li>
-There is a new <a href="/pkg/mime/quotedprintable/"><code>mime/quotedprintable</code></a>
-package that implements the quoted-printable encoding defined by RFC 2045.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package will now
-<a href="/pkg/net/#Dial"><code>Dial</code></a> hostnames by trying each
-IP address in order until one succeeds.
-The <code><a href="/pkg/net/#Dialer">Dialer</a>.DualStack</code>
-mode now implements Happy Eyeballs
-(<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>) by giving the
-first address family a 300ms head start; this value can be overridden by
-the new <code>Dialer.FallbackDelay</code>.
-</li>
-
-<li>
-A number of inconsistencies in the types returned by errors in the
-<a href="/pkg/net/"><code>net</code></a> package have been
-tidied up.
-Most now return an
-<a href="/pkg/net/#OpError"><code>OpError</code></a> value
-with more information than before.
-Also, the <a href="/pkg/net/#OpError"><code>OpError</code></a>
-type now includes a <code>Source</code> field that holds the local
-network address.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-has support for setting trailers from a server <a href="/pkg/net/http/#Handler"><code>Handler</code></a>.
-For details, see the documentation for
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>.
-</li>
-
-<li>
-There is a new method to cancel a <a href="/pkg/net/http/"><code>net/http</code></a>
-<code>Request</code> by setting the new
-<a href="/pkg/net/http/#Request"><code>Request.Cancel</code></a>
-field.
-It is supported by <code>http.Transport</code>.
-The <code>Cancel</code> field's type is compatible with the
-<a href="https://godoc.org/golang.org/x/net/context"><code>context.Context.Done</code></a>
-return value.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
-there is code to ignore the zero <a href="/pkg/time/#Time"><code>Time</code></a> value
-in the <a href="/pkg/net/#ServeContent"><code>ServeContent</code></a> function.
-As of Go 1.5, it now also ignores a time value equal to the Unix epoch.
-</li>
-
-<li>
-The <a href="/pkg/net/http/fcgi/"><code>net/http/fcgi</code></a> package
-exports two new errors,
-<a href="/pkg/net/http/fcgi/#ErrConnClosed"><code>ErrConnClosed</code></a> and
-<a href="/pkg/net/http/fcgi/#ErrRequestAborted"><code>ErrRequestAborted</code></a>,
-to report the corresponding error conditions.
-</li>
-
-<li>
-The <a href="/pkg/net/http/cgi/"><code>net/http/cgi</code></a> package
-had a bug that mishandled the values of the environment variables
-<code>REMOTE_ADDR</code> and <code>REMOTE_HOST</code>.
-This has been fixed.
-Also, starting with Go 1.5 the package sets the <code>REMOTE_PORT</code>
-variable.
-</li>
-
-<li>
-The <a href="/pkg/net/mail/"><code>net/mail</code></a> package
-adds an <a href="/pkg/net/mail/#AddressParser"><code>AddressParser</code></a>
-type that can parse mail addresses.
-</li>
-
-<li>
-The <a href="/pkg/net/smtp/"><code>net/smtp</code></a> package
-now has a <a href="/pkg/net/smtp/#Client.TLSConnectionState"><code>TLSConnectionState</code></a>
-accessor to the <a href="/pkg/net/smtp/#Client"><code>Client</code></a>
-type that returns the client's TLS state.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package
-has a new <a href="/pkg/os/#LookupEnv"><code>LookupEnv</code></a> function
-that is similar to <a href="/pkg/os/#Getenv"><code>Getenv</code></a>
-but can distinguish between an empty environment variable and a missing one.
-</li>
-
-<li>
-The <a href="/pkg/os/signal/"><code>os/signal</code></a> package
-adds new <a href="/pkg/os/signal/#Ignore"><code>Ignore</code></a> and
-<a href="/pkg/os/signal/#Reset"><code>Reset</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a>,
-<a href="/pkg/runtime/trace/"><code>runtime/trace</code></a>,
-and <a href="/pkg/net/http/pprof/"><code>net/http/pprof</code></a> packages
-each have new functions to support the tracing facilities described above:
-<a href="/pkg/runtime/#ReadTrace"><code>ReadTrace</code></a>,
-<a href="/pkg/runtime/#StartTrace"><code>StartTrace</code></a>,
-<a href="/pkg/runtime/#StopTrace"><code>StopTrace</code></a>,
-<a href="/pkg/runtime/trace/#Start"><code>Start</code></a>,
-<a href="/pkg/runtime/trace/#Stop"><code>Stop</code></a>, and
-<a href="/pkg/net/http/pprof/#Trace"><code>Trace</code></a>.
-See the respective documentation for details.
-</li>
-
-<li>
-The <a href="/pkg/runtime/pprof/"><code>runtime/pprof</code></a> package
-by default now includes overall memory statistics in all memory profiles.
-</li>
-
-<li>
-The <a href="/pkg/strings/"><code>strings</code></a> package
-has a new <a href="/pkg/strings/#Compare"><code>Compare</code></a> function.
-This is present to provide symmetry with the <a href="/pkg/bytes/"><code>bytes</code></a> package
-but is otherwise unnecessary as strings support comparison natively.
-</li>
-
-<li>
-The <a href="/pkg/sync/#WaitGroup"><code>WaitGroup</code></a> implementation in
-package <a href="/pkg/sync/"><code>sync</code></a>
-now diagnoses code that races a call to <a href="/pkg/sync/#WaitGroup.Add"><code>Add</code></a>
-against a return from <a href="/pkg/sync/#WaitGroup.Wait"><code>Wait</code></a>.
-If it detects this condition, the implementation panics.
-</li>
-
-<li>
-In the <a href="/pkg/syscall/"><code>syscall</code></a> package,
-the Linux <code>SysProcAttr</code> struct now has a
-<code>GidMappingsEnableSetgroups</code> field, made necessary
-by security changes in Linux 3.19.
-On all Unix systems, the struct also has new <code>Foreground</code> and <code>Pgid</code> fields
-to provide more control when exec'ing.
-On Darwin, there is now a <code>Syscall9</code> function
-to support calls with too many arguments.
-</li>
-
-<li>
-The <a href="/pkg/testing/quick/"><code>testing/quick</code></a> will now
-generate <code>nil</code> values for pointer types,
-making it possible to use with recursive data structures.
-Also, the package now supports generation of array types.
-</li>
-
-<li>
-In the <a href="/pkg/text/template/"><code>text/template</code></a> and
-<a href="/pkg/html/template/"><code>html/template</code></a> packages,
-integer constants too large to be represented as a Go integer now trigger a
-parse error. Before, they were silently converted to floating point, losing
-precision.
-</li>
-
-<li>
-Also in the <a href="/pkg/text/template/"><code>text/template</code></a> and
-<a href="/pkg/html/template/"><code>html/template</code></a> packages,
-a new <a href="/pkg/text/template/#Template.Option"><code>Option</code></a> method
-allows customization of the behavior of the template during execution.
-The sole implemented option allows control over how a missing key is
-handled when indexing a map.
-The default, which can now be overridden, is as before: to continue with an invalid value.
-</li>
-
-<li>
-The <a href="/pkg/time/"><code>time</code></a> package's
-<code>Time</code> type has a new method
-<a href="/pkg/time/#Time.AppendFormat"><code>AppendFormat</code></a>,
-which can be used to avoid allocation when printing a time value.
-</li>
-
-<li>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-support throughout the system has been upgraded from version 7.0 to
-<a href="http://www.unicode.org/versions/Unicode8.0.0/">Unicode 8.0</a>.
-</li>
-
-</ul>

diff --git a/doc/go1.6.html b/doc/go1.6.html
deleted file mode 100644 (file)
index c8ec7e7..0000000
--- a/doc/go1.6.html
+++ /dev/null
@@ -1,923 +0,0 @@
-<!--{
-       "Title": "Go 1.6 Release Notes",
-       "Path":  "/doc/go1.6",
-       "Template": true
-}-->
-
-<!--
-Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
-Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.6</h2>
-
-<p>
-The latest Go release, version 1.6, arrives six months after 1.5.
-Most of its changes are in the implementation of the language, runtime, and libraries.
-There are no changes to the language specification.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-The release adds new ports to <a href="#ports">Linux on 64-bit MIPS and Android on 32-bit x86</a>;
-defined and enforced <a href="#cgo">rules for sharing Go pointers with C</a>;
-transparent, automatic <a href="#http2">support for HTTP/2</a>;
-and a new mechanism for <a href="#template">template reuse</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-There are no language changes in this release.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Go 1.6 adds experimental ports to
-Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>).
-These ports support <code>cgo</code> but only with internal linking.
-</p>
-
-<p>
-Go 1.6 also adds an experimental port to Android on 32-bit x86 (<code>android/386</code>).
-</p>
-
-<p>
-On FreeBSD, Go 1.6 defaults to using <code>clang</code>, not <code>gcc</code>, as the external C compiler.
-</p>
-
-<p>
-On Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>),
-Go 1.6 now supports <code>cgo</code> with external linking and
-is roughly feature complete.
-</p>
-
-<p>
-On NaCl, Go 1.5 required SDK version pepper-41.
-Go 1.6 adds support for later SDK versions.
-</p>
-
-<p>
-On 32-bit x86 systems using the <code>-dynlink</code> or <code>-shared</code> compilation modes,
-the register CX is now overwritten by certain memory references and should
-be avoided in hand-written assembly.
-See the <a href="/doc/asm#x86">assembly documentation</a> for details.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-There is one major change to <a href="/cmd/cgo/"><code>cgo</code></a>, along with one minor change.
-</p>
-
-<p>
-The major change is the definition of rules for sharing Go pointers with C code,
-to ensure that such C code can coexist with Go's garbage collector.
-Briefly, Go and C may share memory allocated by Go
-when a pointer to that memory is passed to C as part of a <code>cgo</code> call,
-provided that the memory itself contains no pointers to Go-allocated memory,
-and provided that C does not retain the pointer after the call returns.
-These rules are checked by the runtime during program execution:
-if the runtime detects a violation, it prints a diagnosis and crashes the program.
-The checks can be disabled by setting the environment variable
-<code>GODEBUG=cgocheck=0</code>, but note that the vast majority of
-code identified by the checks is subtly incompatible with garbage collection
-in one way or another.
-Disabling the checks will typically only lead to more mysterious failure modes.
-Fixing the code in question should be strongly preferred
-over turning off the checks.
-See the <a href="/cmd/cgo/#hdr-Passing_pointers"><code>cgo</code> documentation</a> for more details.
-</p>
-
-<p>
-The minor change is
-the addition of explicit <code>C.complexfloat</code> and <code>C.complexdouble</code> types,
-separate from Go's <code>complex64</code> and <code>complex128</code>.
-Matching the other numeric types, C's complex types and Go's complex type are
-no longer interchangeable.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-The compiler toolchain is mostly unchanged.
-Internally, the most significant change is that the parser is now hand-written
-instead of generated from <a href="/cmd/yacc/">yacc</a>.
-</p>
-
-<p>
-The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
-analogous to <code>-race</code> and only available on linux/amd64,
-that enables interoperation with the <a href="https://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
-Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
-</p>
-
-<p>
-The linker has a new option <code>-libgcc</code> to set the expected location
-of the C compiler support library when linking <a href="/cmd/cgo/"><code>cgo</code></a> code.
-The option is only consulted when using <code>-linkmode=internal</code>,
-and it may be set to <code>none</code> to disable the use of a support library.
-</p>
-
-<p>
-The implementation of <a href="/doc/go1.5#link">build modes started in Go 1.5</a> has been expanded to more systems.
-This release adds support for the <code>c-shared</code> mode on <code>android/386</code>, <code>android/amd64</code>,
-<code>android/arm64</code>, <code>linux/386</code>, and <code>linux/arm64</code>;
-for the <code>shared</code> mode on <code>linux/386</code>, <code>linux/arm</code>, <code>linux/amd64</code>, and <code>linux/ppc64le</code>;
-and for the new <code>pie</code> mode (generating position-independent executables) on
-<code>android/386</code>, <code>android/amd64</code>, <code>android/arm</code>, <code>android/arm64</code>, <code>linux/386</code>,
-<code>linux/amd64</code>, <code>linux/arm</code>, <code>linux/arm64</code>, and <code>linux/ppc64le</code>.
-See the <a href="https://golang.org/s/execmodes">design document</a> for details.
-</p>
-
-<p>
-As a reminder, the linker's <code>-X</code> flag changed in Go 1.5.
-In Go 1.4 and earlier, it took two arguments, as in
-</p>
-
-<pre>
--X importpath.name value
-</pre>
-
-<p>
-Go 1.5 added an alternative syntax using a single argument
-that is itself a <code>name=value</code> pair:
-</p>
-
-<pre>
--X importpath.name=value
-</pre>
-
-<p>
-In Go 1.5 the old syntax was still accepted, after printing a warning
-suggesting use of the new syntax instead.
-Go 1.6 continues to accept the old syntax and print the warning.
-Go 1.7 will remove support for the old syntax.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-The release schedules for the GCC and Go projects do not coincide.
-GCC release 5 contains the Go 1.4 version of gccgo.
-The next release, GCC 6, will have the Go 1.6.1 version of gccgo.
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p>
-The <a href="/cmd/go"><code>go</code></a> command's basic operation
-is unchanged, but there are a number of changes worth noting.
-</p>
-
-<p>
-Go 1.5 introduced experimental support for vendoring,
-enabled by setting the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>1</code>.
-Go 1.6 keeps the vendoring support, no longer considered experimental,
-and enables it by default.
-It can be disabled explicitly by setting
-the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>0</code>.
-Go 1.7 will remove support for the environment variable.
-</p>
-
-<p>
-The most likely problem caused by enabling vendoring by default happens
-in source trees containing an existing directory named <code>vendor</code> that
-does not expect to be interpreted according to new vendoring semantics.
-In this case, the simplest fix is to rename the directory to anything other
-than <code>vendor</code> and update any affected import paths.
-</p>
-
-<p>
-For details about vendoring,
-see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
-and the <a href="https://golang.org/s/go15vendor">design document</a>.
-</p>
-
-<p>
-There is a new build flag, <code>-msan</code>,
-that compiles Go with support for the LLVM memory sanitizer.
-This is intended mainly for use when linking against C or C++ code
-that is being checked with the memory sanitizer.
-</p>
-
-<h3 id="doc_command">Go doc command</h3>
-
-<p>
-Go 1.5 introduced the
-<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go doc</code></a> command,
-which allows references to packages using only the package name, as in
-<code>go</code> <code>doc</code> <code>http</code>.
-In the event of ambiguity, the Go 1.5 behavior was to use the package
-with the lexicographically earliest import path.
-In Go 1.6, ambiguity is resolved by preferring import paths with
-fewer elements, breaking ties using lexicographic comparison.
-An important effect of this change is that original copies of packages
-are now preferred over vendored copies.
-Successful searches also tend to run faster.
-</p>
-
-<h3 id="vet_command">Go vet command</h3>
-
-<p>
-The <a href="/cmd/vet"><code>go vet</code></a> command now diagnoses
-passing function or method values as arguments to <code>Printf</code>,
-such as when passing <code>f</code> where <code>f()</code> was intended.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-Some programs may run faster, some slower.
-On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.6
-than they did in Go 1.5.
-The garbage collector's pauses are even lower than in Go 1.5,
-especially for programs using
-a large amount of memory.
-</p>
-
-<p>
-There have been significant optimizations bringing more than 10% improvements
-to implementations of the
-<a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
-<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
-<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
-<a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
-<a href="/pkg/sort/"><code>sort</code></a> packages.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="http2">HTTP/2</h3>
-
-<p>
-Go 1.6 adds transparent support in the
-<a href="/pkg/net/http/"><code>net/http</code></a> package
-for the new <a href="https://http2.github.io/">HTTP/2 protocol</a>.
-Go clients and servers will automatically use HTTP/2 as appropriate when using HTTPS.
-There is no exported API specific to details of the HTTP/2 protocol handling,
-just as there is no exported API specific to HTTP/1.1.
-</p>
-
-<p>
-Programs that must disable HTTP/2 can do so by setting
-<a href="/pkg/net/http/#Transport"><code>Transport.TLSNextProto</code></a> (for clients)
-or
-<a href="/pkg/net/http/#Server"><code>Server.TLSNextProto</code></a> (for servers)
-to a non-nil, empty map.
-</p>
-
-<p>
-Programs that must adjust HTTP/2 protocol-specific details can import and use
-<a href="https://golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a>,
-in particular its
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureServer">ConfigureServer</a>
-and
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureTransport">ConfigureTransport</a>
-functions.
-</p>
-
-<h3 id="runtime">Runtime</h3>
-
-<p>
-The runtime has added lightweight, best-effort detection of concurrent misuse of maps.
-As always, if one goroutine is writing to a map, no other goroutine should be
-reading or writing the map concurrently.
-If the runtime detects this condition, it prints a diagnosis and crashes the program.
-The best way to find out more about the problem is to run the program
-under the
-<a href="https://blog.golang.org/race-detector">race detector</a>,
-which will more reliably identify the race
-and give more detail.
-</p>
-
-<p>
-For program-ending panics, the runtime now by default
-prints only the stack of the running goroutine,
-not all existing goroutines.
-Usually only the current goroutine is relevant to a panic,
-so omitting the others significantly reduces irrelevant output
-in a crash message.
-To see the stacks from all goroutines in crash messages, set the environment variable
-<code>GOTRACEBACK</code> to <code>all</code>
-or call
-<a href="/pkg/runtime/debug/#SetTraceback"><code>debug.SetTraceback</code></a>
-before the crash, and rerun the program.
-See the <a href="/pkg/runtime/#hdr-Environment_Variables">runtime documentation</a> for details.
-</p>
-
-<p>
-<em>Updating</em>:
-Uncaught panics intended to dump the state of the entire program,
-such as when a timeout is detected or when explicitly handling a received signal,
-should now call <code>debug.SetTraceback("all")</code> before panicking.
-Searching for uses of
-<a href="/pkg/os/signal/#Notify"><code>signal.Notify</code></a> may help identify such code.
-</p>
-
-<p>
-On Windows, Go programs in Go 1.5 and earlier forced
-the global Windows timer resolution to 1ms at startup
-by calling <code>timeBeginPeriod(1)</code>.
-Go no longer needs this for good scheduler performance,
-and changing the global timer resolution caused problems on some systems,
-so the call has been removed.
-</p>
-
-<p>
-When using <code>-buildmode=c-archive</code> or
-<code>-buildmode=c-shared</code> to build an archive or a shared
-library, the handling of signals has changed.
-In Go 1.5 the archive or shared library would install a signal handler
-for most signals.
-In Go 1.6 it will only install a signal handler for the
-synchronous signals needed to handle run-time panics in Go code:
-SIGBUS, SIGFPE, SIGSEGV.
-See the <a href="/pkg/os/signal">os/signal</a> package for more
-details.
-</p>
-
-<h3 id="reflect">Reflect</h3>
-
-<p>
-The
-<a href="/pkg/reflect/"><code>reflect</code></a> package has
-<a href="https://golang.org/issue/12367">resolved a long-standing incompatibility</a>
-between the gc and gccgo toolchains
-regarding embedded unexported struct types containing exported fields.
-Code that walks data structures using reflection, especially to implement
-serialization in the spirit
-of the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages,
-may need to be updated.
-</p>
-
-<p>
-The problem arises when using reflection to walk through
-an embedded unexported struct-typed field
-into an exported field of that struct.
-In this case, <code>reflect</code> had incorrectly reported
-the embedded field as exported, by returning an empty <code>Field.PkgPath</code>.
-Now it correctly reports the field as unexported
-but ignores that fact when evaluating access to exported fields
-contained within the struct.
-</p>
-
-<p>
-<em>Updating</em>:
-Typically, code that previously walked over structs and used
-</p>
-
-<pre>
-f.PkgPath != ""
-</pre>
-
-<p>
-to exclude inaccessible fields
-should now use
-</p>
-
-<pre>
-f.PkgPath != "" &amp;&amp; !f.Anonymous
-</pre>
-
-<p>
-For example, see the changes to the implementations of
-<a href="https://go-review.googlesource.com/#/c/14011/2/src/encoding/json/encode.go"><code>encoding/json</code></a> and
-<a href="https://go-review.googlesource.com/#/c/14012/2/src/encoding/xml/typeinfo.go"><code>encoding/xml</code></a>.
-</p>
-
-<h3 id="sort">Sorting</h3>
-
-<p>
-In the
-<a href="/pkg/sort/"><code>sort</code></a>
-package,
-the implementation of
-<a href="/pkg/sort/#Sort"><code>Sort</code></a>
-has been rewritten to make about 10% fewer calls to the
-<a href="/pkg/sort/#Interface"><code>Interface</code></a>'s
-<code>Less</code> and <code>Swap</code>
-methods, with a corresponding overall time savings.
-The new algorithm does choose a different ordering than before
-for values that compare equal (those pairs for which <code>Less(i,</code> <code>j)</code> and <code>Less(j,</code> <code>i)</code> are false).
-</p>
-
-<p>
-<em>Updating</em>:
-The definition of <code>Sort</code> makes no guarantee about the final order of equal values,
-but the new behavior may still break programs that expect a specific order.
-Such programs should either refine their <code>Less</code> implementations
-to report the desired order
-or should switch to
-<a href="/pkg/sort/#Stable"><code>Stable</code></a>,
-which preserves the original input order
-of equal values.
-</p>
-
-<h3 id="template">Templates</h3>
-
-<p>
-In the
-<a href="/pkg/text/template/">text/template</a> package,
-there are two significant new features to make writing templates easier.
-</p>
-
-<p>
-First, it is now possible to <a href="/pkg/text/template/#hdr-Text_and_spaces">trim spaces around template actions</a>,
-which can make template definitions more readable.
-A minus sign at the beginning of an action says to trim space before the action,
-and a minus sign at the end of an action says to trim space after the action.
-For example, the template
-</p>
-
-<pre>
-{{"{{"}}23 -}}
-   &lt;
-{{"{{"}}- 45}}
-</pre>
-
-<p>
-formats as <code>23&lt;45</code>.
-</p>
-
-<p>
-Second, the new <a href="/pkg/text/template/#hdr-Actions"><code>{{"{{"}}block}}</code> action</a>,
-combined with allowing redefinition of named templates,
-provides a simple way to define pieces of a template that
-can be replaced in different instantiations.
-There is <a href="/pkg/text/template/#example_Template_block">an example</a>
-in the <code>text/template</code> package that demonstrates this new feature.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/tar/"><code>archive/tar</code></a> package's
-implementation corrects many bugs in rare corner cases of the file format.
-One visible change is that the
-<a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> type's
-<a href="/pkg/archive/tar/#Reader.Read"><code>Read</code></a> method
-now presents the content of special file types as being empty,
-returning <code>io.EOF</code> immediately.
-</li>
-
-<li>
-In the <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package, the
-<a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> type now has a
-<a href="/pkg/archive/zip/#Reader.RegisterDecompressor"><code>RegisterDecompressor</code></a> method,
-and the
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
-<a href="/pkg/archive/zip/#Writer.RegisterCompressor"><code>RegisterCompressor</code></a> method,
-enabling control over compression options for individual zip files.
-These take precedence over the pre-existing global
-<a href="/pkg/archive/zip/#RegisterDecompressor"><code>RegisterDecompressor</code></a> and
-<a href="/pkg/archive/zip/#RegisterCompressor"><code>RegisterCompressor</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/bufio/"><code>bufio</code></a> package's
-<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type now has a
-<a href="/pkg/bufio/#Scanner.Buffer"><code>Buffer</code></a> method,
-to specify an initial buffer and maximum buffer size to use during scanning.
-This makes it possible, when needed, to scan tokens larger than
-<code>MaxScanTokenSize</code>.
-Also for the <code>Scanner</code>, the package now defines the
-<a href="/pkg/bufio/#ErrFinalToken"><code>ErrFinalToken</code></a> error value, for use by
-<a href="/pkg/bufio/#SplitFunc">split functions</a> to abort processing or to return a final empty token.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a> package
-has deprecated its
-<a href="/pkg/compress/flate/#ReadError"><code>ReadError</code></a> and
-<a href="/pkg/compress/flate/#WriteError"><code>WriteError</code></a> error implementations.
-In Go 1.5 they were only rarely returned when an error was encountered;
-now they are never returned, although they remain defined for compatibility.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>, and
-<a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> packages
-now report
-<a href="/pkg/io/#ErrUnexpectedEOF"><code>io.ErrUnexpectedEOF</code></a> for truncated input streams, instead of
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package now
-overwrites the destination buffer in the event of a GCM decryption failure.
-This is to allow the AESNI code to avoid using a temporary buffer.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-has a variety of minor changes.
-It now allows
-<a href="/pkg/crypto/tls/#Listen"><code>Listen</code></a>
-to succeed when the
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>
-has a nil <code>Certificates</code>, as long as the <code>GetCertificate</code> callback is set,
-it adds support for RSA with AES-GCM cipher suites,
-and
-it adds a
-<a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>
-to allow clients (in particular, the <a href="/pkg/net/http/"><code>net/http</code></a> package)
-to report a better error when attempting a TLS connection to a non-TLS server.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-now permits certificates to contain negative serial numbers
-(technically an error, but unfortunately common in practice),
-and it defines a new
-<a href="/pkg/crypto/x509/#InsecureAlgorithmError"><code>InsecureAlgorithmError</code></a>
-to give a better error message when rejecting a certificate
-signed with an insecure algorithm like MD5.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf"><code>debug/dwarf</code></a> and
-<a href="/pkg/debug/elf/"><code>debug/elf</code></a> packages
-together add support for compressed DWARF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-</li>
-
-<li>
-The <a href="/pkg/debug/elf/"><code>debug/elf</code></a> package
-adds support for general compressed ELF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-However, compressed
-<a href="/pkg/debug/elf/#Section"><code>Sections</code></a> do not support random access:
-they have a nil <code>ReaderAt</code> field.
-</li>
-
-<li>
-The <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package
-now exports
-<a href="/pkg/encoding/asn1/#pkg-constants">tag and class constants</a>
-useful for advanced parsing of ASN.1 structures.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
-<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects various non-standard integer and length encodings.
-</li>
-
-<li>
-The <a href="/pkg/encoding/base64"><code>encoding/base64</code></a> package's
-<a href="/pkg/encoding/base64/#Decoder"><code>Decoder</code></a> has been fixed
-to process the final bytes of its input. Previously it processed as many four-byte tokens as
-possible but ignored the remainder, up to three bytes.
-The <code>Decoder</code> therefore now handles inputs in unpadded encodings (like
-<a href="/pkg/encoding/base64/#RawURLEncoding">RawURLEncoding</a>) correctly,
-but it also rejects inputs in padded encodings that are truncated or end with invalid bytes,
-such as trailing spaces.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now checks the syntax of a
-<a href="/pkg/encoding/json/#Number"><code>Number</code></a>
-before marshaling it, requiring that it conforms to the JSON specification for numeric values.
-As in previous releases, the zero <code>Number</code> (an empty string) is marshaled as a literal 0 (zero).
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
-<a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
-function now supports a <code>cdata</code> attribute, such as <code>chardata</code>
-but encoding its argument in one or more <code>&lt;![CDATA[ ... ]]&gt;</code> tags.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package,
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a>'s
-<a href="/pkg/encoding/xml/#Decoder.Token"><code>Token</code></a> method
-now reports an error when encountering EOF before seeing all open tags closed,
-consistent with its general requirement that tags in the input be properly matched.
-To avoid that requirement, use
-<a href="/pkg/encoding/xml/#Decoder.RawToken"><code>RawToken</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/fmt/"><code>fmt</code></a> package now allows
-any integer type as an argument to
-<a href="/pkg/fmt/#Printf"><code>Printf</code></a>'s <code>*</code> width and precision specification.
-In previous releases, the argument to <code>*</code> was required to have type <code>int</code>.
-</li>
-
-<li>
-Also in the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-<a href="/pkg/fmt/#Scanf"><code>Scanf</code></a> can now scan hexadecimal strings using %X, as an alias for %x.
-Both formats accept any mix of upper- and lower-case hexadecimal.
-</li>
-
-<li>
-The <a href="/pkg/image/"><code>image</code></a>
-and
-<a href="/pkg/image/color/"><code>image/color</code></a> packages
-add
-<a href="/pkg/image/#NYCbCrA"><code>NYCbCrA</code></a>
-and
-<a href="/pkg/image/color/#NYCbCrA"><code>NYCbCrA</code></a>
-types, to support Y'CbCr images with non-premultiplied alpha.
-</li>
-
-<li>
-The <a href="/pkg/io/"><code>io</code></a> package's
-<a href="/pkg/io/#MultiWriter"><code>MultiWriter</code></a>
-implementation now implements a <code>WriteString</code> method,
-for use by
-<a href="/pkg/io/#WriteString"><code>WriteString</code></a>.
-</li>
-
-<li>
-In the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Int"><code>Int</code></a> adds
-<a href="/pkg/math/big/#Int.Append"><code>Append</code></a>
-and
-<a href="/pkg/math/big/#Int.Text"><code>Text</code></a>
-methods to give more control over printing.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a> now implements
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>,
-allowing it to be serialized in a natural form by the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a>'s
-<a href="/pkg/math/big/#Float.Append"><code>Append</code></a> method now supports the special precision argument -1.
-As in
-<a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
-precision -1 means to use the smallest number of digits necessary such that
-<a href="/pkg/math/big/#Float.Parse"><code>Parse</code></a>
-reading the result into a <code>Float</code> of the same precision
-will yield the original value.
-</li>
-
-<li>
-The <a href="/pkg/math/rand/"><code>math/rand</code></a> package
-adds a
-<a href="/pkg/math/rand/#Read"><code>Read</code></a>
-function, and likewise
-<a href="/pkg/math/rand/#Rand"><code>Rand</code></a> adds a
-<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method.
-These make it easier to generate pseudorandom test data.
-Note that, like the rest of the package,
-these should not be used in cryptographic settings;
-for such purposes, use the <a href="/pkg/crypto/rand/"><code>crypto/rand</code></a> package instead.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package's
-<a href="/pkg/net/#ParseMAC"><code>ParseMAC</code></a> function now accepts 20-byte IP-over-InfiniBand (IPoIB) link-layer addresses.
-</li>
-
-
-<li>
-Also in the <a href="/pkg/net/"><code>net</code></a> package,
-there have been a few changes to DNS lookups.
-First, the
-<a href="/pkg/net/#DNSError"><code>DNSError</code></a> error implementation now implements
-<a href="/pkg/net/#Error"><code>Error</code></a>,
-and in particular its new
-<a href="/pkg/net/#DNSError.IsTemporary"><code>IsTemporary</code></a>
-method returns true for DNS server errors.
-Second, DNS lookup functions such as
-<a href="/pkg/net/#LookupAddr"><code>LookupAddr</code></a>
-now return rooted domain names (with a trailing dot)
-on Plan 9 and Windows, to match the behavior of Go on Unix systems.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package has
-a number of minor additions beyond the HTTP/2 support already discussed.
-First, the
-<a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
-Second, the
-<a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> function now refuses to serve a result
-if the request's URL path contains &ldquo;..&rdquo; (dot-dot) as a path element.
-Programs should typically use <code>FileServer</code> and 
-<a href="/pkg/net/http/#Dir"><code>Dir</code></a>
-instead of calling <code>ServeFile</code> directly.
-Programs that need to serve file content in response to requests for URLs containing dot-dot can 
-still call <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>.
-Third, the
-<a href="/pkg/net/http/#Client"><code>Client</code></a> now allows user code to set the
-<code>Expect:</code> <code>100-continue</code> header (see
-<a href="/pkg/net/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
-Fourth, there are
-<a href="/pkg/net/http/#pkg-constants">five new error codes</a>:
-<code>StatusPreconditionRequired</code> (428),
-<code>StatusTooManyRequests</code> (429),
-<code>StatusRequestHeaderFieldsTooLarge</code> (431), and
-<code>StatusNetworkAuthenticationRequired</code> (511) from RFC 6585,
-as well as the recently-approved
-<code>StatusUnavailableForLegalReasons</code> (451).
-Fifth, the implementation and documentation of
-<a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-has been substantially changed.
-The <a href="/pkg/net/http/#Hijacker"><code>Hijacker</code></a>
-interface now works correctly on connections that have previously
-been used with <code>CloseNotifier</code>.
-The documentation now describes when <code>CloseNotifier</code>
-is expected to work.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
-there are a few changes related to the handling of a
-<a href="/pkg/net/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
-An empty <code>Method</code> field has always been documented as an alias for <code>"GET"</code>
-and it remains so.
-However, Go 1.6 fixes a few routines that did not treat an empty
-<code>Method</code> the same as an explicit <code>"GET"</code>.
-Most notably, in previous releases
-<a href="/pkg/net/http/#Client"><code>Client</code></a> followed redirects only with
-<code>Method</code> set explicitly to <code>"GET"</code>;
-in Go 1.6 <code>Client</code> also follows redirects for the empty <code>Method</code>.
-Finally,
-<a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
-documented as allowed to be empty.
-In past releases, passing an empty <code>method</code> argument resulted
-in a <code>Request</code> with an empty <code>Method</code> field.
-In Go 1.6, the resulting <code>Request</code> always has an initialized
-<code>Method</code> field: if its argument is an empty string, <code>NewRequest</code>
-sets the <code>Method</code> field in the returned <code>Request</code> to <code>"GET"</code>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/httptest/"><code>net/http/httptest</code></a> package's
-<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a> now initializes a default Content-Type header
-using the same content-sniffing algorithm as in
-<a href="/pkg/net/http/#Server"><code>http.Server</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/url/"><code>net/url</code></a> package's
-<a href="/pkg/net/url/#Parse"><code>Parse</code></a> is now stricter and more spec-compliant regarding the parsing
-of host names.
-For example, spaces in the host name are no longer accepted.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/url/"><code>net/url</code></a> package,
-the <a href="/pkg/net/url/#Error"><code>Error</code></a> type now implements
-<a href="/pkg/net/#Error"><code>net.Error</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package's
-<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
-<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>,
-and
-<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
-now return correct results when inquiring about an
-<a href="/pkg/os/#SyscallError"><code>SyscallError</code></a>.
-</li>
-
-<li>
-On Unix-like systems, when a write
-to <a href="/pkg/os/#pkg-variables"><code>os.Stdout</code>
-or <code>os.Stderr</code></a> (more precisely, an <code>os.File</code>
-opened for file descriptor 1 or 2) fails due to a broken pipe error,
-the program will raise a <code>SIGPIPE</code> signal.
-By default this will cause the program to exit; this may be changed by
-calling the
-<a href="/pkg/os/signal"><code>os/signal</code></a>
-<a href="/pkg/os/signal/#Notify"><code>Notify</code></a> function
-for <code>syscall.SIGPIPE</code>.
-A write to a broken pipe on a file descriptor other 1 or 2 will simply
-return <code>syscall.EPIPE</code> (possibly wrapped in
-<a href="/pkg/os#PathError"><code>os.PathError</code></a>
-and/or <a href="/pkg/os#SyscallError"><code>os.SyscallError</code></a>)
-to the caller.
-The old behavior of raising an uncatchable <code>SIGPIPE</code> signal
-after 10 consecutive writes to a broken pipe no longer occurs.
-</li>
-
-<li>
-In the <a href="/pkg/os/exec/"><code>os/exec</code></a> package,
-<a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a>'s
-<a href="/pkg/os/exec/#Cmd.Output"><code>Output</code></a> method continues to return an
-<a href="/pkg/os/exec/#ExitError"><code>ExitError</code></a> when a command exits with an unsuccessful status.
-If standard error would otherwise have been discarded,
-the returned <code>ExitError</code> now holds a prefix and suffix
-(currently 32 kB) of the failed command's standard error output,
-for debugging or for inclusion in error messages.
-The <code>ExitError</code>'s
-<a href="/pkg/os/exec/#ExitError.String"><code>String</code></a>
-method does not show the captured standard error;
-programs must retrieve it from the data structure
-separately.
-</li>
-
-<li>
-On Windows, the <a href="/pkg/path/filepath/"><code>path/filepath</code></a> package's
-<a href="/pkg/path/filepath/#Join"><code>Join</code></a> function now correctly handles the case when the base is a relative drive path.
-For example, <code>Join(`c:`,</code> <code>`a`)</code> now
-returns <code>`c:a`</code> instead of <code>`c:\a`</code> as in past releases.
-This may affect code that expects the incorrect result.
-</li>
-
-<li>
-In the <a href="/pkg/regexp/"><code>regexp</code></a> package,
-the
-<a href="/pkg/regexp/#Regexp"><code>Regexp</code></a> type has always been safe for use by
-concurrent goroutines.
-It uses a <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a> to protect
-a cache of scratch spaces used during regular expression searches.
-Some high-concurrency servers using the same <code>Regexp</code> from many goroutines
-have seen degraded performance due to contention on that mutex.
-To help such servers, <code>Regexp</code> now has a
-<a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> method,
-which makes a copy of a <code>Regexp</code> that shares most of the structure
-of the original but has its own scratch space cache.
-Two goroutines can use different copies of a <code>Regexp</code>
-without mutex contention.
-A copy does have additional space overhead, so <code>Copy</code>
-should only be used when contention has been observed.
-</li>
-
-<li>
-The <a href="/pkg/strconv/"><code>strconv</code></a> package adds
-<a href="/pkg/strconv/#IsGraphic"><code>IsGraphic</code></a>,
-similar to <a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>.
-It also adds
-<a href="/pkg/strconv/#QuoteToGraphic"><code>QuoteToGraphic</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToGraphic"><code>QuoteRuneToGraphic</code></a>,
-<a href="/pkg/strconv/#AppendQuoteToGraphic"><code>AppendQuoteToGraphic</code></a>,
-and
-<a href="/pkg/strconv/#AppendQuoteRuneToGraphic"><code>AppendQuoteRuneToGraphic</code></a>,
-analogous to
-<a href="/pkg/strconv/#QuoteToASCII"><code>QuoteToASCII</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToASCII"><code>QuoteRuneToASCII</code></a>,
-and so on.
-The <code>ASCII</code> family escapes all space characters except ASCII space (U+0020).
-In contrast, the <code>Graphic</code> family does not escape any Unicode space characters (category Zs).
-</li>
-
-<li>
-In the <a href="/pkg/testing/"><code>testing</code></a> package,
-when a test calls
-<a href="/pkg/testing/#T.Parallel">t.Parallel</a>,
-that test is paused until all non-parallel tests complete, and then
-that test continues execution with all other parallel tests.
-Go 1.6 changes the time reported for such a test:
-previously the time counted only the parallel execution,
-but now it also counts the time from the start of testing
-until the call to <code>t.Parallel</code>.
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package
-contains two minor changes, in addition to the <a href="#template">major changes</a>
-described above.
-First, it adds a new
-<a href="/pkg/text/template/#ExecError"><code>ExecError</code></a> type
-returned for any error during
-<a href="/pkg/text/template/#Template.Execute"><code>Execute</code></a>
-that does not originate in a <code>Write</code> to the underlying writer.
-Callers can distinguish template usage errors from I/O errors by checking for
-<code>ExecError</code>.
-Second, the
-<a href="/pkg/text/template/#Template.Funcs"><code>Funcs</code></a> method
-now checks that the names used as keys in the
-<a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
-are identifiers that can appear in a template function invocation.
-If not, <code>Funcs</code> panics.
-</li>
-
-<li>
-The <a href="/pkg/time/"><code>time</code></a> package's
-<a href="/pkg/time/#Parse"><code>Parse</code></a> function has always rejected any day of month larger than 31,
-such as January 32.
-In Go 1.6, <code>Parse</code> now also rejects February 29 in non-leap years,
-February 30, February 31, April 31, June 31, September 31, and November 31.
-</li>
-
-</ul>
-

diff --git a/doc/go1.7.html b/doc/go1.7.html
deleted file mode 100644 (file)
index 61076fd..0000000
--- a/doc/go1.7.html
+++ /dev/null
@@ -1,1281 +0,0 @@
-<!--{
-       "Title": "Go 1.7 Release Notes",
-       "Path":  "/doc/go1.7",
-       "Template": true
-}-->
-
-<!--
-for acme:
-Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
-Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',)]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
-Edit .,s;^FULL:([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',)]|$);<a href="/pkg/\1/#\2\3"><code>\1.\2\3</code></a>\4;g
-Edit .,s;^DPKG:([a-z][A-Za-z0-9_/]+);<dl id="\1"><a href="/pkg/\1/">\1</a></dl>;g
-
-rsc last updated through 6729576
--->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.7</h2>
-
-<p>
-The latest Go release, version 1.7, arrives six months after 1.6.
-Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-There is one minor change to the language specification.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-The release <a href="#ports">adds a port to IBM LinuxOne</a>;
-<a href="#compiler">updates the x86-64 compiler back end</a> to generate more efficient code;
-includes the <a href="#context">context package</a>, promoted from the
-<a href="https://golang.org/x/net/context">x/net subrepository</a>
-and now used in the standard library;
-and <a href="#testing">adds support in the testing package</a> for
-creating hierarchies of tests and benchmarks.
-The release also <a href="#cmd_go">finalizes the vendoring support</a>
-started in Go 1.5, making it a standard feature.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-There is one tiny language change in this release.
-The section on <a href="/ref/spec#Terminating_statements">terminating statements</a>
-clarifies that to determine whether a statement list ends in a terminating statement,
-the “final non-empty statement” is considered the end,
-matching the existing behavior of the gc and gccgo compiler toolchains.
-In earlier releases the definition referred only to the “final statement,”
-leaving the effect of trailing empty statements at the least unclear.
-The <a href="/pkg/go/types/"><code>go/types</code></a>
-package has been updated to match the gc and gccgo compiler toolchains
-in this respect.
-This change has no effect on the correctness of existing programs.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Go 1.7 adds support for macOS 10.12 Sierra.
-Binaries built with versions of Go before 1.7 will not work
-correctly on Sierra.
-</p>
-
-<p>
-Go 1.7 adds an experimental port to <a href="https://en.wikipedia.org/wiki/Linux_on_z_Systems">Linux on z Systems</a> (<code>linux/s390x</code>)
-and the beginning of a port to Plan 9 on ARM (<code>plan9/arm</code>).
-</p>
-
-<p>
-The experimental ports to Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>)
-added in Go 1.6 now have full support for cgo and external linking.
-</p>
-
-<p>
-The experimental port to Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>)
-now requires the POWER8 architecture or later.
-Big-endian 64-bit PowerPC (<code>linux/ppc64</code>) only requires the
-POWER5 architecture.
-</p>
-
-<p>
-The OpenBSD port now requires OpenBSD 5.6 or later, for access to the <a href="https://man.openbsd.org/getentropy.2"><i>getentropy</i>(2)</a> system call.
-</p>
-
-<h3 id="known_issues">Known Issues</h3>
-
-<p>
-There are some instabilities on FreeBSD that are known but not understood.
-These can lead to program crashes in rare cases.
-See <a href="https://golang.org/issue/16136">issue 16136</a>,
-<a href="https://golang.org/issue/15658">issue 15658</a>,
-and <a href="https://golang.org/issue/16396">issue 16396</a>.
-Any help in solving these FreeBSD-specific issues would be appreciated.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="cmd_asm">Assembler</h3>
-
-<p>
-For 64-bit ARM systems, the vector register names have been
-corrected to <code>V0</code> through <code>V31</code>;
-previous releases incorrectly referred to them as <code>V32</code> through <code>V63</code>.
-</p>
-
-<p>
-For 64-bit x86 systems, the following instructions have been added:
-<code>PCMPESTRI</code>,
-<code>RORXL</code>,
-<code>RORXQ</code>,
-<code>VINSERTI128</code>,
-<code>VPADDD</code>,
-<code>VPADDQ</code>,
-<code>VPALIGNR</code>,
-<code>VPBLENDD</code>,
-<code>VPERM2F128</code>,
-<code>VPERM2I128</code>,
-<code>VPOR</code>,
-<code>VPSHUFB</code>,
-<code>VPSHUFD</code>,
-<code>VPSLLD</code>,
-<code>VPSLLDQ</code>,
-<code>VPSLLQ</code>,
-<code>VPSRLD</code>,
-<code>VPSRLDQ</code>,
-and
-<code>VPSRLQ</code>.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-This release includes a new code generation back end for 64-bit x86 systems,
-following a <a href="https://golang.org/s/go17ssa">proposal from 2015</a>
-that has been under development since then.
-The new back end, based on
-<a href="https://en.wikipedia.org/wiki/Static_single_assignment_form">SSA</a>,
-generates more compact, more efficient code
-and provides a better platform for optimizations
-such as bounds check elimination.
-The new back end reduces the CPU time required by
-<a href="https://golang.org/test/bench/go1/">our benchmark programs</a> by 5-35%.
-</p>
-
-<p>
-For this release, the new back end can be disabled by passing
-<code>-ssa=0</code> to the compiler.
-If you find that your program compiles or runs successfully
-only with the new back end disabled, please
-<a href="https://golang.org/issue/new">file a bug report</a>.
-</p>
-
-<p>
-The format of exported metadata written by the compiler in package archives has changed:
-the old textual format has been replaced by a more compact binary format.
-This results in somewhat smaller package archives and fixes a few
-long-standing corner case bugs.
-</p>
-
-<p>
-For this release, the new export format can be disabled by passing
-<code>-newexport=0</code> to the compiler.
-If you find that your program compiles or runs successfully
-only with the new export format disabled, please
-<a href="https://golang.org/issue/new">file a bug report</a>.
-</p>
-
-<p>
-The linker's <code>-X</code> option no longer supports the unusual two-argument form
-<code>-X</code> <code>name</code> <code>value</code>,
-as <a href="/doc/go1.6#compiler">announced</a> in the Go 1.6 release
-and in warnings printed by the linker.
-Use <code>-X</code> <code>name=value</code> instead.
-</p>
-
-<p>
-The compiler and linker have been optimized and run significantly faster in this release than in Go 1.6,
-although they are still slower than we would like and will continue to be optimized in future releases.
-</p>
-
-<p>
-Due to changes across the compiler toolchain and standard library,
-binaries built with this release should typically be smaller than binaries
-built with Go 1.6,
-sometimes by as much as 20-30%.
-</p>
-
-<p>
-On x86-64 systems, Go programs now maintain stack frame pointers
-as expected by profiling tools like Linux's perf and Intel's VTune,
-making it easier to analyze and optimize Go programs using these tools.
-The frame pointer maintenance has a small run-time overhead that varies
-but averages around 2%. We hope to reduce this cost in future releases.
-To build a toolchain that does not use frame pointers, set
-<code>GOEXPERIMENT=noframepointer</code> when running
-<code>make.bash</code>, <code>make.bat</code>, or <code>make.rc</code>.
-</p>
-
-<h3 id="cmd_cgo">Cgo</h3>
-
-<p>
-Packages using <a href="/cmd/cgo/">cgo</a> may now include
-Fortran source files (in addition to C, C++, Objective C, and SWIG),
-although the Go bindings must still use C language APIs.
-</p>
-
-<p>
-Go bindings may now use a new helper function <code>C.CBytes</code>.
-In contrast to <code>C.CString</code>, which takes a Go <code>string</code>
-and returns a <code>*C.byte</code> (a C <code>char*</code>),
-<code>C.CBytes</code> takes a Go <code>[]byte</code>
-and returns an <code>unsafe.Pointer</code> (a C <code>void*</code>).
-</p>
-
-<p>
-Packages and binaries built using <code>cgo</code> have in past releases
-produced different output on each build,
-due to the embedding of temporary directory names.
-When using this release with
-new enough versions of GCC or Clang
-(those that support the <code>-fdebug-prefix-map</code> option),
-those builds should finally be deterministic.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-Due to the alignment of Go's semiannual release schedule with GCC's annual release schedule,
-GCC release 6 contains the Go 1.6.1 version of gccgo.
-The next release, GCC 7, will likely have the Go 1.8 version of gccgo.
-</p>
-
-<h3 id="cmd_go">Go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go</code></a> command's basic operation
-is unchanged, but there are a number of changes worth noting.
-</p>
-
-<p>
-This release removes support for the <code>GO15VENDOREXPERIMENT</code> environment variable,
-as <a href="/doc/go1.6#go_command">announced</a> in the Go 1.6 release.
-<a href="https://golang.org/s/go15vendor">Vendoring support</a>
-is now a standard feature of the <code>go</code> command and toolchain.
-</p>
-
-<p>
-The <code>Package</code> data structure made available to
-“<code>go</code> <code>list</code>” now includes a
-<code>StaleReason</code> field explaining why a particular package
-is or is not considered stale (in need of rebuilding).
-This field is available to the <code>-f</code> or <code>-json</code>
-options and is useful for understanding why a target is being rebuilt.
-</p>
-
-<p>
-The “<code>go</code> <code>get</code>” command now supports
-import paths referring to <code>git.openstack.org</code>.
-</p>
-
-<p>
-This release adds experimental, minimal support for building programs using
-<a href="/pkg/go/build#hdr-Binary_Only_Packages">binary-only packages</a>,
-packages distributed in binary form
-without the corresponding source code.
-This feature is needed in some commercial settings
-but is not intended to be fully integrated into the rest of the toolchain.
-For example, tools that assume access to complete source code
-will not work with such packages, and there are no plans to support
-such packages in the “<code>go</code> <code>get</code>” command.
-</p>
-
-<h3 id="cmd_doc">Go doc</h3>
-
-<p>
-The “<code>go</code> <code>doc</code>” command
-now groups constructors with the type they construct,
-following <a href="/cmd/godoc/"><code>godoc</code></a>.
-</p>
-
-<h3 id="cmd_vet">Go vet</h3>
-
-<p>
-The “<code>go</code> <code>vet</code>” command
-has more accurate analysis in its <code>-copylock</code> and <code>-printf</code> checks,
-and a new <code>-tests</code> check that checks the name and signature of likely test functions.
-To avoid confusion with the new <code>-tests</code> check, the old, unadvertised
-<code>-test</code> option has been removed; it was equivalent to <code>-all</code> <code>-shadow</code>.
-</p>
-
-<p id="vet_lostcancel">
-The <code>vet</code> command also has a new check,
-<code>-lostcancel</code>, which detects failure to call the
-cancelation function returned by the <code>WithCancel</code>,
-<code>WithTimeout</code>, and <code>WithDeadline</code> functions in
-Go 1.7's new <code>context</code> package (see <a
-href='#context'>below</a>).
-Failure to call the function prevents the new <code>Context</code>
-from being reclaimed until its parent is cancelled.
-(The background context is never cancelled.)
-</p>
-
-<h3 id="cmd_dist">Go tool dist</h3>
-
-<p>
-The new subcommand “<code>go</code> <code>tool</code> <code>dist</code> <code>list</code>”
-prints all supported operating system/architecture pairs.
-</p>
-
-<h3 id="cmd_trace">Go tool trace</h3>
-
-<p>
-The “<code>go</code> <code>tool</code> <code>trace</code>” command,
-<a href="/doc/go1.5#trace_command">introduced in Go 1.5</a>,
-has been refined in various ways.
-</p>
-
-<p>
-First, collecting traces is significantly more efficient than in past releases.
-In this release, the typical execution-time overhead of collecting a trace is about 25%;
-in past releases it was at least 400%.
-Second, trace files now include file and line number information,
-making them more self-contained and making the
-original executable optional when running the trace tool.
-Third, the trace tool now breaks up large traces to avoid limits
-in the browser-based viewer.
-</p>
-
-<p>
-Although the trace file format has changed in this release,
-the Go 1.7 tools can still read traces from earlier releases.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-Most programs should run a bit faster,
-due to speedups in the garbage collector and
-optimizations in the core library.
-On x86-64 systems, many programs will run significantly faster,
-due to improvements in generated code brought by the
-new compiler back end.
-As noted above, in our own benchmarks,
-the code generation changes alone typically reduce program CPU time by 5-35%.
-</p>
-
-<p>
-<!-- git log -''-grep '-[0-9][0-9]\.[0-9][0-9]%' go1.6.. -->
-There have been significant optimizations bringing more than 10% improvements
-to implementations in the
-<a href="/pkg/crypto/sha1/"><code>crypto/sha1</code></a>,
-<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a>,
-<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>,
-<a href="/pkg/fmt/"><code>fmt</code></a>,
-<a href="/pkg/hash/adler32/"><code>hash/adler32</code></a>,
-<a href="/pkg/hash/crc32/"><code>hash/crc32</code></a>,
-<a href="/pkg/hash/crc64/"><code>hash/crc64</code></a>,
-<a href="/pkg/image/color/"><code>image/color</code></a>,
-<a href="/pkg/math/big/"><code>math/big</code></a>,
-<a href="/pkg/strconv/"><code>strconv</code></a>,
-<a href="/pkg/strings/"><code>strings</code></a>,
-<a href="/pkg/unicode/"><code>unicode</code></a>,
-and
-<a href="/pkg/unicode/utf16/"><code>unicode/utf16</code></a>
-packages.
-</p>
-
-<p>
-Garbage collection pauses should be significantly shorter than they
-were in Go 1.6 for programs with large numbers of idle goroutines,
-substantial stack size fluctuation, or large package-level variables.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="context">Context</h3>
-
-<p>
-Go 1.7 moves the <code>golang.org/x/net/context</code> package
-into the standard library as <a href="/pkg/context/"><code>context</code></a>.
-This allows the use of contexts for cancelation, timeouts, and passing
-request-scoped data in other standard library packages,
-including
-<a href="#net">net</a>,
-<a href="#net_http">net/http</a>,
-and
-<a href="#os_exec">os/exec</a>,
-as noted below.
-</p>
-
-<p>
-For more information about contexts, see the
-<a href="/pkg/context/">package documentation</a>
-and the Go blog post
-“<a href="https://blog.golang.org/context">Go Concurrent Patterns: Context</a>.”
-</p>
-
-<h3 id="httptrace">HTTP Tracing</h3>
-
-<p>
-Go 1.7 introduces <a href="/pkg/net/http/httptrace/"><code>net/http/httptrace</code></a>,
-a package that provides mechanisms for tracing events within HTTP requests.
-</p>
-
-<h3 id="testing">Testing</h3>
-
-<p>
-The <code>testing</code> package now supports the definition
-of tests with subtests and benchmarks with sub-benchmarks.
-This support makes it easy to write table-driven benchmarks
-and to create hierarchical tests.
-It also provides a way to share common setup and tear-down code.
-See the <a href="/pkg/testing/#hdr-Subtests_and_Sub_benchmarks">package documentation</a> for details.
-</p>
-
-<h3 id="runtime">Runtime</h3>
-
-<p>
-All panics started by the runtime now use panic values
-that implement both the
-builtin <a href="/ref/spec#Errors"><code>error</code></a>,
-and
-<a href="/pkg/runtime/#Error"><code>runtime.Error</code></a>,
-as
-<a href="/ref/spec#Run_time_panics">required by the language specification</a>.
-</p>
-
-<p>
-During panics, if a signal's name is known, it will be printed in the stack trace.
-Otherwise, the signal's number will be used, as it was before Go1.7.
-</p>
-
-<p>
-The new function
-<a href="/pkg/runtime/#KeepAlive"><code>KeepAlive</code></a>
-provides an explicit mechanism for declaring
-that an allocated object must be considered reachable
-at a particular point in a program,
-typically to delay the execution of an associated finalizer.
-</p>
-
-<p>
-The new function
-<a href="/pkg/runtime/#CallersFrames"><code>CallersFrames</code></a>
-translates a PC slice obtained from
-<a href="/pkg/runtime/#Callers"><code>Callers</code></a>
-into a sequence of frames corresponding to the call stack.
-This new API should be preferred instead of direct use of
-<a href="/pkg/runtime/#FuncForPC"><code>FuncForPC</code></a>,
-because the frame sequence can more accurately describe
-call stacks with inlined function calls.
-</p>
-
-<p>
-The new function
-<a href="/pkg/runtime/#SetCgoTraceback"><code>SetCgoTraceback</code></a>
-facilitates tighter integration between Go and C code executing
-in the same process called using cgo.
-</p>
-
-<p>
-On 32-bit systems, the runtime can now use memory allocated
-by the operating system anywhere in the address space,
-eliminating the
-“memory allocated by OS not in usable range” failure
-common in some environments.
-</p>
-
-<p>
-The runtime can now return unused memory to the operating system on
-all architectures.
-In Go 1.6 and earlier, the runtime could not
-release memory on ARM64, 64-bit PowerPC, or MIPS.
-</p>
-
-<p>
-On Windows, Go programs in Go 1.5 and earlier forced
-the global Windows timer resolution to 1ms at startup
-by calling <code>timeBeginPeriod(1)</code>.
-Changing the global timer resolution caused problems on some systems,
-and testing suggested that the call was not needed for good scheduler performance,
-so Go 1.6 removed the call.
-Go 1.7 brings the call back: under some workloads the call
-is still needed for good scheduler performance.
-</p>
-
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-As always, there are various minor changes and updates to the library,
-made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-in mind.
-</p>
-
-<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
-
-<dd>
-<p>
-In previous releases of Go, if
-<a href="/pkg/bufio/#Reader"><code>Reader</code></a>'s
-<a href="/pkg/bufio/#Reader.Peek"><code>Peek</code></a> method
-were asked for more bytes than fit in the underlying buffer,
-it would return an empty slice and the error <code>ErrBufferFull</code>.
-Now it returns the entire underlying buffer, still accompanied by the error <code>ErrBufferFull</code>.
-</p>
-</dd>
-</dl>
-
-<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
-
-<dd>
-<p>
-The new functions
-<a href="/pkg/bytes/#ContainsAny"><code>ContainsAny</code></a> and
-<a href="/pkg/bytes/#ContainsRune"><code>ContainsRune</code></a>
-have been added for symmetry with
-the <a href="/pkg/strings/"><code>strings</code></a> package.
-</p>
-
-<p>
-In previous releases of Go, if
-<a href="/pkg/bytes/#Reader"><code>Reader</code></a>'s
-<a href="/pkg/bytes/#Reader.Read"><code>Read</code></a> method
-were asked for zero bytes with no data remaining, it would
-return a count of 0 and no error.
-Now it returns a count of 0 and the error
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
-</p>
-
-<p>
-The
-<a href="/pkg/bytes/#Reader"><code>Reader</code></a> type has a new method
-<a href="/pkg/bytes/#Reader.Reset"><code>Reset</code></a> to allow reuse of a <code>Reader</code>.
-</p>
-</dd>
-</dl>
-
-<dl id="compress_flate"><dt><a href="/pkg/compress/flate/">compress/flate</a></dt>
-
-<dd>
-<p>
-There are many performance optimizations throughout the package.
-Decompression speed is improved by about 10%,
-while compression for <code>DefaultCompression</code> is twice as fast.
-</p>
-
-<p>
-In addition to those general improvements,
-the
-<code>BestSpeed</code>
-compressor has been replaced entirely and uses an
-algorithm similar to <a href="https://github.com/google/snappy">Snappy</a>,
-resulting in about a 2.5X speed increase,
-although the output can be 5-10% larger than with the previous algorithm.
-</p>
-
-<p>
-There is also a new compression level
-<code>HuffmanOnly</code>
-that applies Huffman but not Lempel-Ziv encoding.
-<a href="https://blog.klauspost.com/constant-time-gzipzip-compression/">Forgoing Lempel-Ziv encoding</a> means that
-<code>HuffmanOnly</code> runs about 3X faster than the new <code>BestSpeed</code>
-but at the cost of producing compressed outputs that are 20-40% larger than those
-generated by the new <code>BestSpeed</code>.
-</p>
-
-<p>
-It is important to note that both
-<code>BestSpeed</code> and <code>HuffmanOnly</code> produce a compressed output that is
-<a href="https://tools.ietf.org/html/rfc1951">RFC 1951</a> compliant.
-In other words, any valid DEFLATE decompressor will continue to be able to decompress these outputs.
-</p>
-
-<p>
-Lastly, there is a minor change to the decompressor's implementation of
-<a href="/pkg/io/#Reader"><code>io.Reader</code></a>. In previous versions,
-the decompressor deferred reporting
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a> until exactly no more bytes could be read.
-Now, it reports
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a> more eagerly when reading the last set of bytes.
-</p>
-</dd>
-</dl>
-
-<dl id="crypto_tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-
-<dd>
-<p>
-The TLS implementation sends the first few data packets on each connection
-using small record sizes, gradually increasing to the TLS maximum record size.
-This heuristic reduces the amount of data that must be received before
-the first packet can be decrypted, improving communication latency over
-low-bandwidth networks.
-Setting
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>'s
-<code>DynamicRecordSizingDisabled</code> field to true
-forces the behavior of Go 1.6 and earlier, where packets are
-as large as possible from the start of the connection.
-</p>
-
-<p>
-The TLS client now has optional, limited support for server-initiated renegotiation,
-enabled by setting the
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>'s
-<code>Renegotiation</code> field.
-This is needed for connecting to many Microsoft Azure servers.
-</p>
-
-<p>
-The errors returned by the package now consistently begin with a
-<code>tls:</code> prefix.
-In past releases, some errors used a <code>crypto/tls:</code> prefix,
-some used a <code>tls:</code> prefix, and some had no prefix at all.
-</p>
-
-<p>
-When generating self-signed certificates, the package no longer sets the
-“Authority Key Identifier” field by default.
-</p>
-</dd>
-</dl>
-
-<dl id="crypto_x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-
-<dd>
-<p>
-The new function
-<a href="/pkg/crypto/x509/#SystemCertPool"><code>SystemCertPool</code></a>
-provides access to the entire system certificate pool if available.
-There is also a new associated error type
-<a href="/pkg/crypto/x509/#SystemRootsError"><code>SystemRootsError</code></a>.
-</p>
-</dd>
-</dl>
-
-<dl id="debug_dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/debug/dwarf/#Reader"><code>Reader</code></a> type's new
-<a href="/pkg/debug/dwarf/#Reader.SeekPC"><code>SeekPC</code></a> method and the
-<a href="/pkg/debug/dwarf/#Data"><code>Data</code></a> type's new
-<a href="/pkg/debug/dwarf/#Ranges"><code>Ranges</code></a> method
-help to find the compilation unit to pass to a
-<a href="/pkg/debug/dwarf/#LineReader"><code>LineReader</code></a>
-and to identify the specific function for a given program counter.
-</p>
-</dd>
-</dl>
-
-<dl id="debug_elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
-
-<dd>
-<p>
-The new
-<a href="/pkg/debug/elf/#R_390"><code>R_390</code></a> relocation type
-and its many predefined constants
-support the S390 port.
-</p>
-</dd>
-</dl>
-
-<dl id="encoding_asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-
-<dd>
-<p>
-The ASN.1 decoder now rejects non-minimal integer encodings.
-This may cause the package to reject some invalid but formerly accepted ASN.1 data.
-</p>
-</dd>
-</dl>
-
-<dl id="encoding_json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/encoding/json/#Encoder"><code>Encoder</code></a>'s new
-<a href="/pkg/encoding/json/#Encoder.SetIndent"><code>SetIndent</code></a> method
-sets the indentation parameters for JSON encoding,
-like in the top-level
-<a href="/pkg/encoding/json/#Indent"><code>Indent</code></a> function.
-</p>
-
-<p>
-The
-<a href="/pkg/encoding/json/#Encoder"><code>Encoder</code></a>'s new
-<a href="/pkg/encoding/json/#Encoder.SetEscapeHTML"><code>SetEscapeHTML</code></a> method
-controls whether the
-<code>&#x26;</code>, <code>&#x3c;</code>, and <code>&#x3e;</code>
-characters in quoted strings should be escaped as
-<code>\u0026</code>, <code>\u003c</code>, and <code>\u003e</code>,
-respectively.
-As in previous releases, the encoder defaults to applying this escaping,
-to avoid certain problems that can arise when embedding JSON in HTML.
-</p>
-
-<p>
-In earlier versions of Go, this package only supported encoding and decoding
-maps using keys with string types.
-Go 1.7 adds support for maps using keys with integer types:
-the encoding uses a quoted decimal representation as the JSON key.
-Go 1.7 also adds support for encoding maps using non-string keys that implement
-the <code>MarshalText</code>
-(see
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a>)
-method,
-as well as support for decoding maps using non-string keys that implement
-the <code>UnmarshalText</code>
-(see
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>)
-method.
-These methods are ignored for keys with string types in order to preserve
-the encoding and decoding used in earlier versions of Go.
-</p>
-
-<p>
-When encoding a slice of typed bytes,
-<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
-now generates an array of elements encoded using
-that byte type's
-<code>MarshalJSON</code>
-or
-<code>MarshalText</code>
-method if present,
-only falling back to the default base64-encoded string data if neither method is available.
-Earlier versions of Go accept both the original base64-encoded string encoding
-and the array encoding (assuming the byte type also implements
-<code>UnmarshalJSON</code>
-or
-<code>UnmarshalText</code>
-as appropriate),
-so this change should be semantically backwards compatible with earlier versions of Go,
-even though it does change the chosen encoding.
-</p>
-</dd>
-</dl>
-
-<dl id="go_build"><dt><a href="/pkg/go/build/">go/build</a></dt>
-
-<dd>
-<p>
-To implement the go command's new support for binary-only packages
-and for Fortran code in cgo-based packages,
-the
-<a href="/pkg/go/build/#Package"><code>Package</code></a> type
-adds new fields <code>BinaryOnly</code>, <code>CgoFFLAGS</code>, and <code>FFiles</code>.
-</p>
-</dd>
-</dl>
-
-<dl id="go_doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-
-<dd>
-<p>
-To support the corresponding change in <code>go</code> <code>test</code> described above,
-<a href="/pkg/go/doc/#Example"><code>Example</code></a> struct adds a Unordered field
-indicating whether the example may generate its output lines in any order.
-</p>
-</dd>
-</dl>
-
-<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
-
-<dd>
-<p>
-The package adds new constants
-<code>SeekStart</code>, <code>SeekCurrent</code>, and <code>SeekEnd</code>,
-for use with
-<a href="/pkg/io/#Seeker"><code>Seeker</code></a>
-implementations.
-These constants are preferred over <code>os.SEEK_SET</code>, <code>os.SEEK_CUR</code>, and <code>os.SEEK_END</code>,
-but the latter will be preserved for compatibility.
-</p>
-</dd>
-</dl>
-
-<dl id="math_big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/math/big/#Float"><code>Float</code></a> type adds
-<a href="/pkg/math/big/#Float.GobEncode"><code>GobEncode</code></a> and
-<a href="/pkg/math/big/#Float.GobDecode"><code>GobDecode</code></a> methods,
-so that values of type <code>Float</code> can now be encoded and decoded using the
-<a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>
-package.
-</p>
-</dd>
-</dl>
-
-<dl id="math_rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/math/rand/#Read"><code>Read</code></a> function and
-<a href="/pkg/math/rand/#Rand"><code>Rand</code></a>'s
-<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method
-now produce a pseudo-random stream of bytes that is consistent and not
-dependent on the size of the input buffer.
-</p>
-
-<p>
-The documentation clarifies that
-Rand's <a href="/pkg/math/rand/#Rand.Seed"><code>Seed</code></a>
-and <a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> methods
-are not safe to call concurrently, though the global
-functions <a href="/pkg/math/rand/#Seed"><code>Seed</code></a>
-and <a href="/pkg/math/rand/#Read"><code>Read</code></a> are (and have
-always been) safe.
-</p>
-</dd>
-</dl>
-
-<dl id="mime_multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/mime/multipart/#Writer"><code>Writer</code></a>
-implementation now emits each multipart section's header sorted by key.
-Previously, iteration over a map caused the section header to use a
-non-deterministic order.
-</p>
-</dd>
-</dl>
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-
-<dd>
-<p>
-As part of the introduction of <a href="#context">context</a>, the
-<a href="/pkg/net/#Dialer"><code>Dialer</code></a> type has a new method
-<a href="/pkg/net/#Dialer.DialContext"><code>DialContext</code></a>, like
-<a href="/pkg/net/#Dialer.Dial"><code>Dial</code></a> but adding the
-<a href="/pkg/context/#Context"><code>context.Context</code></a>
-for the dial operation.
-The context is intended to obsolete the <code>Dialer</code>'s
-<code>Cancel</code> and <code>Deadline</code> fields,
-but the implementation continues to respect them,
-for backwards compatibility.
-</p>
-
-<p>
-The
-<a href="/pkg/net/#IP"><code>IP</code></a> type's
-<a href="/pkg/net/#IP.String"><code>String</code></a> method has changed its result for invalid <code>IP</code> addresses.
-In past releases, if an <code>IP</code> byte slice had length other than 0, 4, or 16, <code>String</code>
-returned <code>"?"</code>.
-Go 1.7 adds the hexadecimal encoding of the bytes, as in <code>"?12ab"</code>.
-</p>
-
-<p>
-The pure Go <a href="/pkg/net/#hdr-Name_Resolution">name resolution</a>
-implementation now respects <code>nsswitch.conf</code>'s
-stated preference for the priority of DNS lookups compared to
-local file (that is, <code>/etc/hosts</code>) lookups.
-</p>
-</dd>
-</dl>
-
-<dl id="net_http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-
-<dd>
-<p>
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>'s
-documentation now makes clear that beginning to write the response
-may prevent future reads on the request body.
-For maximal compatibility, implementations are encouraged to
-read the request body completely before writing any part of the response.
-</p>
-
-<p>
-As part of the introduction of <a href="#context">context</a>, the
-<a href="/pkg/net/http/#Request"><code>Request</code></a> has a new methods
-<a href="/pkg/net/http/#Request.Context"><code>Context</code></a>, to retrieve the associated context, and
-<a href="/pkg/net/http/#Request.WithContext"><code>WithContext</code></a>, to construct a copy of <code>Request</code>
-with a modified context.
-</p>
-
-<p>
-In the
-<a href="/pkg/net/http/#Server"><code>Server</code></a> implementation,
-<a href="/pkg/net/http/#Server.Serve"><code>Serve</code></a> records in the request context
-both the underlying <code>*Server</code> using the key <code>ServerContextKey</code>
-and the local address on which the request was received (a
-<a href="/pkg/net/#Addr"><code>Addr</code></a>) using the key <code>LocalAddrContextKey</code>.
-For example, the address on which a request received is
-<code>req.Context().Value(http.LocalAddrContextKey).(net.Addr)</code>.
-</p>
-
-<p>
-The server's <a href="/pkg/net/http/#Server.Serve"><code>Serve</code></a> method
-now only enables HTTP/2 support if the <code>Server.TLSConfig</code> field is <code>nil</code>
-or includes <code>"h2"</code> in its <code>TLSConfig.NextProtos</code>.
-</p>
-
-<p>
-The server implementation now
-pads response codes less than 100 to three digits
-as required by the protocol,
-so that <code>w.WriteHeader(5)</code> uses the HTTP response
-status <code>005</code>, not just <code>5</code>.
-</p>
-
-<p>
-The server implementation now correctly sends only one "Transfer-Encoding" header when "chunked"
-is set explicitly, following <a href="https://tools.ietf.org/html/rfc7230#section-3.3.1">RFC 7230</a>.
-</p>
-
-<p>
-The server implementation is now stricter about rejecting requests with invalid HTTP versions.
-Invalid requests claiming to be HTTP/0.x are now rejected (HTTP/0.9 was never fully supported),
-and plaintext HTTP/2 requests other than the "PRI * HTTP/2.0" upgrade request are now rejected as well.
-The server continues to handle encrypted HTTP/2 requests.
-</p>
-
-<p>
-In the server, a 200 status code is sent back by the timeout handler on an empty
-response body, instead of sending back 0 as the status code.
-</p>
-
-<p>
-In the client, the
-<a href="/pkg/net/http/#Transport"><code>Transport</code></a> implementation passes the request context
-to any dial operation connecting to the remote server.
-If a custom dialer is needed, the new <code>Transport</code> field
-<code>DialContext</code> is preferred over the existing <code>Dial</code> field,
-to allow the transport to supply a context.
-</p>
-
-<p>
-The
-<a href="/pkg/net/http/#Transport"><code>Transport</code></a> also adds fields
-<code>IdleConnTimeout</code>,
-<code>MaxIdleConns</code>,
-and
-<code>MaxResponseHeaderBytes</code>
-to help control client resources consumed
-by idle or chatty servers.
-</p>
-
-<p>
-A
-<a href="/pkg/net/http/#Client"><code>Client</code></a>'s configured <code>CheckRedirect</code> function can now
-return <code>ErrUseLastResponse</code> to indicate that the
-most recent redirect response should be returned as the
-result of the HTTP request.
-That response is now available to the <code>CheckRedirect</code> function
-as <code>req.Response</code>.
-</p>
-
-<p>
-Since Go 1, the default behavior of the HTTP client is
-to request server-side compression
-using the <code>Accept-Encoding</code> request header
-and then to decompress the response body transparently,
-and this behavior is adjustable using the
-<a href="/pkg/net/http/#Transport"><code>Transport</code></a>'s <code>DisableCompression</code> field.
-In Go 1.7, to aid the implementation of HTTP proxies, the
-<a href="/pkg/net/http/#Response"><code>Response</code></a>'s new
-<code>Uncompressed</code> field reports whether
-this transparent decompression took place.
-</p>
-
-<p>
-<a href="/pkg/net/http/#DetectContentType"><code>DetectContentType</code></a>
-adds support for a few new audio and video content types.
-</p>
-</dd>
-</dl>
-
-<dl id="net_http_cgi"><dt><a href="/pkg/net/http/cgi/">net/http/cgi</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/net/http/cgi/#Handler"><code>Handler</code></a>
-adds a new field
-<code>Stderr</code>
-that allows redirection of the child process's
-standard error away from the host process's
-standard error.
-</p>
-</dd>
-</dl>
-
-<dl id="net_http_httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
-
-<dd>
-<p>
-The new function
-<a href="/pkg/net/http/httptest/#NewRequest"><code>NewRequest</code></a>
-prepares a new
-<a href="/pkg/net/http/#Request"><code>http.Request</code></a>
-suitable for passing to an
-<a href="/pkg/net/http/#Handler"><code>http.Handler</code></a> during a test.
-</p>
-
-<p>
-The
-<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a>'s new
-<a href="/pkg/net/http/httptest/#ResponseRecorder.Result"><code>Result</code></a> method
-returns the recorded
-<a href="/pkg/net/http/#Response"><code>http.Response</code></a>.
-Tests that need to check the response's headers or trailers
-should call <code>Result</code> and inspect the response fields
-instead of accessing
-<code>ResponseRecorder</code>'s <code>HeaderMap</code> directly.
-</p>
-</dd>
-</dl>
-
-<dl id="net_http_httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> implementation now responds with “502 Bad Gateway”
-when it cannot reach a back end; in earlier releases it responded with “500 Internal Server Error.”
-</p>
-
-<p>
-Both
-<a href="/pkg/net/http/httputil/#ClientConn"><code>ClientConn</code></a> and
-<a href="/pkg/net/http/httputil/#ServerConn"><code>ServerConn</code></a> have been documented as deprecated.
-They are low-level, old, and unused by Go's current HTTP stack
-and will no longer be updated.
-Programs should use
-<a href="/pkg/net/http/#Client"><code>http.Client</code></a>,
-<a href="/pkg/net/http/#Transport"><code>http.Transport</code></a>,
-and
-<a href="/pkg/net/http/#Server"><code>http.Server</code></a>
-instead.
-</p>
-</dd>
-</dl>
-
-<dl id="net_http_pprof"><dt><a href="/pkg/net/http/pprof/">net/http/pprof</a></dt>
-
-<dd>
-<p>
-The runtime trace HTTP handler, installed to handle the path <code>/debug/pprof/trace</code>,
-now accepts a fractional number in its <code>seconds</code> query parameter,
-allowing collection of traces for intervals smaller than one second.
-This is especially useful on busy servers.
-</p>
-</dd>
-</dl>
-
-<dl><dt><a href="/pkg/net/mail/">net/mail</a></dt>
-
-<dd>
-<p>
-The address parser now allows unescaped UTF-8 text in addresses
-following <a href="https://tools.ietf.org/html/rfc6532">RFC 6532</a>,
-but it does not apply any normalization to the result.
-For compatibility with older mail parsers,
-the address encoder, namely
-<a href="/pkg/net/mail/#Address"><code>Address</code></a>'s
-<a href="/pkg/net/mail/#Address.String"><code>String</code></a> method,
-continues to escape all UTF-8 text following <a href="https://tools.ietf.org/html/rfc5322">RFC 5322</a>.
-</p>
-
-<p>
-The <a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a>
-function and
-the <a href="/pkg/net/mail/#AddressParser.Parse"><code>AddressParser.Parse</code></a>
-method are stricter.
-They used to ignore any characters following an e-mail address, but
-will now return an error for anything other than whitespace.
-</p>
-</dd>
-</dl>
-
-<dl id="net_url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/net/url/#URL"><code>URL</code></a>'s
-new <code>ForceQuery</code> field
-records whether the URL must have a query string,
-in order to distinguish URLs without query strings (like <code>/search</code>)
-from URLs with empty query strings (like <code>/search?</code>).
-</p>
-</dd>
-</dl>
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-
-<dd>
-<p>
-<a href="/pkg/os/#IsExist"><code>IsExist</code></a> now returns true for <code>syscall.ENOTEMPTY</code>,
-on systems where that error exists.
-</p>
-
-<p>
-On Windows,
-<a href="/pkg/os/#Remove"><code>Remove</code></a> now removes read-only files when possible,
-making the implementation behave as on
-non-Windows systems.
-</p>
-</dd>
-</dl>
-
-<dl id="os_exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
-
-<dd>
-<p>
-As part of the introduction of <a href="#context">context</a>,
-the new constructor
-<a href="/pkg/os/exec/#CommandContext"><code>CommandContext</code></a>
-is like
-<a href="/pkg/os/exec/#Command"><code>Command</code></a> but includes a context that can be used to cancel the command execution.
-</p>
-</dd>
-</dl>
-
-<dl id="os_user"><dt><a href="/pkg/os/user/">os/user</a></dt>
-
-<dd>
-<p>
-The
-<a href="/pkg/os/user/#Current"><code>Current</code></a>
-function is now implemented even when cgo is not available.
-</p>
-
-<p>
-The new
-<a href="/pkg/os/user/#Group"><code>Group</code></a> type,
-along with the lookup functions
-<a href="/pkg/os/user/#LookupGroup"><code>LookupGroup</code></a> and
-<a href="/pkg/os/user/#LookupGroupId"><code>LookupGroupId</code></a>
-and the new field <code>GroupIds</code> in the <code>User</code> struct,
-provides access to system-specific user group information.
-</p>
-</dd>
-</dl>
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-
-<dd>
-<p>
-Although
-<a href="/pkg/reflect/#Value"><code>Value</code></a>'s
-<a href="/pkg/reflect/#Value.Field"><code>Field</code></a> method has always been documented to panic
-if the given field number <code>i</code> is out of range, it has instead
-silently returned a zero
-<a href="/pkg/reflect/#Value"><code>Value</code></a>.
-Go 1.7 changes the method to behave as documented.
-</p>
-
-<p>
-The new
-<a href="/pkg/reflect/#StructOf"><code>StructOf</code></a>
-function constructs a struct type at run time.
-It completes the set of type constructors, joining
-<a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a>,
-<a href="/pkg/reflect/#ChanOf"><code>ChanOf</code></a>,
-<a href="/pkg/reflect/#FuncOf"><code>FuncOf</code></a>,
-<a href="/pkg/reflect/#MapOf"><code>MapOf</code></a>,
-<a href="/pkg/reflect/#PtrTo"><code>PtrTo</code></a>,
-and
-<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a>.
-</p>
-
-<p>
-<a href="/pkg/reflect/#StructTag"><code>StructTag</code></a>'s
-new method
-<a href="/pkg/reflect/#StructTag.Lookup"><code>Lookup</code></a>
-is like
-<a href="/pkg/reflect/#StructTag.Get"><code>Get</code></a>
-but distinguishes the tag not containing the given key
-from the tag associating an empty string with the given key.
-</p>
-
-<p>
-The
-<a href="/pkg/reflect/#Type.Method"><code>Method</code></a> and
-<a href="/pkg/reflect/#Type.NumMethod"><code>NumMethod</code></a>
-methods of
-<a href="/pkg/reflect/#Type"><code>Type</code></a> and
-<a href="/pkg/reflect/#Value"><code>Value</code></a>
-no longer return or count unexported methods.
-</p>
-</dd>
-</dl>
-
-<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
-
-<dd>
-<p>
-In previous releases of Go, if
-<a href="/pkg/strings/#Reader"><code>Reader</code></a>'s
-<a href="/pkg/strings/#Reader.Read"><code>Read</code></a> method
-were asked for zero bytes with no data remaining, it would
-return a count of 0 and no error.
-Now it returns a count of 0 and the error
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
-</p>
-
-<p>
-The
-<a href="/pkg/strings/#Reader"><code>Reader</code></a> type has a new method
-<a href="/pkg/strings/#Reader.Reset"><code>Reset</code></a> to allow reuse of a <code>Reader</code>.
-</p>
-</dd>
-</dl>
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-
-<dd>
-<p>
-<a href="/pkg/time/#Duration"><code>Duration</code></a>'s
-time.Duration.String method now reports the zero duration as <code>"0s"</code>, not <code>"0"</code>.
-<a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> continues to accept both forms.
-</p>
-
-<p>
-The method call <code>time.Local.String()</code> now returns <code>"Local"</code> on all systems;
-in earlier releases, it returned an empty string on Windows.
-</p>
-
-<p>
-The time zone database in
-<code>$GOROOT/lib/time</code> has been updated
-to IANA release 2016d.
-This fallback database is only used when the system time zone database
-cannot be found, for example on Windows.
-The Windows time zone abbreviation list has also been updated.
-</p>
-</dd>
-</dl>
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-
-<dd>
-<p>
-On Linux, the
-<a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a> struct
-(as used in
-<a href="/pkg/os/exec/#Cmd"><code>os/exec.Cmd</code></a>'s <code>SysProcAttr</code> field)
-has a new <code>Unshareflags</code> field.
-If the field is nonzero, the child process created by
-<a href="/pkg/syscall/#ForkExec"><code>ForkExec</code></a>
-(as used in <code>exec.Cmd</code>'s <code>Run</code> method)
-will call the
-<a href="http://man7.org/linux/man-pages/man2/unshare.2.html"><i>unshare</i>(2)</a>
-system call before executing the new program.
-</p>
-</dd>
-</dl>
-
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-
-<dd>
-<p>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-support throughout the system has been upgraded from version 8.0 to
-<a href="http://www.unicode.org/versions/Unicode9.0.0/">Unicode 9.0</a>.
-</p>
-</dd>
-</dl>

diff --git a/doc/go1.8.html b/doc/go1.8.html
deleted file mode 100644 (file)
index 2a47fac..0000000
--- a/doc/go1.8.html
+++ /dev/null
@@ -1,1666 +0,0 @@
-<!--{
-       "Title": "Go 1.8 Release Notes",
-       "Path":  "/doc/go1.8",
-       "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.8</h2>
-
-<p>
-The latest Go release, version 1.8, arrives six months after <a href="go1.7">Go 1.7</a>.
-Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-There are <a href="#language">two minor changes</a> to the language specification.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-The release <a href="#ports">adds support for 32-bit MIPS</a>,
-<a href="#compiler">updates the compiler back end</a> to generate more efficient code,
-<a href="#gc">reduces GC pauses</a> by eliminating stop-the-world stack rescanning,
-<a href="#h2push">adds HTTP/2 Push support</a>,
-<a href="#http_shutdown">adds HTTP graceful shutdown</a>,
-<a href="#more_context">adds more context support</a>,
-<a href="#mutex_prof">enables profiling mutexes</a>,
-and <a href="#sort_slice">simplifies sorting slices</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  When explicitly converting a value from one struct type to another,
-  as of Go 1.8 the tags are ignored. Thus two structs that differ
-  only in their tags may be converted from one to the other:
-</p>
-
-<pre>
-func example() {
-       type T1 struct {
-               X int `json:"foo"`
-       }
-       type T2 struct {
-               X int `json:"bar"`
-       }
-       var v1 T1
-       var v2 T2
-       v1 = T1(v2) // now legal
-}
-</pre>
-
-
-<p> <!-- CL 17711 -->
-  The language specification now only requires that implementations
-  support up to 16-bit exponents in floating-point constants.  This does not affect
-  either the “<a href="/cmd/compile/"><code>gc</code></a>” or
-  <code>gccgo</code> compilers, both of
-  which still support 32-bit exponents.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Go now supports 32-bit MIPS on Linux for both big-endian
-(<code>linux/mips</code>) and little-endian machines
-(<code>linux/mipsle</code>) that implement the MIPS32r1 instruction set with FPU
-or kernel FPU emulation. Note that many common MIPS-based routers lack an FPU and
-have firmware that doesn't enable kernel FPU emulation; Go won't run on such machines.
-</p>
-
-<p>
-On DragonFly BSD, Go now requires DragonFly 4.4.4 or later. <!-- CL 29491, CL 29971 -->
-</p>
-
-<p>
-On OpenBSD, Go now requires OpenBSD 5.9 or later. <!-- CL 34093 -->
-</p>
-
-<p>
-The Plan 9 port's networking support is now much more complete
-and matches the behavior of Unix and Windows with respect to deadlines
-and cancelation. For Plan 9 kernel requirements, see the
-<a href="https://golang.org/wiki/Plan9">Plan 9 wiki page</a>.
-</p>
-
-<p>
-  Go 1.8 now only supports OS X 10.8 or later. This is likely the last
-  Go release to support 10.8. Compiling Go or running
-  binaries on older OS X versions is untested.
-</p>
-
-<p>
-  Go 1.8 will be the last release to support Linux on ARMv5E and ARMv6 processors:
-  Go 1.9 will likely require the ARMv6K (as found in the Raspberry Pi 1) or later.
-  To identify whether a Linux system is ARMv6K or later, run
-  “<code>go</code> <code>tool</code> <code>dist</code> <code>-check-armv6k</code>”
-  (to facilitate testing, it is also possible to just copy the <code>dist</code> command to the
-  system without installing a full copy of Go 1.8)
-  and if the program terminates with output "ARMv6K supported." then the system
-  implements ARMv6K or later.
-  Go on non-Linux ARM systems already requires ARMv6K or later.
-</p>
-
-
-<h3 id="known_issues">Known Issues</h3>
-
-<p>
-There are some instabilities on FreeBSD and NetBSD that are known but not understood.
-These can lead to program crashes in rare cases.
-See
-<a href="https://golang.org/issue/15658">issue 15658</a> and
-<a href="https://golang.org/issue/16511">issue 16511</a>.
-Any help in solving these issues would be appreciated.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="cmd_asm">Assembler</h3>
-
-<p>
-For 64-bit x86 systems, the following instructions have been added:
-<code>VBROADCASTSD</code>,
-<code>BROADCASTSS</code>,
-<code>MOVDDUP</code>,
-<code>MOVSHDUP</code>,
-<code>MOVSLDUP</code>,
-<code>VMOVDDUP</code>,
-<code>VMOVSHDUP</code>, and
-<code>VMOVSLDUP</code>.
-</p>
-
-<p>
-For 64-bit PPC systems, the common vector scalar instructions have been
-added:
-<code>LXS</code>,
-<code>LXSDX</code>,
-<code>LXSI</code>,
-<code>LXSIWAX</code>,
-<code>LXSIWZX</code>,
-<code>LXV</code>,
-<code>LXVD2X</code>,
-<code>LXVDSX</code>,
-<code>LXVW4X</code>,
-<code>MFVSR</code>,
-<code>MFVSRD</code>,
-<code>MFVSRWZ</code>,
-<code>MTVSR</code>,
-<code>MTVSRD</code>,
-<code>MTVSRWA</code>,
-<code>MTVSRWZ</code>,
-<code>STXS</code>,
-<code>STXSDX</code>,
-<code>STXSI</code>,
-<code>STXSIWX</code>,
-<code>STXV</code>,
-<code>STXVD2X</code>,
-<code>STXVW4X</code>,
-<code>XSCV</code>,
-<code>XSCVDPSP</code>,
-<code>XSCVDPSPN</code>,
-<code>XSCVDPSXDS</code>,
-<code>XSCVDPSXWS</code>,
-<code>XSCVDPUXDS</code>,
-<code>XSCVDPUXWS</code>,
-<code>XSCVSPDP</code>,
-<code>XSCVSPDPN</code>,
-<code>XSCVSXDDP</code>,
-<code>XSCVSXDSP</code>,
-<code>XSCVUXDDP</code>,
-<code>XSCVUXDSP</code>,
-<code>XSCVX</code>,
-<code>XSCVXP</code>,
-<code>XVCV</code>,
-<code>XVCVDPSP</code>,
-<code>XVCVDPSXDS</code>,
-<code>XVCVDPSXWS</code>,
-<code>XVCVDPUXDS</code>,
-<code>XVCVDPUXWS</code>,
-<code>XVCVSPDP</code>,
-<code>XVCVSPSXDS</code>,
-<code>XVCVSPSXWS</code>,
-<code>XVCVSPUXDS</code>,
-<code>XVCVSPUXWS</code>,
-<code>XVCVSXDDP</code>,
-<code>XVCVSXDSP</code>,
-<code>XVCVSXWDP</code>,
-<code>XVCVSXWSP</code>,
-<code>XVCVUXDDP</code>,
-<code>XVCVUXDSP</code>,
-<code>XVCVUXWDP</code>,
-<code>XVCVUXWSP</code>,
-<code>XVCVX</code>,
-<code>XVCVXP</code>,
-<code>XXLAND</code>,
-<code>XXLANDC</code>,
-<code>XXLANDQ</code>,
-<code>XXLEQV</code>,
-<code>XXLNAND</code>,
-<code>XXLNOR</code>,
-<code>XXLOR</code>,
-<code>XXLORC</code>,
-<code>XXLORQ</code>,
-<code>XXLXOR</code>,
-<code>XXMRG</code>,
-<code>XXMRGHW</code>,
-<code>XXMRGLW</code>,
-<code>XXPERM</code>,
-<code>XXPERMDI</code>,
-<code>XXSEL</code>,
-<code>XXSI</code>,
-<code>XXSLDWI</code>,
-<code>XXSPLT</code>, and
-<code>XXSPLTW</code>.
-</p>
-
-<h3 id="tool_yacc">Yacc</h3>
-
-<p> <!-- CL 27324, CL 27325 -->
-The <code>yacc</code> tool (previously available by running
-“<code>go</code> <code>tool</code> <code>yacc</code>”) has been removed.
-As of Go 1.7 it was no longer used by the Go compiler.
-It has moved to the “tools” repository and is now available at
-<code><a href="https://godoc.org/golang.org/x/tools/cmd/goyacc">golang.org/x/tools/cmd/goyacc</a></code>.
-</p>
-
-<h3 id="tool_fix">Fix</h3>
-
-<p> <!-- CL 28872 -->
-  The <code>fix</code> tool has a new “<code>context</code>”
-  fix to change imports from “<code>golang.org/x/net/context</code>”
-  to “<a href="/pkg/context/"><code>context</code></a>”.
-</p>
-
-<h3 id="tool_pprof">Pprof</h3>
-
-<p> <!-- CL 33157 -->
-  The <code>pprof</code> tool can now profile TLS servers
-  and skip certificate validation by using the “<code>https+insecure</code>”
-  URL scheme.
-</p>
-
-<p> <!-- CL 23781 -->
-  The callgrind output now has instruction-level granularity.
-</p>
-
-<h3 id="tool_trace">Trace</h3>
-
-<p> <!-- CL 23324 -->
-  The <code>trace</code> tool has a new <code>-pprof</code> flag for
-  producing pprof-compatible blocking and latency profiles from an
-  execution trace.
-</p>
-
-<p> <!-- CL 30017, CL 30702 -->
-  Garbage collection events are now shown more clearly in the
-  execution trace viewer. Garbage collection activity is shown on its
-  own row and GC helper goroutines are annotated with their roles.
-</p>
-
-<h3 id="tool_vet">Vet</h3>
-
-<p>Vet is stricter in some ways and looser where it
-  previously caused false positives.</p>
-
-<p>Vet now checks for copying an array of locks,
-  duplicate JSON and XML struct field tags,
-  non-space-separated struct tags,
-  deferred calls to HTTP <code>Response.Body.Close</code>
-  before checking errors, and
-  indexed arguments in <code>Printf</code>.
-  It also improves existing checks.</p>
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-Go 1.7 introduced a new compiler back end for 64-bit x86 systems.
-In Go 1.8, that back end has been developed further and is now used for
-all architectures.
-</p>
-
-<p>
-The new back end, based on
-<a href="https://en.wikipedia.org/wiki/Static_single_assignment_form">static single assignment form</a> (SSA),
-generates more compact, more efficient code
-and provides a better platform for optimizations
-such as bounds check elimination.
-The new back end reduces the CPU time required by
-<a href="https://golang.org/test/bench/go1/">our benchmark programs</a> by 20-30%
-on 32-bit ARM systems. For 64-bit x86 systems, which already used the SSA back end in
-Go 1.7, the gains are a more modest 0-10%. Other architectures will likely
-see improvements closer to the 32-bit ARM numbers.
-</p>
-
-<p>
-  The temporary <code>-ssa=0</code> compiler flag introduced in Go 1.7
-  to disable the new back end has been removed in Go 1.8.
-</p>
-
-<p>
-  In addition to enabling the new compiler back end for all systems,
-  Go 1.8 also introduces a new compiler front end. The new compiler
-  front end should not be noticeable to users but is the foundation for
-  future performance work.
-</p>
-
-<p>
-  The compiler and linker have been optimized and run faster in this
-  release than in Go 1.7, although they are still slower than we would
-  like and will continue to be optimized in future releases.
-  Compared to the previous release, Go 1.8 is
-  <a href="https://dave.cheney.net/2016/11/19/go-1-8-toolchain-improvements">about 15% faster</a>.
-</p>
-
-<h3 id="cmd_cgo">Cgo</h3>
-
-<p> <!-- CL 31141 -->
-The Go tool now remembers the value of the <code>CGO_ENABLED</code> environment
-variable set during <code>make.bash</code> and applies it to all future compilations
-by default to fix issue <a href="https://golang.org/issue/12808">#12808</a>.
-When doing native compilation, it is rarely necessary to explicitly set
-the <code>CGO_ENABLED</code> environment variable as <code>make.bash</code>
-will detect the correct setting automatically. The main reason to explicitly
-set the <code>CGO_ENABLED</code> environment variable is when your environment
-supports cgo, but you explicitly do not want cgo support, in which case, set
-<code>CGO_ENABLED=0</code> during <code>make.bash</code> or <code>all.bash</code>.
-</p>
-
-<p> <!-- CL 29991 -->
-The environment variable <code>PKG_CONFIG</code> may now be used to
-set the program to run to handle <code>#cgo</code> <code>pkg-config</code>
-directives.  The default is <code>pkg-config</code>, the program
-always used by earlier releases.  This is intended to make it easier
-to cross-compile
-<a href="/cmd/cgo/">cgo</a> code.
-</p>
-
-<p> <!-- CL 32354 -->
-The <a href="/cmd/cgo/">cgo</a> tool now supports a <code>-srcdir</code>
-option, which is used by the <a href="/cmd/go/">go</a> command.
-</p>
-
-<p> <!-- CL 31768, 31811 -->
-If <a href="/cmd/cgo/">cgo</a> code calls <code>C.malloc</code>, and
-<code>malloc</code> returns <code>NULL</code>, the program will now
-crash with an out of memory error.
-<code>C.malloc</code> will never return <code>nil</code>.
-Unlike most C functions, <code>C.malloc</code> may not be used in a
-two-result form returning an errno value.
-</p>
-
-<p> <!-- CL 33237 -->
-If <a href="/cmd/cgo/">cgo</a> is used to call a C function passing a
-pointer to a C union, and if the C union can contain any pointer
-values, and if <a href="/cmd/cgo/#hdr-Passing_pointers">cgo pointer
-checking</a> is enabled (as it is by default), the union value is now
-checked for Go pointers.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-Due to the alignment of Go's semiannual release schedule with GCC's
-annual release schedule,
-GCC release 6 contains the Go 1.6.1 version of gccgo.
-We expect that the next release, GCC 7, will contain the Go 1.8
-version of gccgo.
-</p>
-
-<h3 id="gopath">Default GOPATH</h3>
-
-<p>
-  The
-  <a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>GOPATH</code>
-  environment variable</a> now has a default value if it
-  is unset. It defaults to
-  <code>$HOME/go</code> on Unix and
-  <code>%USERPROFILE%/go</code> on Windows.
-</p>
-
-<h3 id="go_get">Go get</h3>
-
-<p> <!-- CL 34818 -->
-  The “<code>go</code> <code>get</code>” command now always respects
-  HTTP proxy environment variables, regardless of whether
-  the <code style='white-space:nowrap'>-insecure</code> flag is used. In previous releases, the
-  <code style='white-space:nowrap'>-insecure</code> flag had the side effect of not using proxies.
-</p>
-
-<h3 id="go_bug">Go bug</h3>
-
-<p>
-  The new
-  “<a href="/cmd/go/#hdr-Print_information_for_bug_reports"><code>go</code> <code>bug</code></a>”
-  command starts a bug report on GitHub, prefilled
-  with information about the current system.
-</p>
-
-<h3 id="cmd_doc">Go doc</h3>
-
-<p> <!-- CL 25419 -->
-  The
-  “<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go</code> <code>doc</code></a>”
-  command now groups constants and variables with their type,
-  following the behavior of
-  <a href="/cmd/godoc/"><code>godoc</code></a>.
-</p>
-
-<p> <!-- CL 25420 -->
-  In order to improve the readability of <code>doc</code>'s
-  output, each summary of the first-level items is guaranteed to
-  occupy a single line.
-</p>
-
-<p> <!-- CL 31852 -->
-  Documentation for a specific method in an interface definition can
-  now be requested, as in
-  “<code>go</code> <code>doc</code> <code>net.Conn.SetDeadline</code>”.
-</p>
-
-<h3 id="plugin">Plugins</h3>
-
-<p>
-  Go now provides early support for plugins with a “<code>plugin</code>”
-  build mode for generating plugins written in Go, and a
-  new <a href="/pkg/plugin/"><code>plugin</code></a> package for
-  loading such plugins at run time. Plugin support is currently only
-  available on Linux. Please report any issues.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<h3 id="liveness">Argument Liveness</h3>
-
-<p>
-  <!-- Issue 15843 --> The garbage collector no longer considers
-  arguments live throughout the entirety of a function. For more
-  information, and for how to force a variable to remain live, see
-  the <a href="/pkg/runtime/#KeepAlive"><code>runtime.KeepAlive</code></a>
-  function added in Go 1.7.
-</p>
-
-<p>
-  <i>Updating:</i>
-  Code that sets a finalizer on an allocated object may need to add
-  calls to <code>runtime.KeepAlive</code> in functions or methods
-  using that object.
-  Read the
-  <a href="/pkg/runtime/#KeepAlive"><code>KeepAlive</code>
-  documentation</a> and its example for more details.
-</p>
-
-<h3 id="mapiter">Concurrent Map Misuse</h3>
-
-<p>
-In Go 1.6, the runtime
-<a href="/doc/go1.6#runtime">added lightweight,
-best-effort detection of concurrent misuse of maps</a>. This release
-improves that detector with support for detecting programs that
-concurrently write to and iterate over a map.
-</p>
-<p>
-As always, if one goroutine is writing to a map, no other goroutine should be
-reading (which includes iterating) or writing the map concurrently.
-If the runtime detects this condition, it prints a diagnosis and crashes the program.
-The best way to find out more about the problem is to run the program
-under the
-<a href="https://blog.golang.org/race-detector">race detector</a>,
-which will more reliably identify the race
-and give more detail.
-</p>
-
-<h3 id="memstats">MemStats Documentation</h3>
-
-<p> <!-- CL 28972 -->
-  The <a href="/pkg/runtime/#MemStats"><code>runtime.MemStats</code></a>
-  type has been more thoroughly documented.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-Most programs should run a bit faster,
-due to speedups in the garbage collector and
-optimizations in the standard library.
-</p>
-
-<p>
-There have been optimizations to implementations in the
-<a href="/pkg/bytes/"><code>bytes</code></a>,
-<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
-<a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a>,
-<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
-<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a>,
-<a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a>,
-<a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a>,
-<a href="/pkg/encoding/csv/"><code>encoding/csv</code></a>,
-<a href="/pkg/encoding/hex/"><code>encoding/hex</code></a>,
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a>,
-<a href="/pkg/hash/crc32/"><code>hash/crc32</code></a>,
-<a href="/pkg/image/color/"><code>image/color</code></a>,
-<a href="/pkg/image/draw/"><code>image/draw</code></a>,
-<a href="/pkg/math/"><code>math</code></a>,
-<a href="/pkg/math/big/"><code>math/big</code></a>,
-<a href="/pkg/reflect/"><code>reflect</code></a>,
-<a href="/pkg/regexp/"><code>regexp</code></a>,
-<a href="/pkg/runtime/"><code>runtime</code></a>,
-<a href="/pkg/strconv/"><code>strconv</code></a>,
-<a href="/pkg/strings/"><code>strings</code></a>,
-<a href="/pkg/syscall/"><code>syscall</code></a>,
-<a href="/pkg/text/template/"><code>text/template</code></a>, and
-<a href="/pkg/unicode/utf8/"><code>unicode/utf8</code></a>
-packages.
-</p>
-
-<h3 id="gc">Garbage Collector</h3>
-
-<p>
-  Garbage collection pauses should be significantly shorter than they
-  were in Go 1.7, usually under 100 microseconds and often as low as
-  10 microseconds.
-  See the
-  <a href="https://github.com/golang/proposal/blob/master/design/17503-eliminate-rescan.md"
-     >document on eliminating stop-the-world stack re-scanning</a>
-  for details.  More work remains for Go 1.9.
-</p>
-
-<h3 id="defer">Defer</h3>
-
-<!-- CL 29656, CL 29656 -->
-<p>
-  The overhead of <a href="/ref/spec/#Defer_statements">deferred
-  function calls</a> has been reduced by about half.
-</p>
-
-<h3 id="cgoperf">Cgo</h3>
-
-<p>The overhead of calls from Go into C has been reduced by about half.</p>
-
-<h2 id="library">Standard library</h2>
-
-<h3 id="examples">Examples</h3>
-
-<p>
-Examples have been added to the documentation across many packages.
-</p>
-
-<h3 id="sort_slice">Sort</h3>
-
-<p>
-The <a href="/pkg/sort/">sort</a> package
-now includes a convenience function
-<a href="/pkg/sort/#Slice"><code>Slice</code></a> to sort a
-slice given a <em>less</em> function.
-
-In many cases this means that writing a new sorter type is not
-necessary.
-</p>
-
-<p>
-Also new are
-<a href="/pkg/sort/#SliceStable"><code>SliceStable</code></a> and
-<a href="/pkg/sort/#SliceIsSorted"><code>SliceIsSorted</code></a>.
-</p>
-
-<h3 id="h2push">HTTP/2 Push</h3>
-
-<p>
-The <a href="/pkg/net/http/">net/http</a> package now includes a
-mechanism to
-send HTTP/2 server pushes from a
-<a href="/pkg/net/http/#Handler"><code>Handler</code></a>.
-Similar to the existing <code>Flusher</code> and <code>Hijacker</code>
-interfaces, an HTTP/2
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
-now implements the new
-<a href="/pkg/net/http/#Pusher"><code>Pusher</code></a> interface.
-</p>
-
-<h3 id="http_shutdown">HTTP Server Graceful Shutdown</h3>
-
-<p> <!-- CL 32329 -->
-  The HTTP Server now has support for graceful shutdown using the new
-  <a href="/pkg/net/http/#Server.Shutdown"><code>Server.Shutdown</code></a>
-  method and abrupt shutdown using the new
-  <a href="/pkg/net/http/#Server.Close"><code>Server.Close</code></a>
-  method.
-</p>
-
-<h3 id="more_context">More Context Support</h3>
-
-<p>
-  Continuing <a href="/doc/go1.7#context">Go 1.7's adoption</a>
-  of <a href="/pkg/context/#Context"><code>context.Context</code></a>
-  into the standard library, Go 1.8 adds more context support
-  to existing packages:
-</p>
-
-<ul>
-  <li>The new <a href="/pkg/net/http/#Server.Shutdown"><code>Server.Shutdown</code></a>
-    takes a context argument.</li>
-  <li>There have been <a href="#database_sql">significant additions</a> to the
-    <a href="/pkg/database/sql/">database/sql</a> package with context support.</li>
-  <li>All nine of the new <code>Lookup</code> methods on the new
-    <a href="/pkg/net/#Resolver"><code>net.Resolver</code></a> now
-    take a context.</li>
-  </ul>
-
-<h3 id="mutex_prof">Mutex Contention Profiling</h3>
-
-<p>
-  The runtime and tools now support profiling contended mutexes.
-</p>
-
-<p>
-  Most users will want to use the new <code>-mutexprofile</code>
-  flag with “<a href="/cmd/go/#hdr-Description_of_testing_flags"><code>go</code> <code>test</code></a>”,
-  and then use <a href="/cmd/pprof/">pprof</a> on the resultant file.
-</p>
-
-<p>
-  Lower-level support is also available via the new
-  <a href="/pkg/runtime/#MutexProfile"><code>MutexProfile</code></a>
-  and
-  <a href="/pkg/runtime/#SetMutexProfileFraction"><code>SetMutexProfileFraction</code></a>.
-</p>
-
-<p>
-  A known limitation for Go 1.8 is that the profile only reports contention for
-  <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a>,
-  not 
-  <a href="/pkg/sync/#RWMutex"><code>sync.RWMutex</code></a>.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-As always, there are various minor changes and updates to the library,
-made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-in mind. The following sections list the user visible changes and additions.
-Optimizations and minor bug fixes are not listed.
-</p>
-
-<dl id="archive_tar"><dt><a href="/pkg/archive/tar/">archive/tar</a></dt>
-  <dd>
-
-    <p> <!-- CL 28471, CL 31440, CL 31441, CL 31444, CL 28418, CL 31439 -->
-      The tar implementation corrects many bugs in corner cases of the file format.
-      The <a href="/pkg/archive/tar/#Reader"><code>Reader</code></a>
-      is now able to process tar files in the PAX format with entries larger than 8GB.
-      The <a href="/pkg/archive/tar/#Writer"><code>Writer</code></a>
-      no longer produces invalid tar files in some situations involving long pathnames.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="compress_flate"><dt><a href="/pkg/compress/flate/">compress/flate</a></dt>
-  <dd>
-
-    <p> <!-- CL 31640, CL 31174, CL 32149 -->
-      There have been some minor fixes to the encoder to improve the
-      compression ratio in certain situations. As a result, the exact
-      encoded output of <code>DEFLATE</code> may be different from Go 1.7. Since
-      <code>DEFLATE</code> is the underlying compression of gzip, png, zlib, and zip,
-      those formats may have changed outputs.
-    </p>
-
-    <p> <!-- CL 31174 -->
-      The encoder, when operating in
-      <a href="/pkg/compress/flate/#NoCompression"><code>NoCompression</code></a>
-      mode, now produces a consistent output that is not dependent on
-      the size of the slices passed to the
-      <a href="/pkg/compress/flate/#Writer.Write"><code>Write</code></a>
-      method.
-    </p>
-
-    <p> <!-- CL 28216 -->
-      The decoder, upon encountering an error, now returns any
-      buffered data it had uncompressed along with the error.
-    </p>
-
-  </dd>
-</dl>
-
-
-<dl id="compress_gzip"><dt><a href="/pkg/compress/gzip/">compress/gzip</a></dt>
-  <dd>
-
-    <p>
-      The <a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a>
-      now encodes a zero <code>MTIME</code> field when
-      the <a href="/pkg/compress/gzip/#Header"><code>Header.ModTime</code></a>
-      field is the zero value.
-
-      In previous releases of Go, the <code>Writer</code> would encode
-      a nonsensical value.
-
-      Similarly,
-      the <a href="/pkg/compress/gzip/#Reader"><code>Reader</code></a>
-      now reports a zero encoded <code>MTIME</code> field as a zero
-      <code>Header.ModTime</code>.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
-  <dd>
-    <p> <!-- CL 30370 -->
-      The <a href="/pkg/context#DeadlineExceeded"><code>DeadlineExceeded</code></a>
-      error now implements
-      <a href="/pkg/net/#Error"><code>net.Error</code></a>
-      and reports true for both the <code>Timeout</code> and
-      <code>Temporary</code> methods.
-    </p>
-  </dd>
-</dl>
-
-<dl id="crypto_tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p> <!-- CL 25159, CL 31318 -->
-      The new method
-      <a href="/pkg/crypto/tls/#Conn.CloseWrite"><code>Conn.CloseWrite</code></a>
-      allows TLS connections to be half closed.
-    </p>
-
-    <p> <!-- CL 28075 -->
-      The new method
-      <a href="/pkg/crypto/tls/#Config.Clone"><code>Config.Clone</code></a>
-      clones a TLS configuration.
-    </p>
-
-    <p>
-      <!-- CL 30790 -->
-      The new <a href="/pkg/crypto/tls/#Config.GetConfigForClient"><code>Config.GetConfigForClient</code></a>
-      callback allows selecting a configuration for a client dynamically, based
-      on the client's
-      <a href="/pkg/crypto/tls/#ClientHelloInfo"><code>ClientHelloInfo</code></a>.
-
-      <!-- CL 31391, CL 32119 -->
-      The <a href="/pkg/crypto/tls/#ClientHelloInfo"><code>ClientHelloInfo</code></a>
-      struct now has new
-      fields <code>Conn</code>, <code>SignatureSchemes</code> (using
-      the new
-      type <a href="/kg/crypto/tls/#SignatureScheme"><code>SignatureScheme</code></a>),
-      <code>SupportedProtos</code>, and <code>SupportedVersions</code>.
-    </p>
-
-    <p> <!-- CL 32115 -->
-      The new <a href="/pkg/crypto/tls/#Config.GetClientCertificate"><code>Config.GetClientCertificate</code></a>
-      callback allows selecting a client certificate based on the server's
-      TLS <code>CertificateRequest</code> message, represented by the new
-      <a href="/pkg/crypto/tls/#CertificateRequestInfo"><code>CertificateRequestInfo</code></a>.
-    </p>
-
-    <p> <!-- CL 27434 -->
-      The new
-      <a href="/pkg/crypto/tls/#Config.KeyLogWriter"><code>Config.KeyLogWriter</code></a>
-      allows debugging TLS connections
-      in <a href="https://www.wireshark.org/">WireShark</a> and
-      similar tools.
-    </p>
-
-    <p> <!-- CL 32115 -->
-      The new
-      <a href="/pkg/crypto/tls/#Config.VerifyPeerCertificate"><code>Config.VerifyPeerCertificate</code></a>
-      callback allows additional validation of a peer's presented certificate.
-    </p>
-
-    <p> <!-- CL 18130 -->
-      The <code>crypto/tls</code> package now implements basic
-      countermeasures against CBC padding oracles. There should be
-      no explicit secret-dependent timings, but it does not attempt to
-      normalize memory accesses to prevent cache timing leaks.
-    </p>
-
-    <p>
-      The <code>crypto/tls</code> package now supports
-      X25519 and <!-- CL 30824, CL 30825 -->
-      ChaCha20-Poly1305.  <!-- CL 30957, CL 30958 -->
-      ChaCha20-Poly1305 is now prioritized unless <!-- CL 32871 -->
-      hardware support for AES-GCM is present.
-    </p>
-
-    <p> <!-- CL 27315, CL 35290 -->
-      AES-128-CBC cipher suites with SHA-256 are also
-      now supported, but disabled by default.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="crypto_x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p> <!-- CL 24743 -->
-      PSS signatures are now supported.
-    </p>
-
-    <p> <!-- CL 32644 -->
-      <a href="/pkg/crypto/x509/#UnknownAuthorityError"><code>UnknownAuthorityError</code></a>
-      now has a <code>Cert</code> field, reporting the untrusted
-      certificate.
-    </p>
-
-    <p>
-      Certificate validation is more permissive in a few cases and
-      stricter in a few other cases.
-    <!--
-crypto/x509: allow a leaf certificate to be specified directly as root (CL 27393)
-crypto/x509: check that the issuer name matches the issuer's subject name (CL 23571)
-crypto/x509: don't accept a root that already appears in a chain. (CL 32121)
-crypto/x509: fix name constraints handling (CL 30155)
-crypto/x509: parse all names in an RDN (CL 30810)
-crypto/x509: recognise ISO OID for RSA+SHA1 (CL 27394)
-crypto/x509: require a NULL parameters for RSA public keys (CL 16166, CL 27312)
-crypto/x509: return error for missing SerialNumber (CL 27238)
--->
-    </p>
-
-    <p><!-- CL 30375 -->
-      Root certificates will now also be looked for
-      at <code>/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem</code>
-      on Linux, to support RHEL and CentOS.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="database_sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p>
-      The package now supports <code>context.Context</code>. There are new methods
-      ending in <code>Context</code> such as
-      <a href="/pkg/database/sql/#DB.QueryContext"><code>DB.QueryContext</code></a> and
-      <a href="/pkg/database/sql/#DB.PrepareContext"><code>DB.PrepareContext</code></a>
-      that take context arguments. Using the new <code>Context</code> methods ensures that
-      connections are closed and returned to the connection pool when the
-      request is done; enables canceling in-progress queries
-      should the driver support that; and allows the database
-      pool to cancel waiting for the next available connection.
-    </p>
-    <p>
-      The <a href="/pkg/database/sql#IsolationLevel"><code>IsolationLevel</code></a>
-      can now be set when starting a transaction by setting the isolation level
-      on <a href="/pkg/database/sql#TxOptions.Isolation"><code>TxOptions.Isolation</code></a> and passing
-      it to <a href="/pkg/database/sql#DB.BeginTx"><code>DB.BeginTx</code></a>.
-      An error will be returned if an isolation level is selected that the driver
-      does not support. A read-only attribute may also be set on the transaction
-      by setting <a href="/pkg/database/sql/#TxOptions.ReadOnly"><code>TxOptions.ReadOnly</code></a>
-      to true.
-    </p>
-    <p>
-      Queries now expose the SQL column type information for drivers that support it.
-      Rows can return <a href="/pkg/database/sql#Rows.ColumnTypes"><code>ColumnTypes</code></a>
-      which can include SQL type information, column type lengths, and the Go type.
-    </p>
-    <p>
-      A <a href="/pkg/database/sql/#Rows"><code>Rows</code></a>
-      can now represent multiple result sets. After
-      <a href="/pkg/database/sql/#Rows.Next"><code>Rows.Next</code></a> returns false,
-      <a href="/pkg/database/sql/#Rows.NextResultSet"><code>Rows.NextResultSet</code></a>
-      may be called to advance to the next result set. The existing <code>Rows</code>
-      should continue to be used after it advances to the next result set.
-      </p>
-    <p>
-      <a href="/pkg/database/sql/#NamedArg"><code>NamedArg</code></a> may be used
-      as query arguments. The new function <a href="/pkg/database/sql/#Named"><code>Named</code></a>
-      helps create a <a href="/pkg/database/sql/#NamedArg"><code>NamedArg</code></a>
-      more succinctly.
-    <p>
-      If a driver supports the new
-      <a href="/pkg/database/sql/driver/#Pinger"><code>Pinger</code></a>
-      interface, the
-      <a href="/pkg/database/sql/#DB.Ping"><code>DB.Ping</code></a>
-      and
-      <a href="/pkg/database/sql/#DB.PingContext"><code>DB.PingContext</code></a>
-      methods will use that interface to check whether a
-      database connection is still valid.
-    </p>
-    <p>
-      The new <code>Context</code> query methods work for all drivers, but
-      <code>Context</code> cancelation is not responsive unless the driver has been
-      updated to use them. The other features require driver support in
-      <a href="/pkg/database/sql/driver"><code>database/sql/driver</code></a>.
-      Driver authors should review the new interfaces. Users of existing
-      driver should review the driver documentation to see what
-      it supports and any system specific documentation on each feature.
-    </p>
-  </dd>
-</dl>
-
-<dl id="debug_pe"><dt><a href="/pkg/debug/pe/">debug/pe</a></dt>
-  <dd>
-    <p> <!-- CL 22720, CL 27212, CL 22181, CL 22332, CL 22336, Issue 15345 -->
-      The package has been extended and is now used by
-      <a href="/cmd/link/">the Go linker</a> to read <code>gcc</code>-generated object files.
-      The new
-      <a href="/pkg/debug/pe/#File.StringTable"><code>File.StringTable</code></a>
-      and
-      <a href="/pkg/debug/pe/#Section.Relocs"><code>Section.Relocs</code></a>
-      fields provide access to the COFF string table and COFF relocations.
-      The new
-      <a href="/pkg/debug/pe/#File.COFFSymbols"><code>File.COFFSymbols</code></a>
-      allows low-level access to the COFF symbol table.
-      </p>
-  </dd>
-</dl>
-
-<dl id="encoding_base64"><dt><a href="/pkg/encoding/base64/">encoding/base64</a></dt>
-  <dd>
-    <p> <!-- CL 24964 -->
-      The new
-      <a href="/pkg/encoding/base64/#Encoding.Strict"><code>Encoding.Strict</code></a>
-      method returns an <code>Encoding</code> that causes the decoder
-      to return an error when the trailing padding bits are not zero.
-    </p>
-  </dd>
-</dl>
-
-<dl id="encoding_binary"><dt><a href="/pkg/encoding/binary/">encoding/binary</a></dt>
-  <dd>
-    <p> <!-- CL 28514 -->
-      <a href="/pkg/encoding/binary/#Read"><code>Read</code></a>
-      and
-      <a href="/pkg/encoding/binary/#Write"><code>Write</code></a>
-      now support booleans.
-    </p>
-  </dd>
-</dl>
-
-<dl id="encoding_json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-  <dd>
-
-    <p> <!-- CL 18692  -->
-      <a href="/pkg/encoding/json/#UnmarshalTypeError"><code>UnmarshalTypeError</code></a>
-      now includes the struct and field name.
-    </p>
-
-    <p> <!-- CL 31932 -->
-      A nil <a href="/pkg/encoding/json/#Marshaler"><code>Marshaler</code></a>
-      now marshals as a JSON <code>null</code> value.
-    </p>
-
-    <p> <!-- CL 21811 -->
-      A <a href="/pkg/encoding/json/#RawMessage"><code>RawMessage</code></a> value now
-      marshals the same as its pointer type.
-    </p>
-
-    <p> <!-- CL 30371 -->
-      <a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
-      encodes floating-point numbers using the same format as in ES6,
-      preferring decimal (not exponential) notation for a wider range of values.
-      In particular, all floating-point integers up to 2<sup>64</sup> format the
-      same as the equivalent <code>int64</code> representation.
-    </p>
-
-    <p> <!-- CL 30944 -->
-      In previous versions of Go, unmarshaling a JSON <code>null</code> into an
-      <a href="/pkg/encoding/json/#Unmarshaler"><code>Unmarshaler</code></a>
-      was considered a no-op; now the <code>Unmarshaler</code>'s
-      <code>UnmarshalJSON</code> method is called with the JSON literal
-      <code>null</code> and can define the semantics of that case.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="encoding_pem"><dt><a href="/pkg/encoding/pem/">encoding/pem</a></dt>
-  <dd>
-    <p> <!-- CL 27391 -->
-      <a href="/pkg/encoding/pem/#Decode"><code>Decode</code></a>
-      is now strict about the format of the ending line.
-    </p>
-  </dd>
-</dl>
-
-<dl id="encoding_xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
-  <dd>
-    <p> <!-- CL 30946 -->
-      <a href="/pkg/encoding/xml/#Unmarshal"><code>Unmarshal</code></a>
-      now has wildcard support for collecting all attributes using
-      the new <code>",any,attr"</code> struct tag.
-    </p>
-  </dd>
-</dl>
-
-<dl id="expvar"><dt><a href="/pkg/expvar/">expvar</a></dt>
-  <dd>
-    <p> <!-- CL 30917 -->
-      The new methods
-      <a href="/pkg/expvar/#Int.Value"><code>Int.Value</code></a>,
-      <a href="/pkg/expvar/#String.Value"><code>String.Value</code></a>,
-      <a href="/pkg/expvar/#Float.Value"><code>Float.Value</code></a>, and
-      <a href="/pkg/expvar/#Func.Value"><code>Func.Value</code></a>
-      report the current value of an exported variable.
-    </p>
-
-    <p> <!-- CL 24722 -->
-      The new
-      function <a href="/pkg/expvar/#Handler"><code>Handler</code></a>
-      returns the package's HTTP handler, to enable installing it in
-      non-standard locations.
-      </p>
-  </dd>
-</dl>
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 30611 -->
-      <a href="/pkg/fmt/#Scanf"><code>Scanf</code></a>,
-      <a href="/pkg/fmt/#Fscanf"><code>Fscanf</code></a>, and
-      <a href="/pkg/fmt/#Sscanf"><code>Sscanf</code></a> now
-      handle spaces differently and more consistently than
-      previous releases. See the
-      <a href="/pkg/fmt/#hdr-Scanning">scanning documentation</a>
-      for details.
-    </p>
-  </dd>
-</dl>
-
-<dl id="go_doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-  <dd>
-    <p><!-- CL 29870 -->
-      The new <a href="/pkg/go/doc/#IsPredeclared"><code>IsPredeclared</code></a>
-      function reports whether a string is a predeclared identifier.
-    </p>
-  </dd>
-</dl>
-
-<dl id="go_types"><dt><a href="/pkg/go/types/">go/types</a></dt>
-  <dd>
-    <p><!-- CL 30715 -->
-      The new function
-      <a href="/pkg/go/types/#Default"><code>Default</code></a>
-      returns the default "typed" type for an "untyped" type.
-    </p>
-
-    <p><!-- CL 31939 -->
-      The alignment of <code>complex64</code> now matches
-      the <a href="/cmd/compile/">Go compiler</a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="html_template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 14336 -->
-      The package now validates
-      the <code>"type"</code> attribute on
-      a <code>&lt;script&gt;</code> tag.
-    </p>
-  </dd>
-</dl>
-
-<dl id="image_png"><dt><a href="/pkg/image/png/">image/png</a></dt>
-  <dd>
-    <p> <!-- CL 32143, CL 32140 -->
-      <a href="/pkg/image/png/#Decode"><code>Decode</code></a>
-      (and <code>DecodeConfig</code>)
-      now supports True Color and grayscale transparency.
-    </p>
-    <p> <!-- CL 29872 -->
-      <a href="/pkg/image/png/#Encoder"><code>Encoder</code></a>
-      is now faster and creates smaller output
-      when encoding paletted images.
-      </p>
-  </dd>
-</dl>
-
-<dl id="math_big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 30706 -->
-      The new method
-      <a href="/pkg/math/big/#Int.Sqrt"><code>Int.Sqrt</code></a>
-      calculates ⌊√x⌋.
-    </p>
-
-    <p>
-      The new method
-      <a href="/pkg/math/big/#Float.Scan"><code>Float.Scan</code></a>
-      is a support routine for
-      <a href="/pkg/fmt/#Scanner"><code>fmt.Scanner</code></a>.
-    </p>
-
-    <p>
-      <a href="/pkg/math/big/#Int.ModInverse"><code>Int.ModInverse</code></a>
-      now supports negative numbers.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="math_rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
-  <dd>
-
-    <p><!-- CL 27253, CL 33456 -->
-      The new <a href="/pkg/math/rand/#Rand.Uint64"><code>Rand.Uint64</code></a>
-      method returns <code>uint64</code> values. The
-      new <a href="/pkg/math/rand/#Source64"><code>Source64</code></a>
-      interface describes sources capable of generating such values
-      directly; otherwise the <code>Rand.Uint64</code> method
-      constructs a <code>uint64</code> from two calls
-      to <a href="/pkg/math/rand/#Source"><code>Source</code></a>'s
-      <code>Int63</code> method.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
-  <dd>
-    <p> <!-- CL 32175 -->
-    <a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a>
-    now preserves unnecessary backslash escapes as literals,
-    in order to support MSIE.
-    When MSIE sends a full file path (in “intranet mode”), it does not
-    escape backslashes: “<code>C:\dev\go\foo.txt</code>”, not
-    “<code>C:\\dev\\go\\foo.txt</code>”.
-    If we see an unnecessary backslash escape, we now assume it is from MSIE
-    and intended as a literal backslash.
-    No known MIME generators emit unnecessary backslash escapes
-    for simple token characters like numbers and letters.
-    </p>
-  </dd>
-</dl>
-
-<dl id="mime_quotedprintable"><dt><a href="/pkg/mime/quotedprintable/">mime/quotedprintable</a></dt>
-  <dd>
-
-    <p>
-      The
-      <a href="/pkg/mime/quotedprintable/#Reader"><code>Reader</code></a>'s
-      parsing has been relaxed in two ways to accept
-      more input seen in the wild.
-
-      <!-- CL 32174 -->
-      First, it accepts an equals sign (<code>=</code>) not followed
-      by two hex digits as a literal equal sign.
-
-      <!-- CL 27530 -->
-      Second, it silently ignores a trailing equals sign at the end of
-      an encoded input.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-
-    <p><!-- CL 30164, CL 33473 -->
-      The <a href="/pkg/net/#Conn"><code>Conn</code></a> documentation
-      has been updated to clarify expectations of an interface
-      implementation. Updates in the <code>net/http</code> packages
-      depend on implementations obeying the documentation.
-    </p>
-    <p><i>Updating:</i> implementations of the <code>Conn</code> interface should verify
-      they implement the documented semantics. The
-      <a href="https://godoc.org/golang.org/x/net/nettest">golang.org/x/net/nettest</a>
-      package will exercise a <code>Conn</code> and validate it behaves properly.
-    </p>
-
-    <p><!-- CL 32099 -->
-      The new method
-      <a href="/pkg/net/#UnixListener.SetUnlinkOnClose"><code>UnixListener.SetUnlinkOnClose</code></a>
-      sets whether the underlying socket file should be removed from the file system when
-      the listener is closed.
-    </p>
-
-    <p><!-- CL 29951 -->
-      The new <a href="/pkg/net/#Buffers"><code>Buffers</code></a> type permits
-      writing to the network more efficiently from multiple discontiguous buffers
-      in memory. On certain machines, for certain types of connections,
-      this is optimized into an OS-specific batch write operation (such as <code>writev</code>).
-    </p>
-
-    <p><!-- CL 29440 -->
-      The new <a href="/pkg/net/#Resolver"><code>Resolver</code></a> looks up names and numbers
-      and supports <a href="/pkg/context/#Context"><code>context.Context</code></a>.
-      The <a href="/pkg/net/#Dialer"><code>Dialer</code></a> now has an optional
-      <a href="/pkg/net/#Dialer.Resolver"><code>Resolver</code> field</a>.
-    </p>
-
-    <p><!-- CL 29892 -->
-      <a href="/pkg/net/#Interfaces"><code>Interfaces</code></a> is now supported on Solaris.
-    </p>
-
-    <p><!-- CL 29233, CL 24901 -->
-      The Go DNS resolver now supports <code>resolv.conf</code>'s “<code>rotate</code>”
-      and “<code>option</code> <code>ndots:0</code>” options. The “<code>ndots</code>” option is
-      now respected in the same way as <code>libresolve</code>.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="net_http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-
-    <p>Server changes:</p>
-    <ul>
-      <li>The server now supports graceful shutdown support, <a href="#http_shutdown">mentioned above</a>.</li>
-
-      <li> <!-- CL 32024 -->
-        The <a href="/pkg/net/http/#Server"><code>Server</code></a>
-        adds configuration options
-        <code>ReadHeaderTimeout</code> and <code>IdleTimeout</code>
-        and documents <code>WriteTimeout</code>.
-      </li>
-
-      <li> <!-- CL 32014 -->
-        <a href="/pkg/net/http/#FileServer"><code>FileServer</code></a>
-        and
-        <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>
-        now support HTTP <code>If-Match</code> conditional requests,
-        in addition to the previous <code>If-None-Match</code>
-        support for ETags properly formatted according to RFC 7232, section 2.3.
-      </li>
-    </ul>
-
-    <p>
-      There are several additions to what a server's <code>Handler</code> can do:
-    </p>
-
-    <ul>
-      <li><!-- CL 31173 -->
-        The <a href="/pkg/context/#Context"><code>Context</code></a>
-        returned
-        by <a href="/pkg/net/http/#Request.Context"><code>Request.Context</code></a>
-        is canceled if the underlying <code>net.Conn</code>
-        closes. For instance, if the user closes their browser in the
-        middle of a slow request, the <code>Handler</code> can now
-        detect that the user is gone. This complements the
-        existing <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-        support. This functionality requires that the underlying
-        <a href="/pkg/net/#Conn"><code>net.Conn</code></a> implements
-        <a href="#net">recently clarified interface documentation</a>.
-      </li>
-
-      <li><!-- CL 32479 -->
-        To serve trailers produced after the header has already been written,
-        see the new
-        <a href="/pkg/net/http/#TrailerPrefix"><code>TrailerPrefix</code></a>
-        mechanism.
-      </li>
-
-      <li><!-- CL 33099 -->
-        A <code>Handler</code> can now abort a response by panicking
-        with the error
-        <a href="/pkg/net/http/#ErrAbortHandler"><code>ErrAbortHandler</code></a>.
-      </li>
-
-      <li><!-- CL 30812 -->
-        A <code>Write</code> of zero bytes to a
-        <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
-        is now defined as a
-        way to test whether a <code>ResponseWriter</code> has been hijacked:
-        if so, the <code>Write</code> returns
-        <a href="/pkg/net/http/#ErrHijacked"><code>ErrHijacked</code></a>
-        without printing an error
-        to the server's error log.
-      </li>
-
-    </ul>
-
-    <p>Client &amp; Transport changes:</p>
-    <ul>
-      <li><!-- CL 28930, CL 31435 -->
-        The <a href="/pkg/net/http/#Client"><code>Client</code></a>
-        now copies most request headers on redirect. See
-        <a href="/pkg/net/http/#Client">the documentation</a>
-        on the <code>Client</code> type for details.
-      </li>
-
-      <li><!-- CL 29072 -->
-        The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-        now supports international domain names. Consequently, so do
-        <a href="/pkg/net/http/#Get">Get</a> and other helpers.
-      </li>
-
-      <li><!-- CL 31733, CL 29852 -->
-        The <code>Client</code> now supports 301, 307, and 308 redirects.
-
-        For example, <code>Client.Post</code> now follows 301
-        redirects, converting them to <code>GET</code> requests
-        without bodies, like it did for 302 and 303 redirect responses
-        previously.
-
-        The <code>Client</code> now also follows 307 and 308
-        redirects, preserving the original request method and body, if
-        any. If the redirect requires resending the request body, the
-        request must have the new
-        <a href="/pkg/net/http/#Request"><code>Request.GetBody</code></a>
-        field defined.
-        <a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a>
-        sets <code>Request.GetBody</code> automatically for common
-        body types.
-      </li>
-
-      <li><!-- CL 32482 -->
-        The <code>Transport</code> now rejects requests for URLs with
-        ports containing non-digit characters.
-      </li>
-
-      <li><!-- CL 27117 -->
-        The <code>Transport</code> will now retry non-idempotent
-        requests if no bytes were written before a network failure
-        and the request has no body.
-      </li>
-
-      <li><!-- CL 32481 -->
-        The
-        new <a href="/pkg/net/http/#Transport"><code>Transport.ProxyConnectHeader</code></a>
-        allows configuration of header values to send to a proxy
-        during a <code>CONNECT</code> request.
-      </li>
-
-      <li> <!-- CL 28077 -->
-        The <a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport.Dialer</code></a>
-        now enables <code>DualStack</code> ("<a href="https://tools.ietf.org/html/rfc6555">Happy Eyeballs</a>") support,
-        allowing the use of IPv4 as a backup if it looks like IPv6 might be
-        failing.
-      </li>
-
-      <li> <!-- CL 31726 -->
-        The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-        no longer reads a byte of a non-nil
-        <a href="/pkg/net/http/#Request.Body"><code>Request.Body</code></a>
-        when the
-        <a href="/pkg/net/http/#Request.ContentLength"><code>Request.ContentLength</code></a>
-        is zero to determine whether the <code>ContentLength</code>
-        is actually zero or just undefined.
-        To explicitly signal that a body has zero length,
-        either set it to <code>nil</code>, or set it to the new value
-        <a href="/pkg/net/http/#NoBody"><code>NoBody</code></a>.
-        The new <code>NoBody</code> value is intended for use by <code>Request</code>
-        constructor functions; it is used by
-        <a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a>.
-      </li>
-    </ul>
-
-  </dd>
-</dl>
-
-<dl id="net_http_httptrace"><dt><a href="/pkg/net/http/httptrace/">net/http/httptrace</a></dt>
-  <dd>
-    <p> <!-- CL 30359 -->
-    There is now support for tracing a client request's TLS handshakes with
-    the new
-    <a href="/pkg/net/http/httptrace/#ClientTrace.TLSHandshakeStart"><code>ClientTrace.TLSHandshakeStart</code></a>
-    and
-    <a href="/pkg/net/http/httptrace/#ClientTrace.TLSHandshakeDone"><code>ClientTrace.TLSHandshakeDone</code></a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="net_http_httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p> <!-- CL 32356 -->
-    The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-    has a new optional hook,
-    <a href="/pkg/net/http/httputil/#ReverseProxy.ModifyResponse"><code>ModifyResponse</code></a>,
-    for modifying the response from the back end before proxying it to the client.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="net_mail"><dt><a href="/pkg/net/mail/">net/mail</a></dt>
-  <dd>
-
-    <p> <!-- CL 32176 -->
-      Empty quoted strings are once again allowed in the name part of
-      an address. That is, Go 1.4 and earlier accepted
-      <code>""</code> <code>&lt;gopher@example.com&gt;</code>,
-      but Go 1.5 introduced a bug that rejected this address.
-      The address is recognized again.
-    </p>
-
-    <p> <!-- CL 31581 -->
-      The
-      <a href="/pkg/net/mail/#Header.Date"><code>Header.Date</code></a>
-      method has always provided a way to parse
-      the <code>Date:</code> header.
-      A new function
-      <a href="/pkg/net/mail/#ParseDate"><code>ParseDate</code></a>
-      allows parsing dates found in other
-      header lines, such as the <code>Resent-Date:</code> header.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="net_smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
-  <dd>
-
-    <p> <!-- CL 33143 -->
-      If an implementation of the
-      <a href="/pkg/net/smtp/#Auth"><code>Auth.Start</code></a>
-      method returns an empty <code>toServer</code> value,
-      the package no longer sends
-      trailing whitespace in the SMTP <code>AUTH</code> command,
-      which some servers rejected.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="net_url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-
-    <p> <!-- CL 31322 -->
-      The new functions
-      <a href="/pkg/net/url/#PathEscape"><code>PathEscape</code></a>
-      and
-      <a href="/pkg/net/url/#PathUnescape"><code>PathUnescape</code></a>
-      are similar to the query escaping and unescaping functions but
-      for path elements.
-    </p>
-
-    <p> <!-- CL 28933 -->
-      The new methods
-      <a href="/pkg/net/url/#URL.Hostname"><code>URL.Hostname</code></a>
-      and
-      <a href="/pkg/net/url/#URL.Port"><code>URL.Port</code></a>
-      return the hostname and port fields of a URL,
-      correctly handling the case where the port may not be present.
-    </p>
-
-    <p> <!-- CL 28343 -->
-      The existing method
-      <a href="/pkg/net/url/#URL.ResolveReference"><code>URL.ResolveReference</code></a>
-      now properly handles paths with escaped bytes without losing
-      the escaping.
-    </p>
-
-    <p> <!-- CL 31467 -->
-      The <code>URL</code> type now implements
-      <a href="/pkg/encoding/#BinaryMarshaler"><code>encoding.BinaryMarshaler</code></a> and
-      <a href="/pkg/encoding/#BinaryUnmarshaler"><code>encoding.BinaryUnmarshaler</code></a>,
-      making it possible to process URLs in <a href="/pkg/encoding/gob/">gob data</a>.
-    </p>
-
-    <p> <!-- CL 29610, CL 31582 -->
-      Following RFC 3986,
-      <a href="/pkg/net/url/#Parse"><code>Parse</code></a>
-      now rejects URLs like <code>this_that:other/thing</code> instead of
-      interpreting them as relative paths (<code>this_that</code> is not a valid scheme).
-      To force interpretation as a relative path,
-      such URLs should be prefixed with “<code>./</code>”.
-      The <code>URL.String</code> method now inserts this prefix as needed.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p> <!-- CL 16551 -->
-      The new function
-      <a href="/pkg/os/#Executable"><code>Executable</code></a> returns
-      the path name of the running executable.
-    </p>
-
-    <p> <!-- CL 30614 -->
-      An attempt to call a method on
-      an <a href="/pkg/os/#File"><code>os.File</code></a> that has
-      already been closed will now return the new error
-      value <a href="/pkg/os/#ErrClosed"><code>os.ErrClosed</code></a>.
-      Previously it returned a system-specific error such
-      as <code>syscall.EBADF</code>.
-    </p>
-
-    <p> <!-- CL 31358 -->
-      On Unix systems, <a href="/pkg/os/#Rename"><code>os.Rename</code></a>
-      will now return an error when used to rename a directory to an
-      existing empty directory.
-      Previously it would fail when renaming to a non-empty directory
-      but succeed when renaming to an empty directory.
-      This makes the behavior on Unix correspond to that of other systems.
-    </p>
-
-    <p> <!-- CL 32451 -->
-      On Windows, long absolute paths are now transparently converted to
-      extended-length paths (paths that start with “<code>\\?\</code>”).
-      This permits the package to work with files whose path names are
-      longer than 260 characters.
-    </p>
-
-    <p> <!-- CL 29753 -->
-      On Windows, <a href="/pkg/os/#IsExist"><code>os.IsExist</code></a>
-      will now return <code>true</code> for the system
-      error <code>ERROR_DIR_NOT_EMPTY</code>.
-      This roughly corresponds to the existing handling of the Unix
-      error <code>ENOTEMPTY</code>.
-    </p>
-
-    <p> <!-- CL 32152 -->
-      On Plan 9, files that are not served by <code>#M</code> will now
-      have <a href="/pkg/os/#ModeDevice"><code>ModeDevice</code></a> set in
-      the value returned
-      by <a href="/pkg/os/#FileInfo"><code>FileInfo.Mode</code></a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="path_filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
-  <dd>
-    <p>
-      A number of bugs and corner cases on Windows were fixed:
-      <a href="/pkg/path/filepath/#Abs"><code>Abs</code></a> now calls <code>Clean</code> as documented,
-      <a href="/pkg/path/filepath/#Glob"><code>Glob</code></a> now matches
-      “<code>\\?\c:\*</code>”,
-      <a href="/pkg/path/filepath/#EvalSymlinks"><code>EvalSymlinks</code></a> now
-      correctly handles “<code>C:.</code>”, and
-      <a href="/pkg/path/filepath/#Clean"><code>Clean</code></a> now properly
-      handles a leading “<code>..</code>” in the path.
-    </p>
-  </dd>
-</dl>
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p> <!-- CL 30088 -->
-      The new function
-      <a href="/pkg/reflect/#Swapper"><code>Swapper</code></a> was
-      added to support <a href="#sortslice"><code>sort.Slice</code></a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p> <!-- CL 31210 -->
-      The <a href="/pkg/strconv/#Unquote"><code>Unquote</code></a>
-      function now strips carriage returns (<code>\r</code>) in
-      backquoted raw strings, following the
-      <a href="/ref/spec#String_literals">Go language semantics</a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p> <!-- CL 25050, CL 25022 -->
-      The <a href="/pkg/syscall/#Getpagesize"><code>Getpagesize</code></a>
-      now returns the system's size, rather than a constant value.
-      Previously it always returned 4KB.
-    </p>
-
-    <p> <!-- CL 31446 -->
-      The signature
-      of <a href="/pkg/syscall/#Utimes"><code>Utimes</code></a> has
-      changed on Solaris to match all the other Unix systems'
-      signature. Portable code should continue to use
-      <a href="/pkg/os/#Chtimes"><code>os.Chtimes</code></a> instead.
-    </p>
-
-    <p> <!-- CL 32319 -->
-      The <code>X__cmsg_data</code> field has been removed from
-      <a href="/pkg/syscall/#Cmsghdr"><code>Cmsghdr</code></a>.
-      </p>
-  </dd>
-</dl>
-
-<dl id="text_template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p> <!-- CL 31462 -->
-      <a href="/pkg/text/template/#Template.Execute"><code>Template.Execute</code></a>
-      can now take a
-      <a href="/pkg/reflect/#Value"><code>reflect.Value</code></a> as its data
-      argument, and
-      <a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
-      functions can also accept and return <code>reflect.Value</code>.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-
-    <p> <!-- CL 20118 --> The new function
-      <a href="/pkg/time/#Until"><code>Until</code></a> complements
-      the analogous <code>Since</code> function.
-    </p>
-
-    <p> <!-- CL 29338 -->
-      <a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a>
-      now accepts long fractional parts.
-    </p>
-
-    <p> <!-- CL 33429 -->
-      <a href="/pkg/time/#Parse"><code>Parse</code></a>
-      now rejects dates before the start of a month, such as June 0;
-      it already rejected dates beyond the end of the month, such as
-      June 31 and July 32.
-    </p>
-
-    <p> <!-- CL 33029 --> <!-- CL 34816 -->
-      The <code>tzdata</code> database has been updated to version
-      2016j for systems that don't already have a local time zone
-      database.
-    </p>
-
-    <p>
-  </dd>
-</dl>
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 29970 -->
-      The new method
-      <a href="/pkg/testing/#T.Name"><code>T.Name</code></a>
-      (and <code>B.Name</code>) returns the name of the current
-      test or benchmark.
-    </p>
-
-    <p><!-- CL 32483 -->
-      The new function
-      <a href="/pkg/testing/#CoverMode"><code>CoverMode</code></a>
-      reports the test coverage mode.
-    </p>
-
-    <p><!-- CL 32615 -->
-      Tests and benchmarks are now marked as failed if the race
-      detector is enabled and a data race occurs during execution.
-      Previously, individual test cases would appear to pass,
-      and only the overall execution of the test binary would fail.
-    </p>
-
-    <p><!-- CL 32455 -->
-      The signature of the
-      <a href="/pkg/testing/#MainStart"><code>MainStart</code></a>
-      function has changed, as allowed by the documentation. It is an
-      internal detail and not part of the Go 1 compatibility promise.
-      If you're not calling <code>MainStart</code> directly but see
-      errors, that likely means you set the
-      normally-empty <code>GOROOT</code> environment variable and it
-      doesn't match the version of your <code>go</code> command's binary.
-    </p>
-
-  </dd>
-</dl>
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-  <dd>
-    <p><!-- CL 30935 -->
-      <a href="/pkg/unicode/#SimpleFold"><code>SimpleFold</code></a>
-      now returns its argument unchanged if the provided input was an invalid rune.
-      Previously, the implementation failed with an index bounds check panic.
-    </p>
-  </dd>
-</dl>

diff --git a/doc/go1.9.html b/doc/go1.9.html
deleted file mode 100644 (file)
index 86ee257..0000000
--- a/doc/go1.9.html
+++ /dev/null
@@ -1,1024 +0,0 @@
-<!--{
-       "Title": "Go 1.9 Release Notes",
-       "Path":  "/doc/go1.9",
-       "Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.9</h2>
-
-<p>
-  The latest Go release, version 1.9, arrives six months
-  after <a href="go1.8">Go 1.8</a> and is the tenth release in
-  the <a href="https://golang.org/doc/devel/release.html">Go 1.x
-  series</a>.
-  There are two <a href="#language">changes to the language</a>:
-  adding support for type aliases and defining when implementations
-  may fuse floating point operations.
-  Most of the changes are in the implementation of the toolchain,
-  runtime, and libraries.
-  As always, the release maintains the Go 1
-  <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as
-  before.
-</p>
-
-<p>
-  The release
-  adds <a href="#monotonic-time">transparent monotonic time support</a>,
-  <a href="#parallel-compile">parallelizes compilation of functions</a> within a package,
-  better supports <a href="#test-helper">test helper functions</a>,
-  includes a new <a href="#math-bits">bit manipulation package</a>,
-  and has a new <a href="#sync-map">concurrent map type</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are two changes to the language.
-</p>
-<p>
-  Go now supports type aliases to support gradual code repair while
-  moving a type between packages.
-  The <a href="https://golang.org/design/18130-type-alias">type alias
-  design document</a>
-  and <a href="https://talks.golang.org/2016/refactor.article">an
-  article on refactoring</a> cover the problem in detail.
-  In short, a type alias declaration has the form:
-</p>
-
-<pre>
-type T1 = T2
-</pre>
-
-<p>
-  This declaration introduces an alias name <code>T1</code>—an
-  alternate spelling—for the type denoted by <code>T2</code>; that is,
-  both <code>T1</code> and <code>T2</code> denote the same type.
-</p>
-
-<p> <!-- CL 40391 -->
-  A smaller language change is that the
-  <a href="/ref/spec#Floating_point_operators">language specification
-  now states</a> when implementations are allowed to fuse floating
-  point operations together, such as by using an architecture's "fused
-  multiply and add" (FMA) instruction to compute <code>x*y</code>&nbsp;<code>+</code>&nbsp;<code>z</code>
-  without rounding the intermediate result <code>x*y</code>.
-  To force the intermediate rounding, write <code>float64(x*y)</code>&nbsp;<code>+</code>&nbsp;<code>z</code>.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-  There are no new supported operating systems or processor
-  architectures in this release.
-</p>
-
-<h3 id="power8">ppc64x requires POWER8</h3>
-
-<p> <!-- CL 36725, CL 36832 -->
-  Both <code>GOARCH=ppc64</code> and <code>GOARCH=ppc64le</code> now
-  require at least POWER8 support. In previous releases,
-  only <code>GOARCH=ppc64le</code> required POWER8 and the big
-  endian <code>ppc64</code> architecture supported older
-  hardware.
-<p>
-
-<h3 id="freebsd">FreeBSD</h3>
-
-<p>
-  Go 1.9 is the last release that will run on FreeBSD 9.3,
-  which is already
-  <a href="https://www.freebsd.org/security/unsupported.html">unsupported by FreeBSD</a>.
-  Go 1.10 will require FreeBSD 10.3+.
-</p>
-
-<h3 id="openbsd">OpenBSD 6.0</h3>
-
-<p> <!-- CL 40331 -->
-  Go 1.9 now enables PT_TLS generation for cgo binaries and thus
-  requires OpenBSD 6.0 or newer. Go 1.9 no longer supports
-  OpenBSD 5.9.
-<p>
-
-<h3 id="known_issues">Known Issues</h3>
-
-<p>
-  There are some instabilities on FreeBSD that are known but not understood.
-  These can lead to program crashes in rare cases.
-  See <a href="https://golang.org/issue/15658">issue 15658</a>.
-  Any help in solving this FreeBSD-specific issue would be appreciated.
-</p>
-
-<p>
-  Go stopped running NetBSD builders during the Go 1.9 development
-  cycle due to NetBSD kernel crashes, up to and including NetBSD 7.1.
-  As Go 1.9 is being released, NetBSD 7.1.1 is being released with a fix.
-  However, at this time we have no NetBSD builders passing our test suite.
-  Any help investigating the
-  <a href="https://github.com/golang/go/labels/OS-NetBSD">various NetBSD issues</a>
-  would be appreciated.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="parallel-compile">Parallel Compilation</h3>
-
-<p>
-  The Go compiler now supports compiling a package's functions in parallel, taking
-  advantage of multiple cores. This is in addition to the <code>go</code> command's
-  existing support for parallel compilation of separate packages.
-  Parallel compilation is on by default, but it can be disabled by setting the
-  environment variable <code>GO19CONCURRENTCOMPILATION</code> to <code>0</code>.
-</p>
-
-<h3 id="vendor-dotdotdot">Vendor matching with ./...</h3>
-
-<p><!-- CL 38745 -->
-  By popular request, <code>./...</code> no longer matches packages
-  in <code>vendor</code> directories in tools accepting package names,
-  such as <code>go</code> <code>test</code>. To match vendor
-  directories, write <code>./vendor/...</code>.
-</p>
-
-<h3 id="goroot">Moved GOROOT</h3>
-
-<p><!-- CL 42533 -->
-  The <a href="/cmd/go/">go tool</a> will now use the path from which it
-  was invoked to attempt to locate the root of the Go install tree.
-  This means that if the entire Go installation is moved to a new
-  location, the go tool should continue to work as usual.
-  This may be overridden by setting <code>GOROOT</code> in the environment,
-  which should only be done in unusual circumstances.
-  Note that this does not affect the result of
-  the <a href="/pkg/runtime/#GOROOT">runtime.GOROOT</a> function, which
-  will continue to report the original installation location;
-  this may be fixed in later releases.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p><!-- CL 37441 -->
-  Complex division is now C99-compatible. This has always been the
-  case in gccgo and is now fixed in the gc toolchain.
-</p>
-
-<p> <!-- CL 36983 -->
-  The linker will now generate DWARF information for cgo executables on Windows.
-</p>
-
-<p> <!-- CL 44210, CL 40095 -->
-  The compiler now includes lexical scopes in the generated DWARF if the
-  <code>-N -l</code> flags are provided, allowing
-  debuggers to hide variables that are not in scope. The <code>.debug_info</code>
-  section is now DWARF version 4.
-</p>
-
-<p> <!-- CL 43855 -->
-  The values of <code>GOARM</code> and <code>GO386</code> now affect a
-  compiled package's build ID, as used by the <code>go</code> tool's
-  dependency caching.
-</p>
-
-<h3 id="asm">Assembler</h3>
-
-<p> <!-- CL 42028 -->
-  The four-operand ARM <code>MULA</code> instruction is now assembled correctly,
-  with the addend register as the third argument and the result
-  register as the fourth and final argument.
-  In previous releases, the two meanings were reversed.
-  The three-operand form, in which the fourth argument is implicitly
-  the same as the third, is unaffected.
-  Code using four-operand <code>MULA</code> instructions
-  will need to be updated, but we believe this form is very rarely used.
-  <code>MULAWT</code> and <code>MULAWB</code> were already
-  using the correct order in all forms and are unchanged.
-</p>
-
-<p> <!-- CL 42990 -->
-  The assembler now supports <code>ADDSUBPS/PD</code>, completing the
-  two missing x86 SSE3 instructions.
-</p>
-
-<h3 id="go-doc">Doc</h3>
-
-<p><!-- CL 36031 -->
-  Long lists of arguments are now truncated. This improves the readability
-  of <code>go</code> <code>doc</code> on some generated code.
-</p>
-
-<p><!-- CL 38438 -->
-  Viewing documentation on struct fields is now supported.
-  For example, <code>go</code> <code>doc</code> <code>http.Client.Jar</code>.
-</p>
-
-<h3 id="go-env-json">Env</h3>
-
-<p> <!-- CL 38757 -->
-  The new <code>go</code> <code>env</code> <code>-json</code> flag
-  enables JSON output, instead of the default OS-specific output
-  format.
-</p>
-
-<h3 id="go-test-list">Test</h3>
-
-<p> <!-- CL 41195 -->
-  The <a href="/cmd/go/#hdr-Description_of_testing_flags"><code>go</code> <code>test</code></a>
-  command accepts a new <code>-list</code> flag, which takes a regular
-  expression as an argument and prints to stdout the name of any
-  tests, benchmarks, or examples that match it, without running them.
-</p>
-
-
-<h3 id="go-tool-pprof">Pprof</h3>
-
-<p> <!-- CL 34192 -->
-  Profiles produced by the <code>runtime/pprof</code> package now
-  include symbol information, so they can be viewed
-  in <code>go</code> <code>tool</code> <code>pprof</code>
-  without the binary that produced the profile.
-</p>
-
-<p> <!-- CL 38343 -->
-  The <code>go</code> <code>tool</code> <code>pprof</code> command now
-  uses the HTTP proxy information defined in the environment, using
-  <a href="/pkg/net/http/#ProxyFromEnvironment"><code>http.ProxyFromEnvironment</code></a>.
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<!-- CL 40112 -->
-<p>
-  The <a href="/cmd/vet/"><code>vet</code> command</a>
-  has been better integrated into the
-  <a href="/cmd/go/"><code>go</code> tool</a>,
-  so <code>go</code> <code>vet</code> now supports all standard build
-  flags while <code>vet</code>'s own flags are now available
-  from <code>go</code> <code>vet</code> as well as
-  from <code>go</code> <code>tool</code> <code>vet</code>.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-Due to the alignment of Go's semiannual release schedule with GCC's
-annual release schedule,
-GCC release 7 contains the Go 1.8.3 version of gccgo.
-We expect that the next release, GCC 8, will contain the Go 1.10
-version of gccgo.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<h3 id="callersframes">Call stacks with inlined frames</h3>
-
-<p>
-  Users of
-  <a href="/pkg/runtime#Callers"><code>runtime.Callers</code></a>
-  should avoid directly inspecting the resulting PC slice and instead use
-  <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
-  to get a complete view of the call stack, or
-  <a href="/pkg/runtime#Caller"><code>runtime.Caller</code></a>
-  to get information about a single caller.
-  This is because an individual element of the PC slice cannot account
-  for inlined frames or other nuances of the call stack.
-</p>
-
-<p>
-  Specifically, code that directly iterates over the PC slice and uses
-  functions such as
-  <a href="/pkg/runtime#FuncForPC"><code>runtime.FuncForPC</code></a>
-  to resolve each PC individually will miss inlined frames.
-  To get a complete view of the stack, such code should instead use
-  <code>CallersFrames</code>.
-  Likewise, code should not assume that the length returned by
-  <code>Callers</code> is any indication of the call depth.
-  It should instead count the number of frames returned by
-  <code>CallersFrames</code>.
-</p>
-
-<p>
-  Code that queries a single caller at a specific depth should use
-  <code>Caller</code> rather than passing a slice of length 1 to
-  <code>Callers</code>.
-</p>
-
-<p>
-  <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
-  has been available since Go 1.7, so code can be updated prior to
-  upgrading to Go 1.9.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-  As always, the changes are so general and varied that precise
-  statements about performance are difficult to make.  Most programs
-  should run a bit faster, due to speedups in the garbage collector,
-  better generated code, and optimizations in the core library.
-</p>
-
-<h3 id="gc">Garbage Collector</h3>
-
-<p> <!-- CL 37520 -->
-  Library functions that used to trigger stop-the-world garbage
-  collection now trigger concurrent garbage collection.
-
-  Specifically, <a href="/pkg/runtime/#GC"><code>runtime.GC</code></a>,
-  <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>,
-  and
-  <a href="/pkg/runtime/debug/#FreeOSMemory"><code>debug.FreeOSMemory</code></a>,
-  now trigger concurrent garbage collection, blocking only the calling
-  goroutine until the garbage collection is done.
-</p>
-
-<p> <!-- CL 34103, CL 39835 -->
-  The
-  <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>
-  function only triggers a garbage collection if one is immediately
-  necessary because of the new GOGC value.
-  This makes it possible to adjust GOGC on-the-fly.
-</p>
-
-<p> <!-- CL 38732 -->
-  Large object allocation performance is significantly improved in
-  applications using large (&gt;50GB) heaps containing many large
-  objects.
-</p>
-
-<p> <!-- CL 34937 -->
-  The <a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
-  function now takes less than 100µs even for very large heaps.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="monotonic-time">Transparent Monotonic Time support</h3>
-
-<p> <!-- CL 36255 -->
-  The <a href="/pkg/time/"><code>time</code></a> package now transparently
-  tracks monotonic time in each <a href="/pkg/time/#Time"><code>Time</code></a>
-  value, making computing durations between two <code>Time</code> values
-  a safe operation in the presence of wall clock adjustments.
-  See the <a href="/pkg/time/#hdr-Monotonic_Clocks">package docs</a> and
-  <a href="https://golang.org/design/12914-monotonic">design document</a>
-  for details.
-</p>
-
-<h3 id="math-bits">New bit manipulation package</h3>
-
-<p> <!-- CL 36315 -->
-  Go 1.9 includes a new package,
-  <a href="/pkg/math/bits/"><code>math/bits</code></a>, with optimized
-  implementations for manipulating bits. On most architectures,
-  functions in this package are additionally recognized by the
-  compiler and treated as intrinsics for additional performance.
-</p>
-
-<h3 id="test-helper">Test Helper Functions</h3>
-
-<p> <!-- CL 38796 -->
-  The
-  new <a href="/pkg/testing/#T.Helper"><code>(*T).Helper</code></a>
-  and <a href="/pkg/testing/#B.Helper"><code>(*B).Helper</code></a>
-  methods mark the calling function as a test helper function.  When
-  printing file and line information, that function will be skipped.
-  This permits writing test helper functions while still having useful
-  line numbers for users.
-</p>
-
-<h3 id="sync-map">Concurrent Map</h3>
-
-<p> <!-- CL 36617 -->
-  The new <a href="/pkg/sync/#Map"><code>Map</code></a> type
-  in the <a href="/pkg/sync/"><code>sync</code></a> package
-  is a concurrent map with amortized-constant-time loads, stores, and
-  deletes. It is safe for multiple goroutines to call a <code>Map</code>'s methods
-  concurrently.
-</p>
-
-<h3 id="pprof-labels">Profiler Labels</h3>
-
-<p><!-- CL 34198 -->
-  The <a href="/pkg/runtime/pprof"><code>runtime/pprof</code> package</a>
-  now supports adding labels to <code>pprof</code> profiler records.
-  Labels form a key-value map that is used to distinguish calls of the
-  same function in different contexts when looking at profiles
-  with the <a href="/cmd/pprof/"><code>pprof</code> command</a>.
-  The <code>pprof</code> package's
-  new <a href="/pkg/runtime/pprof/#Do"><code>Do</code> function</a>
-  runs code associated with some provided labels. Other new functions
-  in the package help work with labels.
-</p>
-
-</dl><!-- runtime/pprof -->
-
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
-  <dd>
-    <p><!-- CL 39570 -->
-      The
-      ZIP <a href="/pkg/archive/zip/#Writer"><code>Writer</code></a>
-      now sets the UTF-8 bit in
-      the <a href="/pkg/archive/zip/#FileHeader.Flags"><code>FileHeader.Flags</code></a>
-      when appropriate.
-    </p>
-
-</dl><!-- archive/zip -->
-
-<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
-  <dd>
-    <p><!-- CL 43852 -->
-      On Linux, Go now calls the <code>getrandom</code> system call
-      without the <code>GRND_NONBLOCK</code> flag; it will now block
-      until the kernel has sufficient randomness. On kernels predating
-      the <code>getrandom</code> system call, Go continues to read
-      from <code>/dev/urandom</code>.
-    </p>
-
-</dl><!-- crypto/rand -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 36093 -->
-
-      On Unix systems the environment
-      variables <code>SSL_CERT_FILE</code>
-      and <code>SSL_CERT_DIR</code> can now be used to override the
-      system default locations for the SSL certificate file and SSL
-      certificate files directory, respectively.
-    </p>
-
-    <p>The FreeBSD file <code>/usr/local/etc/ssl/cert.pem</code> is
-      now included in the certificate search path.
-    </p>
-
-    <p><!-- CL 36900 -->
-
-      The package now supports excluded domains in name constraints.
-      In addition to enforcing such constraints,
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      will create certificates with excluded name constraints
-      if the provided template certificate has the new
-      field
-      <a href="/pkg/crypto/x509/#Certificate.ExcludedDNSDomains"><code>ExcludedDNSDomains</code></a>
-      populated.
-    </p>
-
-    <p><!-- CL 36696 -->
-
-    If any SAN extension, including with no DNS names, is present
-    in the certificate, then the Common Name from
-    <a href="/pkg/crypto/x509/#Certificate.Subject"><code>Subject</code></a> is ignored.
-    In previous releases, the code tested only whether DNS-name SANs were
-    present in a certificate.
-    </p>
-
-</dl><!-- crypto/x509 -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 35476 -->
-      The package will now use a cached <a href="/pkg/database/sql/#Stmt"><code>Stmt</code></a> if
-      available in <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a>.
-      This prevents statements from being re-prepared each time
-      <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a> is called.
-    </p>
-
-    <p><!-- CL 38533 -->
-      The package now allows drivers to implement their own argument checkers by implementing
-      <a href="/pkg/database/sql/driver/#NamedValueChecker"><code>driver.NamedValueChecker</code></a>.
-      This also allows drivers to support <code>OUTPUT</code> and <code>INOUT</code> parameter types.
-      <a href="/pkg/database/sql/#Out"><code>Out</code></a> should be used to return output parameters
-      when supported by the driver.
-    </p>
-
-    <p><!-- CL 39031 -->
-      <a href="/pkg/database/sql/#Rows.Scan"><code>Rows.Scan</code></a> can now scan user-defined string types.
-      Previously the package supported scanning into numeric types like <code>type</code> <code>Int</code> <code>int64</code>. It now also supports
-      scanning into string types like <code>type</code> <code>String</code> <code>string</code>.
-    </p>
-
-    <p><!-- CL 40694 -->
-      The new <a href="/pkg/database/sql/#DB.Conn"><code>DB.Conn</code></a> method returns the new
-      <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> type representing an
-      exclusive connection to the database from the connection pool. All queries run on
-      a <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> will use the same underlying
-      connection until <a href="/pkg/database/sql/#Conn.Close"><code>Conn.Close</code></a> is called
-      to return the connection to the connection pool.
-    </p>
-
-</dl><!-- database/sql -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 38660 -->
-         The new
-         <a href="/pkg/encoding/asn1/#NullBytes"><code>NullBytes</code></a>
-         and
-         <a href="/pkg/encoding/asn1/#NullRawValue"><code>NullRawValue</code></a>
-         represent the ASN.1 NULL type.
-    </p>
-
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
-  <dd>
-    <p><!-- CL 38634 -->
-         The new <a href="/pkg/encoding/base32/#Encoding.WithPadding">Encoding.WithPadding</a>
-         method adds support for custom padding characters and disabling padding.
-    </p>
-
-</dl><!-- encoding/base32 -->
-
-<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
-  <dd>
-    <p><!-- CL 41730 -->
-      The new field
-      <a href="/pkg/encoding/csv/#Reader.ReuseRecord"><code>Reader.ReuseRecord</code></a>
-      controls whether calls to
-      <a href="/pkg/encoding/csv/#Reader.Read"><code>Read</code></a>
-      may return a slice sharing the backing array of the previous
-      call's returned slice for improved performance.
-    </p>
-
-</dl><!-- encoding/csv -->
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 37051 -->
-      The sharp flag ('<code>#</code>') is now supported when printing
-      floating point and complex numbers. It will always print a
-      decimal point
-      for <code>%e</code>, <code>%E</code>, <code>%f</code>, <code>%F</code>, <code>%g</code>
-      and <code>%G</code>; it will not remove trailing zeros
-      for <code>%g</code> and <code>%G</code>.
-    </p>
-
-</dl><!-- fmt -->
-
-<dl id="hash/fnv"><dt><a href="/pkg/hash/fnv/">hash/fnv</a></dt>
-  <dd>
-    <p><!-- CL 38356 -->
-      The package now includes 128-bit FNV-1 and FNV-1a hash support with
-      <a href="/pkg/hash/fnv/#New128"><code>New128</code></a> and
-      <a href="/pkg/hash/fnv/#New128a"><code>New128a</code></a>, respectively.
-    </p>
-
-</dl><!-- hash/fnv -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 37880, CL 40936 -->
-         The package now reports an error if a predefined escaper (one of
-         "html", "urlquery" and "js") is found in a pipeline and does not match
-         what the auto-escaper would have decided on its own.
-         This avoids certain security or correctness issues.
-         Now use of one of these escapers is always either a no-op or an error.
-         (The no-op case eases migration from <a href="/pkg/text/template/">text/template</a>.)
-    </p>
-
-</dl><!-- html/template -->
-
-<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
-  <dd>
-    <p><!-- CL 36734 -->
-         The <a href="/pkg/image/#Rectangle.Intersect"><code>Rectangle.Intersect</code></a>
-         method now returns a zero <code>Rectangle</code> when called on
-         adjacent but non-overlapping rectangles, as documented. In
-         earlier releases it would incorrectly return an empty but
-         non-zero <code>Rectangle</code>.
-    </p>
-
-</dl><!-- image -->
-
-<dl id="image/color"><dt><a href="/pkg/image/color/">image/color</a></dt>
-  <dd>
-    <p><!-- CL 36732 -->
-         The YCbCr to RGBA conversion formula has been tweaked to ensure
-         that rounding adjustments span the complete [0, 0xffff] RGBA
-         range.
-    </p>
-
-</dl><!-- image/color -->
-
-<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
-  <dd>
-    <p><!-- CL 34150 -->
-         The new <a href="/pkg/image/png/#Encoder.BufferPool"><code>Encoder.BufferPool</code></a>
-         field allows specifying an <a href="/pkg/image/png/#EncoderBufferPool"><code>EncoderBufferPool</code></a>,
-         that will be used by the encoder to get temporary <code>EncoderBuffer</code>
-         buffers when encoding a PNG image.
-
-         The use of a <code>BufferPool</code> reduces the number of
-         memory allocations performed while encoding multiple images.
-    </p>
-
-    <p><!-- CL 38271 -->
-         The package now supports the decoding of transparent 8-bit
-         grayscale ("Gray8") images.
-    </p>
-
-</dl><!-- image/png -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 36487 -->
-      The new
-      <a href="/pkg/math/big/#Int.IsInt64"><code>IsInt64</code></a>
-      and
-      <a href="/pkg/math/big/#Int.IsUint64"><code>IsUint64</code></a>
-      methods report whether an <code>Int</code>
-      may be represented as an <code>int64</code> or <code>uint64</code>
-      value.
-    </p>
-
-</dl><!-- math/big -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p><!-- CL 39223 -->
-      The new
-      <a href="/pkg/mime/multipart/#FileHeader.Size"><code>FileHeader.Size</code></a>
-      field describes the size of a file in a multipart message.
-    </p>
-
-</dl><!-- mime/multipart -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 32572 -->
-      The new
-      <a href="/pkg/net/#Resolver.StrictErrors"><code>Resolver.StrictErrors</code></a>
-      provides control over how Go's built-in DNS resolver handles
-      temporary errors during queries composed of multiple sub-queries,
-      such as an A+AAAA address lookup.
-    </p>
-
-    <p><!-- CL 37260 -->
-      The new
-      <a href="/pkg/net/#Resolver.Dial"><code>Resolver.Dial</code></a>
-      allows a <code>Resolver</code> to use a custom dial function.
-    </p>
-
-    <p><!-- CL 40510 -->
-      <a href="/pkg/net/#JoinHostPort"><code>JoinHostPort</code></a> now only places an address in square brackets if the host contains a colon.
-      In previous releases it would also wrap addresses in square brackets if they contained a percent ('<code>%</code>') sign.
-    </p>
-
-    <p><!-- CL 37913 -->
-      The new methods
-      <a href="/pkg/net/#TCPConn.SyscallConn"><code>TCPConn.SyscallConn</code></a>,
-      <a href="/pkg/net/#IPConn.SyscallConn"><code>IPConn.SyscallConn</code></a>,
-      <a href="/pkg/net/#UDPConn.SyscallConn"><code>UDPConn.SyscallConn</code></a>,
-      and
-      <a href="/pkg/net/#UnixConn.SyscallConn"><code>UnixConn.SyscallConn</code></a>
-      provide access to the connections' underlying file descriptors.
-    </p>
-
-    <p><!-- 45088 -->
-      It is now safe to call <a href="/pkg/net/#Dial"><code>Dial</code></a> with the address obtained from
-      <code>(*TCPListener).String()</code> after creating the listener with
-      <code><a href="/pkg/net/#Listen">Listen</a>("tcp", ":0")</code>.
-      Previously it failed on some machines with half-configured IPv6 stacks.
-    </p>
-
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-
-    <p><!-- CL 37328 -->
-      The <a href="/pkg/net/http/#Cookie.String"><code>Cookie.String</code></a> method, used for
-      <code>Cookie</code> and <code>Set-Cookie</code> headers, now encloses values in double quotes
-      if the value contains either a space or a comma.
-    </p>
-
-    <p>Server changes:</p>
-    <ul>
-      <li><!-- CL 38194 -->
-        <a href="/pkg/net/http/#ServeMux"><code>ServeMux</code></a> now ignores ports in the host
-        header when matching handlers. The host is matched unmodified for <code>CONNECT</code> requests.
-      </li>
-
-      <li><!-- CL 44074 -->
-        The new <a href="/pkg/net/http/#Server.ServeTLS"><code>Server.ServeTLS</code></a> method wraps
-        <a href="/pkg/net/http/#Server.Serve"><code>Server.Serve</code></a> with added TLS support.
-      </li>
-
-      <li><!-- CL 34727 -->
-        <a href="/pkg/net/http/#Server.WriteTimeout"><code>Server.WriteTimeout</code></a>
-        now applies to HTTP/2 connections and is enforced per-stream.
-      </li>
-
-      <li><!-- CL 43231 -->
-        HTTP/2 now uses the priority write scheduler by default.
-        Frames are scheduled by following HTTP/2 priorities as described in
-        <a href="https://tools.ietf.org/html/rfc7540#section-5.3">RFC 7540 Section 5.3</a>.
-      </li>
-
-      <li><!-- CL 36483 -->
-        The HTTP handler returned by <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
-        now calls its provided handler with a modified clone of the original <code>*http.Request</code>.
-        Any code storing per-request state in maps keyed by <code>*http.Request</code> should
-        use
-        <a href="/pkg/net/http/#Request.Context"><code>Request.Context</code></a>,
-        <a href="/pkg/net/http/#Request.WithContext"><code>Request.WithContext</code></a>,
-        and
-        <a href="/pkg/context/#WithValue"><code>context.WithValue</code></a> instead.
-      </li>
-
-      <li><!-- CL 35490 -->
-        <a href="/pkg/net/http/#LocalAddrContextKey"><code>LocalAddrContextKey</code></a> now contains
-        the connection's actual network address instead of the interface address used by the listener.
-      </li>
-    </ul>
-
-    <p>Client &amp; Transport changes:</p>
-    <ul>
-      <li><!-- CL 35488 -->
-        The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-        now supports making requests via SOCKS5 proxy when the URL returned by
-        <a href="/pkg/net/http/#Transport.Proxy"><code>Transport.Proxy</code></a>
-        has the scheme <code>socks5</code>.
-      </li>
-    </ul>
-
-</dl><!-- net/http -->
-
-<dl id="net/http/fcgi"><dt><a href="/pkg/net/http/fcgi/">net/http/fcgi</a></dt>
-  <dd>
-    <p><!-- CL 40012 -->
-      The new
-      <a href="/pkg/net/http/fcgi/#ProcessEnv"><code>ProcessEnv</code></a>
-      function returns FastCGI environment variables associated with an HTTP request
-      for which there are no appropriate
-      <a href="/pkg/net/http/#Request"><code>http.Request</code></a>
-      fields, such as <code>REMOTE_USER</code>.
-    </p>
-
-</dl><!-- net/http/fcgi -->
-
-<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
-  <dd>
-    <p><!-- CL 34639 -->
-      The new
-      <a href="/pkg/net/http/httptest/#Server.Client"><code>Server.Client</code></a>
-      method returns an HTTP client configured for making requests to the test server.
-    </p>
-
-    <p>
-      The new
-      <a href="/pkg/net/http/httptest/#Server.Certificate"><code>Server.Certificate</code></a>
-      method returns the test server's TLS certificate, if any.
-    </p>
-
-</dl><!-- net/http/httptest -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 43712 -->
-      The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      now proxies all HTTP/2 response trailers, even those not declared in the initial response
-      header. Such undeclared trailers are used by the gRPC protocol.
-    </p>
-
-</dl><!-- net/http/httputil -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 36800 -->
-      The <code>os</code> package now uses the internal runtime poller
-      for file I/O.
-      This reduces the number of threads required for read/write
-      operations on pipes, and it eliminates races when one goroutine
-      closes a file while another is using the file for I/O.
-    </p>
-
-  <dd>
-    <p><!-- CL 37915 -->
-      On Windows,
-      <a href="/pkg/os/#Args"><code>Args</code></a>
-      is now populated without <code>shell32.dll</code>, improving process start-up time by 1-7 ms.
-      </p>
-
-</dl><!-- os -->
-
-<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
-  <dd>
-    <p><!-- CL 37586 -->
-      The <code>os/exec</code> package now prevents child processes from being created with
-      any duplicate environment variables.
-      If <a href="/pkg/os/exec/#Cmd.Env"><code>Cmd.Env</code></a>
-      contains duplicate environment keys, only the last
-      value in the slice for each duplicate key is used.
-    </p>
-
-</dl><!-- os/exec -->
-
-<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
-  <dd>
-    <p><!-- CL 37664 -->
-      <a href="/pkg/os/user/#Lookup"><code>Lookup</code></a> and
-      <a href="/pkg/os/user/#LookupId"><code>LookupId</code></a> now
-      work on Unix systems when <code>CGO_ENABLED=0</code> by reading
-      the <code>/etc/passwd</code> file.
-    </p>
-
-    <p><!-- CL 33713 -->
-      <a href="/pkg/os/user/#LookupGroup"><code>LookupGroup</code></a> and
-      <a href="/pkg/os/user/#LookupGroupId"><code>LookupGroupId</code></a> now
-      work on Unix systems when <code>CGO_ENABLED=0</code> by reading
-      the <code>/etc/group</code> file.
-    </p>
-
-</dl><!-- os/user -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 38335 -->
-      The new
-      <a href="/pkg/reflect/#MakeMapWithSize"><code>MakeMapWithSize</code></a>
-      function creates a map with a capacity hint.
-    </p>
-
-</dl><!-- reflect -->
-
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p><!-- CL 37233, CL 37726 -->
-      Tracebacks generated by the runtime and recorded in profiles are
-      now accurate in the presence of inlining.
-      To retrieve tracebacks programmatically, applications should use
-      <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-      rather than directly iterating over the results of
-      <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a>.
-    </p>
-
-    <p><!-- CL 38403 -->
-      On Windows, Go no longer forces the system timer to run at high
-      resolution when the program is idle.
-      This should reduce the impact of Go programs on battery life.
-    </p>
-
-    <p><!-- CL 29341 -->
-      On FreeBSD, <code>GOMAXPROCS</code> and
-      <a href="/pkg/runtime/#NumCPU"><code>runtime.NumCPU</code></a>
-      are now based on the process' CPU mask, rather than the total
-      number of CPUs.
-    </p>
-
-    <p><!-- CL 43641 -->
-      The runtime has preliminary support for Android O.
-    </p>
-
-</dl><!-- runtime -->
-
-<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
-  <dd>
-    <p><!-- CL 34013 -->
-      Calling
-      <a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
-      with a negative value no longer runs an immediate garbage collection.
-    </p>
-
-</dl><!-- runtime/debug -->
-
-<dl id="runtime/trace"><dt><a href="/pkg/runtime/trace/">runtime/trace</a></dt>
-  <dd>
-    <p><!-- CL 36015 -->
-      The execution trace now displays mark assist events, which
-      indicate when an application goroutine is forced to assist
-      garbage collection because it is allocating too quickly.
-    </p>
-
-    <p><!-- CL 40810 -->
-      "Sweep" events now encompass the entire process of finding free
-      space for an allocation, rather than recording each individual
-      span that is swept.
-      This reduces allocation latency when tracing allocation-heavy
-      programs.
-      The sweep event shows how many bytes were swept and how many
-      were reclaimed.
-    </p>
-
-</dl><!-- runtime/trace -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 34310 -->
-      <a href="/pkg/sync/#Mutex"><code>Mutex</code></a> is now more fair.
-    </p>
-
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 36697 -->
-      The new field
-      <a href="/pkg/syscall/#Credential.NoSetGroups"><code>Credential.NoSetGroups</code></a>
-      controls whether Unix systems make a <code>setgroups</code> system call
-      to set supplementary groups when starting a new process.
-    </p>
-
-    <p><!-- CL 43512 -->
-      The new field
-      <a href="/pkg/syscall/#SysProcAttr.AmbientCaps"><code>SysProcAttr.AmbientCaps</code></a>
-      allows setting ambient capabilities on Linux 4.3+ when creating
-      a new process.
-    </p>
-
-    <p><!-- CL 37439 -->
-      On 64-bit x86 Linux, process creation latency has been optimized with
-      use of <code>CLONE_VFORK</code> and <code>CLONE_VM</code>.
-    </p>
-
-    <p><!-- CL 37913 -->
-      The new
-      <a href="/pkg/syscall/#Conn"><code>Conn</code></a>
-      interface describes some types in the
-      <a href="/pkg/net/"><code>net</code></a>
-      package that can provide access to their underlying file descriptor
-      using the new
-      <a href="/pkg/syscall/#RawConn"><code>RawConn</code></a>
-      interface.
-    </p>
-
-</dl><!-- syscall -->
-
-
-<dl id="testing/quick"><dt><a href="/pkg/testing/quick/">testing/quick</a></dt>
-  <dd>
-    <p><!-- CL 39152 -->
-      The package now chooses values in the full range when
-      generating <code>int64</code> and <code>uint64</code> random
-      numbers; in earlier releases generated values were always
-      limited to the [-2<sup>62</sup>, 2<sup>62</sup>) range.
-    </p>
-
-    <p>
-      In previous releases, using a nil
-      <a href="/pkg/testing/quick/#Config.Rand"><code>Config.Rand</code></a>
-      value caused a fixed deterministic random number generator to be used.
-      It now uses a random number generator seeded with the current time.
-      For the old behavior, set <code>Config.Rand</code> to <code>rand.New(rand.NewSource(0))</code>.
-    </p>
-
-</dl><!-- testing/quick -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 38420 -->
-         The handling of empty blocks, which was broken by a Go 1.8
-         change that made the result dependent on the order of templates,
-         has been fixed, restoring the old Go 1.7 behavior.
-    </p>
-
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 36615 -->
-      The new methods
-      <a href="/pkg/time/#Duration.Round"><code>Duration.Round</code></a>
-      and
-      <a href="/pkg/time/#Duration.Truncate"><code>Duration.Truncate</code></a>
-      handle rounding and truncating durations to multiples of a given duration.
-    </p>
-
-    <p><!-- CL 35710 -->
-      Retrieving the time and sleeping now work correctly under Wine.
-    </p>
-
-    <p>
-      If a <code>Time</code> value has a monotonic clock reading, its
-      string representation (as returned by <code>String</code>) now includes a
-      final field <code>"m=±value"</code>, where <code>value</code> is the
-      monotonic clock reading formatted as a decimal number of seconds.
-    </p>
-
-    <p><!-- CL 44832 -->
-      The included <code>tzdata</code> timezone database has been
-      updated to version 2017b. As always, it is only used if the
-      system does not already have the database available.
-    </p>
-
-</dl><!-- time -->

diff --git a/doc/go1.html b/doc/go1.html
deleted file mode 100644 (file)
index 939ee24..0000000
--- a/doc/go1.html
+++ /dev/null
@@ -1,2038 +0,0 @@
-<!--{
-       "Title": "Go 1 Release Notes",
-       "Path":  "/doc/go1",
-       "Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1</h2>
-
-<p>
-Go version 1, Go 1 for short, defines a language and a set of core libraries
-that provide a stable foundation for creating reliable products, projects, and
-publications.
-</p>
-
-<p>
-The driving motivation for Go 1 is stability for its users. People should be able to
-write Go programs and expect that they will continue to compile and run without
-change, on a time scale of years, including in production environments such as
-Google App Engine. Similarly, people should be able to write books about Go, be
-able to say which version of Go the book is describing, and have that version
-number still be meaningful much later.
-</p>
-
-<p>
-Code that compiles in Go 1 should, with few exceptions, continue to compile and
-run throughout the lifetime of that version, even as we issue updates and bug
-fixes such as Go version 1.1, 1.2, and so on. Other than critical fixes, changes
-made to the language and library for subsequent releases of Go 1 may
-add functionality but will not break existing Go 1 programs.
-<a href="go1compat.html">The Go 1 compatibility document</a>
-explains the compatibility guidelines in more detail.
-</p>
-
-<p>
-Go 1 is a representation of Go as it used today, not a wholesale rethinking of
-the language. We avoided designing new features and instead focused on cleaning
-up problems and inconsistencies and improving portability. There are a number
-changes to the Go language and packages that we had considered for some time and
-prototyped but not released primarily because they are significant and
-backwards-incompatible. Go 1 was an opportunity to get them out, which is
-helpful for the long term, but also means that Go 1 introduces incompatibilities
-for old programs. Fortunately, the <code>go</code> <code>fix</code> tool can
-automate much of the work needed to bring programs up to the Go 1 standard.
-</p>
-
-<p>
-This document outlines the major changes in Go 1 that will affect programmers
-updating existing code; its reference point is the prior release, r60 (tagged as
-r60.3). It also explains how to update code from r60 to run under Go 1.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<h3 id="append">Append</h3>
-
-<p>
-The <code>append</code> predeclared variadic function makes it easy to grow a slice
-by adding elements to the end.
-A common use is to add bytes to the end of a byte slice when generating output.
-However, <code>append</code> did not provide a way to append a string to a <code>[]byte</code>,
-which is another common case.
-</p>
-
-{{code "/doc/progs/go1.go" `/greeting := ..byte/` `/append.*hello/`}}
-
-<p>
-By analogy with the similar property of <code>copy</code>, Go 1
-permits a string to be appended (byte-wise) directly to a byte
-slice, reducing the friction between strings and byte slices.
-The conversion is no longer necessary:
-</p>
-
-{{code "/doc/progs/go1.go" `/append.*world/`}}
-
-<p>
-<em>Updating</em>:
-This is a new feature, so existing code needs no changes.
-</p>
-
-<h3 id="close">Close</h3>
-
-<p>
-The <code>close</code> predeclared function provides a mechanism
-for a sender to signal that no more values will be sent.
-It is important to the implementation of <code>for</code> <code>range</code>
-loops over channels and is helpful in other situations.
-Partly by design and partly because of race conditions that can occur otherwise,
-it is intended for use only by the goroutine sending on the channel,
-not by the goroutine receiving data.
-However, before Go 1 there was no compile-time checking that <code>close</code>
-was being used correctly.
-</p>
-
-<p>
-To close this gap, at least in part, Go 1 disallows <code>close</code> on receive-only channels.
-Attempting to close such a channel is a compile-time error.
-</p>
-
-<pre>
-    var c chan int
-    var csend chan&lt;- int = c
-    var crecv &lt;-chan int = c
-    close(c)     // legal
-    close(csend) // legal
-    close(crecv) // illegal
-</pre>
-
-<p>
-<em>Updating</em>:
-Existing code that attempts to close a receive-only channel was
-erroneous even before Go 1 and should be fixed.  The compiler will
-now reject such code.
-</p>
-
-<h3 id="literals">Composite literals</h3>
-
-<p>
-In Go 1, a composite literal of array, slice, or map type can elide the
-type specification for the elements' initializers if they are of pointer type.
-All four of the initializations in this example are legal; the last one was illegal before Go 1.
-</p>
-
-{{code "/doc/progs/go1.go" `/type Date struct/` `/STOP/`}}
-
-<p>
-<em>Updating</em>:
-This change has no effect on existing code, but the command
-<code>gofmt</code> <code>-s</code> applied to existing source
-will, among other things, elide explicit element types wherever permitted.
-</p>
-
-
-<h3 id="init">Goroutines during init</h3>
-
-<p>
-The old language defined that <code>go</code> statements executed during initialization created goroutines but that they did not begin to run until initialization of the entire program was complete.
-This introduced clumsiness in many places and, in effect, limited the utility
-of the <code>init</code> construct:
-if it was possible for another package to use the library during initialization, the library
-was forced to avoid goroutines.
-This design was done for reasons of simplicity and safety but,
-as our confidence in the language grew, it seemed unnecessary.
-Running goroutines during initialization is no more complex or unsafe than running them during normal execution.
-</p>
-
-<p>
-In Go 1, code that uses goroutines can be called from
-<code>init</code> routines and global initialization expressions
-without introducing a deadlock.
-</p>
-
-{{code "/doc/progs/go1.go" `/PackageGlobal/` `/^}/`}}
-
-<p>
-<em>Updating</em>:
-This is a new feature, so existing code needs no changes,
-although it's possible that code that depends on goroutines not starting before <code>main</code> will break.
-There was no such code in the standard repository.
-</p>
-
-<h3 id="rune">The rune type</h3>
-
-<p>
-The language spec allows the <code>int</code> type to be 32 or 64 bits wide, but current implementations set <code>int</code> to 32 bits even on 64-bit platforms.
-It would be preferable to have <code>int</code> be 64 bits on 64-bit platforms.
-(There are important consequences for indexing large slices.)
-However, this change would waste space when processing Unicode characters with
-the old language because the <code>int</code> type was also used to hold Unicode code points: each code point would waste an extra 32 bits of storage if <code>int</code> grew from 32 bits to 64.
-</p>
-
-<p>
-To make changing to 64-bit <code>int</code> feasible,
-Go 1 introduces a new basic type, <code>rune</code>, to represent
-individual Unicode code points.
-It is an alias for <code>int32</code>, analogous to <code>byte</code>
-as an alias for <code>uint8</code>.
-</p>
-
-<p>
-Character literals such as <code>'a'</code>, <code>'語'</code>, and <code>'\u0345'</code>
-now have default type <code>rune</code>,
-analogous to <code>1.0</code> having default type <code>float64</code>.
-A variable initialized to a character constant will therefore
-have type <code>rune</code> unless otherwise specified.
-</p>
-
-<p>
-Libraries have been updated to use <code>rune</code> rather than <code>int</code>
-when appropriate. For instance, the functions <code>unicode.ToLower</code> and
-relatives now take and return a <code>rune</code>.
-</p>
-
-{{code "/doc/progs/go1.go" `/STARTRUNE/` `/ENDRUNE/`}}
-
-<p>
-<em>Updating</em>:
-Most source code will be unaffected by this because the type inference from
-<code>:=</code> initializers introduces the new type silently, and it propagates
-from there.
-Some code may get type errors that a trivial conversion will resolve.
-</p>
-
-<h3 id="error">The error type</h3>
-
-<p>
-Go 1 introduces a new built-in type, <code>error</code>, which has the following definition:
-</p>
-
-<pre>
-    type error interface {
-        Error() string
-    }
-</pre>
-
-<p>
-Since the consequences of this type are all in the package library,
-it is discussed <a href="#errors">below</a>.
-</p>
-
-<h3 id="delete">Deleting from maps</h3>
-
-<p>
-In the old language, to delete the entry with key <code>k</code> from map <code>m</code>, one wrote the statement,
-</p>
-
-<pre>
-    m[k] = value, false
-</pre>
-
-<p>
-This syntax was a peculiar special case, the only two-to-one assignment.
-It required passing a value (usually ignored) that is evaluated but discarded,
-plus a boolean that was nearly always the constant <code>false</code>.
-It did the job but was odd and a point of contention.
-</p>
-
-<p>
-In Go 1, that syntax has gone; instead there is a new built-in
-function, <code>delete</code>.  The call
-</p>
-
-{{code "/doc/progs/go1.go" `/delete\(m, k\)/`}}
-
-<p>
-will delete the map entry retrieved by the expression <code>m[k]</code>.
-There is no return value. Deleting a non-existent entry is a no-op.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will convert expressions of the form <code>m[k] = value,
-false</code> into <code>delete(m, k)</code> when it is clear that
-the ignored value can be safely discarded from the program and
-<code>false</code> refers to the predefined boolean constant.
-The fix tool
-will flag other uses of the syntax for inspection by the programmer.
-</p>
-
-<h3 id="iteration">Iterating in maps</h3>
-
-<p>
-The old language specification did not define the order of iteration for maps,
-and in practice it differed across hardware platforms.
-This caused tests that iterated over maps to be fragile and non-portable, with the
-unpleasant property that a test might always pass on one machine but break on another.
-</p>
-
-<p>
-In Go 1, the order in which elements are visited when iterating
-over a map using a <code>for</code> <code>range</code> statement
-is defined to be unpredictable, even if the same loop is run multiple
-times with the same map.
-Code should not assume that the elements are visited in any particular order.
-</p>
-
-<p>
-This change means that code that depends on iteration order is very likely to break early and be fixed long before it becomes a problem.
-Just as important, it allows the map implementation to ensure better map balancing even when programs are using range loops to select an element from a map.
-</p>
-
-{{code "/doc/progs/go1.go" `/Sunday/` `/^      }/`}}
-
-<p>
-<em>Updating</em>:
-This is one change where tools cannot help.  Most existing code
-will be unaffected, but some programs may break or misbehave; we
-recommend manual checking of all range statements over maps to
-verify they do not depend on iteration order. There were a few such
-examples in the standard repository; they have been fixed.
-Note that it was already incorrect to depend on the iteration order, which
-was unspecified. This change codifies the unpredictability.
-</p>
-
-<h3 id="multiple_assignment">Multiple assignment</h3>
-
-<p>
-The language specification has long guaranteed that in assignments
-the right-hand-side expressions are all evaluated before any left-hand-side expressions are assigned.
-To guarantee predictable behavior,
-Go 1 refines the specification further.
-</p>
-
-<p>
-If the left-hand side of the assignment
-statement contains expressions that require evaluation, such as
-function calls or array indexing operations, these will all be done
-using the usual left-to-right rule before any variables are assigned
-their value.  Once everything is evaluated, the actual assignments
-proceed in left-to-right order.
-</p>
-
-<p>
-These examples illustrate the behavior.
-</p>
-
-{{code "/doc/progs/go1.go" `/sa :=/` `/then sc.0. = 2/`}}
-
-<p>
-<em>Updating</em>:
-This is one change where tools cannot help, but breakage is unlikely.
-No code in the standard repository was broken by this change, and code
-that depended on the previous unspecified behavior was already incorrect.
-</p>
-
-<h3 id="shadowing">Returns and shadowed variables</h3>
-
-<p>
-A common mistake is to use <code>return</code> (without arguments) after an assignment to a variable that has the same name as a result variable but is not the same variable.
-This situation is called <em>shadowing</em>: the result variable has been shadowed by another variable with the same name declared in an inner scope.
-</p>
-
-<p>
-In functions with named return values,
-the Go 1 compilers disallow return statements without arguments if any of the named return values is shadowed at the point of the return statement.
-(It isn't part of the specification, because this is one area we are still exploring;
-the situation is analogous to the compilers rejecting functions that do not end with an explicit return statement.)
-</p>
-
-<p>
-This function implicitly returns a shadowed return value and will be rejected by the compiler:
-</p>
-
-<pre>
-    func Bug() (i, j, k int) {
-        for i = 0; i &lt; 5; i++ {
-            for j := 0; j &lt; 5; j++ { // Redeclares j.
-                k += i*j
-                if k > 100 {
-                    return // Rejected: j is shadowed here.
-                }
-            }
-        }
-        return // OK: j is not shadowed here.
-    }
-</pre>
-
-<p>
-<em>Updating</em>:
-Code that shadows return values in this way will be rejected by the compiler and will need to be fixed by hand.
-The few cases that arose in the standard repository were mostly bugs.
-</p>
-
-<h3 id="unexported">Copying structs with unexported fields</h3>
-
-<p>
-The old language did not allow a package to make a copy of a struct value containing unexported fields belonging to a different package.
-There was, however, a required exception for a method receiver;
-also, the implementations of <code>copy</code> and <code>append</code> have never honored the restriction.
-</p>
-
-<p>
-Go 1 will allow packages to copy struct values containing unexported fields from other packages.
-Besides resolving the inconsistency,
-this change admits a new kind of API: a package can return an opaque value without resorting to a pointer or interface.
-The new implementations of <code>time.Time</code> and
-<code>reflect.Value</code> are examples of types taking advantage of this new property.
-</p>
-
-<p>
-As an example, if package <code>p</code> includes the definitions,
-</p>
-
-<pre>
-    type Struct struct {
-        Public int
-        secret int
-    }
-    func NewStruct(a int) Struct {  // Note: not a pointer.
-        return Struct{a, f(a)}
-    }
-    func (s Struct) String() string {
-        return fmt.Sprintf("{%d (secret %d)}", s.Public, s.secret)
-    }
-</pre>
-
-<p>
-a package that imports <code>p</code> can assign and copy values of type
-<code>p.Struct</code> at will.
-Behind the scenes the unexported fields will be assigned and copied just
-as if they were exported,
-but the client code will never be aware of them. The code
-</p>
-
-<pre>
-    import "p"
-
-    myStruct := p.NewStruct(23)
-    copyOfMyStruct := myStruct
-    fmt.Println(myStruct, copyOfMyStruct)
-</pre>
-
-<p>
-will show that the secret field of the struct has been copied to the new value.
-</p>
-
-<p>
-<em>Updating</em>:
-This is a new feature, so existing code needs no changes.
-</p>
-
-<h3 id="equality">Equality</h3>
-
-<p>
-Before Go 1, the language did not define equality on struct and array values.
-This meant,
-among other things, that structs and arrays could not be used as map keys.
-On the other hand, Go did define equality on function and map values.
-Function equality was problematic in the presence of closures
-(when are two closures equal?)
-while map equality compared pointers, not the maps' content, which was usually
-not what the user would want.
-</p>
-
-<p>
-Go 1 addressed these issues.
-First, structs and arrays can be compared for equality and inequality
-(<code>==</code> and <code>!=</code>),
-and therefore be used as map keys,
-provided they are composed from elements for which equality is also defined,
-using element-wise comparison.
-</p>
-
-{{code "/doc/progs/go1.go" `/type Day struct/` `/Printf/`}}
-
-<p>
-Second, Go 1 removes the definition of equality for function values,
-except for comparison with <code>nil</code>.
-Finally, map equality is gone too, also except for comparison with <code>nil</code>.
-</p>
-
-<p>
-Note that equality is still undefined for slices, for which the
-calculation is in general infeasible.  Also note that the ordered
-comparison operators (<code>&lt;</code> <code>&lt;=</code>
-<code>&gt;</code> <code>&gt;=</code>) are still undefined for
-structs and arrays.
-
-<p>
-<em>Updating</em>:
-Struct and array equality is a new feature, so existing code needs no changes.
-Existing code that depends on function or map equality will be
-rejected by the compiler and will need to be fixed by hand.
-Few programs will be affected, but the fix may require some
-redesign.
-</p>
-
-<h2 id="packages">The package hierarchy</h2>
-
-<p>
-Go 1 addresses many deficiencies in the old standard library and
-cleans up a number of packages, making them more internally consistent
-and portable.
-</p>
-
-<p>
-This section describes how the packages have been rearranged in Go 1.
-Some have moved, some have been renamed, some have been deleted.
-New packages are described in later sections.
-</p>
-
-<h3 id="hierarchy">The package hierarchy</h3>
-
-<p>
-Go 1 has a rearranged package hierarchy that groups related items
-into subdirectories. For instance, <code>utf8</code> and
-<code>utf16</code> now occupy subdirectories of <code>unicode</code>.
-Also, <a href="#subrepo">some packages</a> have moved into
-subrepositories of
-<a href="//code.google.com/p/go"><code>code.google.com/p/go</code></a>
-while <a href="#deleted">others</a> have been deleted outright.
-</p>
-
-<table class="codetable" frame="border" summary="Moved packages">
-<colgroup align="left" width="60%"></colgroup>
-<colgroup align="left" width="40%"></colgroup>
-<tr>
-<th align="left">Old path</th>
-<th align="left">New path</th>
-</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>asn1</td> <td>encoding/asn1</td></tr>
-<tr><td>csv</td> <td>encoding/csv</td></tr>
-<tr><td>gob</td> <td>encoding/gob</td></tr>
-<tr><td>json</td> <td>encoding/json</td></tr>
-<tr><td>xml</td> <td>encoding/xml</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>exp/template/html</td> <td>html/template</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>big</td> <td>math/big</td></tr>
-<tr><td>cmath</td> <td>math/cmplx</td></tr>
-<tr><td>rand</td> <td>math/rand</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>http</td> <td>net/http</td></tr>
-<tr><td>http/cgi</td> <td>net/http/cgi</td></tr>
-<tr><td>http/fcgi</td> <td>net/http/fcgi</td></tr>
-<tr><td>http/httptest</td> <td>net/http/httptest</td></tr>
-<tr><td>http/pprof</td> <td>net/http/pprof</td></tr>
-<tr><td>mail</td> <td>net/mail</td></tr>
-<tr><td>rpc</td> <td>net/rpc</td></tr>
-<tr><td>rpc/jsonrpc</td> <td>net/rpc/jsonrpc</td></tr>
-<tr><td>smtp</td> <td>net/smtp</td></tr>
-<tr><td>url</td> <td>net/url</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>exec</td> <td>os/exec</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>scanner</td> <td>text/scanner</td></tr>
-<tr><td>tabwriter</td> <td>text/tabwriter</td></tr>
-<tr><td>template</td> <td>text/template</td></tr>
-<tr><td>template/parse</td> <td>text/template/parse</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>utf8</td> <td>unicode/utf8</td></tr>
-<tr><td>utf16</td> <td>unicode/utf16</td></tr>
-</table>
-
-<p>
-Note that the package names for the old <code>cmath</code> and
-<code>exp/template/html</code> packages have changed to <code>cmplx</code>
-and <code>template</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update all imports and package renames for packages that
-remain inside the standard repository.  Programs that import packages
-that are no longer in the standard repository will need to be edited
-by hand.
-</p>
-
-<h3 id="exp">The package tree exp</h3>
-
-<p>
-Because they are not standardized, the packages under the <code>exp</code> directory will not be available in the
-standard Go 1 release distributions, although they will be available in source code form
-in <a href="//code.google.com/p/go/">the repository</a> for
-developers who wish to use them.
-</p>
-
-<p>
-Several packages have moved under <code>exp</code> at the time of Go 1's release:
-</p>
-
-<ul>
-<li><code>ebnf</code></li>
-<li><code>html</code><sup>&#8224;</sup></li>
-<li><code>go/types</code></li>
-</ul>
-
-<p>
-(<sup>&#8224;</sup>The <code>EscapeString</code> and <code>UnescapeString</code> types remain
-in package <code>html</code>.)
-</p>
-
-<p>
-All these packages are available under the same names, with the prefix <code>exp/</code>: <code>exp/ebnf</code> etc.
-</p>
-
-<p>
-Also, the <code>utf8.String</code> type has been moved to its own package, <code>exp/utf8string</code>.
-</p>
-
-<p>
-Finally, the <code>gotype</code> command now resides in <code>exp/gotype</code>, while
-<code>ebnflint</code> is now in <code>exp/ebnflint</code>.
-If they are installed, they now reside in <code>$GOROOT/bin/tool</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses packages in <code>exp</code> will need to be updated by hand,
-or else compiled from an installation that has <code>exp</code> available.
-The <code>go</code> <code>fix</code> tool or the compiler will complain about such uses.
-</p>
-
-<h3 id="old">The package tree old</h3>
-
-<p>
-Because they are deprecated, the packages under the <code>old</code> directory will not be available in the
-standard Go 1 release distributions, although they will be available in source code form for
-developers who wish to use them.
-</p>
-
-<p>
-The packages in their new locations are:
-</p>
-
-<ul>
-<li><code>old/netchan</code></li>
-</ul>
-
-<p>
-<em>Updating</em>:
-Code that uses packages now in <code>old</code> will need to be updated by hand,
-or else compiled from an installation that has <code>old</code> available.
-The <code>go</code> <code>fix</code> tool will warn about such uses.
-</p>
-
-<h3 id="deleted">Deleted packages</h3>
-
-<p>
-Go 1 deletes several packages outright:
-</p>
-
-<ul>
-<li><code>container/vector</code></li>
-<li><code>exp/datafmt</code></li>
-<li><code>go/typechecker</code></li>
-<li><code>old/regexp</code></li>
-<li><code>old/template</code></li>
-<li><code>try</code></li>
-</ul>
-
-<p>
-and also the command <code>gotry</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses <code>container/vector</code> should be updated to use
-slices directly.  See
-<a href="//code.google.com/p/go-wiki/wiki/SliceTricks">the Go
-Language Community Wiki</a> for some suggestions.
-Code that uses the other packages (there should be almost zero) will need to be rethought.
-</p>
-
-<h3 id="subrepo">Packages moving to subrepositories</h3>
-
-<p>
-Go 1 has moved a number of packages into other repositories, usually sub-repositories of
-<a href="//code.google.com/p/go/">the main Go repository</a>.
-This table lists the old and new import paths:
-
-<table class="codetable" frame="border" summary="Sub-repositories">
-<colgroup align="left" width="40%"></colgroup>
-<colgroup align="left" width="60%"></colgroup>
-<tr>
-<th align="left">Old</th>
-<th align="left">New</th>
-</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>crypto/bcrypt</td> <td>code.google.com/p/go.crypto/bcrypt</tr>
-<tr><td>crypto/blowfish</td> <td>code.google.com/p/go.crypto/blowfish</tr>
-<tr><td>crypto/cast5</td> <td>code.google.com/p/go.crypto/cast5</tr>
-<tr><td>crypto/md4</td> <td>code.google.com/p/go.crypto/md4</tr>
-<tr><td>crypto/ocsp</td> <td>code.google.com/p/go.crypto/ocsp</tr>
-<tr><td>crypto/openpgp</td> <td>code.google.com/p/go.crypto/openpgp</tr>
-<tr><td>crypto/openpgp/armor</td> <td>code.google.com/p/go.crypto/openpgp/armor</tr>
-<tr><td>crypto/openpgp/elgamal</td> <td>code.google.com/p/go.crypto/openpgp/elgamal</tr>
-<tr><td>crypto/openpgp/errors</td> <td>code.google.com/p/go.crypto/openpgp/errors</tr>
-<tr><td>crypto/openpgp/packet</td> <td>code.google.com/p/go.crypto/openpgp/packet</tr>
-<tr><td>crypto/openpgp/s2k</td> <td>code.google.com/p/go.crypto/openpgp/s2k</tr>
-<tr><td>crypto/ripemd160</td> <td>code.google.com/p/go.crypto/ripemd160</tr>
-<tr><td>crypto/twofish</td> <td>code.google.com/p/go.crypto/twofish</tr>
-<tr><td>crypto/xtea</td> <td>code.google.com/p/go.crypto/xtea</tr>
-<tr><td>exp/ssh</td> <td>code.google.com/p/go.crypto/ssh</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>image/bmp</td> <td>code.google.com/p/go.image/bmp</tr>
-<tr><td>image/tiff</td> <td>code.google.com/p/go.image/tiff</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>net/dict</td> <td>code.google.com/p/go.net/dict</tr>
-<tr><td>net/websocket</td> <td>code.google.com/p/go.net/websocket</tr>
-<tr><td>exp/spdy</td> <td>code.google.com/p/go.net/spdy</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>encoding/git85</td> <td>code.google.com/p/go.codereview/git85</tr>
-<tr><td>patch</td> <td>code.google.com/p/go.codereview/patch</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>exp/wingui</td> <td>code.google.com/p/gowingui</tr>
-</table>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update imports of these packages to use the new import paths.
-Installations that depend on these packages will need to install them using
-a <code>go get</code> command.
-</p>
-
-<h2 id="major">Major changes to the library</h2>
-
-<p>
-This section describes significant changes to the core libraries, the ones that
-affect the most programs.
-</p>
-
-<h3 id="errors">The error type and errors package</h3>
-
-<p>
-The placement of <code>os.Error</code> in package <code>os</code> is mostly historical: errors first came up when implementing package <code>os</code>, and they seemed system-related at the time.
-Since then it has become clear that errors are more fundamental than the operating system.  For example, it would be nice to use <code>Errors</code> in packages that <code>os</code> depends on, like <code>syscall</code>.
-Also, having <code>Error</code> in <code>os</code> introduces many dependencies on <code>os</code> that would otherwise not exist.
-</p>
-
-<p>
-Go 1 solves these problems by introducing a built-in <code>error</code> interface type and a separate <code>errors</code> package (analogous to <code>bytes</code> and <code>strings</code>) that contains utility functions.
-It replaces <code>os.NewError</code> with
-<a href="/pkg/errors/#New"><code>errors.New</code></a>,
-giving errors a more central place in the environment.
-</p>
-
-<p>
-So the widely-used <code>String</code> method does not cause accidental satisfaction
-of the <code>error</code> interface, the <code>error</code> interface uses instead
-the name <code>Error</code> for that method:
-</p>
-
-<pre>
-    type error interface {
-        Error() string
-    }
-</pre>
-
-<p>
-The <code>fmt</code> library automatically invokes <code>Error</code>, as it already
-does for <code>String</code>, for easy printing of error values.
-</p>
-
-{{code "/doc/progs/go1.go" `/START ERROR EXAMPLE/` `/END ERROR EXAMPLE/`}}
-
-<p>
-All standard packages have been updated to use the new interface; the old <code>os.Error</code> is gone.
-</p>
-
-<p>
-A new package, <a href="/pkg/errors/"><code>errors</code></a>, contains the function
-</p>
-
-<pre>
-func New(text string) error
-</pre>
-
-<p>
-to turn a string into an error. It replaces the old <code>os.NewError</code>.
-</p>
-
-{{code "/doc/progs/go1.go" `/ErrSyntax/`}}
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
-Code that defines error types with a <code>String</code> method will need to be updated
-by hand to rename the methods to <code>Error</code>.
-</p>
-
-<h3 id="errno">System call errors</h3>
-
-<p>
-The old <code>syscall</code> package, which predated <code>os.Error</code>
-(and just about everything else),
-returned errors as <code>int</code> values.
-In turn, the <code>os</code> package forwarded many of these errors, such
-as <code>EINVAL</code>, but using a different set of errors on each platform.
-This behavior was unpleasant and unportable.
-</p>
-
-<p>
-In Go 1, the
-<a href="/pkg/syscall/"><code>syscall</code></a>
-package instead returns an <code>error</code> for system call errors.
-On Unix, the implementation is done by a
-<a href="/pkg/syscall/#Errno"><code>syscall.Errno</code></a> type
-that satisfies <code>error</code> and replaces the old <code>os.Errno</code>.
-</p>
-
-<p>
-The changes affecting <code>os.EINVAL</code> and relatives are
-described <a href="#os">elsewhere</a>.
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
-Regardless, most code should use the <code>os</code> package
-rather than <code>syscall</code> and so will be unaffected.
-</p>
-
-<h3 id="time">Time</h3>
-
-<p>
-Time is always a challenge to support well in a programming language.
-The old Go <code>time</code> package had <code>int64</code> units, no
-real type safety,
-and no distinction between absolute times and durations.
-</p>
-
-<p>
-One of the most sweeping changes in the Go 1 library is therefore a
-complete redesign of the
-<a href="/pkg/time/"><code>time</code></a> package.
-Instead of an integer number of nanoseconds as an <code>int64</code>,
-and a separate <code>*time.Time</code> type to deal with human
-units such as hours and years,
-there are now two fundamental types:
-<a href="/pkg/time/#Time"><code>time.Time</code></a>
-(a value, so the <code>*</code> is gone), which represents a moment in time;
-and <a href="/pkg/time/#Duration"><code>time.Duration</code></a>,
-which represents an interval.
-Both have nanosecond resolution.
-A <code>Time</code> can represent any time into the ancient
-past and remote future, while a <code>Duration</code> can
-span plus or minus only about 290 years.
-There are methods on these types, plus a number of helpful
-predefined constant durations such as <code>time.Second</code>.
-</p>
-
-<p>
-Among the new methods are things like
-<a href="/pkg/time/#Time.Add"><code>Time.Add</code></a>,
-which adds a <code>Duration</code> to a <code>Time</code>, and
-<a href="/pkg/time/#Time.Sub"><code>Time.Sub</code></a>,
-which subtracts two <code>Times</code> to yield a <code>Duration</code>.
-</p>
-
-<p>
-The most important semantic change is that the Unix epoch (Jan 1, 1970) is now
-relevant only for those functions and methods that mention Unix:
-<a href="/pkg/time/#Unix"><code>time.Unix</code></a>
-and the <a href="/pkg/time/#Time.Unix"><code>Unix</code></a>
-and <a href="/pkg/time/#Time.UnixNano"><code>UnixNano</code></a> methods
-of the <code>Time</code> type.
-In particular,
-<a href="/pkg/time/#Now"><code>time.Now</code></a>
-returns a <code>time.Time</code> value rather than, in the old
-API, an integer nanosecond count since the Unix epoch.
-</p>
-
-{{code "/doc/progs/go1.go" `/sleepUntil/` `/^}/`}}
-
-<p>
-The new types, methods, and constants have been propagated through
-all the standard packages that use time, such as <code>os</code> and
-its representation of file time stamps.
-</p>
-
-<p>
-<em>Updating</em>:
-The <code>go</code> <code>fix</code> tool will update many uses of the old <code>time</code> package to use the new
-types and methods, although it does not replace values such as <code>1e9</code>
-representing nanoseconds per second.
-Also, because of type changes in some of the values that arise,
-some of the expressions rewritten by the fix tool may require
-further hand editing; in such cases the rewrite will include
-the correct function or method for the old functionality, but
-may have the wrong type or require further analysis.
-</p>
-
-<h2 id="minor">Minor changes to the library</h2>
-
-<p>
-This section describes smaller changes, such as those to less commonly
-used packages or that affect
-few programs beyond the need to run <code>go</code> <code>fix</code>.
-This category includes packages that are new in Go 1.
-Collectively they improve portability, regularize behavior, and
-make the interfaces more modern and Go-like.
-</p>
-
-<h3 id="archive_zip">The archive/zip package</h3>
-
-<p>
-In Go 1, <a href="/pkg/archive/zip/#Writer"><code>*zip.Writer</code></a> no
-longer has a <code>Write</code> method. Its presence was a mistake.
-</p>
-
-<p>
-<em>Updating</em>:
-What little code is affected will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="bufio">The bufio package</h3>
-
-<p>
-In Go 1, <a href="/pkg/bufio/#NewReaderSize"><code>bufio.NewReaderSize</code></a>
-and
-<a href="/pkg/bufio/#NewWriterSize"><code>bufio.NewWriterSize</code></a>
-functions no longer return an error for invalid sizes.
-If the argument size is too small or invalid, it is adjusted.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update calls that assign the error to _.
-Calls that aren't fixed will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="compress">The compress/flate, compress/gzip and compress/zlib packages</h3>
-
-<p>
-In Go 1, the <code>NewWriterXxx</code> functions in
-<a href="/pkg/compress/flate"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip"><code>compress/gzip</code></a> and
-<a href="/pkg/compress/zlib"><code>compress/zlib</code></a>
-all return <code>(*Writer, error)</code> if they take a compression level,
-and <code>*Writer</code> otherwise. Package <code>gzip</code>'s
-<code>Compressor</code> and <code>Decompressor</code> types have been renamed
-to <code>Writer</code> and <code>Reader</code>. Package <code>flate</code>'s
-<code>WrongValueError</code> type has been removed.
-</p>
-
-<p>
-<em>Updating</em>
-Running <code>go</code> <code>fix</code> will update old names and calls that assign the error to _.
-Calls that aren't fixed will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="crypto_aes_des">The crypto/aes and crypto/des packages</h3>
-
-<p>
-In Go 1, the <code>Reset</code> method has been removed. Go does not guarantee
-that memory is not copied and therefore this method was misleading.
-</p>
-
-<p>
-The cipher-specific types <code>*aes.Cipher</code>, <code>*des.Cipher</code>,
-and <code>*des.TripleDESCipher</code> have been removed in favor of
-<code>cipher.Block</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Remove the calls to Reset. Replace uses of the specific cipher types with
-cipher.Block.
-</p>
-
-<h3 id="crypto_elliptic">The crypto/elliptic package</h3>
-
-<p>
-In Go 1, <a href="/pkg/crypto/elliptic/#Curve"><code>elliptic.Curve</code></a>
-has been made an interface to permit alternative implementations. The curve
-parameters have been moved to the
-<a href="/pkg/crypto/elliptic/#CurveParams"><code>elliptic.CurveParams</code></a>
-structure.
-</p>
-
-<p>
-<em>Updating</em>:
-Existing users of <code>*elliptic.Curve</code> will need to change to
-simply <code>elliptic.Curve</code>. Calls to <code>Marshal</code>,
-<code>Unmarshal</code> and <code>GenerateKey</code> are now functions
-in <code>crypto/elliptic</code> that take an <code>elliptic.Curve</code>
-as their first argument.
-</p>
-
-<h3 id="crypto_hmac">The crypto/hmac package</h3>
-
-<p>
-In Go 1, the hash-specific functions, such as <code>hmac.NewMD5</code>, have
-been removed from <code>crypto/hmac</code>. Instead, <code>hmac.New</code> takes
-a function that returns a <code>hash.Hash</code>, such as <code>md5.New</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will perform the needed changes.
-</p>
-
-<h3 id="crypto_x509">The crypto/x509 package</h3>
-
-<p>
-In Go 1, the
-<a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-function and
-<a href="/pkg/crypto/x509/#Certificate.CreateCRL"><code>CreateCRL</code></a>
-method in <code>crypto/x509</code> have been altered to take an
-<code>interface{}</code> where they previously took a <code>*rsa.PublicKey</code>
-or <code>*rsa.PrivateKey</code>. This will allow other public key algorithms
-to be implemented in the future.
-</p>
-
-<p>
-<em>Updating</em>:
-No changes will be needed.
-</p>
-
-<h3 id="encoding_binary">The encoding/binary package</h3>
-
-<p>
-In Go 1, the <code>binary.TotalSize</code> function has been replaced by
-<a href="/pkg/encoding/binary/#Size"><code>Size</code></a>,
-which takes an <code>interface{}</code> argument rather than
-a <code>reflect.Value</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-What little code is affected will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="encoding_xml">The encoding/xml package</h3>
-
-<p>
-In Go 1, the <a href="/pkg/encoding/xml/"><code>xml</code></a> package
-has been brought closer in design to the other marshaling packages such
-as <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>.
-</p>
-
-<p>
-The old <code>Parser</code> type is renamed
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> and has a new
-<a href="/pkg/encoding/xml/#Decoder.Decode"><code>Decode</code></a> method. An
-<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a> type was also introduced.
-</p>
-
-<p>
-The functions <a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
-and <a href="/pkg/encoding/xml/#Unmarshal"><code>Unmarshal</code></a>
-work with <code>[]byte</code> values now. To work with streams,
-use the new <a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>
-and <a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> types.
-</p>
-
-<p>
-When marshaling or unmarshaling values, the format of supported flags in
-field tags has changed to be closer to the
-<a href="/pkg/encoding/json"><code>json</code></a> package
-(<code>`xml:"name,flag"`</code>). The matching done between field tags, field
-names, and the XML attribute and element names is now case-sensitive.
-The <code>XMLName</code> field tag, if present, must also match the name
-of the XML element being marshaled.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update most uses of the package except for some calls to
-<code>Unmarshal</code>. Special care must be taken with field tags,
-since the fix tool will not update them and if not fixed by hand they will
-misbehave silently in some cases. For example, the old
-<code>"attr"</code> is now written <code>",attr"</code> while plain
-<code>"attr"</code> remains valid but with a different meaning.
-</p>
-
-<h3 id="expvar">The expvar package</h3>
-
-<p>
-In Go 1, the <code>RemoveAll</code> function has been removed.
-The <code>Iter</code> function and Iter method on <code>*Map</code> have
-been replaced by
-<a href="/pkg/expvar/#Do"><code>Do</code></a>
-and
-<a href="/pkg/expvar/#Map.Do"><code>(*Map).Do</code></a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Most code using <code>expvar</code> will not need changing. The rare code that used
-<code>Iter</code> can be updated to pass a closure to <code>Do</code> to achieve the same effect.
-</p>
-
-<h3 id="flag">The flag package</h3>
-
-<p>
-In Go 1, the interface <a href="/pkg/flag/#Value"><code>flag.Value</code></a> has changed slightly.
-The <code>Set</code> method now returns an <code>error</code> instead of
-a <code>bool</code> to indicate success or failure.
-</p>
-
-<p>
-There is also a new kind of flag, <code>Duration</code>, to support argument
-values specifying time intervals.
-Values for such flags must be given units, just as <code>time.Duration</code>
-formats them: <code>10s</code>, <code>1h30m</code>, etc.
-</p>
-
-{{code "/doc/progs/go1.go" `/timeout/`}}
-
-<p>
-<em>Updating</em>:
-Programs that implement their own flags will need minor manual fixes to update their
-<code>Set</code> methods.
-The <code>Duration</code> flag is new and affects no existing code.
-</p>
-
-
-<h3 id="go">The go/* packages</h3>
-
-<p>
-Several packages under <code>go</code> have slightly revised APIs.
-</p>
-
-<p>
-A concrete <code>Mode</code> type was introduced for configuration mode flags
-in the packages
-<a href="/pkg/go/scanner/"><code>go/scanner</code></a>,
-<a href="/pkg/go/parser/"><code>go/parser</code></a>,
-<a href="/pkg/go/printer/"><code>go/printer</code></a>, and
-<a href="/pkg/go/doc/"><code>go/doc</code></a>.
-</p>
-
-<p>
-The modes <code>AllowIllegalChars</code> and <code>InsertSemis</code> have been removed
-from the <a href="/pkg/go/scanner/"><code>go/scanner</code></a> package. They were mostly
-useful for scanning text other then Go source files. Instead, the
-<a href="/pkg/text/scanner/"><code>text/scanner</code></a> package should be used
-for that purpose.
-</p>
-
-<p>
-The <a href="/pkg/go/scanner/#ErrorHandler"><code>ErrorHandler</code></a> provided
-to the scanner's <a href="/pkg/go/scanner/#Scanner.Init"><code>Init</code></a> method is
-now simply a function rather than an interface. The <code>ErrorVector</code> type has
-been removed in favor of the (existing) <a href="/pkg/go/scanner/#ErrorList"><code>ErrorList</code></a>
-type, and the <code>ErrorVector</code> methods have been migrated. Instead of embedding
-an <code>ErrorVector</code> in a client of the scanner, now a client should maintain
-an <code>ErrorList</code>.
-</p>
-
-<p>
-The set of parse functions provided by the <a href="/pkg/go/parser/"><code>go/parser</code></a>
-package has been reduced to the primary parse function
-<a href="/pkg/go/parser/#ParseFile"><code>ParseFile</code></a>, and a couple of
-convenience functions <a href="/pkg/go/parser/#ParseDir"><code>ParseDir</code></a>
-and <a href="/pkg/go/parser/#ParseExpr"><code>ParseExpr</code></a>.
-</p>
-
-<p>
-The <a href="/pkg/go/printer/"><code>go/printer</code></a> package supports an additional
-configuration mode <a href="/pkg/go/printer/#Mode"><code>SourcePos</code></a>;
-if set, the printer will emit <code>//line</code> comments such that the generated
-output contains the original source code position information. The new type
-<a href="/pkg/go/printer/#CommentedNode"><code>CommentedNode</code></a> can be
-used to provide comments associated with an arbitrary
-<a href="/pkg/go/ast/#Node"><code>ast.Node</code></a> (until now only
-<a href="/pkg/go/ast/#File"><code>ast.File</code></a> carried comment information).
-</p>
-
-<p>
-The type names of the <a href="/pkg/go/doc/"><code>go/doc</code></a> package have been
-streamlined by removing the <code>Doc</code> suffix: <code>PackageDoc</code>
-is now <code>Package</code>, <code>ValueDoc</code> is <code>Value</code>, etc.
-Also, all types now consistently have a <code>Name</code> field (or <code>Names</code>,
-in the case of type <code>Value</code>) and <code>Type.Factories</code> has become
-<code>Type.Funcs</code>.
-Instead of calling <code>doc.NewPackageDoc(pkg, importpath)</code>,
-documentation for a package is created with:
-</p>
-
-<pre>
-    doc.New(pkg, importpath, mode)
-</pre>
-
-<p>
-where the new <code>mode</code> parameter specifies the operation mode:
-if set to <a href="/pkg/go/doc/#AllDecls"><code>AllDecls</code></a>, all declarations
-(not just exported ones) are considered.
-The function <code>NewFileDoc</code> was removed, and the function
-<code>CommentText</code> has become the method
-<a href="/pkg/go/ast/#CommentGroup.Text"><code>Text</code></a> of
-<a href="/pkg/go/ast/#CommentGroup"><code>ast.CommentGroup</code></a>.
-</p>
-
-<p>
-In package <a href="/pkg/go/token/"><code>go/token</code></a>, the
-<a href="/pkg/go/token/#FileSet"><code>token.FileSet</code></a> method <code>Files</code>
-(which originally returned a channel of <code>*token.File</code>s) has been replaced
-with the iterator <a href="/pkg/go/token/#FileSet.Iterate"><code>Iterate</code></a> that
-accepts a function argument instead.
-</p>
-
-<p>
-In package <a href="/pkg/go/build/"><code>go/build</code></a>, the API
-has been nearly completely replaced.
-The package still computes Go package information
-but it does not run the build: the <code>Cmd</code> and <code>Script</code>
-types are gone.
-(To build code, use the new
-<a href="/cmd/go/"><code>go</code></a> command instead.)
-The <code>DirInfo</code> type is now named
-<a href="/pkg/go/build/#Package"><code>Package</code></a>.
-<code>FindTree</code> and <code>ScanDir</code> are replaced by
-<a href="/pkg/go/build/#Import"><code>Import</code></a>
-and
-<a href="/pkg/go/build/#ImportDir"><code>ImportDir</code></a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses packages in <code>go</code> will have to be updated by hand; the
-compiler will reject incorrect uses. Templates used in conjunction with any of the
-<code>go/doc</code> types may need manual fixes; the renamed fields will lead
-to run-time errors.
-</p>
-
-<h3 id="hash">The hash package</h3>
-
-<p>
-In Go 1, the definition of <a href="/pkg/hash/#Hash"><code>hash.Hash</code></a> includes
-a new method, <code>BlockSize</code>.  This new method is used primarily in the
-cryptographic libraries.
-</p>
-
-<p>
-The <code>Sum</code> method of the
-<a href="/pkg/hash/#Hash"><code>hash.Hash</code></a> interface now takes a
-<code>[]byte</code> argument, to which the hash value will be appended.
-The previous behavior can be recreated by adding a <code>nil</code> argument to the call.
-</p>
-
-<p>
-<em>Updating</em>:
-Existing implementations of <code>hash.Hash</code> will need to add a
-<code>BlockSize</code> method.  Hashes that process the input one byte at
-a time can implement <code>BlockSize</code> to return 1.
-Running <code>go</code> <code>fix</code> will update calls to the <code>Sum</code> methods of the various
-implementations of <code>hash.Hash</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Since the package's functionality is new, no updating is necessary.
-</p>
-
-<h3 id="http">The http package</h3>
-
-<p>
-In Go 1 the <a href="/pkg/net/http/"><code>http</code></a> package is refactored,
-putting some of the utilities into a
-<a href="/pkg/net/http/httputil/"><code>httputil</code></a> subdirectory.
-These pieces are only rarely needed by HTTP clients.
-The affected items are:
-</p>
-
-<ul>
-<li>ClientConn</li>
-<li>DumpRequest</li>
-<li>DumpRequestOut</li>
-<li>DumpResponse</li>
-<li>NewChunkedReader</li>
-<li>NewChunkedWriter</li>
-<li>NewClientConn</li>
-<li>NewProxyClientConn</li>
-<li>NewServerConn</li>
-<li>NewSingleHostReverseProxy</li>
-<li>ReverseProxy</li>
-<li>ServerConn</li>
-</ul>
-
-<p>
-The <code>Request.RawURL</code> field has been removed; it was a
-historical artifact.
-</p>
-
-<p>
-The <code>Handle</code> and <code>HandleFunc</code>
-functions, and the similarly-named methods of <code>ServeMux</code>,
-now panic if an attempt is made to register the same pattern twice.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update the few programs that are affected except for
-uses of <code>RawURL</code>, which must be fixed by hand.
-</p>
-
-<h3 id="image">The image package</h3>
-
-<p>
-The <a href="/pkg/image/"><code>image</code></a> package has had a number of
-minor changes, rearrangements and renamings.
-</p>
-
-<p>
-Most of the color handling code has been moved into its own package,
-<a href="/pkg/image/color/"><code>image/color</code></a>.
-For the elements that moved, a symmetry arises; for instance,
-each pixel of an
-<a href="/pkg/image/#RGBA"><code>image.RGBA</code></a>
-is a
-<a href="/pkg/image/color/#RGBA"><code>color.RGBA</code></a>.
-</p>
-
-<p>
-The old <code>image/ycbcr</code> package has been folded, with some
-renamings, into the
-<a href="/pkg/image/"><code>image</code></a>
-and
-<a href="/pkg/image/color/"><code>image/color</code></a>
-packages.
-</p>
-
-<p>
-The old <code>image.ColorImage</code> type is still in the <code>image</code>
-package but has been renamed
-<a href="/pkg/image/#Uniform"><code>image.Uniform</code></a>,
-while <code>image.Tiled</code> has been removed.
-</p>
-
-<p>
-This table lists the renamings.
-</p>
-
-<table class="codetable" frame="border" summary="image renames">
-<colgroup align="left" width="50%"></colgroup>
-<colgroup align="left" width="50%"></colgroup>
-<tr>
-<th align="left">Old</th>
-<th align="left">New</th>
-</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>image.Color</td> <td>color.Color</td></tr>
-<tr><td>image.ColorModel</td> <td>color.Model</td></tr>
-<tr><td>image.ColorModelFunc</td> <td>color.ModelFunc</td></tr>
-<tr><td>image.PalettedColorModel</td> <td>color.Palette</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>image.RGBAColor</td> <td>color.RGBA</td></tr>
-<tr><td>image.RGBA64Color</td> <td>color.RGBA64</td></tr>
-<tr><td>image.NRGBAColor</td> <td>color.NRGBA</td></tr>
-<tr><td>image.NRGBA64Color</td> <td>color.NRGBA64</td></tr>
-<tr><td>image.AlphaColor</td> <td>color.Alpha</td></tr>
-<tr><td>image.Alpha16Color</td> <td>color.Alpha16</td></tr>
-<tr><td>image.GrayColor</td> <td>color.Gray</td></tr>
-<tr><td>image.Gray16Color</td> <td>color.Gray16</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>image.RGBAColorModel</td> <td>color.RGBAModel</td></tr>
-<tr><td>image.RGBA64ColorModel</td> <td>color.RGBA64Model</td></tr>
-<tr><td>image.NRGBAColorModel</td> <td>color.NRGBAModel</td></tr>
-<tr><td>image.NRGBA64ColorModel</td> <td>color.NRGBA64Model</td></tr>
-<tr><td>image.AlphaColorModel</td> <td>color.AlphaModel</td></tr>
-<tr><td>image.Alpha16ColorModel</td> <td>color.Alpha16Model</td></tr>
-<tr><td>image.GrayColorModel</td> <td>color.GrayModel</td></tr>
-<tr><td>image.Gray16ColorModel</td> <td>color.Gray16Model</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>ycbcr.RGBToYCbCr</td> <td>color.RGBToYCbCr</td></tr>
-<tr><td>ycbcr.YCbCrToRGB</td> <td>color.YCbCrToRGB</td></tr>
-<tr><td>ycbcr.YCbCrColorModel</td> <td>color.YCbCrModel</td></tr>
-<tr><td>ycbcr.YCbCrColor</td> <td>color.YCbCr</td></tr>
-<tr><td>ycbcr.YCbCr</td> <td>image.YCbCr</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>ycbcr.SubsampleRatio444</td> <td>image.YCbCrSubsampleRatio444</td></tr>
-<tr><td>ycbcr.SubsampleRatio422</td> <td>image.YCbCrSubsampleRatio422</td></tr>
-<tr><td>ycbcr.SubsampleRatio420</td> <td>image.YCbCrSubsampleRatio420</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>image.ColorImage</td> <td>image.Uniform</td></tr>
-</table>
-
-<p>
-The image package's <code>New</code> functions
-(<a href="/pkg/image/#NewRGBA"><code>NewRGBA</code></a>,
-<a href="/pkg/image/#NewRGBA64"><code>NewRGBA64</code></a>, etc.)
-take an <a href="/pkg/image/#Rectangle"><code>image.Rectangle</code></a> as an argument
-instead of four integers.
-</p>
-
-<p>
-Finally, there are new predefined <code>color.Color</code> variables
-<a href="/pkg/image/color/#Black"><code>color.Black</code></a>,
-<a href="/pkg/image/color/#White"><code>color.White</code></a>,
-<a href="/pkg/image/color/#Opaque"><code>color.Opaque</code></a>
-and
-<a href="/pkg/image/color/#Transparent"><code>color.Transparent</code></a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
-</p>
-
-<h3 id="log_syslog">The log/syslog package</h3>
-
-<p>
-In Go 1, the <a href="/pkg/log/syslog/#NewLogger"><code>syslog.NewLogger</code></a>
-function returns an error as well as a <code>log.Logger</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-What little code is affected will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="mime">The mime package</h3>
-
-<p>
-In Go 1, the <a href="/pkg/mime/#FormatMediaType"><code>FormatMediaType</code></a> function
-of the <code>mime</code> package has  been simplified to make it
-consistent with
-<a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a>.
-It now takes <code>"text/html"</code> rather than <code>"text"</code> and <code>"html"</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-What little code is affected will be caught by the compiler and must be updated by hand.
-</p>
-
-<h3 id="net">The net package</h3>
-
-<p>
-In Go 1, the various <code>SetTimeout</code>,
-<code>SetReadTimeout</code>, and <code>SetWriteTimeout</code> methods
-have been replaced with
-<a href="/pkg/net/#IPConn.SetDeadline"><code>SetDeadline</code></a>,
-<a href="/pkg/net/#IPConn.SetReadDeadline"><code>SetReadDeadline</code></a>, and
-<a href="/pkg/net/#IPConn.SetWriteDeadline"><code>SetWriteDeadline</code></a>,
-respectively.  Rather than taking a timeout value in nanoseconds that
-apply to any activity on the connection, the new methods set an
-absolute deadline (as a <code>time.Time</code> value) after which
-reads and writes will time out and no longer block.
-</p>
-
-<p>
-There are also new functions
-<a href="/pkg/net/#DialTimeout"><code>net.DialTimeout</code></a>
-to simplify timing out dialing a network address and
-<a href="/pkg/net/#ListenMulticastUDP"><code>net.ListenMulticastUDP</code></a>
-to allow multicast UDP to listen concurrently across multiple listeners.
-The <code>net.ListenMulticastUDP</code> function replaces the old
-<code>JoinGroup</code> and <code>LeaveGroup</code> methods.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses the old methods will fail to compile and must be updated by hand.
-The semantic change makes it difficult for the fix tool to update automatically.
-</p>
-
-<h3 id="os">The os package</h3>
-
-<p>
-The <code>Time</code> function has been removed; callers should use
-the <a href="/pkg/time/#Time"><code>Time</code></a> type from the
-<code>time</code> package.
-</p>
-
-<p>
-The <code>Exec</code> function has been removed; callers should use
-<code>Exec</code> from the <code>syscall</code> package, where available.
-</p>
-
-<p>
-The <code>ShellExpand</code> function has been renamed to <a
-href="/pkg/os/#ExpandEnv"><code>ExpandEnv</code></a>.
-</p>
-
-<p>
-The <a href="/pkg/os/#NewFile"><code>NewFile</code></a> function
-now takes a <code>uintptr</code> fd, instead of an <code>int</code>.
-The <a href="/pkg/os/#File.Fd"><code>Fd</code></a> method on files now
-also returns a <code>uintptr</code>.
-</p>
-
-<p>
-There are no longer error constants such as <code>EINVAL</code>
-in the <code>os</code> package, since the set of values varied with
-the underlying operating system. There are new portable functions like
-<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
-to test common error properties, plus a few new error values
-with more Go-like names, such as
-<a href="/pkg/os/#ErrPermission"><code>ErrPermission</code></a>
-and
-<a href="/pkg/os/#ErrNotExist"><code>ErrNotExist</code></a>.
-</p>
-
-<p>
-The <code>Getenverror</code> function has been removed. To distinguish
-between a non-existent environment variable and an empty string,
-use <a href="/pkg/os/#Environ"><code>os.Environ</code></a> or
-<a href="/pkg/syscall/#Getenv"><code>syscall.Getenv</code></a>.
-</p>
-
-
-<p>
-The <a href="/pkg/os/#Process.Wait"><code>Process.Wait</code></a> method has
-dropped its option argument and the associated constants are gone
-from the package.
-Also, the function <code>Wait</code> is gone; only the method of
-the <code>Process</code> type persists.
-</p>
-
-<p>
-The <code>Waitmsg</code> type returned by
-<a href="/pkg/os/#Process.Wait"><code>Process.Wait</code></a>
-has been replaced with a more portable
-<a href="/pkg/os/#ProcessState"><code>ProcessState</code></a>
-type with accessor methods to recover information about the
-process.
-Because of changes to <code>Wait</code>, the <code>ProcessState</code>
-value always describes an exited process.
-Portability concerns simplified the interface in other ways, but the values returned by the
-<a href="/pkg/os/#ProcessState.Sys"><code>ProcessState.Sys</code></a> and
-<a href="/pkg/os/#ProcessState.SysUsage"><code>ProcessState.SysUsage</code></a>
-methods can be type-asserted to underlying system-specific data structures such as
-<a href="/pkg/syscall/#WaitStatus"><code>syscall.WaitStatus</code></a> and
-<a href="/pkg/syscall/#Rusage"><code>syscall.Rusage</code></a> on Unix.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will drop a zero argument to <code>Process.Wait</code>.
-All other changes will be caught by the compiler and must be updated by hand.
-</p>
-
-<h4 id="os_fileinfo">The os.FileInfo type</h4>
-
-<p>
-Go 1 redefines the <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a> type,
-changing it from a struct to an interface:
-</p>
-
-<pre>
-    type FileInfo interface {
-        Name() string       // base name of the file
-        Size() int64        // length in bytes
-        Mode() FileMode     // file mode bits
-        ModTime() time.Time // modification time
-        IsDir() bool        // abbreviation for Mode().IsDir()
-        Sys() interface{}   // underlying data source (can return nil)
-    }
-</pre>
-
-<p>
-The file mode information has been moved into a subtype called
-<a href="/pkg/os/#FileMode"><code>os.FileMode</code></a>,
-a simple integer type with <code>IsDir</code>, <code>Perm</code>, and <code>String</code>
-methods.
-</p>
-
-<p>
-The system-specific details of file modes and properties such as (on Unix)
-i-number have been removed from <code>FileInfo</code> altogether.
-Instead, each operating system's <code>os</code> package provides an
-implementation of the <code>FileInfo</code> interface, which
-has a <code>Sys</code> method that returns the
-system-specific representation of file metadata.
-For instance, to discover the i-number of a file on a Unix system, unpack
-the <code>FileInfo</code> like this:
-</p>
-
-<pre>
-    fi, err := os.Stat("hello.go")
-    if err != nil {
-        log.Fatal(err)
-    }
-    // Check that it's a Unix file.
-    unixStat, ok := fi.Sys().(*syscall.Stat_t)
-    if !ok {
-        log.Fatal("hello.go: not a Unix file")
-    }
-    fmt.Printf("file i-number: %d\n", unixStat.Ino)
-</pre>
-
-<p>
-Assuming (which is unwise) that <code>"hello.go"</code> is a Unix file,
-the i-number expression could be contracted to
-</p>
-
-<pre>
-    fi.Sys().(*syscall.Stat_t).Ino
-</pre>
-
-<p>
-The vast majority of uses of <code>FileInfo</code> need only the methods
-of the standard interface.
-</p>
-
-<p>
-The <code>os</code> package no longer contains wrappers for the POSIX errors
-such as <code>ENOENT</code>.
-For the few programs that need to verify particular error conditions, there are
-now the boolean functions
-<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
-<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>
-and
-<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>.
-</p>
-
-{{code "/doc/progs/go1.go" `/os\.Open/` `/}/`}}
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update code that uses the old equivalent of the current <code>os.FileInfo</code>
-and <code>os.FileMode</code> API.
-Code that needs system-specific file details will need to be updated by hand.
-Code that uses the old POSIX error values from the <code>os</code> package
-will fail to compile and will also need to be updated by hand.
-</p>
-
-<h3 id="os_signal">The os/signal package</h3>
-
-<p>
-The <code>os/signal</code> package in Go 1 replaces the
-<code>Incoming</code> function, which returned a channel
-that received all incoming signals,
-with the selective <code>Notify</code> function, which asks
-for delivery of specific signals on an existing channel.
-</p>
-
-<p>
-<em>Updating</em>:
-Code must be updated by hand.
-A literal translation of
-</p>
-<pre>
-c := signal.Incoming()
-</pre>
-<p>
-is
-</p>
-<pre>
-c := make(chan os.Signal, 1)
-signal.Notify(c) // ask for all signals
-</pre>
-<p>
-but most code should list the specific signals it wants to handle instead:
-</p>
-<pre>
-c := make(chan os.Signal, 1)
-signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT)
-</pre>
-
-<h3 id="path_filepath">The path/filepath package</h3>
-
-<p>
-In Go 1, the <a href="/pkg/path/filepath/#Walk"><code>Walk</code></a> function of the
-<code>path/filepath</code> package
-has been changed to take a function value of type
-<a href="/pkg/path/filepath/#WalkFunc"><code>WalkFunc</code></a>
-instead of a <code>Visitor</code> interface value.
-<code>WalkFunc</code> unifies the handling of both files and directories.
-</p>
-
-<pre>
-    type WalkFunc func(path string, info os.FileInfo, err error) error
-</pre>
-
-<p>
-The <code>WalkFunc</code> function will be called even for files or directories that could not be opened;
-in such cases the error argument will describe the failure.
-If a directory's contents are to be skipped,
-the function should return the value <a href="/pkg/path/filepath/#pkg-variables"><code>filepath.SkipDir</code></a>
-</p>
-
-{{code "/doc/progs/go1.go" `/STARTWALK/` `/ENDWALK/`}}
-
-<p>
-<em>Updating</em>:
-The change simplifies most code but has subtle consequences, so affected programs
-will need to be updated by hand.
-The compiler will catch code using the old interface.
-</p>
-
-<h3 id="regexp">The regexp package</h3>
-
-<p>
-The <a href="/pkg/regexp/"><code>regexp</code></a> package has been rewritten.
-It has the same interface but the specification of the regular expressions
-it supports has changed from the old "egrep" form to that of
-<a href="//code.google.com/p/re2/">RE2</a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses the package should have its regular expressions checked by hand.
-</p>
-
-<h3 id="runtime">The runtime package</h3>
-
-<p>
-In Go 1, much of the API exported by package
-<code>runtime</code> has been removed in favor of
-functionality provided by other packages.
-Code using the <code>runtime.Type</code> interface
-or its specific concrete type implementations should
-now use package <a href="/pkg/reflect/"><code>reflect</code></a>.
-Code using <code>runtime.Semacquire</code> or <code>runtime.Semrelease</code>
-should use channels or the abstractions in package <a href="/pkg/sync/"><code>sync</code></a>.
-The <code>runtime.Alloc</code>, <code>runtime.Free</code>,
-and <code>runtime.Lookup</code> functions, an unsafe API created for
-debugging the memory allocator, have no replacement.
-</p>
-
-<p>
-Before, <code>runtime.MemStats</code> was a global variable holding
-statistics about memory allocation, and calls to <code>runtime.UpdateMemStats</code>
-ensured that it was up to date.
-In Go 1, <code>runtime.MemStats</code> is a struct type, and code should use
-<a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
-to obtain the current statistics.
-</p>
-
-<p>
-The package adds a new function,
-<a href="/pkg/runtime/#NumCPU"><code>runtime.NumCPU</code></a>, that returns the number of CPUs available
-for parallel execution, as reported by the operating system kernel.
-Its value can inform the setting of <code>GOMAXPROCS</code>.
-The <code>runtime.Cgocalls</code> and <code>runtime.Goroutines</code> functions
-have been renamed to <code>runtime.NumCgoCall</code> and <code>runtime.NumGoroutine</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update code for the function renamings.
-Other code will need to be updated by hand.
-</p>
-
-<h3 id="strconv">The strconv package</h3>
-
-<p>
-In Go 1, the
-<a href="/pkg/strconv/"><code>strconv</code></a>
-package has been significantly reworked to make it more Go-like and less C-like,
-although <code>Atoi</code> lives on (it's similar to
-<code>int(ParseInt(x, 10, 0))</code>, as does
-<code>Itoa(x)</code> (<code>FormatInt(int64(x), 10)</code>).
-There are also new variants of some of the functions that append to byte slices rather than
-return strings, to allow control over allocation.
-</p>
-
-<p>
-This table summarizes the renamings; see the
-<a href="/pkg/strconv/">package documentation</a>
-for full details.
-</p>
-
-<table class="codetable" frame="border" summary="strconv renames">
-<colgroup align="left" width="50%"></colgroup>
-<colgroup align="left" width="50%"></colgroup>
-<tr>
-<th align="left">Old call</th>
-<th align="left">New call</th>
-</tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Atob(x)</td> <td>ParseBool(x)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Atof32(x)</td> <td>ParseFloat(x, 32)§</td></tr>
-<tr><td>Atof64(x)</td> <td>ParseFloat(x, 64)</td></tr>
-<tr><td>AtofN(x, n)</td> <td>ParseFloat(x, n)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Atoi(x)</td> <td>Atoi(x)</td></tr>
-<tr><td>Atoi(x)</td> <td>ParseInt(x, 10, 0)§</td></tr>
-<tr><td>Atoi64(x)</td> <td>ParseInt(x, 10, 64)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Atoui(x)</td> <td>ParseUint(x, 10, 0)§</td></tr>
-<tr><td>Atoui64(x)</td> <td>ParseUint(x, 10, 64)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Btoi64(x, b)</td> <td>ParseInt(x, b, 64)</td></tr>
-<tr><td>Btoui64(x, b)</td> <td>ParseUint(x, b, 64)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Btoa(x)</td> <td>FormatBool(x)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Ftoa32(x, f, p)</td> <td>FormatFloat(float64(x), f, p, 32)</td></tr>
-<tr><td>Ftoa64(x, f, p)</td> <td>FormatFloat(x, f, p, 64)</td></tr>
-<tr><td>FtoaN(x, f, p, n)</td> <td>FormatFloat(x, f, p, n)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Itoa(x)</td> <td>Itoa(x)</td></tr>
-<tr><td>Itoa(x)</td> <td>FormatInt(int64(x), 10)</td></tr>
-<tr><td>Itoa64(x)</td> <td>FormatInt(x, 10)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Itob(x, b)</td> <td>FormatInt(int64(x), b)</td></tr>
-<tr><td>Itob64(x, b)</td> <td>FormatInt(x, b)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Uitoa(x)</td> <td>FormatUint(uint64(x), 10)</td></tr>
-<tr><td>Uitoa64(x)</td> <td>FormatUint(x, 10)</td></tr>
-<tr>
-<td colspan="2"><hr></td>
-</tr>
-<tr><td>Uitob(x, b)</td> <td>FormatUint(uint64(x), b)</td></tr>
-<tr><td>Uitob64(x, b)</td> <td>FormatUint(x, b)</td></tr>
-</table>
-
-<p>
-<em>Updating</em>:
-Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
-<br>
-§ <code>Atoi</code> persists but <code>Atoui</code> and <code>Atof32</code> do not, so
-they may require
-a cast that must be added by hand; the <code>go</code> <code>fix</code> tool will warn about it.
-</p>
-
-
-<h3 id="templates">The template packages</h3>
-
-<p>
-The <code>template</code> and <code>exp/template/html</code> packages have moved to
-<a href="/pkg/text/template/"><code>text/template</code></a> and
-<a href="/pkg/html/template/"><code>html/template</code></a>.
-More significant, the interface to these packages has been simplified.
-The template language is the same, but the concept of "template set" is gone
-and the functions and methods of the packages have changed accordingly,
-often by elimination.
-</p>
-
-<p>
-Instead of sets, a <code>Template</code> object
-may contain multiple named template definitions,
-in effect constructing
-name spaces for template invocation.
-A template can invoke any other template associated with it, but only those
-templates associated with it.
-The simplest way to associate templates is to parse them together, something
-made easier with the new structure of the packages.
-</p>
-
-<p>
-<em>Updating</em>:
-The imports will be updated by fix tool.
-Single-template uses will be otherwise be largely unaffected.
-Code that uses multiple templates in concert will need to be updated by hand.
-The <a href="/pkg/text/template/#pkg-examples">examples</a> in
-the documentation for <code>text/template</code> can provide guidance.
-</p>
-
-<h3 id="testing">The testing package</h3>
-
-<p>
-The testing package has a type, <code>B</code>, passed as an argument to benchmark functions.
-In Go 1, <code>B</code> has new methods, analogous to those of <code>T</code>, enabling
-logging and failure reporting.
-</p>
-
-{{code "/doc/progs/go1.go" `/func.*Benchmark/` `/^}/`}}
-
-<p>
-<em>Updating</em>:
-Existing code is unaffected, although benchmarks that use <code>println</code>
-or <code>panic</code> should be updated to use the new methods.
-</p>
-
-<h3 id="testing_script">The testing/script package</h3>
-
-<p>
-The testing/script package has been deleted. It was a dreg.
-</p>
-
-<p>
-<em>Updating</em>:
-No code is likely to be affected.
-</p>
-
-<h3 id="unsafe">The unsafe package</h3>
-
-<p>
-In Go 1, the functions
-<code>unsafe.Typeof</code>, <code>unsafe.Reflect</code>,
-<code>unsafe.Unreflect</code>, <code>unsafe.New</code>, and
-<code>unsafe.NewArray</code> have been removed;
-they duplicated safer functionality provided by
-package <a href="/pkg/reflect/"><code>reflect</code></a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code using these functions must be rewritten to use
-package <a href="/pkg/reflect/"><code>reflect</code></a>.
-The changes to <a href="//golang.org/change/2646dc956207">encoding/gob</a> and the <a href="//code.google.com/p/goprotobuf/source/detail?r=5340ad310031">protocol buffer library</a>
-may be helpful as examples.
-</p>
-
-<h3 id="url">The url package</h3>
-
-<p>
-In Go 1 several fields from the <a href="/pkg/net/url/#URL"><code>url.URL</code></a> type
-were removed or replaced.
-</p>
-
-<p>
-The <a href="/pkg/net/url/#URL.String"><code>String</code></a> method now
-predictably rebuilds an encoded URL string using all of <code>URL</code>'s
-fields as necessary. The resulting string will also no longer have
-passwords escaped.
-</p>
-
-<p>
-The <code>Raw</code> field has been removed. In most cases the <code>String</code>
-method may be used in its place.
-</p>
-
-<p>
-The old <code>RawUserinfo</code> field is replaced by the <code>User</code>
-field, of type <a href="/pkg/net/url/#Userinfo"><code>*net.Userinfo</code></a>.
-Values of this type may be created using the new <a href="/pkg/net/url/#User"><code>net.User</code></a>
-and <a href="/pkg/net/url/#UserPassword"><code>net.UserPassword</code></a>
-functions. The <code>EscapeUserinfo</code> and <code>UnescapeUserinfo</code>
-functions are also gone.
-</p>
-
-<p>
-The <code>RawAuthority</code> field has been removed. The same information is
-available in the <code>Host</code> and <code>User</code> fields.
-</p>
-
-<p>
-The <code>RawPath</code> field and the <code>EncodedPath</code> method have
-been removed. The path information in rooted URLs (with a slash following the
-schema) is now available only in decoded form in the <code>Path</code> field.
-Occasionally, the encoded data may be required to obtain information that
-was lost in the decoding process. These cases must be handled by accessing
-the data the URL was built from.
-</p>
-
-<p>
-URLs with non-rooted paths, such as <code>"mailto:dev@golang.org?subject=Hi"</code>,
-are also handled differently. The <code>OpaquePath</code> boolean field has been
-removed and a new <code>Opaque</code> string field introduced to hold the encoded
-path for such URLs. In Go 1, the cited URL parses as:
-</p>
-
-<pre>
-    URL{
-        Scheme: "mailto",
-        Opaque: "dev@golang.org",
-        RawQuery: "subject=Hi",
-    }
-</pre>
-
-<p>
-A new <a href="/pkg/net/url/#URL.RequestURI"><code>RequestURI</code></a> method was
-added to <code>URL</code>.
-</p>
-
-<p>
-The <code>ParseWithReference</code> function has been renamed to <code>ParseWithFragment</code>.
-</p>
-
-<p>
-<em>Updating</em>:
-Code that uses the old fields will fail to compile and must be updated by hand.
-The semantic changes make it difficult for the fix tool to update automatically.
-</p>
-
-<h2 id="cmd_go">The go command</h2>
-
-<p>
-Go 1 introduces the <a href="/cmd/go/">go command</a>, a tool for fetching,
-building, and installing Go packages and commands. The <code>go</code> command
-does away with makefiles, instead using Go source code to find dependencies and
-determine build conditions. Most existing Go programs will no longer require
-makefiles to be built.
-</p>
-
-<p>
-See <a href="/doc/code.html">How to Write Go Code</a> for a primer on the
-<code>go</code> command and the <a href="/cmd/go/">go command documentation</a>
-for the full details.
-</p>
-
-<p>
-<em>Updating</em>:
-Projects that depend on the Go project's old makefile-based build
-infrastructure (<code>Make.pkg</code>, <code>Make.cmd</code>, and so on) should
-switch to using the <code>go</code> command for building Go code and, if
-necessary, rewrite their makefiles to perform any auxiliary build tasks.
-</p>
-
-<h2 id="cmd_cgo">The cgo command</h2>
-
-<p>
-In Go 1, the <a href="/cmd/cgo">cgo command</a>
-uses a different <code>_cgo_export.h</code>
-file, which is generated for packages containing <code>//export</code> lines.
-The <code>_cgo_export.h</code> file now begins with the C preamble comment,
-so that exported function definitions can use types defined there.
-This has the effect of compiling the preamble multiple times, so a
-package using <code>//export</code> must not put function definitions
-or variable initializations in the C preamble.
-</p>
-
-<h2 id="releases">Packaged releases</h2>
-
-<p>
-One of the most significant changes associated with Go 1 is the availability
-of prepackaged, downloadable distributions.
-They are available for many combinations of architecture and operating system
-(including Windows) and the list will grow.
-Installation details are described on the
-<a href="/doc/install">Getting Started</a> page, while
-the distributions themselves are listed on the
-<a href="/dl/">downloads page</a>.

diff --git a/doc/go1compat.html b/doc/go1compat.html
deleted file mode 100644 (file)
index a5624ef..0000000
--- a/doc/go1compat.html
+++ /dev/null
@@ -1,202 +0,0 @@
-<!--{
-       "Title": "Go 1 and the Future of Go Programs",
-       "Path":  "/doc/go1compat"
-}-->
-
-<h2 id="introduction">Introduction</h2>
-<p>
-The release of Go version 1, Go 1 for short, is a major milestone
-in the development of the language. Go 1 is a stable platform for
-the growth of programs and projects written in Go.
-</p>
-
-<p>
-Go 1 defines two things: first, the specification of the language;
-and second, the specification of a set of core APIs, the "standard
-packages" of the Go library. The Go 1 release includes their
-implementation in the form of two compiler suites (gc and gccgo),
-and the core libraries themselves.
-</p>
-
-<p>
-It is intended that programs written to the Go 1 specification will
-continue to compile and run correctly, unchanged, over the lifetime
-of that specification. At some indefinite point, a Go 2 specification
-may arise, but until that time, Go programs that work today should
-continue to work even as future "point" releases of Go 1 arise (Go
-1.1, Go 1.2, etc.).
-</p>
-
-<p>
-Compatibility is at the source level. Binary compatibility for
-compiled packages is not guaranteed between releases. After a point
-release, Go source will need to be recompiled to link against the
-new release.
-</p>
-
-<p>
-The APIs may grow, acquiring new packages and features, but not in
-a way that breaks existing Go 1 code.
-</p>
-
-<h2 id="expectations">Expectations</h2>
-
-<p>
-Although we expect that the vast majority of programs will maintain
-this compatibility over time, it is impossible to guarantee that
-no future change will break any program. This document is an attempt
-to set expectations for the compatibility of Go 1 software in the
-future. There are a number of ways in which a program that compiles
-and runs today may fail to do so after a future point release. They
-are all unlikely but worth recording.
-</p>
-
-<ul>
-<li>
-Security. A security issue in the specification or implementation
-may come to light whose resolution requires breaking compatibility.
-We reserve the right to address such security issues.
-</li>
-
-<li>
-Unspecified behavior. The Go specification tries to be explicit
-about most properties of the language, but there are some aspects
-that are undefined. Programs that depend on such unspecified behavior
-may break in future releases.
-</li>
-
-<li>
-Specification errors. If it becomes necessary to address an
-inconsistency or incompleteness in the specification, resolving the
-issue could affect the meaning or legality of existing programs.
-We reserve the right to address such issues, including updating the
-implementations. Except for security issues, no incompatible changes
-to the specification would be made.
-</li>
-
-<li>
-Bugs. If a compiler or library has a bug that violates the
-specification, a program that depends on the buggy behavior may
-break if the bug is fixed. We reserve the right to fix such bugs.
-</li>
-
-<li>
-Struct literals. For the addition of features in later point
-releases, it may be necessary to add fields to exported structs in
-the API. Code that uses unkeyed struct literals (such as pkg.T{3,
-"x"}) to create values of these types would fail to compile after
-such a change. However, code that uses keyed literals (pkg.T{A:
-3, B: "x"}) will continue to compile after such a change. We will
-update such data structures in a way that allows keyed struct
-literals to remain compatible, although unkeyed literals may fail
-to compile. (There are also more intricate cases involving nested
-data structures or interfaces, but they have the same resolution.)
-We therefore recommend that composite literals whose type is defined
-in a separate package should use the keyed notation.
-</li>
-
-<li>
-Methods. As with struct fields, it may be necessary to add methods
-to types.
-Under some circumstances, such as when the type is embedded in
-a struct along with another type,
-the addition of the new method may break
-the struct by creating a conflict with an existing method of the other
-embedded type.
-We cannot protect against this rare case and do not guarantee compatibility
-should it arise.
-</li>
-
-<li>
-Dot imports. If a program imports a standard package
-using <code>import . "path"</code>, additional names defined in the
-imported package in future releases may conflict with other names
-defined in the program.  We do not recommend the use of <code>import .</code>
-outside of tests, and using it may cause a program to fail
-to compile in future releases.
-</li>
-
-<li>
-Use of package <code>unsafe</code>. Packages that import
-<a href="/pkg/unsafe/"><code>unsafe</code></a>
-may depend on internal properties of the Go implementation.
-We reserve the right to make changes to the implementation
-that may break such programs.
-</li>
-
-</ul>
-
-<p>
-Of course, for all of these possibilities, should they arise, we
-would endeavor whenever feasible to update the specification,
-compilers, or libraries without affecting existing code.
-</p>
-
-<p>
-These same considerations apply to successive point releases. For
-instance, code that runs under Go 1.2 should be compatible with Go
-1.2.1, Go 1.3, Go 1.4, etc., although not necessarily with Go 1.1
-since it may use features added only in Go 1.2
-</p>
-
-<p>
-Features added between releases, available in the source repository
-but not part of the numbered binary releases, are under active
-development. No promise of compatibility is made for software using
-such features until they have been released.
-</p>
-
-<p>
-Finally, although it is not a correctness issue, it is possible
-that the performance of a program may be affected by
-changes in the implementation of the compilers or libraries upon
-which it depends.
-No guarantee can be made about the performance of a
-given program between releases.
-</p>
-
-<p>
-Although these expectations apply to Go 1 itself, we hope similar
-considerations would be made for the development of externally
-developed software based on Go 1.
-</p>
-
-<h2 id="subrepos">Sub-repositories</h2>
-
-<p>
-Code in sub-repositories of the main go tree, such as
-<a href="//golang.org/x/net">golang.org/x/net</a>,
-may be developed under
-looser compatibility requirements. However, the sub-repositories
-will be tagged as appropriate to identify versions that are compatible
-with the Go 1 point releases.
-</p>
-
-<h2 id="operating_systems">Operating systems</h2>
-
-<p>
-It is impossible to guarantee long-term compatibility with operating
-system interfaces, which are changed by outside parties.
-The <a href="/pkg/syscall/"><code>syscall</code></a> package
-is therefore outside the purview of the guarantees made here.
-As of Go version 1.4, the <code>syscall</code> package is frozen.
-Any evolution of the system call interface must be supported elsewhere,
-such as in the
-<a href="//golang.org/x/sys">go.sys</a> subrepository.
-For details and background, see
-<a href="//golang.org/s/go1.4-syscall">this document</a>.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<p>
-Finally, the Go toolchain (compilers, linkers, build tools, and so
-on) is under active development and may change behavior. This
-means, for instance, that scripts that depend on the location and
-properties of the tools may be broken by a point release.
-</p>
-
-<p>
-These caveats aside, we believe that Go 1 will be a firm foundation
-for the development of Go and its ecosystem.
-</p>

diff --git a/doc/go_faq.html b/doc/go_faq.html
deleted file mode 100644 (file)
index 23a3080..0000000
--- a/doc/go_faq.html
+++ /dev/null
@@ -1,2475 +0,0 @@
-<!--{
-       "Title": "Frequently Asked Questions (FAQ)",
-       "Path": "/doc/faq"
-}-->
-
-<h2 id="Origins">Origins</h2>
-
-<h3 id="What_is_the_purpose_of_the_project">
-What is the purpose of the project?</h3>
-
-<p>
-At the time of Go's inception, only a decade ago, the programming world was different from today.
-Production software was usually written in C++ or Java,
-GitHub did not exist, most computers were not yet multiprocessors,
-and other than Visual Studio and Eclipse there were few IDEs or other high-level tools available
-at all, let alone for free on the Internet.
-</p>
-
-<p>
-Meanwhile, we had become frustrated by the undue complexity required to use
-the languages we worked with to develop server software.
-Computers had become enormously quicker since languages such as
-C, C++ and Java were first developed but the act of programming had not
-itself advanced nearly as much.
-Also, it was clear that multiprocessors were becoming universal but
-most languages offered little help to program them efficiently
-and safely.
-</p>
-
-<p>
-We decided to take a step back and think about what major issues were
-going to dominate software engineering in the years ahead as technology
-developed, and how a new language might help address them.
-For instance, the rise of multicore CPUs argued that a language should
-provide first-class support for some sort of concurrency or parallelism.
-And to make resource management tractable in a large concurrent program,
-garbage collection, or at least some sort of safe automatic memory management was required.
-</p>
-
-<p>
-These considerations led to
-<a href="https://commandcenter.blogspot.com/2017/09/go-ten-years-and-climbing.html">a
-series of discussions</a> from which Go arose, first as a set of ideas and
-desiderata, then as a language.
-An overarching goal was that Go do more to help the working programmer
-by enabling tooling, automating mundane tasks such as code formatting,
-and removing obstacles to working on large code bases.
-</p>
-
-<p>
-A much more expansive description of the goals of Go and how
-they are met, or at least approached, is available in the article,
-<a href="//talks.golang.org/2012/splash.article">Go at Google:
-Language Design in the Service of Software Engineering</a>.
-</p>
-
-<h3 id="history">
-What is the history of the project?</h3>
-<p>
-Robert Griesemer, Rob Pike and Ken Thompson started sketching the
-goals for a new language on the white board on September 21, 2007.
-Within a few days the goals had settled into a plan to do something
-and a fair idea of what it would be.  Design continued part-time in
-parallel with unrelated work.  By January 2008, Ken had started work
-on a compiler with which to explore ideas; it generated C code as its
-output.  By mid-year the language had become a full-time project and
-had settled enough to attempt a production compiler.  In May 2008,
-Ian Taylor independently started on a GCC front end for Go using the
-draft specification.  Russ Cox joined in late 2008 and helped move the language
-and libraries from prototype to reality.
-</p>
-
-<p>
-Go became a public open source project on November 10, 2009.
-Countless people from the community have contributed ideas, discussions, and code.
-</p>
-
-<p>
-There are now millions of Go programmers—gophers—around the world,
-and there are more every day.
-Go's success has far exceeded our expectations.
-</p>
-
-<h3 id="gopher">
-What's the origin of the gopher mascot?</h3>
-
-<p>
-The mascot and logo were designed by
-<a href="https://reneefrench.blogspot.com">Renée French</a>, who also designed
-<a href="https://9p.io/plan9/glenda.html">Glenda</a>,
-the Plan 9 bunny.
-A <a href="https://blog.golang.org/gopher">blog post</a>
-about the gopher explains how it was
-derived from one she used for a <a href="https://wfmu.org/">WFMU</a>
-T-shirt design some years ago.
-The logo and mascot are covered by the
-<a href="https://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0</a>
-license.
-</p>
-
-<p>
-The gopher has a
-<a href="/doc/gopher/modelsheet.jpg">model sheet</a>
-illustrating his characteristics and how to represent them correctly.
-The model sheet was first shown in a
-<a href="https://www.youtube.com/watch?v=4rw_B4yY69k">talk</a>
-by Renée at Gophercon in 2016.
-He has unique features; he's the <em>Go gopher</em>, not just any old gopher.
-</p>
-
-<h3 id="go_or_golang">
-Is the language called Go or Golang?</h3>
-
-<p>
-The language is called Go.
-The "golang" moniker arose because the web site is
-<a href="https://golang.org">golang.org</a>, not
-go.org, which was not available to us.
-Many use the golang name, though, and it is handy as
-a label.
-For instance, the Twitter tag for the language is "#golang".
-The language's name is just plain Go, regardless.
-</p>
-
-<p>
-A side note: Although the
-<a href="https://blog.golang.org/go-brand">official logo</a>
-has two capital letters, the language name is written Go, not GO.
-</p>
-
-<h3 id="creating_a_new_language">
-Why did you create a new language?</h3>
-
-<p>
-Go was born out of frustration with existing languages and
-environments for the work we were doing at Google.
-Programming had become too
-difficult and the choice of languages was partly to blame.  One had to
-choose either efficient compilation, efficient execution, or ease of
-programming; all three were not available in the same mainstream
-language.  Programmers who could were choosing ease over
-safety and efficiency by moving to dynamically typed languages such as
-Python and JavaScript rather than C++ or, to a lesser extent, Java.
-</p>
-
-<p>
-We were not alone in our concerns.
-After many years with a pretty quiet landscape for programming languages,
-Go was among the first of several new languages—Rust,
-Elixir, Swift, and more—that have made programming language development
-an active, almost mainstream field again.
-</p>
-
-<p>
-Go addressed these issues by attempting to combine the ease of programming of an interpreted,
-dynamically typed
-language with the efficiency and safety of a statically typed, compiled language.
-It also aimed to be modern, with support for networked and multicore
-computing.  Finally, working with Go is intended to be <i>fast</i>: it should take
-at most a few seconds to build a large executable on a single computer.
-To meet these goals required addressing a number of
-linguistic issues: an expressive but lightweight type system;
-concurrency and garbage collection; rigid dependency specification;
-and so on.  These cannot be addressed well by libraries or tools; a new
-language was called for.
-</p>
-
-<p>
-The article <a href="//talks.golang.org/2012/splash.article">Go at Google</a>
-discusses the background and motivation behind the design of the Go language,
-as well as providing more detail about many of the answers presented in this FAQ.
-</p>
-
-
-<h3 id="ancestors">
-What are Go's ancestors?</h3>
-<p>
-Go is mostly in the C family (basic syntax),
-with significant input from the Pascal/Modula/Oberon
-family (declarations, packages),
-plus some ideas from languages
-inspired by Tony Hoare's CSP,
-such as Newsqueak and Limbo (concurrency).
-However, it is a new language across the board.
-In every respect the language was designed by thinking
-about what programmers do and how to make programming, at least the
-kind of programming we do, more effective, which means more fun.
-</p>
-
-<h3 id="principles">
-What are the guiding principles in the design?</h3>
-
-<p>
-When Go was designed, Java and C++ were the most commonly
-used languages for writing servers, at least at Google.
-We felt that these languages required
-too much bookkeeping and repetition.
-Some programmers reacted by moving towards more dynamic,
-fluid languages like Python, at the cost of efficiency and
-type safety.
-We felt it should be possible to have the efficiency,
-the safety, and the fluidity in a single language.
-</p>
-
-<p>
-Go attempts to reduce the amount of typing in both senses of the word.
-Throughout its design, we have tried to reduce clutter and
-complexity.  There are no forward declarations and no header files;
-everything is declared exactly once.  Initialization is expressive,
-automatic, and easy to use.  Syntax is clean and light on keywords.
-Stuttering (<code>foo.Foo* myFoo = new(foo.Foo)</code>) is reduced by
-simple type derivation using the <code>:=</code>
-declare-and-initialize construct.  And perhaps most radically, there
-is no type hierarchy: types just <i>are</i>, they don't have to
-announce their relationships.  These simplifications allow Go to be
-expressive yet comprehensible without sacrificing, well, sophistication.
-</p>
-<p>
-Another important principle is to keep the concepts orthogonal.
-Methods can be implemented for any type; structures represent data while
-interfaces represent abstraction; and so on.  Orthogonality makes it
-easier to understand what happens when things combine.
-</p>
-
-<h2 id="Usage">Usage</h2>
-
-<h3 id="internal_usage">
-Is Google using Go internally?</h3>
-
-<p>
-Yes. Go is used widely in production inside Google.
-One easy example is the server behind
-<a href="//golang.org">golang.org</a>.
-It's just the <a href="/cmd/godoc"><code>godoc</code></a>
-document server running in a production configuration on
-<a href="https://developers.google.com/appengine/">Google App Engine</a>.
-</p>
-
-<p>
-A more significant instance is Google's download server, <code>dl.google.com</code>,
-which delivers Chrome binaries and other large installables such as <code>apt-get</code>
-packages.
-</p>
-
-<p>
-Go is not the only language used at Google, far from it, but it is a key language
-for a number of areas including
-<a href="https://talks.golang.org/2013/go-sreops.slide">site reliability
-engineering (SRE)</a>
-and large-scale data processing.
-</p>
-
-<h3 id="external_usage">
-What other companies use Go?</h3>
-
-<p>
-Go usage is growing worldwide, especially but by no means exclusively
-in the cloud computing space.
-A couple of major cloud infrastructure projects written in Go are
-Docker and Kubernetes,
-but there are many more.
-</p>
-
-<p>
-It's not just cloud, though.
-The Go Wiki includes a
-<a href="https://github.com/golang/go/wiki/GoUsers">page</a>,
-updated regularly, that lists some of the many companies using Go.
-</p>
-
-<p>
-The Wiki also has a page with links to
-<a href="https://github.com/golang/go/wiki/SuccessStories">success stories</a>
-about companies and projects that are using the language.
-</p>
-
-<h3 id="Do_Go_programs_link_with_Cpp_programs">
-Do Go programs link with C/C++ programs?</h3>
-
-<p>
-It is possible to use C and Go together in the same address space,
-but it is not a natural fit and can require special interface software.
-Also, linking C with Go code gives up the memory
-safety and stack management properties that Go provides.
-Sometimes it's absolutely necessary to use C libraries to solve a problem,
-but doing so always introduces an element of risk not present with
-pure Go code, so do so with care.
-</p>
-
-<p>
-If you do need to use C with Go, how to proceed depends on the Go
-compiler implementation.
-There are three Go compiler implementations supported by the
-Go team.
-These are <code>gc</code>, the default compiler,
-<code>gccgo</code>, which uses the GCC back end,
-and a somewhat less mature <code>gollvm</code>, which uses the LLVM infrastructure.
-</p>
-
-<p>
-<code>Gc</code> uses a different calling convention and linker from C and
-therefore cannot be called directly from C programs, or vice versa.
-The <a href="/cmd/cgo/"><code>cgo</code></a> program provides the mechanism for a
-&ldquo;foreign function interface&rdquo; to allow safe calling of
-C libraries from Go code.
-SWIG extends this capability to C++ libraries.
-</p>
-
-<p>
-You can also use <code>cgo</code> and SWIG with <code>Gccgo</code> and <code>gollvm</code>.
-Since they use a traditional API, it's also possible, with great care,
-to link code from these compilers directly with GCC/LLVM-compiled C or C++ programs.
-However, doing so safely requires an understanding of the calling conventions for
-all languages concerned, as well as concern for stack limits when calling C or C++
-from Go.
-</p>
-
-<h3 id="ide">
-What IDEs does Go support?</h3>
-
-<p>
-The Go project does not include a custom IDE, but the language and
-libraries have been designed to make it easy to analyze source code.
-As a consequence, most well-known editors and IDEs support Go well,
-either directly or through a plugin.
-</p>
-
-<p>
-The list of well-known IDEs and editors that have good Go support
-available includes Emacs, Vim, VSCode, Atom, Eclipse, Sublime, IntelliJ
-(through a custom variant called Goland), and many more.
-Chances are your favorite environment is a productive one for
-programming in Go.
-</p>
-
-<h3 id="protocol_buffers">
-Does Go support Google's protocol buffers?</h3>
-
-<p>
-A separate open source project provides the necessary compiler plugin and library.
-It is available at
-<a href="//github.com/golang/protobuf">github.com/golang/protobuf/</a>.
-</p>
-
-
-<h3 id="Can_I_translate_the_Go_home_page">
-Can I translate the Go home page into another language?</h3>
-
-<p>
-Absolutely. We encourage developers to make Go Language sites in their own languages.
-However, if you choose to add the Google logo or branding to your site
-(it does not appear on <a href="//golang.org/">golang.org</a>),
-you will need to abide by the guidelines at
-<a href="//www.google.com/permissions/guidelines.html">www.google.com/permissions/guidelines.html</a>
-</p>
-
-<h2 id="Design">Design</h2>
-
-<h3 id="runtime">
-Does Go have a runtime?</h3>
-
-<p>
-Go does have an extensive library, called the <em>runtime</em>,
-that is part of every Go program.
-The runtime library implements garbage collection, concurrency,
-stack management, and other critical features of the Go language.
-Although it is more central to the language, Go's runtime is analogous
-to <code>libc</code>, the C library.
-</p>
-
-<p>
-It is important to understand, however, that Go's runtime does not
-include a virtual machine, such as is provided by the Java runtime.
-Go programs are compiled ahead of time to native machine code
-(or JavaScript or WebAssembly, for some variant implementations).
-Thus, although the term is often used to describe the virtual
-environment in which a program runs, in Go the word &ldquo;runtime&rdquo;
-is just the name given to the library providing critical language services.
-</p>
-
-<h3 id="unicode_identifiers">
-What's up with Unicode identifiers?</h3>
-
-<p>
-When designing Go, we wanted to make sure that it was not
-overly ASCII-centric,
-which meant extending the space of identifiers from the
-confines of 7-bit ASCII.
-Go's rule&mdash;identifier characters must be
-letters or digits as defined by Unicode&mdash;is simple to understand
-and to implement but has restrictions.
-Combining characters are
-excluded by design, for instance,
-and that excludes some languages such as Devanagari.
-</p>
-
-<p>
-This rule has one other unfortunate consequence.
-Since an exported identifier must begin with an
-upper-case letter, identifiers created from characters
-in some languages can, by definition, not be exported.
-For now the
-only solution is to use something like <code>X日本語</code>, which
-is clearly unsatisfactory.
-</p>
-
-<p>
-Since the earliest version of the language, there has been considerable
-thought into how best to expand the identifier space to accommodate
-programmers using other native languages.
-Exactly what to do remains an active topic of discussion, and a future
-version of the language may be more liberal in its definition
-of an identifier.
-For instance, it might adopt some of the ideas from the Unicode
-organization's <a href="http://unicode.org/reports/tr31/">recommendations</a>
-for identifiers.
-Whatever happens, it must be done compatibly while preserving
-(or perhaps expanding) the way letter case determines visibility of
-identifiers, which remains one of our favorite features of Go.
-</p>
-
-<p>
-For the time being, we have a simple rule that can be expanded later
-without breaking programs, one that avoids bugs that would surely arise
-from a rule that admits ambiguous identifiers.
-</p>
-
-<h3 id="Why_doesnt_Go_have_feature_X">Why does Go not have feature X?</h3>
-
-<p>
-Every language contains novel features and omits someone's favorite
-feature. Go was designed with an eye on felicity of programming, speed of
-compilation, orthogonality of concepts, and the need to support features
-such as concurrency and garbage collection. Your favorite feature may be
-missing because it doesn't fit, because it affects compilation speed or
-clarity of design, or because it would make the fundamental system model
-too difficult.
-</p>
-
-<p>
-If it bothers you that Go is missing feature <var>X</var>,
-please forgive us and investigate the features that Go does have. You might find that
-they compensate in interesting ways for the lack of <var>X</var>.
-</p>
-
-<h3 id="generics">
-Why does Go not have generic types?</h3>
-<p>
-Generics may well be added at some point.  We don't feel an urgency for
-them, although we understand some programmers do.
-</p>
-
-<p>
-Go was intended as a language for writing server programs that would be
-easy to maintain over time.
-(See <a href="https://talks.golang.org/2012/splash.article">this
-article</a> for more background.)
-The design concentrated on things like scalability, readability, and
-concurrency.
-Polymorphic programming did not seem essential to the language's
-goals at the time, and so was left out for simplicity.
-</p>
-
-<p>
-The language is more mature now, and there is scope to consider
-some form of generic programming.
-However, there remain some caveats.
-</p>
-
-<p>
-Generics are convenient but they come at a cost in
-complexity in the type system and run-time.  We haven't yet found a
-design that gives value proportionate to the complexity, although we
-continue to think about it.  Meanwhile, Go's built-in maps and slices,
-plus the ability to use the empty interface to construct containers
-(with explicit unboxing) mean in many cases it is possible to write
-code that does what generics would enable, if less smoothly.
-</p>
-
-<p>
-The topic remains open.
-For a look at several previous unsuccessful attempts to
-design a good generics solution for Go, see
-<a href="https://golang.org/issue/15292">this proposal</a>.
-</p>
-
-<h3 id="exceptions">
-Why does Go not have exceptions?</h3>
-<p>
-We believe that coupling exceptions to a control
-structure, as in the <code>try-catch-finally</code> idiom, results in
-convoluted code.  It also tends to encourage programmers to label
-too many ordinary errors, such as failing to open a file, as
-exceptional.
-</p>
-
-<p>
-Go takes a different approach.  For plain error handling, Go's multi-value
-returns make it easy to report an error without overloading the return value.
-<a href="/doc/articles/error_handling.html">A canonical error type, coupled
-with Go's other features</a>, makes error handling pleasant but quite different
-from that in other languages.
-</p>
-
-<p>
-Go also has a couple
-of built-in functions to signal and recover from truly exceptional
-conditions.  The recovery mechanism is executed only as part of a
-function's state being torn down after an error, which is sufficient
-to handle catastrophe but requires no extra control structures and,
-when used well, can result in clean error-handling code.
-</p>
-
-<p>
-See the <a href="/doc/articles/defer_panic_recover.html">Defer, Panic, and Recover</a> article for details.
-Also, the <a href="https://blog.golang.org/errors-are-values">Errors are values</a> blog post
-describes one approach to handling errors cleanly in Go by demonstrating that,
-since errors are just values, the full power of Go can be deployed in error handling.
-</p>
-
-<h3 id="assertions">
-Why does Go not have assertions?</h3>
-
-<p>
-Go doesn't provide assertions. They are undeniably convenient, but our
-experience has been that programmers use them as a crutch to avoid thinking
-about proper error handling and reporting. Proper error handling means that
-servers continue to operate instead of crashing after a non-fatal error.
-Proper error reporting means that errors are direct and to the point,
-saving the programmer from interpreting a large crash trace. Precise
-errors are particularly important when the programmer seeing the errors is
-not familiar with the code.
-</p>
-
-<p>
-We understand that this is a point of contention. There are many things in
-the Go language and libraries that differ from modern practices, simply
-because we feel it's sometimes worth trying a different approach.
-</p>
-
-<h3 id="csp">
-Why build concurrency on the ideas of CSP?</h3>
-<p>
-Concurrency and multi-threaded programming have over time
-developed a reputation for difficulty.  We believe this is due partly to complex
-designs such as
-<a href="https://en.wikipedia.org/wiki/POSIX_Threads">pthreads</a>
-and partly to overemphasis on low-level details
-such as mutexes, condition variables, and memory barriers.
-Higher-level interfaces enable much simpler code, even if there are still
-mutexes and such under the covers.
-</p>
-
-<p>
-One of the most successful models for providing high-level linguistic support
-for concurrency comes from Hoare's Communicating Sequential Processes, or CSP.
-Occam and Erlang are two well known languages that stem from CSP.
-Go's concurrency primitives derive from a different part of the family tree
-whose main contribution is the powerful notion of channels as first class objects.
-Experience with several earlier languages has shown that the CSP model
-fits well into a procedural language framework.
-</p>
-
-<h3 id="goroutines">
-Why goroutines instead of threads?</h3>
-<p>
-Goroutines are part of making concurrency easy to use.  The idea, which has
-been around for a while, is to multiplex independently executing
-functions&mdash;coroutines&mdash;onto a set of threads.
-When a coroutine blocks, such as by calling a blocking system call,
-the run-time automatically moves other coroutines on the same operating
-system thread to a different, runnable thread so they won't be blocked.
-The programmer sees none of this, which is the point.
-The result, which we call goroutines, can be very cheap: they have little
-overhead beyond the memory for the stack, which is just a few kilobytes.
-</p>
-
-<p>
-To make the stacks small, Go's run-time uses resizable, bounded stacks.  A newly
-minted goroutine is given a few kilobytes, which is almost always enough.
-When it isn't, the run-time grows (and shrinks) the memory for storing
-the stack automatically, allowing many goroutines to live in a modest
-amount of memory.
-The CPU overhead averages about three cheap instructions per function call.
-It is practical to create hundreds of thousands of goroutines in the same
-address space.
-If goroutines were just threads, system resources would
-run out at a much smaller number.
-</p>
-
-<h3 id="atomic_maps">
-Why are map operations not defined to be atomic?</h3>
-
-<p>
-After long discussion it was decided that the typical use of maps did not require
-safe access from multiple goroutines, and in those cases where it did, the map was
-probably part of some larger data structure or computation that was already
-synchronized.  Therefore requiring that all map operations grab a mutex would slow
-down most programs and add safety to few.  This was not an easy decision,
-however, since it means uncontrolled map access can crash the program.
-</p>
-
-<p>
-The language does not preclude atomic map updates.  When required, such
-as when hosting an untrusted program, the implementation could interlock
-map access.
-</p>
-
-<p>
-Map access is unsafe only when updates are occurring.
-As long as all goroutines are only reading—looking up elements in the map,
-including iterating through it using a
-<code>for</code> <code>range</code> loop—and not changing the map
-by assigning to elements or doing deletions,
-it is safe for them to access the map concurrently without synchronization.
-</p>
-
-<p>
-As an aid to correct map use, some implementations of the language
-contain a special check that automatically reports at run time when a map is modified
-unsafely by concurrent execution.
-</p>
-
-<h3 id="language_changes">
-Will you accept my language change?</h3>
-
-<p>
-People often suggest improvements to the language—the
-<a href="//groups.google.com/group/golang-nuts">mailing list</a>
-contains a rich history of such discussions—but very few of these changes have
-been accepted.
-</p>
-
-<p>
-Although Go is an open source project, the language and libraries are protected
-by a <a href="/doc/go1compat.html">compatibility promise</a> that prevents
-changes that break existing programs, at least at the source code level
-(programs may need to be recompiled occasionally to stay current).
-If your proposal violates the Go 1 specification we cannot even entertain the
-idea, regardless of its merit.
-A future major release of Go may be incompatible with Go 1, but discussions
-on that topic have only just begun and one thing is certain:
-there will be very few such incompatibilities introduced in the process.
-Moreover, the compatibility promise encourages us to provide an automatic path
-forward for old programs to adapt should that situation arise.
-</p>
-
-<p>
-Even if your proposal is compatible with the Go 1 spec, it might
-not be in the spirit of Go's design goals.
-The article <i><a href="//talks.golang.org/2012/splash.article">Go
-at Google: Language Design in the Service of Software Engineering</a></i>
-explains Go's origins and the motivation behind its design.
-</p>
-
-<h2 id="types">Types</h2>
-
-<h3 id="Is_Go_an_object-oriented_language">
-Is Go an object-oriented language?</h3>
-
-<p>
-Yes and no. Although Go has types and methods and allows an
-object-oriented style of programming, there is no type hierarchy.
-The concept of &ldquo;interface&rdquo; in Go provides a different approach that
-we believe is easy to use and in some ways more general. There are
-also ways to embed types in other types to provide something
-analogous&mdash;but not identical&mdash;to subclassing.
-Moreover, methods in Go are more general than in C++ or Java:
-they can be defined for any sort of data, even built-in types such
-as plain, &ldquo;unboxed&rdquo; integers.
-They are not restricted to structs (classes).
-</p>
-
-<p>
-Also, the lack of a type hierarchy makes &ldquo;objects&rdquo; in Go feel much more
-lightweight than in languages such as C++ or Java.
-</p>
-
-<h3 id="How_do_I_get_dynamic_dispatch_of_methods">
-How do I get dynamic dispatch of methods?</h3>
-
-<p>
-The only way to have dynamically dispatched methods is through an
-interface. Methods on a struct or any other concrete type are always resolved statically.
-</p>
-
-<h3 id="inheritance">
-Why is there no type inheritance?</h3>
-<p>
-Object-oriented programming, at least in the best-known languages,
-involves too much discussion of the relationships between types,
-relationships that often could be derived automatically.  Go takes a
-different approach.
-</p>
-
-<p>
-Rather than requiring the programmer to declare ahead of time that two
-types are related, in Go a type automatically satisfies any interface
-that specifies a subset of its methods.  Besides reducing the
-bookkeeping, this approach has real advantages.  Types can satisfy
-many interfaces at once, without the complexities of traditional
-multiple inheritance.
-Interfaces can be very lightweight&mdash;an interface with
-one or even zero methods can express a useful concept.
-Interfaces can be added after the fact if a new idea comes along
-or for testing&mdash;without annotating the original types.
-Because there are no explicit relationships between types
-and interfaces, there is no type hierarchy to manage or discuss.
-</p>
-
-<p>
-It's possible to use these ideas to construct something analogous to
-type-safe Unix pipes.  For instance, see how <code>fmt.Fprintf</code>
-enables formatted printing to any output, not just a file, or how the
-<code>bufio</code> package can be completely separate from file I/O,
-or how the <code>image</code> packages generate compressed
-image files.  All these ideas stem from a single interface
-(<code>io.Writer</code>) representing a single method
-(<code>Write</code>).  And that's only scratching the surface.
-Go's interfaces have a profound influence on how programs are structured.
-</p>
-
-<p>
-It takes some getting used to but this implicit style of type
-dependency is one of the most productive things about Go.
-</p>
-
-<h3 id="methods_on_basics">
-Why is <code>len</code> a function and not a method?</h3>
-<p>
-We debated this issue but decided
-implementing <code>len</code> and friends as functions was fine in practice and
-didn't complicate questions about the interface (in the Go type sense)
-of basic types.
-</p>
-
-<h3 id="overloading">
-Why does Go not support overloading of methods and operators?</h3>
-<p>
-Method dispatch is simplified if it doesn't need to do type matching as well.
-Experience with other languages told us that having a variety of
-methods with the same name but different signatures was occasionally useful
-but that it could also be confusing and fragile in practice.  Matching only by name
-and requiring consistency in the types was a major simplifying decision
-in Go's type system.
-</p>
-
-<p>
-Regarding operator overloading, it seems more a convenience than an absolute
-requirement.  Again, things are simpler without it.
-</p>
-
-<h3 id="implements_interface">
-Why doesn't Go have "implements" declarations?</h3>
-
-<p>
-A Go type satisfies an interface by implementing the methods of that interface,
-nothing more.  This property allows interfaces to be defined and used without
-needing to modify existing code.  It enables a kind of
-<a href="https://en.wikipedia.org/wiki/Structural_type_system">structural typing</a> that
-promotes separation of concerns and improves code re-use, and makes it easier
-to build on patterns that emerge as the code develops.
-The semantics of interfaces is one of the main reasons for Go's nimble,
-lightweight feel.
-</p>
-
-<p>
-See the <a href="#inheritance">question on type inheritance</a> for more detail.
-</p>
-
-<h3 id="guarantee_satisfies_interface">
-How can I guarantee my type satisfies an interface?</h3>
-
-<p>
-You can ask the compiler to check that the type <code>T</code> implements the
-interface <code>I</code> by attempting an assignment using the zero value for
-<code>T</code> or pointer to <code>T</code>, as appropriate:
-</p>
-
-<pre>
-type T struct{}
-var _ I = T{}       // Verify that T implements I.
-var _ I = (*T)(nil) // Verify that *T implements I.
-</pre>
-
-<p>
-If <code>T</code> (or <code>*T</code>, accordingly) doesn't implement
-<code>I</code>, the mistake will be caught at compile time.
-</p>
-
-<p>
-If you wish the users of an interface to explicitly declare that they implement
-it, you can add a method with a descriptive name to the interface's method set.
-For example:
-</p>
-
-<pre>
-type Fooer interface {
-    Foo()
-    ImplementsFooer()
-}
-</pre>
-
-<p>
-A type must then implement the <code>ImplementsFooer</code> method to be a
-<code>Fooer</code>, clearly documenting the fact and announcing it in
-<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol">go doc</a>'s output.
-</p>
-
-<pre>
-type Bar struct{}
-func (b Bar) ImplementsFooer() {}
-func (b Bar) Foo() {}
-</pre>
-
-<p>
-Most code doesn't make use of such constraints, since they limit the utility of
-the interface idea. Sometimes, though, they're necessary to resolve ambiguities
-among similar interfaces.
-</p>
-
-<h3 id="t_and_equal_interface">
-Why doesn't type T satisfy the Equal interface?</h3>
-
-<p>
-Consider this simple interface to represent an object that can compare
-itself with another value:
-</p>
-
-<pre>
-type Equaler interface {
-    Equal(Equaler) bool
-}
-</pre>
-
-<p>
-and this type, <code>T</code>:
-</p>
-
-<pre>
-type T int
-func (t T) Equal(u T) bool { return t == u } // does not satisfy Equaler
-</pre>
-
-<p>
-Unlike the analogous situation in some polymorphic type systems,
-<code>T</code> does not implement <code>Equaler</code>.
-The argument type of <code>T.Equal</code> is <code>T</code>,
-not literally the required type <code>Equaler</code>.
-</p>
-
-<p>
-In Go, the type system does not promote the argument of
-<code>Equal</code>; that is the programmer's responsibility, as
-illustrated by the type <code>T2</code>, which does implement
-<code>Equaler</code>:
-</p>
-
-<pre>
-type T2 int
-func (t T2) Equal(u Equaler) bool { return t == u.(T2) }  // satisfies Equaler
-</pre>
-
-<p>
-Even this isn't like other type systems, though, because in Go <em>any</em>
-type that satisfies <code>Equaler</code> could be passed as the
-argument to <code>T2.Equal</code>, and at run time we must
-check that the argument is of type <code>T2</code>.
-Some languages arrange to make that guarantee at compile time.
-</p>
-
-<p>
-A related example goes the other way:
-</p>
-
-<pre>
-type Opener interface {
-   Open() Reader
-}
-
-func (t T3) Open() *os.File
-</pre>
-
-<p>
-In Go, <code>T3</code> does not satisfy <code>Opener</code>,
-although it might in another language.
-</p>
-
-<p>
-While it is true that Go's type system does less for the programmer
-in such cases, the lack of subtyping makes the rules about
-interface satisfaction very easy to state: are the function's names
-and signatures exactly those of the interface?
-Go's rule is also easy to implement efficiently.
-We feel these benefits offset the lack of
-automatic type promotion. Should Go one day adopt some form of polymorphic
-typing, we expect there would be a way to express the idea of these
-examples and also have them be statically checked.
-</p>
-
-<h3 id="convert_slice_of_interface">
-Can I convert a []T to an []interface{}?</h3>
-
-<p>
-Not directly.
-It is disallowed by the language specification because the two types
-do not have the same representation in memory.
-It is necessary to copy the elements individually to the destination
-slice. This example converts a slice of <code>int</code> to a slice of
-<code>interface{}</code>:
-</p>
-
-<pre>
-t := []int{1, 2, 3, 4}
-s := make([]interface{}, len(t))
-for i, v := range t {
-    s[i] = v
-}
-</pre>
-
-<h3 id="convert_slice_with_same_underlying_type">
-Can I convert []T1 to []T2 if T1 and T2 have the same underlying type?</h3>
-
-This last line of this code sample does not compile.
-
-<pre>
-type T1 int
-type T2 int
-var t1 T1
-var x = T2(t1) // OK
-var st1 []T1
-var sx = ([]T2)(st1) // NOT OK
-</pre>
-
-<p>
-In Go, types are closely tied to methods, in that every named type has
-a (possibly empty) method set.
-The general rule is that you can change the name of the type being
-converted (and thus possibly change its method set) but you can't
-change the name (and method set) of elements of a composite type.
-Go requires you to be explicit about type conversions.
-</p>
-
-<h3 id="nil_error">
-Why is my nil error value not equal to nil?
-</h3>
-
-<p>
-Under the covers, interfaces are implemented as two elements, a type <code>T</code>
-and a value <code>V</code>.
-<code>V</code> is a concrete value such as an <code>int</code>,
-<code>struct</code> or pointer, never an interface itself, and has
-type <code>T</code>.
-For instance, if we store the <code>int</code> value 3 in an interface,
-the resulting interface value has, schematically,
-(<code>T=int</code>, <code>V=3</code>).
-The value <code>V</code> is also known as the interface's
-<em>dynamic</em> value,
-since a given interface variable might hold different values <code>V</code>
-(and corresponding types <code>T</code>)
-during the execution of the program.
-</p>
-
-<p>
-An interface value is <code>nil</code> only if the <code>V</code> and <code>T</code>
-are both unset, (<code>T=nil</code>, <code>V</code> is not set),
-In particular, a <code>nil</code> interface will always hold a <code>nil</code> type.
-If we store a <code>nil</code> pointer of type <code>*int</code> inside
-an interface value, the inner type will be <code>*int</code> regardless of the value of the pointer:
-(<code>T=*int</code>, <code>V=nil</code>).
-Such an interface value will therefore be non-<code>nil</code>
-<em>even when the pointer value <code>V</code> inside is</em> <code>nil</code>.
-</p>
-
-<p>
-This situation can be confusing, and arises when a <code>nil</code> value is
-stored inside an interface value such as an <code>error</code> return:
-</p>
-
-<pre>
-func returnsError() error {
-       var p *MyError = nil
-       if bad() {
-               p = ErrBad
-       }
-       return p // Will always return a non-nil error.
-}
-</pre>
-
-<p>
-If all goes well, the function returns a <code>nil</code> <code>p</code>,
-so the return value is an <code>error</code> interface
-value holding (<code>T=*MyError</code>, <code>V=nil</code>).
-This means that if the caller compares the returned error to <code>nil</code>,
-it will always look as if there was an error even if nothing bad happened.
-To return a proper <code>nil</code> <code>error</code> to the caller,
-the function must return an explicit <code>nil</code>:
-</p>
-
-
-<pre>
-func returnsError() error {
-       if bad() {
-               return ErrBad
-       }
-       return nil
-}
-</pre>
-
-<p>
-It's a good idea for functions
-that return errors always to use the <code>error</code> type in
-their signature (as we did above) rather than a concrete type such
-as <code>*MyError</code>, to help guarantee the error is
-created correctly. As an example,
-<a href="/pkg/os/#Open"><code>os.Open</code></a>
-returns an <code>error</code> even though, if not <code>nil</code>,
-it's always of concrete type
-<a href="/pkg/os/#PathError"><code>*os.PathError</code></a>.
-</p>
-
-<p>
-Similar situations to those described here can arise whenever interfaces are used.
-Just keep in mind that if any concrete value
-has been stored in the interface, the interface will not be <code>nil</code>.
-For more information, see
-<a href="/doc/articles/laws_of_reflection.html">The Laws of Reflection</a>.
-</p>
-
-
-<h3 id="unions">
-Why are there no untagged unions, as in C?</h3>
-
-<p>
-Untagged unions would violate Go's memory safety
-guarantees.
-</p>
-
-<h3 id="variant_types">
-Why does Go not have variant types?</h3>
-
-<p>
-Variant types, also known as algebraic types, provide a way to specify
-that a value might take one of a set of other types, but only those
-types. A common example in systems programming would specify that an
-error is, say, a network error, a security error or an application
-error and allow the caller to discriminate the source of the problem
-by examining the type of the error. Another example is a syntax tree
-in which each node can be a different type: declaration, statement,
-assignment and so on.
-</p>
-
-<p>
-We considered adding variant types to Go, but after discussion
-decided to leave them out because they overlap in confusing ways
-with interfaces. What would happen if the elements of a variant type
-were themselves interfaces?
-</p>
-
-<p>
-Also, some of what variant types address is already covered by the
-language. The error example is easy to express using an interface
-value to hold the error and a type switch to discriminate cases.  The
-syntax tree example is also doable, although not as elegantly.
-</p>
-
-<h3 id="covariant_types">
-Why does Go not have covariant result types?</h3>
-
-<p>
-Covariant result types would mean that an interface like
-</p>
-
-<pre>
-type Copyable interface {
-       Copy() interface{}
-}
-</pre>
-
-<p>
-would be satisfied by the method
-</p>
-
-<pre>
-func (v Value) Copy() Value
-</pre>
-
-<p>because <code>Value</code> implements the empty interface.
-In Go method types must match exactly, so <code>Value</code> does not
-implement <code>Copyable</code>.
-Go separates the notion of what a
-type does&mdash;its methods&mdash;from the type's implementation.
-If two methods return different types, they are not doing the same thing.
-Programmers who want covariant result types are often trying to
-express a type hierarchy through interfaces.
-In Go it's more natural to have a clean separation between interface
-and implementation.
-</p>
-
-<h2 id="values">Values</h2>
-
-<h3 id="conversions">
-Why does Go not provide implicit numeric conversions?</h3>
-
-<p>
-The convenience of automatic conversion between numeric types in C is
-outweighed by the confusion it causes.  When is an expression unsigned?
-How big is the value?  Does it overflow?  Is the result portable, independent
-of the machine on which it executes?
-It also complicates the compiler; &ldquo;the usual arithmetic conversions&rdquo;
-are not easy to implement and inconsistent across architectures.
-For reasons of portability, we decided to make things clear and straightforward
-at the cost of some explicit conversions in the code.
-The definition of constants in Go&mdash;arbitrary precision values free
-of signedness and size annotations&mdash;ameliorates matters considerably,
-though.
-</p>
-
-<p>
-A related detail is that, unlike in C, <code>int</code> and <code>int64</code>
-are distinct types even if <code>int</code> is a 64-bit type.  The <code>int</code>
-type is generic; if you care about how many bits an integer holds, Go
-encourages you to be explicit.
-</p>
-
-<h3 id="constants">
-How do constants work in Go?</h3>
-
-<p>
-Although Go is strict about conversion between variables of different
-numeric types, constants in the language are much more flexible.
-Literal constants such as <code>23</code>, <code>3.14159</code>
-and <a href="/pkg/math/#pkg-constants"><code>math.Pi</code></a>
-occupy a sort of ideal number space, with arbitrary precision and
-no overflow or underflow.
-For instance, the value of <code>math.Pi</code> is specified to 63 places
-in the source code, and constant expressions involving the value keep
-precision beyond what a <code>float64</code> could hold.
-Only when the constant or constant expression is assigned to a
-variable&mdash;a memory location in the program&mdash;does
-it become a "computer" number with
-the usual floating-point properties and precision.
-</p>
-
-<p>
-Also,
-because they are just numbers, not typed values, constants in Go can be
-used more freely than variables, thereby softening some of the awkwardness
-around the strict conversion rules.
-One can write expressions such as
-</p>
-
-<pre>
-sqrt2 := math.Sqrt(2)
-</pre>
-
-<p>
-without complaint from the compiler because the ideal number <code>2</code>
-can be converted safely and accurately
-to a <code>float64</code> for the call to <code>math.Sqrt</code>.
-</p>
-
-<p>
-A blog post titled <a href="https://blog.golang.org/constants">Constants</a>
-explores this topic in more detail.
-</p>
-
-<h3 id="builtin_maps">
-Why are maps built in?</h3>
-<p>
-The same reason strings are: they are such a powerful and important data
-structure that providing one excellent implementation with syntactic support
-makes programming more pleasant.  We believe that Go's implementation of maps
-is strong enough that it will serve for the vast majority of uses.
-If a specific application can benefit from a custom implementation, it's possible
-to write one but it will not be as convenient syntactically; this seems a reasonable tradeoff.
-</p>
-
-<h3 id="map_keys">
-Why don't maps allow slices as keys?</h3>
-<p>
-Map lookup requires an equality operator, which slices do not implement.
-They don't implement equality because equality is not well defined on such types;
-there are multiple considerations involving shallow vs. deep comparison, pointer vs.
-value comparison, how to deal with recursive types, and so on.
-We may revisit this issue&mdash;and implementing equality for slices
-will not invalidate any existing programs&mdash;but without a clear idea of what
-equality of slices should mean, it was simpler to leave it out for now.
-</p>
-
-<p>
-In Go 1, unlike prior releases, equality is defined for structs and arrays, so such
-types can be used as map keys. Slices still do not have a definition of equality, though.
-</p>
-
-<h3 id="references">
-Why are maps, slices, and channels references while arrays are values?</h3>
-<p>
-There's a lot of history on that topic.  Early on, maps and channels
-were syntactically pointers and it was impossible to declare or use a
-non-pointer instance.  Also, we struggled with how arrays should work.
-Eventually we decided that the strict separation of pointers and
-values made the language harder to use.  Changing these
-types to act as references to the associated, shared data structures resolved
-these issues. This change added some regrettable complexity to the
-language but had a large effect on usability: Go became a more
-productive, comfortable language when it was introduced.
-</p>
-
-<h2 id="Writing_Code">Writing Code</h2>
-
-<h3 id="How_are_libraries_documented">
-How are libraries documented?</h3>
-
-<p>
-There is a program, <code>godoc</code>, written in Go, that extracts
-package documentation from the source code and serves it as a web
-page with links to declarations, files, and so on.
-An instance is running at
-<a href="/pkg/">golang.org/pkg/</a>.
-In fact, <code>godoc</code> implements the full site at
-<a href="/">golang.org/</a>.
-</p>
-
-<p>
-A <code>godoc</code> instance may be configured to provide rich,
-interactive static analyses of symbols in the programs it displays; details are
-listed <a href="https://golang.org/lib/godoc/analysis/help.html">here</a>.
-</p>
-
-<p>
-For access to documentation from the command line, the
-<a href="https://golang.org/pkg/cmd/go/">go</a> tool has a
-<a href="https://golang.org/pkg/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
-subcommand that provides a textual interface to the same information.
-</p>
-
-<h3 id="Is_there_a_Go_programming_style_guide">
-Is there a Go programming style guide?</h3>
-
-<p>
-There is no explicit style guide, although there is certainly
-a recognizable "Go style".
-</p>
-
-<p>
-Go has established conventions to guide decisions around
-naming, layout, and file organization.
-The document <a href="effective_go.html">Effective Go</a>
-contains some advice on these topics.
-More directly, the program <code>gofmt</code> is a pretty-printer
-whose purpose is to enforce layout rules; it replaces the usual
-compendium of do's and don'ts that allows interpretation.
-All the Go code in the repository, and the vast majority in the
-open source world, has been run through <code>gofmt</code>.
-</p>
-
-<p>
-The document titled
-<a href="//golang.org/s/comments">Go Code Review Comments</a>
-is a collection of very short essays about details of Go idiom that are often
-missed by programmers.
-It is a handy reference for people doing code reviews for Go projects.
-</p>
-
-<h3 id="How_do_I_submit_patches_to_the_Go_libraries">
-How do I submit patches to the Go libraries?</h3>
-
-<p>
-The library sources are in the <code>src</code> directory of the repository.
-If you want to make a significant change, please discuss on the mailing list before embarking.
-</p>
-
-<p>
-See the document
-<a href="contribute.html">Contributing to the Go project</a>
-for more information about how to proceed.
-</p>
-
-<h3 id="git_https">
-Why does "go get" use HTTPS when cloning a repository?</h3>
-
-<p>
-Companies often permit outgoing traffic only on the standard TCP ports 80 (HTTP)
-and 443 (HTTPS), blocking outgoing traffic on other ports, including TCP port 9418
-(git) and TCP port 22 (SSH).
-When using HTTPS instead of HTTP, <code>git</code> enforces certificate validation by
-default, providing protection against man-in-the-middle, eavesdropping and tampering attacks.
-The <code>go get</code> command therefore uses HTTPS for safety.
-</p>
-
-<p>
-<code>Git</code> can be configured to authenticate over HTTPS or to use SSH in place of HTTPS.
-To authenticate over HTTPS, you can add a line
-to the <code>$HOME/.netrc</code> file that git consults:
-</p>
-<pre>
-machine github.com login <i>USERNAME</i> password <i>APIKEY</i>
-</pre>
-<p>
-For GitHub accounts, the password can be a
-<a href="https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/">personal access token</a>.
-</p>
-
-<p>
-<code>Git</code> can also be configured to use SSH in place of HTTPS for URLs matching a given prefix.
-For example, to use SSH for all GitHub access,
-add these lines to your <code>~/.gitconfig</code>:
-</p>
-<pre>
-[url "ssh://git@github.com/"]
-       insteadOf = https://github.com/
-</pre>
-
-<h3 id="get_version">
-How should I manage package versions using "go get"?</h3>
-
-<p>
-Since the inception of the project, Go has had no explicit concept of package versions,
-but that is changing.
-Versioning is a source of significant complexity, especially in large code bases,
-and it has taken some time to develop an
-approach that works well at scale in a large enough
-variety of situations to be appropriate to supply to all Go users.
-</p>
-
-<p>
-The Go 1.11 release adds new, experimental support
-for package versioning to the <code>go</code> command,
-in the form of Go modules.
-For more information, see the <a href="/doc/go1.11#modules">Go 1.11 release notes</a>
-and the <a href="/cmd/go#hdr-Modules__module_versions__and_more"><code>go</code> command documentation</a>.
-</p>
-
-<p>
-Regardless of the actual package management technology,
-"go get" and the larger Go toolchain does provide isolation of
-packages with different import paths.
-For example, the standard library's <code>html/template</code> and <code>text/template</code>
-coexist even though both are "package template".
-This observation leads to some advice for package authors and package users.
-</p>
-
-<p>
-Packages intended for public use should try to maintain backwards compatibility as they evolve.
-The <a href="/doc/go1compat.html">Go 1 compatibility guidelines</a> are a good reference here:
-don't remove exported names, encourage tagged composite literals, and so on.
-If different functionality is required, add a new name instead of changing an old one.
-If a complete break is required, create a new package with a new import path.
-</p>
-
-<p>
-If you're using an externally supplied package and worry that it might change in
-unexpected ways, but are not yet using Go modules,
-the simplest solution is to copy it to your local repository.
-This is the approach Google takes internally and is supported by the
-<code>go</code> command through a technique called "vendoring".
-This involves
-storing a copy of the dependency under a new import path that identifies it as a local copy.
-See the <a href="https://golang.org/s/go15vendor">design
-document</a> for details.
-</p>
-
-<h2 id="Pointers">Pointers and Allocation</h2>
-
-<h3 id="pass_by_value">
-When are function parameters passed by value?</h3>
-
-<p>
-As in all languages in the C family, everything in Go is passed by value.
-That is, a function always gets a copy of the
-thing being passed, as if there were an assignment statement assigning the
-value to the parameter.  For instance, passing an <code>int</code> value
-to a function makes a copy of the <code>int</code>, and passing a pointer
-value makes a copy of the pointer, but not the data it points to.
-(See a <a href="/doc/faq#methods_on_values_or_pointers">later
-section</a> for a discussion of how this affects method receivers.)
-</p>
-
-<p>
-Map and slice values behave like pointers: they are descriptors that
-contain pointers to the underlying map or slice data.  Copying a map or
-slice value doesn't copy the data it points to.  Copying an interface value
-makes a copy of the thing stored in the interface value.  If the interface
-value holds a struct, copying the interface value makes a copy of the
-struct.  If the interface value holds a pointer, copying the interface value
-makes a copy of the pointer, but again not the data it points to.
-</p>
-
-<p>
-Note that this discussion is about the semantics of the operations.
-Actual implementations may apply optimizations to avoid copying
-as long as the optimizations do not change the semantics.
-</p>
-
-<h3 id="pointer_to_interface">
-When should I use a pointer to an interface?</h3>
-
-<p>
-Almost never. Pointers to interface values arise only in rare, tricky situations involving
-disguising an interface value's type for delayed evaluation.
-</p>
-
-<p>
-It is a common mistake to pass a pointer to an interface value
-to a function expecting an interface. The compiler will complain about this
-error but the situation can still be confusing, because sometimes a
-<a href="#different_method_sets">pointer
-is necessary to satisfy an interface</a>.
-The insight is that although a pointer to a concrete type can satisfy
-an interface, with one exception <em>a pointer to an interface can never satisfy an interface</em>.
-</p>
-
-<p>
-Consider the variable declaration,
-</p>
-
-<pre>
-var w io.Writer
-</pre>
-
-<p>
-The printing function <code>fmt.Fprintf</code> takes as its first argument
-a value that satisfies <code>io.Writer</code>—something that implements
-the canonical <code>Write</code> method. Thus we can write
-</p>
-
-<pre>
-fmt.Fprintf(w, "hello, world\n")
-</pre>
-
-<p>
-If however we pass the address of <code>w</code>, the program will not compile.
-</p>
-
-<pre>
-fmt.Fprintf(&amp;w, "hello, world\n") // Compile-time error.
-</pre>
-
-<p>
-The one exception is that any value, even a pointer to an interface, can be assigned to
-a variable of empty interface type (<code>interface{}</code>).
-Even so, it's almost certainly a mistake if the value is a pointer to an interface;
-the result can be confusing.
-</p>
-
-<h3 id="methods_on_values_or_pointers">
-Should I define methods on values or pointers?</h3>
-
-<pre>
-func (s *MyStruct) pointerMethod() { } // method on pointer
-func (s MyStruct)  valueMethod()   { } // method on value
-</pre>
-
-<p>
-For programmers unaccustomed to pointers, the distinction between these
-two examples can be confusing, but the situation is actually very simple.
-When defining a method on a type, the receiver (<code>s</code> in the above
-examples) behaves exactly as if it were an argument to the method.
-Whether to define the receiver as a value or as a pointer is the same
-question, then, as whether a function argument should be a value or
-a pointer.
-There are several considerations.
-</p>
-
-<p>
-First, and most important, does the method need to modify the
-receiver?
-If it does, the receiver <em>must</em> be a pointer.
-(Slices and maps act as references, so their story is a little
-more subtle, but for instance to change the length of a slice
-in a method the receiver must still be a pointer.)
-In the examples above, if <code>pointerMethod</code> modifies
-the fields of <code>s</code>,
-the caller will see those changes, but <code>valueMethod</code>
-is called with a copy of the caller's argument (that's the definition
-of passing a value), so changes it makes will be invisible to the caller.
-</p>
-
-<p>
-By the way, in Java method receivers are always pointers,
-although their pointer nature is somewhat disguised
-(and there is a proposal to add value receivers to the language).
-It is the value receivers in Go that are unusual.
-</p>
-
-<p>
-Second is the consideration of efficiency. If the receiver is large,
-a big <code>struct</code> for instance, it will be much cheaper to
-use a pointer receiver.
-</p>
-
-<p>
-Next is consistency. If some of the methods of the type must have
-pointer receivers, the rest should too, so the method set is
-consistent regardless of how the type is used.
-See the section on <a href="#different_method_sets">method sets</a>
-for details.
-</p>
-
-<p>
-For types such as basic types, slices, and small <code>structs</code>,
-a value receiver is very cheap so unless the semantics of the method
-requires a pointer, a value receiver is efficient and clear.
-</p>
-
-
-<h3 id="new_and_make">
-What's the difference between new and make?</h3>
-
-<p>
-In short: <code>new</code> allocates memory, while <code>make</code> initializes
-the slice, map, and channel types.
-</p>
-
-<p>
-See the <a href="/doc/effective_go.html#allocation_new">relevant section
-of Effective Go</a> for more details.
-</p>
-
-<h3 id="q_int_sizes">
-What is the size of an <code>int</code> on a 64 bit machine?</h3>
-
-<p>
-The sizes of <code>int</code> and <code>uint</code> are implementation-specific
-but the same as each other on a given platform.
-For portability, code that relies on a particular
-size of value should use an explicitly sized type, like <code>int64</code>.
-On 32-bit machines the compilers use 32-bit integers by default,
-while on 64-bit machines integers have 64 bits.
-(Historically, this was not always true.)
-</p>
-
-<p>
-On the other hand, floating-point scalars and complex
-types are always sized (there are no <code>float</code> or <code>complex</code> basic types),
-because programmers should be aware of precision when using floating-point numbers.
-The default type used for an (untyped) floating-point constant is <code>float64</code>.
-Thus <code>foo</code> <code>:=</code> <code>3.0</code> declares a variable <code>foo</code>
-of type <code>float64</code>.
-For a <code>float32</code> variable initialized by an (untyped) constant, the variable type
-must be specified explicitly in the variable declaration:
-</p>
-
-<pre>
-var foo float32 = 3.0
-</pre>
-
-<p>
-Alternatively, the constant must be given a type with a conversion as in
-<code>foo := float32(3.0)</code>.
-</p>
-
-<h3 id="stack_or_heap">
-How do I know whether a variable is allocated on the heap or the stack?</h3>
-
-<p>
-From a correctness standpoint, you don't need to know.
-Each variable in Go exists as long as there are references to it.
-The storage location chosen by the implementation is irrelevant to the
-semantics of the language.
-</p>
-
-<p>
-The storage location does have an effect on writing efficient programs.
-When possible, the Go compilers will allocate variables that are
-local to a function in that function's stack frame.  However, if the
-compiler cannot prove that the variable is not referenced after the
-function returns, then the compiler must allocate the variable on the
-garbage-collected heap to avoid dangling pointer errors.
-Also, if a local variable is very large, it might make more sense
-to store it on the heap rather than the stack.
-</p>
-
-<p>
-In the current compilers, if a variable has its address taken, that variable
-is a candidate for allocation on the heap. However, a basic <em>escape
-analysis</em> recognizes some cases when such variables will not
-live past the return from the function and can reside on the stack.
-</p>
-
-<h3 id="Why_does_my_Go_process_use_so_much_virtual_memory">
-Why does my Go process use so much virtual memory?</h3>
-
-<p>
-The Go memory allocator reserves a large region of virtual memory as an arena
-for allocations. This virtual memory is local to the specific Go process; the
-reservation does not deprive other processes of memory.
-</p>
-
-<p>
-To find the amount of actual memory allocated to a Go process, use the Unix
-<code>top</code> command and consult the <code>RES</code> (Linux) or
-<code>RSIZE</code> (macOS) columns.
-<!-- TODO(adg): find out how this works on Windows -->
-</p>
-
-<h2 id="Concurrency">Concurrency</h2>
-
-<h3 id="What_operations_are_atomic_What_about_mutexes">
-What operations are atomic? What about mutexes?</h3>
-
-<p>
-A description of the atomicity of operations in Go can be found in
-the <a href="/ref/mem">Go Memory Model</a> document.
-</p>
-
-<p>
-Low-level synchronization and atomic primitives are available in the
-<a href="/pkg/sync">sync</a> and
-<a href="/pkg/sync/atomic">sync/atomic</a>
-packages.
-These packages are good for simple tasks such as incrementing
-reference counts or guaranteeing small-scale mutual exclusion.
-</p>
-
-<p>
-For higher-level operations, such as coordination among
-concurrent servers, higher-level techniques can lead
-to nicer programs, and Go supports this approach through
-its goroutines and channels.
-For instance, you can structure your program so that only one
-goroutine at a time is ever responsible for a particular piece of data.
-That approach is summarized by the original
-<a href="https://www.youtube.com/watch?v=PAAkCSZUG1c">Go proverb</a>,
-</p>
-
-<p>
-Do not communicate by sharing memory. Instead, share memory by communicating.
-</p>
-
-<p>
-See the <a href="/doc/codewalk/sharemem/">Share Memory By Communicating</a> code walk
-and its <a href="https://blog.golang.org/2010/07/share-memory-by-communicating.html">
-associated article</a> for a detailed discussion of this concept.
-</p>
-
-<p>
-Large concurrent programs are likely to borrow from both these toolkits.
-</p>
-
-<h3 id="parallel_slow">
-Why doesn't my program run faster with more CPUs?</h3>
-
-<p>
-Whether a program runs faster with more CPUs depends on the problem
-it is solving.
-The Go language provides concurrency primitives, such as goroutines
-and channels, but concurrency only enables parallelism
-when the underlying problem is intrinsically parallel.
-Problems that are intrinsically sequential cannot be sped up by adding
-more CPUs, while those that can be broken into pieces that can
-execute in parallel can be sped up, sometimes dramatically.
-</p>
-
-<p>
-Sometimes adding more CPUs can slow a program down.
-In practical terms, programs that spend more time
-synchronizing or communicating than doing useful computation
-may experience performance degradation when using
-multiple OS threads.
-This is because passing data between threads involves switching
-contexts, which has significant cost, and that cost can increase
-with more CPUs.
-For instance, the <a href="/ref/spec#An_example_package">prime sieve example</a>
-from the Go specification has no significant parallelism although it launches many
-goroutines; increasing the number of threads (CPUs) is more likely to slow it down than
-to speed it up.
-</p>
-
-<p>
-For more detail on this topic see the talk entitled
-<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">Concurrency
-is not Parallelism</a>.
-
-<h3 id="number_cpus">
-How can I control the number of CPUs?</h3>
-
-<p>
-The number of CPUs available simultaneously to executing goroutines is
-controlled by the <code>GOMAXPROCS</code> shell environment variable,
-whose default value is the number of CPU cores available.
-Programs with the potential for parallel execution should therefore
-achieve it by default on a multiple-CPU machine.
-To change the number of parallel CPUs to use,
-set the environment variable or use the similarly-named
-<a href="/pkg/runtime/#GOMAXPROCS">function</a>
-of the runtime package to configure the
-run-time support to utilize a different number of threads.
-Setting it to 1 eliminates the possibility of true parallelism,
-forcing independent goroutines to take turns executing.
-</p>
-
-<p>
-The runtime can allocate more threads than the value
-of <code>GOMAXPROCS</code> to service multiple outstanding
-I/O requests.
-<code>GOMAXPROCS</code> only affects how many goroutines
-can actually execute at once; arbitrarily more may be blocked
-in system calls.
-</p>
-
-<p>
-Go's goroutine scheduler is not as good as it needs to be, although it
-has improved over time.
-In the future, it may better optimize its use of OS threads.
-For now, if there are performance issues,
-setting <code>GOMAXPROCS</code> on a per-application basis may help.
-</p>
-
-
-<h3 id="no_goroutine_id">
-Why is there no goroutine ID?</h3>
-
-<p>
-Goroutines do not have names; they are just anonymous workers.
-They expose no unique identifier, name, or data structure to the programmer.
-Some people are surprised by this, expecting the <code>go</code>
-statement to return some item that can be used to access and control
-the goroutine later.
-</p>
-
-<p>
-The fundamental reason goroutines are anonymous is so that
-the full Go language is available when programming concurrent code.
-By contrast, the usage patterns that develop when threads and goroutines are
-named can restrict what a library using them can do.
-</p>
-
-<p>
-Here is an illustration of the difficulties.
-Once one names a goroutine and constructs a model around
-it, it becomes special, and one is tempted to associate all computation
-with that goroutine, ignoring the possibility
-of using multiple, possibly shared goroutines for the processing.
-If the <code>net/http</code> package associated per-request
-state with a goroutine,
-clients would be unable to use more goroutines
-when serving a request.
-</p>
-
-<p>
-Moreover, experience with libraries such as those for graphics systems
-that require all processing to occur on the "main thread"
-has shown how awkward and limiting the approach can be when
-deployed in a concurrent language.
-The very existence of a special thread or goroutine forces
-the programmer to distort the program to avoid crashes
-and other problems caused by inadvertently operating
-on the wrong thread.
-</p>
-
-<p>
-For those cases where a particular goroutine is truly special,
-the language provides features such as channels that can be
-used in flexible ways to interact with it.
-</p>
-
-<h2 id="Functions_methods">Functions and Methods</h2>
-
-<h3 id="different_method_sets">
-Why do T and *T have different method sets?</h3>
-
-<p>
-As the <a href="/ref/spec#Types">Go specification</a> says,
-the method set of a type <code>T</code> consists of all methods
-with receiver type <code>T</code>,
-while that of the corresponding pointer
-type <code>*T</code> consists of all methods with receiver <code>*T</code> or
-<code>T</code>.
-That means the method set of <code>*T</code>
-includes that of <code>T</code>,
-but not the reverse.
-</p>
-
-<p>
-This distinction arises because
-if an interface value contains a pointer <code>*T</code>,
-a method call can obtain a value by dereferencing the pointer,
-but if an interface value contains a value <code>T</code>,
-there is no safe way for a method call to obtain a pointer.
-(Doing so would allow a method to modify the contents of
-the value inside the interface, which is not permitted by
-the language specification.)
-</p>
-
-<p>
-Even in cases where the compiler could take the address of a value
-to pass to the method, if the method modifies the value the changes
-will be lost in the caller.
-As an example, if the <code>Write</code> method of
-<a href="/pkg/bytes/#Buffer"><code>bytes.Buffer</code></a>
-used a value receiver rather than a pointer,
-this code:
-</p>
-
-<pre>
-var buf bytes.Buffer
-io.Copy(buf, os.Stdin)
-</pre>
-
-<p>
-would copy standard input into a <i>copy</i> of <code>buf</code>,
-not into <code>buf</code> itself.
-This is almost never the desired behavior.
-</p>
-
-<h3 id="closures_and_goroutines">
-What happens with closures running as goroutines?</h3>
-
-<p>
-Some confusion may arise when using closures with concurrency.
-Consider the following program:
-</p>
-
-<pre>
-func main() {
-    done := make(chan bool)
-
-    values := []string{"a", "b", "c"}
-    for _, v := range values {
-        go func() {
-            fmt.Println(v)
-            done &lt;- true
-        }()
-    }
-
-    // wait for all goroutines to complete before exiting
-    for _ = range values {
-        &lt;-done
-    }
-}
-</pre>
-
-<p>
-One might mistakenly expect to see <code>a, b, c</code> as the output.
-What you'll probably see instead is <code>c, c, c</code>.  This is because
-each iteration of the loop uses the same instance of the variable <code>v</code>, so
-each closure shares that single variable. When the closure runs, it prints the
-value of <code>v</code> at the time <code>fmt.Println</code> is executed,
-but <code>v</code> may have been modified since the goroutine was launched.
-To help detect this and other problems before they happen, run
-<a href="/cmd/go/#hdr-Run_go_tool_vet_on_packages"><code>go vet</code></a>.
-</p>
-
-<p>
-To bind the current value of <code>v</code> to each closure as it is launched, one
-must modify the inner loop to create a new variable each iteration.
-One way is to pass the variable as an argument to the closure:
-</p>
-
-<pre>
-    for _, v := range values {
-        go func(<b>u</b> string) {
-            fmt.Println(<b>u</b>)
-            done &lt;- true
-        }(<b>v</b>)
-    }
-</pre>
-
-<p>
-In this example, the value of <code>v</code> is passed as an argument to the
-anonymous function. That value is then accessible inside the function as
-the variable <code>u</code>.
-</p>
-
-<p>
-Even easier is just to create a new variable, using a declaration style that may
-seem odd but works fine in Go:
-</p>
-
-<pre>
-    for _, v := range values {
-        <b>v := v</b> // create a new 'v'.
-        go func() {
-            fmt.Println(<b>v</b>)
-            done &lt;- true
-        }()
-    }
-</pre>
-
-<p>
-This behavior of the language, not defining a new variable for
-each iteration, may have been a mistake in retrospect.
-It may be addressed in a later version but, for compatibility,
-cannot change in Go version 1.
-</p>
-
-<h2 id="Control_flow">Control flow</h2>
-
-<h3 id="Does_Go_have_a_ternary_form">
-Why does Go not have the <code>?:</code> operator?</h3>
-
-<p>
-There is no ternary testing operation in Go.
-You may use the following to achieve the same
-result:
-</p>
-
-<pre>
-if expr {
-    n = trueVal
-} else {
-    n = falseVal
-}
-</pre>
-
-<p>
-The reason <code>?:</code> is absent from Go is that the language's designers
-had seen the operation used too often to create impenetrably complex expressions.
-The <code>if-else</code> form, although longer,
-is unquestionably clearer.
-A language needs only one conditional control flow construct.
-</p>
-
-<h2 id="Packages_Testing">Packages and Testing</h2>
-
-<h3 id="How_do_I_create_a_multifile_package">
-How do I create a multifile package?</h3>
-
-<p>
-Put all the source files for the package in a directory by themselves.
-Source files can refer to items from different files at will; there is
-no need for forward declarations or a header file.
-</p>
-
-<p>
-Other than being split into multiple files, the package will compile and test
-just like a single-file package.
-</p>
-
-<h3 id="How_do_I_write_a_unit_test">
-How do I write a unit test?</h3>
-
-<p>
-Create a new file ending in <code>_test.go</code> in the same directory
-as your package sources. Inside that file, <code>import "testing"</code>
-and write functions of the form
-</p>
-
-<pre>
-func TestFoo(t *testing.T) {
-    ...
-}
-</pre>
-
-<p>
-Run <code>go test</code> in that directory.
-That script finds the <code>Test</code> functions,
-builds a test binary, and runs it.
-</p>
-
-<p>See the <a href="/doc/code.html">How to Write Go Code</a> document,
-the <a href="/pkg/testing/"><code>testing</code></a> package
-and the <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a> subcommand for more details.
-</p>
-
-<h3 id="testing_framework">
-Where is my favorite helper function for testing?</h3>
-
-<p>
-Go's standard <a href="/pkg/testing/"><code>testing</code></a> package makes it easy to write unit tests, but it lacks
-features provided in other language's testing frameworks such as assertion functions.
-An <a href="#assertions">earlier section</a> of this document explained why Go
-doesn't have assertions, and
-the same arguments apply to the use of <code>assert</code> in tests.
-Proper error handling means letting other tests run after one has failed, so
-that the person debugging the failure gets a complete picture of what is
-wrong. It is more useful for a test to report that
-<code>isPrime</code> gives the wrong answer for 2, 3, 5, and 7 (or for
-2, 4, 8, and 16) than to report that <code>isPrime</code> gives the wrong
-answer for 2 and therefore no more tests were run. The programmer who
-triggers the test failure may not be familiar with the code that fails.
-Time invested writing a good error message now pays off later when the
-test breaks.
-</p>
-
-<p>
-A related point is that testing frameworks tend to develop into mini-languages
-of their own, with conditionals and controls and printing mechanisms,
-but Go already has all those capabilities; why recreate them?
-We'd rather write tests in Go; it's one fewer language to learn and the
-approach keeps the tests straightforward and easy to understand.
-</p>
-
-<p>
-If the amount of extra code required to write
-good errors seems repetitive and overwhelming, the test might work better if
-table-driven, iterating over a list of inputs and outputs defined
-in a data structure (Go has excellent support for data structure literals).
-The work to write a good test and good error messages will then be amortized over many
-test cases. The standard Go library is full of illustrative examples, such as in
-<a href="/src/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
-</p>
-
-<h3 id="x_in_std">
-Why isn't <i>X</i> in the standard library?</h3>
-
-<p>
-The standard library's purpose is to support the runtime, connect to
-the operating system, and provide key functionality that many Go
-programs require, such as formatted I/O and networking.
-It also contains elements important for web programming, including
-cryptography and support for standards like HTTP, JSON, and XML.
-</p>
-
-<p>
-There is no clear criterion that defines what is included because for
-a long time, this was the <i>only</i> Go library.
-There are criteria that define what gets added today, however.
-</p>
-
-<p>
-New additions to the standard library are rare and the bar for
-inclusion is high.
-Code included in the standard library bears a large ongoing maintenance cost
-(often borne by those other than the original author),
-is subject to the <a href="/doc/go1compat.html">Go 1 compatibility promise</a>
-(blocking fixes to any flaws in the API),
-and is subject to the Go
-<a href="https://golang.org/s/releasesched">release schedule</a>,
-preventing bug fixes from being available to users quickly.
-</p>
-
-<p>
-Most new code should live outside of the standard library and be accessible
-via the <a href="/cmd/go/"><code>go</code> tool</a>'s
-<code>go get</code> command.
-Such code can have its own maintainers, release cycle,
-and compatibility guarantees.
-Users can find packages and read their documentation at
-<a href="https://godoc.org/">godoc.org</a>.
-</p>
-
-<p>
-Although there are pieces in the standard library that don't really belong,
-such as <code>log/syslog</code>, we continue to maintain everything in the
-library because of the Go 1 compatibility promise.
-But we encourage most new code to live elsewhere.
-</p>
-
-<h2 id="Implementation">Implementation</h2>
-
-<h3 id="What_compiler_technology_is_used_to_build_the_compilers">
-What compiler technology is used to build the compilers?</h3>
-
-<p>
-There are several production compilers for Go, and a number of others
-in development for various platforms.
-</p>
-
-<p>
-The default compiler, <code>gc</code>, is included with the
-Go distribution as part of the support for the <code>go</code>
-command.
-<code>Gc</code> was originally written in C
-because of the difficulties of bootstrapping&mdash;you'd need a Go compiler to
-set up a Go environment.
-But things have advanced and since the Go 1.5 release the compiler has been
-a Go program.
-The compiler was converted from C to Go using automatic translation tools, as
-described in this <a href="/s/go13compiler">design document</a>
-and <a href="https://talks.golang.org/2015/gogo.slide#1">talk</a>.
-Thus the compiler is now "self-hosting", which means we needed to face
-the bootstrapping problem.
-The solution is to have a working Go installation already in place,
-just as one normally has with a working C installation.
-The story of how to bring up a new Go environment from source
-is described <a href="/s/go15bootstrap">here</a> and
-<a href="/doc/install/source">here</a>.
-</p>
-
-<p>
-<code>Gc</code> is written in Go with a recursive descent parser
-and uses a custom loader, also written in Go but
-based on the Plan 9 loader, to generate ELF/Mach-O/PE binaries.
-</p>
-
-<p>
-At the beginning of the project we considered using LLVM for
-<code>gc</code> but decided it was too large and slow to meet
-our performance goals.
-More important in retrospect, starting with LLVM would have made it
-harder to introduce some of the ABI and related changes, such as
-stack management, that Go requires but are not part of the standard
-C setup.
-A new <a href="https://go.googlesource.com/gollvm/">LLVM implementation</a>
-is starting to come together now, however.
-</p>
-
-<p>
-The <code>Gccgo</code> compiler is a front end written in C++
-with a recursive descent parser coupled to the
-standard GCC back end.
-</p>
-
-<p>
-Go turned out to be a fine language in which to implement a Go compiler,
-although that was not its original goal.
-Not being self-hosting from the beginning allowed Go's design to
-concentrate on its original use case, which was networked servers.
-Had we decided Go should compile itself early on, we might have
-ended up with a language targeted more for compiler construction,
-which is a worthy goal but not the one we had initially.
-</p>
-
-<p>
-Although <code>gc</code> does not use them (yet?), a native lexer and
-parser are available in the <a href="/pkg/go/"><code>go</code></a> package
-and there is also a native <a href="/pkg/go/types">type checker</a>.
-</p>
-
-<h3 id="How_is_the_run_time_support_implemented">
-How is the run-time support implemented?</h3>
-
-<p>
-Again due to bootstrapping issues, the run-time code was originally written mostly in C (with a
-tiny bit of assembler) but it has since been translated to Go
-(except for some assembler bits).
-<code>Gccgo</code>'s run-time support uses <code>glibc</code>.
-The <code>gccgo</code> compiler implements goroutines using
-a technique called segmented stacks,
-supported by recent modifications to the gold linker.
-<code>Gollvm</code> similarly is built on the corresponding
-LLVM infrastructure.
-</p>
-
-<h3 id="Why_is_my_trivial_program_such_a_large_binary">
-Why is my trivial program such a large binary?</h3>
-
-<p>
-The linker in the <code>gc</code> toolchain
-creates statically-linked binaries by default.
-All Go binaries therefore include the Go
-runtime, along with the run-time type information necessary to support dynamic
-type checks, reflection, and even panic-time stack traces.
-</p>
-
-<p>
-A simple C "hello, world" program compiled and linked statically using
-gcc on Linux is around 750 kB, including an implementation of
-<code>printf</code>.
-An equivalent Go program using
-<code>fmt.Printf</code> weighs a couple of megabytes, but that includes
-more powerful run-time support and type and debugging information.
-</p>
-
-<p>
-A Go program compiled with <code>gc</code> can be linked with
-the <code>-ldflags=-w</code> flag to disable DWARF generation,
-removing debugging information from the binary but with no
-other loss of functionality.
-This can reduce the binary size substantially.
-</p>
-
-<h3 id="unused_variables_and_imports">
-Can I stop these complaints about my unused variable/import?</h3>
-
-<p>
-The presence of an unused variable may indicate a bug, while
-unused imports just slow down compilation,
-an effect that can become substantial as a program accumulates
-code and programmers over time.
-For these reasons, Go refuses to compile programs with unused
-variables or imports,
-trading short-term convenience for long-term build speed and
-program clarity.
-</p>
-
-<p>
-Still, when developing code, it's common to create these situations
-temporarily and it can be annoying to have to edit them out before the
-program will compile.
-</p>
-
-<p>
-Some have asked for a compiler option to turn those checks off
-or at least reduce them to warnings.
-Such an option has not been added, though,
-because compiler options should not affect the semantics of the
-language and because the Go compiler does not report warnings, only
-errors that prevent compilation.
-</p>
-
-<p>
-There are two reasons for having no warnings.  First, if it's worth
-complaining about, it's worth fixing in the code.  (And if it's not
-worth fixing, it's not worth mentioning.) Second, having the compiler
-generate warnings encourages the implementation to warn about weak
-cases that can make compilation noisy, masking real errors that
-<em>should</em> be fixed.
-</p>
-
-<p>
-It's easy to address the situation, though.  Use the blank identifier
-to let unused things persist while you're developing.
-</p>
-
-<pre>
-import "unused"
-
-// This declaration marks the import as used by referencing an
-// item from the package.
-var _ = unused.Item  // TODO: Delete before committing!
-
-func main() {
-    debugData := debug.Profile()
-    _ = debugData // Used only during debugging.
-    ....
-}
-</pre>
-
-<p>
-Nowadays, most Go programmers use a tool,
-<a href="https://godoc.org/golang.org/x/tools/cmd/goimports">goimports</a>,
-which automatically rewrites a Go source file to have the correct imports,
-eliminating the unused imports issue in practice.
-This program is easily connected to most editors to run automatically when a Go source file is written.
-</p>
-
-<h3 id="virus">
-Why does my virus-scanning software think my Go distribution or compiled binary is infected?</h3>
-
-<p>
-This is a common occurrence, especially on Windows machines, and is almost always a false positive.
-Commercial virus scanning programs are often confused by the structure of Go binaries, which
-they don't see as often as those compiled from other languages.
-</p>
-
-<p>
-If you've just installed the Go distribution and the system reports it is infected, that's certainly a mistake.
-To be really thorough, you can verify the download by comparing the checksum with those on the
-<a href="https://golang.org/dl/">downloads page</a>.
-</p>
-
-<p>
-In any case, if you believe the report is in error, please report a bug to the supplier of your virus scanner.
-Maybe in time virus scanners can learn to understand Go programs.
-</p>
-
-<h2 id="Performance">Performance</h2>
-
-<h3 id="Why_does_Go_perform_badly_on_benchmark_x">
-Why does Go perform badly on benchmark X?</h3>
-
-<p>
-One of Go's design goals is to approach the performance of C for comparable
-programs, yet on some benchmarks it does quite poorly, including several
-in <a href="https://go.googlesource.com/exp/+/master/shootout/">golang.org/x/exp/shootout</a>.
-The slowest depend on libraries for which versions of comparable performance
-are not available in Go.
-For instance, <a href="https://go.googlesource.com/exp/+/master/shootout/pidigits.go">pidigits.go</a>
-depends on a multi-precision math package, and the C
-versions, unlike Go's, use <a href="https://gmplib.org/">GMP</a> (which is
-written in optimized assembler).
-Benchmarks that depend on regular expressions
-(<a href="https://go.googlesource.com/exp/+/master/shootout/regex-dna.go">regex-dna.go</a>,
-for instance) are essentially comparing Go's native <a href="/pkg/regexp">regexp package</a> to
-mature, highly optimized regular expression libraries like PCRE.
-</p>
-
-<p>
-Benchmark games are won by extensive tuning and the Go versions of most
-of the benchmarks need attention.  If you measure comparable C
-and Go programs
-(<a href="https://go.googlesource.com/exp/+/master/shootout/reverse-complement.go">reverse-complement.go</a>
-is one example), you'll see the two languages are much closer in raw performance
-than this suite would indicate.
-</p>
-
-<p>
-Still, there is room for improvement. The compilers are good but could be
-better, many libraries need major performance work, and the garbage collector
-isn't fast enough yet. (Even if it were, taking care not to generate unnecessary
-garbage can have a huge effect.)
-</p>
-
-<p>
-In any case, Go can often be very competitive.
-There has been significant improvement in the performance of many programs
-as the language and tools have developed.
-See the blog post about
-<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
-Go programs</a> for an informative example.
-
-<h2 id="change_from_c">Changes from C</h2>
-
-<h3 id="different_syntax">
-Why is the syntax so different from C?</h3>
-<p>
-Other than declaration syntax, the differences are not major and stem
-from two desires.  First, the syntax should feel light, without too
-many mandatory keywords, repetition, or arcana.  Second, the language
-has been designed to be easy to analyze
-and can be parsed without a symbol table.  This makes it much easier
-to build tools such as debuggers, dependency analyzers, automated
-documentation extractors, IDE plug-ins, and so on.  C and its
-descendants are notoriously difficult in this regard.
-</p>
-
-<h3 id="declarations_backwards">
-Why are declarations backwards?</h3>
-<p>
-They're only backwards if you're used to C. In C, the notion is that a
-variable is declared like an expression denoting its type, which is a
-nice idea, but the type and expression grammars don't mix very well and
-the results can be confusing; consider function pointers.  Go mostly
-separates expression and type syntax and that simplifies things (using
-prefix <code>*</code> for pointers is an exception that proves the rule).  In C,
-the declaration
-</p>
-<pre>
-    int* a, b;
-</pre>
-<p>
-declares <code>a</code> to be a pointer but not <code>b</code>; in Go
-</p>
-<pre>
-    var a, b *int
-</pre>
-<p>
-declares both to be pointers.  This is clearer and more regular.
-Also, the <code>:=</code> short declaration form argues that a full variable
-declaration should present the same order as <code>:=</code> so
-</p>
-<pre>
-    var a uint64 = 1
-</pre>
-<p>
-has the same effect as
-</p>
-<pre>
-    a := uint64(1)
-</pre>
-<p>
-Parsing is also simplified by having a distinct grammar for types that
-is not just the expression grammar; keywords such as <code>func</code>
-and <code>chan</code> keep things clear.
-</p>
-
-<p>
-See the article about
-<a href="/doc/articles/gos_declaration_syntax.html">Go's Declaration Syntax</a>
-for more details.
-</p>
-
-<h3 id="no_pointer_arithmetic">
-Why is there no pointer arithmetic?</h3>
-<p>
-Safety.  Without pointer arithmetic it's possible to create a
-language that can never derive an illegal address that succeeds
-incorrectly.  Compiler and hardware technology have advanced to the
-point where a loop using array indices can be as efficient as a loop
-using pointer arithmetic.  Also, the lack of pointer arithmetic can
-simplify the implementation of the garbage collector.
-</p>
-
-<h3 id="inc_dec">
-Why are <code>++</code> and <code>--</code> statements and not expressions?  And why postfix, not prefix?</h3>
-<p>
-Without pointer arithmetic, the convenience value of pre- and postfix
-increment operators drops.  By removing them from the expression
-hierarchy altogether, expression syntax is simplified and the messy
-issues around order of evaluation of <code>++</code> and <code>--</code>
-(consider <code>f(i++)</code> and <code>p[i] = q[++i]</code>)
-are eliminated as well.  The simplification is
-significant.  As for postfix vs. prefix, either would work fine but
-the postfix version is more traditional; insistence on prefix arose
-with the STL, a library for a language whose name contains, ironically, a
-postfix increment.
-</p>
-
-<h3 id="semicolons">
-Why are there braces but no semicolons? And why can't I put the opening
-brace on the next line?</h3>
-<p>
-Go uses brace brackets for statement grouping, a syntax familiar to
-programmers who have worked with any language in the C family.
-Semicolons, however, are for parsers, not for people, and we wanted to
-eliminate them as much as possible.  To achieve this goal, Go borrows
-a trick from BCPL: the semicolons that separate statements are in the
-formal grammar but are injected automatically, without lookahead, by
-the lexer at the end of any line that could be the end of a statement.
-This works very well in practice but has the effect that it forces a
-brace style.  For instance, the opening brace of a function cannot
-appear on a line by itself.
-</p>
-
-<p>
-Some have argued that the lexer should do lookahead to permit the
-brace to live on the next line.  We disagree.  Since Go code is meant
-to be formatted automatically by
-<a href="/cmd/gofmt/"><code>gofmt</code></a>,
-<i>some</i> style must be chosen.  That style may differ from what
-you've used in C or Java, but Go is a different language and
-<code>gofmt</code>'s style is as good as any other.  More
-important&mdash;much more important&mdash;the advantages of a single,
-programmatically mandated format for all Go programs greatly outweigh
-any perceived disadvantages of the particular style.
-Note too that Go's style means that an interactive implementation of
-Go can use the standard syntax one line at a time without special rules.
-</p>
-
-<h3 id="garbage_collection">
-Why do garbage collection?  Won't it be too expensive?</h3>
-<p>
-One of the biggest sources of bookkeeping in systems programs is
-managing the lifetimes of allocated objects.
-In languages such as C in which it is done manually,
-it can consume a significant amount of programmer time and is
-often the cause of pernicious bugs.
-Even in languages like C++ or Rust that provide mechanisms
-to assist, those mechanisms can have a significant effect on the
-design of the software, often adding programming overhead
-of its own.
-We felt it was critical to eliminate such
-programmer overheads, and advances in garbage collection
-technology in the last few years gave us confidence that it
-could be implemented cheaply enough, and with low enough
-latency, that it could be a viable approach for networked
-systems.
-</p>
-
-<p>
-Much of the difficulty of concurrent programming
-has its roots in the object lifetime problem:
-as objects get passed among threads it becomes cumbersome
-to guarantee they become freed safely.
-Automatic garbage collection makes concurrent code far easier to write.
-Of course, implementing garbage collection in a concurrent environment is
-itself a challenge, but meeting it once rather than in every
-program helps everyone.
-</p>
-
-<p>
-Finally, concurrency aside, garbage collection makes interfaces
-simpler because they don't need to specify how memory is managed across them.
-</p>
-
-<p>
-This is not to say that the recent work in languages
-like Rust that bring new ideas to the problem of managing
-resources is misguided; we encourage this work and are excited to see
-how it evolves.
-But Go takes a more traditional approach by addressing
-object lifetimes through
-garbage collection, and garbage collection alone.
-</p>
-
-<p>
-The current implementation is a mark-and-sweep collector.
-If the machine is a multiprocessor, the collector runs on a separate CPU
-core in parallel with the main program.
-Major work on the collector in recent years has reduced pause times
-often to the sub-millisecond range, even for large heaps,
-all but eliminating one of the major objections to garbage collection
-in networked servers.
-Work continues to refine the algorithm, reduce overhead and
-latency further, and to explore new approaches.
-The 2018
-<a href="https://blog.golang.org/ismmkeynote">ISMM keynote</a>
-by Rick Hudson of the Go team
-describes the progress so far and suggests some future approaches.
-</p>
-
-<p>
-On the topic of performance, keep in mind that Go gives the programmer
-considerable control over memory layout and allocation, much more than
-is typical in garbage-collected languages. A careful programmer can reduce
-the garbage collection overhead dramatically by using the language well;
-see the article about
-<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
-Go programs</a> for a worked example, including a demonstration of Go's
-profiling tools.
-</p>

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 676407f6f2bfd0799393da0ad40bbcfd4fc56eb6..59c9ce3c434e67614bf3e906f820a854e57b1f0b 100644 (file)
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
        "Title": "The Go Programming Language Specification",
-       "Subtitle": "Version of Oct 7, 2020",
+       "Subtitle": "Version of Feb 10, 2021",
        "Path": "/ref/spec"
 }-->
 
@@ -3400,7 +3400,7 @@ A type assertion used in an <a href="#Assignments">assignment</a> or initializat
 v, ok = x.(T)
 v, ok := x.(T)
 var v, ok = x.(T)
-var v, ok T1 = x.(T)
+var v, ok interface{} = x.(T) // dynamic types of v and ok are T and bool
 </pre>
 
 <p>
@@ -3446,7 +3446,7 @@ In a function call, the function value and arguments are evaluated in
 After they are evaluated, the parameters of the call are passed by value to the function
 and the called function begins execution.
 The return parameters of the function are passed by value
-back to the calling function when the function returns.
+back to the caller when the function returns.
 </p>
 
 <p>

diff --git a/doc/gopher/README b/doc/gopher/README
deleted file mode 100644 (file)
index d4ca8a1..0000000
--- a/doc/gopher/README
+++ /dev/null
@@ -1,3 +0,0 @@
-The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
-The design is licensed under the Creative Commons 3.0 Attributions license.
-Read this article for more details: https://blog.golang.org/gopher

diff --git a/doc/gopher/appenginegopher.jpg b/doc/gopher/appenginegopher.jpg
deleted file mode 100644 (file)
index 0a64306..0000000
Binary files a/doc/gopher/appenginegopher.jpg and /dev/null differ

diff --git a/doc/gopher/appenginegophercolor.jpg b/doc/gopher/appenginegophercolor.jpg
deleted file mode 100644 (file)
index 68795a9..0000000
Binary files a/doc/gopher/appenginegophercolor.jpg and /dev/null differ

diff --git a/doc/gopher/appenginelogo.gif b/doc/gopher/appenginelogo.gif
deleted file mode 100644 (file)
index 46b3c1e..0000000
Binary files a/doc/gopher/appenginelogo.gif and /dev/null differ

diff --git a/doc/gopher/biplane.jpg b/doc/gopher/biplane.jpg
deleted file mode 100644 (file)
index d5e666f..0000000
Binary files a/doc/gopher/biplane.jpg and /dev/null differ

diff --git a/doc/gopher/bumper.png b/doc/gopher/bumper.png
deleted file mode 100644 (file)
index b357cdf..0000000
Binary files a/doc/gopher/bumper.png and /dev/null differ

diff --git a/doc/gopher/bumper192x108.png b/doc/gopher/bumper192x108.png
deleted file mode 100644 (file)
index 925474e..0000000
Binary files a/doc/gopher/bumper192x108.png and /dev/null differ

diff --git a/doc/gopher/bumper320x180.png b/doc/gopher/bumper320x180.png
deleted file mode 100644 (file)
index 611c417..0000000
Binary files a/doc/gopher/bumper320x180.png and /dev/null differ

diff --git a/doc/gopher/bumper480x270.png b/doc/gopher/bumper480x270.png
deleted file mode 100644 (file)
index cf18715..0000000
Binary files a/doc/gopher/bumper480x270.png and /dev/null differ

diff --git a/doc/gopher/bumper640x360.png b/doc/gopher/bumper640x360.png
deleted file mode 100644 (file)
index a5073e0..0000000
Binary files a/doc/gopher/bumper640x360.png and /dev/null differ

diff --git a/doc/gopher/doc.png b/doc/gopher/doc.png
deleted file mode 100644 (file)
index e15a323..0000000
Binary files a/doc/gopher/doc.png and /dev/null differ

diff --git a/doc/gopher/favicon.svg b/doc/gopher/favicon.svg
deleted file mode 100644 (file)
index e5a68fe..0000000
--- a/doc/gopher/favicon.svg
+++ /dev/null
@@ -1,238 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="32"
-   height="32"
-   viewBox="0 0 32 32.000001"
-   id="svg4416"
-   version="1.1"
-   inkscape:version="0.91 r13725"
-   sodipodi:docname="favicon.svg"
-   inkscape:export-filename="../../favicon.png"
-   inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90">
-  <defs
-     id="defs4418" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="15.839192"
-     inkscape:cx="17.966652"
-     inkscape:cy="9.2991824"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="true"
-     units="px"
-     inkscape:snap-bbox="true"
-     inkscape:snap-bbox-edge-midpoints="false"
-     inkscape:bbox-nodes="true"
-     showguides="false"
-     inkscape:window-width="1920"
-     inkscape:window-height="1018"
-     inkscape:window-x="1912"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:object-nodes="true"
-     inkscape:snap-smooth-nodes="true"
-     inkscape:snap-global="false">
-    <inkscape:grid
-       type="xygrid"
-       id="grid5148" />
-  </sodipodi:namedview>
-  <metadata
-     id="metadata4421">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="icon"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(0,-1020.3622)">
-    <ellipse
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="ellipse4216"
-       cx="-907.35657"
-       cy="479.90009"
-       rx="3.5793996"
-       ry="3.8207953"
-       transform="matrix(-0.49169095,-0.87076978,-0.87076978,0.49169095,0,0)"
-       inkscape:transform-center-x="0.67794294"
-       inkscape:transform-center-y="-2.3634048" />
-    <ellipse
-       inkscape:transform-center-y="-2.3633882"
-       inkscape:transform-center-x="-0.67793718"
-       transform="matrix(0.49169095,-0.87076978,0.87076978,0.49169095,0,0)"
-       ry="3.8207953"
-       rx="3.5793996"
-       cy="507.8461"
-       cx="-891.57654"
-       id="ellipse4463"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16.091693,1021.3642 c -1.105749,0.01 -2.210341,0.049 -3.31609,0.09 C 6.8422558,1021.6738 2,1026.3942 2,1032.3622 c 0,2.9786 0,13 0,20 l 28,0 c 0,-8 0,-16 0,-20 0,-5.9683 -4.667345,-10.4912 -10.59023,-10.908 -1.10575,-0.078 -2.212328,-0.099 -3.318077,-0.09 z"
-       id="path4465"
-       sodipodi:nodetypes="ccsccscc" />
-    <path
-       inkscape:transform-center-y="-1.3604657"
-       inkscape:transform-center-x="-0.98424303"
-       sodipodi:nodetypes="sssssss"
-       inkscape:connector-curvature="0"
-       id="path4469"
-       d="m 4.6078867,1025.0462 c 0.459564,0.2595 1.818262,1.2013 1.980983,1.648 0.183401,0.5035 0.159385,1.0657 -0.114614,1.551 -0.346627,0.6138 -1.005341,0.9487 -1.696421,0.9365 -0.339886,-0.01 -1.720283,-0.6372 -2.042561,-0.8192 -0.97754,-0.5519 -1.350795,-1.7418 -0.833686,-2.6576 0.517109,-0.9158 1.728749,-1.2107 2.706299,-0.6587 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <rect
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32850246;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4473"
-       width="3.0866659"
-       height="3.5313663"
-       x="14.406213"
-       y="1035.6842"
-       ry="0.62426329" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16,1023.3622 c -9,0 -12,3.7153 -12,9 l 0,20 24,0 c -0.04889,-7.3562 0,-18 0,-20 0,-5.2848 -3,-9 -12,-9 z"
-       id="path4471"
-       sodipodi:nodetypes="zsccsz" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 27.074073,1025.0462 c -0.45957,0.2595 -1.818257,1.2013 -1.980979,1.648 -0.183401,0.5035 -0.159384,1.0657 0.114614,1.551 0.346627,0.6138 1.005335,0.9487 1.696415,0.9365 0.33988,-0.01 1.72029,-0.6372 2.04256,-0.8192 0.97754,-0.5519 1.35079,-1.7418 0.83369,-2.6576 -0.51711,-0.9158 -1.72876,-1.2107 -2.7063,-0.6587 z"
-       id="path4481"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssss"
-       inkscape:transform-center-x="0.98424094"
-       inkscape:transform-center-y="-1.3604657" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4477"
-       cx="21.175734"
-       cy="1030.3542"
-       r="4.6537542"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="4.8316345"
-       cy="1030.3542"
-       cx="10.339486"
-       id="circle4483"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       inkscape:export-ydpi="90"
-       inkscape:export-xdpi="90"
-       inkscape:export-filename=".\rect4485.png"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4246"
-       width="3.6673687"
-       height="4.1063409"
-       x="14.115863"
-       y="1035.9174"
-       ry="0.72590536" />
-    <rect
-       ry="0.72590536"
-       y="1035.2253"
-       x="14.115863"
-       height="4.1063409"
-       width="3.6673687"
-       id="rect4485"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#fffcfb;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 19.999735,1036.5289 c 0,0.838 -0.871228,1.2682 -2.144766,1.1659 -0.02366,0 -0.04795,-0.6004 -0.254147,-0.5832 -0.503669,0.042 -1.095902,-0.02 -1.685964,-0.02 -0.612939,0 -1.206342,0.1826 -1.68549,0.017 -0.110233,-0.038 -0.178298,0.5838 -0.261532,0.5816 -1.243685,-0.033 -2.078803,-0.3383 -2.078803,-1.1618 0,-1.2118 1.815635,-2.1941 4.055351,-2.1941 2.239704,0 4.055351,0.9823 4.055351,2.1941 z"
-       id="path4487"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssssss"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="sssssssss"
-       inkscape:connector-curvature="0"
-       id="path4489"
-       d="m 19.977414,1035.7004 c 0,0.5685 -0.433659,0.8554 -1.138091,1.0001 -0.291933,0.06 -0.630371,0.096 -1.003719,0.1166 -0.56405,0.032 -1.207782,0.031 -1.89122,0.031 -0.672834,0 -1.307182,0 -1.864904,-0.029 -0.306268,-0.017 -0.589429,-0.043 -0.843164,-0.084 -0.813833,-0.1318 -1.324962,-0.417 -1.324962,-1.0344 0,-1.1601 1.805642,-2.1006 4.03303,-2.1006 2.227377,0 4.03303,0.9405 4.03303,2.1006 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#c38c74;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <ellipse
-       cy="1033.8501"
-       cx="15.944382"
-       id="ellipse4491"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#23201f;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       rx="2.0801733"
-       ry="1.343747"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4493"
-       cx="12.414201"
-       cy="1030.3542"
-       r="1.9630634"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="1.9630634"
-       cy="1030.3542"
-       cx="23.110121"
-       id="circle4495"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4497"
-       d="m 5.0055377,1027.2727 c -1.170435,-1.0835 -2.026973,-0.7721 -2.044172,-0.7463"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 4.3852457,1026.9152 c -1.158557,0.036 -1.346704,0.6303 -1.33881,0.6523"
-       id="path4499"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 26.630533,1027.1724 c 1.17043,-1.0835 2.02697,-0.7721 2.04417,-0.7463"
-       id="path4501"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4503"
-       d="m 27.321773,1026.673 c 1.15856,0.036 1.3467,0.6302 1.3388,0.6522"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-  </g>
-</svg>

diff --git a/doc/gopher/fiveyears.jpg b/doc/gopher/fiveyears.jpg
deleted file mode 100644 (file)
index df10648..0000000
Binary files a/doc/gopher/fiveyears.jpg and /dev/null differ

diff --git a/doc/gopher/frontpage.png b/doc/gopher/frontpage.png
deleted file mode 100644 (file)
index 1eb81f0..0000000
Binary files a/doc/gopher/frontpage.png and /dev/null differ

diff --git a/doc/gopher/gopherbw.png b/doc/gopher/gopherbw.png
deleted file mode 100644 (file)
index 3bfe85d..0000000
Binary files a/doc/gopher/gopherbw.png and /dev/null differ

diff --git a/doc/gopher/gophercolor.png b/doc/gopher/gophercolor.png
deleted file mode 100644 (file)
index b5f8d01..0000000
Binary files a/doc/gopher/gophercolor.png and /dev/null differ

diff --git a/doc/gopher/gophercolor16x16.png b/doc/gopher/gophercolor16x16.png
deleted file mode 100644 (file)
index ec7028c..0000000
Binary files a/doc/gopher/gophercolor16x16.png and /dev/null differ

diff --git a/doc/gopher/help.png b/doc/gopher/help.png
deleted file mode 100644 (file)
index 6ee5238..0000000
Binary files a/doc/gopher/help.png and /dev/null differ

diff --git a/doc/gopher/modelsheet.jpg b/doc/gopher/modelsheet.jpg
deleted file mode 100644 (file)
index c31e35a..0000000
Binary files a/doc/gopher/modelsheet.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gopherhat.jpg b/doc/gopher/pencil/gopherhat.jpg
deleted file mode 100644 (file)
index f34d7b3..0000000
Binary files a/doc/gopher/pencil/gopherhat.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gopherhelmet.jpg b/doc/gopher/pencil/gopherhelmet.jpg
deleted file mode 100644 (file)
index c7b6c61..0000000
Binary files a/doc/gopher/pencil/gopherhelmet.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gophermega.jpg b/doc/gopher/pencil/gophermega.jpg
deleted file mode 100644 (file)
index 779fb07..0000000
Binary files a/doc/gopher/pencil/gophermega.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gopherrunning.jpg b/doc/gopher/pencil/gopherrunning.jpg
deleted file mode 100644 (file)
index eeeddf1..0000000
Binary files a/doc/gopher/pencil/gopherrunning.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gopherswim.jpg b/doc/gopher/pencil/gopherswim.jpg
deleted file mode 100644 (file)
index 2f32877..0000000
Binary files a/doc/gopher/pencil/gopherswim.jpg and /dev/null differ

diff --git a/doc/gopher/pencil/gopherswrench.jpg b/doc/gopher/pencil/gopherswrench.jpg
deleted file mode 100644 (file)
index 93005f4..0000000
Binary files a/doc/gopher/pencil/gopherswrench.jpg and /dev/null differ

diff --git a/doc/gopher/pkg.png b/doc/gopher/pkg.png
deleted file mode 100644 (file)
index ac96551..0000000
Binary files a/doc/gopher/pkg.png and /dev/null differ

diff --git a/doc/gopher/project.png b/doc/gopher/project.png
deleted file mode 100644 (file)
index 24603f3..0000000
Binary files a/doc/gopher/project.png and /dev/null differ

diff --git a/doc/gopher/ref.png b/doc/gopher/ref.png
deleted file mode 100644 (file)
index 0508f6e..0000000
Binary files a/doc/gopher/ref.png and /dev/null differ

diff --git a/doc/gopher/run.png b/doc/gopher/run.png
deleted file mode 100644 (file)
index eb690e3..0000000
Binary files a/doc/gopher/run.png and /dev/null differ

diff --git a/doc/gopher/talks.png b/doc/gopher/talks.png
deleted file mode 100644 (file)
index 589db47..0000000
Binary files a/doc/gopher/talks.png and /dev/null differ

diff --git a/doc/help.html b/doc/help.html
deleted file mode 100644 (file)
index 3d32ae5..0000000
--- a/doc/help.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!--{
-       "Title": "Help",
-       "Path": "/help/",
-       "Template": true
-}-->
-
-<div id="manual-nav"></div>
-
-<h2 id="help">Get help</h2>
-
-<img class="gopher" src="/doc/gopher/help.png" alt=""/>
-
-{{if not $.GoogleCN}}
-<h3 id="mailinglist"><a href="https://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
-<p>
-Get help from Go users, and share your work on the official mailing list.
-</p>
-<p>
-Search the <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>
-archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
-<a href="//golang.org/wiki">wiki</a> before posting.
-</p>
-
-<h3 id="forum"><a href="https://forum.golangbridge.org/">Go Forum</a></h3>
-<p>
-The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
-forum for Go programmers.
-</p>
-
-<h3 id="discord"><a href="https://discord.gg/64C346U">Gophers Discord</a></h3>
-<p>
-Get live support and talk with other gophers on the Go Discord.
-</p>
-
-<h3 id="slack"><a href="https://blog.gopheracademy.com/gophers-slack-community/">Gopher Slack</a></h3>
-<p>Get live support from other users in the Go slack channel.</p>
-
-<h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
-<p>Get live support at <b>#go-nuts</b> on <b>irc.freenode.net</b>, the official
-Go IRC channel.</p>
-{{end}}
-
-<h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
-<p>Answers to common questions about Go.</p>
-
-{{if not $.GoogleCN}}
-<h2 id="inform">Stay informed</h2>
-
-<h3 id="announce"><a href="https://groups.google.com/group/golang-announce">Go Announcements Mailing List</a></h3>
-<p>
-Subscribe to
-<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
-for important announcements, such as the availability of new Go releases.
-</p>
-
-<h3 id="blog"><a href="//blog.golang.org">Go Blog</a></h3>
-<p>The Go project's official blog.</p>
-
-<h3 id="twitter"><a href="https://twitter.com/golang">@golang at Twitter</a></h3>
-<p>The Go project's official Twitter account.</p>
-
-<h3 id="reddit"><a href="https://reddit.com/r/golang">golang sub-Reddit</a></h3>
-<p>
-The <a href="https://reddit.com/r/golang">golang sub-Reddit</a> is a place
-for Go news and discussion.
-</p>
-
-<h3 id="gotime"><a href="https://changelog.com/gotime">Go Time Podcast</a></h3>
-<p>
-The <a href="https://changelog.com/gotime">Go Time podcast</a> is a panel of Go experts and special guests
-discussing the Go programming language, the community, and everything in between.
-</p>
-{{end}}
-
-<h2 id="community">Community resources</h2>
-
-<h3 id="go_user_groups"><a href="/wiki/GoUserGroups">Go User Groups</a></h3>
-<p>
-Each month in places around the world, groups of Go programmers ("gophers")
-meet to talk about Go. Find a chapter near you.
-</p>
-
-{{if not $.GoogleCN}}
-<h3 id="playground"><a href="/play">Go Playground</a></h3>
-<p>A place to write, run, and share Go code.</p>
-
-<h3 id="wiki"><a href="/wiki">Go Wiki</a></h3>
-<p>A wiki maintained by the Go community.</p>
-{{end}}
-
-<h3 id="conduct"><a href="/conduct">Code of Conduct</a></h3>
-<p>
-Guidelines for participating in Go community spaces
-and a reporting process for handling issues.
-</p>
-

diff --git a/doc/ie.css b/doc/ie.css
deleted file mode 100644 (file)
index bb89d54..0000000
--- a/doc/ie.css
+++ /dev/null
@@ -1 +0,0 @@
-#nav-main li { display: inline; }

diff --git a/doc/install-source.html b/doc/install-source.html
deleted file mode 100644 (file)
index f0a9092..0000000
--- a/doc/install-source.html
+++ /dev/null
@@ -1,777 +0,0 @@
-<!--{
-       "Title": "Installing Go from source",
-       "Path": "/doc/install/source"
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-Go is an open source project, distributed under a
-<a href="/LICENSE">BSD-style license</a>.
-This document explains how to check out the sources,
-build them on your own machine, and run them.
-</p>
-
-<p>
-Most users don't need to do this, and will instead install
-from precompiled binary packages as described in
-<a href="/doc/install">Getting Started</a>,
-a much simpler process.
-If you want to help develop what goes into those precompiled
-packages, though, read on.
-</p>
-
-<div class="detail">
-
-<p>
-There are two official Go compiler toolchains.
-This document focuses on the <code>gc</code> Go
-compiler and tools.
-For information on how to work on <code>gccgo</code>, a more traditional
-compiler using the GCC back end, see
-<a href="/doc/install/gccgo">Setting up and using gccgo</a>.
-</p>
-
-<p>
-The Go compilers support the following instruction sets:
-
-<dl>
-<dt>
-  <code>amd64</code>, <code>386</code>
-</dt>
-<dd>
-  The <code>x86</code> instruction set, 64- and 32-bit.
-</dd>
-<dt>
-  <code>arm64</code>, <code>arm</code>
-</dt>
-<dd>
-  The <code>ARM</code> instruction set, 64-bit (<code>AArch64</code>) and 32-bit.
-</dd>
-<dt>
-  <code>mips64</code>, <code>mips64le</code>, <code>mips</code>,  <code>mipsle</code>
-</dt>
-<dd>
-  The <code>MIPS</code> instruction set, big- and little-endian, 64- and 32-bit.
-</dd>
-<dt>
-  <code>ppc64</code>, <code>ppc64le</code>
-</dt>
-<dd>
-  The 64-bit PowerPC instruction set, big- and little-endian.
-</dd>
-<dt>
-  <code>riscv64</code>
-</dt>
-<dd>
-  The 64-bit RISC-V instruction set.
-</dd>
-<dt>
-  <code>s390x</code>
-</dt>
-<dd>
-  The IBM z/Architecture.
-</dd>
-<dt>
-  <code>wasm</code>
-</dt>
-<dd>
-  <a href="https://webassembly.org">WebAssembly</a>.
-</dd>
-</dl>
-</p>
-
-<p>
-The compilers can target the AIX, Android, DragonFly BSD, FreeBSD,
-Illumos, Linux, macOS/iOS (Darwin), NetBSD, OpenBSD, Plan 9, Solaris,
-and Windows operating systems (although not all operating systems
-support all architectures).
-</p>
-
-<p>
-A list of ports which are considered "first class" is available at the
-<a href="/wiki/PortingPolicy#first-class-ports">first class ports</a>
-wiki page.
-</p>
-
-<p>
-The full set of supported combinations is listed in the
-discussion of <a href="#environment">environment variables</a> below.
-</p>
-
-<p>
-See the main installation page for the <a href="/doc/install#requirements">overall system requirements</a>.
-The following additional constraints apply to systems that can be built only from source:
-</p>
-
-<ul>
-<li>For Linux on PowerPC 64-bit, the minimum supported kernel version is 2.6.37, meaning that
-Go does not support CentOS 6 on these systems.
-</li>
-</ul>
-
-</div>
-
-<h2 id="go14">Install Go compiler binaries for bootstrap</h2>
-
-<p>
-The Go toolchain is written in Go. To build it, you need a Go compiler installed.
-The scripts that do the initial build of the tools look for a "go" command
-in <code>$PATH</code>, so as long as you have Go installed in your
-system and configured in your <code>$PATH</code>, you are ready to build Go
-from source.
-Or if you prefer you can set <code>$GOROOT_BOOTSTRAP</code> to the
-root of a Go installation to use to build the new Go toolchain;
-<code>$GOROOT_BOOTSTRAP/bin/go</code> should be the go command to use.</p>
-
-<p>
-There are four possible ways to obtain a bootstrap toolchain:
-</p>
-
-<ul>
-<li>Download a recent binary release of Go.
-<li>Cross-compile a toolchain using a system with a working Go installation.
-<li>Use gccgo.
-<li>Compile a toolchain from Go 1.4, the last Go release with a compiler written in C.
-</ul>
-
-<p>
-These approaches are detailed below.
-</p>
-
-<h3 id="bootstrapFromBinaryRelease">Bootstrap toolchain from binary release</h3>
-
-<p>
-To use a binary release as a bootstrap toolchain, see
-<a href="/dl/">the downloads page</a> or use any other
-packaged Go distribution.
-</p>
-
-<h3 id="bootstrapFromCrosscompiledSource">Bootstrap toolchain from cross-compiled source</h3>
-
-<p>
-To cross-compile a bootstrap toolchain from source, which is
-necessary on systems Go 1.4 did not target (for
-example, <code>linux/ppc64le</code>), install Go on a different system
-and run <a href="/src/bootstrap.bash">bootstrap.bash</a>.
-</p>
-
-<p>
-When run as (for example)
-</p>
-
-<pre>
-$ GOOS=linux GOARCH=ppc64 ./bootstrap.bash
-</pre>
-
-<p>
-<code>bootstrap.bash</code> cross-compiles a toolchain for that <code>GOOS/GOARCH</code>
-combination, leaving the resulting tree in <code>../../go-${GOOS}-${GOARCH}-bootstrap</code>.
-That tree can be copied to a machine of the given target type
-and used as <code>GOROOT_BOOTSTRAP</code> to bootstrap a local build.
-</p>
-
-<h3 id="bootstrapFromGccgo">Bootstrap toolchain using gccgo</h3>
-
-<p>
-To use gccgo as the bootstrap toolchain, you need to arrange
-for <code>$GOROOT_BOOTSTRAP/bin/go</code> to be the go tool that comes
-as part of gccgo 5. For example on Ubuntu Vivid:
-</p>
-
-<pre>
-$ sudo apt-get install gccgo-5
-$ sudo update-alternatives --set go /usr/bin/go-5
-$ GOROOT_BOOTSTRAP=/usr ./make.bash
-</pre>
-
-<h3 id="bootstrapFromSource">Bootstrap toolchain from C source code</h3>
-
-<p>
-To build a bootstrap toolchain from C source code, use
-either the git branch <code>release-branch.go1.4</code> or
-<a href="https://dl.google.com/go/go1.4-bootstrap-20171003.tar.gz">go1.4-bootstrap-20171003.tar.gz</a>,
-which contains the Go 1.4 source code plus accumulated fixes
-to keep the tools running on newer operating systems.
-(Go 1.4 was the last distribution in which the toolchain was written in C.)
-After unpacking the Go 1.4 source, <code>cd</code> to
-the <code>src</code> subdirectory, set <code>CGO_ENABLED=0</code> in
-the environment, and run <code>make.bash</code> (or,
-on Windows, <code>make.bat</code>).
-</p>
-
-<p>
-Once the Go 1.4 source has been unpacked into your GOROOT_BOOTSTRAP directory,
-you must keep this git clone instance checked out to branch
-<code>release-branch.go1.4</code>.  Specifically, do not attempt to reuse
-this git clone in the later step named "Fetch the repository."  The go1.4
-bootstrap toolchain <b>must be able</b> to properly traverse the go1.4 sources
-that it assumes are present under this repository root.
-</p>
-
-<p>
-Note that Go 1.4 does not run on all systems that later versions of Go do.
-In particular, Go 1.4 does not support current versions of macOS.
-On such systems, the bootstrap toolchain must be obtained using one of the other methods.
-</p>
-
-<h2 id="git">Install Git, if needed</h2>
-
-<p>
-To perform the next step you must have Git installed. (Check that you
-have a <code>git</code> command before proceeding.)
-</p>
-
-<p>
-If you do not have a working Git installation,
-follow the instructions on the
-<a href="https://git-scm.com/downloads">Git downloads</a> page.
-</p>
-
-<h2 id="ccompiler">(Optional) Install a C compiler</h2>
-
-<p>
-To build a Go installation
-with <code><a href="/cmd/cgo">cgo</a></code> support, which permits Go
-programs to import C libraries, a C compiler such as <code>gcc</code>
-or <code>clang</code> must be installed first. Do this using whatever
-installation method is standard on the system.
-</p>
-
-<p>
-To build without <code>cgo</code>, set the environment variable
-<code>CGO_ENABLED=0</code> before running <code>all.bash</code> or
-<code>make.bash</code>.
-</p>
-
-<h2 id="fetch">Fetch the repository</h2>
-
-<p>Change to the directory where you intend to install Go, and make sure
-the <code>goroot</code> directory does not exist. Then clone the repository
-and check out the latest release tag (<code class="versionTag">go1.12</code>,
-for example):</p>
-
-<pre>
-$ git clone https://go.googlesource.com/go goroot
-$ cd goroot
-$ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></span>
-</pre>
-
-<p class="whereTag">
-Where <code>&lt;tag&gt;</code> is the version string of the release.
-</p>
-
-<p>Go will be installed in the directory where it is checked out. For example,
-if Go is checked out in <code>$HOME/goroot</code>, executables will be installed
-in <code>$HOME/goroot/bin</code>. The directory may have any name, but note
-that if Go is checked out in <code>$HOME/go</code>, it will conflict with
-the default location of <code>$GOPATH</code>.
-See <a href="#gopath"><code>GOPATH</code></a> below.</p>
-
-<p>
-Reminder: If you opted to also compile the bootstrap binaries from source (in an
-earlier section), you still need to <code>git clone</code> again at this point
-(to checkout the latest <code>&lt;tag&gt;</code>), because you must keep your
-go1.4 repository distinct.
-</p>
-
-<h2 id="head">(Optional) Switch to the master branch</h2>
-
-<p>If you intend to modify the go source code, and
-<a href="/doc/contribute.html">contribute your changes</a>
-to the project, then move your repository
-off the release branch, and onto the master (development) branch.
-Otherwise, skip this step.</p>
-
-<pre>
-$ git checkout master
-</pre>
-
-<h2 id="install">Install Go</h2>
-
-<p>
-To build the Go distribution, run
-</p>
-
-<pre>
-$ cd src
-$ ./all.bash
-</pre>
-
-<p>
-(To build under Windows use <code>all.bat</code>.)
-</p>
-
-<p>
-If all goes well, it will finish by printing output like:
-</p>
-
-<pre>
-ALL TESTS PASSED
-
----
-Installed Go for linux/amd64 in /home/you/go.
-Installed commands in /home/you/go/bin.
-*** You need to add /home/you/go/bin to your $PATH. ***
-</pre>
-
-<p>
-where the details on the last few lines reflect the operating system,
-architecture, and root directory used during the install.
-</p>
-
-<div class="detail">
-<p>
-For more information about ways to control the build, see the discussion of
-<a href="#environment">environment variables</a> below.
-<code>all.bash</code> (or <code>all.bat</code>) runs important tests for Go,
-which can take more time than simply building Go. If you do not want to run
-the test suite use <code>make.bash</code> (or <code>make.bat</code>)
-instead.
-</p>
-</div>
-
-
-<h2 id="testing">Testing your installation</h2>
-
-<p>
-Check that Go is installed correctly by building a simple program.
-</p>
-
-<p>
-Create a file named <code>hello.go</code> and put the following program in it:
-</p>
-
-<pre>
-package main
-
-import "fmt"
-
-func main() {
-       fmt.Printf("hello, world\n")
-}
-</pre>
-
-<p>
-Then run it with the <code>go</code> tool:
-</p>
-
-<pre>
-$ go run hello.go
-hello, world
-</pre>
-
-<p>
-If you see the "hello, world" message then Go is installed correctly.
-</p>
-
-<h2 id="gopath">Set up your work environment</h2>
-
-<p>
-You're almost done.
-You just need to do a little more setup.
-</p>
-
-<p>
-<a href="/doc/code.html" class="download" id="start">
-<span class="big">How to Write Go Code</span>
-<span class="desc">Learn how to set up and use the Go tools</span>
-</a>
-</p>
-
-<p>
-The <a href="/doc/code.html">How to Write Go Code</a> document
-provides <b>essential setup instructions</b> for using the Go tools.
-</p>
-
-
-<h2 id="tools">Install additional tools</h2>
-
-<p>
-The source code for several Go tools (including <a href="/cmd/godoc/">godoc</a>)
-is kept in <a href="https://golang.org/x/tools">the go.tools repository</a>.
-To install one of the tools (<code>godoc</code> in this case):
-</p>
-
-<pre>
-$ go get golang.org/x/tools/cmd/godoc
-</pre>
-
-<p>
-To install these tools, the <code>go</code> <code>get</code> command requires
-that <a href="#git">Git</a> be installed locally.
-</p>
-
-<p>
-You must also have a workspace (<code>GOPATH</code>) set up;
-see <a href="/doc/code.html">How to Write Go Code</a> for the details.
-</p>
-
-<h2 id="community">Community resources</h2>
-
-<p>
-The usual community resources such as
-<code>#go-nuts</code> on the <a href="https://freenode.net/">Freenode</a> IRC server
-and the
-<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>
-mailing list have active developers that can help you with problems
-with your installation or your development work.
-For those who wish to keep up to date,
-there is another mailing list, <a href="//groups.google.com/group/golang-checkins">golang-checkins</a>,
-that receives a message summarizing each checkin to the Go repository.
-</p>
-
-<p>
-Bugs can be reported using the <a href="//golang.org/issue/new">Go issue tracker</a>.
-</p>
-
-
-<h2 id="releases">Keeping up with releases</h2>
-
-<p>
-New releases are announced on the
-<a href="//groups.google.com/group/golang-announce">golang-announce</a>
-mailing list.
-Each announcement mentions the latest release tag, for instance,
-<code class="versionTag">go1.9</code>.
-</p>
-
-<p>
-To update an existing tree to the latest release, you can run:
-</p>
-
-<pre>
-$ cd go/src
-$ git fetch
-$ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></psan>
-$ ./all.bash
-</pre>
-
-<p class="whereTag">
-Where <code>&lt;tag&gt;</code> is the version string of the release.
-</p>
-
-
-<h2 id="environment">Optional environment variables</h2>
-
-<p>
-The Go compilation environment can be customized by environment variables.
-<i>None is required by the build</i>, but you may wish to set some
-to override the defaults.
-</p>
-
-<ul>
-<li><code>$GOROOT</code>
-<p>
-The root of the Go tree, often <code>$HOME/go1.X</code>.
-Its value is built into the tree when it is compiled, and
-defaults to the parent of the directory where <code>all.bash</code> was run.
-There is no need to set this unless you want to switch between multiple
-local copies of the repository.
-</p>
-</li>
-
-<li><code>$GOROOT_FINAL</code>
-<p>
-The value assumed by installed binaries and scripts when
-<code>$GOROOT</code> is not set explicitly.
-It defaults to the value of <code>$GOROOT</code>.
-If you want to build the Go tree in one location
-but move it elsewhere after the build, set
-<code>$GOROOT_FINAL</code> to the eventual location.
-</p>
-</li>
-
-<li id="gopath"><code>$GOPATH</code>
-<p>
-The directory where Go projects outside the Go distribution are typically
-checked out. For example, <code>golang.org/x/tools</code> might be checked out
-to <code>$GOPATH/src/golang.org/x/tools</code>. Executables outside the
-Go distribution are installed in <code>$GOPATH/bin</code> (or
-<code>$GOBIN</code>, if set). Modules are downloaded and cached in
-<code>$GOPATH/pkg/mod</code>.
-</p>
-
-<p>The default location of <code>$GOPATH</code> is <code>$HOME/go</code>,
-and it's not usually necessary to set <code>GOPATH</code> explicitly. However,
-if you have checked out the Go distribution to <code>$HOME/go</code>,
-you must set <code>GOPATH</code> to another location to avoid conflicts.
-</p>
-</li>
-
-<li><code>$GOBIN</code>
-<p>
-The directory where executables outside the Go distribution are installed
-using the <a href="/cmd/go">go command</a>. For example,
-<code>go get golang.org/x/tools/cmd/godoc</code> downloads, builds, and
-installs <code>$GOBIN/godoc</code>. By default, <code>$GOBIN</code> is
-<code>$GOPATH/bin</code> (or <code>$HOME/go/bin</code> if <code>GOPATH</code>
-is not set). After installing, you will want to add this directory to
-your <code>$PATH</code> so you can use installed tools.
-</p>
-
-<p>
-Note that the Go distribution's executables are installed in
-<code>$GOROOT/bin</code> (for executables invoked by people) or
-<code>$GOTOOLDIR</code> (for executables invoked by the go command;
-defaults to <code>$GOROOT/pkg/$GOOS_GOARCH</code>) instead of
-<code>$GOBIN</code>.
-</p>
-</li>
-
-<li><code>$GOOS</code> and <code>$GOARCH</code>
-<p>
-The name of the target operating system and compilation architecture.
-These default to the values of <code>$GOHOSTOS</code> and
-<code>$GOHOSTARCH</code> respectively (described below).
-</li>
-
-<p>
-Choices for <code>$GOOS</code> are
-<code>android</code>, <code>darwin</code>, <code>dragonfly</code>,
-<code>freebsd</code>, <code>illumos</code>, <code>ios</code>, <code>js</code>,
-<code>linux</code>, <code>netbsd</code>, <code>openbsd</code>,
-<code>plan9</code>, <code>solaris</code> and <code>windows</code>.
-</p>
-
-<p>
-Choices for <code>$GOARCH</code> are
-<code>amd64</code> (64-bit x86, the most mature port),
-<code>386</code> (32-bit x86), <code>arm</code> (32-bit ARM), <code>arm64</code> (64-bit ARM),
-<code>ppc64le</code> (PowerPC 64-bit, little-endian), <code>ppc64</code> (PowerPC 64-bit, big-endian),
-<code>mips64le</code> (MIPS 64-bit, little-endian), <code>mips64</code> (MIPS 64-bit, big-endian),
-<code>mipsle</code> (MIPS 32-bit, little-endian), <code>mips</code> (MIPS 32-bit, big-endian),
-<code>s390x</code> (IBM System z 64-bit, big-endian), and
-<code>wasm</code> (WebAssembly 32-bit).
-</p>
-
-<p>
-The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
-<table cellpadding="0">
-<tr>
-<th width="50"></th><th align="left" width="100"><code>$GOOS</code></th> <th align="left" width="100"><code>$GOARCH</code></th>
-</tr>
-<tr>
-<td></td><td><code>aix</code></td> <td><code>ppc64</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>darwin</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>darwin</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>dragonfly</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>freebsd</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>freebsd</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>freebsd</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>illumos</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>ios</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>js</code></td> <td><code>wasm</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>ppc64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>ppc64le</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mipsle</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips64le</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>riscv64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>s390x</code></td>
-</tr>
-<tr>
-<td></td><td><code>netbsd</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>netbsd</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>netbsd</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>openbsd</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>openbsd</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>openbsd</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>openbsd</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>plan9</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>plan9</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>plan9</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>solaris</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>windows</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>windows</code></td> <td><code>amd64</code></td>
-</tr>
-</table>
-<br>
-
-<li><code>$GOHOSTOS</code> and <code>$GOHOSTARCH</code>
-<p>
-The name of the host operating system and compilation architecture.
-These default to the local system's operating system and
-architecture.
-</p>
-</li>
-
-<p>
-Valid choices are the same as for <code>$GOOS</code> and
-<code>$GOARCH</code>, listed above.
-The specified values must be compatible with the local system.
-For example, you should not set <code>$GOHOSTARCH</code> to
-<code>arm</code> on an x86 system.
-</p>
-
-<li><code>$GO386</code> (for <code>386</code> only, defaults to <code>sse2</code>)
-<p>
-This variable controls how gc implements floating point computations.
-</p>
-<ul>
-       <li><code>GO386=softfloat</code>: use software floating point operations; should support all x86 chips (Pentium MMX or later).</li>
-       <li><code>GO386=sse2</code>: use SSE2 for floating point operations; has better performance but only available on Pentium 4/Opteron/Athlon 64 or later.</li>
-</ul>
-</li>
-
-<li><code>$GOARM</code> (for <code>arm</code> only; default is auto-detected if building
-on the target processor, 6 if not)
-<p>
-This sets the ARM floating point co-processor architecture version the run-time
-should target. If you are compiling on the target system, its value will be auto-detected.
-</p>
-<ul>
-       <li><code>GOARM=5</code>: use software floating point; when CPU doesn't have VFP co-processor</li>
-       <li><code>GOARM=6</code>: use VFPv1 only; default if cross compiling; usually ARM11 or better cores (VFPv2 or better is also supported)</li>
-       <li><code>GOARM=7</code>: use VFPv3; usually Cortex-A cores</li>
-</ul>
-<p>
-If in doubt, leave this variable unset, and adjust it if required
-when you first run the Go executable.
-The <a href="//golang.org/wiki/GoArm">GoARM</a> page
-on the <a href="//golang.org/wiki">Go community wiki</a>
-contains further details regarding Go's ARM support.
-</p>
-</li>
-
-<li><code>$GOMIPS</code> (for <code>mips</code> and <code>mipsle</code> only) <br> <code>$GOMIPS64</code> (for <code>mips64</code> and <code>mips64le</code> only)
-<p>
-       These variables set whether to use floating point instructions. Set to "<code>hardfloat</code>" to use floating point instructions; this is the default.  Set to "<code>softfloat</code>" to use soft floating point.
-</p>
-</li>
-
-<li><code>$GOPPC64</code> (for <code>ppc64</code> and <code>ppc64le</code> only)
-<p>
-This variable sets the processor level (i.e. Instruction Set Architecture version)
-for which the compiler will target. The default is <code>power8</code>.
-</p>
-<ul>
-       <li><code>GOPPC64=power8</code>: generate ISA v2.07 instructions</li>
-       <li><code>GOPPC64=power9</code>: generate ISA v3.00 instructions</li>
-</ul>
-</li>
-
-
-<li><code>$GOWASM</code> (for <code>wasm</code> only)
-       <p>
-       This variable is a comma separated list of <a href="https://github.com/WebAssembly/proposals">experimental WebAssembly features</a> that the compiled WebAssembly binary is allowed to use.
-       The default is to use no experimental features.
-       </p>
-       <ul>
-               <li><code>GOWASM=satconv</code>: generate <a href="https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md">saturating (non-trapping) float-to-int conversions</a></li>
-               <li><code>GOWASM=signext</code>: generate <a href="https://github.com/WebAssembly/sign-extension-ops/blob/master/proposals/sign-extension-ops/Overview.md">sign-extension operators</a></li>
-       </ul>
-</li>
-
-</ul>
-
-<p>
-Note that <code>$GOARCH</code> and <code>$GOOS</code> identify the
-<em>target</em> environment, not the environment you are running on.
-In effect, you are always cross-compiling.
-By architecture, we mean the kind of binaries
-that the target environment can run:
-an x86-64 system running a 32-bit-only operating system
-must set <code>GOARCH</code> to <code>386</code>,
-not <code>amd64</code>.
-</p>
-
-<p>
-If you choose to override the defaults,
-set these variables in your shell profile (<code>$HOME/.bashrc</code>,
-<code>$HOME/.profile</code>, or equivalent). The settings might look
-something like this:
-</p>
-
-<pre>
-export GOARCH=amd64
-export GOOS=linux
-</pre>
-
-<p>
-although, to reiterate, none of these variables needs to be set to build,
-install, and develop the Go tree.
-</p>

diff --git a/doc/install.html b/doc/install.html
deleted file mode 100644 (file)
index 706d66c..0000000
--- a/doc/install.html
+++ /dev/null
@@ -1,315 +0,0 @@
-<!--{
-       "Title": "Getting Started",
-       "Path":  "/doc/install"
-}-->
-
-<div class="hideFromDownload">
-
-<h2 id="download">Download the Go distribution</h2>
-
-<p>
-<a href="/dl/" id="start" class="download">
-<span class="big">Download Go</span>
-<span class="desc">Click here to visit the downloads page</span>
-</a>
-</p>
-
-<p>
-<a href="/dl/" target="_blank">Official binary
-distributions</a> are available for the FreeBSD (release 10-STABLE and above),
-Linux, macOS (10.11 and above), and Windows operating systems and
-the 32-bit (<code>386</code>) and 64-bit (<code>amd64</code>) x86 processor
-architectures.
-</p>
-
-<p>
-If a binary distribution is not available for your combination of operating
-system and architecture, try
-<a href="/doc/install/source">installing from source</a> or
-<a href="/doc/install/gccgo">installing gccgo instead of gc</a>.
-</p>
-
-
-<h2 id="requirements">System requirements</h2>
-
-<p>
-Go <a href="/dl/">binary distributions</a> are available for these supported operating systems and architectures.
-Please ensure your system meets these requirements before proceeding.
-If your OS or architecture is not on the list, you may be able to
-<a href="/doc/install/source">install from source</a> or
-<a href="/doc/install/gccgo">use gccgo instead</a>.
-</p>
-
-<table class="codetable" frame="border" summary="requirements">
-<tr>
-<th align="center">Operating system</th>
-<th align="center">Architectures</th>
-<th align="center">Notes</th>
-</tr>
-<tr><td colspan="3"><hr></td></tr>
-<tr><td>FreeBSD 10.3 or later</td> <td>amd64, 386</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
-<tr valign='top'><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm, arm64,<br>s390x, ppc64le</td> <td>CentOS/RHEL 5.x not supported.<br>Install from source for other libc.</td></tr>
-<tr><td>macOS 10.11 or later</td> <td>amd64</td> <td>use the clang or gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup> for <code>cgo</code> support</td></tr>
-<tr valign='top'><td>Windows 7, Server 2008R2 or later</td> <td>amd64, 386</td> <td>use MinGW (<code>386</code>) or MinGW-W64 (<code>amd64</code>) gcc<sup>&#8224;</sup>.<br>No need for cygwin or msys.</td></tr>
-</table>
-
-<p>
-<sup>&#8224;</sup>A C compiler is required only if you plan to use
-<a href="/cmd/cgo">cgo</a>.<br/>
-<sup>&#8225;</sup>You only need to install the command line tools for
-<a href="https://developer.apple.com/Xcode/">Xcode</a>. If you have already
-installed Xcode 4.3+, you can install it from the Components tab of the
-Downloads preferences panel.
-</p>
-
-</div><!-- hideFromDownload -->
-
-
-<h2 id="install">Install the Go tools</h2>
-
-<p>
-If you are upgrading from an older version of Go you must
-first <a href="#uninstall">remove the existing version</a>.
-</p>
-
-<div id="tarballInstructions">
-
-<h3 id="tarball">Linux, macOS, and FreeBSD tarballs</h3>
-
-<p>
-<a href="/dl/">Download the archive</a>
-and extract it into <code>/usr/local</code>, creating a Go tree in
-<code>/usr/local/go</code>. For example:
-</p>
-
-<pre>
-tar -C /usr/local -xzf <span class="downloadFilename">go$VERSION.$OS-$ARCH.tar.gz</span>
-</pre>
-
-<p class="hideFromDownload">
-Choose the archive file appropriate for your installation.
-For instance, if you are installing Go version 1.2.1 for 64-bit x86 on Linux,
-the archive you want is called <code>go1.2.1.linux-amd64.tar.gz</code>.
-</p>
-
-<p>
-(Typically these commands must be run as root or through <code>sudo</code>.)
-</p>
-
-<p>
-Add <code>/usr/local/go/bin</code> to the <code>PATH</code> environment
-variable. You can do this by adding this line to your <code>/etc/profile</code>
-(for a system-wide installation) or <code>$HOME/.profile</code>:
-</p>
-
-<pre>
-export PATH=$PATH:/usr/local/go/bin
-</pre>
-
-<p>
-<b>Note</b>: changes made to a <code>profile</code> file may not apply until the
-next time you log into your computer.
-To apply the changes immediately, just run the shell commands directly
-or execute them from the profile using a command such as
-<code>source $HOME/.profile</code>.
-</p>
-
-</div><!-- tarballInstructions -->
-
-<div id="darwinPackageInstructions">
-
-<h3 id="macos"><div id="osx"></div>macOS package installer</h3>
-
-<p>
-<a href="/dl/">Download the package file</a>,
-open it, and follow the prompts to install the Go tools.
-The package installs the Go distribution to <code>/usr/local/go</code>.
-</p>
-
-<p>
-The package should put the <code>/usr/local/go/bin</code> directory in your
-<code>PATH</code> environment variable. You may need to restart any open
-Terminal sessions for the change to take effect.
-</p>
-
-</div><!-- darwinPackageInstructions -->
-
-<div id="windowsInstructions">
-
-<h3 id="windows">Windows</h3>
-
-<p class="hideFromDownload">
-The Go project provides two installation options for Windows users
-(besides <a href="/doc/install/source">installing from source</a>):
-a zip archive that requires you to set some environment variables and an
-MSI installer that configures your installation automatically.
-</p>
-
-<div id="windowsInstallerInstructions">
-
-<h4 id="windows_msi">MSI installer</h4>
-
-<p>
-Open the <a href="/dl/">MSI file</a>
-and follow the prompts to install the Go tools.
-By default, the installer puts the Go distribution in <code>c:\Go</code>.
-</p>
-
-<p>
-The installer should put the <code>c:\Go\bin</code> directory in your
-<code>PATH</code> environment variable. You may need to restart any open
-command prompts for the change to take effect.
-</p>
-
-</div><!-- windowsInstallerInstructions -->
-
-<div id="windowsZipInstructions">
-
-<h4 id="windows_zip">Zip archive</h4>
-
-<p>
-<a href="/dl/">Download the zip file</a> and extract it into the directory of your choice (we suggest <code>c:\Go</code>).
-</p>
-
-<p>
-Add the <code>bin</code> subdirectory of your Go root (for example, <code>c:\Go\bin</code>) to your <code>PATH</code> environment variable.
-</p>
-
-</div><!-- windowsZipInstructions -->
-
-<h4 id="windows_env">Setting environment variables under Windows</h4>
-
-<p>
-Under Windows, you may set environment variables through the "Environment
-Variables" button on the "Advanced" tab of the "System" control panel. Some
-versions of Windows provide this control panel through the "Advanced System
-Settings" option inside the "System" control panel.
-</p>
-
-</div><!-- windowsInstructions -->
-
-
-<h2 id="testing">Test your installation</h2>
-
-<p>
-Check that Go is installed correctly by building a simple program, as follows.
-</p>
-
-<p>
-Create a file named <code>hello.go</code> that looks like:
-</p>
-
-<pre>
-package main
-
-import "fmt"
-
-func main() {
-       fmt.Printf("hello, world\n")
-}
-</pre>
-
-<p>
-Then build it with the <code>go</code> tool:
-</p>
-
-<pre class="testUnix">
-$ <b>go build hello.go</b>
-</pre>
-
-<pre class="testWindows">
-C:\Users\Gopher\go\src\hello&gt; <b>go build hello.go</b>
-</pre>
-
-<p>
-The command above will build an executable named
-<code class="testUnix">hello</code><code class="testWindows">hello.exe</code>
-in the current directory alongside your source code.
-Execute it to see the greeting:
-</p>
-
-<pre class="testUnix">
-$ <b>./hello</b>
-hello, world
-</pre>
-
-<pre class="testWindows">
-C:\Users\Gopher\go\src\hello&gt; <b>hello</b>
-hello, world
-</pre>
-
-<p>
-If you see the "hello, world" message then your Go installation is working.
-</p>
-
-<p>
-Before rushing off to write Go code please read the
-<a href="/doc/code.html">How to Write Go Code</a> document,
-which describes some essential concepts about using the Go tools.
-</p>
-
-
-<h2 id="extra_versions">Installing extra Go versions</h2>
-
-<p>
-It may be useful to have multiple Go versions installed on the same machine, for
-example, to ensure that a package's tests pass on multiple Go versions.
-Once you have one Go version installed, you can install another (such as 1.10.7)
-as follows:
-</p>
-
-<pre>
-$ go get golang.org/dl/go1.10.7
-$ go1.10.7 download
-</pre>
-
-<p>
-The newly downloaded version can be used like <code>go</code>:
-</p>
-
-<pre>
-$ go1.10.7 version
-go version go1.10.7 linux/amd64
-</pre>
-
-<p>
-All Go versions available via this method are listed on
-<a href="https://godoc.org/golang.org/dl#pkg-subdirectories">the download page</a>.
-You can find where each of these extra Go versions is installed by looking
-at its <code>GOROOT</code>; for example, <code>go1.10.7 env GOROOT</code>.
-To uninstall a downloaded version, just remove its <code>GOROOT</code> directory
-and the <code>goX.Y.Z</code> binary.
-</p>
-
-
-<h2 id="uninstall">Uninstalling Go</h2>
-
-<p>
-To remove an existing Go installation from your system delete the
-<code>go</code> directory. This is usually <code>/usr/local/go</code>
-under Linux, macOS, and FreeBSD or <code>c:\Go</code>
-under Windows.
-</p>
-
-<p>
-You should also remove the Go <code>bin</code> directory from your
-<code>PATH</code> environment variable.
-Under Linux and FreeBSD you should edit <code>/etc/profile</code> or
-<code>$HOME/.profile</code>.
-If you installed Go with the <a href="#macos">macOS package</a> then you
-should remove the <code>/etc/paths.d/go</code> file.
-Windows users should read the section about <a href="#windows_env">setting
-environment variables under Windows</a>.
-</p>
-
-
-<h2 id="help">Getting help</h2>
-
-<p>
-  For help, see the <a href="/help/">list of Go mailing lists, forums, and places to chat</a>.
-</p>
-
-<p>
-  Report bugs either by running “<b><code>go</code> <code>bug</code></b>”, or
-  manually at the <a href="https://golang.org/issue">Go issue tracker</a>.
-</p>

diff --git a/doc/play/fib.go b/doc/play/fib.go
deleted file mode 100644 (file)
index 19e4721..0000000
--- a/doc/play/fib.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package main
-
-import "fmt"
-
-// fib returns a function that returns
-// successive Fibonacci numbers.
-func fib() func() int {
-       a, b := 0, 1
-       return func() int {
-               a, b = b, a+b
-               return a
-       }
-}
-
-func main() {
-       f := fib()
-       // Function calls are evaluated left-to-right.
-       fmt.Println(f(), f(), f(), f(), f())
-}

diff --git a/doc/play/hello.go b/doc/play/hello.go
deleted file mode 100644 (file)
index 3badf12..0000000
--- a/doc/play/hello.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// You can edit this code!
-// Click here and start typing.
-package main
-
-import "fmt"
-
-func main() {
-       fmt.Println("Hello, 世界")
-}

diff --git a/doc/play/life.go b/doc/play/life.go
deleted file mode 100644 (file)
index 51afb61..0000000
--- a/doc/play/life.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// An implementation of Conway's Game of Life.
-package main
-
-import (
-       "bytes"
-       "fmt"
-       "math/rand"
-       "time"
-)
-
-// Field represents a two-dimensional field of cells.
-type Field struct {
-       s    [][]bool
-       w, h int
-}
-
-// NewField returns an empty field of the specified width and height.
-func NewField(w, h int) *Field {
-       s := make([][]bool, h)
-       for i := range s {
-               s[i] = make([]bool, w)
-       }
-       return &Field{s: s, w: w, h: h}
-}
-
-// Set sets the state of the specified cell to the given value.
-func (f *Field) Set(x, y int, b bool) {
-       f.s[y][x] = b
-}
-
-// Alive reports whether the specified cell is alive.
-// If the x or y coordinates are outside the field boundaries they are wrapped
-// toroidally. For instance, an x value of -1 is treated as width-1.
-func (f *Field) Alive(x, y int) bool {
-       x += f.w
-       x %= f.w
-       y += f.h
-       y %= f.h
-       return f.s[y][x]
-}
-
-// Next returns the state of the specified cell at the next time step.
-func (f *Field) Next(x, y int) bool {
-       // Count the adjacent cells that are alive.
-       alive := 0
-       for i := -1; i <= 1; i++ {
-               for j := -1; j <= 1; j++ {
-                       if (j != 0 || i != 0) && f.Alive(x+i, y+j) {
-                               alive++
-                       }
-               }
-       }
-       // Return next state according to the game rules:
-       //   exactly 3 neighbors: on,
-       //   exactly 2 neighbors: maintain current state,
-       //   otherwise: off.
-       return alive == 3 || alive == 2 && f.Alive(x, y)
-}
-
-// Life stores the state of a round of Conway's Game of Life.
-type Life struct {
-       a, b *Field
-       w, h int
-}
-
-// NewLife returns a new Life game state with a random initial state.
-func NewLife(w, h int) *Life {
-       a := NewField(w, h)
-       for i := 0; i < (w * h / 4); i++ {
-               a.Set(rand.Intn(w), rand.Intn(h), true)
-       }
-       return &Life{
-               a: a, b: NewField(w, h),
-               w: w, h: h,
-       }
-}
-
-// Step advances the game by one instant, recomputing and updating all cells.
-func (l *Life) Step() {
-       // Update the state of the next field (b) from the current field (a).
-       for y := 0; y < l.h; y++ {
-               for x := 0; x < l.w; x++ {
-                       l.b.Set(x, y, l.a.Next(x, y))
-               }
-       }
-       // Swap fields a and b.
-       l.a, l.b = l.b, l.a
-}
-
-// String returns the game board as a string.
-func (l *Life) String() string {
-       var buf bytes.Buffer
-       for y := 0; y < l.h; y++ {
-               for x := 0; x < l.w; x++ {
-                       b := byte(' ')
-                       if l.a.Alive(x, y) {
-                               b = '*'
-                       }
-                       buf.WriteByte(b)
-               }
-               buf.WriteByte('\n')
-       }
-       return buf.String()
-}
-
-func main() {
-       l := NewLife(40, 15)
-       for i := 0; i < 300; i++ {
-               l.Step()
-               fmt.Print("\x0c", l) // Clear screen and print field.
-               time.Sleep(time.Second / 30)
-       }
-}

diff --git a/doc/play/peano.go b/doc/play/peano.go
deleted file mode 100644 (file)
index 214fe1b..0000000
--- a/doc/play/peano.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Peano integers are represented by a linked
-// list whose nodes contain no data
-// (the nodes are the data).
-// http://en.wikipedia.org/wiki/Peano_axioms
-
-// This program demonstrates that Go's automatic
-// stack management can handle heavily recursive
-// computations.
-
-package main
-
-import "fmt"
-
-// Number is a pointer to a Number
-type Number *Number
-
-// The arithmetic value of a Number is the
-// count of the nodes comprising the list.
-// (See the count function below.)
-
-// -------------------------------------
-// Peano primitives
-
-func zero() *Number {
-       return nil
-}
-
-func isZero(x *Number) bool {
-       return x == nil
-}
-
-func add1(x *Number) *Number {
-       e := new(Number)
-       *e = x
-       return e
-}
-
-func sub1(x *Number) *Number {
-       return *x
-}
-
-func add(x, y *Number) *Number {
-       if isZero(y) {
-               return x
-       }
-       return add(add1(x), sub1(y))
-}
-
-func mul(x, y *Number) *Number {
-       if isZero(x) || isZero(y) {
-               return zero()
-       }
-       return add(mul(x, sub1(y)), x)
-}
-
-func fact(n *Number) *Number {
-       if isZero(n) {
-               return add1(zero())
-       }
-       return mul(fact(sub1(n)), n)
-}
-
-// -------------------------------------
-// Helpers to generate/count Peano integers
-
-func gen(n int) *Number {
-       if n > 0 {
-               return add1(gen(n - 1))
-       }
-       return zero()
-}
-
-func count(x *Number) int {
-       if isZero(x) {
-               return 0
-       }
-       return count(sub1(x)) + 1
-}
-
-// -------------------------------------
-// Print i! for i in [0,9]
-
-func main() {
-       for i := 0; i <= 9; i++ {
-               f := count(fact(gen(i)))
-               fmt.Println(i, "! =", f)
-       }
-}

diff --git a/doc/play/pi.go b/doc/play/pi.go
deleted file mode 100644 (file)
index f61884e..0000000
--- a/doc/play/pi.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Concurrent computation of pi.
-// See https://goo.gl/la6Kli.
-//
-// This demonstrates Go's ability to handle
-// large numbers of concurrent processes.
-// It is an unreasonable way to calculate pi.
-package main
-
-import (
-       "fmt"
-       "math"
-)
-
-func main() {
-       fmt.Println(pi(5000))
-}
-
-// pi launches n goroutines to compute an
-// approximation of pi.
-func pi(n int) float64 {
-       ch := make(chan float64)
-       for k := 0; k <= n; k++ {
-               go term(ch, float64(k))
-       }
-       f := 0.0
-       for k := 0; k <= n; k++ {
-               f += <-ch
-       }
-       return f
-}
-
-func term(ch chan float64, k float64) {
-       ch <- 4 * math.Pow(-1, k) / (2*k + 1)
-}

diff --git a/doc/play/sieve.go b/doc/play/sieve.go
deleted file mode 100644 (file)
index 5190934..0000000
--- a/doc/play/sieve.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// A concurrent prime sieve
-
-package main
-
-import "fmt"
-
-// Send the sequence 2, 3, 4, ... to channel 'ch'.
-func Generate(ch chan<- int) {
-       for i := 2; ; i++ {
-               ch <- i // Send 'i' to channel 'ch'.
-       }
-}
-
-// Copy the values from channel 'in' to channel 'out',
-// removing those divisible by 'prime'.
-func Filter(in <-chan int, out chan<- int, prime int) {
-       for {
-               i := <-in // Receive value from 'in'.
-               if i%prime != 0 {
-                       out <- i // Send 'i' to 'out'.
-               }
-       }
-}
-
-// The prime sieve: Daisy-chain Filter processes.
-func main() {
-       ch := make(chan int) // Create a new channel.
-       go Generate(ch)      // Launch Generate goroutine.
-       for i := 0; i < 10; i++ {
-               prime := <-ch
-               fmt.Println(prime)
-               ch1 := make(chan int)
-               go Filter(ch, ch1, prime)
-               ch = ch1
-       }
-}

diff --git a/doc/play/solitaire.go b/doc/play/solitaire.go
deleted file mode 100644 (file)
index 15022aa..0000000
--- a/doc/play/solitaire.go
+++ /dev/null
@@ -1,117 +0,0 @@
-// This program solves the (English) peg
-// solitaire board game.
-// http://en.wikipedia.org/wiki/Peg_solitaire
-
-package main
-
-import "fmt"
-
-const N = 11 + 1 // length of a row (+1 for \n)
-
-// The board must be surrounded by 2 illegal
-// fields in each direction so that move()
-// doesn't need to check the board boundaries.
-// Periods represent illegal fields,
-// ● are pegs, and ○ are holes.
-
-var board = []rune(
-       `...........
-...........
-....●●●....
-....●●●....
-..●●●●●●●..
-..●●●○●●●..
-..●●●●●●●..
-....●●●....
-....●●●....
-...........
-...........
-`)
-
-// center is the position of the center hole if
-// there is a single one; otherwise it is -1.
-var center int
-
-func init() {
-       n := 0
-       for pos, field := range board {
-               if field == '○' {
-                       center = pos
-                       n++
-               }
-       }
-       if n != 1 {
-               center = -1 // no single hole
-       }
-}
-
-var moves int // number of times move is called
-
-// move tests if there is a peg at position pos that
-// can jump over another peg in direction dir. If the
-// move is valid, it is executed and move returns true.
-// Otherwise, move returns false.
-func move(pos, dir int) bool {
-       moves++
-       if board[pos] == '●' && board[pos+dir] == '●' && board[pos+2*dir] == '○' {
-               board[pos] = '○'
-               board[pos+dir] = '○'
-               board[pos+2*dir] = '●'
-               return true
-       }
-       return false
-}
-
-// unmove reverts a previously executed valid move.
-func unmove(pos, dir int) {
-       board[pos] = '●'
-       board[pos+dir] = '●'
-       board[pos+2*dir] = '○'
-}
-
-// solve tries to find a sequence of moves such that
-// there is only one peg left at the end; if center is
-// >= 0, that last peg must be in the center position.
-// If a solution is found, solve prints the board after
-// each move in a backward fashion (i.e., the last
-// board position is printed first, all the way back to
-// the starting board position).
-func solve() bool {
-       var last, n int
-       for pos, field := range board {
-               // try each board position
-               if field == '●' {
-                       // found a peg
-                       for _, dir := range [...]int{-1, -N, +1, +N} {
-                               // try each direction
-                               if move(pos, dir) {
-                                       // a valid move was found and executed,
-                                       // see if this new board has a solution
-                                       if solve() {
-                                               unmove(pos, dir)
-                                               fmt.Println(string(board))
-                                               return true
-                                       }
-                                       unmove(pos, dir)
-                               }
-                       }
-                       last = pos
-                       n++
-               }
-       }
-       // tried each possible move
-       if n == 1 && (center < 0 || last == center) {
-               // there's only one peg left
-               fmt.Println(string(board))
-               return true
-       }
-       // no solution found for this board
-       return false
-}
-
-func main() {
-       if !solve() {
-               fmt.Println("no solution found")
-       }
-       fmt.Println(moves, "moves tried")
-}

diff --git a/doc/play/tree.go b/doc/play/tree.go
deleted file mode 100644 (file)
index 3790e6c..0000000
--- a/doc/play/tree.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Go's concurrency primitives make it easy to
-// express concurrent concepts, such as
-// this binary tree comparison.
-//
-// Trees may be of different shapes,
-// but have the same contents. For example:
-//
-//        4               6
-//      2   6          4     7
-//     1 3 5 7       2   5
-//                  1 3
-//
-// This program compares a pair of trees by
-// walking each in its own goroutine,
-// sending their contents through a channel
-// to a third goroutine that compares them.
-
-package main
-
-import (
-       "fmt"
-       "math/rand"
-)
-
-// A Tree is a binary tree with integer values.
-type Tree struct {
-       Left  *Tree
-       Value int
-       Right *Tree
-}
-
-// Walk traverses a tree depth-first,
-// sending each Value on a channel.
-func Walk(t *Tree, ch chan int) {
-       if t == nil {
-               return
-       }
-       Walk(t.Left, ch)
-       ch <- t.Value
-       Walk(t.Right, ch)
-}
-
-// Walker launches Walk in a new goroutine,
-// and returns a read-only channel of values.
-func Walker(t *Tree) <-chan int {
-       ch := make(chan int)
-       go func() {
-               Walk(t, ch)
-               close(ch)
-       }()
-       return ch
-}
-
-// Compare reads values from two Walkers
-// that run simultaneously, and returns true
-// if t1 and t2 have the same contents.
-func Compare(t1, t2 *Tree) bool {
-       c1, c2 := Walker(t1), Walker(t2)
-       for {
-               v1, ok1 := <-c1
-               v2, ok2 := <-c2
-               if !ok1 || !ok2 {
-                       return ok1 == ok2
-               }
-               if v1 != v2 {
-                       break
-               }
-       }
-       return false
-}
-
-// New returns a new, random binary tree
-// holding the values 1k, 2k, ..., nk.
-func New(n, k int) *Tree {
-       var t *Tree
-       for _, v := range rand.Perm(n) {
-               t = insert(t, (1+v)*k)
-       }
-       return t
-}
-
-func insert(t *Tree, v int) *Tree {
-       if t == nil {
-               return &Tree{nil, v, nil}
-       }
-       if v < t.Value {
-               t.Left = insert(t.Left, v)
-               return t
-       }
-       t.Right = insert(t.Right, v)
-       return t
-}
-
-func main() {
-       t1 := New(100, 1)
-       fmt.Println(Compare(t1, New(100, 1)), "Same Contents")
-       fmt.Println(Compare(t1, New(99, 1)), "Differing Sizes")
-       fmt.Println(Compare(t1, New(100, 2)), "Differing Values")
-       fmt.Println(Compare(t1, New(101, 2)), "Dissimilar")
-}

diff --git a/doc/progs/cgo1.go b/doc/progs/cgo1.go
deleted file mode 100644 (file)
index d559e13..0000000
--- a/doc/progs/cgo1.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package rand
-
-/*
-#include <stdlib.h>
-*/
-import "C"
-
-// STOP OMIT
-func Random() int {
-       return int(C.rand())
-}
-
-// STOP OMIT
-func Seed(i int) {
-       C.srand(C.uint(i))
-}
-
-// END OMIT

diff --git a/doc/progs/cgo2.go b/doc/progs/cgo2.go
deleted file mode 100644 (file)
index da07aa4..0000000
--- a/doc/progs/cgo2.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package rand2
-
-/*
-#include <stdlib.h>
-*/
-import "C"
-
-func Random() int {
-       var r C.int = C.rand()
-       return int(r)
-}
-
-// STOP OMIT
-func Seed(i int) {
-       C.srand(C.uint(i))
-}
-
-// END OMIT

diff --git a/doc/progs/cgo3.go b/doc/progs/cgo3.go
deleted file mode 100644 (file)
index d5cedf4..0000000
--- a/doc/progs/cgo3.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package print
-
-// #include <stdio.h>
-// #include <stdlib.h>
-import "C"
-import "unsafe"
-
-func Print(s string) {
-       cs := C.CString(s)
-       C.fputs(cs, (*C.FILE)(C.stdout))
-       C.free(unsafe.Pointer(cs))
-}
-
-// END OMIT

diff --git a/doc/progs/cgo4.go b/doc/progs/cgo4.go
deleted file mode 100644 (file)
index dbb07e8..0000000
--- a/doc/progs/cgo4.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package print
-
-// #include <stdio.h>
-// #include <stdlib.h>
-import "C"
-import "unsafe"
-
-func Print(s string) {
-       cs := C.CString(s)
-       defer C.free(unsafe.Pointer(cs))
-       C.fputs(cs, (*C.FILE)(C.stdout))
-}
-
-// END OMIT

diff --git a/doc/progs/defer.go b/doc/progs/defer.go
deleted file mode 100644 (file)
index 2e11020..0000000
--- a/doc/progs/defer.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Defer, Panic, and Recover."
-
-package main
-
-import (
-       "fmt"
-       "io"
-       "os"
-)
-
-func a() {
-       i := 0
-       defer fmt.Println(i)
-       i++
-       return
-}
-
-// STOP OMIT
-
-func b() {
-       for i := 0; i < 4; i++ {
-               defer fmt.Print(i)
-       }
-}
-
-// STOP OMIT
-
-func c() (i int) {
-       defer func() { i++ }()
-       return 1
-}
-
-// STOP OMIT
-
-// Initial version.
-func CopyFile(dstName, srcName string) (written int64, err error) {
-       src, err := os.Open(srcName)
-       if err != nil {
-               return
-       }
-
-       dst, err := os.Create(dstName)
-       if err != nil {
-               return
-       }
-
-       written, err = io.Copy(dst, src)
-       dst.Close()
-       src.Close()
-       return
-}
-
-// STOP OMIT
-
-func main() {
-       a()
-       b()
-       fmt.Println()
-       fmt.Println(c())
-}

diff --git a/doc/progs/defer2.go b/doc/progs/defer2.go
deleted file mode 100644 (file)
index cad66b0..0000000
--- a/doc/progs/defer2.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Defer, Panic, and Recover."
-
-package main
-
-import "fmt"
-import "io" // OMIT
-import "os" // OMIT
-
-func main() {
-       f()
-       fmt.Println("Returned normally from f.")
-}
-
-func f() {
-       defer func() {
-               if r := recover(); r != nil {
-                       fmt.Println("Recovered in f", r)
-               }
-       }()
-       fmt.Println("Calling g.")
-       g(0)
-       fmt.Println("Returned normally from g.")
-}
-
-func g(i int) {
-       if i > 3 {
-               fmt.Println("Panicking!")
-               panic(fmt.Sprintf("%v", i))
-       }
-       defer fmt.Println("Defer in g", i)
-       fmt.Println("Printing in g", i)
-       g(i + 1)
-}
-
-// STOP OMIT
-
-// Revised version.
-func CopyFile(dstName, srcName string) (written int64, err error) {
-       src, err := os.Open(srcName)
-       if err != nil {
-               return
-       }
-       defer src.Close()
-
-       dst, err := os.Create(dstName)
-       if err != nil {
-               return
-       }
-       defer dst.Close()
-
-       return io.Copy(dst, src)
-}
-
-// STOP OMIT

diff --git a/doc/progs/eff_bytesize.go b/doc/progs/eff_bytesize.go
deleted file mode 100644 (file)
index b459611..0000000
--- a/doc/progs/eff_bytesize.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import "fmt"
-
-type ByteSize float64
-
-const (
-       _           = iota // ignore first value by assigning to blank identifier
-       KB ByteSize = 1 << (10 * iota)
-       MB
-       GB
-       TB
-       PB
-       EB
-       ZB
-       YB
-)
-
-func (b ByteSize) String() string {
-       switch {
-       case b >= YB:
-               return fmt.Sprintf("%.2fYB", b/YB)
-       case b >= ZB:
-               return fmt.Sprintf("%.2fZB", b/ZB)
-       case b >= EB:
-               return fmt.Sprintf("%.2fEB", b/EB)
-       case b >= PB:
-               return fmt.Sprintf("%.2fPB", b/PB)
-       case b >= TB:
-               return fmt.Sprintf("%.2fTB", b/TB)
-       case b >= GB:
-               return fmt.Sprintf("%.2fGB", b/GB)
-       case b >= MB:
-               return fmt.Sprintf("%.2fMB", b/MB)
-       case b >= KB:
-               return fmt.Sprintf("%.2fKB", b/KB)
-       }
-       return fmt.Sprintf("%.2fB", b)
-}
-
-func main() {
-       fmt.Println(YB, ByteSize(1e13))
-}

diff --git a/doc/progs/eff_qr.go b/doc/progs/eff_qr.go
deleted file mode 100644 (file)
index f2055f0..0000000
--- a/doc/progs/eff_qr.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "flag"
-       "html/template"
-       "log"
-       "net/http"
-)
-
-var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
-
-var templ = template.Must(template.New("qr").Parse(templateStr))
-
-func main() {
-       flag.Parse()
-       http.Handle("/", http.HandlerFunc(QR))
-       err := http.ListenAndServe(*addr, nil)
-       if err != nil {
-               log.Fatal("ListenAndServe:", err)
-       }
-}
-
-func QR(w http.ResponseWriter, req *http.Request) {
-       templ.Execute(w, req.FormValue("s"))
-}
-
-const templateStr = `
-<html>
-<head>
-<title>QR Link Generator</title>
-</head>
-<body>
-{{if .}}
-<img src="http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl={{.}}" />
-<br>
-{{.}}
-<br>
-<br>
-{{end}}
-<form action="/" name=f method="GET">
-       <input maxLength=1024 size=70 name=s value="" title="Text to QR Encode">
-       <input type=submit value="Show QR" name=qr>
-</form>
-</body>
-</html>
-`

diff --git a/doc/progs/eff_sequence.go b/doc/progs/eff_sequence.go
deleted file mode 100644 (file)
index ab1826b..0000000
--- a/doc/progs/eff_sequence.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "sort"
-)
-
-func main() {
-       seq := Sequence{6, 2, -1, 44, 16}
-       sort.Sort(seq)
-       fmt.Println(seq)
-}
-
-type Sequence []int
-
-// Methods required by sort.Interface.
-func (s Sequence) Len() int {
-       return len(s)
-}
-func (s Sequence) Less(i, j int) bool {
-       return s[i] < s[j]
-}
-func (s Sequence) Swap(i, j int) {
-       s[i], s[j] = s[j], s[i]
-}
-
-// Copy returns a copy of the Sequence.
-func (s Sequence) Copy() Sequence {
-       copy := make(Sequence, 0, len(s))
-       return append(copy, s...)
-}
-
-// Method for printing - sorts the elements before printing.
-func (s Sequence) String() string {
-       s = s.Copy() // Make a copy; don't overwrite argument.
-       sort.Sort(s)
-       str := "["
-       for i, elem := range s { // Loop is O(N²); will fix that in next example.
-               if i > 0 {
-                       str += " "
-               }
-               str += fmt.Sprint(elem)
-       }
-       return str + "]"
-}

diff --git a/doc/progs/eff_unused1.go b/doc/progs/eff_unused1.go
deleted file mode 100644 (file)
index 285d55e..0000000
--- a/doc/progs/eff_unused1.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package main
-
-import (
-       "fmt"
-       "io"
-       "log"
-       "os"
-)
-
-func main() {
-       fd, err := os.Open("test.go")
-       if err != nil {
-               log.Fatal(err)
-       }
-       // TODO: use fd.
-}

diff --git a/doc/progs/eff_unused2.go b/doc/progs/eff_unused2.go
deleted file mode 100644 (file)
index 92eb74e..0000000
--- a/doc/progs/eff_unused2.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package main
-
-import (
-       "fmt"
-       "io"
-       "log"
-       "os"
-)
-
-var _ = fmt.Printf // For debugging; delete when done.
-var _ io.Reader    // For debugging; delete when done.
-
-func main() {
-       fd, err := os.Open("test.go")
-       if err != nil {
-               log.Fatal(err)
-       }
-       // TODO: use fd.
-       _ = fd
-}

diff --git a/doc/progs/error.go b/doc/progs/error.go
deleted file mode 100644 (file)
index e776cdb..0000000
--- a/doc/progs/error.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Error Handling and Go."
-
-package main
-
-import (
-       "encoding/json"
-       "errors"
-       "fmt"
-       "log"
-       "net"
-       "os"
-       "time"
-)
-
-type File struct{}
-
-func Open(name string) (file *File, err error) {
-       // OMIT
-       panic(1)
-       // STOP OMIT
-}
-
-func openFile() { // OMIT
-       f, err := os.Open("filename.ext")
-       if err != nil {
-               log.Fatal(err)
-       }
-       // do something with the open *File f
-       // STOP OMIT
-       _ = f
-}
-
-// errorString is a trivial implementation of error.
-type errorString struct {
-       s string
-}
-
-func (e *errorString) Error() string {
-       return e.s
-}
-
-// STOP OMIT
-
-// New returns an error that formats as the given text.
-func New(text string) error {
-       return &errorString{text}
-}
-
-// STOP OMIT
-
-func Sqrt(f float64) (float64, error) {
-       if f < 0 {
-               return 0, errors.New("math: square root of negative number")
-       }
-       // implementation
-       return 0, nil // OMIT
-}
-
-// STOP OMIT
-
-func printErr() (int, error) { // OMIT
-       f, err := Sqrt(-1)
-       if err != nil {
-               fmt.Println(err)
-       }
-       // STOP OMIT
-       // fmtError OMIT
-       if f < 0 {
-               return 0, fmt.Errorf("math: square root of negative number %g", f)
-       }
-       // STOP OMIT
-       return 0, nil
-}
-
-type NegativeSqrtError float64
-
-func (f NegativeSqrtError) Error() string {
-       return fmt.Sprintf("math: square root of negative number %g", float64(f))
-}
-
-// STOP OMIT
-
-type SyntaxError struct {
-       msg    string // description of error
-       Offset int64  // error occurred after reading Offset bytes
-}
-
-func (e *SyntaxError) Error() string { return e.msg }
-
-// STOP OMIT
-
-func decodeError(dec *json.Decoder, val struct{}) error { // OMIT
-       var f os.FileInfo // OMIT
-       if err := dec.Decode(&val); err != nil {
-               if serr, ok := err.(*json.SyntaxError); ok {
-                       line, col := findLine(f, serr.Offset)
-                       return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
-               }
-               return err
-       }
-       // STOP OMIT
-       return nil
-}
-
-func findLine(os.FileInfo, int64) (int, int) {
-       // place holder; no need to run
-       return 0, 0
-}
-
-func netError(err error) { // OMIT
-       for { // OMIT
-               if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
-                       time.Sleep(1e9)
-                       continue
-               }
-               if err != nil {
-                       log.Fatal(err)
-               }
-               // STOP OMIT
-       }
-}
-
-func main() {}

diff --git a/doc/progs/error2.go b/doc/progs/error2.go
deleted file mode 100644 (file)
index 086b671..0000000
--- a/doc/progs/error2.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Error Handling and Go."
-
-package main
-
-import (
-       "net/http"
-       "text/template"
-)
-
-func init() {
-       http.HandleFunc("/view", viewRecord)
-}
-
-func viewRecord(w http.ResponseWriter, r *http.Request) {
-       c := appengine.NewContext(r)
-       key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
-       record := new(Record)
-       if err := datastore.Get(c, key, record); err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-               return
-       }
-       if err := viewTemplate.Execute(w, record); err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-       }
-}
-
-// STOP OMIT
-
-type ap struct{}
-
-func (ap) NewContext(*http.Request) *ctx { return nil }
-
-type ctx struct{}
-
-func (*ctx) Errorf(string, ...interface{}) {}
-
-var appengine ap
-
-type ds struct{}
-
-func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
-func (ds) Get(*ctx, string, *Record) error               { return nil }
-
-var datastore ds
-
-type Record struct{}
-
-var viewTemplate *template.Template
-
-func main() {}

diff --git a/doc/progs/error3.go b/doc/progs/error3.go
deleted file mode 100644 (file)
index d9e56b5..0000000
--- a/doc/progs/error3.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Error Handling and Go."
-
-package main
-
-import (
-       "net/http"
-       "text/template"
-)
-
-func init() {
-       http.Handle("/view", appHandler(viewRecord))
-}
-
-// STOP OMIT
-
-func viewRecord(w http.ResponseWriter, r *http.Request) error {
-       c := appengine.NewContext(r)
-       key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
-       record := new(Record)
-       if err := datastore.Get(c, key, record); err != nil {
-               return err
-       }
-       return viewTemplate.Execute(w, record)
-}
-
-// STOP OMIT
-
-type appHandler func(http.ResponseWriter, *http.Request) error
-
-func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-       if err := fn(w, r); err != nil {
-               http.Error(w, err.Error(), http.StatusInternalServerError)
-       }
-}
-
-// STOP OMIT
-
-type ap struct{}
-
-func (ap) NewContext(*http.Request) *ctx { return nil }
-
-type ctx struct{}
-
-func (*ctx) Errorf(string, ...interface{}) {}
-
-var appengine ap
-
-type ds struct{}
-
-func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
-func (ds) Get(*ctx, string, *Record) error               { return nil }
-
-var datastore ds
-
-type Record struct{}
-
-var viewTemplate *template.Template
-
-func main() {}

diff --git a/doc/progs/error4.go b/doc/progs/error4.go
deleted file mode 100644 (file)
index 8b2f304..0000000
--- a/doc/progs/error4.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "Error Handling and Go."
-
-package main
-
-import (
-       "net/http"
-       "text/template"
-)
-
-type appError struct {
-       Error   error
-       Message string
-       Code    int
-}
-
-// STOP OMIT
-
-type appHandler func(http.ResponseWriter, *http.Request) *appError
-
-func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-       if e := fn(w, r); e != nil { // e is *appError, not error.
-               c := appengine.NewContext(r)
-               c.Errorf("%v", e.Error)
-               http.Error(w, e.Message, e.Code)
-       }
-}
-
-// STOP OMIT
-
-func viewRecord(w http.ResponseWriter, r *http.Request) *appError {
-       c := appengine.NewContext(r)
-       key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
-       record := new(Record)
-       if err := datastore.Get(c, key, record); err != nil {
-               return &appError{err, "Record not found", 404}
-       }
-       if err := viewTemplate.Execute(w, record); err != nil {
-               return &appError{err, "Can't display record", 500}
-       }
-       return nil
-}
-
-// STOP OMIT
-
-func init() {
-       http.Handle("/view", appHandler(viewRecord))
-}
-
-type ap struct{}
-
-func (ap) NewContext(*http.Request) *ctx { return nil }
-
-type ctx struct{}
-
-func (*ctx) Errorf(string, ...interface{}) {}
-
-var appengine ap
-
-type ds struct{}
-
-func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
-func (ds) Get(*ctx, string, *Record) error               { return nil }
-
-var datastore ds
-
-type Record struct{}
-
-var viewTemplate *template.Template
-
-func main() {}

diff --git a/doc/progs/go1.go b/doc/progs/go1.go
deleted file mode 100644 (file)
index 50fd934..0000000
--- a/doc/progs/go1.go
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains examples to embed in the Go 1 release notes document.
-
-package main
-
-import (
-       "errors"
-       "flag"
-       "fmt"
-       "log"
-       "os"
-       "path/filepath"
-       "testing"
-       "time"
-       "unicode"
-)
-
-func main() {
-       flag.Parse()
-       stringAppend()
-       mapDelete()
-       mapIteration()
-       multipleAssignment()
-       structEquality()
-       compositeLiterals()
-       runeType()
-       errorExample()
-       timePackage()
-       walkExample()
-       osIsExist()
-}
-
-var timeout = flag.Duration("timeout", 30*time.Second, "how long to wait for completion")
-
-func init() {
-       // canonicalize the logging
-       log.SetFlags(0)
-}
-
-func mapDelete() {
-       m := map[string]int{"7": 7, "23": 23}
-       k := "7"
-       delete(m, k)
-       if m["7"] != 0 || m["23"] != 23 {
-               log.Fatal("mapDelete:", m)
-       }
-}
-
-func stringAppend() {
-       greeting := []byte{}
-       greeting = append(greeting, []byte("hello ")...)
-       greeting = append(greeting, "world"...)
-       if string(greeting) != "hello world" {
-               log.Fatal("stringAppend: ", string(greeting))
-       }
-}
-
-func mapIteration() {
-       m := map[string]int{"Sunday": 0, "Monday": 1}
-       for name, value := range m {
-               // This loop should not assume Sunday will be visited first.
-               f(name, value)
-       }
-}
-
-func f(string, int) {
-}
-
-func assert(t bool) {
-       if !t {
-               log.Panic("assertion fail")
-       }
-}
-
-func multipleAssignment() {
-       sa := []int{1, 2, 3}
-       i := 0
-       i, sa[i] = 1, 2 // sets i = 1, sa[0] = 2
-
-       sb := []int{1, 2, 3}
-       j := 0
-       sb[j], j = 2, 1 // sets sb[0] = 2, j = 1
-
-       sc := []int{1, 2, 3}
-       sc[0], sc[0] = 1, 2 // sets sc[0] = 1, then sc[0] = 2 (so sc[0] = 2 at end)
-
-       assert(i == 1 && sa[0] == 2)
-       assert(j == 1 && sb[0] == 2)
-       assert(sc[0] == 2)
-}
-
-func structEquality() {
-       type Day struct {
-               long  string
-               short string
-       }
-       Christmas := Day{"Christmas", "XMas"}
-       Thanksgiving := Day{"Thanksgiving", "Turkey"}
-       holiday := map[Day]bool{
-               Christmas:    true,
-               Thanksgiving: true,
-       }
-       fmt.Printf("Christmas is a holiday: %t\n", holiday[Christmas])
-}
-
-func compositeLiterals() {
-       type Date struct {
-               month string
-               day   int
-       }
-       // Struct values, fully qualified; always legal.
-       holiday1 := []Date{
-               Date{"Feb", 14},
-               Date{"Nov", 11},
-               Date{"Dec", 25},
-       }
-       // Struct values, type name elided; always legal.
-       holiday2 := []Date{
-               {"Feb", 14},
-               {"Nov", 11},
-               {"Dec", 25},
-       }
-       // Pointers, fully qualified, always legal.
-       holiday3 := []*Date{
-               &Date{"Feb", 14},
-               &Date{"Nov", 11},
-               &Date{"Dec", 25},
-       }
-       // Pointers, type name elided; legal in Go 1.
-       holiday4 := []*Date{
-               {"Feb", 14},
-               {"Nov", 11},
-               {"Dec", 25},
-       }
-       // STOP OMIT
-       _, _, _, _ = holiday1, holiday2, holiday3, holiday4
-}
-
-func runeType() {
-       // STARTRUNE OMIT
-       delta := 'δ' // delta has type rune.
-       var DELTA rune
-       DELTA = unicode.ToUpper(delta)
-       epsilon := unicode.ToLower(DELTA + 1)
-       if epsilon != 'δ'+1 {
-               log.Fatal("inconsistent casing for Greek")
-       }
-       // ENDRUNE OMIT
-}
-
-// START ERROR EXAMPLE OMIT
-type SyntaxError struct {
-       File    string
-       Line    int
-       Message string
-}
-
-func (se *SyntaxError) Error() string {
-       return fmt.Sprintf("%s:%d: %s", se.File, se.Line, se.Message)
-}
-
-// END ERROR EXAMPLE OMIT
-
-func errorExample() {
-       var ErrSyntax = errors.New("syntax error")
-       _ = ErrSyntax
-       se := &SyntaxError{"file", 7, "error"}
-       got := fmt.Sprint(se)
-       const expect = "file:7: error"
-       if got != expect {
-               log.Fatalf("errorsPackage: expected %q got %q", expect, got)
-       }
-}
-
-// sleepUntil sleeps until the specified time. It returns immediately if it's too late.
-func sleepUntil(wakeup time.Time) {
-       now := time.Now() // A Time.
-       if !wakeup.After(now) {
-               return
-       }
-       delta := wakeup.Sub(now) // A Duration.
-       fmt.Printf("Sleeping for %.3fs\n", delta.Seconds())
-       time.Sleep(delta)
-}
-
-func timePackage() {
-       sleepUntil(time.Now().Add(123 * time.Millisecond))
-}
-
-func walkExample() {
-       // STARTWALK OMIT
-       markFn := func(path string, info os.FileInfo, err error) error {
-               if path == "pictures" { // Will skip walking of directory pictures and its contents.
-                       return filepath.SkipDir
-               }
-               if err != nil {
-                       return err
-               }
-               log.Println(path)
-               return nil
-       }
-       err := filepath.Walk(".", markFn)
-       if err != nil {
-               log.Fatal(err)
-       }
-       // ENDWALK OMIT
-}
-
-func initializationFunction(c chan int) {
-       c <- 1
-}
-
-var PackageGlobal int
-
-func init() {
-       c := make(chan int)
-       go initializationFunction(c)
-       PackageGlobal = <-c
-}
-
-func BenchmarkSprintf(b *testing.B) {
-       // Verify correctness before running benchmark.
-       b.StopTimer()
-       got := fmt.Sprintf("%x", 23)
-       const expect = "17"
-       if expect != got {
-               b.Fatalf("expected %q; got %q", expect, got)
-       }
-       b.StartTimer()
-       for i := 0; i < b.N; i++ {
-               fmt.Sprintf("%x", 23)
-       }
-}
-
-func osIsExist() {
-       name := "go1.go"
-       f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
-       if os.IsExist(err) {
-               log.Printf("%s already exists", name)
-       }
-       _ = f
-}

diff --git a/doc/progs/gobs1.go b/doc/progs/gobs1.go
deleted file mode 100644 (file)
index 7077ca1..0000000
--- a/doc/progs/gobs1.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gobs1
-
-type T struct{ X, Y, Z int } // Only exported fields are encoded and decoded.
-var t = T{X: 7, Y: 0, Z: 8}
-
-// STOP OMIT
-
-type U struct{ X, Y *int8 } // Note: pointers to int8s
-var u U
-
-// STOP OMIT
-
-type Node struct {
-       Value       int
-       Left, Right *Node
-}
-
-// STOP OMIT

diff --git a/doc/progs/gobs2.go b/doc/progs/gobs2.go
deleted file mode 100644 (file)
index 85bb41c..0000000
--- a/doc/progs/gobs2.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "bytes"
-       "encoding/gob"
-       "fmt"
-       "log"
-)
-
-type P struct {
-       X, Y, Z int
-       Name    string
-}
-
-type Q struct {
-       X, Y *int32
-       Name string
-}
-
-func main() {
-       // Initialize the encoder and decoder.  Normally enc and dec would be
-       // bound to network connections and the encoder and decoder would
-       // run in different processes.
-       var network bytes.Buffer        // Stand-in for a network connection
-       enc := gob.NewEncoder(&network) // Will write to network.
-       dec := gob.NewDecoder(&network) // Will read from network.
-       // Encode (send) the value.
-       err := enc.Encode(P{3, 4, 5, "Pythagoras"})
-       if err != nil {
-               log.Fatal("encode error:", err)
-       }
-       // Decode (receive) the value.
-       var q Q
-       err = dec.Decode(&q)
-       if err != nil {
-               log.Fatal("decode error:", err)
-       }
-       fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
-}

diff --git a/doc/progs/image_draw.go b/doc/progs/image_draw.go
deleted file mode 100644 (file)
index bb73c8a..0000000
--- a/doc/progs/image_draw.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "The Go image/draw package."
-
-package main
-
-import (
-       "image"
-       "image/color"
-       "image/draw"
-)
-
-func main() {
-       Color()
-       Rect()
-       RectAndScroll()
-       ConvAndCircle()
-       Glyph()
-}
-
-func Color() {
-       c := color.RGBA{255, 0, 255, 255}
-       r := image.Rect(0, 0, 640, 480)
-       dst := image.NewRGBA(r)
-
-       // ZERO OMIT
-       // image.ZP is the zero point -- the origin.
-       draw.Draw(dst, r, &image.Uniform{c}, image.ZP, draw.Src)
-       // STOP OMIT
-
-       // BLUE OMIT
-       m := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       blue := color.RGBA{0, 0, 255, 255}
-       draw.Draw(m, m.Bounds(), &image.Uniform{blue}, image.ZP, draw.Src)
-       // STOP OMIT
-
-       // RESET OMIT
-       draw.Draw(m, m.Bounds(), image.Transparent, image.ZP, draw.Src)
-       // STOP OMIT
-}
-
-func Rect() {
-       dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       sr := image.Rect(0, 0, 200, 200)
-       src := image.Black
-       dp := image.Point{100, 100}
-
-       // RECT OMIT
-       r := image.Rectangle{dp, dp.Add(sr.Size())}
-       draw.Draw(dst, r, src, sr.Min, draw.Src)
-       // STOP OMIT
-}
-
-func RectAndScroll() {
-       dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       sr := image.Rect(0, 0, 200, 200)
-       src := image.Black
-       dp := image.Point{100, 100}
-
-       // RECT2 OMIT
-       r := sr.Sub(sr.Min).Add(dp)
-       draw.Draw(dst, r, src, sr.Min, draw.Src)
-       // STOP OMIT
-
-       m := dst
-
-       // SCROLL OMIT
-       b := m.Bounds()
-       p := image.Pt(0, 20)
-       // Note that even though the second argument is b,
-       // the effective rectangle is smaller due to clipping.
-       draw.Draw(m, b, m, b.Min.Add(p), draw.Src)
-       dirtyRect := b.Intersect(image.Rect(b.Min.X, b.Max.Y-20, b.Max.X, b.Max.Y))
-       // STOP OMIT
-
-       _ = dirtyRect // noop
-}
-
-func ConvAndCircle() {
-       src := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-
-       // CONV OMIT
-       b := src.Bounds()
-       m := image.NewRGBA(b)
-       draw.Draw(m, b, src, b.Min, draw.Src)
-       // STOP OMIT
-
-       p := image.Point{100, 100}
-       r := 50
-
-       // CIRCLE2 OMIT
-       draw.DrawMask(dst, dst.Bounds(), src, image.ZP, &circle{p, r}, image.ZP, draw.Over)
-       // STOP OMIT
-}
-
-func theGlyphImageForAFont() image.Image {
-       return image.NewRGBA(image.Rect(0, 0, 640, 480))
-}
-
-func theBoundsFor(index int) image.Rectangle {
-       return image.Rect(0, 0, 32, 32)
-}
-
-func Glyph() {
-       p := image.Point{100, 100}
-       dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       glyphIndex := 42
-
-       // GLYPH OMIT
-       src := &image.Uniform{color.RGBA{0, 0, 255, 255}}
-       mask := theGlyphImageForAFont()
-       mr := theBoundsFor(glyphIndex)
-       draw.DrawMask(dst, mr.Sub(mr.Min).Add(p), src, image.ZP, mask, mr.Min, draw.Over)
-       // STOP OMIT
-}
-
-//CIRCLESTRUCT OMIT
-type circle struct {
-       p image.Point
-       r int
-}
-
-func (c *circle) ColorModel() color.Model {
-       return color.AlphaModel
-}
-
-func (c *circle) Bounds() image.Rectangle {
-       return image.Rect(c.p.X-c.r, c.p.Y-c.r, c.p.X+c.r, c.p.Y+c.r)
-}
-
-func (c *circle) At(x, y int) color.Color {
-       xx, yy, rr := float64(x-c.p.X)+0.5, float64(y-c.p.Y)+0.5, float64(c.r)
-       if xx*xx+yy*yy < rr*rr {
-               return color.Alpha{255}
-       }
-       return color.Alpha{0}
-}
-
-//STOP OMIT

diff --git a/doc/progs/image_package1.go b/doc/progs/image_package1.go
deleted file mode 100644 (file)
index c4c401e..0000000
--- a/doc/progs/image_package1.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-)
-
-func main() {
-       p := image.Point{2, 1}
-       fmt.Println("X is", p.X, "Y is", p.Y)
-}

diff --git a/doc/progs/image_package2.go b/doc/progs/image_package2.go
deleted file mode 100644 (file)
index fcb5d9f..0000000
--- a/doc/progs/image_package2.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-)
-
-func main() {
-       r := image.Rect(2, 1, 5, 5)
-       // Dx and Dy return a rectangle's width and height.
-       fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 false
-}

diff --git a/doc/progs/image_package3.go b/doc/progs/image_package3.go
deleted file mode 100644 (file)
index 13d0f08..0000000
--- a/doc/progs/image_package3.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-)
-
-func main() {
-       r := image.Rect(2, 1, 5, 5).Add(image.Pt(-4, -2))
-       fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 true
-}

diff --git a/doc/progs/image_package4.go b/doc/progs/image_package4.go
deleted file mode 100644 (file)
index c46fddf..0000000
--- a/doc/progs/image_package4.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-)
-
-func main() {
-       r := image.Rect(0, 0, 4, 3).Intersect(image.Rect(2, 2, 5, 5))
-       // Size returns a rectangle's width and height, as a Point.
-       fmt.Printf("%#v\n", r.Size()) // prints image.Point{X:2, Y:1}
-}

diff --git a/doc/progs/image_package5.go b/doc/progs/image_package5.go
deleted file mode 100644 (file)
index 0bb5c76..0000000
--- a/doc/progs/image_package5.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-       "image/color"
-)
-
-func main() {
-       m := image.NewRGBA(image.Rect(0, 0, 640, 480))
-       m.Set(5, 5, color.RGBA{255, 0, 0, 255})
-       fmt.Println(m.At(5, 5))
-}

diff --git a/doc/progs/image_package6.go b/doc/progs/image_package6.go
deleted file mode 100644 (file)
index 62eeecd..0000000
--- a/doc/progs/image_package6.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "image"
-)
-
-func main() {
-       m0 := image.NewRGBA(image.Rect(0, 0, 8, 5))
-       m1 := m0.SubImage(image.Rect(1, 2, 5, 5)).(*image.RGBA)
-       fmt.Println(m0.Bounds().Dx(), m1.Bounds().Dx()) // prints 8, 4
-       fmt.Println(m0.Stride == m1.Stride)             // prints true
-}

diff --git a/doc/progs/interface.go b/doc/progs/interface.go
deleted file mode 100644 (file)
index c2925d5..0000000
--- a/doc/progs/interface.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "The Laws of Reflection."
-
-package main
-
-import (
-       "bufio"
-       "bytes"
-       "io"
-       "os"
-)
-
-type MyInt int
-
-var i int
-var j MyInt
-
-// STOP OMIT
-
-// Reader is the interface that wraps the basic Read method.
-type Reader interface {
-       Read(p []byte) (n int, err error)
-}
-
-// Writer is the interface that wraps the basic Write method.
-type Writer interface {
-       Write(p []byte) (n int, err error)
-}
-
-// STOP OMIT
-
-func readers() { // OMIT
-       var r io.Reader
-       r = os.Stdin
-       r = bufio.NewReader(r)
-       r = new(bytes.Buffer)
-       // and so on
-       // STOP OMIT
-}
-
-func typeAssertions() (interface{}, error) { // OMIT
-       var r io.Reader
-       tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
-       if err != nil {
-               return nil, err
-       }
-       r = tty
-       // STOP OMIT
-       var w io.Writer
-       w = r.(io.Writer)
-       // STOP OMIT
-       var empty interface{}
-       empty = w
-       // STOP OMIT
-       return empty, err
-}
-
-func main() {
-}

diff --git a/doc/progs/interface2.go b/doc/progs/interface2.go
deleted file mode 100644 (file)
index a541d94..0000000
--- a/doc/progs/interface2.go
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the code snippets included in "The Laws of Reflection."
-
-package main
-
-import (
-       "fmt"
-       "reflect"
-)
-
-func main() {
-       var x float64 = 3.4
-       fmt.Println("type:", reflect.TypeOf(x))
-       // STOP OMIT
-       // TODO(proppy): test output OMIT
-}
-
-// STOP main OMIT
-
-func f1() {
-       // START f1 OMIT
-       var x float64 = 3.4
-       v := reflect.ValueOf(x)
-       fmt.Println("type:", v.Type())
-       fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
-       fmt.Println("value:", v.Float())
-       // STOP OMIT
-}
-
-func f2() {
-       // START f2 OMIT
-       var x uint8 = 'x'
-       v := reflect.ValueOf(x)
-       fmt.Println("type:", v.Type())                            // uint8.
-       fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
-       x = uint8(v.Uint())                                       // v.Uint returns a uint64.
-       // STOP OMIT
-}
-
-func f3() {
-       // START f3 OMIT
-       type MyInt int
-       var x MyInt = 7
-       v := reflect.ValueOf(x)
-       // STOP OMIT
-       // START f3b OMIT
-       y := v.Interface().(float64) // y will have type float64.
-       fmt.Println(y)
-       // STOP OMIT
-       // START f3c OMIT
-       fmt.Println(v.Interface())
-       // STOP OMIT
-       // START f3d OMIT
-       fmt.Printf("value is %7.1e\n", v.Interface())
-       // STOP OMIT
-}
-
-func f4() {
-       // START f4 OMIT
-       var x float64 = 3.4
-       v := reflect.ValueOf(x)
-       v.SetFloat(7.1) // Error: will panic.
-       // STOP OMIT
-}
-
-func f5() {
-       // START f5 OMIT
-       var x float64 = 3.4
-       v := reflect.ValueOf(x)
-       fmt.Println("settability of v:", v.CanSet())
-       // STOP OMIT
-}
-
-func f6() {
-       // START f6 OMIT
-       var x float64 = 3.4
-       v := reflect.ValueOf(x)
-       // STOP OMIT
-       // START f6b OMIT
-       v.SetFloat(7.1)
-       // STOP OMIT
-}
-
-func f7() {
-       // START f7 OMIT
-       var x float64 = 3.4
-       p := reflect.ValueOf(&x) // Note: take the address of x.
-       fmt.Println("type of p:", p.Type())
-       fmt.Println("settability of p:", p.CanSet())
-       // STOP OMIT
-       // START f7b OMIT
-       v := p.Elem()
-       fmt.Println("settability of v:", v.CanSet())
-       // STOP OMIT
-       // START f7c OMIT
-       v.SetFloat(7.1)
-       fmt.Println(v.Interface())
-       fmt.Println(x)
-       // STOP OMIT
-}
-
-func f8() {
-       // START f8 OMIT
-       type T struct {
-               A int
-               B string
-       }
-       t := T{23, "skidoo"}
-       s := reflect.ValueOf(&t).Elem()
-       typeOfT := s.Type()
-       for i := 0; i < s.NumField(); i++ {
-               f := s.Field(i)
-               fmt.Printf("%d: %s %s = %v\n", i,
-                       typeOfT.Field(i).Name, f.Type(), f.Interface())
-       }
-       // STOP OMIT
-       // START f8b OMIT
-       s.Field(0).SetInt(77)
-       s.Field(1).SetString("Sunset Strip")
-       fmt.Println("t is now", t)
-       // STOP OMIT
-}
-
-func f9() {
-       // START f9 OMIT
-       var x float64 = 3.4
-       fmt.Println("value:", reflect.ValueOf(x))
-       // STOP OMIT
-}

diff --git a/doc/progs/json1.go b/doc/progs/json1.go
deleted file mode 100644 (file)
index 9804efb..0000000
--- a/doc/progs/json1.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "encoding/json"
-       "log"
-       "reflect"
-)
-
-type Message struct {
-       Name string
-       Body string
-       Time int64
-}
-
-// STOP OMIT
-
-func Encode() {
-       m := Message{"Alice", "Hello", 1294706395881547000}
-       b, err := json.Marshal(m)
-
-       if err != nil {
-               panic(err)
-       }
-
-       expected := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
-       if !reflect.DeepEqual(b, expected) {
-               log.Panicf("Error marshaling %q, expected %q, got %q.", m, expected, b)
-       }
-
-}
-
-func Decode() {
-       b := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
-       var m Message
-       err := json.Unmarshal(b, &m)
-
-       if err != nil {
-               panic(err)
-       }
-
-       expected := Message{
-               Name: "Alice",
-               Body: "Hello",
-               Time: 1294706395881547000,
-       }
-
-       if !reflect.DeepEqual(m, expected) {
-               log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
-       }
-
-       m = Message{
-               Name: "Alice",
-               Body: "Hello",
-               Time: 1294706395881547000,
-       }
-
-       // STOP OMIT
-}
-
-func PartialDecode() {
-       b := []byte(`{"Name":"Bob","Food":"Pickle"}`)
-       var m Message
-       err := json.Unmarshal(b, &m)
-
-       // STOP OMIT
-
-       if err != nil {
-               panic(err)
-       }
-
-       expected := Message{
-               Name: "Bob",
-       }
-
-       if !reflect.DeepEqual(expected, m) {
-               log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
-       }
-}
-
-func main() {
-       Encode()
-       Decode()
-       PartialDecode()
-}

diff --git a/doc/progs/json2.go b/doc/progs/json2.go
deleted file mode 100644 (file)
index 6089ae6..0000000
--- a/doc/progs/json2.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "fmt"
-       "math"
-)
-
-func InterfaceExample() {
-       var i interface{}
-       i = "a string"
-       i = 2011
-       i = 2.777
-
-       // STOP OMIT
-
-       r := i.(float64)
-       fmt.Println("the circle's area", math.Pi*r*r)
-
-       // STOP OMIT
-
-       switch v := i.(type) {
-       case int:
-               fmt.Println("twice i is", v*2)
-       case float64:
-               fmt.Println("the reciprocal of i is", 1/v)
-       case string:
-               h := len(v) / 2
-               fmt.Println("i swapped by halves is", v[h:]+v[:h])
-       default:
-               // i isn't one of the types above
-       }
-
-       // STOP OMIT
-}
-
-func main() {
-       InterfaceExample()
-}

diff --git a/doc/progs/json3.go b/doc/progs/json3.go
deleted file mode 100644 (file)
index 442c155..0000000
--- a/doc/progs/json3.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "encoding/json"
-       "fmt"
-       "log"
-       "reflect"
-)
-
-func Decode() {
-       b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
-
-       var f interface{}
-       err := json.Unmarshal(b, &f)
-
-       // STOP OMIT
-
-       if err != nil {
-               panic(err)
-       }
-
-       expected := map[string]interface{}{
-               "Name": "Wednesday",
-               "Age":  float64(6),
-               "Parents": []interface{}{
-                       "Gomez",
-                       "Morticia",
-               },
-       }
-
-       if !reflect.DeepEqual(f, expected) {
-               log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, f)
-       }
-
-       f = map[string]interface{}{
-               "Name": "Wednesday",
-               "Age":  6,
-               "Parents": []interface{}{
-                       "Gomez",
-                       "Morticia",
-               },
-       }
-
-       // STOP OMIT
-
-       m := f.(map[string]interface{})
-
-       for k, v := range m {
-               switch vv := v.(type) {
-               case string:
-                       fmt.Println(k, "is string", vv)
-               case int:
-                       fmt.Println(k, "is int", vv)
-               case []interface{}:
-                       fmt.Println(k, "is an array:")
-                       for i, u := range vv {
-                               fmt.Println(i, u)
-                       }
-               default:
-                       fmt.Println(k, "is of a type I don't know how to handle")
-               }
-       }
-
-       // STOP OMIT
-}
-
-func main() {
-       Decode()
-}

diff --git a/doc/progs/json4.go b/doc/progs/json4.go
deleted file mode 100644 (file)
index 1c7e5b4..0000000
--- a/doc/progs/json4.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "encoding/json"
-       "log"
-       "reflect"
-)
-
-type FamilyMember struct {
-       Name    string
-       Age     int
-       Parents []string
-}
-
-// STOP OMIT
-
-func Decode() {
-       b := []byte(`{"Name":"Bob","Age":20,"Parents":["Morticia", "Gomez"]}`)
-       var m FamilyMember
-       err := json.Unmarshal(b, &m)
-
-       // STOP OMIT
-
-       if err != nil {
-               panic(err)
-       }
-
-       expected := FamilyMember{
-               Name:    "Bob",
-               Age:     20,
-               Parents: []string{"Morticia", "Gomez"},
-       }
-
-       if !reflect.DeepEqual(expected, m) {
-               log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, m)
-       }
-}
-
-func main() {
-       Decode()
-}

diff --git a/doc/progs/json5.go b/doc/progs/json5.go
deleted file mode 100644 (file)
index 6d7a4ca..0000000
--- a/doc/progs/json5.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "encoding/json"
-       "log"
-       "os"
-)
-
-func main() {
-       dec := json.NewDecoder(os.Stdin)
-       enc := json.NewEncoder(os.Stdout)
-       for {
-               var v map[string]interface{}
-               if err := dec.Decode(&v); err != nil {
-                       log.Println(err)
-                       return
-               }
-               for k := range v {
-                       if k != "Name" {
-                               delete(v, k)
-                       }
-               }
-               if err := enc.Encode(&v); err != nil {
-                       log.Println(err)
-               }
-       }
-}

diff --git a/doc/progs/run.go b/doc/progs/run.go
deleted file mode 100644 (file)
index 8ac75cd..0000000
--- a/doc/progs/run.go
+++ /dev/null
@@ -1,229 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// run runs the docs tests found in this directory.
-package main
-
-import (
-       "bytes"
-       "flag"
-       "fmt"
-       "io/ioutil"
-       "os"
-       "os/exec"
-       "path/filepath"
-       "regexp"
-       "runtime"
-       "strings"
-       "time"
-)
-
-const usage = `go run run.go [tests]
-
-run.go runs the docs tests in this directory.
-If no tests are provided, it runs all tests.
-Tests may be specified without their .go suffix.
-`
-
-func main() {
-       start := time.Now()
-
-       flag.Usage = func() {
-               fmt.Fprintf(os.Stderr, usage)
-               flag.PrintDefaults()
-               os.Exit(2)
-       }
-
-       flag.Parse()
-       if flag.NArg() == 0 {
-               // run all tests
-               fixcgo()
-       } else {
-               // run specified tests
-               onlyTest(flag.Args()...)
-       }
-
-       tmpdir, err := ioutil.TempDir("", "go-progs")
-       if err != nil {
-               fmt.Fprintln(os.Stderr, err)
-               os.Exit(1)
-       }
-
-       // ratec limits the number of tests running concurrently.
-       // None of the tests are intensive, so don't bother
-       // trying to manually adjust for slow builders.
-       ratec := make(chan bool, runtime.NumCPU())
-       errc := make(chan error, len(tests))
-
-       for _, tt := range tests {
-               tt := tt
-               ratec <- true
-               go func() {
-                       errc <- test(tmpdir, tt.file, tt.want)
-                       <-ratec
-               }()
-       }
-
-       var rc int
-       for range tests {
-               if err := <-errc; err != nil {
-                       fmt.Fprintln(os.Stderr, err)
-                       rc = 1
-               }
-       }
-       os.Remove(tmpdir)
-       if rc == 0 {
-               fmt.Printf("ok\t%s\t%s\n", filepath.Base(os.Args[0]), time.Since(start).Round(time.Millisecond))
-       }
-       os.Exit(rc)
-}
-
-// test builds the test in the given file.
-// If want is non-empty, test also runs the test
-// and checks that the output matches the regexp want.
-func test(tmpdir, file, want string) error {
-       // Build the program.
-       prog := filepath.Join(tmpdir, file+".exe")
-       cmd := exec.Command("go", "build", "-o", prog, file+".go")
-       out, err := cmd.CombinedOutput()
-       if err != nil {
-               return fmt.Errorf("go build %s.go failed: %v\nOutput:\n%s", file, err, out)
-       }
-       defer os.Remove(prog)
-
-       // Only run the test if we have output to check.
-       if want == "" {
-               return nil
-       }
-
-       cmd = exec.Command(prog)
-       out, err = cmd.CombinedOutput()
-       if err != nil {
-               return fmt.Errorf("%s failed: %v\nOutput:\n%s", file, err, out)
-       }
-
-       // Canonicalize output.
-       out = bytes.TrimRight(out, "\n")
-       out = bytes.ReplaceAll(out, []byte{'\n'}, []byte{' '})
-
-       // Check the result.
-       match, err := regexp.Match(want, out)
-       if err != nil {
-               return fmt.Errorf("failed to parse regexp %q: %v", want, err)
-       }
-       if !match {
-               return fmt.Errorf("%s.go:\n%q\ndoes not match %s", file, out, want)
-       }
-
-       return nil
-}
-
-type testcase struct {
-       file string
-       want string
-}
-
-var tests = []testcase{
-       // defer_panic_recover
-       {"defer", `^0 3210 2$`},
-       {"defer2", `^Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 Recovered in f 4 Returned normally from f.$`},
-
-       // effective_go
-       {"eff_bytesize", `^1.00YB 9.09TB$`},
-       {"eff_qr", ""},
-       {"eff_sequence", `^\[-1 2 6 16 44\]$`},
-       {"eff_unused2", ""},
-
-       // error_handling
-       {"error", ""},
-       {"error2", ""},
-       {"error3", ""},
-       {"error4", ""},
-
-       // law_of_reflection
-       {"interface", ""},
-       {"interface2", `^type: float64$`},
-
-       // c_go_cgo
-       {"cgo1", ""},
-       {"cgo2", ""},
-       {"cgo3", ""},
-       {"cgo4", ""},
-
-       // timeout
-       {"timeout1", ""},
-       {"timeout2", ""},
-
-       // gobs
-       {"gobs1", ""},
-       {"gobs2", ""},
-
-       // json
-       {"json1", `^$`},
-       {"json2", `the reciprocal of i is`},
-       {"json3", `Age is int 6`},
-       {"json4", `^$`},
-       {"json5", ""},
-
-       // image_package
-       {"image_package1", `^X is 2 Y is 1$`},
-       {"image_package2", `^3 4 false$`},
-       {"image_package3", `^3 4 true$`},
-       {"image_package4", `^image.Point{X:2, Y:1}$`},
-       {"image_package5", `^{255 0 0 255}$`},
-       {"image_package6", `^8 4 true$`},
-
-       // other
-       {"go1", `^Christmas is a holiday: true .*go1.go already exists$`},
-       {"slices", ""},
-}
-
-func onlyTest(files ...string) {
-       var new []testcase
-NextFile:
-       for _, file := range files {
-               file = strings.TrimSuffix(file, ".go")
-               for _, tt := range tests {
-                       if tt.file == file {
-                               new = append(new, tt)
-                               continue NextFile
-                       }
-               }
-               fmt.Fprintf(os.Stderr, "test %s.go not found\n", file)
-               os.Exit(1)
-       }
-       tests = new
-}
-
-func skipTest(file string) {
-       for i, tt := range tests {
-               if tt.file == file {
-                       copy(tests[i:], tests[i+1:])
-                       tests = tests[:len(tests)-1]
-                       return
-               }
-       }
-       panic("delete(" + file + "): not found")
-}
-
-func fixcgo() {
-       if os.Getenv("CGO_ENABLED") != "1" {
-               skipTest("cgo1")
-               skipTest("cgo2")
-               skipTest("cgo3")
-               skipTest("cgo4")
-               return
-       }
-
-       switch runtime.GOOS {
-       case "freebsd":
-               // cgo1 and cgo2 don't run on freebsd, srandom has a different signature
-               skipTest("cgo1")
-               skipTest("cgo2")
-       case "netbsd":
-               // cgo1 and cgo2 don't run on netbsd, srandom has a different signature
-               skipTest("cgo1")
-               skipTest("cgo2")
-       }
-}

diff --git a/doc/progs/slices.go b/doc/progs/slices.go
deleted file mode 100644 (file)
index 967a3e7..0000000
--- a/doc/progs/slices.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-       "io/ioutil"
-       "regexp"
-)
-
-func AppendByte(slice []byte, data ...byte) []byte {
-       m := len(slice)
-       n := m + len(data)
-       if n > cap(slice) { // if necessary, reallocate
-               // allocate double what's needed, for future growth.
-               newSlice := make([]byte, (n+1)*2)
-               copy(newSlice, slice)
-               slice = newSlice
-       }
-       slice = slice[0:n]
-       copy(slice[m:n], data)
-       return slice
-}
-
-// STOP OMIT
-
-// Filter returns a new slice holding only
-// the elements of s that satisfy fn.
-func Filter(s []int, fn func(int) bool) []int {
-       var p []int // == nil
-       for _, i := range s {
-               if fn(i) {
-                       p = append(p, i)
-               }
-       }
-       return p
-}
-
-// STOP OMIT
-
-var digitRegexp = regexp.MustCompile("[0-9]+")
-
-func FindDigits(filename string) []byte {
-       b, _ := ioutil.ReadFile(filename)
-       return digitRegexp.Find(b)
-}
-
-// STOP OMIT
-
-func CopyDigits(filename string) []byte {
-       b, _ := ioutil.ReadFile(filename)
-       b = digitRegexp.Find(b)
-       c := make([]byte, len(b))
-       copy(c, b)
-       return c
-}
-
-// STOP OMIT
-
-func main() {
-       // place holder; no need to run
-}

diff --git a/doc/progs/timeout1.go b/doc/progs/timeout1.go
deleted file mode 100644 (file)
index 353ba69..0000000
--- a/doc/progs/timeout1.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package timeout
-
-import (
-       "time"
-)
-
-func Timeout() {
-       ch := make(chan bool, 1)
-       timeout := make(chan bool, 1)
-       go func() {
-               time.Sleep(1 * time.Second)
-               timeout <- true
-       }()
-
-       // STOP OMIT
-
-       select {
-       case <-ch:
-               // a read from ch has occurred
-       case <-timeout:
-               // the read from ch has timed out
-       }
-
-       // STOP OMIT
-}

diff --git a/doc/progs/timeout2.go b/doc/progs/timeout2.go
deleted file mode 100644 (file)
index b0d34ea..0000000
--- a/doc/progs/timeout2.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package query
-
-type Conn string
-
-func (c Conn) DoQuery(query string) Result {
-       return Result("result")
-}
-
-type Result string
-
-func Query(conns []Conn, query string) Result {
-       ch := make(chan Result, 1)
-       for _, conn := range conns {
-               go func(c Conn) {
-                       select {
-                       case ch <- c.DoQuery(query):
-                       default:
-                       }
-               }(conn)
-       }
-       return <-ch
-}
-
-// STOP OMIT

diff --git a/doc/share.png b/doc/share.png
deleted file mode 100644 (file)
index c04f0c7..0000000
Binary files a/doc/share.png and /dev/null differ

diff --git a/doc/tos.html b/doc/tos.html
deleted file mode 100644 (file)
index fff4642..0000000
--- a/doc/tos.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!--{
-       "Title": "Terms of service"
-}-->
-
-<p>
-The Go website (the "Website") is hosted by Google.
-By using and/or visiting the Website, you consent to be bound by Google's general
-<a href="//www.google.com/intl/en/policies/terms/">Terms of Service</a>
-and Google's general
-<a href="//www.google.com/intl/en/privacy/privacy-policy.html">Privacy Policy</a>.
-</p>

diff --git a/lib/time/update.bash b/lib/time/update.bash
index 8eebdf11f4f8b3a3f6318b278fba44f64b68fd77..e088ea6b908a5fc281654cb9bebbd87c46173ed5 100755 (executable)
--- a/lib/time/update.bash
+++ b/lib/time/update.bash
@@ -8,8 +8,8 @@
 # Consult https://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2020d
-DATA=2020d
+CODE=2021a
+DATA=2021a
 
 set -e
 rm -rf work

diff --git a/lib/time/zoneinfo.zip b/lib/time/zoneinfo.zip
index fa143a296da2f72ddb3413e45b60e432c69997e5..d32fbba5175174b72ca42df853941f5a7122fad6 100644 (file)
Binary files a/lib/time/zoneinfo.zip and b/lib/time/zoneinfo.zip differ

diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 814888e3ac5d9a7fad84e00dfb90e5e4c01d1bdd..08dd9b39d8191ec1a2d4a7ef30151724ffa4b85e 100644 (file)
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -182,7 +182,7 @@ func testCallbackCallers(t *testing.T) {
                "runtime.cgocallbackg1",
                "runtime.cgocallbackg",
                "runtime.cgocallback",
-               "runtime.asmcgocall",
+               "runtime.systemstack_switch",
                "runtime.cgocall",
                "test._Cfunc_callback",
                "test.nestedCall.func1",

diff --git a/misc/cgo/test/pkg_test.go b/misc/cgo/test/pkg_test.go
index a28ad4ea74f6b11c68e6edbbeb36e2105eb01de0..94abaa03e8d4b98cd679bcb69f5a3c38c6110ef6 100644 (file)
--- a/misc/cgo/test/pkg_test.go
+++ b/misc/cgo/test/pkg_test.go
@@ -30,7 +30,7 @@ func TestCrossPackageTests(t *testing.T) {
        switch runtime.GOOS {
        case "android":
                t.Skip("Can't exec cmd/go subprocess on Android.")
-       case "darwin", "ios":
+       case "ios":
                switch runtime.GOARCH {
                case "arm64":
                        t.Skip("Can't exec cmd/go subprocess on iOS.")

diff --git a/misc/cgo/testcarchive/carchive_test.go b/misc/cgo/testcarchive/carchive_test.go
index 6ed25d8948fbd892bb9b3a5e42debd48faea084b..6a5adf79ca05bb72cdbb048fade45c15d13f499b 100644 (file)
--- a/misc/cgo/testcarchive/carchive_test.go
+++ b/misc/cgo/testcarchive/carchive_test.go
@@ -118,11 +118,6 @@ func testMain(m *testing.M) int {
                cc = append(cc, s[start:])
        }
 
-       if GOOS == "darwin" || GOOS == "ios" {
-               // For Darwin/ARM.
-               // TODO: do we still need this?
-               cc = append(cc, []string{"-framework", "CoreFoundation", "-framework", "Foundation"}...)
-       }
        if GOOS == "aix" {
                // -Wl,-bnoobjreorder is mandatory to keep the same layout
                // in .text section.

diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go
index 5e0893784b69d74cca9350719c313748121c2230..f52391c6f6c6ab1750fce523ad87606f25a5c708 100644 (file)
--- a/misc/cgo/testshared/shared_test.go
+++ b/misc/cgo/testshared/shared_test.go
@@ -1063,3 +1063,11 @@ func TestGCData(t *testing.T) {
        goCmd(t, "build", "-linkshared", "./gcdata/main")
        runWithEnv(t, "running gcdata/main", []string{"GODEBUG=clobberfree=1"}, "./main")
 }
+
+// Test that we don't decode type symbols from shared libraries (which has no data,
+// causing panic). See issue 44031.
+func TestIssue44031(t *testing.T) {
+       goCmd(t, "install", "-buildmode=shared", "-linkshared", "./issue44031/a")
+       goCmd(t, "install", "-buildmode=shared", "-linkshared", "./issue44031/b")
+       goCmd(t, "run", "-linkshared", "./issue44031/main")
+}

diff --git a/misc/cgo/testshared/testdata/issue44031/a/a.go b/misc/cgo/testshared/testdata/issue44031/a/a.go
new file mode 100644 (file)
index 0000000..48827e6
--- /dev/null
+++ b/misc/cgo/testshared/testdata/issue44031/a/a.go
@@ -0,0 +1,9 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type ATypeWithALoooooongName interface { // a long name, so the type descriptor symbol name is mangled
+       M()
+}

diff --git a/misc/cgo/testshared/testdata/issue44031/b/b.go b/misc/cgo/testshared/testdata/issue44031/b/b.go
new file mode 100644 (file)
index 0000000..ad3ebec
--- /dev/null
+++ b/misc/cgo/testshared/testdata/issue44031/b/b.go
@@ -0,0 +1,17 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "testshared/issue44031/a"
+
+type T int
+
+func (T) M() {}
+
+var i = a.ATypeWithALoooooongName(T(0))
+
+func F() {
+       i.M()
+}

diff --git a/misc/cgo/testshared/testdata/issue44031/main/main.go b/misc/cgo/testshared/testdata/issue44031/main/main.go
new file mode 100644 (file)
index 0000000..47f2e3a
--- /dev/null
+++ b/misc/cgo/testshared/testdata/issue44031/main/main.go
@@ -0,0 +1,20 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "testshared/issue44031/b"
+
+type t int
+
+func (t) m() {}
+
+type i interface{ m() } // test that unexported method is correctly marked
+
+var v interface{} = t(0)
+
+func main() {
+       b.F()
+       v.(i).m()
+}

diff --git a/misc/ios/README b/misc/ios/README
index 433bcdfd8f951f3d6600cf51225b249c4e7b1186..0f5e9e335ea000251c469d6e80b3d6ae897254a6 100644 (file)
--- a/misc/ios/README
+++ b/misc/ios/README
@@ -7,6 +7,13 @@ set to the clang wrapper that invokes clang for iOS. For example, this command r
 
        GOOS=ios GOARCH=amd64 CGO_ENABLED=1 CC_FOR_TARGET=$(pwd)/../misc/ios/clangwrap.sh ./all.bash
 
+If CC_FOR_TARGET is not set when the toolchain is built (make.bash or all.bash), CC
+can be set on the command line. For example,
+
+       GOOS=ios GOARCH=amd64 CGO_ENABLED=1 CC=$(go env GOROOT)/misc/ios/clangwrap.sh go build
+
+Setting CC is not necessary if the toolchain is built with CC_FOR_TARGET set.
+
 To use the go tool to run individual programs and tests, put $GOROOT/bin into PATH to ensure
 the go_ios_$GOARCH_exec wrapper is found. For example, to run the archive/tar tests:
 

diff --git a/src/archive/tar/strconv.go b/src/archive/tar/strconv.go
index 0a910f33b9d68746e19992bf66bcb2091410b0cf..f0b61e6dba69a4fb393c8c92c694713c9defd4d6 100644 (file)
--- a/src/archive/tar/strconv.go
+++ b/src/archive/tar/strconv.go
@@ -28,7 +28,7 @@ func isASCII(s string) bool {
 }
 
 // toASCII converts the input to an ASCII C-style string.
-// This a best effort conversion, so invalid characters are dropped.
+// This is a best effort conversion, so invalid characters are dropped.
 func toASCII(s string) string {
        if isASCII(s) {
                return s
@@ -265,8 +265,27 @@ func parsePAXRecord(s string) (k, v, r string, err error) {
                return "", "", s, ErrHeader
        }
 
+       afterSpace := int64(sp + 1)
+       beforeLastNewLine := n - 1
+       // In some cases, "length" was perhaps padded/malformed, and
+       // trying to index past where the space supposedly is goes past
+       // the end of the actual record.
+       // For example:
+       //    "0000000000000000000000000000000030 mtime=1432668921.098285006\n30 ctime=2147483649.15163319"
+       //                                  ^     ^
+       //                                  |     |
+       //                                  |  afterSpace=35
+       //                                  |
+       //                          beforeLastNewLine=29
+       // yet indexOf(firstSpace) MUST BE before endOfRecord.
+       //
+       // See https://golang.org/issues/40196.
+       if afterSpace >= beforeLastNewLine {
+               return "", "", s, ErrHeader
+       }
+
        // Extract everything between the space and the final newline.
-       rec, nl, rem := s[sp+1:n-1], s[n-1:n], s[n:]
+       rec, nl, rem := s[afterSpace:beforeLastNewLine], s[beforeLastNewLine:n], s[n:]
        if nl != "\n" {
                return "", "", s, ErrHeader
        }

diff --git a/src/archive/tar/strconv_test.go b/src/archive/tar/strconv_test.go
index dd3505a758af8d5d17ceae4ecd1c11652952f6b0..add65e272ae6d776eecc97dd163f3988cddf23ce 100644 (file)
--- a/src/archive/tar/strconv_test.go
+++ b/src/archive/tar/strconv_test.go
@@ -368,6 +368,13 @@ func TestParsePAXRecord(t *testing.T) {
                {"16 longkeyname=hahaha\n", "16 longkeyname=hahaha\n", "", "", false},
                {"3 somelongkey=\n", "3 somelongkey=\n", "", "", false},
                {"50 tooshort=\n", "50 tooshort=\n", "", "", false},
+               {"0000000000000000000000000000000030 mtime=1432668921.098285006\n30 ctime=2147483649.15163319", "0000000000000000000000000000000030 mtime=1432668921.098285006\n30 ctime=2147483649.15163319", "mtime", "1432668921.098285006", false},
+               {"06 k=v\n", "06 k=v\n", "", "", false},
+               {"00006 k=v\n", "00006 k=v\n", "", "", false},
+               {"000006 k=v\n", "000006 k=v\n", "", "", false},
+               {"000000 k=v\n", "000000 k=v\n", "", "", false},
+               {"0 k=v\n", "0 k=v\n", "", "", false},
+               {"+0000005 x=\n", "+0000005 x=\n", "", "", false},
        }
 
        for _, v := range vectors {

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index ba42812fa6365e3a1adcf6c20b6606ce5b905820..efc2696f8fecc72bfdf6ad27ffc99ec814cdaae0 100644 (file)
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -16,10 +16,10 @@ import (
        "go/parser"
        "go/token"
        "go/types"
+       exec "internal/execabs"
        "io"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "runtime"

diff --git a/src/cmd/api/run.go b/src/cmd/api/run.go
index a36f1179c16e9839fa7f1bd417b788a27d9df6db..ecb1d0f81aa46695d47634b94eb6571368e0ffef 100644 (file)
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -10,9 +10,9 @@ package main
 
 import (
        "fmt"
+       exec "internal/execabs"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "runtime"
        "strings"

diff --git a/src/cmd/asm/internal/arch/arch.go b/src/cmd/asm/internal/arch/arch.go
index a62e55191e6898d43efc4aef5030bf9df5aea1ac..026d8abf81305f51d953b500c35d3bd2d7c7a087 100644 (file)
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -109,6 +109,10 @@ func archX86(linkArch *obj.LinkArch) *Arch {
        register["SB"] = RSB
        register["FP"] = RFP
        register["PC"] = RPC
+       if linkArch == &x86.Linkamd64 {
+               // Alias g to R14
+               register["g"] = x86.REGG
+       }
        // Register prefix not used on this architecture.
 
        instructions := make(map[string]obj.As)

diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index 7472507caf18ef64725e1a1822d8fb63632bed86..a4153f3af12fe1f78dd2bf8babc3cd467467d64f 100644 (file)
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -36,6 +36,7 @@ func testEndToEnd(t *testing.T, goarch, file string) {
        var ok bool
        testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
        ctxt.Bso = bufio.NewWriter(os.Stdout)
+       ctxt.IsAsm = true
        defer ctxt.Bso.Flush()
        failed := false
        ctxt.DiagFunc = func(format string, args ...interface{}) {
@@ -278,6 +279,7 @@ func testErrors(t *testing.T, goarch, file string) {
        var ok bool
        testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
        ctxt.Bso = bufio.NewWriter(os.Stdout)
+       ctxt.IsAsm = true
        defer ctxt.Bso.Flush()
        failed := false
        var errBuf bytes.Buffer

diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index 2e83e176b297cb5840944f7c3a6787370644ac97..c6def15e20eac16b07239ecca149ac03a66e0929 100644 (file)
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -259,6 +259,7 @@ var amd64OperandTests = []operandTest{
        {"R15", "R15"},
        {"R8", "R8"},
        {"R9", "R9"},
+       {"g", "R14"},
        {"SI", "SI"},
        {"SP", "SP"},
        {"X0", "X0"},

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index 154cf9c7a7854bf2cfe56ed1ef041286a1d04fc3..f1d37bc2c8d72148809cdd714f6fb91d32eb5eab 100644 (file)
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -305,7 +305,7 @@ func (p *Parser) pseudo(word string, operands [][]lex.Token) bool {
 // references and writes symabis information to w.
 //
 // The symabis format is documented at
-// cmd/compile/internal/gc.readSymABIs.
+// cmd/compile/internal/ssagen.ReadSymABIs.
 func (p *Parser) symDefRef(w io.Writer, word string, operands [][]lex.Token) {
        switch word {
        case "TEXT":

diff --git a/src/cmd/asm/internal/flags/flags.go b/src/cmd/asm/internal/flags/flags.go
index 1335860315a839ffc2d48580eda32d87790876ed..dd947c7b5ba5b805d4319d78fe432cafdbf1faad 100644 (file)
--- a/src/cmd/asm/internal/flags/flags.go
+++ b/src/cmd/asm/internal/flags/flags.go
@@ -32,11 +32,13 @@ var (
        D        MultiFlag
        I        MultiFlag
        PrintOut int
+       DebugV   bool
 )
 
 func init() {
        flag.Var(&D, "D", "predefined symbol with optional simple value -D=identifier=value; can be set multiple times")
        flag.Var(&I, "I", "include directory; can be set multiple times")
+       flag.BoolVar(&DebugV, "v", false, "print debug output")
        objabi.AddVersionFlag() // -V
        objabi.Flagcount("S", "print assembly and machine code", &PrintOut)
 }

diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go
index 31636e30458974920aa6d5a4ced11513a48cecdc..98618a67ef5311c94ab19adfaa0d9e728898aa26 100644 (file)
--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -36,6 +36,7 @@ func main() {
 
        ctxt := obj.Linknew(architecture.LinkArch)
        ctxt.Debugasm = flags.PrintOut
+       ctxt.Debugvlog = flags.DebugV
        ctxt.Flag_dynlink = *flags.Dynlink
        ctxt.Flag_linkshared = *flags.Linkshared
        ctxt.Flag_shared = *flags.Shared || *flags.Dynlink

diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 111a309eb5c026c78c99808c7ae8bfe25ee7b2a0..b5e28e325459c0ac54122e97ceeeb74de54133c2 100644 (file)
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -1549,7 +1549,14 @@ func (p *Package) gccBaseCmd() []string {
 func (p *Package) gccMachine() []string {
        switch goarch {
        case "amd64":
+               if goos == "darwin" {
+                       return []string{"-arch", "x86_64", "-m64"}
+               }
                return []string{"-m64"}
+       case "arm64":
+               if goos == "darwin" {
+                       return []string{"-arch", "arm64"}
+               }
        case "386":
                return []string{"-m32"}
        case "arm":

diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 11c53facf8f979488f52f494e287d61ec6bf494e..8e83f02202f73c15a92b8a1b5fce6f4b18236103 100644 (file)
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -14,10 +14,10 @@ import (
        "go/ast"
        "go/printer"
        "go/token"
+       exec "internal/execabs"
        "internal/xcoff"
        "io"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "sort"
@@ -953,9 +953,9 @@ func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
                // Build the wrapper function compiled by gcc.
                gccExport := ""
                if goos == "windows" {
-                       gccExport = "__declspec(dllexport)"
+                       gccExport = "__declspec(dllexport) "
                }
-               s := fmt.Sprintf("%s %s %s(", gccExport, gccResult, exp.ExpName)
+               s := fmt.Sprintf("%s%s %s(", gccExport, gccResult, exp.ExpName)
                if fn.Recv != nil {
                        s += p.cgoType(fn.Recv.List[0].Type).C.String()
                        s += " recv"

diff --git a/src/cmd/cgo/util.go b/src/cmd/cgo/util.go
index 921306b7aabf653c5d60c04aaee505c8d86bb75d..00d931b98a0c1e8416d5bb14334946dbd9a56304 100644 (file)
--- a/src/cmd/cgo/util.go
+++ b/src/cmd/cgo/util.go
@@ -8,9 +8,9 @@ import (
        "bytes"
        "fmt"
        "go/token"
+       exec "internal/execabs"
        "io/ioutil"
        "os"
-       "os/exec"
 )
 
 // run runs the command argv, feeding in stdin on standard input.
@@ -63,7 +63,7 @@ func run(stdin []byte, argv []string) (stdout, stderr []byte, ok bool) {
        p.Env = append(os.Environ(), "TERM=dumb")
        err := p.Run()
        if _, ok := err.(*exec.ExitError); err != nil && !ok {
-               fatalf("%s", err)
+               fatalf("exec %s: %s", argv[0], err)
        }
        ok = p.ProcessState.Success()
        stdout, stderr = bout.Bytes(), berr.Bytes()
@@ -88,7 +88,7 @@ func fatalf(msg string, args ...interface{}) {
        // If we've already printed other errors, they might have
        // caused the fatal condition. Assume they're enough.
        if nerrors == 0 {
-               fmt.Fprintf(os.Stderr, msg+"\n", args...)
+               fmt.Fprintf(os.Stderr, "cgo: "+msg+"\n", args...)
        }
        os.Exit(2)
 }

diff --git a/src/cmd/compile/fmt_test.go b/src/cmd/compile/fmt_test.go
deleted file mode 100644 (file)
index 6625ccf..0000000
--- a/src/cmd/compile/fmt_test.go
+++ /dev/null
@@ -1,599 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements TestFormats; a test that verifies
-// format strings in the compiler (this directory and all
-// subdirectories, recursively).
-//
-// TestFormats finds potential (Printf, etc.) format strings.
-// If they are used in a call, the format verbs are verified
-// based on the matching argument type against a precomputed
-// map of valid formats (knownFormats). This map can be used to
-// automatically rewrite format strings across all compiler
-// files with the -r flag.
-//
-// The format map needs to be updated whenever a new (type,
-// format) combination is found and the format verb is not
-// 'v' or 'T' (as in "%v" or "%T"). To update the map auto-
-// matically from the compiler source's use of format strings,
-// use the -u flag. (Whether formats are valid for the values
-// to be formatted must be verified manually, of course.)
-//
-// The -v flag prints out the names of all functions called
-// with a format string, the names of files that were not
-// processed, and any format rewrites made (with -r).
-//
-// Run as: go test -run Formats [-r][-u][-v]
-//
-// Known shortcomings:
-// - indexed format strings ("%[2]s", etc.) are not supported
-//   (the test will fail)
-// - format strings that are not simple string literals cannot
-//   be updated automatically
-//   (the test will fail with respective warnings)
-// - format strings in _test packages outside the current
-//   package are not processed
-//   (the test will report those files)
-//
-package main_test
-
-import (
-       "bytes"
-       "flag"
-       "fmt"
-       "go/ast"
-       "go/build"
-       "go/constant"
-       "go/format"
-       "go/importer"
-       "go/parser"
-       "go/token"
-       "go/types"
-       "internal/testenv"
-       "io"
-       "io/fs"
-       "io/ioutil"
-       "log"
-       "os"
-       "path/filepath"
-       "sort"
-       "strconv"
-       "strings"
-       "testing"
-       "unicode/utf8"
-)
-
-var (
-       rewrite = flag.Bool("r", false, "rewrite format strings")
-       update  = flag.Bool("u", false, "update known formats")
-)
-
-// The following variables collect information across all processed files.
-var (
-       fset          = token.NewFileSet()
-       formatStrings = make(map[*ast.BasicLit]bool)      // set of all potential format strings found
-       foundFormats  = make(map[string]bool)             // set of all formats found
-       callSites     = make(map[*ast.CallExpr]*callSite) // map of all calls
-)
-
-// A File is a corresponding (filename, ast) pair.
-type File struct {
-       name string
-       ast  *ast.File
-}
-
-func TestFormats(t *testing.T) {
-       if testing.Short() && testenv.Builder() == "" {
-               t.Skip("Skipping in short mode")
-       }
-       testenv.MustHaveGoBuild(t) // more restrictive than necessary, but that's ok
-
-       // process all directories
-       filepath.WalkDir(".", func(path string, info fs.DirEntry, err error) error {
-               if info.IsDir() {
-                       if info.Name() == "testdata" {
-                               return filepath.SkipDir
-                       }
-
-                       importPath := filepath.Join("cmd/compile", path)
-                       if ignoredPackages[filepath.ToSlash(importPath)] {
-                               return filepath.SkipDir
-                       }
-
-                       pkg, err := build.Import(importPath, path, 0)
-                       if err != nil {
-                               if _, ok := err.(*build.NoGoError); ok {
-                                       return nil // nothing to do here
-                               }
-                               t.Fatal(err)
-                       }
-                       collectPkgFormats(t, pkg)
-               }
-               return nil
-       })
-
-       // test and rewrite formats
-       updatedFiles := make(map[string]File) // files that were rewritten
-       for _, p := range callSites {
-               // test current format literal and determine updated one
-               out := formatReplace(p.str, func(index int, in string) string {
-                       if in == "*" {
-                               return in // cannot rewrite '*' (as in "%*d")
-                       }
-                       // in != '*'
-                       typ := p.types[index]
-                       format := typ + " " + in // e.g., "*Node %n"
-
-                       // check if format is known
-                       out, known := knownFormats[format]
-
-                       // record format if not yet found
-                       _, found := foundFormats[format]
-                       if !found {
-                               foundFormats[format] = true
-                       }
-
-                       // report an error if the format is unknown and this is the first
-                       // time we see it; ignore "%v" and "%T" which are always valid
-                       if !known && !found && in != "%v" && in != "%T" {
-                               t.Errorf("%s: unknown format %q for %s argument", posString(p.arg), in, typ)
-                       }
-
-                       if out == "" {
-                               out = in
-                       }
-                       return out
-               })
-
-               // replace existing format literal if it changed
-               if out != p.str {
-                       // we cannot replace the argument if it's not a string literal for now
-                       // (e.g., it may be "foo" + "bar")
-                       lit, ok := p.arg.(*ast.BasicLit)
-                       if !ok {
-                               delete(callSites, p.call) // treat as if we hadn't found this site
-                               continue
-                       }
-
-                       if testing.Verbose() {
-                               fmt.Printf("%s:\n\t- %q\n\t+ %q\n", posString(p.arg), p.str, out)
-                       }
-
-                       // find argument index of format argument
-                       index := -1
-                       for i, arg := range p.call.Args {
-                               if p.arg == arg {
-                                       index = i
-                                       break
-                               }
-                       }
-                       if index < 0 {
-                               // we may have processed the same call site twice,
-                               // but that shouldn't happen
-                               panic("internal error: matching argument not found")
-                       }
-
-                       // replace literal
-                       new := *lit                    // make a copy
-                       new.Value = strconv.Quote(out) // this may introduce "-quotes where there were `-quotes
-                       p.call.Args[index] = &new
-                       updatedFiles[p.file.name] = p.file
-               }
-       }
-
-       // write dirty files back
-       var filesUpdated bool
-       if len(updatedFiles) > 0 && *rewrite {
-               for _, file := range updatedFiles {
-                       var buf bytes.Buffer
-                       if err := format.Node(&buf, fset, file.ast); err != nil {
-                               t.Errorf("WARNING: gofmt %s failed: %v", file.name, err)
-                               continue
-                       }
-                       if err := ioutil.WriteFile(file.name, buf.Bytes(), 0x666); err != nil {
-                               t.Errorf("WARNING: writing %s failed: %v", file.name, err)
-                               continue
-                       }
-                       fmt.Printf("updated %s\n", file.name)
-                       filesUpdated = true
-               }
-       }
-
-       // report the names of all functions called with a format string
-       if len(callSites) > 0 && testing.Verbose() {
-               set := make(map[string]bool)
-               for _, p := range callSites {
-                       set[nodeString(p.call.Fun)] = true
-               }
-               var list []string
-               for s := range set {
-                       list = append(list, s)
-               }
-               fmt.Println("\nFunctions called with a format string")
-               writeList(os.Stdout, list)
-       }
-
-       // update formats
-       if len(foundFormats) > 0 && *update {
-               var list []string
-               for s := range foundFormats {
-                       list = append(list, fmt.Sprintf("%q: \"\",", s))
-               }
-               var buf bytes.Buffer
-               buf.WriteString(knownFormatsHeader)
-               writeList(&buf, list)
-               buf.WriteString("}\n")
-               out, err := format.Source(buf.Bytes())
-               const outfile = "fmtmap_test.go"
-               if err != nil {
-                       t.Errorf("WARNING: gofmt %s failed: %v", outfile, err)
-                       out = buf.Bytes() // continue with unformatted source
-               }
-               if err = ioutil.WriteFile(outfile, out, 0644); err != nil {
-                       t.Errorf("WARNING: updating format map failed: %v", err)
-               }
-       }
-
-       // check that knownFormats is up to date
-       if !*rewrite && !*update {
-               var mismatch bool
-               for s := range foundFormats {
-                       if _, ok := knownFormats[s]; !ok {
-                               mismatch = true
-                               break
-                       }
-               }
-               if !mismatch {
-                       for s := range knownFormats {
-                               if _, ok := foundFormats[s]; !ok {
-                                       mismatch = true
-                                       break
-                               }
-                       }
-               }
-               if mismatch {
-                       t.Errorf("format map is out of date; run 'go test -u' to update and manually verify correctness of change'")
-               }
-       }
-
-       // all format strings of calls must be in the formatStrings set (self-verification)
-       for _, p := range callSites {
-               if lit, ok := p.arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
-                       if formatStrings[lit] {
-                               // ok
-                               delete(formatStrings, lit)
-                       } else {
-                               // this should never happen
-                               panic(fmt.Sprintf("internal error: format string not found (%s)", posString(lit)))
-                       }
-               }
-       }
-
-       // if we have any strings left, we may need to update them manually
-       if len(formatStrings) > 0 && filesUpdated {
-               var list []string
-               for lit := range formatStrings {
-                       list = append(list, fmt.Sprintf("%s: %s", posString(lit), nodeString(lit)))
-               }
-               fmt.Println("\nWARNING: Potentially missed format strings")
-               writeList(os.Stdout, list)
-               t.Fail()
-       }
-
-       fmt.Println()
-}
-
-// A callSite describes a function call that appears to contain
-// a format string.
-type callSite struct {
-       file  File
-       call  *ast.CallExpr // call containing the format string
-       arg   ast.Expr      // format argument (string literal or constant)
-       str   string        // unquoted format string
-       types []string      // argument types
-}
-
-func collectPkgFormats(t *testing.T, pkg *build.Package) {
-       // collect all files
-       var filenames []string
-       filenames = append(filenames, pkg.GoFiles...)
-       filenames = append(filenames, pkg.CgoFiles...)
-       filenames = append(filenames, pkg.TestGoFiles...)
-
-       // TODO(gri) verify _test files outside package
-       for _, name := range pkg.XTestGoFiles {
-               // don't process this test itself
-               if name != "fmt_test.go" && testing.Verbose() {
-                       fmt.Printf("WARNING: %s not processed\n", filepath.Join(pkg.Dir, name))
-               }
-       }
-
-       // make filenames relative to .
-       for i, name := range filenames {
-               filenames[i] = filepath.Join(pkg.Dir, name)
-       }
-
-       // parse all files
-       files := make([]*ast.File, len(filenames))
-       for i, filename := range filenames {
-               f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
-               if err != nil {
-                       t.Fatal(err)
-               }
-               files[i] = f
-       }
-
-       // typecheck package
-       conf := types.Config{Importer: importer.Default()}
-       etypes := make(map[ast.Expr]types.TypeAndValue)
-       if _, err := conf.Check(pkg.ImportPath, fset, files, &types.Info{Types: etypes}); err != nil {
-               t.Fatal(err)
-       }
-
-       // collect all potential format strings (for extra verification later)
-       for _, file := range files {
-               ast.Inspect(file, func(n ast.Node) bool {
-                       if s, ok := stringLit(n); ok && isFormat(s) {
-                               formatStrings[n.(*ast.BasicLit)] = true
-                       }
-                       return true
-               })
-       }
-
-       // collect all formats/arguments of calls with format strings
-       for index, file := range files {
-               ast.Inspect(file, func(n ast.Node) bool {
-                       if call, ok := n.(*ast.CallExpr); ok {
-                               if ignoredFunctions[nodeString(call.Fun)] {
-                                       return true
-                               }
-                               // look for an arguments that might be a format string
-                               for i, arg := range call.Args {
-                                       if s, ok := stringVal(etypes[arg]); ok && isFormat(s) {
-                                               // make sure we have enough arguments
-                                               n := numFormatArgs(s)
-                                               if i+1+n > len(call.Args) {
-                                                       t.Errorf("%s: not enough format args (ignore %s?)", posString(call), nodeString(call.Fun))
-                                                       break // ignore this call
-                                               }
-                                               // assume last n arguments are to be formatted;
-                                               // determine their types
-                                               argTypes := make([]string, n)
-                                               for i, arg := range call.Args[len(call.Args)-n:] {
-                                                       if tv, ok := etypes[arg]; ok {
-                                                               argTypes[i] = typeString(tv.Type)
-                                                       }
-                                               }
-                                               // collect call site
-                                               if callSites[call] != nil {
-                                                       panic("internal error: file processed twice?")
-                                               }
-                                               callSites[call] = &callSite{
-                                                       file:  File{filenames[index], file},
-                                                       call:  call,
-                                                       arg:   arg,
-                                                       str:   s,
-                                                       types: argTypes,
-                                               }
-                                               break // at most one format per argument list
-                                       }
-                               }
-                       }
-                       return true
-               })
-       }
-}
-
-// writeList writes list in sorted order to w.
-func writeList(w io.Writer, list []string) {
-       sort.Strings(list)
-       for _, s := range list {
-               fmt.Fprintln(w, "\t", s)
-       }
-}
-
-// posString returns a string representation of n's position
-// in the form filename:line:col: .
-func posString(n ast.Node) string {
-       if n == nil {
-               return ""
-       }
-       return fset.Position(n.Pos()).String()
-}
-
-// nodeString returns a string representation of n.
-func nodeString(n ast.Node) string {
-       var buf bytes.Buffer
-       if err := format.Node(&buf, fset, n); err != nil {
-               log.Fatal(err) // should always succeed
-       }
-       return buf.String()
-}
-
-// typeString returns a string representation of n.
-func typeString(typ types.Type) string {
-       return filepath.ToSlash(typ.String())
-}
-
-// stringLit returns the unquoted string value and true if
-// n represents a string literal; otherwise it returns ""
-// and false.
-func stringLit(n ast.Node) (string, bool) {
-       if lit, ok := n.(*ast.BasicLit); ok && lit.Kind == token.STRING {
-               s, err := strconv.Unquote(lit.Value)
-               if err != nil {
-                       log.Fatal(err) // should not happen with correct ASTs
-               }
-               return s, true
-       }
-       return "", false
-}
-
-// stringVal returns the (unquoted) string value and true if
-// tv is a string constant; otherwise it returns "" and false.
-func stringVal(tv types.TypeAndValue) (string, bool) {
-       if tv.IsValue() && tv.Value != nil && tv.Value.Kind() == constant.String {
-               return constant.StringVal(tv.Value), true
-       }
-       return "", false
-}
-
-// formatIter iterates through the string s in increasing
-// index order and calls f for each format specifier '%..v'.
-// The arguments for f describe the specifier's index range.
-// If a format specifier contains a "*", f is called with
-// the index range for "*" alone, before being called for
-// the entire specifier. The result of f is the index of
-// the rune at which iteration continues.
-func formatIter(s string, f func(i, j int) int) {
-       i := 0     // index after current rune
-       var r rune // current rune
-
-       next := func() {
-               r1, w := utf8.DecodeRuneInString(s[i:])
-               if w == 0 {
-                       r1 = -1 // signal end-of-string
-               }
-               r = r1
-               i += w
-       }
-
-       flags := func() {
-               for r == ' ' || r == '#' || r == '+' || r == '-' || r == '0' {
-                       next()
-               }
-       }
-
-       index := func() {
-               if r == '[' {
-                       log.Fatalf("cannot handle indexed arguments: %s", s)
-               }
-       }
-
-       digits := func() {
-               index()
-               if r == '*' {
-                       i = f(i-1, i)
-                       next()
-                       return
-               }
-               for '0' <= r && r <= '9' {
-                       next()
-               }
-       }
-
-       for next(); r >= 0; next() {
-               if r == '%' {
-                       i0 := i
-                       next()
-                       flags()
-                       digits()
-                       if r == '.' {
-                               next()
-                               digits()
-                       }
-                       index()
-                       // accept any letter (a-z, A-Z) as format verb;
-                       // ignore anything else
-                       if 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' {
-                               i = f(i0-1, i)
-                       }
-               }
-       }
-}
-
-// isFormat reports whether s contains format specifiers.
-func isFormat(s string) (yes bool) {
-       formatIter(s, func(i, j int) int {
-               yes = true
-               return len(s) // stop iteration
-       })
-       return
-}
-
-// oneFormat reports whether s is exactly one format specifier.
-func oneFormat(s string) (yes bool) {
-       formatIter(s, func(i, j int) int {
-               yes = i == 0 && j == len(s)
-               return j
-       })
-       return
-}
-
-// numFormatArgs returns the number of format specifiers in s.
-func numFormatArgs(s string) int {
-       count := 0
-       formatIter(s, func(i, j int) int {
-               count++
-               return j
-       })
-       return count
-}
-
-// formatReplace replaces the i'th format specifier s in the incoming
-// string in with the result of f(i, s) and returns the new string.
-func formatReplace(in string, f func(i int, s string) string) string {
-       var buf []byte
-       i0 := 0
-       index := 0
-       formatIter(in, func(i, j int) int {
-               if sub := in[i:j]; sub != "*" { // ignore calls for "*" width/length specifiers
-                       buf = append(buf, in[i0:i]...)
-                       buf = append(buf, f(index, sub)...)
-                       i0 = j
-               }
-               index++
-               return j
-       })
-       return string(append(buf, in[i0:]...))
-}
-
-// ignoredPackages is the set of packages which can
-// be ignored.
-var ignoredPackages = map[string]bool{}
-
-// ignoredFunctions is the set of functions which may have
-// format-like arguments but which don't do any formatting and
-// thus may be ignored.
-var ignoredFunctions = map[string]bool{}
-
-func init() {
-       // verify that knownFormats entries are correctly formatted
-       for key, val := range knownFormats {
-               // key must be "typename format", and format starts with a '%'
-               // (formats containing '*' alone are not collected in this map)
-               i := strings.Index(key, "%")
-               if i < 0 || !oneFormat(key[i:]) {
-                       log.Fatalf("incorrect knownFormats key: %q", key)
-               }
-               // val must be "format" or ""
-               if val != "" && !oneFormat(val) {
-                       log.Fatalf("incorrect knownFormats value: %q (key = %q)", val, key)
-               }
-       }
-}
-
-const knownFormatsHeader = `// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements the knownFormats map which records the valid
-// formats for a given type. The valid formats must correspond to
-// supported compiler formats implemented in fmt.go, or whatever
-// other format verbs are implemented for the given type. The map may
-// also be used to change the use of a format verb across all compiler
-// sources automatically (for instance, if the implementation of fmt.go
-// changes), by using the -r option together with the new formats in the
-// map. To generate this file automatically from the existing source,
-// run: go test -run Formats -u.
-//
-// See the package comment in fmt_test.go for additional information.
-
-package main_test
-
-// knownFormats entries are of the form "typename format" -> "newformat".
-// An absent entry means that the format is not recognized as valid.
-// An empty new format means that the format should remain unchanged.
-var knownFormats = map[string]string{
-`

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
deleted file mode 100644 (file)
index 0811df7..0000000
--- a/src/cmd/compile/fmtmap_test.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements the knownFormats map which records the valid
-// formats for a given type. The valid formats must correspond to
-// supported compiler formats implemented in fmt.go, or whatever
-// other format verbs are implemented for the given type. The map may
-// also be used to change the use of a format verb across all compiler
-// sources automatically (for instance, if the implementation of fmt.go
-// changes), by using the -r option together with the new formats in the
-// map. To generate this file automatically from the existing source,
-// run: go test -run Formats -u.
-//
-// See the package comment in fmt_test.go for additional information.
-
-package main_test
-
-// knownFormats entries are of the form "typename format" -> "newformat".
-// An absent entry means that the format is not recognized as valid.
-// An empty new format means that the format should remain unchanged.
-var knownFormats = map[string]string{
-       "*bytes.Buffer %s":                                "",
-       "*cmd/compile/internal/gc.EscLocation %v":         "",
-       "*cmd/compile/internal/gc.Mpflt %v":               "",
-       "*cmd/compile/internal/gc.Mpint %v":               "",
-       "*cmd/compile/internal/gc.Node %#v":               "",
-       "*cmd/compile/internal/gc.Node %+S":               "",
-       "*cmd/compile/internal/gc.Node %+v":               "",
-       "*cmd/compile/internal/gc.Node %L":                "",
-       "*cmd/compile/internal/gc.Node %S":                "",
-       "*cmd/compile/internal/gc.Node %j":                "",
-       "*cmd/compile/internal/gc.Node %p":                "",
-       "*cmd/compile/internal/gc.Node %v":                "",
-       "*cmd/compile/internal/ssa.Block %s":              "",
-       "*cmd/compile/internal/ssa.Block %v":              "",
-       "*cmd/compile/internal/ssa.Func %s":               "",
-       "*cmd/compile/internal/ssa.Func %v":               "",
-       "*cmd/compile/internal/ssa.Register %s":           "",
-       "*cmd/compile/internal/ssa.Register %v":           "",
-       "*cmd/compile/internal/ssa.SparseTreeNode %v":     "",
-       "*cmd/compile/internal/ssa.Value %s":              "",
-       "*cmd/compile/internal/ssa.Value %v":              "",
-       "*cmd/compile/internal/ssa.sparseTreeMapEntry %v": "",
-       "*cmd/compile/internal/types.Field %p":            "",
-       "*cmd/compile/internal/types.Field %v":            "",
-       "*cmd/compile/internal/types.Sym %0S":             "",
-       "*cmd/compile/internal/types.Sym %S":              "",
-       "*cmd/compile/internal/types.Sym %p":              "",
-       "*cmd/compile/internal/types.Sym %v":              "",
-       "*cmd/compile/internal/types.Type %#L":            "",
-       "*cmd/compile/internal/types.Type %#v":            "",
-       "*cmd/compile/internal/types.Type %+v":            "",
-       "*cmd/compile/internal/types.Type %-S":            "",
-       "*cmd/compile/internal/types.Type %0S":            "",
-       "*cmd/compile/internal/types.Type %L":             "",
-       "*cmd/compile/internal/types.Type %S":             "",
-       "*cmd/compile/internal/types.Type %p":             "",
-       "*cmd/compile/internal/types.Type %s":             "",
-       "*cmd/compile/internal/types.Type %v":             "",
-       "*cmd/internal/obj.Addr %v":                       "",
-       "*cmd/internal/obj.LSym %v":                       "",
-       "*math/big.Float %f":                              "",
-       "*math/big.Int %#x":                               "",
-       "*math/big.Int %s":                                "",
-       "*math/big.Int %v":                                "",
-       "[16]byte %x":                                     "",
-       "[]*cmd/compile/internal/ssa.Block %v":            "",
-       "[]*cmd/compile/internal/ssa.Value %v":            "",
-       "[][]string %q":                                   "",
-       "[]byte %s":                                       "",
-       "[]byte %x":                                       "",
-       "[]cmd/compile/internal/ssa.Edge %v":              "",
-       "[]cmd/compile/internal/ssa.ID %v":                "",
-       "[]cmd/compile/internal/ssa.posetNode %v":         "",
-       "[]cmd/compile/internal/ssa.posetUndo %v":         "",
-       "[]cmd/compile/internal/syntax.token %s":          "",
-       "[]string %v":                                     "",
-       "[]uint32 %v":                                     "",
-       "bool %v":                                         "",
-       "byte %08b":                                       "",
-       "byte %c":                                         "",
-       "byte %q":                                         "",
-       "byte %v":                                         "",
-       "cmd/compile/internal/arm.shift %d":               "",
-       "cmd/compile/internal/gc.Class %d":                "",
-       "cmd/compile/internal/gc.Class %s":                "",
-       "cmd/compile/internal/gc.Class %v":                "",
-       "cmd/compile/internal/gc.Ctype %d":                "",
-       "cmd/compile/internal/gc.Ctype %v":                "",
-       "cmd/compile/internal/gc.Nodes %#v":               "",
-       "cmd/compile/internal/gc.Nodes %+v":               "",
-       "cmd/compile/internal/gc.Nodes %.v":               "",
-       "cmd/compile/internal/gc.Nodes %v":                "",
-       "cmd/compile/internal/gc.Op %#v":                  "",
-       "cmd/compile/internal/gc.Op %v":                   "",
-       "cmd/compile/internal/gc.Val %#v":                 "",
-       "cmd/compile/internal/gc.Val %T":                  "",
-       "cmd/compile/internal/gc.Val %v":                  "",
-       "cmd/compile/internal/gc.fmtMode %d":              "",
-       "cmd/compile/internal/gc.initKind %d":             "",
-       "cmd/compile/internal/gc.itag %v":                 "",
-       "cmd/compile/internal/ssa.BranchPrediction %d":    "",
-       "cmd/compile/internal/ssa.Edge %v":                "",
-       "cmd/compile/internal/ssa.GCNode %v":              "",
-       "cmd/compile/internal/ssa.ID %d":                  "",
-       "cmd/compile/internal/ssa.ID %v":                  "",
-       "cmd/compile/internal/ssa.LocalSlot %s":           "",
-       "cmd/compile/internal/ssa.LocalSlot %v":           "",
-       "cmd/compile/internal/ssa.Location %s":            "",
-       "cmd/compile/internal/ssa.Op %s":                  "",
-       "cmd/compile/internal/ssa.Op %v":                  "",
-       "cmd/compile/internal/ssa.Sym %v":                 "",
-       "cmd/compile/internal/ssa.ValAndOff %s":           "",
-       "cmd/compile/internal/ssa.domain %v":              "",
-       "cmd/compile/internal/ssa.flagConstant %s":        "",
-       "cmd/compile/internal/ssa.posetNode %v":           "",
-       "cmd/compile/internal/ssa.posetTestOp %v":         "",
-       "cmd/compile/internal/ssa.rbrank %d":              "",
-       "cmd/compile/internal/ssa.regMask %d":             "",
-       "cmd/compile/internal/ssa.register %d":            "",
-       "cmd/compile/internal/ssa.relation %s":            "",
-       "cmd/compile/internal/syntax.Error %q":            "",
-       "cmd/compile/internal/syntax.Expr %#v":            "",
-       "cmd/compile/internal/syntax.LitKind %d":          "",
-       "cmd/compile/internal/syntax.Node %T":             "",
-       "cmd/compile/internal/syntax.Operator %s":         "",
-       "cmd/compile/internal/syntax.Pos %s":              "",
-       "cmd/compile/internal/syntax.Pos %v":              "",
-       "cmd/compile/internal/syntax.position %s":         "",
-       "cmd/compile/internal/syntax.token %q":            "",
-       "cmd/compile/internal/syntax.token %s":            "",
-       "cmd/compile/internal/types.EType %d":             "",
-       "cmd/compile/internal/types.EType %s":             "",
-       "cmd/compile/internal/types.EType %v":             "",
-       "cmd/internal/obj.ABI %v":                         "",
-       "error %v":                                        "",
-       "float64 %.2f":                                    "",
-       "float64 %.3f":                                    "",
-       "float64 %.6g":                                    "",
-       "float64 %g":                                      "",
-       "int %#x":                                         "",
-       "int %-12d":                                       "",
-       "int %-6d":                                        "",
-       "int %-8o":                                        "",
-       "int %02d":                                        "",
-       "int %6d":                                         "",
-       "int %c":                                          "",
-       "int %d":                                          "",
-       "int %v":                                          "",
-       "int %x":                                          "",
-       "int16 %d":                                        "",
-       "int16 %x":                                        "",
-       "int32 %#x":                                       "",
-       "int32 %d":                                        "",
-       "int32 %v":                                        "",
-       "int32 %x":                                        "",
-       "int64 %#x":                                       "",
-       "int64 %+d":                                       "",
-       "int64 %-10d":                                     "",
-       "int64 %.5d":                                      "",
-       "int64 %d":                                        "",
-       "int64 %v":                                        "",
-       "int64 %x":                                        "",
-       "int8 %d":                                         "",
-       "int8 %v":                                         "",
-       "int8 %x":                                         "",
-       "interface{} %#v":                                 "",
-       "interface{} %T":                                  "",
-       "interface{} %p":                                  "",
-       "interface{} %q":                                  "",
-       "interface{} %s":                                  "",
-       "interface{} %v":                                  "",
-       "map[*cmd/compile/internal/gc.Node]*cmd/compile/internal/ssa.Value %v": "",
-       "map[*cmd/compile/internal/gc.Node][]*cmd/compile/internal/gc.Node %v": "",
-       "map[cmd/compile/internal/ssa.ID]uint32 %v":                            "",
-       "map[int64]uint32 %v":  "",
-       "math/big.Accuracy %s": "",
-       "reflect.Type %s":      "",
-       "rune %#U":             "",
-       "rune %c":              "",
-       "rune %q":              "",
-       "string %-*s":          "",
-       "string %-16s":         "",
-       "string %-6s":          "",
-       "string %q":            "",
-       "string %s":            "",
-       "string %v":            "",
-       "time.Duration %d":     "",
-       "time.Duration %v":     "",
-       "uint %04x":            "",
-       "uint %5d":             "",
-       "uint %d":              "",
-       "uint %x":              "",
-       "uint16 %d":            "",
-       "uint16 %x":            "",
-       "uint32 %#U":           "",
-       "uint32 %#x":           "",
-       "uint32 %d":            "",
-       "uint32 %v":            "",
-       "uint32 %x":            "",
-       "uint64 %08x":          "",
-       "uint64 %b":            "",
-       "uint64 %d":            "",
-       "uint64 %x":            "",
-       "uint8 %#x":            "",
-       "uint8 %d":             "",
-       "uint8 %v":             "",
-       "uint8 %x":             "",
-       "uintptr %d":           "",
-}

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
new file mode 100644 (file)
index 0000000..f4ef2cc
--- /dev/null
+++ b/src/cmd/compile/internal-abi.md
@@ -0,0 +1,628 @@
+# Go internal ABI specification
+
+This document describes Go’s internal application binary interface
+(ABI), known as ABIInternal.
+Go's ABI defines the layout of data in memory and the conventions for
+calling between Go functions.
+This ABI is *unstable* and will change between Go versions.
+If you’re writing assembly code, please instead refer to Go’s
+[assembly documentation](/doc/asm.html), which describes Go’s stable
+ABI, known as ABI0.
+
+All functions defined in Go source follow ABIInternal.
+However, ABIInternal and ABI0 functions are able to call each other
+through transparent *ABI wrappers*, described in the [internal calling
+convention proposal](https://golang.org/design/27539-internal-abi).
+
+Go uses a common ABI design across all architectures.
+We first describe the common ABI, and then cover per-architecture
+specifics.
+
+*Rationale*: For the reasoning behind using a common ABI across
+architectures instead of the platform ABI, see the [register-based Go
+calling convention proposal](https://golang.org/design/40724-register-calling).
+
+## Memory layout
+
+Go's built-in types have the following sizes and alignments.
+Many, though not all, of these sizes are guaranteed by the [language
+specification](/doc/go_spec.html#Size_and_alignment_guarantees).
+Those that aren't guaranteed may change in future versions of Go (for
+example, we've considered changing the alignment of int64 on 32-bit).
+
+| Type | 64-bit |       | 32-bit |       |
+| ---  | ---    | ---   | ---    | ---   |
+|      | Size   | Align | Size   | Align |
+| bool, uint8, int8  | 1  | 1 | 1  | 1 |
+| uint16, int16      | 2  | 2 | 2  | 2 |
+| uint32, int32      | 4  | 4 | 4  | 4 |
+| uint64, int64      | 8  | 8 | 8  | 4 |
+| int, uint          | 8  | 8 | 4  | 4 |
+| float32            | 4  | 4 | 4  | 4 |
+| float64            | 8  | 8 | 8  | 4 |
+| complex64          | 8  | 4 | 8  | 4 |
+| complex128         | 16 | 8 | 16 | 4 |
+| uintptr, *T, unsafe.Pointer | 8 | 8 | 4 | 4 |
+
+The types `byte` and `rune` are aliases for `uint8` and `int32`,
+respectively, and hence have the same size and alignment as these
+types.
+
+The layout of `map`, `chan`, and `func` types is equivalent to *T.
+
+To describe the layout of the remaining composite types, we first
+define the layout of a *sequence* S of N fields with types
+t<sub>1</sub>, t<sub>2</sub>, ..., t<sub>N</sub>.
+We define the byte offset at which each field begins relative to a
+base address of 0, as well as the size and alignment of the sequence
+as follows:
+
+```
+offset(S, i) = 0  if i = 1
+             = align(offset(S, i-1) + sizeof(t_(i-1)), alignof(t_i))
+alignof(S)   = 1  if N = 0
+             = max(alignof(t_i) | 1 <= i <= N)
+sizeof(S)    = 0  if N = 0
+             = align(offset(S, N) + sizeof(t_N), alignof(S))
+```
+
+Where sizeof(T) and alignof(T) are the size and alignment of type T,
+respectively, and align(x, y) rounds x up to a multiple of y.
+
+The `interface{}` type is a sequence of 1. a pointer to the runtime type
+description for the interface's dynamic type and 2. an `unsafe.Pointer`
+data field.
+Any other interface type (besides the empty interface) is a sequence
+of 1. a pointer to the runtime "itab" that gives the method pointers and
+the type of the data field and 2. an `unsafe.Pointer` data field.
+An interface can be "direct" or "indirect" depending on the dynamic
+type: a direct interface stores the value directly in the data field,
+and an indirect interface stores a pointer to the value in the data
+field.
+An interface can only be direct if the value consists of a single
+pointer word.
+
+An array type `[N]T` is a sequence of N fields of type T.
+
+The slice type `[]T` is a sequence of a `*[cap]T` pointer to the slice
+backing store, an `int` giving the `len` of the slice, and an `int`
+giving the `cap` of the slice.
+
+The `string` type is a sequence of a `*[len]byte` pointer to the
+string backing store, and an `int` giving the `len` of the string.
+
+A struct type `struct { f1 t1; ...; fM tM }` is laid out as the
+sequence t1, ..., tM, tP, where tP is either:
+
+- Type `byte` if sizeof(tM) = 0 and any of sizeof(t*i*) ≠ 0.
+- Empty (size 0 and align 1) otherwise.
+
+The padding byte prevents creating a past-the-end pointer by taking
+the address of the final, empty fN field.
+
+Note that user-written assembly code should generally not depend on Go
+type layout and should instead use the constants defined in
+[`go_asm.h`](/doc/asm.html#data-offsets).
+
+## Function call argument and result passing
+
+Function calls pass arguments and results using a combination of the
+stack and machine registers.
+Each argument or result is passed either entirely in registers or
+entirely on the stack.
+Because access to registers is generally faster than access to the
+stack, arguments and results are preferentially passed in registers.
+However, any argument or result that contains a non-trivial array or
+does not fit entirely in the remaining available registers is passed
+on the stack.
+
+Each architecture defines a sequence of integer registers and a
+sequence of floating-point registers.
+At a high level, arguments and results are recursively broken down
+into values of base types and these base values are assigned to
+registers from these sequences.
+
+Arguments and results can share the same registers, but do not share
+the same stack space.
+Beyond the arguments and results passed on the stack, the caller also
+reserves spill space on the stack for all register-based arguments
+(but does not populate this space).
+
+The receiver, arguments, and results of function or method F are
+assigned to registers or the stack using the following algorithm:
+
+1. Let NI and NFP be the length of integer and floating-point register
+   sequences defined by the architecture.
+   Let I and FP be 0; these are the indexes of the next integer and
+   floating-pointer register.
+   Let S, the type sequence defining the stack frame, be empty.
+1. If F is a method, assign F’s receiver.
+1. For each argument A of F, assign A.
+1. Add a pointer-alignment field to S. This has size 0 and the same
+   alignment as `uintptr`.
+1. Reset I and FP to 0.
+1. For each result R of F, assign R.
+1. Add a pointer-alignment field to S.
+1. For each register-assigned receiver and argument of F, let T be its
+   type and add T to the stack sequence S.
+   This is the argument's (or receiver's) spill space and will be
+   uninitialized at the call.
+1. Add a pointer-alignment field to S.
+
+Assigning a receiver, argument, or result V of underlying type T works
+as follows:
+
+1. Remember I and FP.
+1. Try to register-assign V.
+1. If step 2 failed, reset I and FP to the values from step 1, add T
+   to the stack sequence S, and assign V to this field in S.
+
+Register-assignment of a value V of underlying type T works as follows:
+
+1. If T is a boolean or integral type that fits in an integer
+   register, assign V to register I and increment I.
+1. If T is an integral type that fits in two integer registers, assign
+   the least significant and most significant halves of V to registers
+   I and I+1, respectively, and increment I by 2
+1. If T is a floating-point type and can be represented without loss
+   of precision in a floating-point register, assign V to register FP
+   and increment FP.
+1. If T is a complex type, recursively register-assign its real and
+   imaginary parts.
+1. If T is a pointer type, map type, channel type, or function type,
+   assign V to register I and increment I.
+1. If T is a string type, interface type, or slice type, recursively
+   register-assign V’s components (2 for strings and interfaces, 3 for
+   slices).
+1. If T is a struct type, recursively register-assign each field of V.
+1. If T is an array type of length 0, do nothing.
+1. If T is an array type of length 1, recursively register-assign its
+   one element.
+1. If T is an array type of length > 1, fail.
+1. If I > NI or FP > NFP, fail.
+1. If any recursive assignment above fails, fail.
+
+The above algorithm produces an assignment of each receiver, argument,
+and result to registers or to a field in the stack sequence.
+The final stack sequence looks like: stack-assigned receiver,
+stack-assigned arguments, pointer-alignment, stack-assigned results,
+pointer-alignment, spill space for each register-assigned argument,
+pointer-alignment.
+The following diagram shows what this stack frame looks like on the
+stack, using the typical convention where address 0 is at the bottom:
+
+    +------------------------------+
+    |             . . .            |
+    | 2nd reg argument spill space |
+    | 1st reg argument spill space |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned result    |
+    | 1st stack-assigned result    |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned argument  |
+    | 1st stack-assigned argument  |
+    | stack-assigned receiver      |
+    +------------------------------+ ↓ lower addresses
+
+To perform a call, the caller reserves space starting at the lowest
+address in its stack frame for the call stack frame, stores arguments
+in the registers and argument stack fields determined by the above
+algorithm, and performs the call.
+At the time of a call, spill space, result stack fields, and result
+registers are left uninitialized.
+Upon return, the callee must have stored results to all result
+registers and result stack fields determined by the above algorithm.
+
+There are no callee-save registers, so a call may overwrite any
+register that doesn’t have a fixed meaning, including argument
+registers.
+
+### Example
+
+Consider the function `func f(a1 uint8, a2 [2]uintptr, a3 uint8) (r1
+struct { x uintptr; y [2]uintptr }, r2 string)` on a 64-bit
+architecture with hypothetical integer registers R0–R9.
+
+On entry, `a1` is assigned to `R0`, `a3` is assigned to `R1` and the
+stack frame is laid out in the following sequence:
+
+    a2      [2]uintptr
+    r1.x    uintptr
+    r1.y    [2]uintptr
+    a1Spill uint8
+    a2Spill uint8
+    _       [6]uint8  // alignment padding
+
+In the stack frame, only the `a2` field is initialized on entry; the
+rest of the frame is left uninitialized.
+
+On exit, `r2.base` is assigned to `R0`, `r2.len` is assigned to `R1`,
+and `r1.x` and `r1.y` are initialized in the stack frame.
+
+There are several things to note in this example.
+First, `a2` and `r1` are stack-assigned because they contain arrays.
+The other arguments and results are register-assigned.
+Result `r2` is decomposed into its components, which are individually
+register-assigned.
+On the stack, the stack-assigned arguments appear at lower addresses
+than the stack-assigned results, which appear at lower addresses than
+the argument spill area.
+Only arguments, not results, are assigned a spill area on the stack.
+
+### Rationale
+
+Each base value is assigned to its own register to optimize
+construction and access.
+An alternative would be to pack multiple sub-word values into
+registers, or to simply map an argument's in-memory layout to
+registers (this is common in C ABIs), but this typically adds cost to
+pack and unpack these values.
+Modern architectures have more than enough registers to pass all
+arguments and results this way for nearly all functions (see the
+appendix), so there’s little downside to spreading base values across
+registers.
+
+Arguments that can’t be fully assigned to registers are passed
+entirely on the stack in case the callee takes the address of that
+argument.
+If an argument could be split across the stack and registers and the
+callee took its address, it would need to be reconstructed in memory,
+a process that would be proportional to the size of the argument.
+
+Non-trivial arrays are always passed on the stack because indexing
+into an array typically requires a computed offset, which generally
+isn’t possible with registers.
+Arrays in general are rare in function signatures (only 0.7% of
+functions in the Go 1.15 standard library and 0.2% in kubelet).
+We considered allowing array fields to be passed on the stack while
+the rest of an argument’s fields are passed in registers, but this
+creates the same problems as other large structs if the callee takes
+the address of an argument, and would benefit <0.1% of functions in
+kubelet (and even these very little).
+
+We make exceptions for 0 and 1-element arrays because these don’t
+require computed offsets, and 1-element arrays are already decomposed
+in the compiler’s SSA representation.
+
+The ABI assignment algorithm above is equivalent to Go’s stack-based
+ABI0 calling convention if there are zero architecture registers.
+This is intended to ease the transition to the register-based internal
+ABI and make it easy for the compiler to generate either calling
+convention.
+An architecture may still define register meanings that aren’t
+compatible with ABI0, but these differences should be easy to account
+for in the compiler.
+
+The algorithm reserves spill space for arguments in the caller’s frame
+so that the compiler can generate a stack growth path that spills into
+this reserved space.
+If the callee has to grow the stack, it may not be able to reserve
+enough additional stack space in its own frame to spill these, which
+is why it’s important that the caller do so.
+These slots also act as the home location if these arguments need to
+be spilled for any other reason, which simplifies traceback printing.
+
+There are several options for how to lay out the argument spill space.
+We chose to lay out each argument according to its type's usual memory
+layout but to separate the spill space from the regular argument
+space.
+Using the usual memory layout simplifies the compiler because it
+already understands this layout.
+Also, if a function takes the address of a register-assigned argument,
+the compiler must spill that argument to memory in its usual memory
+layout and it's more convenient to use the argument spill space for
+this purpose.
+
+Alternatively, the spill space could be structured around argument
+registers.
+In this approach, the stack growth spill path would spill each
+argument register to a register-sized stack word.
+However, if the function takes the address of a register-assigned
+argument, the compiler would have to reconstruct it in memory layout
+elsewhere on the stack.
+
+The spill space could also be interleaved with the stack-assigned
+arguments so the arguments appear in order whether they are register-
+or stack-assigned.
+This would be close to ABI0, except that register-assigned arguments
+would be uninitialized on the stack and there's no need to reserve
+stack space for register-assigned results.
+We expect separating the spill space to perform better because of
+memory locality.
+Separating the space is also potentially simpler for `reflect` calls
+because this allows `reflect` to summarize the spill space as a single
+number.
+Finally, the long-term intent is to remove reserved spill slots
+entirely – allowing most functions to be called without any stack
+setup and easing the introduction of callee-save registers – and
+separating the spill space makes that transition easier.
+
+## Closures
+
+A func value (e.g., `var x func()`) is a pointer to a closure object.
+A closure object begins with a pointer-sized program counter
+representing the entry point of the function, followed by zero or more
+bytes containing the closed-over environment.
+
+Closure calls follow the same conventions as static function and
+method calls, with one addition. Each architecture specifies a
+*closure context pointer* register and calls to closures store the
+address of the closure object in the closure context pointer register
+prior to the call.
+
+## Software floating-point mode
+
+In "softfloat" mode, the ABI simply treats the hardware as having zero
+floating-point registers.
+As a result, any arguments containing floating-point values will be
+passed on the stack.
+
+*Rationale*: Softfloat mode is about compatibility over performance
+and is not commonly used.
+Hence, we keep the ABI as simple as possible in this case, rather than
+adding additional rules for passing floating-point values in integer
+registers.
+
+## Architecture specifics
+
+This section describes per-architecture register mappings, as well as
+other per-architecture special cases.
+
+### amd64 architecture
+
+The amd64 architecture uses the following sequence of 9 registers for
+integer arguments and results:
+
+    RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11
+
+It uses X0 – X14 for floating-point arguments and results.
+
+*Rationale*: These sequences are chosen from the available registers
+to be relatively easy to remember.
+
+Registers R12 and R13 are permanent scratch registers.
+R15 is a scratch register except in dynamically linked binaries.
+
+*Rationale*: Some operations such as stack growth and reflection calls
+need dedicated scratch registers in order to manipulate call frames
+without corrupting arguments or results.
+
+Special-purpose registers are as follows:
+
+| Register | Call meaning | Body meaning |
+| --- | --- | --- |
+| RSP | Stack pointer | Fixed |
+| RBP | Frame pointer | Fixed |
+| RDX | Closure context pointer | Scratch |
+| R12 | None | Scratch |
+| R13 | None | Scratch |
+| R14 | Current goroutine | Scratch |
+| R15 | GOT reference temporary | Fixed if dynlink |
+| X15 | Zero value | Fixed |
+
+TODO: We may start with the existing TLS-based g and move to R14
+later.
+
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention except for R14 and X15, which will have
+to be restored on transitions from ABI0 code to ABIInternal code.
+In ABI0, these are undefined, so transitions from ABIInternal to ABI0
+can ignore these registers.
+
+*Rationale*: For the current goroutine pointer, we chose a register
+that requires an additional REX byte.
+While this adds one byte to every function prologue, it is hardly ever
+accessed outside the function prologue and we expect making more
+single-byte registers available to be a net win.
+
+*Rationale*: We designate X15 as a fixed zero register because
+functions often have to bulk zero their stack frames, and this is more
+efficient with a designated zero register.
+
+#### Stack layout
+
+The stack pointer, RSP, grows down and is always aligned to 8 bytes.
+
+The amd64 architecture does not use a link register.
+
+A function's stack frame is laid out as follows:
+
+    +------------------------------+
+    | return PC                    |
+    | RBP on entry                 |
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is pushed as part of the standard amd64 `CALL`
+operation.
+On entry, a function subtracts from RSP to open its stack frame and
+saves the value of RBP directly below the return PC.
+A leaf function that does not require any stack space may omit the
+saved RBP.
+
+The Go ABI's use of RBP as a frame pointer register is compatible with
+amd64 platform conventions so that Go can inter-operate with platform
+debuggers and profilers.
+
+#### Flags
+
+The direction flag (D) is always cleared (set to the “forward”
+direction) at a call.
+The arithmetic status flags are treated like scratch registers and not
+preserved across calls.
+All other bits in RFLAGS are system flags.
+
+The CPU is always in MMX technology state (not x87 mode).
+
+*Rationale*: Go on amd64 uses the XMM registers and never uses the x87
+registers, so it makes sense to assume the CPU is in MMX mode.
+Otherwise, any function that used the XMM registers would have to
+execute an EMMS instruction before calling another function or
+returning (this is the case in the SysV ABI).
+
+At calls, the MXCSR control bits are always set as follows:
+
+| Flag | Bit | Value | Meaning |
+| --- | --- | --- | --- |
+| FZ | 15 | 0 | Do not flush to zero |
+| RC | 14/13 | 0 (RN) | Round to nearest |
+| PM | 12 | 1 | Precision masked |
+| UM | 11 | 1 | Underflow masked |
+| OM | 10 | 1 | Overflow masked |
+| ZM | 9 | 1 | Divide-by-zero masked |
+| DM | 8 | 1 | Denormal operations masked |
+| IM | 7 | 1 | Invalid operations masked |
+| DAZ | 6 | 0 | Do not zero de-normals |
+
+The MXCSR status bits are callee-save.
+
+*Rationale*: Having a fixed MXCSR control configuration allows Go
+functions to use SSE operations without modifying or saving the MXCSR.
+Functions are allowed to modify it between calls (as long as they
+restore it), but as of this writing Go code never does.
+The above fixed configuration matches the process initialization
+control bits specified by the ELF AMD64 ABI.
+
+The x87 floating-point control word is not used by Go on amd64.
+
+## Future directions
+
+### Spill path improvements
+
+The ABI currently reserves spill space for argument registers so the
+compiler can statically generate an argument spill path before calling
+into `runtime.morestack` to grow the stack.
+This ensures there will be sufficient spill space even when the stack
+is nearly exhausted and keeps stack growth and stack scanning
+essentially unchanged from ABI0.
+
+However, this wastes stack space (the median wastage is 16 bytes per
+call), resulting in larger stacks and increased cache footprint.
+A better approach would be to reserve stack space only when spilling.
+One way to ensure enough space is available to spill would be for
+every function to ensure there is enough space for the function's own
+frame *as well as* the spill space of all functions it calls.
+For most functions, this would change the threshold for the prologue
+stack growth check.
+For `nosplit` functions, this would change the threshold used in the
+linker's static stack size check.
+
+Allocating spill space in the callee rather than the caller may also
+allow for faster reflection calls in the common case where a function
+takes only register arguments, since it would allow reflection to make
+these calls directly without allocating any frame.
+
+The statically-generated spill path also increases code size.
+It is possible to instead have a generic spill path in the runtime, as
+part of `morestack`.
+However, this complicates reserving the spill space, since spilling
+all possible register arguments would, in most cases, take
+significantly more space than spilling only those used by a particular
+function.
+Some options are to spill to a temporary space and copy back only the
+registers used by the function, or to grow the stack if necessary
+before spilling to it (using a temporary space if necessary), or to
+use a heap-allocated space if insufficient stack space is available.
+These options all add enough complexity that we will have to make this
+decision based on the actual code size growth caused by the static
+spill paths.
+
+### Clobber sets
+
+As defined, the ABI does not use callee-save registers.
+This significantly simplifies the garbage collector and the compiler's
+register allocator, but at some performance cost.
+A potentially better balance for Go code would be to use *clobber
+sets*: for each function, the compiler records the set of registers it
+clobbers (including those clobbered by functions it calls) and any
+register not clobbered by function F can remain live across calls to
+F.
+
+This is generally a good fit for Go because Go's package DAG allows
+function metadata like the clobber set to flow up the call graph, even
+across package boundaries.
+Clobber sets would require relatively little change to the garbage
+collector, unlike general callee-save registers.
+One disadvantage of clobber sets over callee-save registers is that
+they don't help with indirect function calls or interface method
+calls, since static information isn't available in these cases.
+
+### Large aggregates
+
+Go encourages passing composite values by value, and this simplifies
+reasoning about mutation and races.
+However, this comes at a performance cost for large composite values.
+It may be possible to instead transparently pass large composite
+values by reference and delay copying until it is actually necessary.
+
+## Appendix: Register usage analysis
+
+In order to understand the impacts of the above design on register
+usage, we
+[analyzed](https://github.com/aclements/go-misc/tree/master/abi) the
+impact of the above ABI on a large code base: cmd/kubelet from
+[Kubernetes](https://github.com/kubernetes/kubernetes) at tag v1.18.8.
+
+The following table shows the impact of different numbers of available
+integer and floating-point registers on argument assignment:
+
+```
+|      |        |       |      stack args |          spills |     stack total |
+| ints | floats | % fit | p50 | p95 | p99 | p50 | p95 | p99 | p50 | p95 | p99 |
+|    0 |      0 |  6.3% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    0 |      8 |  6.4% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    1 |      8 | 21.3% |  24 | 144 | 248 |   8 |   8 |   8 |  32 | 152 | 256 |
+|    2 |      8 | 38.9% |  16 | 128 | 224 |   8 |  16 |  16 |  24 | 136 | 240 |
+|    3 |      8 | 57.0% |   0 | 120 | 224 |  16 |  24 |  24 |  24 | 136 | 240 |
+|    4 |      8 | 73.0% |   0 | 120 | 216 |  16 |  32 |  32 |  24 | 136 | 232 |
+|    5 |      8 | 83.3% |   0 | 112 | 216 |  16 |  40 |  40 |  24 | 136 | 232 |
+|    6 |      8 | 87.5% |   0 | 112 | 208 |  16 |  48 |  48 |  24 | 136 | 232 |
+|    7 |      8 | 89.8% |   0 | 112 | 208 |  16 |  48 |  56 |  24 | 136 | 232 |
+|    8 |      8 | 91.3% |   0 | 112 | 200 |  16 |  56 |  64 |  24 | 136 | 232 |
+|    9 |      8 | 92.1% |   0 | 112 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   10 |      8 | 92.6% |   0 | 104 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   11 |      8 | 93.1% |   0 | 104 | 184 |  16 |  56 |  80 |  24 | 128 | 232 |
+|   12 |      8 | 93.4% |   0 | 104 | 176 |  16 |  56 |  88 |  24 | 128 | 232 |
+|   13 |      8 | 94.0% |   0 |  88 | 176 |  16 |  56 |  96 |  24 | 128 | 232 |
+|   14 |      8 | 94.4% |   0 |  80 | 152 |  16 |  64 | 104 |  24 | 128 | 232 |
+|   15 |      8 | 94.6% |   0 |  80 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|   16 |      8 | 94.9% |   0 |  16 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|    ∞ |      8 | 99.8% |   0 |   0 |   0 |  24 | 112 | 216 |  24 | 120 | 216 |
+```
+
+The first two columns show the number of available integer and
+floating-point registers.
+The first row shows the results for 0 integer and 0 floating-point
+registers, which is equivalent to ABI0.
+We found that any reasonable number of floating-point registers has
+the same effect, so we fixed it at 8 for all other rows.
+
+The “% fit” column gives the fraction of functions where all arguments
+and results are register-assigned and no arguments are passed on the
+stack.
+The three “stack args” columns give the median, 95th and 99th
+percentile number of bytes of stack arguments.
+The “spills” columns likewise summarize the number of bytes in
+on-stack spill space.
+And “stack total” summarizes the sum of stack arguments and on-stack
+spill slots.
+Note that these are three different distributions; for example,
+there’s no single function that takes 0 stack argument bytes, 16 spill
+bytes, and 24 total stack bytes.
+
+From this, we can see that the fraction of functions that fit entirely
+in registers grows very slowly once it reaches about 90%, though
+curiously there is a small minority of functions that could benefit
+from a huge number of registers.
+Making 9 integer registers available on amd64 puts it in this realm.
+We also see that the stack space required for most functions is fairly
+small.
+While the increasing space required for spills largely balances out
+the decreasing space required for stack arguments as the number of
+available registers increases, there is a general reduction in the
+total stack space required with more available registers.
+This does, however, suggest that eliminating spill slots in the future
+would noticeably reduce stack requirements.

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
new file mode 100644 (file)
index 0000000..e935821
--- /dev/null
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -0,0 +1,461 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import (
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+       "fmt"
+       "sync"
+)
+
+//......................................................................
+//
+// Public/exported bits of the ABI utilities.
+//
+
+// ABIParamResultInfo stores the results of processing a given
+// function type to compute stack layout and register assignments. For
+// each input and output parameter we capture whether the param was
+// register-assigned (and to which register(s)) or the stack offset
+// for the param if is not going to be passed in registers according
+// to the rules in the Go internal ABI specification (1.17).
+type ABIParamResultInfo struct {
+       inparams          []ABIParamAssignment // Includes receiver for method calls.  Does NOT include hidden closure pointer.
+       outparams         []ABIParamAssignment
+       offsetToSpillArea int64
+       spillAreaSize     int64
+       config            *ABIConfig // to enable String() method
+}
+
+func (a *ABIParamResultInfo) InParams() []ABIParamAssignment {
+       return a.inparams
+}
+
+func (a *ABIParamResultInfo) OutParams() []ABIParamAssignment {
+       return a.outparams
+}
+
+func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
+       return a.inparams[i]
+}
+
+func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
+       return a.outparams[i]
+}
+
+func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
+       return a.offsetToSpillArea
+}
+
+func (a *ABIParamResultInfo) SpillAreaSize() int64 {
+       return a.spillAreaSize
+}
+
+// RegIndex stores the index into the set of machine registers used by
+// the ABI on a specific architecture for parameter passing.  RegIndex
+// values 0 through N-1 (where N is the number of integer registers
+// used for param passing according to the ABI rules) describe integer
+// registers; values N through M (where M is the number of floating
+// point registers used).  Thus if the ABI says there are 5 integer
+// registers and 7 floating point registers, then RegIndex value of 4
+// indicates the 5th integer register, and a RegIndex value of 11
+// indicates the 7th floating point register.
+type RegIndex uint8
+
+// ABIParamAssignment holds information about how a specific param or
+// result will be passed: in registers (in which case 'Registers' is
+// populated) or on the stack (in which case 'Offset' is set to a
+// non-negative stack offset. The values in 'Registers' are indices (as
+// described above), not architected registers.
+type ABIParamAssignment struct {
+       Type      *types.Type
+       Registers []RegIndex
+       offset    int32
+}
+
+// Offset returns the stack offset for addressing the parameter that "a" describes.
+// This will panic if "a" describes a register-allocated parameter.
+func (a *ABIParamAssignment) Offset() int32 {
+       if len(a.Registers) > 0 {
+               panic("Register allocated parameters have no offset")
+       }
+       return a.offset
+}
+
+// SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
+// Registers will be spilled here; if a memory home is needed (for a pointer method e.g.)
+// then that will be the address.
+// This will panic if "a" describes a stack-allocated parameter.
+func (a *ABIParamAssignment) SpillOffset() int32 {
+       if len(a.Registers) == 0 {
+               panic("Stack-allocated parameters have no spill offset")
+       }
+       return a.offset
+}
+
+// RegAmounts holds a specified number of integer/float registers.
+type RegAmounts struct {
+       intRegs   int
+       floatRegs int
+}
+
+// ABIConfig captures the number of registers made available
+// by the ABI rules for parameter passing and result returning.
+type ABIConfig struct {
+       // Do we need anything more than this?
+       regAmounts       RegAmounts
+       regsForTypeCache map[*types.Type]int
+}
+
+// NewABIConfig returns a new ABI configuration for an architecture with
+// iRegsCount integer/pointer registers and fRegsCount floating point registers.
+func NewABIConfig(iRegsCount, fRegsCount int) *ABIConfig {
+       return &ABIConfig{regAmounts: RegAmounts{iRegsCount, fRegsCount}, regsForTypeCache: make(map[*types.Type]int)}
+}
+
+// NumParamRegs returns the number of parameter registers used for a given type,
+// without regard for the number available.
+func (a *ABIConfig) NumParamRegs(t *types.Type) int {
+       if n, ok := a.regsForTypeCache[t]; ok {
+               return n
+       }
+
+       if t.IsScalar() || t.IsPtrShaped() {
+               var n int
+               if t.IsComplex() {
+                       n = 2
+               } else {
+                       n = (int(t.Size()) + types.RegSize - 1) / types.RegSize
+               }
+               a.regsForTypeCache[t] = n
+               return n
+       }
+       typ := t.Kind()
+       n := 0
+       switch typ {
+       case types.TARRAY:
+               n = a.NumParamRegs(t.Elem()) * int(t.NumElem())
+       case types.TSTRUCT:
+               for _, f := range t.FieldSlice() {
+                       n += a.NumParamRegs(f.Type)
+               }
+       case types.TSLICE:
+               n = a.NumParamRegs(synthSlice)
+       case types.TSTRING:
+               n = a.NumParamRegs(synthString)
+       case types.TINTER:
+               n = a.NumParamRegs(synthIface)
+       }
+       a.regsForTypeCache[t] = n
+       return n
+}
+
+// ABIAnalyze takes a function type 't' and an ABI rules description
+// 'config' and analyzes the function to determine how its parameters
+// and results will be passed (in registers or on the stack), returning
+// an ABIParamResultInfo object that holds the results of the analysis.
+func (config *ABIConfig) ABIAnalyze(t *types.Type) ABIParamResultInfo {
+       setup()
+       s := assignState{
+               rTotal: config.regAmounts,
+       }
+       result := ABIParamResultInfo{config: config}
+
+       // Receiver
+       ft := t.FuncType()
+       if t.NumRecvs() != 0 {
+               rfsl := ft.Receiver.FieldSlice()
+               result.inparams = append(result.inparams,
+                       s.assignParamOrReturn(rfsl[0].Type, false))
+       }
+
+       // Inputs
+       ifsl := ft.Params.FieldSlice()
+       for _, f := range ifsl {
+               result.inparams = append(result.inparams,
+                       s.assignParamOrReturn(f.Type, false))
+       }
+       s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
+
+       // Outputs
+       s.rUsed = RegAmounts{}
+       ofsl := ft.Results.FieldSlice()
+       for _, f := range ofsl {
+               result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type, true))
+       }
+       // The spill area is at a register-aligned offset and its size is rounded up to a register alignment.
+       // TODO in theory could align offset only to minimum required by spilled data types.
+       result.offsetToSpillArea = alignTo(s.stackOffset, types.RegSize)
+       result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
+
+       return result
+}
+
+//......................................................................
+//
+// Non-public portions.
+
+// regString produces a human-readable version of a RegIndex.
+func (c *RegAmounts) regString(r RegIndex) string {
+       if int(r) < c.intRegs {
+               return fmt.Sprintf("I%d", int(r))
+       } else if int(r) < c.intRegs+c.floatRegs {
+               return fmt.Sprintf("F%d", int(r)-c.intRegs)
+       }
+       return fmt.Sprintf("<?>%d", r)
+}
+
+// toString method renders an ABIParamAssignment in human-readable
+// form, suitable for debugging or unit testing.
+func (ri *ABIParamAssignment) toString(config *ABIConfig) string {
+       regs := "R{"
+       offname := "spilloffset" // offset is for spill for register(s)
+       if len(ri.Registers) == 0 {
+               offname = "offset" // offset is for memory arg
+       }
+       for _, r := range ri.Registers {
+               regs += " " + config.regAmounts.regString(r)
+       }
+       return fmt.Sprintf("%s } %s: %d typ: %v", regs, offname, ri.offset, ri.Type)
+}
+
+// toString method renders an ABIParamResultInfo in human-readable
+// form, suitable for debugging or unit testing.
+func (ri *ABIParamResultInfo) String() string {
+       res := ""
+       for k, p := range ri.inparams {
+               res += fmt.Sprintf("IN %d: %s\n", k, p.toString(ri.config))
+       }
+       for k, r := range ri.outparams {
+               res += fmt.Sprintf("OUT %d: %s\n", k, r.toString(ri.config))
+       }
+       res += fmt.Sprintf("offsetToSpillArea: %d spillAreaSize: %d",
+               ri.offsetToSpillArea, ri.spillAreaSize)
+       return res
+}
+
+// assignState holds intermediate state during the register assigning process
+// for a given function signature.
+type assignState struct {
+       rTotal      RegAmounts // total reg amounts from ABI rules
+       rUsed       RegAmounts // regs used by params completely assigned so far
+       pUsed       RegAmounts // regs used by the current param (or pieces therein)
+       stackOffset int64      // current stack offset
+       spillOffset int64      // current spill offset
+}
+
+// align returns a rounded up to t's alignment
+func align(a int64, t *types.Type) int64 {
+       return alignTo(a, int(t.Align))
+}
+
+// alignTo returns a rounded up to t, where t must be 0 or a power of 2.
+func alignTo(a int64, t int) int64 {
+       if t == 0 {
+               return a
+       }
+       return types.Rnd(a, int64(t))
+}
+
+// stackSlot returns a stack offset for a param or result of the
+// specified type.
+func (state *assignState) stackSlot(t *types.Type) int64 {
+       rv := align(state.stackOffset, t)
+       state.stackOffset = rv + t.Width
+       return rv
+}
+
+// allocateRegs returns a set of register indices for a parameter or result
+// that we've just determined to be register-assignable. The number of registers
+// needed is assumed to be stored in state.pUsed.
+func (state *assignState) allocateRegs() []RegIndex {
+       regs := []RegIndex{}
+
+       // integer
+       for r := state.rUsed.intRegs; r < state.rUsed.intRegs+state.pUsed.intRegs; r++ {
+               regs = append(regs, RegIndex(r))
+       }
+       state.rUsed.intRegs += state.pUsed.intRegs
+
+       // floating
+       for r := state.rUsed.floatRegs; r < state.rUsed.floatRegs+state.pUsed.floatRegs; r++ {
+               regs = append(regs, RegIndex(r+state.rTotal.intRegs))
+       }
+       state.rUsed.floatRegs += state.pUsed.floatRegs
+
+       return regs
+}
+
+// regAllocate creates a register ABIParamAssignment object for a param
+// or result with the specified type, as a final step (this assumes
+// that all of the safety/suitability analysis is complete).
+func (state *assignState) regAllocate(t *types.Type, isReturn bool) ABIParamAssignment {
+       spillLoc := int64(-1)
+       if !isReturn {
+               // Spill for register-resident t must be aligned for storage of a t.
+               spillLoc = align(state.spillOffset, t)
+               state.spillOffset = spillLoc + t.Size()
+       }
+       return ABIParamAssignment{
+               Type:      t,
+               Registers: state.allocateRegs(),
+               offset:    int32(spillLoc),
+       }
+}
+
+// stackAllocate creates a stack memory ABIParamAssignment object for
+// a param or result with the specified type, as a final step (this
+// assumes that all of the safety/suitability analysis is complete).
+func (state *assignState) stackAllocate(t *types.Type) ABIParamAssignment {
+       return ABIParamAssignment{
+               Type:   t,
+               offset: int32(state.stackSlot(t)),
+       }
+}
+
+// intUsed returns the number of integer registers consumed
+// at a given point within an assignment stage.
+func (state *assignState) intUsed() int {
+       return state.rUsed.intRegs + state.pUsed.intRegs
+}
+
+// floatUsed returns the number of floating point registers consumed at
+// a given point within an assignment stage.
+func (state *assignState) floatUsed() int {
+       return state.rUsed.floatRegs + state.pUsed.floatRegs
+}
+
+// regassignIntegral examines a param/result of integral type 't' to
+// determines whether it can be register-assigned. Returns TRUE if we
+// can register allocate, FALSE otherwise (and updates state
+// accordingly).
+func (state *assignState) regassignIntegral(t *types.Type) bool {
+       regsNeeded := int(types.Rnd(t.Width, int64(types.PtrSize)) / int64(types.PtrSize))
+       if t.IsComplex() {
+               regsNeeded = 2
+       }
+
+       // Floating point and complex.
+       if t.IsFloat() || t.IsComplex() {
+               if regsNeeded+state.floatUsed() > state.rTotal.floatRegs {
+                       // not enough regs
+                       return false
+               }
+               state.pUsed.floatRegs += regsNeeded
+               return true
+       }
+
+       // Non-floating point
+       if regsNeeded+state.intUsed() > state.rTotal.intRegs {
+               // not enough regs
+               return false
+       }
+       state.pUsed.intRegs += regsNeeded
+       return true
+}
+
+// regassignArray processes an array type (or array component within some
+// other enclosing type) to determine if it can be register assigned.
+// Returns TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassignArray(t *types.Type) bool {
+
+       nel := t.NumElem()
+       if nel == 0 {
+               return true
+       }
+       if nel > 1 {
+               // Not an array of length 1: stack assign
+               return false
+       }
+       // Visit element
+       return state.regassign(t.Elem())
+}
+
+// regassignStruct processes a struct type (or struct component within
+// some other enclosing type) to determine if it can be register
+// assigned. Returns TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassignStruct(t *types.Type) bool {
+       for _, field := range t.FieldSlice() {
+               if !state.regassign(field.Type) {
+                       return false
+               }
+       }
+       return true
+}
+
+// synthOnce ensures that we only create the synth* fake types once.
+var synthOnce sync.Once
+
+// synthSlice, synthString, and syncIface are synthesized struct types
+// meant to capture the underlying implementations of string/slice/interface.
+var synthSlice *types.Type
+var synthString *types.Type
+var synthIface *types.Type
+
+// setup performs setup for the register assignment utilities, manufacturing
+// a small set of synthesized types that we'll need along the way.
+func setup() {
+       synthOnce.Do(func() {
+               fname := types.BuiltinPkg.Lookup
+               nxp := src.NoXPos
+               unsp := types.Types[types.TUNSAFEPTR]
+               ui := types.Types[types.TUINTPTR]
+               synthSlice = types.NewStruct(types.NoPkg, []*types.Field{
+                       types.NewField(nxp, fname("ptr"), unsp),
+                       types.NewField(nxp, fname("len"), ui),
+                       types.NewField(nxp, fname("cap"), ui),
+               })
+               synthString = types.NewStruct(types.NoPkg, []*types.Field{
+                       types.NewField(nxp, fname("data"), unsp),
+                       types.NewField(nxp, fname("len"), ui),
+               })
+               synthIface = types.NewStruct(types.NoPkg, []*types.Field{
+                       types.NewField(nxp, fname("f1"), unsp),
+                       types.NewField(nxp, fname("f2"), unsp),
+               })
+       })
+}
+
+// regassign examines a given param type (or component within some
+// composite) to determine if it can be register assigned.  Returns
+// TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassign(pt *types.Type) bool {
+       typ := pt.Kind()
+       if pt.IsScalar() || pt.IsPtrShaped() {
+               return state.regassignIntegral(pt)
+       }
+       switch typ {
+       case types.TARRAY:
+               return state.regassignArray(pt)
+       case types.TSTRUCT:
+               return state.regassignStruct(pt)
+       case types.TSLICE:
+               return state.regassignStruct(synthSlice)
+       case types.TSTRING:
+               return state.regassignStruct(synthString)
+       case types.TINTER:
+               return state.regassignStruct(synthIface)
+       default:
+               panic("not expected")
+       }
+}
+
+// assignParamOrReturn processes a given receiver, param, or result
+// of type 'pt' to determine whether it can be register assigned.
+// The result of the analysis is recorded in the result
+// ABIParamResultInfo held in 'state'.
+func (state *assignState) assignParamOrReturn(pt *types.Type, isReturn bool) ABIParamAssignment {
+       state.pUsed = RegAmounts{}
+       if pt.Width == types.BADWIDTH {
+               panic("should never happen")
+       } else if pt.Width == 0 {
+               return state.stackAllocate(pt)
+       } else if state.regassign(pt) {
+               return state.regAllocate(pt, isReturn)
+       } else {
+               return state.stackAllocate(pt)
+       }
+}

diff --git a/src/cmd/compile/internal/amd64/galign.go b/src/cmd/compile/internal/amd64/galign.go
index af58440502e00a2b5c3162f154e123cf18063c45..ce1c402902f7e94fca6a06118c24cba14ae87e45 100644 (file)
--- a/src/cmd/compile/internal/amd64/galign.go
+++ b/src/cmd/compile/internal/amd64/galign.go
@@ -5,13 +5,13 @@
 package amd64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/x86"
 )
 
 var leaptr = x86.ALEAQ
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &x86.Linkamd64
        arch.REGSP = x86.REGSP
        arch.MAXWIDTH = 1 << 50

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 0c1456f4d0dedeb5c469daa0511cbad26e23fc53..aefdb14a69b12e91afcc1ca2f2c6f525a9234645 100644 (file)
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -5,7 +5,10 @@
 package amd64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/x86"
        "cmd/internal/objabi"
@@ -19,8 +22,8 @@ var isPlan9 = objabi.GOOS == "plan9"
 const (
        dzBlocks    = 16 // number of MOV/ADD blocks
        dzBlockLen  = 4  // number of clears per block
-       dzBlockSize = 19 // size of instructions in a single block
-       dzMovSize   = 4  // size of single MOV instruction w/ offset
+       dzBlockSize = 23 // size of instructions in a single block
+       dzMovSize   = 5  // size of single MOV instruction w/ offset
        dzLeaqSize  = 4  // size of single LEAQ instruction
        dzClearStep = 16 // number of bytes cleared by each MOV instruction
 
@@ -51,7 +54,7 @@ func dzDI(b int64) int64 {
        return -dzClearStep * (dzBlockLen - tailSteps)
 }
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
        const (
                ax = 1 << iota
                x0
@@ -61,67 +64,67 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
                return p
        }
 
-       if cnt%int64(gc.Widthreg) != 0 {
+       if cnt%int64(types.RegSize) != 0 {
                // should only happen with nacl
-               if cnt%int64(gc.Widthptr) != 0 {
-                       gc.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
+               if cnt%int64(types.PtrSize) != 0 {
+                       base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
                }
                if *state&ax == 0 {
-                       p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+                       p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
                        *state |= ax
                }
-               p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
-               off += int64(gc.Widthptr)
-               cnt -= int64(gc.Widthptr)
+               p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+               off += int64(types.PtrSize)
+               cnt -= int64(types.PtrSize)
        }
 
        if cnt == 8 {
                if *state&ax == 0 {
-                       p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+                       p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
                        *state |= ax
                }
-               p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
-       } else if !isPlan9 && cnt <= int64(8*gc.Widthreg) {
+               p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+       } else if !isPlan9 && cnt <= int64(8*types.RegSize) {
                if *state&x0 == 0 {
-                       p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
+                       p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
                        *state |= x0
                }
 
                for i := int64(0); i < cnt/16; i++ {
-                       p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
+                       p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
                }
 
                if cnt%16 != 0 {
-                       p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
+                       p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
                }
-       } else if !isPlan9 && (cnt <= int64(128*gc.Widthreg)) {
+       } else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
                if *state&x0 == 0 {
-                       p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
+                       p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
                        *state |= x0
                }
-               p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
-               p.To.Sym = gc.Duffzero
+               p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
+               p.To.Sym = ir.Syms.Duffzero
 
                if cnt%16 != 0 {
-                       p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
+                       p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
                }
        } else {
                if *state&ax == 0 {
-                       p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+                       p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
                        *state |= ax
                }
 
-               p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
-               p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-               p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
-               p = pp.Appendpp(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
+               p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+               p = pp.Append(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        // This is a hardware nop (1-byte 0x90) instruction,
        // even though we describe it as an explicit XCHGL here.
        // Particularly, this does not zero the high 32 bits

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 5ff05a0edd16c6b0dab15099d13e9d89d1be7fc0..4938e4b0e351983f640704df393ba11556a20a28 100644 (file)
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -8,16 +8,18 @@ import (
        "fmt"
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/x86"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
        flive := b.FlagsLiveAtEnd
        for _, c := range b.ControlValues() {
                flive = c.Type.IsFlags() || flive
@@ -110,7 +112,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
        p := s.Prog(op)
        p.From.Type = obj.TYPE_REG
        p.To.Type = obj.TYPE_REG
@@ -164,7 +166,35 @@ func duff(size int64) (int64, int64) {
        return off, adj
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func getgFromTLS(s *ssagen.State, r int16) {
+       // See the comments in cmd/internal/obj/x86/obj6.go
+       // near CanUse1InsnTLS for a detailed explanation of these instructions.
+       if x86.CanUse1InsnTLS(base.Ctxt) {
+               // MOVQ (TLS), r
+               p := s.Prog(x86.AMOVQ)
+               p.From.Type = obj.TYPE_MEM
+               p.From.Reg = x86.REG_TLS
+               p.To.Type = obj.TYPE_REG
+               p.To.Reg = r
+       } else {
+               // MOVQ TLS, r
+               // MOVQ (r)(TLS*1), r
+               p := s.Prog(x86.AMOVQ)
+               p.From.Type = obj.TYPE_REG
+               p.From.Reg = x86.REG_TLS
+               p.To.Type = obj.TYPE_REG
+               p.To.Reg = r
+               q := s.Prog(x86.AMOVQ)
+               q.From.Type = obj.TYPE_MEM
+               q.From.Reg = r
+               q.From.Index = x86.REG_TLS
+               q.From.Scale = 1
+               q.To.Type = obj.TYPE_REG
+               q.To.Reg = r
+       }
+}
+
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpAMD64VFMADD231SD:
                p := s.Prog(v.Op.Asm())
@@ -630,12 +660,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.To.Type = obj.TYPE_REG
                        p.To.Reg = o
                }
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
        case ssa.OpAMD64LEAQ, ssa.OpAMD64LEAL, ssa.OpAMD64LEAW:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB,
@@ -671,7 +701,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Args[1].Reg()
        case ssa.OpAMD64CMPQconstload, ssa.OpAMD64CMPLconstload, ssa.OpAMD64CMPWconstload, ssa.OpAMD64CMPBconstload:
@@ -679,20 +709,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.From, v, sc.Off())
+               ssagen.AddAux2(&p.From, v, sc.Off())
                p.To.Type = obj.TYPE_CONST
                p.To.Offset = sc.Val()
        case ssa.OpAMD64CMPQloadidx8, ssa.OpAMD64CMPQloadidx1, ssa.OpAMD64CMPLloadidx4, ssa.OpAMD64CMPLloadidx1, ssa.OpAMD64CMPWloadidx2, ssa.OpAMD64CMPWloadidx1, ssa.OpAMD64CMPBloadidx1:
                p := s.Prog(v.Op.Asm())
                memIdx(&p.From, v)
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Args[2].Reg()
        case ssa.OpAMD64CMPQconstloadidx8, ssa.OpAMD64CMPQconstloadidx1, ssa.OpAMD64CMPLconstloadidx4, ssa.OpAMD64CMPLconstloadidx1, ssa.OpAMD64CMPWconstloadidx2, ssa.OpAMD64CMPWconstloadidx1, ssa.OpAMD64CMPBconstloadidx1:
                sc := v.AuxValAndOff()
                p := s.Prog(v.Op.Asm())
                memIdx(&p.From, v)
-               gc.AddAux2(&p.From, v, sc.Off())
+               ssagen.AddAux2(&p.From, v, sc.Off())
                p.To.Type = obj.TYPE_CONST
                p.To.Offset = sc.Val()
        case ssa.OpAMD64MOVLconst, ssa.OpAMD64MOVQconst:
@@ -732,14 +762,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpAMD64MOVBloadidx1, ssa.OpAMD64MOVWloadidx1, ssa.OpAMD64MOVLloadidx1, ssa.OpAMD64MOVQloadidx1, ssa.OpAMD64MOVSSloadidx1, ssa.OpAMD64MOVSDloadidx1,
                ssa.OpAMD64MOVQloadidx8, ssa.OpAMD64MOVSDloadidx8, ssa.OpAMD64MOVLloadidx8, ssa.OpAMD64MOVLloadidx4, ssa.OpAMD64MOVSSloadidx4, ssa.OpAMD64MOVWloadidx2:
                p := s.Prog(v.Op.Asm())
                memIdx(&p.From, v)
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore, ssa.OpAMD64MOVOstore,
@@ -751,7 +781,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpAMD64MOVBstoreidx1, ssa.OpAMD64MOVWstoreidx1, ssa.OpAMD64MOVLstoreidx1, ssa.OpAMD64MOVQstoreidx1, ssa.OpAMD64MOVSSstoreidx1, ssa.OpAMD64MOVSDstoreidx1,
                ssa.OpAMD64MOVQstoreidx8, ssa.OpAMD64MOVSDstoreidx8, ssa.OpAMD64MOVLstoreidx8, ssa.OpAMD64MOVSSstoreidx4, ssa.OpAMD64MOVLstoreidx4, ssa.OpAMD64MOVWstoreidx2,
                ssa.OpAMD64ADDLmodifyidx1, ssa.OpAMD64ADDLmodifyidx4, ssa.OpAMD64ADDLmodifyidx8, ssa.OpAMD64ADDQmodifyidx1, ssa.OpAMD64ADDQmodifyidx8,
@@ -763,7 +793,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[2].Reg()
                memIdx(&p.To, v)
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpAMD64ADDQconstmodify, ssa.OpAMD64ADDLconstmodify:
                sc := v.AuxValAndOff()
                off := sc.Off()
@@ -786,7 +816,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p := s.Prog(asm)
                        p.To.Type = obj.TYPE_MEM
                        p.To.Reg = v.Args[0].Reg()
-                       gc.AddAux2(&p.To, v, off)
+                       ssagen.AddAux2(&p.To, v, off)
                        break
                }
                fallthrough
@@ -801,7 +831,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = val
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, off)
+               ssagen.AddAux2(&p.To, v, off)
 
        case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst:
                p := s.Prog(v.Op.Asm())
@@ -810,7 +840,21 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = sc.Val()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
+       case ssa.OpAMD64MOVOstorezero:
+               if s.ABI != obj.ABIInternal {
+                       v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
+               }
+               if !base.Flag.ABIWrap {
+                       // zeroing X15 manually if wrappers are not used
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+               }
+               p := s.Prog(v.Op.Asm())
+               p.From.Type = obj.TYPE_REG
+               p.From.Reg = x86.REG_X15
+               p.To.Type = obj.TYPE_MEM
+               p.To.Reg = v.Args[0].Reg()
+               ssagen.AddAux(&p.To, v)
        case ssa.OpAMD64MOVQstoreconstidx1, ssa.OpAMD64MOVQstoreconstidx8, ssa.OpAMD64MOVLstoreconstidx1, ssa.OpAMD64MOVLstoreconstidx4, ssa.OpAMD64MOVWstoreconstidx1, ssa.OpAMD64MOVWstoreconstidx2, ssa.OpAMD64MOVBstoreconstidx1,
                ssa.OpAMD64ADDLconstmodifyidx1, ssa.OpAMD64ADDLconstmodifyidx4, ssa.OpAMD64ADDLconstmodifyidx8, ssa.OpAMD64ADDQconstmodifyidx1, ssa.OpAMD64ADDQconstmodifyidx8,
                ssa.OpAMD64ANDLconstmodifyidx1, ssa.OpAMD64ANDLconstmodifyidx4, ssa.OpAMD64ANDLconstmodifyidx8, ssa.OpAMD64ANDQconstmodifyidx1, ssa.OpAMD64ANDQconstmodifyidx8,
@@ -835,7 +879,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.From.Type = obj.TYPE_NONE
                }
                memIdx(&p.To, v)
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
        case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX,
                ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ,
                ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS:
@@ -865,7 +909,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[1].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
                if v.Reg() != v.Args[0].Reg() {
@@ -891,13 +935,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = r
                p.From.Index = i
 
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
                if v.Reg() != v.Args[0].Reg() {
                        v.Fatalf("input[0] and output not in same register %s", v.LongString())
                }
        case ssa.OpAMD64DUFFZERO:
+               if s.ABI != obj.ABIInternal {
+                       v.Fatalf("MOVOconst can be only used in ABIInternal functions")
+               }
+               if !base.Flag.ABIWrap {
+                       // zeroing X15 manually if wrappers are not used
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+               }
                off := duffStart(v.AuxInt)
                adj := duffAdj(v.AuxInt)
                var p *obj.Prog
@@ -911,18 +962,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                p = s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = off
-       case ssa.OpAMD64MOVOconst:
-               if v.AuxInt != 0 {
-                       v.Fatalf("MOVOconst can only do constant=0")
-               }
-               r := v.Reg()
-               opregreg(s, x86.AXORPS, r, r)
        case ssa.OpAMD64DUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                if v.AuxInt%16 != 0 {
                        v.Fatalf("bad DUFFCOPY AuxInt %v", v.AuxInt)
                }
@@ -949,7 +994,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
 
@@ -961,44 +1006,37 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpAMD64LoweredHasCPUFeature:
                p := s.Prog(x86.AMOVBQZX)
                p.From.Type = obj.TYPE_MEM
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpAMD64LoweredGetClosurePtr:
                // Closure pointer is DX.
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpAMD64LoweredGetG:
+               if base.Flag.ABIWrap {
+                       v.Fatalf("LoweredGetG should not appear in new ABI")
+               }
                r := v.Reg()
-               // See the comments in cmd/internal/obj/x86/obj6.go
-               // near CanUse1InsnTLS for a detailed explanation of these instructions.
-               if x86.CanUse1InsnTLS(gc.Ctxt) {
-                       // MOVQ (TLS), r
-                       p := s.Prog(x86.AMOVQ)
-                       p.From.Type = obj.TYPE_MEM
-                       p.From.Reg = x86.REG_TLS
-                       p.To.Type = obj.TYPE_REG
-                       p.To.Reg = r
-               } else {
-                       // MOVQ TLS, r
-                       // MOVQ (r)(TLS*1), r
-                       p := s.Prog(x86.AMOVQ)
-                       p.From.Type = obj.TYPE_REG
-                       p.From.Reg = x86.REG_TLS
-                       p.To.Type = obj.TYPE_REG
-                       p.To.Reg = r
-                       q := s.Prog(x86.AMOVQ)
-                       q.From.Type = obj.TYPE_MEM
-                       q.From.Reg = r
-                       q.From.Index = x86.REG_TLS
-                       q.From.Scale = 1
-                       q.To.Type = obj.TYPE_REG
-                       q.To.Reg = r
+               getgFromTLS(s, r)
+       case ssa.OpAMD64CALLstatic:
+               if s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+                       // zeroing X15 when entering ABIInternal from ABI0
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+                       // set G register from TLS
+                       getgFromTLS(s, x86.REG_R14)
+               }
+               s.Call(v)
+               if s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+                       // zeroing X15 when entering ABIInternal from ABI0
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+                       // set G register from TLS
+                       getgFromTLS(s, x86.REG_R14)
                }
-       case ssa.OpAMD64CALLstatic, ssa.OpAMD64CALLclosure, ssa.OpAMD64CALLinter:
+       case ssa.OpAMD64CALLclosure, ssa.OpAMD64CALLinter:
                s.Call(v)
 
        case ssa.OpAMD64LoweredGetCallerPC:
@@ -1012,12 +1050,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.OpAMD64LoweredGetCallerSP:
                // caller's SP is the address of the first arg
                mov := x86.AMOVQ
-               if gc.Widthptr == 4 {
+               if types.PtrSize == 4 {
                        mov = x86.AMOVL
                }
                p := s.Prog(mov)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize() // 0 on amd64, just to be consistent with other architectures
+               p.From.Offset = -base.Ctxt.FixedFrameSize() // 0 on amd64, just to be consistent with other architectures
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -1027,14 +1065,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
                // arg0 is in DI. Set sym to match where regalloc put arg1.
-               p.To.Sym = gc.GCWriteBarrierReg[v.Args[1].Reg()]
+               p.To.Sym = ssagen.GCWriteBarrierReg[v.Args[1].Reg()]
 
        case ssa.OpAMD64LoweredPanicBoundsA, ssa.OpAMD64LoweredPanicBoundsB, ssa.OpAMD64LoweredPanicBoundsC:
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
-               s.UseArgs(int64(2 * gc.Widthptr)) // space used in callee args area by assembly stubs
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
+               s.UseArgs(int64(2 * types.PtrSize)) // space used in callee args area by assembly stubs
 
        case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL,
                ssa.OpAMD64BSWAPQ, ssa.OpAMD64BSWAPL,
@@ -1115,7 +1153,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
 
        case ssa.OpAMD64SETNEF:
                p := s.Prog(v.Op.Asm())
@@ -1164,14 +1202,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpAMD64MOVBatomicload, ssa.OpAMD64MOVLatomicload, ssa.OpAMD64MOVQatomicload:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg0()
        case ssa.OpAMD64XCHGB, ssa.OpAMD64XCHGL, ssa.OpAMD64XCHGQ:
@@ -1184,7 +1222,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = r
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[1].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpAMD64XADDLlock, ssa.OpAMD64XADDQlock:
                r := v.Reg0()
                if r != v.Args[0].Reg() {
@@ -1196,7 +1234,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = r
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[1].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpAMD64CMPXCHGLlock, ssa.OpAMD64CMPXCHGQlock:
                if v.Args[1].Reg() != x86.REG_AX {
                        v.Fatalf("input[1] not in AX %s", v.LongString())
@@ -1207,7 +1245,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[2].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
                p = s.Prog(x86.ASETEQ)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg0()
@@ -1218,20 +1256,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpClobber:
                p := s.Prog(x86.AMOVL)
                p.From.Type = obj.TYPE_CONST
                p.From.Offset = 0xdeaddead
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = x86.REG_SP
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
                p = s.Prog(x86.AMOVL)
                p.From.Type = obj.TYPE_CONST
                p.From.Offset = 0xdeaddead
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = x86.REG_SP
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
                p.To.Offset += 4
        default:
                v.Fatalf("genValue not implemented: %s", v.LongString())
@@ -1257,22 +1295,22 @@ var blockJump = [...]struct {
        ssa.BlockAMD64NAN: {x86.AJPS, x86.AJPC},
 }
 
-var eqfJumps = [2][2]gc.IndexJump{
+var eqfJumps = [2][2]ssagen.IndexJump{
        {{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPS, Index: 1}}, // next == b.Succs[0]
        {{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPC, Index: 0}}, // next == b.Succs[1]
 }
-var nefJumps = [2][2]gc.IndexJump{
+var nefJumps = [2][2]ssagen.IndexJump{
        {{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPC, Index: 1}}, // next == b.Succs[0]
        {{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPS, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockDefer:
                // defer returns in rax:
@@ -1285,16 +1323,22 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.To.Reg = x86.REG_AX
                p = s.Prog(x86.AJNE)
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:
                s.Prog(obj.ARET)
        case ssa.BlockRetJmp:
+               if s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+                       // zeroing X15 when entering ABIInternal from ABI0
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+                       // set G register from TLS
+                       getgFromTLS(s, x86.REG_R14)
+               }
                p := s.Prog(obj.ARET)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN

diff --git a/src/cmd/compile/internal/arm/galign.go b/src/cmd/compile/internal/arm/galign.go
index 20e2f43a91c0d7f162f3e5b6ea70f6d12f24e71a..81959ae0abcb32d5045a1980cdd4f5198433da84 100644 (file)
--- a/src/cmd/compile/internal/arm/galign.go
+++ b/src/cmd/compile/internal/arm/galign.go
@@ -5,13 +5,13 @@
 package arm
 
 import (
-       "cmd/compile/internal/gc"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/arm"
        "cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &arm.Linkarm
        arch.REGSP = arm.REGSP
        arch.MAXWIDTH = (1 << 32) - 1
@@ -20,7 +20,7 @@ func Init(arch *gc.Arch) {
        arch.Ginsnop = ginsnop
        arch.Ginsnopdefer = ginsnop
 
-       arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+       arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
        arch.SSAGenValue = ssaGenValue
        arch.SSAGenBlock = ssaGenBlock
 }

diff --git a/src/cmd/compile/internal/arm/ggen.go b/src/cmd/compile/internal/arm/ggen.go
index bd8d7ff40b8f83f986143e874e6f2b6a0eec2a1b..f2c676300a93a5531c2f160fb0dba7f121068683 100644 (file)
--- a/src/cmd/compile/internal/arm/ggen.go
+++ b/src/cmd/compile/internal/arm/ggen.go
@@ -5,49 +5,51 @@
 package arm
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/arm"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
        if *r0 == 0 {
-               p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, arm.REG_R0, 0)
+               p = pp.Append(p, arm.AMOVW, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, arm.REG_R0, 0)
                *r0 = 1
        }
 
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, 4+off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, 4+off+i)
                }
-       } else if cnt <= int64(128*gc.Widthptr) {
-               p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
+       } else if cnt <= int64(128*types.PtrSize) {
+               p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
                p.Reg = arm.REGSP
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
-               p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+               p.To.Sym = ir.Syms.Duffzero
+               p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
        } else {
-               p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
+               p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
                p.Reg = arm.REGSP
-               p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, arm.REG_R2, 0)
+               p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, arm.REG_R2, 0)
                p.Reg = arm.REG_R1
-               p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4)
+               p = pp.Append(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4)
                p1 := p
                p.Scond |= arm.C_PBIT
-               p = pp.Appendpp(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0)
                p.Reg = arm.REG_R2
-               p = pp.Appendpp(p, arm.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-               gc.Patch(p, p1)
+               p = pp.Append(p, arm.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+               p.To.SetTarget(p1)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        p := pp.Prog(arm.AAND)
        p.From.Type = obj.TYPE_REG
        p.From.Reg = arm.REG_R0

diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 765a7715465ce8af6f6297ed37d6a924d060af9c..729d2dab2d809ceb0ac422ff3898cf9959d77e7d 100644 (file)
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -9,9 +9,11 @@ import (
        "math"
        "math/bits"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/arm"
@@ -91,7 +93,7 @@ func makeshift(reg int16, typ int64, s int64) shift {
 }
 
 // genshift generates a Prog for r = r0 op (r1 shifted by n)
-func genshift(s *gc.SSAGenState, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
+func genshift(s *ssagen.State, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
        p := s.Prog(as)
        p.From.Type = obj.TYPE_SHIFT
        p.From.Offset = int64(makeshift(r1, typ, n))
@@ -109,7 +111,7 @@ func makeregshift(r1 int16, typ int64, r2 int16) shift {
 }
 
 // genregshift generates a Prog for r = r0 op (r1 shifted by r2)
-func genregshift(s *gc.SSAGenState, as obj.As, r0, r1, r2, r int16, typ int64) *obj.Prog {
+func genregshift(s *ssagen.State, as obj.As, r0, r1, r2, r int16, typ int64) *obj.Prog {
        p := s.Prog(as)
        p.From.Type = obj.TYPE_SHIFT
        p.From.Offset = int64(makeregshift(r1, typ, r2))
@@ -143,7 +145,7 @@ func getBFC(v uint32) (uint32, uint32) {
        return 0xffffffff, 0
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpCopy, ssa.OpARMMOVWreg:
                if v.Type.IsMemory() {
@@ -181,7 +183,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpStoreReg:
@@ -192,7 +194,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpARMADD,
                ssa.OpARMADC,
                ssa.OpARMSUB,
@@ -543,10 +545,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        v.Fatalf("aux is of unknown type %T", v.Aux)
                case *obj.LSym:
                        wantreg = "SB"
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        wantreg = "SP"
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                case nil:
                        // No sym, just MOVW $off(SP), R
                        wantreg = "SP"
@@ -566,7 +568,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpARMMOVBstore,
@@ -579,7 +581,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpARMMOVWloadidx, ssa.OpARMMOVBUloadidx, ssa.OpARMMOVBloadidx, ssa.OpARMMOVHUloadidx, ssa.OpARMMOVHloadidx:
                // this is just shift 0 bits
                fallthrough
@@ -700,7 +702,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Udiv
+               p.To.Sym = ir.Syms.Udiv
        case ssa.OpARMLoweredWB:
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
@@ -710,39 +712,39 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(8) // space used in callee args area by assembly stubs
        case ssa.OpARMLoweredPanicExtendA, ssa.OpARMLoweredPanicExtendB, ssa.OpARMLoweredPanicExtendC:
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
                s.UseArgs(12) // space used in callee args area by assembly stubs
        case ssa.OpARMDUFFZERO:
                p := s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpARMDUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                p.To.Offset = v.AuxInt
        case ssa.OpARMLoweredNilCheck:
                // Issue a load which will fault if arg is nil.
                p := s.Prog(arm.AMOVB)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = arm.REGTMP
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpARMLoweredZero:
                // MOVW.P       Rarg2, 4(R1)
@@ -777,7 +779,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p2.Reg = arm.REG_R1
                p3 := s.Prog(arm.ABLE)
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
        case ssa.OpARMLoweredMove:
                // MOVW.P       4(R1), Rtmp
                // MOVW.P       Rtmp, 4(R2)
@@ -818,7 +820,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.Reg = arm.REG_R1
                p4 := s.Prog(arm.ABLE)
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p)
+               p4.To.SetTarget(p)
        case ssa.OpARMEqual,
                ssa.OpARMNotEqual,
                ssa.OpARMLessThan,
@@ -844,12 +846,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Reg = v.Reg()
        case ssa.OpARMLoweredGetClosurePtr:
                // Closure pointer is R7 (arm.REGCTXT).
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpARMLoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(arm.AMOVW)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -899,24 +901,24 @@ var blockJump = map[ssa.BlockKind]struct {
 }
 
 // To model a 'LEnoov' ('<=' without overflow checking) branching
-var leJumps = [2][2]gc.IndexJump{
+var leJumps = [2][2]ssagen.IndexJump{
        {{Jump: arm.ABEQ, Index: 0}, {Jump: arm.ABPL, Index: 1}}, // next == b.Succs[0]
        {{Jump: arm.ABMI, Index: 0}, {Jump: arm.ABEQ, Index: 0}}, // next == b.Succs[1]
 }
 
 // To model a 'GTnoov' ('>' without overflow checking) branching
-var gtJumps = [2][2]gc.IndexJump{
+var gtJumps = [2][2]ssagen.IndexJump{
        {{Jump: arm.ABMI, Index: 1}, {Jump: arm.ABEQ, Index: 1}}, // next == b.Succs[0]
        {{Jump: arm.ABEQ, Index: 1}, {Jump: arm.ABPL, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
 
        case ssa.BlockDefer:
@@ -929,11 +931,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.Reg = arm.REG_R0
                p = s.Prog(arm.ABNE)
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
 
        case ssa.BlockExit:

diff --git a/src/cmd/compile/internal/arm64/galign.go b/src/cmd/compile/internal/arm64/galign.go
index 40d6e17ae2296cb4961cc58b589dcb4b43961c48..d3db37e16f43bcbbb261d75078df6c8d126b4a72 100644 (file)
--- a/src/cmd/compile/internal/arm64/galign.go
+++ b/src/cmd/compile/internal/arm64/galign.go
@@ -5,12 +5,12 @@
 package arm64
 
 import (
-       "cmd/compile/internal/gc"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/arm64"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &arm64.Linkarm64
        arch.REGSP = arm64.REGSP
        arch.MAXWIDTH = 1 << 50
@@ -20,7 +20,7 @@ func Init(arch *gc.Arch) {
        arch.Ginsnop = ginsnop
        arch.Ginsnopdefer = ginsnop
 
-       arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+       arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
        arch.SSAGenValue = ssaGenValue
        arch.SSAGenBlock = ssaGenBlock
 }

diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index f3fec03854f16c8308f0efce89a33b3c665c8bd4..8364535f63bb8f49882faeb8d54ff2eb82cc6562 100644 (file)
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -5,7 +5,9 @@
 package arm64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/arm64"
        "cmd/internal/objabi"
@@ -22,52 +24,52 @@ func padframe(frame int64) int64 {
        return frame
 }
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off+i)
                }
-       } else if cnt <= int64(128*gc.Widthptr) && !darwin { // darwin ld64 cannot handle BR26 reloc with non-zero addend
-               if cnt%(2*int64(gc.Widthptr)) != 0 {
-                       p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off)
-                       off += int64(gc.Widthptr)
-                       cnt -= int64(gc.Widthptr)
+       } else if cnt <= int64(128*types.PtrSize) && !darwin { // darwin ld64 cannot handle BR26 reloc with non-zero addend
+               if cnt%(2*int64(types.PtrSize)) != 0 {
+                       p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off)
+                       off += int64(types.PtrSize)
+                       cnt -= int64(types.PtrSize)
                }
-               p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REG_R20, 0)
-               p = pp.Appendpp(p, arm64.AADD, obj.TYPE_CONST, 0, 8+off, obj.TYPE_REG, arm64.REG_R20, 0)
+               p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REG_R20, 0)
+               p = pp.Append(p, arm64.AADD, obj.TYPE_CONST, 0, 8+off, obj.TYPE_REG, arm64.REG_R20, 0)
                p.Reg = arm64.REG_R20
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
-               p.To.Offset = 4 * (64 - cnt/(2*int64(gc.Widthptr)))
+               p.To.Sym = ir.Syms.Duffzero
+               p.To.Offset = 4 * (64 - cnt/(2*int64(types.PtrSize)))
        } else {
                // Not using REGTMP, so this is async preemptible (async preemption clobbers REGTMP).
                // We are at the function entry, where no register is live, so it is okay to clobber
                // other registers
                const rtmp = arm64.REG_R20
-               p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, rtmp, 0)
-               p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REGRT1, 0)
-               p = pp.Appendpp(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT1, 0)
+               p = pp.Append(p, arm64.AMOVD, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, rtmp, 0)
+               p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REGRT1, 0)
+               p = pp.Append(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT1, 0)
                p.Reg = arm64.REGRT1
-               p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, rtmp, 0)
-               p = pp.Appendpp(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT2, 0)
+               p = pp.Append(p, arm64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, rtmp, 0)
+               p = pp.Append(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT2, 0)
                p.Reg = arm64.REGRT1
-               p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(gc.Widthptr))
+               p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(types.PtrSize))
                p.Scond = arm64.C_XPRE
                p1 := p
-               p = pp.Appendpp(p, arm64.ACMP, obj.TYPE_REG, arm64.REGRT1, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, arm64.ACMP, obj.TYPE_REG, arm64.REGRT1, 0, obj.TYPE_NONE, 0, 0)
                p.Reg = arm64.REGRT2
-               p = pp.Appendpp(p, arm64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-               gc.Patch(p, p1)
+               p = pp.Append(p, arm64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+               p.To.SetTarget(p1)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        p := pp.Prog(arm64.AHINT)
        p.From.Type = obj.TYPE_CONST
        return p

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 22b28a9308bd39270376e491a2c100a3ea2cb86c..73e74e12199b5ecdf0be97d91dc85a5c05c9b37f 100644 (file)
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -7,9 +7,11 @@ package arm64
 import (
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/arm64"
@@ -81,7 +83,7 @@ func makeshift(reg int16, typ int64, s int64) int64 {
 }
 
 // genshift generates a Prog for r = r0 op (r1 shifted by n)
-func genshift(s *gc.SSAGenState, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
+func genshift(s *ssagen.State, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
        p := s.Prog(as)
        p.From.Type = obj.TYPE_SHIFT
        p.From.Offset = makeshift(r1, typ, n)
@@ -110,7 +112,7 @@ func genIndexedOperand(v *ssa.Value) obj.Addr {
        return mop
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpCopy, ssa.OpARM64MOVDreg:
                if v.Type.IsMemory() {
@@ -148,7 +150,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpStoreReg:
@@ -159,7 +161,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpARM64ADD,
                ssa.OpARM64SUB,
                ssa.OpARM64AND,
@@ -393,10 +395,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        v.Fatalf("aux is of unknown type %T", v.Aux)
                case *obj.LSym:
                        wantreg = "SB"
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        wantreg = "SP"
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                case nil:
                        // No sym, just MOVD $off(SP), R
                        wantreg = "SP"
@@ -417,7 +419,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpARM64MOVBloadidx,
@@ -444,7 +446,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg0()
        case ssa.OpARM64MOVBstore,
@@ -461,7 +463,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpARM64MOVBstoreidx,
                ssa.OpARM64MOVHstoreidx,
                ssa.OpARM64MOVWstoreidx,
@@ -482,7 +484,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = int64(v.Args[2].Reg())
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpARM64MOVBstorezero,
                ssa.OpARM64MOVHstorezero,
                ssa.OpARM64MOVWstorezero,
@@ -492,7 +494,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = arm64.REGZERO
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpARM64MOVBstorezeroidx,
                ssa.OpARM64MOVHstorezeroidx,
                ssa.OpARM64MOVWstorezeroidx,
@@ -511,7 +513,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = int64(arm64.REGZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpARM64BFI,
                ssa.OpARM64BFXIL:
                r := v.Reg()
@@ -580,7 +582,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p2.From.Type = obj.TYPE_REG
                p2.From.Reg = arm64.REGTMP
                p2.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p2, p)
+               p2.To.SetTarget(p)
        case ssa.OpARM64LoweredAtomicExchange64Variant,
                ssa.OpARM64LoweredAtomicExchange32Variant:
                swap := arm64.ASWPALD
@@ -634,7 +636,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = arm64.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
        case ssa.OpARM64LoweredAtomicAdd64Variant,
                ssa.OpARM64LoweredAtomicAdd32Variant:
                // LDADDAL      Rarg1, (Rarg0), Rout
@@ -698,13 +700,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p4.From.Type = obj.TYPE_REG
                p4.From.Reg = arm64.REGTMP
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p)
+               p4.To.SetTarget(p)
                p5 := s.Prog(arm64.ACSET)
                p5.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
                p5.From.Reg = arm64.COND_EQ
                p5.To.Type = obj.TYPE_REG
                p5.To.Reg = out
-               gc.Patch(p2, p5)
+               p2.To.SetTarget(p5)
        case ssa.OpARM64LoweredAtomicCas64Variant,
                ssa.OpARM64LoweredAtomicCas32Variant:
                // Rarg0: ptr
@@ -792,7 +794,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = arm64.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
        case ssa.OpARM64LoweredAtomicAnd8Variant,
                ssa.OpARM64LoweredAtomicAnd32Variant:
                atomic_clear := arm64.ALDCLRALW
@@ -959,7 +961,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpARM64LoweredZero:
                // STP.P        (ZR,ZR), 16(R16)
@@ -980,12 +982,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p2.Reg = arm64.REG_R16
                p3 := s.Prog(arm64.ABLE)
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
        case ssa.OpARM64DUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                p.To.Offset = v.AuxInt
        case ssa.OpARM64LoweredMove:
                // MOVD.P       8(R16), Rtmp
@@ -1013,7 +1015,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.Reg = arm64.REG_R16
                p4 := s.Prog(arm64.ABLE)
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p)
+               p4.To.SetTarget(p)
        case ssa.OpARM64CALLstatic, ssa.OpARM64CALLclosure, ssa.OpARM64CALLinter:
                s.Call(v)
        case ssa.OpARM64LoweredWB:
@@ -1025,21 +1027,21 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(16) // space used in callee args area by assembly stubs
        case ssa.OpARM64LoweredNilCheck:
                // Issue a load which will fault if arg is nil.
                p := s.Prog(arm64.AMOVB)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = arm64.REGTMP
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpARM64Equal,
                ssa.OpARM64NotEqual,
@@ -1054,7 +1056,11 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                ssa.OpARM64LessThanF,
                ssa.OpARM64LessEqualF,
                ssa.OpARM64GreaterThanF,
-               ssa.OpARM64GreaterEqualF:
+               ssa.OpARM64GreaterEqualF,
+               ssa.OpARM64NotLessThanF,
+               ssa.OpARM64NotLessEqualF,
+               ssa.OpARM64NotGreaterThanF,
+               ssa.OpARM64NotGreaterEqualF:
                // generate boolean values using CSET
                p := s.Prog(arm64.ACSET)
                p.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
@@ -1063,12 +1069,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Reg = v.Reg()
        case ssa.OpARM64LoweredGetClosurePtr:
                // Closure pointer is R26 (arm64.REGCTXT).
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpARM64LoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(arm64.AMOVD)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -1098,10 +1104,16 @@ var condBits = map[ssa.Op]int16{
        ssa.OpARM64GreaterThanU:  arm64.COND_HI,
        ssa.OpARM64GreaterEqual:  arm64.COND_GE,
        ssa.OpARM64GreaterEqualU: arm64.COND_HS,
-       ssa.OpARM64LessThanF:     arm64.COND_MI,
-       ssa.OpARM64LessEqualF:    arm64.COND_LS,
-       ssa.OpARM64GreaterThanF:  arm64.COND_GT,
-       ssa.OpARM64GreaterEqualF: arm64.COND_GE,
+       ssa.OpARM64LessThanF:     arm64.COND_MI, // Less than
+       ssa.OpARM64LessEqualF:    arm64.COND_LS, // Less than or equal to
+       ssa.OpARM64GreaterThanF:  arm64.COND_GT, // Greater than
+       ssa.OpARM64GreaterEqualF: arm64.COND_GE, // Greater than or equal to
+
+       // The following condition codes have unordered to handle comparisons related to NaN.
+       ssa.OpARM64NotLessThanF:     arm64.COND_PL, // Greater than, equal to, or unordered
+       ssa.OpARM64NotLessEqualF:    arm64.COND_HI, // Greater than or unordered
+       ssa.OpARM64NotGreaterThanF:  arm64.COND_LE, // Less than, equal to or unordered
+       ssa.OpARM64NotGreaterEqualF: arm64.COND_LT, // Less than or unordered
 }
 
 var blockJump = map[ssa.BlockKind]struct {
@@ -1132,24 +1144,24 @@ var blockJump = map[ssa.BlockKind]struct {
 }
 
 // To model a 'LEnoov' ('<=' without overflow checking) branching
-var leJumps = [2][2]gc.IndexJump{
+var leJumps = [2][2]ssagen.IndexJump{
        {{Jump: arm64.ABEQ, Index: 0}, {Jump: arm64.ABPL, Index: 1}}, // next == b.Succs[0]
        {{Jump: arm64.ABMI, Index: 0}, {Jump: arm64.ABEQ, Index: 0}}, // next == b.Succs[1]
 }
 
 // To model a 'GTnoov' ('>' without overflow checking) branching
-var gtJumps = [2][2]gc.IndexJump{
+var gtJumps = [2][2]ssagen.IndexJump{
        {{Jump: arm64.ABMI, Index: 1}, {Jump: arm64.ABEQ, Index: 1}}, // next == b.Succs[0]
        {{Jump: arm64.ABEQ, Index: 1}, {Jump: arm64.ABPL, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
 
        case ssa.BlockDefer:
@@ -1162,11 +1174,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.Reg = arm64.REG_R0
                p = s.Prog(arm64.ABNE)
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
 
        case ssa.BlockExit:

diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/base/base.go
similarity index 55%
rename from src/cmd/compile/internal/gc/racewalk.go
rename to src/cmd/compile/internal/base/base.go
index 35526174010fa361be76e2938900cc2c5067aa80..3b9bc3a8af2d5f49068058f2d55bc720ba5ca1c8 100644 (file)
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/base/base.go
@@ -1,15 +1,43 @@
-// Copyright 2012 The Go Authors. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package base
 
 import (
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "cmd/internal/sys"
+       "os"
 )
 
+var atExitFuncs []func()
+
+func AtExit(f func()) {
+       atExitFuncs = append(atExitFuncs, f)
+}
+
+func Exit(code int) {
+       for i := len(atExitFuncs) - 1; i >= 0; i-- {
+               f := atExitFuncs[i]
+               atExitFuncs = atExitFuncs[:i]
+               f()
+       }
+       os.Exit(code)
+}
+
+// To enable tracing support (-t flag), set EnableTrace to true.
+const EnableTrace = false
+
+func Compiling(pkgs []string) bool {
+       if Ctxt.Pkgpath != "" {
+               for _, p := range pkgs {
+                       if Ctxt.Pkgpath == p {
+                               return true
+                       }
+               }
+       }
+
+       return false
+}
+
 // The racewalk pass is currently handled in three parts.
 //
 // First, for flag_race, it inserts calls to racefuncenter and
@@ -32,7 +60,7 @@ import (
 
 // Do not instrument the following packages at all,
 // at best instrumentation would cause infinite recursion.
-var omit_pkgs = []string{
+var NoInstrumentPkgs = []string{
        "runtime/internal/atomic",
        "runtime/internal/sys",
        "runtime/internal/math",
@@ -44,50 +72,4 @@ var omit_pkgs = []string{
 
 // Don't insert racefuncenterfp/racefuncexit into the following packages.
 // Memory accesses in the packages are either uninteresting or will cause false positives.
-var norace_inst_pkgs = []string{"sync", "sync/atomic"}
-
-func ispkgin(pkgs []string) bool {
-       if myimportpath != "" {
-               for _, p := range pkgs {
-                       if myimportpath == p {
-                               return true
-                       }
-               }
-       }
-
-       return false
-}
-
-func instrument(fn *Node) {
-       if fn.Func.Pragma&Norace != 0 {
-               return
-       }
-
-       if !flag_race || !ispkgin(norace_inst_pkgs) {
-               fn.Func.SetInstrumentBody(true)
-       }
-
-       if flag_race {
-               lno := lineno
-               lineno = src.NoXPos
-
-               if thearch.LinkArch.Arch.Family != sys.AMD64 {
-                       fn.Func.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
-                       fn.Func.Exit.Append(mkcall("racefuncexit", nil, nil))
-               } else {
-
-                       // nodpc is the PC of the caller as extracted by
-                       // getcallerpc. We use -widthptr(FP) for x86.
-                       // This only works for amd64. This will not
-                       // work on arm or others that might support
-                       // race in the future.
-                       nodpc := nodfp.copy()
-                       nodpc.Type = types.Types[TUINTPTR]
-                       nodpc.Xoffset = int64(-Widthptr)
-                       fn.Func.Dcl = append(fn.Func.Dcl, nodpc)
-                       fn.Func.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
-                       fn.Func.Exit.Append(mkcall("racefuncexit", nil, nil))
-               }
-               lineno = lno
-       }
-}
+var NoRacePkgs = []string{"sync", "sync/atomic"}

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
new file mode 100644 (file)
index 0000000..164941b
--- /dev/null
+++ b/src/cmd/compile/internal/base/debug.go
@@ -0,0 +1,194 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Debug arguments, set by -d flag.
+
+package base
+
+import (
+       "fmt"
+       "log"
+       "os"
+       "reflect"
+       "strconv"
+       "strings"
+
+       "cmd/internal/objabi"
+)
+
+// Debug holds the parsed debugging configuration values.
+var Debug = DebugFlags{
+       Fieldtrack: &objabi.Fieldtrack_enabled,
+}
+
+// DebugFlags defines the debugging configuration values (see var Debug).
+// Each struct field is a different value, named for the lower-case of the field name.
+// Each field must be an int or string and must have a `help` struct tag.
+//
+// The -d option takes a comma-separated list of settings.
+// Each setting is name=value; for ints, name is short for name=1.
+type DebugFlags struct {
+       Append        int    `help:"print information about append compilation"`
+       Checkptr      int    `help:"instrument unsafe pointer conversions"`
+       Closure       int    `help:"print information about closure compilation"`
+       DclStack      int    `help:"run internal dclstack check"`
+       Defer         int    `help:"print information about defer compilation"`
+       DisableNil    int    `help:"disable nil checks"`
+       DumpPtrs      int    `help:"show Node pointers values in dump output"`
+       DwarfInl      int    `help:"print information about DWARF inlined function creation"`
+       Export        int    `help:"print export data"`
+       Fieldtrack    *int   `help:"enable field tracking"`
+       GCProg        int    `help:"print dump of GC programs"`
+       Libfuzzer     int    `help:"enable coverage instrumentation for libfuzzer"`
+       LocationLists int    `help:"print information about DWARF location list creation"`
+       Nil           int    `help:"print information about nil checks"`
+       PCTab         string `help:"print named pc-value table"`
+       Panic         int    `help:"show all compiler panics"`
+       Slice         int    `help:"print information about slice compilation"`
+       SoftFloat     int    `help:"force compiler to emit soft-float code"`
+       TypeAssert    int    `help:"print information about type assertion inlining"`
+       TypecheckInl  int    `help:"eager typechecking of inline function bodies"`
+       WB            int    `help:"print information about write barriers"`
+       ABIWrap       int    `help:"print information about ABI wrapper generation"`
+
+       any bool // set when any of the values have been set
+}
+
+// Any reports whether any of the debug flags have been set.
+func (d *DebugFlags) Any() bool { return d.any }
+
+type debugField struct {
+       name string
+       help string
+       val  interface{} // *int or *string
+}
+
+var debugTab []debugField
+
+func init() {
+       v := reflect.ValueOf(&Debug).Elem()
+       t := v.Type()
+       for i := 0; i < t.NumField(); i++ {
+               f := t.Field(i)
+               if f.Name == "any" {
+                       continue
+               }
+               name := strings.ToLower(f.Name)
+               help := f.Tag.Get("help")
+               if help == "" {
+                       panic(fmt.Sprintf("base.Debug.%s is missing help text", f.Name))
+               }
+               ptr := v.Field(i).Addr().Interface()
+               switch ptr.(type) {
+               default:
+                       panic(fmt.Sprintf("base.Debug.%s has invalid type %v (must be int or string)", f.Name, f.Type))
+               case *int, *string:
+                       // ok
+               case **int:
+                       ptr = *ptr.(**int) // record the *int itself
+               }
+               debugTab = append(debugTab, debugField{name, help, ptr})
+       }
+}
+
+// DebugSSA is called to set a -d ssa/... option.
+// If nil, those options are reported as invalid options.
+// If DebugSSA returns a non-empty string, that text is reported as a compiler error.
+var DebugSSA func(phase, flag string, val int, valString string) string
+
+// parseDebug parses the -d debug string argument.
+func parseDebug(debugstr string) {
+       // parse -d argument
+       if debugstr == "" {
+               return
+       }
+       Debug.any = true
+Split:
+       for _, name := range strings.Split(debugstr, ",") {
+               if name == "" {
+                       continue
+               }
+               // display help about the -d option itself and quit
+               if name == "help" {
+                       fmt.Print(debugHelpHeader)
+                       maxLen := len("ssa/help")
+                       for _, t := range debugTab {
+                               if len(t.name) > maxLen {
+                                       maxLen = len(t.name)
+                               }
+                       }
+                       for _, t := range debugTab {
+                               fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
+                       }
+                       // ssa options have their own help
+                       fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
+                       fmt.Print(debugHelpFooter)
+                       os.Exit(0)
+               }
+               val, valstring, haveInt := 1, "", true
+               if i := strings.IndexAny(name, "=:"); i >= 0 {
+                       var err error
+                       name, valstring = name[:i], name[i+1:]
+                       val, err = strconv.Atoi(valstring)
+                       if err != nil {
+                               val, haveInt = 1, false
+                       }
+               }
+               for _, t := range debugTab {
+                       if t.name != name {
+                               continue
+                       }
+                       switch vp := t.val.(type) {
+                       case nil:
+                               // Ignore
+                       case *string:
+                               *vp = valstring
+                       case *int:
+                               if !haveInt {
+                                       log.Fatalf("invalid debug value %v", name)
+                               }
+                               *vp = val
+                       default:
+                               panic("bad debugtab type")
+                       }
+                       continue Split
+               }
+               // special case for ssa for now
+               if DebugSSA != nil && strings.HasPrefix(name, "ssa/") {
+                       // expect form ssa/phase/flag
+                       // e.g. -d=ssa/generic_cse/time
+                       // _ in phase name also matches space
+                       phase := name[4:]
+                       flag := "debug" // default flag is debug
+                       if i := strings.Index(phase, "/"); i >= 0 {
+                               flag = phase[i+1:]
+                               phase = phase[:i]
+                       }
+                       err := DebugSSA(phase, flag, val, valstring)
+                       if err != "" {
+                               log.Fatalf(err)
+                       }
+                       continue Split
+               }
+               log.Fatalf("unknown debug key -d %s\n", name)
+       }
+}
+
+const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>]
+
+<key> is one of:
+
+`
+
+const debugHelpFooter = `
+<value> is key-specific.
+
+Key "checkptr" supports values:
+       "0": instrumentation disabled
+       "1": conversions involving unsafe.Pointer are instrumented
+       "2": conversions to unsafe.Pointer force heap allocation
+
+Key "pctab" supports values:
+       "pctospadj", "pctofile", "pctoline", "pctoinline", "pctopcdata"
+`

diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
new file mode 100644 (file)
index 0000000..c38bbe6
--- /dev/null
+++ b/src/cmd/compile/internal/base/flag.go
@@ -0,0 +1,459 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package base
+
+import (
+       "encoding/json"
+       "flag"
+       "fmt"
+       "io/ioutil"
+       "log"
+       "os"
+       "reflect"
+       "runtime"
+       "strings"
+
+       "cmd/internal/objabi"
+       "cmd/internal/sys"
+)
+
+func usage() {
+       fmt.Fprintf(os.Stderr, "usage: compile [options] file.go...\n")
+       objabi.Flagprint(os.Stderr)
+       Exit(2)
+}
+
+// Flag holds the parsed command-line flags.
+// See ParseFlag for non-zero defaults.
+var Flag CmdFlags
+
+// A CountFlag is a counting integer flag.
+// It accepts -name=value to set the value directly,
+// but it also accepts -name with no =value to increment the count.
+type CountFlag int
+
+// CmdFlags defines the command-line flags (see var Flag).
+// Each struct field is a different flag, by default named for the lower-case of the field name.
+// If the flag name is a single letter, the default flag name is left upper-case.
+// If the flag name is "Lower" followed by a single letter, the default flag name is the lower-case of the last letter.
+//
+// If this default flag name can't be made right, the `flag` struct tag can be used to replace it,
+// but this should be done only in exceptional circumstances: it helps everyone if the flag name
+// is obvious from the field name when the flag is used elsewhere in the compiler sources.
+// The `flag:"-"` struct tag makes a field invisible to the flag logic and should also be used sparingly.
+//
+// Each field must have a `help` struct tag giving the flag help message.
+//
+// The allowed field types are bool, int, string, pointers to those (for values stored elsewhere),
+// CountFlag (for a counting flag), and func(string) (for a flag that uses special code for parsing).
+type CmdFlags struct {
+       // Single letters
+       B CountFlag    "help:\"disable bounds checking\""
+       C CountFlag    "help:\"disable printing of columns in error messages\""
+       D string       "help:\"set relative `path` for local imports\""
+       E CountFlag    "help:\"debug symbol export\""
+       I func(string) "help:\"add `directory` to import search path\""
+       K CountFlag    "help:\"debug missing line numbers\""
+       L CountFlag    "help:\"show full file names in error messages\""
+       N CountFlag    "help:\"disable optimizations\""
+       S CountFlag    "help:\"print assembly listing\""
+       // V is added by objabi.AddVersionFlag
+       W CountFlag "help:\"debug parse tree after type checking\""
+
+       LowerC int          "help:\"concurrency during compilation (1 means no concurrency)\""
+       LowerD func(string) "help:\"enable debugging settings; try -d help\""
+       LowerE CountFlag    "help:\"no limit on number of errors reported\""
+       LowerH CountFlag    "help:\"halt on error\""
+       LowerJ CountFlag    "help:\"debug runtime-initialized variables\""
+       LowerL CountFlag    "help:\"disable inlining\""
+       LowerM CountFlag    "help:\"print optimization decisions\""
+       LowerO string       "help:\"write output to `file`\""
+       LowerP *string      "help:\"set expected package import `path`\"" // &Ctxt.Pkgpath, set below
+       LowerR CountFlag    "help:\"debug generated wrappers\""
+       LowerT bool         "help:\"enable tracing for debugging the compiler\""
+       LowerW CountFlag    "help:\"debug type checking\""
+       LowerV *bool        "help:\"increase debug verbosity\""
+
+       // Special characters
+       Percent          int  "flag:\"%\" help:\"debug non-static initializers\""
+       CompilingRuntime bool "flag:\"+\" help:\"compiling runtime\""
+
+       // Longer names
+       ABIWrap            bool         "help:\"enable generation of ABI wrappers\""
+       ABIWrapLimit       int          "help:\"emit at most N ABI wrappers (for debugging)\""
+       AsmHdr             string       "help:\"write assembly header to `file`\""
+       Bench              string       "help:\"append benchmark times to `file`\""
+       BlockProfile       string       "help:\"write block profile to `file`\""
+       BuildID            string       "help:\"record `id` as the build id in the export metadata\""
+       CPUProfile         string       "help:\"write cpu profile to `file`\""
+       Complete           bool         "help:\"compiling complete package (no C or assembly)\""
+       Dwarf              bool         "help:\"generate DWARF symbols\""
+       DwarfBASEntries    *bool        "help:\"use base address selection entries in DWARF\""                        // &Ctxt.UseBASEntries, set below
+       DwarfLocationLists *bool        "help:\"add location lists to DWARF in optimized mode\""                      // &Ctxt.Flag_locationlists, set below
+       Dynlink            *bool        "help:\"support references to Go symbols defined in other shared libraries\"" // &Ctxt.Flag_dynlink, set below
+       EmbedCfg           func(string) "help:\"read go:embed configuration from `file`\""
+       GenDwarfInl        int          "help:\"generate DWARF inline info records\"" // 0=disabled, 1=funcs, 2=funcs+formals/locals
+       GoVersion          string       "help:\"required version of the runtime\""
+       ImportCfg          func(string) "help:\"read import configuration from `file`\""
+       ImportMap          func(string) "help:\"add `definition` of the form source=actual to import map\""
+       InstallSuffix      string       "help:\"set pkg directory `suffix`\""
+       JSON               string       "help:\"version,file for JSON compiler/optimizer detail output\""
+       Lang               string       "help:\"Go language version source code expects\""
+       LinkObj            string       "help:\"write linker-specific object to `file`\""
+       LinkShared         *bool        "help:\"generate code that will be linked against Go shared libraries\"" // &Ctxt.Flag_linkshared, set below
+       Live               CountFlag    "help:\"debug liveness analysis\""
+       MSan               bool         "help:\"build code compatible with C/C++ memory sanitizer\""
+       MemProfile         string       "help:\"write memory profile to `file`\""
+       MemProfileRate     int64        "help:\"set runtime.MemProfileRate to `rate`\""
+       MutexProfile       string       "help:\"write mutex profile to `file`\""
+       NoLocalImports     bool         "help:\"reject local (relative) imports\""
+       Pack               bool         "help:\"write to file.a instead of file.o\""
+       Race               bool         "help:\"enable race detector\""
+       Shared             *bool        "help:\"generate code that can be linked into a shared library\"" // &Ctxt.Flag_shared, set below
+       SmallFrames        bool         "help:\"reduce the size limit for stack allocated objects\""      // small stacks, to diagnose GC latency; see golang.org/issue/27732
+       Spectre            string       "help:\"enable spectre mitigations in `list` (all, index, ret)\""
+       Std                bool         "help:\"compiling standard library\""
+       SymABIs            string       "help:\"read symbol ABIs from `file`\""
+       TraceProfile       string       "help:\"write an execution trace to `file`\""
+       TrimPath           string       "help:\"remove `prefix` from recorded source file paths\""
+       WB                 bool         "help:\"enable write barrier\"" // TODO: remove
+
+       // Configuration derived from flags; not a flag itself.
+       Cfg struct {
+               Embed struct { // set by -embedcfg
+                       Patterns map[string][]string
+                       Files    map[string]string
+               }
+               ImportDirs   []string          // appended to by -I
+               ImportMap    map[string]string // set by -importmap OR -importcfg
+               PackageFile  map[string]string // set by -importcfg; nil means not in use
+               SpectreIndex bool              // set by -spectre=index or -spectre=all
+               // Whether we are adding any sort of code instrumentation, such as
+               // when the race detector is enabled.
+               Instrumenting bool
+       }
+}
+
+// ParseFlags parses the command-line flags into Flag.
+func ParseFlags() {
+       Flag.I = addImportDir
+
+       Flag.LowerC = 1
+       Flag.LowerD = parseDebug
+       Flag.LowerP = &Ctxt.Pkgpath
+       Flag.LowerV = &Ctxt.Debugvlog
+
+       Flag.ABIWrap = objabi.Regabi_enabled != 0
+       Flag.Dwarf = objabi.GOARCH != "wasm"
+       Flag.DwarfBASEntries = &Ctxt.UseBASEntries
+       Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
+       *Flag.DwarfLocationLists = true
+       Flag.Dynlink = &Ctxt.Flag_dynlink
+       Flag.EmbedCfg = readEmbedCfg
+       Flag.GenDwarfInl = 2
+       Flag.ImportCfg = readImportCfg
+       Flag.ImportMap = addImportMap
+       Flag.LinkShared = &Ctxt.Flag_linkshared
+       Flag.Shared = &Ctxt.Flag_shared
+       Flag.WB = true
+
+       Flag.Cfg.ImportMap = make(map[string]string)
+
+       objabi.AddVersionFlag() // -V
+       registerFlags()
+       objabi.Flagparse(usage)
+
+       if Flag.MSan && !sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
+               log.Fatalf("%s/%s does not support -msan", objabi.GOOS, objabi.GOARCH)
+       }
+       if Flag.Race && !sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
+               log.Fatalf("%s/%s does not support -race", objabi.GOOS, objabi.GOARCH)
+       }
+       if (*Flag.Shared || *Flag.Dynlink || *Flag.LinkShared) && !Ctxt.Arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) {
+               log.Fatalf("%s/%s does not support -shared", objabi.GOOS, objabi.GOARCH)
+       }
+       parseSpectre(Flag.Spectre) // left as string for RecordFlags
+
+       Ctxt.Flag_shared = Ctxt.Flag_dynlink || Ctxt.Flag_shared
+       Ctxt.Flag_optimize = Flag.N == 0
+       Ctxt.Debugasm = int(Flag.S)
+
+       if flag.NArg() < 1 {
+               usage()
+       }
+
+       if Flag.GoVersion != "" && Flag.GoVersion != runtime.Version() {
+               fmt.Printf("compile: version %q does not match go tool version %q\n", runtime.Version(), Flag.GoVersion)
+               Exit(2)
+       }
+
+       if Flag.LowerO == "" {
+               p := flag.Arg(0)
+               if i := strings.LastIndex(p, "/"); i >= 0 {
+                       p = p[i+1:]
+               }
+               if runtime.GOOS == "windows" {
+                       if i := strings.LastIndex(p, `\`); i >= 0 {
+                               p = p[i+1:]
+                       }
+               }
+               if i := strings.LastIndex(p, "."); i >= 0 {
+                       p = p[:i]
+               }
+               suffix := ".o"
+               if Flag.Pack {
+                       suffix = ".a"
+               }
+               Flag.LowerO = p + suffix
+       }
+
+       if Flag.Race && Flag.MSan {
+               log.Fatal("cannot use both -race and -msan")
+       }
+       if Flag.Race || Flag.MSan {
+               // -race and -msan imply -d=checkptr for now.
+               Debug.Checkptr = 1
+       }
+
+       if Flag.CompilingRuntime && Flag.N != 0 {
+               log.Fatal("cannot disable optimizations while compiling runtime")
+       }
+       if Flag.LowerC < 1 {
+               log.Fatalf("-c must be at least 1, got %d", Flag.LowerC)
+       }
+       if Flag.LowerC > 1 && !concurrentBackendAllowed() {
+               log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
+       }
+
+       if Flag.CompilingRuntime {
+               // Runtime can't use -d=checkptr, at least not yet.
+               Debug.Checkptr = 0
+
+               // Fuzzing the runtime isn't interesting either.
+               Debug.Libfuzzer = 0
+       }
+
+       // set via a -d flag
+       Ctxt.Debugpcln = Debug.PCTab
+}
+
+// registerFlags adds flag registrations for all the fields in Flag.
+// See the comment on type CmdFlags for the rules.
+func registerFlags() {
+       var (
+               boolType      = reflect.TypeOf(bool(false))
+               intType       = reflect.TypeOf(int(0))
+               stringType    = reflect.TypeOf(string(""))
+               ptrBoolType   = reflect.TypeOf(new(bool))
+               ptrIntType    = reflect.TypeOf(new(int))
+               ptrStringType = reflect.TypeOf(new(string))
+               countType     = reflect.TypeOf(CountFlag(0))
+               funcType      = reflect.TypeOf((func(string))(nil))
+       )
+
+       v := reflect.ValueOf(&Flag).Elem()
+       t := v.Type()
+       for i := 0; i < t.NumField(); i++ {
+               f := t.Field(i)
+               if f.Name == "Cfg" {
+                       continue
+               }
+
+               var name string
+               if len(f.Name) == 1 {
+                       name = f.Name
+               } else if len(f.Name) == 6 && f.Name[:5] == "Lower" && 'A' <= f.Name[5] && f.Name[5] <= 'Z' {
+                       name = string(rune(f.Name[5] + 'a' - 'A'))
+               } else {
+                       name = strings.ToLower(f.Name)
+               }
+               if tag := f.Tag.Get("flag"); tag != "" {
+                       name = tag
+               }
+
+               help := f.Tag.Get("help")
+               if help == "" {
+                       panic(fmt.Sprintf("base.Flag.%s is missing help text", f.Name))
+               }
+
+               if k := f.Type.Kind(); (k == reflect.Ptr || k == reflect.Func) && v.Field(i).IsNil() {
+                       panic(fmt.Sprintf("base.Flag.%s is uninitialized %v", f.Name, f.Type))
+               }
+
+               switch f.Type {
+               case boolType:
+                       p := v.Field(i).Addr().Interface().(*bool)
+                       flag.BoolVar(p, name, *p, help)
+               case intType:
+                       p := v.Field(i).Addr().Interface().(*int)
+                       flag.IntVar(p, name, *p, help)
+               case stringType:
+                       p := v.Field(i).Addr().Interface().(*string)
+                       flag.StringVar(p, name, *p, help)
+               case ptrBoolType:
+                       p := v.Field(i).Interface().(*bool)
+                       flag.BoolVar(p, name, *p, help)
+               case ptrIntType:
+                       p := v.Field(i).Interface().(*int)
+                       flag.IntVar(p, name, *p, help)
+               case ptrStringType:
+                       p := v.Field(i).Interface().(*string)
+                       flag.StringVar(p, name, *p, help)
+               case countType:
+                       p := (*int)(v.Field(i).Addr().Interface().(*CountFlag))
+                       objabi.Flagcount(name, help, p)
+               case funcType:
+                       f := v.Field(i).Interface().(func(string))
+                       objabi.Flagfn1(name, help, f)
+               }
+       }
+}
+
+// concurrentFlagOk reports whether the current compiler flags
+// are compatible with concurrent compilation.
+func concurrentFlagOk() bool {
+       // TODO(rsc): Many of these are fine. Remove them.
+       return Flag.Percent == 0 &&
+               Flag.E == 0 &&
+               Flag.K == 0 &&
+               Flag.L == 0 &&
+               Flag.LowerH == 0 &&
+               Flag.LowerJ == 0 &&
+               Flag.LowerM == 0 &&
+               Flag.LowerR == 0
+}
+
+func concurrentBackendAllowed() bool {
+       if !concurrentFlagOk() {
+               return false
+       }
+
+       // Debug.S by itself is ok, because all printing occurs
+       // while writing the object file, and that is non-concurrent.
+       // Adding Debug_vlog, however, causes Debug.S to also print
+       // while flushing the plist, which happens concurrently.
+       if Ctxt.Debugvlog || Debug.Any() || Flag.Live > 0 {
+               return false
+       }
+       // TODO: Test and delete this condition.
+       if objabi.Fieldtrack_enabled != 0 {
+               return false
+       }
+       // TODO: fix races and enable the following flags
+       if Ctxt.Flag_shared || Ctxt.Flag_dynlink || Flag.Race {
+               return false
+       }
+       return true
+}
+
+func addImportDir(dir string) {
+       if dir != "" {
+               Flag.Cfg.ImportDirs = append(Flag.Cfg.ImportDirs, dir)
+       }
+}
+
+func addImportMap(s string) {
+       if Flag.Cfg.ImportMap == nil {
+               Flag.Cfg.ImportMap = make(map[string]string)
+       }
+       if strings.Count(s, "=") != 1 {
+               log.Fatal("-importmap argument must be of the form source=actual")
+       }
+       i := strings.Index(s, "=")
+       source, actual := s[:i], s[i+1:]
+       if source == "" || actual == "" {
+               log.Fatal("-importmap argument must be of the form source=actual; source and actual must be non-empty")
+       }
+       Flag.Cfg.ImportMap[source] = actual
+}
+
+func readImportCfg(file string) {
+       if Flag.Cfg.ImportMap == nil {
+               Flag.Cfg.ImportMap = make(map[string]string)
+       }
+       Flag.Cfg.PackageFile = map[string]string{}
+       data, err := ioutil.ReadFile(file)
+       if err != nil {
+               log.Fatalf("-importcfg: %v", err)
+       }
+
+       for lineNum, line := range strings.Split(string(data), "\n") {
+               lineNum++ // 1-based
+               line = strings.TrimSpace(line)
+               if line == "" || strings.HasPrefix(line, "#") {
+                       continue
+               }
+
+               var verb, args string
+               if i := strings.Index(line, " "); i < 0 {
+                       verb = line
+               } else {
+                       verb, args = line[:i], strings.TrimSpace(line[i+1:])
+               }
+               var before, after string
+               if i := strings.Index(args, "="); i >= 0 {
+                       before, after = args[:i], args[i+1:]
+               }
+               switch verb {
+               default:
+                       log.Fatalf("%s:%d: unknown directive %q", file, lineNum, verb)
+               case "importmap":
+                       if before == "" || after == "" {
+                               log.Fatalf(`%s:%d: invalid importmap: syntax is "importmap old=new"`, file, lineNum)
+                       }
+                       Flag.Cfg.ImportMap[before] = after
+               case "packagefile":
+                       if before == "" || after == "" {
+                               log.Fatalf(`%s:%d: invalid packagefile: syntax is "packagefile path=filename"`, file, lineNum)
+                       }
+                       Flag.Cfg.PackageFile[before] = after
+               }
+       }
+}
+
+func readEmbedCfg(file string) {
+       data, err := ioutil.ReadFile(file)
+       if err != nil {
+               log.Fatalf("-embedcfg: %v", err)
+       }
+       if err := json.Unmarshal(data, &Flag.Cfg.Embed); err != nil {
+               log.Fatalf("%s: %v", file, err)
+       }
+       if Flag.Cfg.Embed.Patterns == nil {
+               log.Fatalf("%s: invalid embedcfg: missing Patterns", file)
+       }
+       if Flag.Cfg.Embed.Files == nil {
+               log.Fatalf("%s: invalid embedcfg: missing Files", file)
+       }
+}
+
+// parseSpectre parses the spectre configuration from the string s.
+func parseSpectre(s string) {
+       for _, f := range strings.Split(s, ",") {
+               f = strings.TrimSpace(f)
+               switch f {
+               default:
+                       log.Fatalf("unknown setting -spectre=%s", f)
+               case "":
+                       // nothing
+               case "all":
+                       Flag.Cfg.SpectreIndex = true
+                       Ctxt.Retpoline = true
+               case "index":
+                       Flag.Cfg.SpectreIndex = true
+               case "ret":
+                       Ctxt.Retpoline = true
+               }
+       }
+
+       if Flag.Cfg.SpectreIndex {
+               switch objabi.GOARCH {
+               case "amd64":
+                       // ok
+               default:
+                       log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/base/link.go b/src/cmd/compile/internal/base/link.go
new file mode 100644 (file)
index 0000000..49fe435
--- /dev/null
+++ b/src/cmd/compile/internal/base/link.go
@@ -0,0 +1,36 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package base
+
+import (
+       "cmd/internal/obj"
+)
+
+var Ctxt *obj.Link
+
+// TODO(mdempsky): These should probably be obj.Link methods.
+
+// PkgLinksym returns the linker symbol for name within the given
+// package prefix. For user packages, prefix should be the package
+// path encoded with objabi.PathToPrefix.
+func PkgLinksym(prefix, name string, abi obj.ABI) *obj.LSym {
+       if name == "_" {
+               // TODO(mdempsky): Cleanup callers and Fatalf instead.
+               return linksym(prefix, "_", abi)
+       }
+       return linksym(prefix, prefix+"."+name, abi)
+}
+
+// Linkname returns the linker symbol for the given name as it might
+// appear within a //go:linkname directive.
+func Linkname(name string, abi obj.ABI) *obj.LSym {
+       return linksym("_", name, abi)
+}
+
+// linksym is an internal helper function for implementing the above
+// exported APIs.
+func linksym(pkg, name string, abi obj.ABI) *obj.LSym {
+       return Ctxt.LookupABIInit(name, abi, func(r *obj.LSym) { r.Pkg = pkg })
+}

diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go
new file mode 100644 (file)
index 0000000..668c600
--- /dev/null
+++ b/src/cmd/compile/internal/base/print.go
@@ -0,0 +1,264 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package base
+
+import (
+       "fmt"
+       "os"
+       "runtime/debug"
+       "sort"
+       "strings"
+
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+// An errorMsg is a queued error message, waiting to be printed.
+type errorMsg struct {
+       pos src.XPos
+       msg string
+}
+
+// Pos is the current source position being processed,
+// printed by Errorf, ErrorfLang, Fatalf, and Warnf.
+var Pos src.XPos
+
+var (
+       errorMsgs       []errorMsg
+       numErrors       int // number of entries in errorMsgs that are errors (as opposed to warnings)
+       numSyntaxErrors int
+)
+
+// Errors returns the number of errors reported.
+func Errors() int {
+       return numErrors
+}
+
+// SyntaxErrors returns the number of syntax errors reported
+func SyntaxErrors() int {
+       return numSyntaxErrors
+}
+
+// addErrorMsg adds a new errorMsg (which may be a warning) to errorMsgs.
+func addErrorMsg(pos src.XPos, format string, args ...interface{}) {
+       msg := fmt.Sprintf(format, args...)
+       // Only add the position if know the position.
+       // See issue golang.org/issue/11361.
+       if pos.IsKnown() {
+               msg = fmt.Sprintf("%v: %s", FmtPos(pos), msg)
+       }
+       errorMsgs = append(errorMsgs, errorMsg{
+               pos: pos,
+               msg: msg + "\n",
+       })
+}
+
+// FmtPos formats pos as a file:line string.
+func FmtPos(pos src.XPos) string {
+       if Ctxt == nil {
+               return "???"
+       }
+       return Ctxt.OutermostPos(pos).Format(Flag.C == 0, Flag.L == 1)
+}
+
+// byPos sorts errors by source position.
+type byPos []errorMsg
+
+func (x byPos) Len() int           { return len(x) }
+func (x byPos) Less(i, j int) bool { return x[i].pos.Before(x[j].pos) }
+func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+
+// FlushErrors sorts errors seen so far by line number, prints them to stdout,
+// and empties the errors array.
+func FlushErrors() {
+       if Ctxt != nil && Ctxt.Bso != nil {
+               Ctxt.Bso.Flush()
+       }
+       if len(errorMsgs) == 0 {
+               return
+       }
+       sort.Stable(byPos(errorMsgs))
+       for i, err := range errorMsgs {
+               if i == 0 || err.msg != errorMsgs[i-1].msg {
+                       fmt.Printf("%s", err.msg)
+               }
+       }
+       errorMsgs = errorMsgs[:0]
+}
+
+// lasterror keeps track of the most recently issued error,
+// to avoid printing multiple error messages on the same line.
+var lasterror struct {
+       syntax src.XPos // source position of last syntax error
+       other  src.XPos // source position of last non-syntax error
+       msg    string   // error message of last non-syntax error
+}
+
+// sameline reports whether two positions a, b are on the same line.
+func sameline(a, b src.XPos) bool {
+       p := Ctxt.PosTable.Pos(a)
+       q := Ctxt.PosTable.Pos(b)
+       return p.Base() == q.Base() && p.Line() == q.Line()
+}
+
+// Errorf reports a formatted error at the current line.
+func Errorf(format string, args ...interface{}) {
+       ErrorfAt(Pos, format, args...)
+}
+
+// ErrorfAt reports a formatted error message at pos.
+func ErrorfAt(pos src.XPos, format string, args ...interface{}) {
+       msg := fmt.Sprintf(format, args...)
+
+       if strings.HasPrefix(msg, "syntax error") {
+               numSyntaxErrors++
+               // only one syntax error per line, no matter what error
+               if sameline(lasterror.syntax, pos) {
+                       return
+               }
+               lasterror.syntax = pos
+       } else {
+               // only one of multiple equal non-syntax errors per line
+               // (FlushErrors shows only one of them, so we filter them
+               // here as best as we can (they may not appear in order)
+               // so that we don't count them here and exit early, and
+               // then have nothing to show for.)
+               if sameline(lasterror.other, pos) && lasterror.msg == msg {
+                       return
+               }
+               lasterror.other = pos
+               lasterror.msg = msg
+       }
+
+       addErrorMsg(pos, "%s", msg)
+       numErrors++
+
+       hcrash()
+       if numErrors >= 10 && Flag.LowerE == 0 {
+               FlushErrors()
+               fmt.Printf("%v: too many errors\n", FmtPos(pos))
+               ErrorExit()
+       }
+}
+
+// ErrorfVers reports that a language feature (format, args) requires a later version of Go.
+func ErrorfVers(lang string, format string, args ...interface{}) {
+       Errorf("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, Flag.Lang)
+}
+
+// UpdateErrorDot is a clumsy hack that rewrites the last error,
+// if it was "LINE: undefined: NAME", to be "LINE: undefined: NAME in EXPR".
+// It is used to give better error messages for dot (selector) expressions.
+func UpdateErrorDot(line string, name, expr string) {
+       if len(errorMsgs) == 0 {
+               return
+       }
+       e := &errorMsgs[len(errorMsgs)-1]
+       if strings.HasPrefix(e.msg, line) && e.msg == fmt.Sprintf("%v: undefined: %v\n", line, name) {
+               e.msg = fmt.Sprintf("%v: undefined: %v in %v\n", line, name, expr)
+       }
+}
+
+// Warnf reports a formatted warning at the current line.
+// In general the Go compiler does NOT generate warnings,
+// so this should be used only when the user has opted in
+// to additional output by setting a particular flag.
+func Warn(format string, args ...interface{}) {
+       WarnfAt(Pos, format, args...)
+}
+
+// WarnfAt reports a formatted warning at pos.
+// In general the Go compiler does NOT generate warnings,
+// so this should be used only when the user has opted in
+// to additional output by setting a particular flag.
+func WarnfAt(pos src.XPos, format string, args ...interface{}) {
+       addErrorMsg(pos, format, args...)
+       if Flag.LowerM != 0 {
+               FlushErrors()
+       }
+}
+
+// Fatalf reports a fatal error - an internal problem - at the current line and exits.
+// If other errors have already been printed, then Fatalf just quietly exits.
+// (The internal problem may have been caused by incomplete information
+// after the already-reported errors, so best to let users fix those and
+// try again without being bothered about a spurious internal error.)
+//
+// But if no errors have been printed, or if -d panic has been specified,
+// Fatalf prints the error as an "internal compiler error". In a released build,
+// it prints an error asking to file a bug report. In development builds, it
+// prints a stack trace.
+//
+// If -h has been specified, Fatalf panics to force the usual runtime info dump.
+func Fatalf(format string, args ...interface{}) {
+       FatalfAt(Pos, format, args...)
+}
+
+// FatalfAt reports a fatal error - an internal problem - at pos and exits.
+// If other errors have already been printed, then FatalfAt just quietly exits.
+// (The internal problem may have been caused by incomplete information
+// after the already-reported errors, so best to let users fix those and
+// try again without being bothered about a spurious internal error.)
+//
+// But if no errors have been printed, or if -d panic has been specified,
+// FatalfAt prints the error as an "internal compiler error". In a released build,
+// it prints an error asking to file a bug report. In development builds, it
+// prints a stack trace.
+//
+// If -h has been specified, FatalfAt panics to force the usual runtime info dump.
+func FatalfAt(pos src.XPos, format string, args ...interface{}) {
+       FlushErrors()
+
+       if Debug.Panic != 0 || numErrors == 0 {
+               fmt.Printf("%v: internal compiler error: ", FmtPos(pos))
+               fmt.Printf(format, args...)
+               fmt.Printf("\n")
+
+               // If this is a released compiler version, ask for a bug report.
+               if strings.HasPrefix(objabi.Version, "go") {
+                       fmt.Printf("\n")
+                       fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
+                       fmt.Printf("https://golang.org/issue/new\n")
+               } else {
+                       // Not a release; dump a stack trace, too.
+                       fmt.Println()
+                       os.Stdout.Write(debug.Stack())
+                       fmt.Println()
+               }
+       }
+
+       hcrash()
+       ErrorExit()
+}
+
+// hcrash crashes the compiler when -h is set, to find out where a message is generated.
+func hcrash() {
+       if Flag.LowerH != 0 {
+               FlushErrors()
+               if Flag.LowerO != "" {
+                       os.Remove(Flag.LowerO)
+               }
+               panic("-h")
+       }
+}
+
+// ErrorExit handles an error-status exit.
+// It flushes any pending errors, removes the output file, and exits.
+func ErrorExit() {
+       FlushErrors()
+       if Flag.LowerO != "" {
+               os.Remove(Flag.LowerO)
+       }
+       os.Exit(2)
+}
+
+// ExitIfErrors calls ErrorExit if any errors have been reported.
+func ExitIfErrors() {
+       if Errors() > 0 {
+               ErrorExit()
+       }
+}
+
+var AutogeneratedPos src.XPos

diff --git a/src/cmd/compile/internal/gc/timings.go b/src/cmd/compile/internal/base/timings.go
similarity index 99%
rename from src/cmd/compile/internal/gc/timings.go
rename to src/cmd/compile/internal/base/timings.go
index 56b3899e2f6ae1e6fe9e62552baa4e2178753756..f599f4e05f63309a7a5e98d90680be6e88c32ae3 100644 (file)
--- a/src/cmd/compile/internal/gc/timings.go
+++ b/src/cmd/compile/internal/base/timings.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package base
 
 import (
        "fmt"
@@ -11,6 +11,8 @@ import (
        "time"
 )
 
+var Timer Timings
+
 // Timings collects the execution times of labeled phases
 // which are added trough a sequence of Start/Stop calls.
 // Events may be associated with each phase via AddEvent.

diff --git a/src/cmd/compile/internal/bitvec/bv.go b/src/cmd/compile/internal/bitvec/bv.go
new file mode 100644 (file)
index 0000000..bcac1fe
--- /dev/null
+++ b/src/cmd/compile/internal/bitvec/bv.go
@@ -0,0 +1,190 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package bitvec
+
+import (
+       "math/bits"
+
+       "cmd/compile/internal/base"
+)
+
+const (
+       wordBits  = 32
+       wordMask  = wordBits - 1
+       wordShift = 5
+)
+
+// A BitVec is a bit vector.
+type BitVec struct {
+       N int32    // number of bits in vector
+       B []uint32 // words holding bits
+}
+
+func New(n int32) BitVec {
+       nword := (n + wordBits - 1) / wordBits
+       return BitVec{n, make([]uint32, nword)}
+}
+
+type Bulk struct {
+       words []uint32
+       nbit  int32
+       nword int32
+}
+
+func NewBulk(nbit int32, count int32) Bulk {
+       nword := (nbit + wordBits - 1) / wordBits
+       size := int64(nword) * int64(count)
+       if int64(int32(size*4)) != size*4 {
+               base.Fatalf("NewBulk too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
+       }
+       return Bulk{
+               words: make([]uint32, size),
+               nbit:  nbit,
+               nword: nword,
+       }
+}
+
+func (b *Bulk) Next() BitVec {
+       out := BitVec{b.nbit, b.words[:b.nword]}
+       b.words = b.words[b.nword:]
+       return out
+}
+
+func (bv1 BitVec) Eq(bv2 BitVec) bool {
+       if bv1.N != bv2.N {
+               base.Fatalf("bvequal: lengths %d and %d are not equal", bv1.N, bv2.N)
+       }
+       for i, x := range bv1.B {
+               if x != bv2.B[i] {
+                       return false
+               }
+       }
+       return true
+}
+
+func (dst BitVec) Copy(src BitVec) {
+       copy(dst.B, src.B)
+}
+
+func (bv BitVec) Get(i int32) bool {
+       if i < 0 || i >= bv.N {
+               base.Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.N)
+       }
+       mask := uint32(1 << uint(i%wordBits))
+       return bv.B[i>>wordShift]&mask != 0
+}
+
+func (bv BitVec) Set(i int32) {
+       if i < 0 || i >= bv.N {
+               base.Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.N)
+       }
+       mask := uint32(1 << uint(i%wordBits))
+       bv.B[i/wordBits] |= mask
+}
+
+func (bv BitVec) Unset(i int32) {
+       if i < 0 || i >= bv.N {
+               base.Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.N)
+       }
+       mask := uint32(1 << uint(i%wordBits))
+       bv.B[i/wordBits] &^= mask
+}
+
+// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
+// If there is no such index, bvnext returns -1.
+func (bv BitVec) Next(i int32) int32 {
+       if i >= bv.N {
+               return -1
+       }
+
+       // Jump i ahead to next word with bits.
+       if bv.B[i>>wordShift]>>uint(i&wordMask) == 0 {
+               i &^= wordMask
+               i += wordBits
+               for i < bv.N && bv.B[i>>wordShift] == 0 {
+                       i += wordBits
+               }
+       }
+
+       if i >= bv.N {
+               return -1
+       }
+
+       // Find 1 bit.
+       w := bv.B[i>>wordShift] >> uint(i&wordMask)
+       i += int32(bits.TrailingZeros32(w))
+
+       return i
+}
+
+func (bv BitVec) IsEmpty() bool {
+       for _, x := range bv.B {
+               if x != 0 {
+                       return false
+               }
+       }
+       return true
+}
+
+func (bv BitVec) Not() {
+       for i, x := range bv.B {
+               bv.B[i] = ^x
+       }
+}
+
+// union
+func (dst BitVec) Or(src1, src2 BitVec) {
+       if len(src1.B) == 0 {
+               return
+       }
+       _, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+       for i, x := range src1.B {
+               dst.B[i] = x | src2.B[i]
+       }
+}
+
+// intersection
+func (dst BitVec) And(src1, src2 BitVec) {
+       if len(src1.B) == 0 {
+               return
+       }
+       _, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+       for i, x := range src1.B {
+               dst.B[i] = x & src2.B[i]
+       }
+}
+
+// difference
+func (dst BitVec) AndNot(src1, src2 BitVec) {
+       if len(src1.B) == 0 {
+               return
+       }
+       _, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+       for i, x := range src1.B {
+               dst.B[i] = x &^ src2.B[i]
+       }
+}
+
+func (bv BitVec) String() string {
+       s := make([]byte, 2+bv.N)
+       copy(s, "#*")
+       for i := int32(0); i < bv.N; i++ {
+               ch := byte('0')
+               if bv.Get(i) {
+                       ch = '1'
+               }
+               s[2+i] = ch
+       }
+       return string(s)
+}
+
+func (bv BitVec) Clear() {
+       for i := range bv.B {
+               bv.B[i] = 0
+       }
+}

diff --git a/src/cmd/compile/internal/deadcode/deadcode.go b/src/cmd/compile/internal/deadcode/deadcode.go
new file mode 100644 (file)
index 0000000..5202037
--- /dev/null
+++ b/src/cmd/compile/internal/deadcode/deadcode.go
@@ -0,0 +1,152 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package deadcode
+
+import (
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+)
+
+func Func(fn *ir.Func) {
+       stmts(&fn.Body)
+
+       if len(fn.Body) == 0 {
+               return
+       }
+
+       for _, n := range fn.Body {
+               if len(n.Init()) > 0 {
+                       return
+               }
+               switch n.Op() {
+               case ir.OIF:
+                       n := n.(*ir.IfStmt)
+                       if !ir.IsConst(n.Cond, constant.Bool) || len(n.Body) > 0 || len(n.Else) > 0 {
+                               return
+                       }
+               case ir.OFOR:
+                       n := n.(*ir.ForStmt)
+                       if !ir.IsConst(n.Cond, constant.Bool) || ir.BoolVal(n.Cond) {
+                               return
+                       }
+               default:
+                       return
+               }
+       }
+
+       fn.Body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
+}
+
+func stmts(nn *ir.Nodes) {
+       var lastLabel = -1
+       for i, n := range *nn {
+               if n != nil && n.Op() == ir.OLABEL {
+                       lastLabel = i
+               }
+       }
+       for i, n := range *nn {
+               // Cut is set to true when all nodes after i'th position
+               // should be removed.
+               // In other words, it marks whole slice "tail" as dead.
+               cut := false
+               if n == nil {
+                       continue
+               }
+               if n.Op() == ir.OIF {
+                       n := n.(*ir.IfStmt)
+                       n.Cond = expr(n.Cond)
+                       if ir.IsConst(n.Cond, constant.Bool) {
+                               var body ir.Nodes
+                               if ir.BoolVal(n.Cond) {
+                                       n.Else = ir.Nodes{}
+                                       body = n.Body
+                               } else {
+                                       n.Body = ir.Nodes{}
+                                       body = n.Else
+                               }
+                               // If "then" or "else" branch ends with panic or return statement,
+                               // it is safe to remove all statements after this node.
+                               // isterminating is not used to avoid goto-related complications.
+                               // We must be careful not to deadcode-remove labels, as they
+                               // might be the target of a goto. See issue 28616.
+                               if body := body; len(body) != 0 {
+                                       switch body[(len(body) - 1)].Op() {
+                                       case ir.ORETURN, ir.OTAILCALL, ir.OPANIC:
+                                               if i > lastLabel {
+                                                       cut = true
+                                               }
+                                       }
+                               }
+                       }
+               }
+
+               if len(n.Init()) != 0 {
+                       stmts(n.(ir.InitNode).PtrInit())
+               }
+               switch n.Op() {
+               case ir.OBLOCK:
+                       n := n.(*ir.BlockStmt)
+                       stmts(&n.List)
+               case ir.OFOR:
+                       n := n.(*ir.ForStmt)
+                       stmts(&n.Body)
+               case ir.OIF:
+                       n := n.(*ir.IfStmt)
+                       stmts(&n.Body)
+                       stmts(&n.Else)
+               case ir.ORANGE:
+                       n := n.(*ir.RangeStmt)
+                       stmts(&n.Body)
+               case ir.OSELECT:
+                       n := n.(*ir.SelectStmt)
+                       for _, cas := range n.Cases {
+                               stmts(&cas.Body)
+                       }
+               case ir.OSWITCH:
+                       n := n.(*ir.SwitchStmt)
+                       for _, cas := range n.Cases {
+                               stmts(&cas.Body)
+                       }
+               }
+
+               if cut {
+                       *nn = (*nn)[:i+1]
+                       break
+               }
+       }
+}
+
+func expr(n ir.Node) ir.Node {
+       // Perform dead-code elimination on short-circuited boolean
+       // expressions involving constants with the intent of
+       // producing a constant 'if' condition.
+       switch n.Op() {
+       case ir.OANDAND:
+               n := n.(*ir.LogicalExpr)
+               n.X = expr(n.X)
+               n.Y = expr(n.Y)
+               if ir.IsConst(n.X, constant.Bool) {
+                       if ir.BoolVal(n.X) {
+                               return n.Y // true && x => x
+                       } else {
+                               return n.X // false && x => false
+                       }
+               }
+       case ir.OOROR:
+               n := n.(*ir.LogicalExpr)
+               n.X = expr(n.X)
+               n.Y = expr(n.Y)
+               if ir.IsConst(n.X, constant.Bool) {
+                       if ir.BoolVal(n.X) {
+                               return n.X // true || x => true
+                       } else {
+                               return n.Y // false || x => x
+                       }
+               }
+       }
+       return n
+}

diff --git a/src/cmd/compile/internal/devirtualize/devirtualize.go b/src/cmd/compile/internal/devirtualize/devirtualize.go
new file mode 100644 (file)
index 0000000..60ba208
--- /dev/null
+++ b/src/cmd/compile/internal/devirtualize/devirtualize.go
@@ -0,0 +1,85 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package devirtualize implements a simple "devirtualization"
+// optimization pass, which replaces interface method calls with
+// direct concrete-type method calls where possible.
+package devirtualize
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+)
+
+// Func devirtualizes calls within fn where possible.
+func Func(fn *ir.Func) {
+       ir.CurFunc = fn
+       ir.VisitList(fn.Body, func(n ir.Node) {
+               if call, ok := n.(*ir.CallExpr); ok {
+                       Call(call)
+               }
+       })
+}
+
+// Call devirtualizes the given call if possible.
+func Call(call *ir.CallExpr) {
+       if call.Op() != ir.OCALLINTER {
+               return
+       }
+       sel := call.X.(*ir.SelectorExpr)
+       r := ir.StaticValue(sel.X)
+       if r.Op() != ir.OCONVIFACE {
+               return
+       }
+       recv := r.(*ir.ConvExpr)
+
+       typ := recv.X.Type()
+       if typ.IsInterface() {
+               return
+       }
+
+       dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)
+       dt.SetType(typ)
+       x := typecheck.Callee(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel))
+       switch x.Op() {
+       case ir.ODOTMETH:
+               x := x.(*ir.SelectorExpr)
+               if base.Flag.LowerM != 0 {
+                       base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
+               }
+               call.SetOp(ir.OCALLMETH)
+               call.X = x
+       case ir.ODOTINTER:
+               // Promoted method from embedded interface-typed field (#42279).
+               x := x.(*ir.SelectorExpr)
+               if base.Flag.LowerM != 0 {
+                       base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
+               }
+               call.SetOp(ir.OCALLINTER)
+               call.X = x
+       default:
+               // TODO(mdempsky): Turn back into Fatalf after more testing.
+               if base.Flag.LowerM != 0 {
+                       base.WarnfAt(call.Pos(), "failed to devirtualize %v (%v)", x, x.Op())
+               }
+               return
+       }
+
+       // Duplicated logic from typecheck for function call return
+       // value types.
+       //
+       // Receiver parameter size may have changed; need to update
+       // call.Type to get correct stack offsets for result
+       // parameters.
+       types.CheckSize(x.Type())
+       switch ft := x.Type(); ft.NumResults() {
+       case 0:
+       case 1:
+               call.SetType(ft.Results().Field(0).Type)
+       default:
+               call.SetType(ft.Results())
+       }
+}

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
new file mode 100644 (file)
index 0000000..70168cf
--- /dev/null
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -0,0 +1,457 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dwarfgen
+
+import (
+       "bytes"
+       "flag"
+       "fmt"
+       "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/types"
+       "cmd/internal/dwarf"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
+       fn := curfn.(*ir.Func)
+
+       if fn.Nname != nil {
+               expect := fn.Linksym()
+               if fnsym.ABI() == obj.ABI0 {
+                       expect = fn.LinksymABI(obj.ABI0)
+               }
+               if fnsym != expect {
+                       base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
+               }
+       }
+
+       // Back when there were two different *Funcs for a function, this code
+       // was not consistent about whether a particular *Node being processed
+       // was an ODCLFUNC or ONAME node. Partly this is because inlined function
+       // bodies have no ODCLFUNC node, which was it's own inconsistency.
+       // In any event, the handling of the two different nodes for DWARF purposes
+       // was subtly different, likely in unintended ways. CL 272253 merged the
+       // two nodes' Func fields, so that code sees the same *Func whether it is
+       // holding the ODCLFUNC or the ONAME. This resulted in changes in the
+       // DWARF output. To preserve the existing DWARF output and leave an
+       // intentional change for a future CL, this code does the following when
+       // fn.Op == ONAME:
+       //
+       // 1. Disallow use of createComplexVars in createDwarfVars.
+       //    It was not possible to reach that code for an ONAME before,
+       //    because the DebugInfo was set only on the ODCLFUNC Func.
+       //    Calling into it in the ONAME case causes an index out of bounds panic.
+       //
+       // 2. Do not populate apdecls. fn.Func.Dcl was in the ODCLFUNC Func,
+       //    not the ONAME Func. Populating apdecls for the ONAME case results
+       //    in selected being populated after createSimpleVars is called in
+       //    createDwarfVars, and then that causes the loop to skip all the entries
+       //    in dcl, meaning that the RecordAutoType calls don't happen.
+       //
+       // These two adjustments keep toolstash -cmp working for now.
+       // Deciding the right answer is, as they say, future work.
+       //
+       // We can tell the difference between the old ODCLFUNC and ONAME
+       // cases by looking at the infosym.Name. If it's empty, DebugInfo is
+       // being called from (*obj.Link).populateDWARF, which used to use
+       // the ODCLFUNC. If it's non-empty (the name will end in $abstract),
+       // DebugInfo is being called from (*obj.Link).DwarfAbstractFunc,
+       // which used to use the ONAME form.
+       isODCLFUNC := infosym.Name == ""
+
+       var apdecls []*ir.Name
+       // Populate decls for fn.
+       if isODCLFUNC {
+               for _, n := range fn.Dcl {
+                       if n.Op() != ir.ONAME { // might be OTYPE or OLITERAL
+                               continue
+                       }
+                       switch n.Class {
+                       case ir.PAUTO:
+                               if !n.Used() {
+                                       // Text == nil -> generating abstract function
+                                       if fnsym.Func().Text != nil {
+                                               base.Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
+                                       }
+                                       continue
+                               }
+                       case ir.PPARAM, ir.PPARAMOUT:
+                       default:
+                               continue
+                       }
+                       apdecls = append(apdecls, n)
+                       fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
+               }
+       }
+
+       decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn, apdecls)
+
+       // For each type referenced by the functions auto vars but not
+       // already referenced by a dwarf var, attach an R_USETYPE relocation to
+       // the function symbol to insure that the type included in DWARF
+       // processing during linking.
+       typesyms := []*obj.LSym{}
+       for t, _ := range fnsym.Func().Autot {
+               typesyms = append(typesyms, t)
+       }
+       sort.Sort(obj.BySymName(typesyms))
+       for _, sym := range typesyms {
+               r := obj.Addrel(infosym)
+               r.Sym = sym
+               r.Type = objabi.R_USETYPE
+       }
+       fnsym.Func().Autot = nil
+
+       var varScopes []ir.ScopeID
+       for _, decl := range decls {
+               pos := declPos(decl)
+               varScopes = append(varScopes, findScope(fn.Marks, pos))
+       }
+
+       scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
+       var inlcalls dwarf.InlCalls
+       if base.Flag.GenDwarfInl > 0 {
+               inlcalls = assembleInlines(fnsym, dwarfVars)
+       }
+       return scopes, inlcalls
+}
+
+func declPos(decl *ir.Name) src.XPos {
+       return decl.Canonical().Pos()
+}
+
+// createDwarfVars process fn, returning a list of DWARF variables and the
+// Nodes they represent.
+func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var) {
+       // Collect a raw list of DWARF vars.
+       var vars []*dwarf.Var
+       var decls []*ir.Name
+       var selected ir.NameSet
+       if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
+               decls, vars, selected = createComplexVars(fnsym, fn)
+       } else {
+               decls, vars, selected = createSimpleVars(fnsym, apDecls)
+       }
+
+       dcl := apDecls
+       if fnsym.WasInlined() {
+               dcl = preInliningDcls(fnsym)
+       }
+
+       // If optimization is enabled, the list above will typically be
+       // missing some of the original pre-optimization variables in the
+       // function (they may have been promoted to registers, folded into
+       // constants, dead-coded away, etc).  Input arguments not eligible
+       // for SSA optimization are also missing.  Here we add back in entries
+       // for selected missing vars. Note that the recipe below creates a
+       // conservative location. The idea here is that we want to
+       // communicate to the user that "yes, there is a variable named X
+       // in this function, but no, I don't have enough information to
+       // reliably report its contents."
+       // For non-SSA-able arguments, however, the correct information
+       // is known -- they have a single home on the stack.
+       for _, n := range dcl {
+               if selected.Has(n) {
+                       continue
+               }
+               c := n.Sym().Name[0]
+               if c == '.' || n.Type().IsUntyped() {
+                       continue
+               }
+               if n.Class == ir.PPARAM && !ssagen.TypeOK(n.Type()) {
+                       // SSA-able args get location lists, and may move in and
+                       // out of registers, so those are handled elsewhere.
+                       // Autos and named output params seem to get handled
+                       // with VARDEF, which creates location lists.
+                       // Args not of SSA-able type are treated here; they
+                       // are homed on the stack in a single place for the
+                       // entire call.
+                       vars = append(vars, createSimpleVar(fnsym, n))
+                       decls = append(decls, n)
+                       continue
+               }
+               typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
+               decls = append(decls, n)
+               abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
+               isReturnValue := (n.Class == ir.PPARAMOUT)
+               if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+                       abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
+               }
+               if n.Esc() == ir.EscHeap {
+                       // The variable in question has been promoted to the heap.
+                       // Its address is in n.Heapaddr.
+                       // TODO(thanm): generate a better location expression
+               }
+               inlIndex := 0
+               if base.Flag.GenDwarfInl > 1 {
+                       if n.InlFormal() || n.InlLocal() {
+                               inlIndex = posInlIndex(n.Pos()) + 1
+                               if n.InlFormal() {
+                                       abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
+                               }
+                       }
+               }
+               declpos := base.Ctxt.InnermostPos(n.Pos())
+               vars = append(vars, &dwarf.Var{
+                       Name:          n.Sym().Name,
+                       IsReturnValue: isReturnValue,
+                       Abbrev:        abbrev,
+                       StackOffset:   int32(n.FrameOffset()),
+                       Type:          base.Ctxt.Lookup(typename),
+                       DeclFile:      declpos.RelFilename(),
+                       DeclLine:      declpos.RelLine(),
+                       DeclCol:       declpos.Col(),
+                       InlIndex:      int32(inlIndex),
+                       ChildIndex:    -1,
+               })
+               // Record go type of to insure that it gets emitted by the linker.
+               fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
+       }
+
+       return decls, vars
+}
+
+// Given a function that was inlined at some point during the
+// compilation, return a sorted list of nodes corresponding to the
+// autos/locals in that function prior to inlining. If this is a
+// function that is not local to the package being compiled, then the
+// names of the variables may have been "versioned" to avoid conflicts
+// with local vars; disregard this versioning when sorting.
+func preInliningDcls(fnsym *obj.LSym) []*ir.Name {
+       fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Func)
+       var rdcl []*ir.Name
+       for _, n := range fn.Inl.Dcl {
+               c := n.Sym().Name[0]
+               // Avoid reporting "_" parameters, since if there are more than
+               // one, it can result in a collision later on, as in #23179.
+               if unversion(n.Sym().Name) == "_" || c == '.' || n.Type().IsUntyped() {
+                       continue
+               }
+               rdcl = append(rdcl, n)
+       }
+       return rdcl
+}
+
+// createSimpleVars creates a DWARF entry for every variable declared in the
+// function, claiming that they are permanently on the stack.
+func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
+       var vars []*dwarf.Var
+       var decls []*ir.Name
+       var selected ir.NameSet
+       for _, n := range apDecls {
+               if ir.IsAutoTmp(n) {
+                       continue
+               }
+
+               decls = append(decls, n)
+               vars = append(vars, createSimpleVar(fnsym, n))
+               selected.Add(n)
+       }
+       return decls, vars, selected
+}
+
+func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
+       var abbrev int
+       var offs int64
+
+       switch n.Class {
+       case ir.PAUTO:
+               offs = n.FrameOffset()
+               abbrev = dwarf.DW_ABRV_AUTO
+               if base.Ctxt.FixedFrameSize() == 0 {
+                       offs -= int64(types.PtrSize)
+               }
+               if objabi.Framepointer_enabled {
+                       offs -= int64(types.PtrSize)
+               }
+
+       case ir.PPARAM, ir.PPARAMOUT:
+               abbrev = dwarf.DW_ABRV_PARAM
+               offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+       default:
+               base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
+       }
+
+       typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
+       delete(fnsym.Func().Autot, reflectdata.TypeLinksym(n.Type()))
+       inlIndex := 0
+       if base.Flag.GenDwarfInl > 1 {
+               if n.InlFormal() || n.InlLocal() {
+                       inlIndex = posInlIndex(n.Pos()) + 1
+                       if n.InlFormal() {
+                               abbrev = dwarf.DW_ABRV_PARAM
+                       }
+               }
+       }
+       declpos := base.Ctxt.InnermostPos(declPos(n))
+       return &dwarf.Var{
+               Name:          n.Sym().Name,
+               IsReturnValue: n.Class == ir.PPARAMOUT,
+               IsInlFormal:   n.InlFormal(),
+               Abbrev:        abbrev,
+               StackOffset:   int32(offs),
+               Type:          base.Ctxt.Lookup(typename),
+               DeclFile:      declpos.RelFilename(),
+               DeclLine:      declpos.RelLine(),
+               DeclCol:       declpos.Col(),
+               InlIndex:      int32(inlIndex),
+               ChildIndex:    -1,
+       }
+}
+
+// createComplexVars creates recomposed DWARF vars with location lists,
+// suitable for describing optimized code.
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
+       debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
+
+       // Produce a DWARF variable entry for each user variable.
+       var decls []*ir.Name
+       var vars []*dwarf.Var
+       var ssaVars ir.NameSet
+
+       for varID, dvar := range debugInfo.Vars {
+               n := dvar
+               ssaVars.Add(n)
+               for _, slot := range debugInfo.VarSlots[varID] {
+                       ssaVars.Add(debugInfo.Slots[slot].N)
+               }
+
+               if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
+                       decls = append(decls, n)
+                       vars = append(vars, dvar)
+               }
+       }
+
+       return decls, vars, ssaVars
+}
+
+// createComplexVar builds a single DWARF variable entry and location list.
+func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var {
+       debug := fn.DebugInfo.(*ssa.FuncDebug)
+       n := debug.Vars[varID]
+
+       var abbrev int
+       switch n.Class {
+       case ir.PAUTO:
+               abbrev = dwarf.DW_ABRV_AUTO_LOCLIST
+       case ir.PPARAM, ir.PPARAMOUT:
+               abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
+       default:
+               return nil
+       }
+
+       gotype := reflectdata.TypeLinksym(n.Type())
+       delete(fnsym.Func().Autot, gotype)
+       typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
+       inlIndex := 0
+       if base.Flag.GenDwarfInl > 1 {
+               if n.InlFormal() || n.InlLocal() {
+                       inlIndex = posInlIndex(n.Pos()) + 1
+                       if n.InlFormal() {
+                               abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
+                       }
+               }
+       }
+       declpos := base.Ctxt.InnermostPos(n.Pos())
+       dvar := &dwarf.Var{
+               Name:          n.Sym().Name,
+               IsReturnValue: n.Class == ir.PPARAMOUT,
+               IsInlFormal:   n.InlFormal(),
+               Abbrev:        abbrev,
+               Type:          base.Ctxt.Lookup(typename),
+               // The stack offset is used as a sorting key, so for decomposed
+               // variables just give it the first one. It's not used otherwise.
+               // This won't work well if the first slot hasn't been assigned a stack
+               // location, but it's not obvious how to do better.
+               StackOffset: ssagen.StackOffset(debug.Slots[debug.VarSlots[varID][0]]),
+               DeclFile:    declpos.RelFilename(),
+               DeclLine:    declpos.RelLine(),
+               DeclCol:     declpos.Col(),
+               InlIndex:    int32(inlIndex),
+               ChildIndex:  -1,
+       }
+       list := debug.LocationLists[varID]
+       if len(list) != 0 {
+               dvar.PutLocationList = func(listSym, startPC dwarf.Sym) {
+                       debug.PutLocationList(list, base.Ctxt, listSym.(*obj.LSym), startPC.(*obj.LSym))
+               }
+       }
+       return dvar
+}
+
+// RecordFlags records the specified command-line flags to be placed
+// in the DWARF info.
+func RecordFlags(flags ...string) {
+       if base.Ctxt.Pkgpath == "" {
+               // We can't record the flags if we don't know what the
+               // package name is.
+               return
+       }
+
+       type BoolFlag interface {
+               IsBoolFlag() bool
+       }
+       type CountFlag interface {
+               IsCountFlag() bool
+       }
+       var cmd bytes.Buffer
+       for _, name := range flags {
+               f := flag.Lookup(name)
+               if f == nil {
+                       continue
+               }
+               getter := f.Value.(flag.Getter)
+               if getter.String() == f.DefValue {
+                       // Flag has default value, so omit it.
+                       continue
+               }
+               if bf, ok := f.Value.(BoolFlag); ok && bf.IsBoolFlag() {
+                       val, ok := getter.Get().(bool)
+                       if ok && val {
+                               fmt.Fprintf(&cmd, " -%s", f.Name)
+                               continue
+                       }
+               }
+               if cf, ok := f.Value.(CountFlag); ok && cf.IsCountFlag() {
+                       val, ok := getter.Get().(int)
+                       if ok && val == 1 {
+                               fmt.Fprintf(&cmd, " -%s", f.Name)
+                               continue
+                       }
+               }
+               fmt.Fprintf(&cmd, " -%s=%v", f.Name, getter.Get())
+       }
+
+       if cmd.Len() == 0 {
+               return
+       }
+       s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + base.Ctxt.Pkgpath)
+       s.Type = objabi.SDWARFCUINFO
+       // Sometimes (for example when building tests) we can link
+       // together two package main archives. So allow dups.
+       s.Set(obj.AttrDuplicateOK, true)
+       base.Ctxt.Data = append(base.Ctxt.Data, s)
+       s.P = cmd.Bytes()[1:]
+}
+
+// RecordPackageName records the name of the package being
+// compiled, so that the linker can save it in the compile unit's DIE.
+func RecordPackageName() {
+       s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + base.Ctxt.Pkgpath)
+       s.Type = objabi.SDWARFCUINFO
+       // Sometimes (for example when building tests) we can link
+       // together two package main archives. So allow dups.
+       s.Set(obj.AttrDuplicateOK, true)
+       base.Ctxt.Data = append(base.Ctxt.Data, s)
+       s.P = []byte(types.LocalPkg.Name)
+}

diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/dwarfgen/dwinl.go
similarity index 86%
rename from src/cmd/compile/internal/gc/dwinl.go
rename to src/cmd/compile/internal/dwarfgen/dwinl.go
index bb5ae61cbb3b40bd48e39704fc2683697666048a..d5687cb1d72bb41465340dfb77c9deb759131254 100644 (file)
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/dwarfgen/dwinl.go
@@ -2,14 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package dwarfgen
 
 import (
+       "fmt"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/internal/dwarf"
        "cmd/internal/obj"
        "cmd/internal/src"
-       "fmt"
-       "strings"
 )
 
 // To identify variables by original source position.
@@ -26,8 +29,8 @@ type varPos struct {
 func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
        var inlcalls dwarf.InlCalls
 
-       if Debug_gendwarfinl != 0 {
-               Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name)
+       if base.Debug.DwarfInl != 0 {
+               base.Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name)
        }
 
        // This maps inline index (from Ctxt.InlTree) to index in inlcalls.Calls
@@ -106,7 +109,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
                        }
                        m = makePreinlineDclMap(fnsym)
                } else {
-                       ifnlsym := Ctxt.InlTree.InlinedFunction(int(ii - 1))
+                       ifnlsym := base.Ctxt.InlTree.InlinedFunction(int(ii - 1))
                        m = makePreinlineDclMap(ifnlsym)
                }
 
@@ -181,7 +184,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
        }
 
        // Debugging
-       if Debug_gendwarfinl != 0 {
+       if base.Debug.DwarfInl != 0 {
                dumpInlCalls(inlcalls)
                dumpInlVars(dwVars)
        }
@@ -204,16 +207,17 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 // late in the compilation when it is determined that we need an
 // abstract function DIE for an inlined routine imported from a
 // previously compiled package.
-func genAbstractFunc(fn *obj.LSym) {
-       ifn := Ctxt.DwFixups.GetPrecursorFunc(fn)
+func AbstractFunc(fn *obj.LSym) {
+       ifn := base.Ctxt.DwFixups.GetPrecursorFunc(fn)
        if ifn == nil {
-               Ctxt.Diag("failed to locate precursor fn for %v", fn)
+               base.Ctxt.Diag("failed to locate precursor fn for %v", fn)
                return
        }
-       if Debug_gendwarfinl != 0 {
-               Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
+       _ = ifn.(*ir.Func)
+       if base.Debug.DwarfInl != 0 {
+               base.Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
        }
-       Ctxt.DwarfAbstractFunc(ifn, fn, myimportpath)
+       base.Ctxt.DwarfAbstractFunc(ifn, fn, base.Ctxt.Pkgpath)
 }
 
 // Undo any versioning performed when a name was written
@@ -235,15 +239,15 @@ func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int {
        dcl := preInliningDcls(fnsym)
        m := make(map[varPos]int)
        for i, n := range dcl {
-               pos := Ctxt.InnermostPos(n.Pos)
+               pos := base.Ctxt.InnermostPos(n.Pos())
                vp := varPos{
-                       DeclName: unversion(n.Sym.Name),
+                       DeclName: unversion(n.Sym().Name),
                        DeclFile: pos.RelFilename(),
                        DeclLine: pos.RelLine(),
                        DeclCol:  pos.Col(),
                }
                if _, found := m[vp]; found {
-                       Fatalf("child dcl collision on symbol %s within %v\n", n.Sym.Name, fnsym.Name)
+                       base.Fatalf("child dcl collision on symbol %s within %v\n", n.Sym().Name, fnsym.Name)
                }
                m[vp] = i
        }
@@ -260,17 +264,17 @@ func insertInlCall(dwcalls *dwarf.InlCalls, inlIdx int, imap map[int]int) int {
        // is one. We do this first so that parents appear before their
        // children in the resulting table.
        parCallIdx := -1
-       parInlIdx := Ctxt.InlTree.Parent(inlIdx)
+       parInlIdx := base.Ctxt.InlTree.Parent(inlIdx)
        if parInlIdx >= 0 {
                parCallIdx = insertInlCall(dwcalls, parInlIdx, imap)
        }
 
        // Create new entry for this inline
-       inlinedFn := Ctxt.InlTree.InlinedFunction(inlIdx)
-       callXPos := Ctxt.InlTree.CallPos(inlIdx)
-       absFnSym := Ctxt.DwFixups.AbsFuncDwarfSym(inlinedFn)
-       pb := Ctxt.PosTable.Pos(callXPos).Base()
-       callFileSym := Ctxt.Lookup(pb.SymFilename())
+       inlinedFn := base.Ctxt.InlTree.InlinedFunction(inlIdx)
+       callXPos := base.Ctxt.InlTree.CallPos(inlIdx)
+       absFnSym := base.Ctxt.DwFixups.AbsFuncDwarfSym(inlinedFn)
+       pb := base.Ctxt.PosTable.Pos(callXPos).Base()
+       callFileSym := base.Ctxt.Lookup(pb.SymFilename())
        ic := dwarf.InlCall{
                InlIndex:  inlIdx,
                CallFile:  callFileSym,
@@ -298,7 +302,7 @@ func insertInlCall(dwcalls *dwarf.InlCalls, inlIdx int, imap map[int]int) int {
 // the index for a node from the inlined body of D will refer to the
 // call to D from C. Whew.
 func posInlIndex(xpos src.XPos) int {
-       pos := Ctxt.PosTable.Pos(xpos)
+       pos := base.Ctxt.PosTable.Pos(xpos)
        if b := pos.Base(); b != nil {
                ii := b.InliningIndex()
                if ii >= 0 {
@@ -324,7 +328,7 @@ func addRange(calls []dwarf.InlCall, start, end int64, ii int, imap map[int]int)
        // Append range to correct inlined call
        callIdx, found := imap[ii]
        if !found {
-               Fatalf("can't find inlIndex %d in imap for prog at %d\n", ii, start)
+               base.Fatalf("can't find inlIndex %d in imap for prog at %d\n", ii, start)
        }
        call := &calls[callIdx]
        call.Ranges = append(call.Ranges, dwarf.Range{Start: start, End: end})
@@ -332,23 +336,23 @@ func addRange(calls []dwarf.InlCall, start, end int64, ii int, imap map[int]int)
 
 func dumpInlCall(inlcalls dwarf.InlCalls, idx, ilevel int) {
        for i := 0; i < ilevel; i++ {
-               Ctxt.Logf("  ")
+               base.Ctxt.Logf("  ")
        }
        ic := inlcalls.Calls[idx]
-       callee := Ctxt.InlTree.InlinedFunction(ic.InlIndex)
-       Ctxt.Logf("  %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name)
+       callee := base.Ctxt.InlTree.InlinedFunction(ic.InlIndex)
+       base.Ctxt.Logf("  %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name)
        for _, f := range ic.InlVars {
-               Ctxt.Logf(" %v", f.Name)
+               base.Ctxt.Logf(" %v", f.Name)
        }
-       Ctxt.Logf(" ) C: (")
+       base.Ctxt.Logf(" ) C: (")
        for _, k := range ic.Children {
-               Ctxt.Logf(" %v", k)
+               base.Ctxt.Logf(" %v", k)
        }
-       Ctxt.Logf(" ) R:")
+       base.Ctxt.Logf(" ) R:")
        for _, r := range ic.Ranges {
-               Ctxt.Logf(" [%d,%d)", r.Start, r.End)
+               base.Ctxt.Logf(" [%d,%d)", r.Start, r.End)
        }
-       Ctxt.Logf("\n")
+       base.Ctxt.Logf("\n")
        for _, k := range ic.Children {
                dumpInlCall(inlcalls, k, ilevel+1)
        }
@@ -373,7 +377,7 @@ func dumpInlVars(dwvars []*dwarf.Var) {
                if dwv.IsInAbstract {
                        ia = 1
                }
-               Ctxt.Logf("V%d: %s CI:%d II:%d IA:%d %s\n", i, dwv.Name, dwv.ChildIndex, dwv.InlIndex-1, ia, typ)
+               base.Ctxt.Logf("V%d: %s CI:%d II:%d IA:%d %s\n", i, dwv.Name, dwv.ChildIndex, dwv.InlIndex-1, ia, typ)
        }
 }
 
@@ -410,7 +414,7 @@ func checkInlCall(funcName string, inlCalls dwarf.InlCalls, funcSize int64, idx,
 
        // Callee
        ic := inlCalls.Calls[idx]
-       callee := Ctxt.InlTree.InlinedFunction(ic.InlIndex).Name
+       callee := base.Ctxt.InlTree.InlinedFunction(ic.InlIndex).Name
        calleeRanges := ic.Ranges
 
        // Caller
@@ -418,14 +422,14 @@ func checkInlCall(funcName string, inlCalls dwarf.InlCalls, funcSize int64, idx,
        parentRanges := []dwarf.Range{dwarf.Range{Start: int64(0), End: funcSize}}
        if parentIdx != -1 {
                pic := inlCalls.Calls[parentIdx]
-               caller = Ctxt.InlTree.InlinedFunction(pic.InlIndex).Name
+               caller = base.Ctxt.InlTree.InlinedFunction(pic.InlIndex).Name
                parentRanges = pic.Ranges
        }
 
        // Callee ranges contained in caller ranges?
        c, m := rangesContainsAll(parentRanges, calleeRanges)
        if !c {
-               Fatalf("** malformed inlined routine range in %s: caller %s callee %s II=%d %s\n", funcName, caller, callee, idx, m)
+               base.Fatalf("** malformed inlined routine range in %s: caller %s callee %s II=%d %s\n", funcName, caller, callee, idx, m)
        }
 
        // Now visit kids

diff --git a/src/cmd/compile/internal/dwarfgen/marker.go b/src/cmd/compile/internal/dwarfgen/marker.go
new file mode 100644 (file)
index 0000000..ec6ce45
--- /dev/null
+++ b/src/cmd/compile/internal/dwarfgen/marker.go
@@ -0,0 +1,94 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dwarfgen
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/internal/src"
+)
+
+// A ScopeMarker tracks scope nesting and boundaries for later use
+// during DWARF generation.
+type ScopeMarker struct {
+       parents []ir.ScopeID
+       marks   []ir.Mark
+}
+
+// checkPos validates the given position and returns the current scope.
+func (m *ScopeMarker) checkPos(pos src.XPos) ir.ScopeID {
+       if !pos.IsKnown() {
+               base.Fatalf("unknown scope position")
+       }
+
+       if len(m.marks) == 0 {
+               return 0
+       }
+
+       last := &m.marks[len(m.marks)-1]
+       if xposBefore(pos, last.Pos) {
+               base.FatalfAt(pos, "non-monotonic scope positions\n\t%v: previous scope position", base.FmtPos(last.Pos))
+       }
+       return last.Scope
+}
+
+// Push records a transition to a new child scope of the current scope.
+func (m *ScopeMarker) Push(pos src.XPos) {
+       current := m.checkPos(pos)
+
+       m.parents = append(m.parents, current)
+       child := ir.ScopeID(len(m.parents))
+
+       m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: child})
+}
+
+// Pop records a transition back to the current scope's parent.
+func (m *ScopeMarker) Pop(pos src.XPos) {
+       current := m.checkPos(pos)
+
+       parent := m.parents[current-1]
+
+       m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: parent})
+}
+
+// Unpush removes the current scope, which must be empty.
+func (m *ScopeMarker) Unpush() {
+       i := len(m.marks) - 1
+       current := m.marks[i].Scope
+
+       if current != ir.ScopeID(len(m.parents)) {
+               base.FatalfAt(m.marks[i].Pos, "current scope is not empty")
+       }
+
+       m.parents = m.parents[:current-1]
+       m.marks = m.marks[:i]
+}
+
+// WriteTo writes the recorded scope marks to the given function,
+// and resets the marker for reuse.
+func (m *ScopeMarker) WriteTo(fn *ir.Func) {
+       m.compactMarks()
+
+       fn.Parents = make([]ir.ScopeID, len(m.parents))
+       copy(fn.Parents, m.parents)
+       m.parents = m.parents[:0]
+
+       fn.Marks = make([]ir.Mark, len(m.marks))
+       copy(fn.Marks, m.marks)
+       m.marks = m.marks[:0]
+}
+
+func (m *ScopeMarker) compactMarks() {
+       n := 0
+       for _, next := range m.marks {
+               if n > 0 && next.Pos == m.marks[n-1].Pos {
+                       m.marks[n-1].Scope = next.Scope
+                       continue
+               }
+               m.marks[n] = next
+               n++
+       }
+       m.marks = m.marks[:n]
+}

diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/dwarfgen/scope.go
similarity index 78%
rename from src/cmd/compile/internal/gc/scope.go
rename to src/cmd/compile/internal/dwarfgen/scope.go
index e66b859e10069142984bf528a1cf47db8d449293..1c040edc2842391cdc544de6280c3afad83f8e14 100644 (file)
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/dwarfgen/scope.go
@@ -2,21 +2,24 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package dwarfgen
 
 import (
+       "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/internal/dwarf"
        "cmd/internal/obj"
        "cmd/internal/src"
-       "sort"
 )
 
 // See golang.org/issue/20390.
 func xposBefore(p, q src.XPos) bool {
-       return Ctxt.PosTable.Pos(p).Before(Ctxt.PosTable.Pos(q))
+       return base.Ctxt.PosTable.Pos(p).Before(base.Ctxt.PosTable.Pos(q))
 }
 
-func findScope(marks []Mark, pos src.XPos) ScopeID {
+func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
        i := sort.Search(len(marks), func(i int) bool {
                return xposBefore(pos, marks[i].Pos)
        })
@@ -26,20 +29,20 @@ func findScope(marks []Mark, pos src.XPos) ScopeID {
        return marks[i-1].Scope
 }
 
-func assembleScopes(fnsym *obj.LSym, fn *Node, dwarfVars []*dwarf.Var, varScopes []ScopeID) []dwarf.Scope {
+func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
        // Initialize the DWARF scope tree based on lexical scopes.
-       dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func.Parents))
-       for i, parent := range fn.Func.Parents {
+       dwarfScopes := make([]dwarf.Scope, 1+len(fn.Parents))
+       for i, parent := range fn.Parents {
                dwarfScopes[i+1].Parent = int32(parent)
        }
 
        scopeVariables(dwarfVars, varScopes, dwarfScopes)
-       scopePCs(fnsym, fn.Func.Marks, dwarfScopes)
+       scopePCs(fnsym, fn.Marks, dwarfScopes)
        return compactScopes(dwarfScopes)
 }
 
 // scopeVariables assigns DWARF variable records to their scopes.
-func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ScopeID, dwarfScopes []dwarf.Scope) {
+func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ir.ScopeID, dwarfScopes []dwarf.Scope) {
        sort.Stable(varsByScopeAndOffset{dwarfVars, varScopes})
 
        i0 := 0
@@ -56,7 +59,7 @@ func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ScopeID, dwarfScopes []d
 }
 
 // scopePCs assigns PC ranges to their scopes.
-func scopePCs(fnsym *obj.LSym, marks []Mark, dwarfScopes []dwarf.Scope) {
+func scopePCs(fnsym *obj.LSym, marks []ir.Mark, dwarfScopes []dwarf.Scope) {
        // If there aren't any child scopes (in particular, when scope
        // tracking is disabled), we can skip a whole lot of work.
        if len(marks) == 0 {
@@ -89,7 +92,7 @@ func compactScopes(dwarfScopes []dwarf.Scope) []dwarf.Scope {
 
 type varsByScopeAndOffset struct {
        vars   []*dwarf.Var
-       scopes []ScopeID
+       scopes []ir.ScopeID
 }
 
 func (v varsByScopeAndOffset) Len() int {

diff --git a/src/cmd/compile/internal/gc/scope_test.go b/src/cmd/compile/internal/dwarfgen/scope_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/scope_test.go
rename to src/cmd/compile/internal/dwarfgen/scope_test.go
index b0e038d27f5db419414c71058430c76ddab267be..fcfcf85f84c2a35b5ed3fb9d0ddad0011c2cda08 100644 (file)
--- a/src/cmd/compile/internal/gc/scope_test.go
+++ b/src/cmd/compile/internal/dwarfgen/scope_test.go
@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package dwarfgen
 
 import (
-       "cmd/internal/objfile"
        "debug/dwarf"
        "fmt"
        "internal/testenv"
@@ -18,6 +17,8 @@ import (
        "strconv"
        "strings"
        "testing"
+
+       "cmd/internal/objfile"
 )
 
 type testline struct {

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
new file mode 100644 (file)
index 0000000..58cad73
--- /dev/null
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -0,0 +1,2137 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package escape
+
+import (
+       "fmt"
+       "math"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/logopt"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// Escape analysis.
+//
+// Here we analyze functions to determine which Go variables
+// (including implicit allocations such as calls to "new" or "make",
+// composite literals, etc.) can be allocated on the stack. The two
+// key invariants we have to ensure are: (1) pointers to stack objects
+// cannot be stored in the heap, and (2) pointers to a stack object
+// cannot outlive that object (e.g., because the declaring function
+// returned and destroyed the object's stack frame, or its space is
+// reused across loop iterations for logically distinct variables).
+//
+// We implement this with a static data-flow analysis of the AST.
+// First, we construct a directed weighted graph where vertices
+// (termed "locations") represent variables allocated by statements
+// and expressions, and edges represent assignments between variables
+// (with weights representing addressing/dereference counts).
+//
+// Next we walk the graph looking for assignment paths that might
+// violate the invariants stated above. If a variable v's address is
+// stored in the heap or elsewhere that may outlive it, then v is
+// marked as requiring heap allocation.
+//
+// To support interprocedural analysis, we also record data-flow from
+// each function's parameters to the heap and to its result
+// parameters. This information is summarized as "parameter tags",
+// which are used at static call sites to improve escape analysis of
+// function arguments.
+
+// Constructing the location graph.
+//
+// Every allocating statement (e.g., variable declaration) or
+// expression (e.g., "new" or "make") is first mapped to a unique
+// "location."
+//
+// We also model every Go assignment as a directed edges between
+// locations. The number of dereference operations minus the number of
+// addressing operations is recorded as the edge's weight (termed
+// "derefs"). For example:
+//
+//     p = &q    // -1
+//     p = q     //  0
+//     p = *q    //  1
+//     p = **q   //  2
+//
+//     p = **&**&q  // 2
+//
+// Note that the & operator can only be applied to addressable
+// expressions, and the expression &x itself is not addressable, so
+// derefs cannot go below -1.
+//
+// Every Go language construct is lowered into this representation,
+// generally without sensitivity to flow, path, or context; and
+// without distinguishing elements within a compound variable. For
+// example:
+//
+//     var x struct { f, g *int }
+//     var u []*int
+//
+//     x.f = u[0]
+//
+// is modeled simply as
+//
+//     x = *u
+//
+// That is, we don't distinguish x.f from x.g, or u[0] from u[1],
+// u[2], etc. However, we do record the implicit dereference involved
+// in indexing a slice.
+
+// A batch holds escape analysis state that's shared across an entire
+// batch of functions being analyzed at once.
+type batch struct {
+       allLocs  []*location
+       closures []closure
+
+       heapLoc  location
+       blankLoc location
+}
+
+// A closure holds a closure expression and its spill hole (i.e.,
+// where the hole representing storing into its closure record).
+type closure struct {
+       k   hole
+       clo *ir.ClosureExpr
+}
+
+// An escape holds state specific to a single function being analyzed
+// within a batch.
+type escape struct {
+       *batch
+
+       curfn *ir.Func // function being analyzed
+
+       labels map[*types.Sym]labelState // known labels
+
+       // loopDepth counts the current loop nesting depth within
+       // curfn. It increments within each "for" loop and at each
+       // label with a corresponding backwards "goto" (i.e.,
+       // unstructured loop).
+       loopDepth int
+}
+
+// An location represents an abstract location that stores a Go
+// variable.
+type location struct {
+       n         ir.Node  // represented variable or expression, if any
+       curfn     *ir.Func // enclosing function
+       edges     []edge   // incoming edges
+       loopDepth int      // loopDepth at declaration
+
+       // resultIndex records the tuple index (starting at 1) for
+       // PPARAMOUT variables within their function's result type.
+       // For non-PPARAMOUT variables it's 0.
+       resultIndex int
+
+       // derefs and walkgen are used during walkOne to track the
+       // minimal dereferences from the walk root.
+       derefs  int // >= -1
+       walkgen uint32
+
+       // dst and dstEdgeindex track the next immediate assignment
+       // destination location during walkone, along with the index
+       // of the edge pointing back to this location.
+       dst        *location
+       dstEdgeIdx int
+
+       // queued is used by walkAll to track whether this location is
+       // in the walk queue.
+       queued bool
+
+       // escapes reports whether the represented variable's address
+       // escapes; that is, whether the variable must be heap
+       // allocated.
+       escapes bool
+
+       // transient reports whether the represented expression's
+       // address does not outlive the statement; that is, whether
+       // its storage can be immediately reused.
+       transient bool
+
+       // paramEsc records the represented parameter's leak set.
+       paramEsc leaks
+
+       captured   bool // has a closure captured this variable?
+       reassigned bool // has this variable been reassigned?
+       addrtaken  bool // has this variable's address been taken?
+}
+
+// An edge represents an assignment edge between two Go variables.
+type edge struct {
+       src    *location
+       derefs int // >= -1
+       notes  *note
+}
+
+// Fmt is called from node printing to print information about escape analysis results.
+func Fmt(n ir.Node) string {
+       text := ""
+       switch n.Esc() {
+       case ir.EscUnknown:
+               break
+
+       case ir.EscHeap:
+               text = "esc(h)"
+
+       case ir.EscNone:
+               text = "esc(no)"
+
+       case ir.EscNever:
+               text = "esc(N)"
+
+       default:
+               text = fmt.Sprintf("esc(%d)", n.Esc())
+       }
+
+       if n.Op() == ir.ONAME {
+               n := n.(*ir.Name)
+               if loc, ok := n.Opt.(*location); ok && loc.loopDepth != 0 {
+                       if text != "" {
+                               text += " "
+                       }
+                       text += fmt.Sprintf("ld(%d)", loc.loopDepth)
+               }
+       }
+
+       return text
+}
+
+// Batch performs escape analysis on a minimal batch of
+// functions.
+func Batch(fns []*ir.Func, recursive bool) {
+       for _, fn := range fns {
+               if fn.Op() != ir.ODCLFUNC {
+                       base.Fatalf("unexpected node: %v", fn)
+               }
+       }
+
+       var b batch
+       b.heapLoc.escapes = true
+
+       // Construct data-flow graph from syntax trees.
+       for _, fn := range fns {
+               if base.Flag.W > 1 {
+                       s := fmt.Sprintf("\nbefore escape %v", fn)
+                       ir.Dump(s, fn)
+               }
+               b.initFunc(fn)
+       }
+       for _, fn := range fns {
+               if !fn.IsHiddenClosure() {
+                       b.walkFunc(fn)
+               }
+       }
+
+       // We've walked the function bodies, so we've seen everywhere a
+       // variable might be reassigned or have it's address taken. Now we
+       // can decide whether closures should capture their free variables
+       // by value or reference.
+       for _, closure := range b.closures {
+               b.flowClosure(closure.k, closure.clo)
+       }
+       b.closures = nil
+
+       for _, loc := range b.allLocs {
+               if why := HeapAllocReason(loc.n); why != "" {
+                       b.flow(b.heapHole().addr(loc.n, why), loc)
+               }
+       }
+
+       b.walkAll()
+       b.finish(fns)
+}
+
+func (b *batch) with(fn *ir.Func) *escape {
+       return &escape{
+               batch:     b,
+               curfn:     fn,
+               loopDepth: 1,
+       }
+}
+
+func (b *batch) initFunc(fn *ir.Func) {
+       e := b.with(fn)
+       if fn.Esc() != escFuncUnknown {
+               base.Fatalf("unexpected node: %v", fn)
+       }
+       fn.SetEsc(escFuncPlanned)
+       if base.Flag.LowerM > 3 {
+               ir.Dump("escAnalyze", fn)
+       }
+
+       // Allocate locations for local variables.
+       for _, n := range fn.Dcl {
+               if n.Op() == ir.ONAME {
+                       e.newLoc(n, false)
+               }
+       }
+
+       // Initialize resultIndex for result parameters.
+       for i, f := range fn.Type().Results().FieldSlice() {
+               e.oldLoc(f.Nname.(*ir.Name)).resultIndex = 1 + i
+       }
+}
+
+func (b *batch) walkFunc(fn *ir.Func) {
+       e := b.with(fn)
+       fn.SetEsc(escFuncStarted)
+
+       // Identify labels that mark the head of an unstructured loop.
+       ir.Visit(fn, func(n ir.Node) {
+               switch n.Op() {
+               case ir.OLABEL:
+                       n := n.(*ir.LabelStmt)
+                       if e.labels == nil {
+                               e.labels = make(map[*types.Sym]labelState)
+                       }
+                       e.labels[n.Label] = nonlooping
+
+               case ir.OGOTO:
+                       // If we visited the label before the goto,
+                       // then this is a looping label.
+                       n := n.(*ir.BranchStmt)
+                       if e.labels[n.Label] == nonlooping {
+                               e.labels[n.Label] = looping
+                       }
+               }
+       })
+
+       e.block(fn.Body)
+
+       if len(e.labels) != 0 {
+               base.FatalfAt(fn.Pos(), "leftover labels after walkFunc")
+       }
+}
+
+func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr) {
+       for _, cv := range clo.Func.ClosureVars {
+               n := cv.Canonical()
+               loc := b.oldLoc(cv)
+               if !loc.captured {
+                       base.FatalfAt(cv.Pos(), "closure variable never captured: %v", cv)
+               }
+
+               // Capture by value for variables <= 128 bytes that are never reassigned.
+               n.SetByval(!loc.addrtaken && !loc.reassigned && n.Type().Size() <= 128)
+               if !n.Byval() {
+                       n.SetAddrtaken(true)
+               }
+
+               if base.Flag.LowerM > 1 {
+                       how := "ref"
+                       if n.Byval() {
+                               how = "value"
+                       }
+                       base.WarnfAt(n.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", n.Curfn, how, n, loc.addrtaken, loc.reassigned, n.Type().Size())
+               }
+
+               // Flow captured variables to closure.
+               k := k
+               if !cv.Byval() {
+                       k = k.addr(cv, "reference")
+               }
+               b.flow(k.note(cv, "captured by a closure"), loc)
+       }
+}
+
+// Below we implement the methods for walking the AST and recording
+// data flow edges. Note that because a sub-expression might have
+// side-effects, it's important to always visit the entire AST.
+//
+// For example, write either:
+//
+//     if x {
+//         e.discard(n.Left)
+//     } else {
+//         e.value(k, n.Left)
+//     }
+//
+// or
+//
+//     if x {
+//         k = e.discardHole()
+//     }
+//     e.value(k, n.Left)
+//
+// Do NOT write:
+//
+//    // BAD: possibly loses side-effects within n.Left
+//    if !x {
+//        e.value(k, n.Left)
+//    }
+
+// stmt evaluates a single Go statement.
+func (e *escape) stmt(n ir.Node) {
+       if n == nil {
+               return
+       }
+
+       lno := ir.SetPos(n)
+       defer func() {
+               base.Pos = lno
+       }()
+
+       if base.Flag.LowerM > 2 {
+               fmt.Printf("%v:[%d] %v stmt: %v\n", base.FmtPos(base.Pos), e.loopDepth, e.curfn, n)
+       }
+
+       e.stmts(n.Init())
+
+       switch n.Op() {
+       default:
+               base.Fatalf("unexpected stmt: %v", n)
+
+       case ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL, ir.OINLMARK:
+               // nop
+
+       case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
+               // TODO(mdempsky): Handle dead code?
+
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
+               e.stmts(n.List)
+
+       case ir.ODCL:
+               // Record loop depth at declaration.
+               n := n.(*ir.Decl)
+               if !ir.IsBlank(n.X) {
+                       e.dcl(n.X)
+               }
+
+       case ir.OLABEL:
+               n := n.(*ir.LabelStmt)
+               switch e.labels[n.Label] {
+               case nonlooping:
+                       if base.Flag.LowerM > 2 {
+                               fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
+                       }
+               case looping:
+                       if base.Flag.LowerM > 2 {
+                               fmt.Printf("%v: %v looping label\n", base.FmtPos(base.Pos), n)
+                       }
+                       e.loopDepth++
+               default:
+                       base.Fatalf("label missing tag")
+               }
+               delete(e.labels, n.Label)
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               e.discard(n.Cond)
+               e.block(n.Body)
+               e.block(n.Else)
+
+       case ir.OFOR, ir.OFORUNTIL:
+               n := n.(*ir.ForStmt)
+               e.loopDepth++
+               e.discard(n.Cond)
+               e.stmt(n.Post)
+               e.block(n.Body)
+               e.loopDepth--
+
+       case ir.ORANGE:
+               // for Key, Value = range X { Body }
+               n := n.(*ir.RangeStmt)
+
+               // X is evaluated outside the loop.
+               tmp := e.newLoc(nil, false)
+               e.expr(tmp.asHole(), n.X)
+
+               e.loopDepth++
+               ks := e.addrs([]ir.Node{n.Key, n.Value})
+               if n.X.Type().IsArray() {
+                       e.flow(ks[1].note(n, "range"), tmp)
+               } else {
+                       e.flow(ks[1].deref(n, "range-deref"), tmp)
+               }
+               e.reassigned(ks, n)
+
+               e.block(n.Body)
+               e.loopDepth--
+
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+
+               if guard, ok := n.Tag.(*ir.TypeSwitchGuard); ok {
+                       var ks []hole
+                       if guard.Tag != nil {
+                               for _, cas := range n.Cases {
+                                       cv := cas.Var
+                                       k := e.dcl(cv) // type switch variables have no ODCL.
+                                       if cv.Type().HasPointers() {
+                                               ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
+                                       }
+                               }
+                       }
+                       e.expr(e.teeHole(ks...), n.Tag.(*ir.TypeSwitchGuard).X)
+               } else {
+                       e.discard(n.Tag)
+               }
+
+               for _, cas := range n.Cases {
+                       e.discards(cas.List)
+                       e.block(cas.Body)
+               }
+
+       case ir.OSELECT:
+               n := n.(*ir.SelectStmt)
+               for _, cas := range n.Cases {
+                       e.stmt(cas.Comm)
+                       e.block(cas.Body)
+               }
+       case ir.ORECV:
+               // TODO(mdempsky): Consider e.discard(n.Left).
+               n := n.(*ir.UnaryExpr)
+               e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
+       case ir.OSEND:
+               n := n.(*ir.SendStmt)
+               e.discard(n.Chan)
+               e.assignHeap(n.Value, "send", n)
+
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               e.assignList([]ir.Node{n.X}, []ir.Node{n.Y}, "assign", n)
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               // TODO(mdempsky): Worry about OLSH/ORSH?
+               e.assignList([]ir.Node{n.X}, []ir.Node{n.Y}, "assign", n)
+       case ir.OAS2:
+               n := n.(*ir.AssignListStmt)
+               e.assignList(n.Lhs, n.Rhs, "assign-pair", n)
+
+       case ir.OAS2DOTTYPE: // v, ok = x.(type)
+               n := n.(*ir.AssignListStmt)
+               e.assignList(n.Lhs, n.Rhs, "assign-pair-dot-type", n)
+       case ir.OAS2MAPR: // v, ok = m[k]
+               n := n.(*ir.AssignListStmt)
+               e.assignList(n.Lhs, n.Rhs, "assign-pair-mapr", n)
+       case ir.OAS2RECV, ir.OSELRECV2: // v, ok = <-ch
+               n := n.(*ir.AssignListStmt)
+               e.assignList(n.Lhs, n.Rhs, "assign-pair-receive", n)
+
+       case ir.OAS2FUNC:
+               n := n.(*ir.AssignListStmt)
+               e.stmts(n.Rhs[0].Init())
+               ks := e.addrs(n.Lhs)
+               e.call(ks, n.Rhs[0], nil)
+               e.reassigned(ks, n)
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               results := e.curfn.Type().Results().FieldSlice()
+               dsts := make([]ir.Node, len(results))
+               for i, res := range results {
+                       dsts[i] = res.Nname.(*ir.Name)
+               }
+               e.assignList(dsts, n.Results, "return", n)
+       case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+               e.call(nil, n, nil)
+       case ir.OGO, ir.ODEFER:
+               n := n.(*ir.GoDeferStmt)
+               e.stmts(n.Call.Init())
+               e.call(nil, n.Call, n)
+
+       case ir.OTAILCALL:
+               // TODO(mdempsky): Treat like a normal call? esc.go used to just ignore it.
+       }
+}
+
+func (e *escape) stmts(l ir.Nodes) {
+       for _, n := range l {
+               e.stmt(n)
+       }
+}
+
+// block is like stmts, but preserves loopDepth.
+func (e *escape) block(l ir.Nodes) {
+       old := e.loopDepth
+       e.stmts(l)
+       e.loopDepth = old
+}
+
+// expr models evaluating an expression n and flowing the result into
+// hole k.
+func (e *escape) expr(k hole, n ir.Node) {
+       if n == nil {
+               return
+       }
+       e.stmts(n.Init())
+       e.exprSkipInit(k, n)
+}
+
+func (e *escape) exprSkipInit(k hole, n ir.Node) {
+       if n == nil {
+               return
+       }
+
+       lno := ir.SetPos(n)
+       defer func() {
+               base.Pos = lno
+       }()
+
+       uintptrEscapesHack := k.uintptrEscapesHack
+       k.uintptrEscapesHack = false
+
+       if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
+               // nop
+       } else if k.derefs >= 0 && !n.Type().HasPointers() {
+               k.dst = &e.blankLoc
+       }
+
+       switch n.Op() {
+       default:
+               base.Fatalf("unexpected expr: %v", n)
+
+       case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR, ir.OLINKSYMOFFSET:
+               // nop
+
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Class == ir.PFUNC || n.Class == ir.PEXTERN {
+                       return
+               }
+               if n.IsClosureVar() && n.Defn == nil {
+                       return // ".this" from method value wrapper
+               }
+               e.flow(k, e.oldLoc(n))
+
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+               n := n.(*ir.UnaryExpr)
+               e.discard(n.X)
+       case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+               n := n.(*ir.BinaryExpr)
+               e.discard(n.X)
+               e.discard(n.Y)
+       case ir.OANDAND, ir.OOROR:
+               n := n.(*ir.LogicalExpr)
+               e.discard(n.X)
+               e.discard(n.Y)
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               e.expr(k.addr(n, "address-of"), n.X) // "address-of"
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               e.expr(k.deref(n, "indirection"), n.X) // "indirection"
+       case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
+               n := n.(*ir.SelectorExpr)
+               e.expr(k.note(n, "dot"), n.X)
+       case ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               e.expr(k.deref(n, "dot of pointer"), n.X) // "dot of pointer"
+       case ir.ODOTTYPE, ir.ODOTTYPE2:
+               n := n.(*ir.TypeAssertExpr)
+               e.expr(k.dotType(n.Type(), n, "dot"), n.X)
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               if n.X.Type().IsArray() {
+                       e.expr(k.note(n, "fixed-array-index-of"), n.X)
+               } else {
+                       // TODO(mdempsky): Fix why reason text.
+                       e.expr(k.deref(n, "dot of pointer"), n.X)
+               }
+               e.discard(n.Index)
+       case ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               e.discard(n.X)
+               e.discard(n.Index)
+       case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
+               n := n.(*ir.SliceExpr)
+               e.expr(k.note(n, "slice"), n.X)
+               e.discard(n.Low)
+               e.discard(n.High)
+               e.discard(n.Max)
+
+       case ir.OCONV, ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               if ir.ShouldCheckPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.X.Type().IsPtr() {
+                       // When -d=checkptr=2 is enabled, treat
+                       // conversions to unsafe.Pointer as an
+                       // escaping operation. This allows better
+                       // runtime instrumentation, since we can more
+                       // easily detect object boundaries on the heap
+                       // than the stack.
+                       e.assignHeap(n.X, "conversion to unsafe.Pointer", n)
+               } else if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() {
+                       e.unsafeValue(k, n.X)
+               } else {
+                       e.expr(k, n.X)
+               }
+       case ir.OCONVIFACE:
+               n := n.(*ir.ConvExpr)
+               if !n.X.Type().IsInterface() && !types.IsDirectIface(n.X.Type()) {
+                       k = e.spill(k, n)
+               }
+               e.expr(k.note(n, "interface-converted"), n.X)
+
+       case ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               e.discard(n.X)
+
+       case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
+               e.call([]hole{k}, n, nil)
+
+       case ir.ONEW:
+               n := n.(*ir.UnaryExpr)
+               e.spill(k, n)
+
+       case ir.OMAKESLICE:
+               n := n.(*ir.MakeExpr)
+               e.spill(k, n)
+               e.discard(n.Len)
+               e.discard(n.Cap)
+       case ir.OMAKECHAN:
+               n := n.(*ir.MakeExpr)
+               e.discard(n.Len)
+       case ir.OMAKEMAP:
+               n := n.(*ir.MakeExpr)
+               e.spill(k, n)
+               e.discard(n.Len)
+
+       case ir.ORECOVER:
+               // nop
+
+       case ir.OCALLPART:
+               // Flow the receiver argument to both the closure and
+               // to the receiver parameter.
+
+               n := n.(*ir.SelectorExpr)
+               closureK := e.spill(k, n)
+
+               m := n.Selection
+
+               // We don't know how the method value will be called
+               // later, so conservatively assume the result
+               // parameters all flow to the heap.
+               //
+               // TODO(mdempsky): Change ks into a callback, so that
+               // we don't have to create this slice?
+               var ks []hole
+               for i := m.Type.NumResults(); i > 0; i-- {
+                       ks = append(ks, e.heapHole())
+               }
+               name, _ := m.Nname.(*ir.Name)
+               paramK := e.tagHole(ks, name, m.Type.Recv())
+
+               e.expr(e.teeHole(paramK, closureK), n.X)
+
+       case ir.OPTRLIT:
+               n := n.(*ir.AddrExpr)
+               e.expr(e.spill(k, n), n.X)
+
+       case ir.OARRAYLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, elt := range n.List {
+                       if elt.Op() == ir.OKEY {
+                               elt = elt.(*ir.KeyExpr).Value
+                       }
+                       e.expr(k.note(n, "array literal element"), elt)
+               }
+
+       case ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               k = e.spill(k, n)
+               k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
+
+               for _, elt := range n.List {
+                       if elt.Op() == ir.OKEY {
+                               elt = elt.(*ir.KeyExpr).Value
+                       }
+                       e.expr(k.note(n, "slice-literal-element"), elt)
+               }
+
+       case ir.OSTRUCTLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, elt := range n.List {
+                       e.expr(k.note(n, "struct literal element"), elt.(*ir.StructKeyExpr).Value)
+               }
+
+       case ir.OMAPLIT:
+               n := n.(*ir.CompLitExpr)
+               e.spill(k, n)
+
+               // Map keys and values are always stored in the heap.
+               for _, elt := range n.List {
+                       elt := elt.(*ir.KeyExpr)
+                       e.assignHeap(elt.Key, "map literal key", n)
+                       e.assignHeap(elt.Value, "map literal value", n)
+               }
+
+       case ir.OCLOSURE:
+               n := n.(*ir.ClosureExpr)
+               k = e.spill(k, n)
+               e.closures = append(e.closures, closure{k, n})
+
+               if fn := n.Func; fn.IsHiddenClosure() {
+                       for _, cv := range fn.ClosureVars {
+                               if loc := e.oldLoc(cv); !loc.captured {
+                                       loc.captured = true
+
+                                       // Ignore reassignments to the variable in straightline code
+                                       // preceding the first capture by a closure.
+                                       if loc.loopDepth == e.loopDepth {
+                                               loc.reassigned = false
+                                       }
+                               }
+                       }
+
+                       for _, n := range fn.Dcl {
+                               // Add locations for local variables of the
+                               // closure, if needed, in case we're not including
+                               // the closure func in the batch for escape
+                               // analysis (happens for escape analysis called
+                               // from reflectdata.methodWrapper)
+                               if n.Op() == ir.ONAME && n.Opt == nil {
+                                       e.with(fn).newLoc(n, false)
+                               }
+                       }
+                       e.walkFunc(fn)
+               }
+
+       case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
+               n := n.(*ir.ConvExpr)
+               e.spill(k, n)
+               e.discard(n.X)
+
+       case ir.OADDSTR:
+               n := n.(*ir.AddStringExpr)
+               e.spill(k, n)
+
+               // Arguments of OADDSTR never escape;
+               // runtime.concatstrings makes sure of that.
+               e.discards(n.List)
+       }
+}
+
+// unsafeValue evaluates a uintptr-typed arithmetic expression looking
+// for conversions from an unsafe.Pointer.
+func (e *escape) unsafeValue(k hole, n ir.Node) {
+       if n.Type().Kind() != types.TUINTPTR {
+               base.Fatalf("unexpected type %v for %v", n.Type(), n)
+       }
+       if k.addrtaken {
+               base.Fatalf("unexpected addrtaken")
+       }
+
+       e.stmts(n.Init())
+
+       switch n.Op() {
+       case ir.OCONV, ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               if n.X.Type().IsUnsafePtr() {
+                       e.expr(k, n.X)
+               } else {
+                       e.discard(n.X)
+               }
+       case ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               if ir.IsReflectHeaderDataField(n) {
+                       e.expr(k.deref(n, "reflect.Header.Data"), n.X)
+               } else {
+                       e.discard(n.X)
+               }
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT:
+               n := n.(*ir.UnaryExpr)
+               e.unsafeValue(k, n.X)
+       case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OAND, ir.OANDNOT:
+               n := n.(*ir.BinaryExpr)
+               e.unsafeValue(k, n.X)
+               e.unsafeValue(k, n.Y)
+       case ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               e.unsafeValue(k, n.X)
+               // RHS need not be uintptr-typed (#32959) and can't meaningfully
+               // flow pointers anyway.
+               e.discard(n.Y)
+       default:
+               e.exprSkipInit(e.discardHole(), n)
+       }
+}
+
+// discard evaluates an expression n for side-effects, but discards
+// its value.
+func (e *escape) discard(n ir.Node) {
+       e.expr(e.discardHole(), n)
+}
+
+func (e *escape) discards(l ir.Nodes) {
+       for _, n := range l {
+               e.discard(n)
+       }
+}
+
+// addr evaluates an addressable expression n and returns a hole
+// that represents storing into the represented location.
+func (e *escape) addr(n ir.Node) hole {
+       if n == nil || ir.IsBlank(n) {
+               // Can happen in select case, range, maybe others.
+               return e.discardHole()
+       }
+
+       k := e.heapHole()
+
+       switch n.Op() {
+       default:
+               base.Fatalf("unexpected addr: %v", n)
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Class == ir.PEXTERN {
+                       break
+               }
+               k = e.oldLoc(n).asHole()
+       case ir.OLINKSYMOFFSET:
+               break
+       case ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               k = e.addr(n.X)
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               e.discard(n.Index)
+               if n.X.Type().IsArray() {
+                       k = e.addr(n.X)
+               } else {
+                       e.discard(n.X)
+               }
+       case ir.ODEREF, ir.ODOTPTR:
+               e.discard(n)
+       case ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               e.discard(n.X)
+               e.assignHeap(n.Index, "key of map put", n)
+       }
+
+       return k
+}
+
+func (e *escape) addrs(l ir.Nodes) []hole {
+       var ks []hole
+       for _, n := range l {
+               ks = append(ks, e.addr(n))
+       }
+       return ks
+}
+
+// reassigned marks the locations associated with the given holes as
+// reassigned, unless the location represents a variable declared and
+// assigned exactly once by where.
+func (e *escape) reassigned(ks []hole, where ir.Node) {
+       if as, ok := where.(*ir.AssignStmt); ok && as.Op() == ir.OAS && as.Y == nil {
+               if dst, ok := as.X.(*ir.Name); ok && dst.Op() == ir.ONAME && dst.Defn == nil {
+                       // Zero-value assignment for variable declared without an
+                       // explicit initial value. Assume this is its initialization
+                       // statement.
+                       return
+               }
+       }
+
+       for _, k := range ks {
+               loc := k.dst
+               // Variables declared by range statements are assigned on every iteration.
+               if n, ok := loc.n.(*ir.Name); ok && n.Defn == where && where.Op() != ir.ORANGE {
+                       continue
+               }
+               loc.reassigned = true
+       }
+}
+
+// assignList evaluates the assignment dsts... = srcs....
+func (e *escape) assignList(dsts, srcs []ir.Node, why string, where ir.Node) {
+       ks := e.addrs(dsts)
+       for i, k := range ks {
+               var src ir.Node
+               if i < len(srcs) {
+                       src = srcs[i]
+               }
+
+               if dst := dsts[i]; dst != nil {
+                       // Detect implicit conversion of uintptr to unsafe.Pointer when
+                       // storing into reflect.{Slice,String}Header.
+                       if dst.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(dst) {
+                               e.unsafeValue(e.heapHole().note(where, why), src)
+                               continue
+                       }
+
+                       // Filter out some no-op assignments for escape analysis.
+                       if src != nil && isSelfAssign(dst, src) {
+                               if base.Flag.LowerM != 0 {
+                                       base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %v", e.curfn, where)
+                               }
+                               k = e.discardHole()
+                       }
+               }
+
+               e.expr(k.note(where, why), src)
+       }
+
+       e.reassigned(ks, where)
+}
+
+func (e *escape) assignHeap(src ir.Node, why string, where ir.Node) {
+       e.expr(e.heapHole().note(where, why), src)
+}
+
+// call evaluates a call expressions, including builtin calls. ks
+// should contain the holes representing where the function callee's
+// results flows; where is the OGO/ODEFER context of the call, if any.
+func (e *escape) call(ks []hole, call, where ir.Node) {
+       topLevelDefer := where != nil && where.Op() == ir.ODEFER && e.loopDepth == 1
+       if topLevelDefer {
+               // force stack allocation of defer record, unless
+               // open-coded defers are used (see ssa.go)
+               where.SetEsc(ir.EscNever)
+       }
+
+       argument := func(k hole, arg ir.Node) {
+               if topLevelDefer {
+                       // Top level defers arguments don't escape to
+                       // heap, but they do need to last until end of
+                       // function.
+                       k = e.later(k)
+               } else if where != nil {
+                       k = e.heapHole()
+               }
+
+               e.expr(k.note(call, "call parameter"), arg)
+       }
+
+       switch call.Op() {
+       default:
+               ir.Dump("esc", call)
+               base.Fatalf("unexpected call op: %v", call.Op())
+
+       case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+               call := call.(*ir.CallExpr)
+               typecheck.FixVariadicCall(call)
+
+               // Pick out the function callee, if statically known.
+               var fn *ir.Name
+               switch call.Op() {
+               case ir.OCALLFUNC:
+                       switch v := ir.StaticValue(call.X); {
+                       case v.Op() == ir.ONAME && v.(*ir.Name).Class == ir.PFUNC:
+                               fn = v.(*ir.Name)
+                       case v.Op() == ir.OCLOSURE:
+                               fn = v.(*ir.ClosureExpr).Func.Nname
+                       }
+               case ir.OCALLMETH:
+                       fn = ir.MethodExprName(call.X)
+               }
+
+               fntype := call.X.Type()
+               if fn != nil {
+                       fntype = fn.Type()
+               }
+
+               if ks != nil && fn != nil && e.inMutualBatch(fn) {
+                       for i, result := range fn.Type().Results().FieldSlice() {
+                               e.expr(ks[i], ir.AsNode(result.Nname))
+                       }
+               }
+
+               if r := fntype.Recv(); r != nil {
+                       argument(e.tagHole(ks, fn, r), call.X.(*ir.SelectorExpr).X)
+               } else {
+                       // Evaluate callee function expression.
+                       argument(e.discardHole(), call.X)
+               }
+
+               args := call.Args
+               for i, param := range fntype.Params().FieldSlice() {
+                       argument(e.tagHole(ks, fn, param), args[i])
+               }
+
+       case ir.OAPPEND:
+               call := call.(*ir.CallExpr)
+               args := call.Args
+
+               // Appendee slice may flow directly to the result, if
+               // it has enough capacity. Alternatively, a new heap
+               // slice might be allocated, and all slice elements
+               // might flow to heap.
+               appendeeK := ks[0]
+               if args[0].Type().Elem().HasPointers() {
+                       appendeeK = e.teeHole(appendeeK, e.heapHole().deref(call, "appendee slice"))
+               }
+               argument(appendeeK, args[0])
+
+               if call.IsDDD {
+                       appendedK := e.discardHole()
+                       if args[1].Type().IsSlice() && args[1].Type().Elem().HasPointers() {
+                               appendedK = e.heapHole().deref(call, "appended slice...")
+                       }
+                       argument(appendedK, args[1])
+               } else {
+                       for _, arg := range args[1:] {
+                               argument(e.heapHole(), arg)
+                       }
+               }
+
+       case ir.OCOPY:
+               call := call.(*ir.BinaryExpr)
+               argument(e.discardHole(), call.X)
+
+               copiedK := e.discardHole()
+               if call.Y.Type().IsSlice() && call.Y.Type().Elem().HasPointers() {
+                       copiedK = e.heapHole().deref(call, "copied slice")
+               }
+               argument(copiedK, call.Y)
+
+       case ir.OPANIC:
+               call := call.(*ir.UnaryExpr)
+               argument(e.heapHole(), call.X)
+
+       case ir.OCOMPLEX:
+               call := call.(*ir.BinaryExpr)
+               argument(e.discardHole(), call.X)
+               argument(e.discardHole(), call.Y)
+       case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+               call := call.(*ir.CallExpr)
+               for _, arg := range call.Args {
+                       argument(e.discardHole(), arg)
+               }
+       case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
+               call := call.(*ir.UnaryExpr)
+               argument(e.discardHole(), call.X)
+       }
+}
+
+// tagHole returns a hole for evaluating an argument passed to param.
+// ks should contain the holes representing where the function
+// callee's results flows. fn is the statically-known callee function,
+// if any.
+func (e *escape) tagHole(ks []hole, fn *ir.Name, param *types.Field) hole {
+       // If this is a dynamic call, we can't rely on param.Note.
+       if fn == nil {
+               return e.heapHole()
+       }
+
+       if e.inMutualBatch(fn) {
+               return e.addr(ir.AsNode(param.Nname))
+       }
+
+       // Call to previously tagged function.
+
+       if param.Note == UintptrEscapesNote {
+               k := e.heapHole()
+               k.uintptrEscapesHack = true
+               return k
+       }
+
+       var tagKs []hole
+
+       esc := parseLeaks(param.Note)
+       if x := esc.Heap(); x >= 0 {
+               tagKs = append(tagKs, e.heapHole().shift(x))
+       }
+
+       if ks != nil {
+               for i := 0; i < numEscResults; i++ {
+                       if x := esc.Result(i); x >= 0 {
+                               tagKs = append(tagKs, ks[i].shift(x))
+                       }
+               }
+       }
+
+       return e.teeHole(tagKs...)
+}
+
+// inMutualBatch reports whether function fn is in the batch of
+// mutually recursive functions being analyzed. When this is true,
+// fn has not yet been analyzed, so its parameters and results
+// should be incorporated directly into the flow graph instead of
+// relying on its escape analysis tagging.
+func (e *escape) inMutualBatch(fn *ir.Name) bool {
+       if fn.Defn != nil && fn.Defn.Esc() < escFuncTagged {
+               if fn.Defn.Esc() == escFuncUnknown {
+                       base.Fatalf("graph inconsistency: %v", fn)
+               }
+               return true
+       }
+       return false
+}
+
+// An hole represents a context for evaluation a Go
+// expression. E.g., when evaluating p in "x = **p", we'd have a hole
+// with dst==x and derefs==2.
+type hole struct {
+       dst    *location
+       derefs int // >= -1
+       notes  *note
+
+       // addrtaken indicates whether this context is taking the address of
+       // the expression, independent of whether the address will actually
+       // be stored into a variable.
+       addrtaken bool
+
+       // uintptrEscapesHack indicates this context is evaluating an
+       // argument for a //go:uintptrescapes function.
+       uintptrEscapesHack bool
+}
+
+type note struct {
+       next  *note
+       where ir.Node
+       why   string
+}
+
+func (k hole) note(where ir.Node, why string) hole {
+       if where == nil || why == "" {
+               base.Fatalf("note: missing where/why")
+       }
+       if base.Flag.LowerM >= 2 || logopt.Enabled() {
+               k.notes = &note{
+                       next:  k.notes,
+                       where: where,
+                       why:   why,
+               }
+       }
+       return k
+}
+
+func (k hole) shift(delta int) hole {
+       k.derefs += delta
+       if k.derefs < -1 {
+               base.Fatalf("derefs underflow: %v", k.derefs)
+       }
+       k.addrtaken = delta < 0
+       return k
+}
+
+func (k hole) deref(where ir.Node, why string) hole { return k.shift(1).note(where, why) }
+func (k hole) addr(where ir.Node, why string) hole  { return k.shift(-1).note(where, why) }
+
+func (k hole) dotType(t *types.Type, where ir.Node, why string) hole {
+       if !t.IsInterface() && !types.IsDirectIface(t) {
+               k = k.shift(1)
+       }
+       return k.note(where, why)
+}
+
+// teeHole returns a new hole that flows into each hole of ks,
+// similar to the Unix tee(1) command.
+func (e *escape) teeHole(ks ...hole) hole {
+       if len(ks) == 0 {
+               return e.discardHole()
+       }
+       if len(ks) == 1 {
+               return ks[0]
+       }
+       // TODO(mdempsky): Optimize if there's only one non-discard hole?
+
+       // Given holes "l1 = _", "l2 = **_", "l3 = *_", ..., create a
+       // new temporary location ltmp, wire it into place, and return
+       // a hole for "ltmp = _".
+       loc := e.newLoc(nil, true)
+       for _, k := range ks {
+               // N.B., "p = &q" and "p = &tmp; tmp = q" are not
+               // semantically equivalent. To combine holes like "l1
+               // = _" and "l2 = &_", we'd need to wire them as "l1 =
+               // *ltmp" and "l2 = ltmp" and return "ltmp = &_"
+               // instead.
+               if k.derefs < 0 {
+                       base.Fatalf("teeHole: negative derefs")
+               }
+
+               e.flow(k, loc)
+       }
+       return loc.asHole()
+}
+
+func (e *escape) dcl(n *ir.Name) hole {
+       if n.Curfn != e.curfn || n.IsClosureVar() {
+               base.Fatalf("bad declaration of %v", n)
+       }
+       loc := e.oldLoc(n)
+       loc.loopDepth = e.loopDepth
+       return loc.asHole()
+}
+
+// spill allocates a new location associated with expression n, flows
+// its address to k, and returns a hole that flows values to it. It's
+// intended for use with most expressions that allocate storage.
+func (e *escape) spill(k hole, n ir.Node) hole {
+       loc := e.newLoc(n, true)
+       e.flow(k.addr(n, "spill"), loc)
+       return loc.asHole()
+}
+
+// later returns a new hole that flows into k, but some time later.
+// Its main effect is to prevent immediate reuse of temporary
+// variables introduced during Order.
+func (e *escape) later(k hole) hole {
+       loc := e.newLoc(nil, false)
+       e.flow(k, loc)
+       return loc.asHole()
+}
+
+func (e *escape) newLoc(n ir.Node, transient bool) *location {
+       if e.curfn == nil {
+               base.Fatalf("e.curfn isn't set")
+       }
+       if n != nil && n.Type() != nil && n.Type().NotInHeap() {
+               base.ErrorfAt(n.Pos(), "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type())
+       }
+
+       if n != nil && n.Op() == ir.ONAME {
+               n = n.(*ir.Name).Canonical()
+       }
+       loc := &location{
+               n:         n,
+               curfn:     e.curfn,
+               loopDepth: e.loopDepth,
+               transient: transient,
+       }
+       e.allLocs = append(e.allLocs, loc)
+       if n != nil {
+               if n.Op() == ir.ONAME {
+                       n := n.(*ir.Name)
+                       if n.Curfn != e.curfn {
+                               base.Fatalf("curfn mismatch: %v != %v", n.Curfn, e.curfn)
+                       }
+
+                       if n.Opt != nil {
+                               base.Fatalf("%v already has a location", n)
+                       }
+                       n.Opt = loc
+               }
+       }
+       return loc
+}
+
+func (b *batch) oldLoc(n *ir.Name) *location {
+       return n.Canonical().Opt.(*location)
+}
+
+func (l *location) asHole() hole {
+       return hole{dst: l}
+}
+
+func (b *batch) flow(k hole, src *location) {
+       if k.addrtaken {
+               src.addrtaken = true
+       }
+
+       dst := k.dst
+       if dst == &b.blankLoc {
+               return
+       }
+       if dst == src && k.derefs >= 0 { // dst = dst, dst = *dst, ...
+               return
+       }
+       if dst.escapes && k.derefs < 0 { // dst = &src
+               if base.Flag.LowerM >= 2 || logopt.Enabled() {
+                       pos := base.FmtPos(src.n.Pos())
+                       if base.Flag.LowerM >= 2 {
+                               fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
+                       }
+                       explanation := b.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
+                       if logopt.Enabled() {
+                               var e_curfn *ir.Func // TODO(mdempsky): Fix.
+                               logopt.LogOpt(src.n.Pos(), "escapes", "escape", ir.FuncName(e_curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
+                       }
+
+               }
+               src.escapes = true
+               return
+       }
+
+       // TODO(mdempsky): Deduplicate edges?
+       dst.edges = append(dst.edges, edge{src: src, derefs: k.derefs, notes: k.notes})
+}
+
+func (b *batch) heapHole() hole    { return b.heapLoc.asHole() }
+func (b *batch) discardHole() hole { return b.blankLoc.asHole() }
+
+// walkAll computes the minimal dereferences between all pairs of
+// locations.
+func (b *batch) walkAll() {
+       // We use a work queue to keep track of locations that we need
+       // to visit, and repeatedly walk until we reach a fixed point.
+       //
+       // We walk once from each location (including the heap), and
+       // then re-enqueue each location on its transition from
+       // transient->!transient and !escapes->escapes, which can each
+       // happen at most once. So we take Θ(len(e.allLocs)) walks.
+
+       // LIFO queue, has enough room for e.allLocs and e.heapLoc.
+       todo := make([]*location, 0, len(b.allLocs)+1)
+       enqueue := func(loc *location) {
+               if !loc.queued {
+                       todo = append(todo, loc)
+                       loc.queued = true
+               }
+       }
+
+       for _, loc := range b.allLocs {
+               enqueue(loc)
+       }
+       enqueue(&b.heapLoc)
+
+       var walkgen uint32
+       for len(todo) > 0 {
+               root := todo[len(todo)-1]
+               todo = todo[:len(todo)-1]
+               root.queued = false
+
+               walkgen++
+               b.walkOne(root, walkgen, enqueue)
+       }
+}
+
+// walkOne computes the minimal number of dereferences from root to
+// all other locations.
+func (b *batch) walkOne(root *location, walkgen uint32, enqueue func(*location)) {
+       // The data flow graph has negative edges (from addressing
+       // operations), so we use the Bellman-Ford algorithm. However,
+       // we don't have to worry about infinite negative cycles since
+       // we bound intermediate dereference counts to 0.
+
+       root.walkgen = walkgen
+       root.derefs = 0
+       root.dst = nil
+
+       todo := []*location{root} // LIFO queue
+       for len(todo) > 0 {
+               l := todo[len(todo)-1]
+               todo = todo[:len(todo)-1]
+
+               derefs := l.derefs
+
+               // If l.derefs < 0, then l's address flows to root.
+               addressOf := derefs < 0
+               if addressOf {
+                       // For a flow path like "root = &l; l = x",
+                       // l's address flows to root, but x's does
+                       // not. We recognize this by lower bounding
+                       // derefs at 0.
+                       derefs = 0
+
+                       // If l's address flows to a non-transient
+                       // location, then l can't be transiently
+                       // allocated.
+                       if !root.transient && l.transient {
+                               l.transient = false
+                               enqueue(l)
+                       }
+               }
+
+               if b.outlives(root, l) {
+                       // l's value flows to root. If l is a function
+                       // parameter and root is the heap or a
+                       // corresponding result parameter, then record
+                       // that value flow for tagging the function
+                       // later.
+                       if l.isName(ir.PPARAM) {
+                               if (logopt.Enabled() || base.Flag.LowerM >= 2) && !l.escapes {
+                                       if base.Flag.LowerM >= 2 {
+                                               fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos()), l.n, b.explainLoc(root), derefs)
+                                       }
+                                       explanation := b.explainPath(root, l)
+                                       if logopt.Enabled() {
+                                               var e_curfn *ir.Func // TODO(mdempsky): Fix.
+                                               logopt.LogOpt(l.n.Pos(), "leak", "escape", ir.FuncName(e_curfn),
+                                                       fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, b.explainLoc(root), derefs), explanation)
+                                       }
+                               }
+                               l.leakTo(root, derefs)
+                       }
+
+                       // If l's address flows somewhere that
+                       // outlives it, then l needs to be heap
+                       // allocated.
+                       if addressOf && !l.escapes {
+                               if logopt.Enabled() || base.Flag.LowerM >= 2 {
+                                       if base.Flag.LowerM >= 2 {
+                                               fmt.Printf("%s: %v escapes to heap:\n", base.FmtPos(l.n.Pos()), l.n)
+                                       }
+                                       explanation := b.explainPath(root, l)
+                                       if logopt.Enabled() {
+                                               var e_curfn *ir.Func // TODO(mdempsky): Fix.
+                                               logopt.LogOpt(l.n.Pos(), "escape", "escape", ir.FuncName(e_curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
+                                       }
+                               }
+                               l.escapes = true
+                               enqueue(l)
+                               continue
+                       }
+               }
+
+               for i, edge := range l.edges {
+                       if edge.src.escapes {
+                               continue
+                       }
+                       d := derefs + edge.derefs
+                       if edge.src.walkgen != walkgen || edge.src.derefs > d {
+                               edge.src.walkgen = walkgen
+                               edge.src.derefs = d
+                               edge.src.dst = l
+                               edge.src.dstEdgeIdx = i
+                               todo = append(todo, edge.src)
+                       }
+               }
+       }
+}
+
+// explainPath prints an explanation of how src flows to the walk root.
+func (b *batch) explainPath(root, src *location) []*logopt.LoggedOpt {
+       visited := make(map[*location]bool)
+       pos := base.FmtPos(src.n.Pos())
+       var explanation []*logopt.LoggedOpt
+       for {
+               // Prevent infinite loop.
+               if visited[src] {
+                       if base.Flag.LowerM >= 2 {
+                               fmt.Printf("%s:   warning: truncated explanation due to assignment cycle; see golang.org/issue/35518\n", pos)
+                       }
+                       break
+               }
+               visited[src] = true
+               dst := src.dst
+               edge := &dst.edges[src.dstEdgeIdx]
+               if edge.src != src {
+                       base.Fatalf("path inconsistency: %v != %v", edge.src, src)
+               }
+
+               explanation = b.explainFlow(pos, dst, src, edge.derefs, edge.notes, explanation)
+
+               if dst == root {
+                       break
+               }
+               src = dst
+       }
+
+       return explanation
+}
+
+func (b *batch) explainFlow(pos string, dst, srcloc *location, derefs int, notes *note, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
+       ops := "&"
+       if derefs >= 0 {
+               ops = strings.Repeat("*", derefs)
+       }
+       print := base.Flag.LowerM >= 2
+
+       flow := fmt.Sprintf("   flow: %s = %s%v:", b.explainLoc(dst), ops, b.explainLoc(srcloc))
+       if print {
+               fmt.Printf("%s:%s\n", pos, flow)
+       }
+       if logopt.Enabled() {
+               var epos src.XPos
+               if notes != nil {
+                       epos = notes.where.Pos()
+               } else if srcloc != nil && srcloc.n != nil {
+                       epos = srcloc.n.Pos()
+               }
+               var e_curfn *ir.Func // TODO(mdempsky): Fix.
+               explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", ir.FuncName(e_curfn), flow))
+       }
+
+       for note := notes; note != nil; note = note.next {
+               if print {
+                       fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos()))
+               }
+               if logopt.Enabled() {
+                       var e_curfn *ir.Func // TODO(mdempsky): Fix.
+                       explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos(), "escflow", "escape", ir.FuncName(e_curfn),
+                               fmt.Sprintf("     from %v (%v)", note.where, note.why)))
+               }
+       }
+       return explanation
+}
+
+func (b *batch) explainLoc(l *location) string {
+       if l == &b.heapLoc {
+               return "{heap}"
+       }
+       if l.n == nil {
+               // TODO(mdempsky): Omit entirely.
+               return "{temp}"
+       }
+       if l.n.Op() == ir.ONAME {
+               return fmt.Sprintf("%v", l.n)
+       }
+       return fmt.Sprintf("{storage for %v}", l.n)
+}
+
+// outlives reports whether values stored in l may survive beyond
+// other's lifetime if stack allocated.
+func (b *batch) outlives(l, other *location) bool {
+       // The heap outlives everything.
+       if l.escapes {
+               return true
+       }
+
+       // We don't know what callers do with returned values, so
+       // pessimistically we need to assume they flow to the heap and
+       // outlive everything too.
+       if l.isName(ir.PPARAMOUT) {
+               // Exception: Directly called closures can return
+               // locations allocated outside of them without forcing
+               // them to the heap. For example:
+               //
+               //    var u int  // okay to stack allocate
+               //    *(func() *int { return &u }()) = 42
+               if containsClosure(other.curfn, l.curfn) && l.curfn.ClosureCalled() {
+                       return false
+               }
+
+               return true
+       }
+
+       // If l and other are within the same function, then l
+       // outlives other if it was declared outside other's loop
+       // scope. For example:
+       //
+       //    var l *int
+       //    for {
+       //        l = new(int)
+       //    }
+       if l.curfn == other.curfn && l.loopDepth < other.loopDepth {
+               return true
+       }
+
+       // If other is declared within a child closure of where l is
+       // declared, then l outlives it. For example:
+       //
+       //    var l *int
+       //    func() {
+       //        l = new(int)
+       //    }
+       if containsClosure(l.curfn, other.curfn) {
+               return true
+       }
+
+       return false
+}
+
+// containsClosure reports whether c is a closure contained within f.
+func containsClosure(f, c *ir.Func) bool {
+       // Common case.
+       if f == c {
+               return false
+       }
+
+       // Closures within function Foo are named like "Foo.funcN..."
+       // TODO(mdempsky): Better way to recognize this.
+       fn := f.Sym().Name
+       cn := c.Sym().Name
+       return len(cn) > len(fn) && cn[:len(fn)] == fn && cn[len(fn)] == '.'
+}
+
+// leak records that parameter l leaks to sink.
+func (l *location) leakTo(sink *location, derefs int) {
+       // If sink is a result parameter and we can fit return bits
+       // into the escape analysis tag, then record a return leak.
+       if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
+               ri := sink.resultIndex - 1
+               if ri < numEscResults {
+                       // Leak to result parameter.
+                       l.paramEsc.AddResult(ri, derefs)
+                       return
+               }
+       }
+
+       // Otherwise, record as heap leak.
+       l.paramEsc.AddHeap(derefs)
+}
+
+func (b *batch) finish(fns []*ir.Func) {
+       // Record parameter tags for package export data.
+       for _, fn := range fns {
+               fn.SetEsc(escFuncTagged)
+
+               narg := 0
+               for _, fs := range &types.RecvsParams {
+                       for _, f := range fs(fn.Type()).Fields().Slice() {
+                               narg++
+                               f.Note = b.paramTag(fn, narg, f)
+                       }
+               }
+       }
+
+       for _, loc := range b.allLocs {
+               n := loc.n
+               if n == nil {
+                       continue
+               }
+               if n.Op() == ir.ONAME {
+                       n := n.(*ir.Name)
+                       n.Opt = nil
+               }
+
+               // Update n.Esc based on escape analysis results.
+
+               if loc.escapes {
+                       if n.Op() == ir.ONAME {
+                               if base.Flag.CompilingRuntime {
+                                       base.ErrorfAt(n.Pos(), "%v escapes to heap, not allowed in runtime", n)
+                               }
+                               if base.Flag.LowerM != 0 {
+                                       base.WarnfAt(n.Pos(), "moved to heap: %v", n)
+                               }
+                       } else {
+                               if base.Flag.LowerM != 0 {
+                                       base.WarnfAt(n.Pos(), "%v escapes to heap", n)
+                               }
+                               if logopt.Enabled() {
+                                       var e_curfn *ir.Func // TODO(mdempsky): Fix.
+                                       logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e_curfn))
+                               }
+                       }
+                       n.SetEsc(ir.EscHeap)
+               } else {
+                       if base.Flag.LowerM != 0 && n.Op() != ir.ONAME {
+                               base.WarnfAt(n.Pos(), "%v does not escape", n)
+                       }
+                       n.SetEsc(ir.EscNone)
+                       if loc.transient {
+                               switch n.Op() {
+                               case ir.OCLOSURE:
+                                       n := n.(*ir.ClosureExpr)
+                                       n.SetTransient(true)
+                               case ir.OCALLPART:
+                                       n := n.(*ir.SelectorExpr)
+                                       n.SetTransient(true)
+                               case ir.OSLICELIT:
+                                       n := n.(*ir.CompLitExpr)
+                                       n.SetTransient(true)
+                               }
+                       }
+               }
+       }
+}
+
+func (l *location) isName(c ir.Class) bool {
+       return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class == c
+}
+
+const numEscResults = 7
+
+// An leaks represents a set of assignment flows from a parameter
+// to the heap or to any of its function's (first numEscResults)
+// result parameters.
+type leaks [1 + numEscResults]uint8
+
+// Empty reports whether l is an empty set (i.e., no assignment flows).
+func (l leaks) Empty() bool { return l == leaks{} }
+
+// Heap returns the minimum deref count of any assignment flow from l
+// to the heap. If no such flows exist, Heap returns -1.
+func (l leaks) Heap() int { return l.get(0) }
+
+// Result returns the minimum deref count of any assignment flow from
+// l to its function's i'th result parameter. If no such flows exist,
+// Result returns -1.
+func (l leaks) Result(i int) int { return l.get(1 + i) }
+
+// AddHeap adds an assignment flow from l to the heap.
+func (l *leaks) AddHeap(derefs int) { l.add(0, derefs) }
+
+// AddResult adds an assignment flow from l to its function's i'th
+// result parameter.
+func (l *leaks) AddResult(i, derefs int) { l.add(1+i, derefs) }
+
+func (l *leaks) setResult(i, derefs int) { l.set(1+i, derefs) }
+
+func (l leaks) get(i int) int { return int(l[i]) - 1 }
+
+func (l *leaks) add(i, derefs int) {
+       if old := l.get(i); old < 0 || derefs < old {
+               l.set(i, derefs)
+       }
+}
+
+func (l *leaks) set(i, derefs int) {
+       v := derefs + 1
+       if v < 0 {
+               base.Fatalf("invalid derefs count: %v", derefs)
+       }
+       if v > math.MaxUint8 {
+               v = math.MaxUint8
+       }
+
+       l[i] = uint8(v)
+}
+
+// Optimize removes result flow paths that are equal in length or
+// longer than the shortest heap flow path.
+func (l *leaks) Optimize() {
+       // If we have a path to the heap, then there's no use in
+       // keeping equal or longer paths elsewhere.
+       if x := l.Heap(); x >= 0 {
+               for i := 0; i < numEscResults; i++ {
+                       if l.Result(i) >= x {
+                               l.setResult(i, -1)
+                       }
+               }
+       }
+}
+
+var leakTagCache = map[leaks]string{}
+
+// Encode converts l into a binary string for export data.
+func (l leaks) Encode() string {
+       if l.Heap() == 0 {
+               // Space optimization: empty string encodes more
+               // efficiently in export data.
+               return ""
+       }
+       if s, ok := leakTagCache[l]; ok {
+               return s
+       }
+
+       n := len(l)
+       for n > 0 && l[n-1] == 0 {
+               n--
+       }
+       s := "esc:" + string(l[:n])
+       leakTagCache[l] = s
+       return s
+}
+
+// parseLeaks parses a binary string representing a leaks
+func parseLeaks(s string) leaks {
+       var l leaks
+       if !strings.HasPrefix(s, "esc:") {
+               l.AddHeap(0)
+               return l
+       }
+       copy(l[:], s[4:])
+       return l
+}
+
+func Funcs(all []ir.Node) {
+       ir.VisitFuncsBottomUp(all, Batch)
+}
+
+const (
+       escFuncUnknown = 0 + iota
+       escFuncPlanned
+       escFuncStarted
+       escFuncTagged
+)
+
+// Mark labels that have no backjumps to them as not increasing e.loopdepth.
+type labelState int
+
+const (
+       looping labelState = 1 + iota
+       nonlooping
+)
+
+func isSliceSelfAssign(dst, src ir.Node) bool {
+       // Detect the following special case.
+       //
+       //      func (b *Buffer) Foo() {
+       //              n, m := ...
+       //              b.buf = b.buf[n:m]
+       //      }
+       //
+       // This assignment is a no-op for escape analysis,
+       // it does not store any new pointers into b that were not already there.
+       // However, without this special case b will escape, because we assign to OIND/ODOTPTR.
+       // Here we assume that the statement will not contain calls,
+       // that is, that order will move any calls to init.
+       // Otherwise base ONAME value could change between the moments
+       // when we evaluate it for dst and for src.
+
+       // dst is ONAME dereference.
+       var dstX ir.Node
+       switch dst.Op() {
+       default:
+               return false
+       case ir.ODEREF:
+               dst := dst.(*ir.StarExpr)
+               dstX = dst.X
+       case ir.ODOTPTR:
+               dst := dst.(*ir.SelectorExpr)
+               dstX = dst.X
+       }
+       if dstX.Op() != ir.ONAME {
+               return false
+       }
+       // src is a slice operation.
+       switch src.Op() {
+       case ir.OSLICE, ir.OSLICE3, ir.OSLICESTR:
+               // OK.
+       case ir.OSLICEARR, ir.OSLICE3ARR:
+               // Since arrays are embedded into containing object,
+               // slice of non-pointer array will introduce a new pointer into b that was not already there
+               // (pointer to b itself). After such assignment, if b contents escape,
+               // b escapes as well. If we ignore such OSLICEARR, we will conclude
+               // that b does not escape when b contents do.
+               //
+               // Pointer to an array is OK since it's not stored inside b directly.
+               // For slicing an array (not pointer to array), there is an implicit OADDR.
+               // We check that to determine non-pointer array slicing.
+               src := src.(*ir.SliceExpr)
+               if src.X.Op() == ir.OADDR {
+                       return false
+               }
+       default:
+               return false
+       }
+       // slice is applied to ONAME dereference.
+       var baseX ir.Node
+       switch base := src.(*ir.SliceExpr).X; base.Op() {
+       default:
+               return false
+       case ir.ODEREF:
+               base := base.(*ir.StarExpr)
+               baseX = base.X
+       case ir.ODOTPTR:
+               base := base.(*ir.SelectorExpr)
+               baseX = base.X
+       }
+       if baseX.Op() != ir.ONAME {
+               return false
+       }
+       // dst and src reference the same base ONAME.
+       return dstX.(*ir.Name) == baseX.(*ir.Name)
+}
+
+// isSelfAssign reports whether assignment from src to dst can
+// be ignored by the escape analysis as it's effectively a self-assignment.
+func isSelfAssign(dst, src ir.Node) bool {
+       if isSliceSelfAssign(dst, src) {
+               return true
+       }
+
+       // Detect trivial assignments that assign back to the same object.
+       //
+       // It covers these cases:
+       //      val.x = val.y
+       //      val.x[i] = val.y[j]
+       //      val.x1.x2 = val.x1.y2
+       //      ... etc
+       //
+       // These assignments do not change assigned object lifetime.
+
+       if dst == nil || src == nil || dst.Op() != src.Op() {
+               return false
+       }
+
+       // The expression prefix must be both "safe" and identical.
+       switch dst.Op() {
+       case ir.ODOT, ir.ODOTPTR:
+               // Safe trailing accessors that are permitted to differ.
+               dst := dst.(*ir.SelectorExpr)
+               src := src.(*ir.SelectorExpr)
+               return ir.SameSafeExpr(dst.X, src.X)
+       case ir.OINDEX:
+               dst := dst.(*ir.IndexExpr)
+               src := src.(*ir.IndexExpr)
+               if mayAffectMemory(dst.Index) || mayAffectMemory(src.Index) {
+                       return false
+               }
+               return ir.SameSafeExpr(dst.X, src.X)
+       default:
+               return false
+       }
+}
+
+// mayAffectMemory reports whether evaluation of n may affect the program's
+// memory state. If the expression can't affect memory state, then it can be
+// safely ignored by the escape analysis.
+func mayAffectMemory(n ir.Node) bool {
+       // We may want to use a list of "memory safe" ops instead of generally
+       // "side-effect free", which would include all calls and other ops that can
+       // allocate or change global state. For now, it's safer to start with the latter.
+       //
+       // We're ignoring things like division by zero, index out of range,
+       // and nil pointer dereference here.
+
+       // TODO(rsc): It seems like it should be possible to replace this with
+       // an ir.Any looking for any op that's not the ones in the case statement.
+       // But that produces changes in the compiled output detected by buildall.
+       switch n.Op() {
+       case ir.ONAME, ir.OLITERAL, ir.ONIL:
+               return false
+
+       case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+               n := n.(*ir.BinaryExpr)
+               return mayAffectMemory(n.X) || mayAffectMemory(n.Y)
+
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               return mayAffectMemory(n.X) || mayAffectMemory(n.Index)
+
+       case ir.OCONVNOP, ir.OCONV:
+               n := n.(*ir.ConvExpr)
+               return mayAffectMemory(n.X)
+
+       case ir.OLEN, ir.OCAP, ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+               n := n.(*ir.UnaryExpr)
+               return mayAffectMemory(n.X)
+
+       case ir.ODOT, ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               return mayAffectMemory(n.X)
+
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               return mayAffectMemory(n.X)
+
+       default:
+               return true
+       }
+}
+
+// HeapAllocReason returns the reason the given Node must be heap
+// allocated, or the empty string if it doesn't.
+func HeapAllocReason(n ir.Node) string {
+       if n == nil || n.Type() == nil {
+               return ""
+       }
+
+       // Parameters are always passed via the stack.
+       if n.Op() == ir.ONAME {
+               n := n.(*ir.Name)
+               if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+                       return ""
+               }
+       }
+
+       if n.Type().Width > ir.MaxStackVarSize {
+               return "too large for stack"
+       }
+
+       if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
+               return "too large for stack"
+       }
+
+       if n.Op() == ir.OCLOSURE && typecheck.ClosureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
+               return "too large for stack"
+       }
+       if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.SelectorExpr)).Size() >= ir.MaxImplicitStackVarSize {
+               return "too large for stack"
+       }
+
+       if n.Op() == ir.OMAKESLICE {
+               n := n.(*ir.MakeExpr)
+               r := n.Cap
+               if r == nil {
+                       r = n.Len
+               }
+               if !ir.IsSmallIntConst(r) {
+                       return "non-constant size"
+               }
+               if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) >= ir.MaxImplicitStackVarSize/t.Elem().Width {
+                       return "too large for stack"
+               }
+       }
+
+       return ""
+}
+
+// This special tag is applied to uintptr variables
+// that we believe may hold unsafe.Pointers for
+// calls into assembly functions.
+const UnsafeUintptrNote = "unsafe-uintptr"
+
+// This special tag is applied to uintptr parameters of functions
+// marked go:uintptrescapes.
+const UintptrEscapesNote = "uintptr-escapes"
+
+func (b *batch) paramTag(fn *ir.Func, narg int, f *types.Field) string {
+       name := func() string {
+               if f.Sym != nil {
+                       return f.Sym.Name
+               }
+               return fmt.Sprintf("arg#%d", narg)
+       }
+
+       if len(fn.Body) == 0 {
+               // Assume that uintptr arguments must be held live across the call.
+               // This is most important for syscall.Syscall.
+               // See golang.org/issue/13372.
+               // This really doesn't have much to do with escape analysis per se,
+               // but we are reusing the ability to annotate an individual function
+               // argument and pass those annotations along to importing code.
+               if f.Type.IsUintptr() {
+                       if base.Flag.LowerM != 0 {
+                               base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
+                       }
+                       return UnsafeUintptrNote
+               }
+
+               if !f.Type.HasPointers() { // don't bother tagging for scalars
+                       return ""
+               }
+
+               var esc leaks
+
+               // External functions are assumed unsafe, unless
+               // //go:noescape is given before the declaration.
+               if fn.Pragma&ir.Noescape != 0 {
+                       if base.Flag.LowerM != 0 && f.Sym != nil {
+                               base.WarnfAt(f.Pos, "%v does not escape", name())
+                       }
+               } else {
+                       if base.Flag.LowerM != 0 && f.Sym != nil {
+                               base.WarnfAt(f.Pos, "leaking param: %v", name())
+                       }
+                       esc.AddHeap(0)
+               }
+
+               return esc.Encode()
+       }
+
+       if fn.Pragma&ir.UintptrEscapes != 0 {
+               if f.Type.IsUintptr() {
+                       if base.Flag.LowerM != 0 {
+                               base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
+                       }
+                       return UintptrEscapesNote
+               }
+               if f.IsDDD() && f.Type.Elem().IsUintptr() {
+                       // final argument is ...uintptr.
+                       if base.Flag.LowerM != 0 {
+                               base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
+                       }
+                       return UintptrEscapesNote
+               }
+       }
+
+       if !f.Type.HasPointers() { // don't bother tagging for scalars
+               return ""
+       }
+
+       // Unnamed parameters are unused and therefore do not escape.
+       if f.Sym == nil || f.Sym.IsBlank() {
+               var esc leaks
+               return esc.Encode()
+       }
+
+       n := f.Nname.(*ir.Name)
+       loc := b.oldLoc(n)
+       esc := loc.paramEsc
+       esc.Optimize()
+
+       if base.Flag.LowerM != 0 && !loc.escapes {
+               if esc.Empty() {
+                       base.WarnfAt(f.Pos, "%v does not escape", name())
+               }
+               if x := esc.Heap(); x >= 0 {
+                       if x == 0 {
+                               base.WarnfAt(f.Pos, "leaking param: %v", name())
+                       } else {
+                               // TODO(mdempsky): Mention level=x like below?
+                               base.WarnfAt(f.Pos, "leaking param content: %v", name())
+                       }
+               }
+               for i := 0; i < numEscResults; i++ {
+                       if x := esc.Result(i); x >= 0 {
+                               res := fn.Type().Results().Field(i).Sym
+                               base.WarnfAt(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
+                       }
+               }
+       }
+
+       return esc.Encode()
+}

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
deleted file mode 100644 (file)
index 2f7fa27..0000000
--- a/src/cmd/compile/internal/gc/alg.go
+++ /dev/null
@@ -1,959 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "fmt"
-       "sort"
-)
-
-// AlgKind describes the kind of algorithms used for comparing and
-// hashing a Type.
-type AlgKind int
-
-//go:generate stringer -type AlgKind -trimprefix A
-
-const (
-       // These values are known by runtime.
-       ANOEQ AlgKind = iota
-       AMEM0
-       AMEM8
-       AMEM16
-       AMEM32
-       AMEM64
-       AMEM128
-       ASTRING
-       AINTER
-       ANILINTER
-       AFLOAT32
-       AFLOAT64
-       ACPLX64
-       ACPLX128
-
-       // Type can be compared/hashed as regular memory.
-       AMEM AlgKind = 100
-
-       // Type needs special comparison/hashing functions.
-       ASPECIAL AlgKind = -1
-)
-
-// IsComparable reports whether t is a comparable type.
-func IsComparable(t *types.Type) bool {
-       a, _ := algtype1(t)
-       return a != ANOEQ
-}
-
-// IsRegularMemory reports whether t can be compared/hashed as regular memory.
-func IsRegularMemory(t *types.Type) bool {
-       a, _ := algtype1(t)
-       return a == AMEM
-}
-
-// IncomparableField returns an incomparable Field of struct Type t, if any.
-func IncomparableField(t *types.Type) *types.Field {
-       for _, f := range t.FieldSlice() {
-               if !IsComparable(f.Type) {
-                       return f
-               }
-       }
-       return nil
-}
-
-// EqCanPanic reports whether == on type t could panic (has an interface somewhere).
-// t must be comparable.
-func EqCanPanic(t *types.Type) bool {
-       switch t.Etype {
-       default:
-               return false
-       case TINTER:
-               return true
-       case TARRAY:
-               return EqCanPanic(t.Elem())
-       case TSTRUCT:
-               for _, f := range t.FieldSlice() {
-                       if !f.Sym.IsBlank() && EqCanPanic(f.Type) {
-                               return true
-                       }
-               }
-               return false
-       }
-}
-
-// algtype is like algtype1, except it returns the fixed-width AMEMxx variants
-// instead of the general AMEM kind when possible.
-func algtype(t *types.Type) AlgKind {
-       a, _ := algtype1(t)
-       if a == AMEM {
-               switch t.Width {
-               case 0:
-                       return AMEM0
-               case 1:
-                       return AMEM8
-               case 2:
-                       return AMEM16
-               case 4:
-                       return AMEM32
-               case 8:
-                       return AMEM64
-               case 16:
-                       return AMEM128
-               }
-       }
-
-       return a
-}
-
-// algtype1 returns the AlgKind used for comparing and hashing Type t.
-// If it returns ANOEQ, it also returns the component type of t that
-// makes it incomparable.
-func algtype1(t *types.Type) (AlgKind, *types.Type) {
-       if t.Broke() {
-               return AMEM, nil
-       }
-       if t.Noalg() {
-               return ANOEQ, t
-       }
-
-       switch t.Etype {
-       case TANY, TFORW:
-               // will be defined later.
-               return ANOEQ, t
-
-       case TINT8, TUINT8, TINT16, TUINT16,
-               TINT32, TUINT32, TINT64, TUINT64,
-               TINT, TUINT, TUINTPTR,
-               TBOOL, TPTR,
-               TCHAN, TUNSAFEPTR:
-               return AMEM, nil
-
-       case TFUNC, TMAP:
-               return ANOEQ, t
-
-       case TFLOAT32:
-               return AFLOAT32, nil
-
-       case TFLOAT64:
-               return AFLOAT64, nil
-
-       case TCOMPLEX64:
-               return ACPLX64, nil
-
-       case TCOMPLEX128:
-               return ACPLX128, nil
-
-       case TSTRING:
-               return ASTRING, nil
-
-       case TINTER:
-               if t.IsEmptyInterface() {
-                       return ANILINTER, nil
-               }
-               return AINTER, nil
-
-       case TSLICE:
-               return ANOEQ, t
-
-       case TARRAY:
-               a, bad := algtype1(t.Elem())
-               switch a {
-               case AMEM:
-                       return AMEM, nil
-               case ANOEQ:
-                       return ANOEQ, bad
-               }
-
-               switch t.NumElem() {
-               case 0:
-                       // We checked above that the element type is comparable.
-                       return AMEM, nil
-               case 1:
-                       // Single-element array is same as its lone element.
-                       return a, nil
-               }
-
-               return ASPECIAL, nil
-
-       case TSTRUCT:
-               fields := t.FieldSlice()
-
-               // One-field struct is same as that one field alone.
-               if len(fields) == 1 && !fields[0].Sym.IsBlank() {
-                       return algtype1(fields[0].Type)
-               }
-
-               ret := AMEM
-               for i, f := range fields {
-                       // All fields must be comparable.
-                       a, bad := algtype1(f.Type)
-                       if a == ANOEQ {
-                               return ANOEQ, bad
-                       }
-
-                       // Blank fields, padded fields, fields with non-memory
-                       // equality need special compare.
-                       if a != AMEM || f.Sym.IsBlank() || ispaddedfield(t, i) {
-                               ret = ASPECIAL
-                       }
-               }
-
-               return ret, nil
-       }
-
-       Fatalf("algtype1: unexpected type %v", t)
-       return 0, nil
-}
-
-// genhash returns a symbol which is the closure used to compute
-// the hash of a value of type t.
-// Note: the generated function must match runtime.typehash exactly.
-func genhash(t *types.Type) *obj.LSym {
-       switch algtype(t) {
-       default:
-               // genhash is only called for types that have equality
-               Fatalf("genhash %v", t)
-       case AMEM0:
-               return sysClosure("memhash0")
-       case AMEM8:
-               return sysClosure("memhash8")
-       case AMEM16:
-               return sysClosure("memhash16")
-       case AMEM32:
-               return sysClosure("memhash32")
-       case AMEM64:
-               return sysClosure("memhash64")
-       case AMEM128:
-               return sysClosure("memhash128")
-       case ASTRING:
-               return sysClosure("strhash")
-       case AINTER:
-               return sysClosure("interhash")
-       case ANILINTER:
-               return sysClosure("nilinterhash")
-       case AFLOAT32:
-               return sysClosure("f32hash")
-       case AFLOAT64:
-               return sysClosure("f64hash")
-       case ACPLX64:
-               return sysClosure("c64hash")
-       case ACPLX128:
-               return sysClosure("c128hash")
-       case AMEM:
-               // For other sizes of plain memory, we build a closure
-               // that calls memhash_varlen. The size of the memory is
-               // encoded in the first slot of the closure.
-               closure := typeLookup(fmt.Sprintf(".hashfunc%d", t.Width)).Linksym()
-               if len(closure.P) > 0 { // already generated
-                       return closure
-               }
-               if memhashvarlen == nil {
-                       memhashvarlen = sysfunc("memhash_varlen")
-               }
-               ot := 0
-               ot = dsymptr(closure, ot, memhashvarlen, 0)
-               ot = duintptr(closure, ot, uint64(t.Width)) // size encoded in closure
-               ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
-               return closure
-       case ASPECIAL:
-               break
-       }
-
-       closure := typesymprefix(".hashfunc", t).Linksym()
-       if len(closure.P) > 0 { // already generated
-               return closure
-       }
-
-       // Generate hash functions for subtypes.
-       // There are cases where we might not use these hashes,
-       // but in that case they will get dead-code eliminated.
-       // (And the closure generated by genhash will also get
-       // dead-code eliminated, as we call the subtype hashers
-       // directly.)
-       switch t.Etype {
-       case types.TARRAY:
-               genhash(t.Elem())
-       case types.TSTRUCT:
-               for _, f := range t.FieldSlice() {
-                       genhash(f.Type)
-               }
-       }
-
-       sym := typesymprefix(".hash", t)
-       if Debug.r != 0 {
-               fmt.Printf("genhash %v %v %v\n", closure, sym, t)
-       }
-
-       lineno = autogeneratedPos // less confusing than end of input
-       dclcontext = PEXTERN
-
-       // func sym(p *T, h uintptr) uintptr
-       tfn := nod(OTFUNC, nil, nil)
-       tfn.List.Set2(
-               namedfield("p", types.NewPtr(t)),
-               namedfield("h", types.Types[TUINTPTR]),
-       )
-       tfn.Rlist.Set1(anonfield(types.Types[TUINTPTR]))
-
-       fn := dclfunc(sym, tfn)
-       np := asNode(tfn.Type.Params().Field(0).Nname)
-       nh := asNode(tfn.Type.Params().Field(1).Nname)
-
-       switch t.Etype {
-       case types.TARRAY:
-               // An array of pure memory would be handled by the
-               // standard algorithm, so the element type must not be
-               // pure memory.
-               hashel := hashfor(t.Elem())
-
-               n := nod(ORANGE, nil, nod(ODEREF, np, nil))
-               ni := newname(lookup("i"))
-               ni.Type = types.Types[TINT]
-               n.List.Set1(ni)
-               n.SetColas(true)
-               colasdefn(n.List.Slice(), n)
-               ni = n.List.First()
-
-               // h = hashel(&p[i], h)
-               call := nod(OCALL, hashel, nil)
-
-               nx := nod(OINDEX, np, ni)
-               nx.SetBounded(true)
-               na := nod(OADDR, nx, nil)
-               call.List.Append(na)
-               call.List.Append(nh)
-               n.Nbody.Append(nod(OAS, nh, call))
-
-               fn.Nbody.Append(n)
-
-       case types.TSTRUCT:
-               // Walk the struct using memhash for runs of AMEM
-               // and calling specific hash functions for the others.
-               for i, fields := 0, t.FieldSlice(); i < len(fields); {
-                       f := fields[i]
-
-                       // Skip blank fields.
-                       if f.Sym.IsBlank() {
-                               i++
-                               continue
-                       }
-
-                       // Hash non-memory fields with appropriate hash function.
-                       if !IsRegularMemory(f.Type) {
-                               hashel := hashfor(f.Type)
-                               call := nod(OCALL, hashel, nil)
-                               nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
-                               na := nod(OADDR, nx, nil)
-                               call.List.Append(na)
-                               call.List.Append(nh)
-                               fn.Nbody.Append(nod(OAS, nh, call))
-                               i++
-                               continue
-                       }
-
-                       // Otherwise, hash a maximal length run of raw memory.
-                       size, next := memrun(t, i)
-
-                       // h = hashel(&p.first, size, h)
-                       hashel := hashmem(f.Type)
-                       call := nod(OCALL, hashel, nil)
-                       nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
-                       na := nod(OADDR, nx, nil)
-                       call.List.Append(na)
-                       call.List.Append(nh)
-                       call.List.Append(nodintconst(size))
-                       fn.Nbody.Append(nod(OAS, nh, call))
-
-                       i = next
-               }
-       }
-
-       r := nod(ORETURN, nil, nil)
-       r.List.Append(nh)
-       fn.Nbody.Append(r)
-
-       if Debug.r != 0 {
-               dumplist("genhash body", fn.Nbody)
-       }
-
-       funcbody()
-
-       fn.Func.SetDupok(true)
-       fn = typecheck(fn, ctxStmt)
-
-       Curfn = fn
-       typecheckslice(fn.Nbody.Slice(), ctxStmt)
-       Curfn = nil
-
-       if debug_dclstack != 0 {
-               testdclstack()
-       }
-
-       fn.Func.SetNilCheckDisabled(true)
-       xtop = append(xtop, fn)
-
-       // Build closure. It doesn't close over any variables, so
-       // it contains just the function pointer.
-       dsymptr(closure, 0, sym.Linksym(), 0)
-       ggloblsym(closure, int32(Widthptr), obj.DUPOK|obj.RODATA)
-
-       return closure
-}
-
-func hashfor(t *types.Type) *Node {
-       var sym *types.Sym
-
-       switch a, _ := algtype1(t); a {
-       case AMEM:
-               Fatalf("hashfor with AMEM type")
-       case AINTER:
-               sym = Runtimepkg.Lookup("interhash")
-       case ANILINTER:
-               sym = Runtimepkg.Lookup("nilinterhash")
-       case ASTRING:
-               sym = Runtimepkg.Lookup("strhash")
-       case AFLOAT32:
-               sym = Runtimepkg.Lookup("f32hash")
-       case AFLOAT64:
-               sym = Runtimepkg.Lookup("f64hash")
-       case ACPLX64:
-               sym = Runtimepkg.Lookup("c64hash")
-       case ACPLX128:
-               sym = Runtimepkg.Lookup("c128hash")
-       default:
-               // Note: the caller of hashfor ensured that this symbol
-               // exists and has a body by calling genhash for t.
-               sym = typesymprefix(".hash", t)
-       }
-
-       n := newname(sym)
-       setNodeNameFunc(n)
-       n.Type = functype(nil, []*Node{
-               anonfield(types.NewPtr(t)),
-               anonfield(types.Types[TUINTPTR]),
-       }, []*Node{
-               anonfield(types.Types[TUINTPTR]),
-       })
-       return n
-}
-
-// sysClosure returns a closure which will call the
-// given runtime function (with no closed-over variables).
-func sysClosure(name string) *obj.LSym {
-       s := sysvar(name + "·f")
-       if len(s.P) == 0 {
-               f := sysfunc(name)
-               dsymptr(s, 0, f, 0)
-               ggloblsym(s, int32(Widthptr), obj.DUPOK|obj.RODATA)
-       }
-       return s
-}
-
-// geneq returns a symbol which is the closure used to compute
-// equality for two objects of type t.
-func geneq(t *types.Type) *obj.LSym {
-       switch algtype(t) {
-       case ANOEQ:
-               // The runtime will panic if it tries to compare
-               // a type with a nil equality function.
-               return nil
-       case AMEM0:
-               return sysClosure("memequal0")
-       case AMEM8:
-               return sysClosure("memequal8")
-       case AMEM16:
-               return sysClosure("memequal16")
-       case AMEM32:
-               return sysClosure("memequal32")
-       case AMEM64:
-               return sysClosure("memequal64")
-       case AMEM128:
-               return sysClosure("memequal128")
-       case ASTRING:
-               return sysClosure("strequal")
-       case AINTER:
-               return sysClosure("interequal")
-       case ANILINTER:
-               return sysClosure("nilinterequal")
-       case AFLOAT32:
-               return sysClosure("f32equal")
-       case AFLOAT64:
-               return sysClosure("f64equal")
-       case ACPLX64:
-               return sysClosure("c64equal")
-       case ACPLX128:
-               return sysClosure("c128equal")
-       case AMEM:
-               // make equality closure. The size of the type
-               // is encoded in the closure.
-               closure := typeLookup(fmt.Sprintf(".eqfunc%d", t.Width)).Linksym()
-               if len(closure.P) != 0 {
-                       return closure
-               }
-               if memequalvarlen == nil {
-                       memequalvarlen = sysvar("memequal_varlen") // asm func
-               }
-               ot := 0
-               ot = dsymptr(closure, ot, memequalvarlen, 0)
-               ot = duintptr(closure, ot, uint64(t.Width))
-               ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
-               return closure
-       case ASPECIAL:
-               break
-       }
-
-       closure := typesymprefix(".eqfunc", t).Linksym()
-       if len(closure.P) > 0 { // already generated
-               return closure
-       }
-       sym := typesymprefix(".eq", t)
-       if Debug.r != 0 {
-               fmt.Printf("geneq %v\n", t)
-       }
-
-       // Autogenerate code for equality of structs and arrays.
-
-       lineno = autogeneratedPos // less confusing than end of input
-       dclcontext = PEXTERN
-
-       // func sym(p, q *T) bool
-       tfn := nod(OTFUNC, nil, nil)
-       tfn.List.Set2(
-               namedfield("p", types.NewPtr(t)),
-               namedfield("q", types.NewPtr(t)),
-       )
-       tfn.Rlist.Set1(namedfield("r", types.Types[TBOOL]))
-
-       fn := dclfunc(sym, tfn)
-       np := asNode(tfn.Type.Params().Field(0).Nname)
-       nq := asNode(tfn.Type.Params().Field(1).Nname)
-       nr := asNode(tfn.Type.Results().Field(0).Nname)
-
-       // Label to jump to if an equality test fails.
-       neq := autolabel(".neq")
-
-       // We reach here only for types that have equality but
-       // cannot be handled by the standard algorithms,
-       // so t must be either an array or a struct.
-       switch t.Etype {
-       default:
-               Fatalf("geneq %v", t)
-
-       case TARRAY:
-               nelem := t.NumElem()
-
-               // checkAll generates code to check the equality of all array elements.
-               // If unroll is greater than nelem, checkAll generates:
-               //
-               // if eq(p[0], q[0]) && eq(p[1], q[1]) && ... {
-               // } else {
-               //   return
-               // }
-               //
-               // And so on.
-               //
-               // Otherwise it generates:
-               //
-               // for i := 0; i < nelem; i++ {
-               //   if eq(p[i], q[i]) {
-               //   } else {
-               //     goto neq
-               //   }
-               // }
-               //
-               // TODO(josharian): consider doing some loop unrolling
-               // for larger nelem as well, processing a few elements at a time in a loop.
-               checkAll := func(unroll int64, last bool, eq func(pi, qi *Node) *Node) {
-                       // checkIdx generates a node to check for equality at index i.
-                       checkIdx := func(i *Node) *Node {
-                               // pi := p[i]
-                               pi := nod(OINDEX, np, i)
-                               pi.SetBounded(true)
-                               pi.Type = t.Elem()
-                               // qi := q[i]
-                               qi := nod(OINDEX, nq, i)
-                               qi.SetBounded(true)
-                               qi.Type = t.Elem()
-                               return eq(pi, qi)
-                       }
-
-                       if nelem <= unroll {
-                               if last {
-                                       // Do last comparison in a different manner.
-                                       nelem--
-                               }
-                               // Generate a series of checks.
-                               for i := int64(0); i < nelem; i++ {
-                                       // if check {} else { goto neq }
-                                       nif := nod(OIF, checkIdx(nodintconst(i)), nil)
-                                       nif.Rlist.Append(nodSym(OGOTO, nil, neq))
-                                       fn.Nbody.Append(nif)
-                               }
-                               if last {
-                                       fn.Nbody.Append(nod(OAS, nr, checkIdx(nodintconst(nelem))))
-                               }
-                       } else {
-                               // Generate a for loop.
-                               // for i := 0; i < nelem; i++
-                               i := temp(types.Types[TINT])
-                               init := nod(OAS, i, nodintconst(0))
-                               cond := nod(OLT, i, nodintconst(nelem))
-                               post := nod(OAS, i, nod(OADD, i, nodintconst(1)))
-                               loop := nod(OFOR, cond, post)
-                               loop.Ninit.Append(init)
-                               // if eq(pi, qi) {} else { goto neq }
-                               nif := nod(OIF, checkIdx(i), nil)
-                               nif.Rlist.Append(nodSym(OGOTO, nil, neq))
-                               loop.Nbody.Append(nif)
-                               fn.Nbody.Append(loop)
-                               if last {
-                                       fn.Nbody.Append(nod(OAS, nr, nodbool(true)))
-                               }
-                       }
-               }
-
-               switch t.Elem().Etype {
-               case TSTRING:
-                       // Do two loops. First, check that all the lengths match (cheap).
-                       // Second, check that all the contents match (expensive).
-                       // TODO: when the array size is small, unroll the length match checks.
-                       checkAll(3, false, func(pi, qi *Node) *Node {
-                               // Compare lengths.
-                               eqlen, _ := eqstring(pi, qi)
-                               return eqlen
-                       })
-                       checkAll(1, true, func(pi, qi *Node) *Node {
-                               // Compare contents.
-                               _, eqmem := eqstring(pi, qi)
-                               return eqmem
-                       })
-               case TFLOAT32, TFLOAT64:
-                       checkAll(2, true, func(pi, qi *Node) *Node {
-                               // p[i] == q[i]
-                               return nod(OEQ, pi, qi)
-                       })
-               // TODO: pick apart structs, do them piecemeal too
-               default:
-                       checkAll(1, true, func(pi, qi *Node) *Node {
-                               // p[i] == q[i]
-                               return nod(OEQ, pi, qi)
-                       })
-               }
-
-       case TSTRUCT:
-               // Build a list of conditions to satisfy.
-               // The conditions are a list-of-lists. Conditions are reorderable
-               // within each inner list. The outer lists must be evaluated in order.
-               var conds [][]*Node
-               conds = append(conds, []*Node{})
-               and := func(n *Node) {
-                       i := len(conds) - 1
-                       conds[i] = append(conds[i], n)
-               }
-
-               // Walk the struct using memequal for runs of AMEM
-               // and calling specific equality tests for the others.
-               for i, fields := 0, t.FieldSlice(); i < len(fields); {
-                       f := fields[i]
-
-                       // Skip blank-named fields.
-                       if f.Sym.IsBlank() {
-                               i++
-                               continue
-                       }
-
-                       // Compare non-memory fields with field equality.
-                       if !IsRegularMemory(f.Type) {
-                               if EqCanPanic(f.Type) {
-                                       // Enforce ordering by starting a new set of reorderable conditions.
-                                       conds = append(conds, []*Node{})
-                               }
-                               p := nodSym(OXDOT, np, f.Sym)
-                               q := nodSym(OXDOT, nq, f.Sym)
-                               switch {
-                               case f.Type.IsString():
-                                       eqlen, eqmem := eqstring(p, q)
-                                       and(eqlen)
-                                       and(eqmem)
-                               default:
-                                       and(nod(OEQ, p, q))
-                               }
-                               if EqCanPanic(f.Type) {
-                                       // Also enforce ordering after something that can panic.
-                                       conds = append(conds, []*Node{})
-                               }
-                               i++
-                               continue
-                       }
-
-                       // Find maximal length run of memory-only fields.
-                       size, next := memrun(t, i)
-
-                       // TODO(rsc): All the calls to newname are wrong for
-                       // cross-package unexported fields.
-                       if s := fields[i:next]; len(s) <= 2 {
-                               // Two or fewer fields: use plain field equality.
-                               for _, f := range s {
-                                       and(eqfield(np, nq, f.Sym))
-                               }
-                       } else {
-                               // More than two fields: use memequal.
-                               and(eqmem(np, nq, f.Sym, size))
-                       }
-                       i = next
-               }
-
-               // Sort conditions to put runtime calls last.
-               // Preserve the rest of the ordering.
-               var flatConds []*Node
-               for _, c := range conds {
-                       isCall := func(n *Node) bool {
-                               return n.Op == OCALL || n.Op == OCALLFUNC
-                       }
-                       sort.SliceStable(c, func(i, j int) bool {
-                               return !isCall(c[i]) && isCall(c[j])
-                       })
-                       flatConds = append(flatConds, c...)
-               }
-
-               if len(flatConds) == 0 {
-                       fn.Nbody.Append(nod(OAS, nr, nodbool(true)))
-               } else {
-                       for _, c := range flatConds[:len(flatConds)-1] {
-                               // if cond {} else { goto neq }
-                               n := nod(OIF, c, nil)
-                               n.Rlist.Append(nodSym(OGOTO, nil, neq))
-                               fn.Nbody.Append(n)
-                       }
-                       fn.Nbody.Append(nod(OAS, nr, flatConds[len(flatConds)-1]))
-               }
-       }
-
-       // ret:
-       //   return
-       ret := autolabel(".ret")
-       fn.Nbody.Append(nodSym(OLABEL, nil, ret))
-       fn.Nbody.Append(nod(ORETURN, nil, nil))
-
-       // neq:
-       //   r = false
-       //   return (or goto ret)
-       fn.Nbody.Append(nodSym(OLABEL, nil, neq))
-       fn.Nbody.Append(nod(OAS, nr, nodbool(false)))
-       if EqCanPanic(t) || hasCall(fn) {
-               // Epilogue is large, so share it with the equal case.
-               fn.Nbody.Append(nodSym(OGOTO, nil, ret))
-       } else {
-               // Epilogue is small, so don't bother sharing.
-               fn.Nbody.Append(nod(ORETURN, nil, nil))
-       }
-       // TODO(khr): the epilogue size detection condition above isn't perfect.
-       // We should really do a generic CL that shares epilogues across
-       // the board. See #24936.
-
-       if Debug.r != 0 {
-               dumplist("geneq body", fn.Nbody)
-       }
-
-       funcbody()
-
-       fn.Func.SetDupok(true)
-       fn = typecheck(fn, ctxStmt)
-
-       Curfn = fn
-       typecheckslice(fn.Nbody.Slice(), ctxStmt)
-       Curfn = nil
-
-       if debug_dclstack != 0 {
-               testdclstack()
-       }
-
-       // Disable checknils while compiling this code.
-       // We are comparing a struct or an array,
-       // neither of which can be nil, and our comparisons
-       // are shallow.
-       fn.Func.SetNilCheckDisabled(true)
-       xtop = append(xtop, fn)
-
-       // Generate a closure which points at the function we just generated.
-       dsymptr(closure, 0, sym.Linksym(), 0)
-       ggloblsym(closure, int32(Widthptr), obj.DUPOK|obj.RODATA)
-       return closure
-}
-
-func hasCall(n *Node) bool {
-       if n.Op == OCALL || n.Op == OCALLFUNC {
-               return true
-       }
-       if n.Left != nil && hasCall(n.Left) {
-               return true
-       }
-       if n.Right != nil && hasCall(n.Right) {
-               return true
-       }
-       for _, x := range n.Ninit.Slice() {
-               if hasCall(x) {
-                       return true
-               }
-       }
-       for _, x := range n.Nbody.Slice() {
-               if hasCall(x) {
-                       return true
-               }
-       }
-       for _, x := range n.List.Slice() {
-               if hasCall(x) {
-                       return true
-               }
-       }
-       for _, x := range n.Rlist.Slice() {
-               if hasCall(x) {
-                       return true
-               }
-       }
-       return false
-}
-
-// eqfield returns the node
-//     p.field == q.field
-func eqfield(p *Node, q *Node, field *types.Sym) *Node {
-       nx := nodSym(OXDOT, p, field)
-       ny := nodSym(OXDOT, q, field)
-       ne := nod(OEQ, nx, ny)
-       return ne
-}
-
-// eqstring returns the nodes
-//   len(s) == len(t)
-// and
-//   memequal(s.ptr, t.ptr, len(s))
-// which can be used to construct string equality comparison.
-// eqlen must be evaluated before eqmem, and shortcircuiting is required.
-func eqstring(s, t *Node) (eqlen, eqmem *Node) {
-       s = conv(s, types.Types[TSTRING])
-       t = conv(t, types.Types[TSTRING])
-       sptr := nod(OSPTR, s, nil)
-       tptr := nod(OSPTR, t, nil)
-       slen := conv(nod(OLEN, s, nil), types.Types[TUINTPTR])
-       tlen := conv(nod(OLEN, t, nil), types.Types[TUINTPTR])
-
-       fn := syslook("memequal")
-       fn = substArgTypes(fn, types.Types[TUINT8], types.Types[TUINT8])
-       call := nod(OCALL, fn, nil)
-       call.List.Append(sptr, tptr, slen.copy())
-       call = typecheck(call, ctxExpr|ctxMultiOK)
-
-       cmp := nod(OEQ, slen, tlen)
-       cmp = typecheck(cmp, ctxExpr)
-       cmp.Type = types.Types[TBOOL]
-       return cmp, call
-}
-
-// eqinterface returns the nodes
-//   s.tab == t.tab (or s.typ == t.typ, as appropriate)
-// and
-//   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
-// which can be used to construct interface equality comparison.
-// eqtab must be evaluated before eqdata, and shortcircuiting is required.
-func eqinterface(s, t *Node) (eqtab, eqdata *Node) {
-       if !types.Identical(s.Type, t.Type) {
-               Fatalf("eqinterface %v %v", s.Type, t.Type)
-       }
-       // func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
-       // func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
-       var fn *Node
-       if s.Type.IsEmptyInterface() {
-               fn = syslook("efaceeq")
-       } else {
-               fn = syslook("ifaceeq")
-       }
-
-       stab := nod(OITAB, s, nil)
-       ttab := nod(OITAB, t, nil)
-       sdata := nod(OIDATA, s, nil)
-       tdata := nod(OIDATA, t, nil)
-       sdata.Type = types.Types[TUNSAFEPTR]
-       tdata.Type = types.Types[TUNSAFEPTR]
-       sdata.SetTypecheck(1)
-       tdata.SetTypecheck(1)
-
-       call := nod(OCALL, fn, nil)
-       call.List.Append(stab, sdata, tdata)
-       call = typecheck(call, ctxExpr|ctxMultiOK)
-
-       cmp := nod(OEQ, stab, ttab)
-       cmp = typecheck(cmp, ctxExpr)
-       cmp.Type = types.Types[TBOOL]
-       return cmp, call
-}
-
-// eqmem returns the node
-//     memequal(&p.field, &q.field [, size])
-func eqmem(p *Node, q *Node, field *types.Sym, size int64) *Node {
-       nx := nod(OADDR, nodSym(OXDOT, p, field), nil)
-       ny := nod(OADDR, nodSym(OXDOT, q, field), nil)
-       nx = typecheck(nx, ctxExpr)
-       ny = typecheck(ny, ctxExpr)
-
-       fn, needsize := eqmemfunc(size, nx.Type.Elem())
-       call := nod(OCALL, fn, nil)
-       call.List.Append(nx)
-       call.List.Append(ny)
-       if needsize {
-               call.List.Append(nodintconst(size))
-       }
-
-       return call
-}
-
-func eqmemfunc(size int64, t *types.Type) (fn *Node, needsize bool) {
-       switch size {
-       default:
-               fn = syslook("memequal")
-               needsize = true
-       case 1, 2, 4, 8, 16:
-               buf := fmt.Sprintf("memequal%d", int(size)*8)
-               fn = syslook(buf)
-       }
-
-       fn = substArgTypes(fn, t, t)
-       return fn, needsize
-}
-
-// memrun finds runs of struct fields for which memory-only algs are appropriate.
-// t is the parent struct type, and start is the field index at which to start the run.
-// size is the length in bytes of the memory included in the run.
-// next is the index just after the end of the memory run.
-func memrun(t *types.Type, start int) (size int64, next int) {
-       next = start
-       for {
-               next++
-               if next == t.NumFields() {
-                       break
-               }
-               // Stop run after a padded field.
-               if ispaddedfield(t, next-1) {
-                       break
-               }
-               // Also, stop before a blank or non-memory field.
-               if f := t.Field(next); f.Sym.IsBlank() || !IsRegularMemory(f.Type) {
-                       break
-               }
-       }
-       return t.Field(next-1).End() - t.Field(start).Offset, next
-}
-
-// ispaddedfield reports whether the i'th field of struct type t is followed
-// by padding.
-func ispaddedfield(t *types.Type, i int) bool {
-       if !t.IsStruct() {
-               Fatalf("ispaddedfield called non-struct %v", t)
-       }
-       end := t.Width
-       if i+1 < t.NumFields() {
-               end = t.Field(i + 1).Offset
-       }
-       return t.Field(i).End() != end
-}

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
deleted file mode 100644 (file)
index 10f21f8..0000000
--- a/src/cmd/compile/internal/gc/bexport.go
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-)
-
-type exporter struct {
-       marked map[*types.Type]bool // types already seen by markType
-}
-
-// markType recursively visits types reachable from t to identify
-// functions whose inline bodies may be needed.
-func (p *exporter) markType(t *types.Type) {
-       if p.marked[t] {
-               return
-       }
-       p.marked[t] = true
-
-       // If this is a named type, mark all of its associated
-       // methods. Skip interface types because t.Methods contains
-       // only their unexpanded method set (i.e., exclusive of
-       // interface embeddings), and the switch statement below
-       // handles their full method set.
-       if t.Sym != nil && t.Etype != TINTER {
-               for _, m := range t.Methods().Slice() {
-                       if types.IsExported(m.Sym.Name) {
-                               p.markType(m.Type)
-                       }
-               }
-       }
-
-       // Recursively mark any types that can be produced given a
-       // value of type t: dereferencing a pointer; indexing or
-       // iterating over an array, slice, or map; receiving from a
-       // channel; accessing a struct field or interface method; or
-       // calling a function.
-       //
-       // Notably, we don't mark function parameter types, because
-       // the user already needs some way to construct values of
-       // those types.
-       switch t.Etype {
-       case TPTR, TARRAY, TSLICE:
-               p.markType(t.Elem())
-
-       case TCHAN:
-               if t.ChanDir().CanRecv() {
-                       p.markType(t.Elem())
-               }
-
-       case TMAP:
-               p.markType(t.Key())
-               p.markType(t.Elem())
-
-       case TSTRUCT:
-               for _, f := range t.FieldSlice() {
-                       if types.IsExported(f.Sym.Name) || f.Embedded != 0 {
-                               p.markType(f.Type)
-                       }
-               }
-
-       case TFUNC:
-               // If t is the type of a function or method, then
-               // t.Nname() is its ONAME. Mark its inline body and
-               // any recursively called functions for export.
-               inlFlood(asNode(t.Nname()))
-
-               for _, f := range t.Results().FieldSlice() {
-                       p.markType(f.Type)
-               }
-
-       case TINTER:
-               for _, f := range t.FieldSlice() {
-                       if types.IsExported(f.Sym.Name) {
-                               p.markType(f.Type)
-                       }
-               }
-       }
-}
-
-// ----------------------------------------------------------------------------
-// Export format
-
-// Tags. Must be < 0.
-const (
-       // Objects
-       packageTag = -(iota + 1)
-       constTag
-       typeTag
-       varTag
-       funcTag
-       endTag
-
-       // Types
-       namedTag
-       arrayTag
-       sliceTag
-       dddTag
-       structTag
-       pointerTag
-       signatureTag
-       interfaceTag
-       mapTag
-       chanTag
-
-       // Values
-       falseTag
-       trueTag
-       int64Tag
-       floatTag
-       fractionTag // not used by gc
-       complexTag
-       stringTag
-       nilTag
-       unknownTag // not used by gc (only appears in packages with errors)
-
-       // Type aliases
-       aliasTag
-)
-
-var predecl []*types.Type // initialized lazily
-
-func predeclared() []*types.Type {
-       if predecl == nil {
-               // initialize lazily to be sure that all
-               // elements have been initialized before
-               predecl = []*types.Type{
-                       // basic types
-                       types.Types[TBOOL],
-                       types.Types[TINT],
-                       types.Types[TINT8],
-                       types.Types[TINT16],
-                       types.Types[TINT32],
-                       types.Types[TINT64],
-                       types.Types[TUINT],
-                       types.Types[TUINT8],
-                       types.Types[TUINT16],
-                       types.Types[TUINT32],
-                       types.Types[TUINT64],
-                       types.Types[TUINTPTR],
-                       types.Types[TFLOAT32],
-                       types.Types[TFLOAT64],
-                       types.Types[TCOMPLEX64],
-                       types.Types[TCOMPLEX128],
-                       types.Types[TSTRING],
-
-                       // basic type aliases
-                       types.Bytetype,
-                       types.Runetype,
-
-                       // error
-                       types.Errortype,
-
-                       // untyped types
-                       types.UntypedBool,
-                       types.UntypedInt,
-                       types.UntypedRune,
-                       types.UntypedFloat,
-                       types.UntypedComplex,
-                       types.UntypedString,
-                       types.Types[TNIL],
-
-                       // package unsafe
-                       types.Types[TUNSAFEPTR],
-
-                       // invalid type (package contains errors)
-                       types.Types[Txxx],
-
-                       // any type, for builtin export data
-                       types.Types[TANY],
-               }
-       }
-       return predecl
-}

diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
deleted file mode 100644 (file)
index 911ac4c..0000000
--- a/src/cmd/compile/internal/gc/bimport.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/internal/src"
-)
-
-// numImport tracks how often a package with a given name is imported.
-// It is used to provide a better error message (by using the package
-// path to disambiguate) if a package that appears multiple times with
-// the same name appears in an error message.
-var numImport = make(map[string]int)
-
-func npos(pos src.XPos, n *Node) *Node {
-       n.Pos = pos
-       return n
-}
-
-func builtinCall(op Op) *Node {
-       return nod(OCALL, mkname(builtinpkg.Lookup(goopnames[op])), nil)
-}

diff --git a/src/cmd/compile/internal/gc/bootstrap.go b/src/cmd/compile/internal/gc/bootstrap.go
index 967f75a9ac3a7534e3f8f8182761c4e97526ffa1..2e13d6b57acd443670770bf6c4e18ed1f78995f7 100644 (file)
--- a/src/cmd/compile/internal/gc/bootstrap.go
+++ b/src/cmd/compile/internal/gc/bootstrap.go
@@ -6,8 +6,11 @@
 
 package gc
 
-import "runtime"
+import (
+       "cmd/compile/internal/base"
+       "runtime"
+)
 
 func startMutexProfiling() {
-       Fatalf("mutex profiling unavailable in version %v", runtime.Version())
+       base.Fatalf("mutex profiling unavailable in version %v", runtime.Version())
 }

diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
deleted file mode 100644 (file)
index e04f23e..0000000
--- a/src/cmd/compile/internal/gc/builtin.go
+++ /dev/null
@@ -1,340 +0,0 @@
-// Code generated by mkbuiltin.go. DO NOT EDIT.
-
-package gc
-
-import "cmd/compile/internal/types"
-
-var runtimeDecls = [...]struct {
-       name string
-       tag  int
-       typ  int
-}{
-       {"newobject", funcTag, 4},
-       {"mallocgc", funcTag, 8},
-       {"panicdivide", funcTag, 9},
-       {"panicshift", funcTag, 9},
-       {"panicmakeslicelen", funcTag, 9},
-       {"panicmakeslicecap", funcTag, 9},
-       {"throwinit", funcTag, 9},
-       {"panicwrap", funcTag, 9},
-       {"gopanic", funcTag, 11},
-       {"gorecover", funcTag, 14},
-       {"goschedguarded", funcTag, 9},
-       {"goPanicIndex", funcTag, 16},
-       {"goPanicIndexU", funcTag, 18},
-       {"goPanicSliceAlen", funcTag, 16},
-       {"goPanicSliceAlenU", funcTag, 18},
-       {"goPanicSliceAcap", funcTag, 16},
-       {"goPanicSliceAcapU", funcTag, 18},
-       {"goPanicSliceB", funcTag, 16},
-       {"goPanicSliceBU", funcTag, 18},
-       {"goPanicSlice3Alen", funcTag, 16},
-       {"goPanicSlice3AlenU", funcTag, 18},
-       {"goPanicSlice3Acap", funcTag, 16},
-       {"goPanicSlice3AcapU", funcTag, 18},
-       {"goPanicSlice3B", funcTag, 16},
-       {"goPanicSlice3BU", funcTag, 18},
-       {"goPanicSlice3C", funcTag, 16},
-       {"goPanicSlice3CU", funcTag, 18},
-       {"printbool", funcTag, 19},
-       {"printfloat", funcTag, 21},
-       {"printint", funcTag, 23},
-       {"printhex", funcTag, 25},
-       {"printuint", funcTag, 25},
-       {"printcomplex", funcTag, 27},
-       {"printstring", funcTag, 29},
-       {"printpointer", funcTag, 30},
-       {"printuintptr", funcTag, 31},
-       {"printiface", funcTag, 30},
-       {"printeface", funcTag, 30},
-       {"printslice", funcTag, 30},
-       {"printnl", funcTag, 9},
-       {"printsp", funcTag, 9},
-       {"printlock", funcTag, 9},
-       {"printunlock", funcTag, 9},
-       {"concatstring2", funcTag, 34},
-       {"concatstring3", funcTag, 35},
-       {"concatstring4", funcTag, 36},
-       {"concatstring5", funcTag, 37},
-       {"concatstrings", funcTag, 39},
-       {"cmpstring", funcTag, 40},
-       {"intstring", funcTag, 43},
-       {"slicebytetostring", funcTag, 44},
-       {"slicebytetostringtmp", funcTag, 45},
-       {"slicerunetostring", funcTag, 48},
-       {"stringtoslicebyte", funcTag, 50},
-       {"stringtoslicerune", funcTag, 53},
-       {"slicecopy", funcTag, 54},
-       {"decoderune", funcTag, 55},
-       {"countrunes", funcTag, 56},
-       {"convI2I", funcTag, 57},
-       {"convT16", funcTag, 58},
-       {"convT32", funcTag, 58},
-       {"convT64", funcTag, 58},
-       {"convTstring", funcTag, 58},
-       {"convTslice", funcTag, 58},
-       {"convT2E", funcTag, 59},
-       {"convT2Enoptr", funcTag, 59},
-       {"convT2I", funcTag, 59},
-       {"convT2Inoptr", funcTag, 59},
-       {"assertE2I", funcTag, 57},
-       {"assertE2I2", funcTag, 60},
-       {"assertI2I", funcTag, 57},
-       {"assertI2I2", funcTag, 60},
-       {"panicdottypeE", funcTag, 61},
-       {"panicdottypeI", funcTag, 61},
-       {"panicnildottype", funcTag, 62},
-       {"ifaceeq", funcTag, 64},
-       {"efaceeq", funcTag, 64},
-       {"fastrand", funcTag, 66},
-       {"makemap64", funcTag, 68},
-       {"makemap", funcTag, 69},
-       {"makemap_small", funcTag, 70},
-       {"mapaccess1", funcTag, 71},
-       {"mapaccess1_fast32", funcTag, 72},
-       {"mapaccess1_fast64", funcTag, 72},
-       {"mapaccess1_faststr", funcTag, 72},
-       {"mapaccess1_fat", funcTag, 73},
-       {"mapaccess2", funcTag, 74},
-       {"mapaccess2_fast32", funcTag, 75},
-       {"mapaccess2_fast64", funcTag, 75},
-       {"mapaccess2_faststr", funcTag, 75},
-       {"mapaccess2_fat", funcTag, 76},
-       {"mapassign", funcTag, 71},
-       {"mapassign_fast32", funcTag, 72},
-       {"mapassign_fast32ptr", funcTag, 72},
-       {"mapassign_fast64", funcTag, 72},
-       {"mapassign_fast64ptr", funcTag, 72},
-       {"mapassign_faststr", funcTag, 72},
-       {"mapiterinit", funcTag, 77},
-       {"mapdelete", funcTag, 77},
-       {"mapdelete_fast32", funcTag, 78},
-       {"mapdelete_fast64", funcTag, 78},
-       {"mapdelete_faststr", funcTag, 78},
-       {"mapiternext", funcTag, 79},
-       {"mapclear", funcTag, 80},
-       {"makechan64", funcTag, 82},
-       {"makechan", funcTag, 83},
-       {"chanrecv1", funcTag, 85},
-       {"chanrecv2", funcTag, 86},
-       {"chansend1", funcTag, 88},
-       {"closechan", funcTag, 30},
-       {"writeBarrier", varTag, 90},
-       {"typedmemmove", funcTag, 91},
-       {"typedmemclr", funcTag, 92},
-       {"typedslicecopy", funcTag, 93},
-       {"selectnbsend", funcTag, 94},
-       {"selectnbrecv", funcTag, 95},
-       {"selectnbrecv2", funcTag, 97},
-       {"selectsetpc", funcTag, 98},
-       {"selectgo", funcTag, 99},
-       {"block", funcTag, 9},
-       {"makeslice", funcTag, 100},
-       {"makeslice64", funcTag, 101},
-       {"makeslicecopy", funcTag, 102},
-       {"growslice", funcTag, 104},
-       {"memmove", funcTag, 105},
-       {"memclrNoHeapPointers", funcTag, 106},
-       {"memclrHasPointers", funcTag, 106},
-       {"memequal", funcTag, 107},
-       {"memequal0", funcTag, 108},
-       {"memequal8", funcTag, 108},
-       {"memequal16", funcTag, 108},
-       {"memequal32", funcTag, 108},
-       {"memequal64", funcTag, 108},
-       {"memequal128", funcTag, 108},
-       {"f32equal", funcTag, 109},
-       {"f64equal", funcTag, 109},
-       {"c64equal", funcTag, 109},
-       {"c128equal", funcTag, 109},
-       {"strequal", funcTag, 109},
-       {"interequal", funcTag, 109},
-       {"nilinterequal", funcTag, 109},
-       {"memhash", funcTag, 110},
-       {"memhash0", funcTag, 111},
-       {"memhash8", funcTag, 111},
-       {"memhash16", funcTag, 111},
-       {"memhash32", funcTag, 111},
-       {"memhash64", funcTag, 111},
-       {"memhash128", funcTag, 111},
-       {"f32hash", funcTag, 111},
-       {"f64hash", funcTag, 111},
-       {"c64hash", funcTag, 111},
-       {"c128hash", funcTag, 111},
-       {"strhash", funcTag, 111},
-       {"interhash", funcTag, 111},
-       {"nilinterhash", funcTag, 111},
-       {"int64div", funcTag, 112},
-       {"uint64div", funcTag, 113},
-       {"int64mod", funcTag, 112},
-       {"uint64mod", funcTag, 113},
-       {"float64toint64", funcTag, 114},
-       {"float64touint64", funcTag, 115},
-       {"float64touint32", funcTag, 116},
-       {"int64tofloat64", funcTag, 117},
-       {"uint64tofloat64", funcTag, 118},
-       {"uint32tofloat64", funcTag, 119},
-       {"complex128div", funcTag, 120},
-       {"racefuncenter", funcTag, 31},
-       {"racefuncenterfp", funcTag, 9},
-       {"racefuncexit", funcTag, 9},
-       {"raceread", funcTag, 31},
-       {"racewrite", funcTag, 31},
-       {"racereadrange", funcTag, 121},
-       {"racewriterange", funcTag, 121},
-       {"msanread", funcTag, 121},
-       {"msanwrite", funcTag, 121},
-       {"msanmove", funcTag, 122},
-       {"checkptrAlignment", funcTag, 123},
-       {"checkptrArithmetic", funcTag, 125},
-       {"libfuzzerTraceCmp1", funcTag, 127},
-       {"libfuzzerTraceCmp2", funcTag, 129},
-       {"libfuzzerTraceCmp4", funcTag, 130},
-       {"libfuzzerTraceCmp8", funcTag, 131},
-       {"libfuzzerTraceConstCmp1", funcTag, 127},
-       {"libfuzzerTraceConstCmp2", funcTag, 129},
-       {"libfuzzerTraceConstCmp4", funcTag, 130},
-       {"libfuzzerTraceConstCmp8", funcTag, 131},
-       {"x86HasPOPCNT", varTag, 6},
-       {"x86HasSSE41", varTag, 6},
-       {"x86HasFMA", varTag, 6},
-       {"armHasVFPv4", varTag, 6},
-       {"arm64HasATOMICS", varTag, 6},
-}
-
-func runtimeTypes() []*types.Type {
-       var typs [132]*types.Type
-       typs[0] = types.Bytetype
-       typs[1] = types.NewPtr(typs[0])
-       typs[2] = types.Types[TANY]
-       typs[3] = types.NewPtr(typs[2])
-       typs[4] = functype(nil, []*Node{anonfield(typs[1])}, []*Node{anonfield(typs[3])})
-       typs[5] = types.Types[TUINTPTR]
-       typs[6] = types.Types[TBOOL]
-       typs[7] = types.Types[TUNSAFEPTR]
-       typs[8] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*Node{anonfield(typs[7])})
-       typs[9] = functype(nil, nil, nil)
-       typs[10] = types.Types[TINTER]
-       typs[11] = functype(nil, []*Node{anonfield(typs[10])}, nil)
-       typs[12] = types.Types[TINT32]
-       typs[13] = types.NewPtr(typs[12])
-       typs[14] = functype(nil, []*Node{anonfield(typs[13])}, []*Node{anonfield(typs[10])})
-       typs[15] = types.Types[TINT]
-       typs[16] = functype(nil, []*Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
-       typs[17] = types.Types[TUINT]
-       typs[18] = functype(nil, []*Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
-       typs[19] = functype(nil, []*Node{anonfield(typs[6])}, nil)
-       typs[20] = types.Types[TFLOAT64]
-       typs[21] = functype(nil, []*Node{anonfield(typs[20])}, nil)
-       typs[22] = types.Types[TINT64]
-       typs[23] = functype(nil, []*Node{anonfield(typs[22])}, nil)
-       typs[24] = types.Types[TUINT64]
-       typs[25] = functype(nil, []*Node{anonfield(typs[24])}, nil)
-       typs[26] = types.Types[TCOMPLEX128]
-       typs[27] = functype(nil, []*Node{anonfield(typs[26])}, nil)
-       typs[28] = types.Types[TSTRING]
-       typs[29] = functype(nil, []*Node{anonfield(typs[28])}, nil)
-       typs[30] = functype(nil, []*Node{anonfield(typs[2])}, nil)
-       typs[31] = functype(nil, []*Node{anonfield(typs[5])}, nil)
-       typs[32] = types.NewArray(typs[0], 32)
-       typs[33] = types.NewPtr(typs[32])
-       typs[34] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-       typs[35] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-       typs[36] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-       typs[37] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-       typs[38] = types.NewSlice(typs[28])
-       typs[39] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[38])}, []*Node{anonfield(typs[28])})
-       typs[40] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[15])})
-       typs[41] = types.NewArray(typs[0], 4)
-       typs[42] = types.NewPtr(typs[41])
-       typs[43] = functype(nil, []*Node{anonfield(typs[42]), anonfield(typs[22])}, []*Node{anonfield(typs[28])})
-       typs[44] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
-       typs[45] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
-       typs[46] = types.Runetype
-       typs[47] = types.NewSlice(typs[46])
-       typs[48] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[47])}, []*Node{anonfield(typs[28])})
-       typs[49] = types.NewSlice(typs[0])
-       typs[50] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28])}, []*Node{anonfield(typs[49])})
-       typs[51] = types.NewArray(typs[46], 32)
-       typs[52] = types.NewPtr(typs[51])
-       typs[53] = functype(nil, []*Node{anonfield(typs[52]), anonfield(typs[28])}, []*Node{anonfield(typs[47])})
-       typs[54] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*Node{anonfield(typs[15])})
-       typs[55] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[15])}, []*Node{anonfield(typs[46]), anonfield(typs[15])})
-       typs[56] = functype(nil, []*Node{anonfield(typs[28])}, []*Node{anonfield(typs[15])})
-       typs[57] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2])})
-       typs[58] = functype(nil, []*Node{anonfield(typs[2])}, []*Node{anonfield(typs[7])})
-       typs[59] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, []*Node{anonfield(typs[2])})
-       typs[60] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2]), anonfield(typs[6])})
-       typs[61] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
-       typs[62] = functype(nil, []*Node{anonfield(typs[1])}, nil)
-       typs[63] = types.NewPtr(typs[5])
-       typs[64] = functype(nil, []*Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
-       typs[65] = types.Types[TUINT32]
-       typs[66] = functype(nil, nil, []*Node{anonfield(typs[65])})
-       typs[67] = types.NewMap(typs[2], typs[2])
-       typs[68] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
-       typs[69] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
-       typs[70] = functype(nil, nil, []*Node{anonfield(typs[67])})
-       typs[71] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3])})
-       typs[72] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3])})
-       typs[73] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3])})
-       typs[74] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-       typs[75] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-       typs[76] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-       typs[77] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
-       typs[78] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
-       typs[79] = functype(nil, []*Node{anonfield(typs[3])}, nil)
-       typs[80] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
-       typs[81] = types.NewChan(typs[2], types.Cboth)
-       typs[82] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22])}, []*Node{anonfield(typs[81])})
-       typs[83] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[81])})
-       typs[84] = types.NewChan(typs[2], types.Crecv)
-       typs[85] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
-       typs[86] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
-       typs[87] = types.NewChan(typs[2], types.Csend)
-       typs[88] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
-       typs[89] = types.NewArray(typs[0], 3)
-       typs[90] = tostruct([]*Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
-       typs[91] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
-       typs[92] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
-       typs[93] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*Node{anonfield(typs[15])})
-       typs[94] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
-       typs[95] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
-       typs[96] = types.NewPtr(typs[6])
-       typs[97] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
-       typs[98] = functype(nil, []*Node{anonfield(typs[63])}, nil)
-       typs[99] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*Node{anonfield(typs[15]), anonfield(typs[6])})
-       typs[100] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*Node{anonfield(typs[7])})
-       typs[101] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[7])})
-       typs[102] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*Node{anonfield(typs[7])})
-       typs[103] = types.NewSlice(typs[2])
-       typs[104] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*Node{anonfield(typs[103])})
-       typs[105] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
-       typs[106] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
-       typs[107] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*Node{anonfield(typs[6])})
-       typs[108] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
-       typs[109] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
-       typs[110] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
-       typs[111] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
-       typs[112] = functype(nil, []*Node{anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[22])})
-       typs[113] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, []*Node{anonfield(typs[24])})
-       typs[114] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[22])})
-       typs[115] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[24])})
-       typs[116] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[65])})
-       typs[117] = functype(nil, []*Node{anonfield(typs[22])}, []*Node{anonfield(typs[20])})
-       typs[118] = functype(nil, []*Node{anonfield(typs[24])}, []*Node{anonfield(typs[20])})
-       typs[119] = functype(nil, []*Node{anonfield(typs[65])}, []*Node{anonfield(typs[20])})
-       typs[120] = functype(nil, []*Node{anonfield(typs[26]), anonfield(typs[26])}, []*Node{anonfield(typs[26])})
-       typs[121] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
-       typs[122] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[5]), anonfield(typs[5])}, nil)
-       typs[123] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
-       typs[124] = types.NewSlice(typs[7])
-       typs[125] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[124])}, nil)
-       typs[126] = types.Types[TUINT8]
-       typs[127] = functype(nil, []*Node{anonfield(typs[126]), anonfield(typs[126])}, nil)
-       typs[128] = types.Types[TUINT16]
-       typs[129] = functype(nil, []*Node{anonfield(typs[128]), anonfield(typs[128])}, nil)
-       typs[130] = functype(nil, []*Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
-       typs[131] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
-       return typs[:]
-}

diff --git a/src/cmd/compile/internal/gc/bv.go b/src/cmd/compile/internal/gc/bv.go
deleted file mode 100644 (file)
index e32ab97..0000000
--- a/src/cmd/compile/internal/gc/bv.go
+++ /dev/null
@@ -1,278 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "math/bits"
-)
-
-const (
-       wordBits  = 32
-       wordMask  = wordBits - 1
-       wordShift = 5
-)
-
-// A bvec is a bit vector.
-type bvec struct {
-       n int32    // number of bits in vector
-       b []uint32 // words holding bits
-}
-
-func bvalloc(n int32) bvec {
-       nword := (n + wordBits - 1) / wordBits
-       return bvec{n, make([]uint32, nword)}
-}
-
-type bulkBvec struct {
-       words []uint32
-       nbit  int32
-       nword int32
-}
-
-func bvbulkalloc(nbit int32, count int32) bulkBvec {
-       nword := (nbit + wordBits - 1) / wordBits
-       size := int64(nword) * int64(count)
-       if int64(int32(size*4)) != size*4 {
-               Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
-       }
-       return bulkBvec{
-               words: make([]uint32, size),
-               nbit:  nbit,
-               nword: nword,
-       }
-}
-
-func (b *bulkBvec) next() bvec {
-       out := bvec{b.nbit, b.words[:b.nword]}
-       b.words = b.words[b.nword:]
-       return out
-}
-
-func (bv1 bvec) Eq(bv2 bvec) bool {
-       if bv1.n != bv2.n {
-               Fatalf("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
-       }
-       for i, x := range bv1.b {
-               if x != bv2.b[i] {
-                       return false
-               }
-       }
-       return true
-}
-
-func (dst bvec) Copy(src bvec) {
-       copy(dst.b, src.b)
-}
-
-func (bv bvec) Get(i int32) bool {
-       if i < 0 || i >= bv.n {
-               Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.n)
-       }
-       mask := uint32(1 << uint(i%wordBits))
-       return bv.b[i>>wordShift]&mask != 0
-}
-
-func (bv bvec) Set(i int32) {
-       if i < 0 || i >= bv.n {
-               Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.n)
-       }
-       mask := uint32(1 << uint(i%wordBits))
-       bv.b[i/wordBits] |= mask
-}
-
-func (bv bvec) Unset(i int32) {
-       if i < 0 || i >= bv.n {
-               Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.n)
-       }
-       mask := uint32(1 << uint(i%wordBits))
-       bv.b[i/wordBits] &^= mask
-}
-
-// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
-// If there is no such index, bvnext returns -1.
-func (bv bvec) Next(i int32) int32 {
-       if i >= bv.n {
-               return -1
-       }
-
-       // Jump i ahead to next word with bits.
-       if bv.b[i>>wordShift]>>uint(i&wordMask) == 0 {
-               i &^= wordMask
-               i += wordBits
-               for i < bv.n && bv.b[i>>wordShift] == 0 {
-                       i += wordBits
-               }
-       }
-
-       if i >= bv.n {
-               return -1
-       }
-
-       // Find 1 bit.
-       w := bv.b[i>>wordShift] >> uint(i&wordMask)
-       i += int32(bits.TrailingZeros32(w))
-
-       return i
-}
-
-func (bv bvec) IsEmpty() bool {
-       for _, x := range bv.b {
-               if x != 0 {
-                       return false
-               }
-       }
-       return true
-}
-
-func (bv bvec) Not() {
-       for i, x := range bv.b {
-               bv.b[i] = ^x
-       }
-}
-
-// union
-func (dst bvec) Or(src1, src2 bvec) {
-       if len(src1.b) == 0 {
-               return
-       }
-       _, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-       for i, x := range src1.b {
-               dst.b[i] = x | src2.b[i]
-       }
-}
-
-// intersection
-func (dst bvec) And(src1, src2 bvec) {
-       if len(src1.b) == 0 {
-               return
-       }
-       _, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-       for i, x := range src1.b {
-               dst.b[i] = x & src2.b[i]
-       }
-}
-
-// difference
-func (dst bvec) AndNot(src1, src2 bvec) {
-       if len(src1.b) == 0 {
-               return
-       }
-       _, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-       for i, x := range src1.b {
-               dst.b[i] = x &^ src2.b[i]
-       }
-}
-
-func (bv bvec) String() string {
-       s := make([]byte, 2+bv.n)
-       copy(s, "#*")
-       for i := int32(0); i < bv.n; i++ {
-               ch := byte('0')
-               if bv.Get(i) {
-                       ch = '1'
-               }
-               s[2+i] = ch
-       }
-       return string(s)
-}
-
-func (bv bvec) Clear() {
-       for i := range bv.b {
-               bv.b[i] = 0
-       }
-}
-
-// FNV-1 hash function constants.
-const (
-       H0 = 2166136261
-       Hp = 16777619
-)
-
-func hashbitmap(h uint32, bv bvec) uint32 {
-       n := int((bv.n + 31) / 32)
-       for i := 0; i < n; i++ {
-               w := bv.b[i]
-               h = (h * Hp) ^ (w & 0xff)
-               h = (h * Hp) ^ ((w >> 8) & 0xff)
-               h = (h * Hp) ^ ((w >> 16) & 0xff)
-               h = (h * Hp) ^ ((w >> 24) & 0xff)
-       }
-
-       return h
-}
-
-// bvecSet is a set of bvecs, in initial insertion order.
-type bvecSet struct {
-       index []int  // hash -> uniq index. -1 indicates empty slot.
-       uniq  []bvec // unique bvecs, in insertion order
-}
-
-func (m *bvecSet) grow() {
-       // Allocate new index.
-       n := len(m.index) * 2
-       if n == 0 {
-               n = 32
-       }
-       newIndex := make([]int, n)
-       for i := range newIndex {
-               newIndex[i] = -1
-       }
-
-       // Rehash into newIndex.
-       for i, bv := range m.uniq {
-               h := hashbitmap(H0, bv) % uint32(len(newIndex))
-               for {
-                       j := newIndex[h]
-                       if j < 0 {
-                               newIndex[h] = i
-                               break
-                       }
-                       h++
-                       if h == uint32(len(newIndex)) {
-                               h = 0
-                       }
-               }
-       }
-       m.index = newIndex
-}
-
-// add adds bv to the set and returns its index in m.extractUniqe.
-// The caller must not modify bv after this.
-func (m *bvecSet) add(bv bvec) int {
-       if len(m.uniq)*4 >= len(m.index) {
-               m.grow()
-       }
-
-       index := m.index
-       h := hashbitmap(H0, bv) % uint32(len(index))
-       for {
-               j := index[h]
-               if j < 0 {
-                       // New bvec.
-                       index[h] = len(m.uniq)
-                       m.uniq = append(m.uniq, bv)
-                       return len(m.uniq) - 1
-               }
-               jlive := m.uniq[j]
-               if bv.Eq(jlive) {
-                       // Existing bvec.
-                       return j
-               }
-
-               h++
-               if h == uint32(len(index)) {
-                       h = 0
-               }
-       }
-}
-
-// extractUniqe returns this slice of unique bit vectors in m, as
-// indexed by the result of bvecSet.add.
-func (m *bvecSet) extractUniqe() []bvec {
-       return m.uniq
-}

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
deleted file mode 100644 (file)
index bd350f6..0000000
--- a/src/cmd/compile/internal/gc/closure.go
+++ /dev/null
@@ -1,594 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/syntax"
-       "cmd/compile/internal/types"
-       "fmt"
-)
-
-func (p *noder) funcLit(expr *syntax.FuncLit) *Node {
-       xtype := p.typeExpr(expr.Type)
-       ntype := p.typeExpr(expr.Type)
-
-       xfunc := p.nod(expr, ODCLFUNC, nil, nil)
-       xfunc.Func.SetIsHiddenClosure(Curfn != nil)
-       xfunc.Func.Nname = newfuncnamel(p.pos(expr), nblank.Sym) // filled in by typecheckclosure
-       xfunc.Func.Nname.Name.Param.Ntype = xtype
-       xfunc.Func.Nname.Name.Defn = xfunc
-
-       clo := p.nod(expr, OCLOSURE, nil, nil)
-       clo.Func.Ntype = ntype
-
-       xfunc.Func.Closure = clo
-       clo.Func.Closure = xfunc
-
-       p.funcBody(xfunc, expr.Body)
-
-       // closure-specific variables are hanging off the
-       // ordinary ones in the symbol table; see oldname.
-       // unhook them.
-       // make the list of pointers for the closure call.
-       for _, v := range xfunc.Func.Cvars.Slice() {
-               // Unlink from v1; see comment in syntax.go type Param for these fields.
-               v1 := v.Name.Defn
-               v1.Name.Param.Innermost = v.Name.Param.Outer
-
-               // If the closure usage of v is not dense,
-               // we need to make it dense; now that we're out
-               // of the function in which v appeared,
-               // look up v.Sym in the enclosing function
-               // and keep it around for use in the compiled code.
-               //
-               // That is, suppose we just finished parsing the innermost
-               // closure f4 in this code:
-               //
-               //      func f() {
-               //              v := 1
-               //              func() { // f2
-               //                      use(v)
-               //                      func() { // f3
-               //                              func() { // f4
-               //                                      use(v)
-               //                              }()
-               //                      }()
-               //              }()
-               //      }
-               //
-               // At this point v.Outer is f2's v; there is no f3's v.
-               // To construct the closure f4 from within f3,
-               // we need to use f3's v and in this case we need to create f3's v.
-               // We are now in the context of f3, so calling oldname(v.Sym)
-               // obtains f3's v, creating it if necessary (as it is in the example).
-               //
-               // capturevars will decide whether to use v directly or &v.
-               v.Name.Param.Outer = oldname(v.Sym)
-       }
-
-       return clo
-}
-
-// typecheckclosure typechecks an OCLOSURE node. It also creates the named
-// function associated with the closure.
-// TODO: This creation of the named function should probably really be done in a
-// separate pass from type-checking.
-func typecheckclosure(clo *Node, top int) {
-       xfunc := clo.Func.Closure
-       // Set current associated iota value, so iota can be used inside
-       // function in ConstSpec, see issue #22344
-       if x := getIotaValue(); x >= 0 {
-               xfunc.SetIota(x)
-       }
-
-       clo.Func.Ntype = typecheck(clo.Func.Ntype, ctxType)
-       clo.Type = clo.Func.Ntype.Type
-       clo.Func.Top = top
-
-       // Do not typecheck xfunc twice, otherwise, we will end up pushing
-       // xfunc to xtop multiple times, causing initLSym called twice.
-       // See #30709
-       if xfunc.Typecheck() == 1 {
-               return
-       }
-
-       for _, ln := range xfunc.Func.Cvars.Slice() {
-               n := ln.Name.Defn
-               if !n.Name.Captured() {
-                       n.Name.SetCaptured(true)
-                       if n.Name.Decldepth == 0 {
-                               Fatalf("typecheckclosure: var %S does not have decldepth assigned", n)
-                       }
-
-                       // Ignore assignments to the variable in straightline code
-                       // preceding the first capturing by a closure.
-                       if n.Name.Decldepth == decldepth {
-                               n.Name.SetAssigned(false)
-                       }
-               }
-       }
-
-       xfunc.Func.Nname.Sym = closurename(Curfn)
-       setNodeNameFunc(xfunc.Func.Nname)
-       xfunc = typecheck(xfunc, ctxStmt)
-
-       // Type check the body now, but only if we're inside a function.
-       // At top level (in a variable initialization: curfn==nil) we're not
-       // ready to type check code yet; we'll check it later, because the
-       // underlying closure function we create is added to xtop.
-       if Curfn != nil && clo.Type != nil {
-               oldfn := Curfn
-               Curfn = xfunc
-               olddd := decldepth
-               decldepth = 1
-               typecheckslice(xfunc.Nbody.Slice(), ctxStmt)
-               decldepth = olddd
-               Curfn = oldfn
-       }
-
-       xtop = append(xtop, xfunc)
-}
-
-// globClosgen is like Func.Closgen, but for the global scope.
-var globClosgen int
-
-// closurename generates a new unique name for a closure within
-// outerfunc.
-func closurename(outerfunc *Node) *types.Sym {
-       outer := "glob."
-       prefix := "func"
-       gen := &globClosgen
-
-       if outerfunc != nil {
-               if outerfunc.Func.Closure != nil {
-                       prefix = ""
-               }
-
-               outer = outerfunc.funcname()
-
-               // There may be multiple functions named "_". In those
-               // cases, we can't use their individual Closgens as it
-               // would lead to name clashes.
-               if !outerfunc.Func.Nname.isBlank() {
-                       gen = &outerfunc.Func.Closgen
-               }
-       }
-
-       *gen++
-       return lookup(fmt.Sprintf("%s.%s%d", outer, prefix, *gen))
-}
-
-// capturevarscomplete is set to true when the capturevars phase is done.
-var capturevarscomplete bool
-
-// capturevars is called in a separate phase after all typechecking is done.
-// It decides whether each variable captured by a closure should be captured
-// by value or by reference.
-// We use value capturing for values <= 128 bytes that are never reassigned
-// after capturing (effectively constant).
-func capturevars(xfunc *Node) {
-       lno := lineno
-       lineno = xfunc.Pos
-
-       clo := xfunc.Func.Closure
-       cvars := xfunc.Func.Cvars.Slice()
-       out := cvars[:0]
-       for _, v := range cvars {
-               if v.Type == nil {
-                       // If v.Type is nil, it means v looked like it
-                       // was going to be used in the closure, but
-                       // isn't. This happens in struct literals like
-                       // s{f: x} where we can't distinguish whether
-                       // f is a field identifier or expression until
-                       // resolving s.
-                       continue
-               }
-               out = append(out, v)
-
-               // type check the & of closed variables outside the closure,
-               // so that the outer frame also grabs them and knows they escape.
-               dowidth(v.Type)
-
-               outer := v.Name.Param.Outer
-               outermost := v.Name.Defn
-
-               // out parameters will be assigned to implicitly upon return.
-               if outermost.Class() != PPARAMOUT && !outermost.Name.Addrtaken() && !outermost.Name.Assigned() && v.Type.Width <= 128 {
-                       v.Name.SetByval(true)
-               } else {
-                       outermost.Name.SetAddrtaken(true)
-                       outer = nod(OADDR, outer, nil)
-               }
-
-               if Debug.m > 1 {
-                       var name *types.Sym
-                       if v.Name.Curfn != nil && v.Name.Curfn.Func.Nname != nil {
-                               name = v.Name.Curfn.Func.Nname.Sym
-                       }
-                       how := "ref"
-                       if v.Name.Byval() {
-                               how = "value"
-                       }
-                       Warnl(v.Pos, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, outermost.Name.Addrtaken(), outermost.Name.Assigned(), int32(v.Type.Width))
-               }
-
-               outer = typecheck(outer, ctxExpr)
-               clo.Func.Enter.Append(outer)
-       }
-
-       xfunc.Func.Cvars.Set(out)
-       lineno = lno
-}
-
-// transformclosure is called in a separate phase after escape analysis.
-// It transform closure bodies to properly reference captured variables.
-func transformclosure(xfunc *Node) {
-       lno := lineno
-       lineno = xfunc.Pos
-       clo := xfunc.Func.Closure
-
-       if clo.Func.Top&ctxCallee != 0 {
-               // If the closure is directly called, we transform it to a plain function call
-               // with variables passed as args. This avoids allocation of a closure object.
-               // Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
-               // will complete the transformation later.
-               // For illustration, the following closure:
-               //      func(a int) {
-               //              println(byval)
-               //              byref++
-               //      }(42)
-               // becomes:
-               //      func(byval int, &byref *int, a int) {
-               //              println(byval)
-               //              (*&byref)++
-               //      }(byval, &byref, 42)
-
-               // f is ONAME of the actual function.
-               f := xfunc.Func.Nname
-
-               // We are going to insert captured variables before input args.
-               var params []*types.Field
-               var decls []*Node
-               for _, v := range xfunc.Func.Cvars.Slice() {
-                       if !v.Name.Byval() {
-                               // If v of type T is captured by reference,
-                               // we introduce function param &v *T
-                               // and v remains PAUTOHEAP with &v heapaddr
-                               // (accesses will implicitly deref &v).
-                               addr := newname(lookup("&" + v.Sym.Name))
-                               addr.Type = types.NewPtr(v.Type)
-                               v.Name.Param.Heapaddr = addr
-                               v = addr
-                       }
-
-                       v.SetClass(PPARAM)
-                       decls = append(decls, v)
-
-                       fld := types.NewField()
-                       fld.Nname = asTypesNode(v)
-                       fld.Type = v.Type
-                       fld.Sym = v.Sym
-                       params = append(params, fld)
-               }
-
-               if len(params) > 0 {
-                       // Prepend params and decls.
-                       f.Type.Params().SetFields(append(params, f.Type.Params().FieldSlice()...))
-                       xfunc.Func.Dcl = append(decls, xfunc.Func.Dcl...)
-               }
-
-               dowidth(f.Type)
-               xfunc.Type = f.Type // update type of ODCLFUNC
-       } else {
-               // The closure is not called, so it is going to stay as closure.
-               var body []*Node
-               offset := int64(Widthptr)
-               for _, v := range xfunc.Func.Cvars.Slice() {
-                       // cv refers to the field inside of closure OSTRUCTLIT.
-                       cv := nod(OCLOSUREVAR, nil, nil)
-
-                       cv.Type = v.Type
-                       if !v.Name.Byval() {
-                               cv.Type = types.NewPtr(v.Type)
-                       }
-                       offset = Rnd(offset, int64(cv.Type.Align))
-                       cv.Xoffset = offset
-                       offset += cv.Type.Width
-
-                       if v.Name.Byval() && v.Type.Width <= int64(2*Widthptr) {
-                               // If it is a small variable captured by value, downgrade it to PAUTO.
-                               v.SetClass(PAUTO)
-                               xfunc.Func.Dcl = append(xfunc.Func.Dcl, v)
-                               body = append(body, nod(OAS, v, cv))
-                       } else {
-                               // Declare variable holding addresses taken from closure
-                               // and initialize in entry prologue.
-                               addr := newname(lookup("&" + v.Sym.Name))
-                               addr.Type = types.NewPtr(v.Type)
-                               addr.SetClass(PAUTO)
-                               addr.Name.SetUsed(true)
-                               addr.Name.Curfn = xfunc
-                               xfunc.Func.Dcl = append(xfunc.Func.Dcl, addr)
-                               v.Name.Param.Heapaddr = addr
-                               if v.Name.Byval() {
-                                       cv = nod(OADDR, cv, nil)
-                               }
-                               body = append(body, nod(OAS, addr, cv))
-                       }
-               }
-
-               if len(body) > 0 {
-                       typecheckslice(body, ctxStmt)
-                       xfunc.Func.Enter.Set(body)
-                       xfunc.Func.SetNeedctxt(true)
-               }
-       }
-
-       lineno = lno
-}
-
-// hasemptycvars reports whether closure clo has an
-// empty list of captured vars.
-func hasemptycvars(clo *Node) bool {
-       xfunc := clo.Func.Closure
-       return xfunc.Func.Cvars.Len() == 0
-}
-
-// closuredebugruntimecheck applies boilerplate checks for debug flags
-// and compiling runtime
-func closuredebugruntimecheck(clo *Node) {
-       if Debug_closure > 0 {
-               xfunc := clo.Func.Closure
-               if clo.Esc == EscHeap {
-                       Warnl(clo.Pos, "heap closure, captured vars = %v", xfunc.Func.Cvars)
-               } else {
-                       Warnl(clo.Pos, "stack closure, captured vars = %v", xfunc.Func.Cvars)
-               }
-       }
-       if compiling_runtime && clo.Esc == EscHeap {
-               yyerrorl(clo.Pos, "heap-allocated closure, not allowed in runtime")
-       }
-}
-
-// closureType returns the struct type used to hold all the information
-// needed in the closure for clo (clo must be a OCLOSURE node).
-// The address of a variable of the returned type can be cast to a func.
-func closureType(clo *Node) *types.Type {
-       // Create closure in the form of a composite literal.
-       // supposing the closure captures an int i and a string s
-       // and has one float64 argument and no results,
-       // the generated code looks like:
-       //
-       //      clos = &struct{.F uintptr; i *int; s *string}{func.1, &i, &s}
-       //
-       // The use of the struct provides type information to the garbage
-       // collector so that it can walk the closure. We could use (in this case)
-       // [3]unsafe.Pointer instead, but that would leave the gc in the dark.
-       // The information appears in the binary in the form of type descriptors;
-       // the struct is unnamed so that closures in multiple packages with the
-       // same struct type can share the descriptor.
-       fields := []*Node{
-               namedfield(".F", types.Types[TUINTPTR]),
-       }
-       for _, v := range clo.Func.Closure.Func.Cvars.Slice() {
-               typ := v.Type
-               if !v.Name.Byval() {
-                       typ = types.NewPtr(typ)
-               }
-               fields = append(fields, symfield(v.Sym, typ))
-       }
-       typ := tostruct(fields)
-       typ.SetNoalg(true)
-       return typ
-}
-
-func walkclosure(clo *Node, init *Nodes) *Node {
-       xfunc := clo.Func.Closure
-
-       // If no closure vars, don't bother wrapping.
-       if hasemptycvars(clo) {
-               if Debug_closure > 0 {
-                       Warnl(clo.Pos, "closure converted to global")
-               }
-               return xfunc.Func.Nname
-       }
-       closuredebugruntimecheck(clo)
-
-       typ := closureType(clo)
-
-       clos := nod(OCOMPLIT, nil, typenod(typ))
-       clos.Esc = clo.Esc
-       clos.List.Set(append([]*Node{nod(OCFUNC, xfunc.Func.Nname, nil)}, clo.Func.Enter.Slice()...))
-
-       clos = nod(OADDR, clos, nil)
-       clos.Esc = clo.Esc
-
-       // Force type conversion from *struct to the func type.
-       clos = convnop(clos, clo.Type)
-
-       // non-escaping temp to use, if any.
-       if x := prealloc[clo]; x != nil {
-               if !types.Identical(typ, x.Type) {
-                       panic("closure type does not match order's assigned type")
-               }
-               clos.Left.Right = x
-               delete(prealloc, clo)
-       }
-
-       return walkexpr(clos, init)
-}
-
-func typecheckpartialcall(fn *Node, sym *types.Sym) {
-       switch fn.Op {
-       case ODOTINTER, ODOTMETH:
-               break
-
-       default:
-               Fatalf("invalid typecheckpartialcall")
-       }
-
-       // Create top-level function.
-       xfunc := makepartialcall(fn, fn.Type, sym)
-       fn.Func = xfunc.Func
-       fn.Func.SetWrapper(true)
-       fn.Right = newname(sym)
-       fn.Op = OCALLPART
-       fn.Type = xfunc.Type
-}
-
-// makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
-// for partial calls.
-func makepartialcall(fn *Node, t0 *types.Type, meth *types.Sym) *Node {
-       rcvrtype := fn.Left.Type
-       sym := methodSymSuffix(rcvrtype, meth, "-fm")
-
-       if sym.Uniq() {
-               return asNode(sym.Def)
-       }
-       sym.SetUniq(true)
-
-       savecurfn := Curfn
-       saveLineNo := lineno
-       Curfn = nil
-
-       // Set line number equal to the line number where the method is declared.
-       var m *types.Field
-       if lookdot0(meth, rcvrtype, &m, false) == 1 && m.Pos.IsKnown() {
-               lineno = m.Pos
-       }
-       // Note: !m.Pos.IsKnown() happens for method expressions where
-       // the method is implicitly declared. The Error method of the
-       // built-in error type is one such method.  We leave the line
-       // number at the use of the method expression in this
-       // case. See issue 29389.
-
-       tfn := nod(OTFUNC, nil, nil)
-       tfn.List.Set(structargs(t0.Params(), true))
-       tfn.Rlist.Set(structargs(t0.Results(), false))
-
-       xfunc := dclfunc(sym, tfn)
-       xfunc.Func.SetDupok(true)
-       xfunc.Func.SetNeedctxt(true)
-
-       tfn.Type.SetPkg(t0.Pkg())
-
-       // Declare and initialize variable holding receiver.
-
-       cv := nod(OCLOSUREVAR, nil, nil)
-       cv.Type = rcvrtype
-       cv.Xoffset = Rnd(int64(Widthptr), int64(cv.Type.Align))
-
-       ptr := newname(lookup(".this"))
-       declare(ptr, PAUTO)
-       ptr.Name.SetUsed(true)
-       var body []*Node
-       if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
-               ptr.Type = rcvrtype
-               body = append(body, nod(OAS, ptr, cv))
-       } else {
-               ptr.Type = types.NewPtr(rcvrtype)
-               body = append(body, nod(OAS, ptr, nod(OADDR, cv, nil)))
-       }
-
-       call := nod(OCALL, nodSym(OXDOT, ptr, meth), nil)
-       call.List.Set(paramNnames(tfn.Type))
-       call.SetIsDDD(tfn.Type.IsVariadic())
-       if t0.NumResults() != 0 {
-               n := nod(ORETURN, nil, nil)
-               n.List.Set1(call)
-               call = n
-       }
-       body = append(body, call)
-
-       xfunc.Nbody.Set(body)
-       funcbody()
-
-       xfunc = typecheck(xfunc, ctxStmt)
-       // Need to typecheck the body of the just-generated wrapper.
-       // typecheckslice() requires that Curfn is set when processing an ORETURN.
-       Curfn = xfunc
-       typecheckslice(xfunc.Nbody.Slice(), ctxStmt)
-       sym.Def = asTypesNode(xfunc)
-       xtop = append(xtop, xfunc)
-       Curfn = savecurfn
-       lineno = saveLineNo
-
-       return xfunc
-}
-
-// partialCallType returns the struct type used to hold all the information
-// needed in the closure for n (n must be a OCALLPART node).
-// The address of a variable of the returned type can be cast to a func.
-func partialCallType(n *Node) *types.Type {
-       t := tostruct([]*Node{
-               namedfield("F", types.Types[TUINTPTR]),
-               namedfield("R", n.Left.Type),
-       })
-       t.SetNoalg(true)
-       return t
-}
-
-func walkpartialcall(n *Node, init *Nodes) *Node {
-       // Create closure in the form of a composite literal.
-       // For x.M with receiver (x) type T, the generated code looks like:
-       //
-       //      clos = &struct{F uintptr; R T}{T.M·f, x}
-       //
-       // Like walkclosure above.
-
-       if n.Left.Type.IsInterface() {
-               // Trigger panic for method on nil interface now.
-               // Otherwise it happens in the wrapper and is confusing.
-               n.Left = cheapexpr(n.Left, init)
-               n.Left = walkexpr(n.Left, nil)
-
-               tab := nod(OITAB, n.Left, nil)
-               tab = typecheck(tab, ctxExpr)
-
-               c := nod(OCHECKNIL, tab, nil)
-               c.SetTypecheck(1)
-               init.Append(c)
-       }
-
-       typ := partialCallType(n)
-
-       clos := nod(OCOMPLIT, nil, typenod(typ))
-       clos.Esc = n.Esc
-       clos.List.Set2(nod(OCFUNC, n.Func.Nname, nil), n.Left)
-
-       clos = nod(OADDR, clos, nil)
-       clos.Esc = n.Esc
-
-       // Force type conversion from *struct to the func type.
-       clos = convnop(clos, n.Type)
-
-       // non-escaping temp to use, if any.
-       if x := prealloc[n]; x != nil {
-               if !types.Identical(typ, x.Type) {
-                       panic("partial call type does not match order's assigned type")
-               }
-               clos.Left.Right = x
-               delete(prealloc, n)
-       }
-
-       return walkexpr(clos, init)
-}
-
-// callpartMethod returns the *types.Field representing the method
-// referenced by method value n.
-func callpartMethod(n *Node) *types.Field {
-       if n.Op != OCALLPART {
-               Fatalf("expected OCALLPART, got %v", n)
-       }
-
-       // TODO(mdempsky): Optimize this. If necessary,
-       // makepartialcall could save m for us somewhere.
-       var m *types.Field
-       if lookdot0(n.Right.Sym, n.Left.Type, &m, false) != 1 {
-               Fatalf("failed to find field for OCALLPART")
-       }
-
-       return m
-}

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
new file mode 100644 (file)
index 0000000..ba67c58
--- /dev/null
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -0,0 +1,147 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gc
+
+import (
+       "internal/race"
+       "math/rand"
+       "sort"
+       "sync"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/liveness"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/compile/internal/walk"
+)
+
+// "Portable" code generation.
+
+var (
+       compilequeue []*ir.Func // functions waiting to be compiled
+)
+
+func enqueueFunc(fn *ir.Func) {
+       if ir.CurFunc != nil {
+               base.FatalfAt(fn.Pos(), "enqueueFunc %v inside %v", fn, ir.CurFunc)
+       }
+
+       if ir.FuncName(fn) == "_" {
+               // Skip compiling blank functions.
+               // Frontend already reported any spec-mandated errors (#29870).
+               return
+       }
+
+       if clo := fn.OClosure; clo != nil && !ir.IsTrivialClosure(clo) {
+               return // we'll get this as part of its enclosing function
+       }
+
+       if len(fn.Body) == 0 {
+               // Initialize ABI wrappers if necessary.
+               ssagen.InitLSym(fn, false)
+               liveness.WriteFuncMap(fn)
+               return
+       }
+
+       errorsBefore := base.Errors()
+
+       todo := []*ir.Func{fn}
+       for len(todo) > 0 {
+               next := todo[len(todo)-1]
+               todo = todo[:len(todo)-1]
+
+               prepareFunc(next)
+               todo = append(todo, next.Closures...)
+       }
+
+       if base.Errors() > errorsBefore {
+               return
+       }
+
+       // Enqueue just fn itself. compileFunctions will handle
+       // scheduling compilation of its closures after it's done.
+       compilequeue = append(compilequeue, fn)
+}
+
+// prepareFunc handles any remaining frontend compilation tasks that
+// aren't yet safe to perform concurrently.
+func prepareFunc(fn *ir.Func) {
+       // Set up the function's LSym early to avoid data races with the assemblers.
+       // Do this before walk, as walk needs the LSym to set attributes/relocations
+       // (e.g. in MarkTypeUsedInInterface).
+       ssagen.InitLSym(fn, true)
+
+       // Calculate parameter offsets.
+       types.CalcSize(fn.Type())
+
+       typecheck.DeclContext = ir.PAUTO
+       ir.CurFunc = fn
+       walk.Walk(fn)
+       ir.CurFunc = nil // enforce no further uses of CurFunc
+       typecheck.DeclContext = ir.PEXTERN
+}
+
+// compileFunctions compiles all functions in compilequeue.
+// It fans out nBackendWorkers to do the work
+// and waits for them to complete.
+func compileFunctions() {
+       if len(compilequeue) == 0 {
+               return
+       }
+
+       if race.Enabled {
+               // Randomize compilation order to try to shake out races.
+               tmp := make([]*ir.Func, len(compilequeue))
+               perm := rand.Perm(len(compilequeue))
+               for i, v := range perm {
+                       tmp[v] = compilequeue[i]
+               }
+               copy(compilequeue, tmp)
+       } else {
+               // Compile the longest functions first,
+               // since they're most likely to be the slowest.
+               // This helps avoid stragglers.
+               sort.Slice(compilequeue, func(i, j int) bool {
+                       return len(compilequeue[i].Body) > len(compilequeue[j].Body)
+               })
+       }
+
+       // We queue up a goroutine per function that needs to be
+       // compiled, but require them to grab an available worker ID
+       // before doing any substantial work to limit parallelism.
+       workerIDs := make(chan int, base.Flag.LowerC)
+       for i := 0; i < base.Flag.LowerC; i++ {
+               workerIDs <- i
+       }
+
+       var wg sync.WaitGroup
+       var asyncCompile func(*ir.Func)
+       asyncCompile = func(fn *ir.Func) {
+               wg.Add(1)
+               go func() {
+                       worker := <-workerIDs
+                       ssagen.Compile(fn, worker)
+                       workerIDs <- worker
+
+                       // Done compiling fn. Schedule it's closures for compilation.
+                       for _, closure := range fn.Closures {
+                               asyncCompile(closure)
+                       }
+                       wg.Done()
+               }()
+       }
+
+       types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
+       base.Ctxt.InParallel = true
+       for _, fn := range compilequeue {
+               asyncCompile(fn)
+       }
+       compilequeue = nil
+       wg.Wait()
+       base.Ctxt.InParallel = false
+       types.CalcSizeDisabled = false
+}

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
deleted file mode 100644 (file)
index b92c8d6..0000000
--- a/src/cmd/compile/internal/gc/const.go
+++ /dev/null
@@ -1,1323 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "fmt"
-       "math/big"
-       "strings"
-)
-
-// Ctype describes the constant kind of an "ideal" (untyped) constant.
-type Ctype uint8
-
-const (
-       CTxxx Ctype = iota
-
-       CTINT
-       CTRUNE
-       CTFLT
-       CTCPLX
-       CTSTR
-       CTBOOL
-       CTNIL
-)
-
-type Val struct {
-       // U contains one of:
-       // bool     bool when Ctype() == CTBOOL
-       // *Mpint   int when Ctype() == CTINT, rune when Ctype() == CTRUNE
-       // *Mpflt   float when Ctype() == CTFLT
-       // *Mpcplx  pair of floats when Ctype() == CTCPLX
-       // string   string when Ctype() == CTSTR
-       // *Nilval  when Ctype() == CTNIL
-       U interface{}
-}
-
-func (v Val) Ctype() Ctype {
-       switch x := v.U.(type) {
-       default:
-               Fatalf("unexpected Ctype for %T", v.U)
-               panic("unreachable")
-       case nil:
-               return CTxxx
-       case *NilVal:
-               return CTNIL
-       case bool:
-               return CTBOOL
-       case *Mpint:
-               if x.Rune {
-                       return CTRUNE
-               }
-               return CTINT
-       case *Mpflt:
-               return CTFLT
-       case *Mpcplx:
-               return CTCPLX
-       case string:
-               return CTSTR
-       }
-}
-
-func eqval(a, b Val) bool {
-       if a.Ctype() != b.Ctype() {
-               return false
-       }
-       switch x := a.U.(type) {
-       default:
-               Fatalf("unexpected Ctype for %T", a.U)
-               panic("unreachable")
-       case *NilVal:
-               return true
-       case bool:
-               y := b.U.(bool)
-               return x == y
-       case *Mpint:
-               y := b.U.(*Mpint)
-               return x.Cmp(y) == 0
-       case *Mpflt:
-               y := b.U.(*Mpflt)
-               return x.Cmp(y) == 0
-       case *Mpcplx:
-               y := b.U.(*Mpcplx)
-               return x.Real.Cmp(&y.Real) == 0 && x.Imag.Cmp(&y.Imag) == 0
-       case string:
-               y := b.U.(string)
-               return x == y
-       }
-}
-
-// Interface returns the constant value stored in v as an interface{}.
-// It returns int64s for ints and runes, float64s for floats,
-// complex128s for complex values, and nil for constant nils.
-func (v Val) Interface() interface{} {
-       switch x := v.U.(type) {
-       default:
-               Fatalf("unexpected Interface for %T", v.U)
-               panic("unreachable")
-       case *NilVal:
-               return nil
-       case bool, string:
-               return x
-       case *Mpint:
-               return x.Int64()
-       case *Mpflt:
-               return x.Float64()
-       case *Mpcplx:
-               return complex(x.Real.Float64(), x.Imag.Float64())
-       }
-}
-
-type NilVal struct{}
-
-// Int64Val returns n as an int64.
-// n must be an integer or rune constant.
-func (n *Node) Int64Val() int64 {
-       if !Isconst(n, CTINT) {
-               Fatalf("Int64Val(%v)", n)
-       }
-       return n.Val().U.(*Mpint).Int64()
-}
-
-// CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *Node) CanInt64() bool {
-       if !Isconst(n, CTINT) {
-               return false
-       }
-
-       // if the value inside n cannot be represented as an int64, the
-       // return value of Int64 is undefined
-       return n.Val().U.(*Mpint).CmpInt64(n.Int64Val()) == 0
-}
-
-// BoolVal returns n as a bool.
-// n must be a boolean constant.
-func (n *Node) BoolVal() bool {
-       if !Isconst(n, CTBOOL) {
-               Fatalf("BoolVal(%v)", n)
-       }
-       return n.Val().U.(bool)
-}
-
-// StringVal returns the value of a literal string Node as a string.
-// n must be a string constant.
-func (n *Node) StringVal() string {
-       if !Isconst(n, CTSTR) {
-               Fatalf("StringVal(%v)", n)
-       }
-       return n.Val().U.(string)
-}
-
-// truncate float literal fv to 32-bit or 64-bit precision
-// according to type; return truncated value.
-func truncfltlit(oldv *Mpflt, t *types.Type) *Mpflt {
-       if t == nil {
-               return oldv
-       }
-
-       if overflow(Val{oldv}, t) {
-               // If there was overflow, simply continuing would set the
-               // value to Inf which in turn would lead to spurious follow-on
-               // errors. Avoid this by returning the existing value.
-               return oldv
-       }
-
-       fv := newMpflt()
-
-       // convert large precision literal floating
-       // into limited precision (float64 or float32)
-       switch t.Etype {
-       case types.TFLOAT32:
-               fv.SetFloat64(oldv.Float32())
-       case types.TFLOAT64:
-               fv.SetFloat64(oldv.Float64())
-       default:
-               Fatalf("truncfltlit: unexpected Etype %v", t.Etype)
-       }
-
-       return fv
-}
-
-// truncate Real and Imag parts of Mpcplx to 32-bit or 64-bit
-// precision, according to type; return truncated value. In case of
-// overflow, calls yyerror but does not truncate the input value.
-func trunccmplxlit(oldv *Mpcplx, t *types.Type) *Mpcplx {
-       if t == nil {
-               return oldv
-       }
-
-       if overflow(Val{oldv}, t) {
-               // If there was overflow, simply continuing would set the
-               // value to Inf which in turn would lead to spurious follow-on
-               // errors. Avoid this by returning the existing value.
-               return oldv
-       }
-
-       cv := newMpcmplx()
-
-       switch t.Etype {
-       case types.TCOMPLEX64:
-               cv.Real.SetFloat64(oldv.Real.Float32())
-               cv.Imag.SetFloat64(oldv.Imag.Float32())
-       case types.TCOMPLEX128:
-               cv.Real.SetFloat64(oldv.Real.Float64())
-               cv.Imag.SetFloat64(oldv.Imag.Float64())
-       default:
-               Fatalf("trunccplxlit: unexpected Etype %v", t.Etype)
-       }
-
-       return cv
-}
-
-// TODO(mdempsky): Replace these with better APIs.
-func convlit(n *Node, t *types.Type) *Node    { return convlit1(n, t, false, nil) }
-func defaultlit(n *Node, t *types.Type) *Node { return convlit1(n, t, false, nil) }
-
-// convlit1 converts an untyped expression n to type t. If n already
-// has a type, convlit1 has no effect.
-//
-// For explicit conversions, t must be non-nil, and integer-to-string
-// conversions are allowed.
-//
-// For implicit conversions (e.g., assignments), t may be nil; if so,
-// n is converted to its default type.
-//
-// If there's an error converting n to t, context is used in the error
-// message.
-func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Node {
-       if explicit && t == nil {
-               Fatalf("explicit conversion missing type")
-       }
-       if t != nil && t.IsUntyped() {
-               Fatalf("bad conversion to untyped: %v", t)
-       }
-
-       if n == nil || n.Type == nil {
-               // Allow sloppy callers.
-               return n
-       }
-       if !n.Type.IsUntyped() {
-               // Already typed; nothing to do.
-               return n
-       }
-
-       if n.Op == OLITERAL {
-               // Can't always set n.Type directly on OLITERAL nodes.
-               // See discussion on CL 20813.
-               n = n.rawcopy()
-       }
-
-       // Nil is technically not a constant, so handle it specially.
-       if n.Type.Etype == TNIL {
-               if t == nil {
-                       yyerror("use of untyped nil")
-                       n.SetDiag(true)
-                       n.Type = nil
-                       return n
-               }
-
-               if !t.HasNil() {
-                       // Leave for caller to handle.
-                       return n
-               }
-
-               n.Type = t
-               return n
-       }
-
-       if t == nil || !okforconst[t.Etype] {
-               t = defaultType(n.Type)
-       }
-
-       switch n.Op {
-       default:
-               Fatalf("unexpected untyped expression: %v", n)
-
-       case OLITERAL:
-               v := convertVal(n.Val(), t, explicit)
-               if v.U == nil {
-                       break
-               }
-               n.SetVal(v)
-               n.Type = t
-               return n
-
-       case OPLUS, ONEG, OBITNOT, ONOT, OREAL, OIMAG:
-               ot := operandType(n.Op, t)
-               if ot == nil {
-                       n = defaultlit(n, nil)
-                       break
-               }
-
-               n.Left = convlit(n.Left, ot)
-               if n.Left.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               n.Type = t
-               return n
-
-       case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND, OCOMPLEX:
-               ot := operandType(n.Op, t)
-               if ot == nil {
-                       n = defaultlit(n, nil)
-                       break
-               }
-
-               n.Left = convlit(n.Left, ot)
-               n.Right = convlit(n.Right, ot)
-               if n.Left.Type == nil || n.Right.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !types.Identical(n.Left.Type, n.Right.Type) {
-                       yyerror("invalid operation: %v (mismatched types %v and %v)", n, n.Left.Type, n.Right.Type)
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = t
-               return n
-
-       case OEQ, ONE, OLT, OLE, OGT, OGE:
-               if !t.IsBoolean() {
-                       break
-               }
-               n.Type = t
-               return n
-
-       case OLSH, ORSH:
-               n.Left = convlit1(n.Left, t, explicit, nil)
-               n.Type = n.Left.Type
-               if n.Type != nil && !n.Type.IsInteger() {
-                       yyerror("invalid operation: %v (shift of type %v)", n, n.Type)
-                       n.Type = nil
-               }
-               return n
-       }
-
-       if !n.Diag() {
-               if !t.Broke() {
-                       if explicit {
-                               yyerror("cannot convert %L to type %v", n, t)
-                       } else if context != nil {
-                               yyerror("cannot use %L as type %v in %s", n, t, context())
-                       } else {
-                               yyerror("cannot use %L as type %v", n, t)
-                       }
-               }
-               n.SetDiag(true)
-       }
-       n.Type = nil
-       return n
-}
-
-func operandType(op Op, t *types.Type) *types.Type {
-       switch op {
-       case OCOMPLEX:
-               if t.IsComplex() {
-                       return floatForComplex(t)
-               }
-       case OREAL, OIMAG:
-               if t.IsFloat() {
-                       return complexForFloat(t)
-               }
-       default:
-               if okfor[op][t.Etype] {
-                       return t
-               }
-       }
-       return nil
-}
-
-// convertVal converts v into a representation appropriate for t. If
-// no such representation exists, it returns Val{} instead.
-//
-// If explicit is true, then conversions from integer to string are
-// also allowed.
-func convertVal(v Val, t *types.Type, explicit bool) Val {
-       switch ct := v.Ctype(); ct {
-       case CTBOOL:
-               if t.IsBoolean() {
-                       return v
-               }
-
-       case CTSTR:
-               if t.IsString() {
-                       return v
-               }
-
-       case CTINT, CTRUNE:
-               if explicit && t.IsString() {
-                       return tostr(v)
-               }
-               fallthrough
-       case CTFLT, CTCPLX:
-               switch {
-               case t.IsInteger():
-                       v = toint(v)
-                       overflow(v, t)
-                       return v
-               case t.IsFloat():
-                       v = toflt(v)
-                       v = Val{truncfltlit(v.U.(*Mpflt), t)}
-                       return v
-               case t.IsComplex():
-                       v = tocplx(v)
-                       v = Val{trunccmplxlit(v.U.(*Mpcplx), t)}
-                       return v
-               }
-       }
-
-       return Val{}
-}
-
-func tocplx(v Val) Val {
-       switch u := v.U.(type) {
-       case *Mpint:
-               c := newMpcmplx()
-               c.Real.SetInt(u)
-               c.Imag.SetFloat64(0.0)
-               v.U = c
-
-       case *Mpflt:
-               c := newMpcmplx()
-               c.Real.Set(u)
-               c.Imag.SetFloat64(0.0)
-               v.U = c
-       }
-
-       return v
-}
-
-func toflt(v Val) Val {
-       switch u := v.U.(type) {
-       case *Mpint:
-               f := newMpflt()
-               f.SetInt(u)
-               v.U = f
-
-       case *Mpcplx:
-               f := newMpflt()
-               f.Set(&u.Real)
-               if u.Imag.CmpFloat64(0) != 0 {
-                       yyerror("constant %v truncated to real", u.GoString())
-               }
-               v.U = f
-       }
-
-       return v
-}
-
-func toint(v Val) Val {
-       switch u := v.U.(type) {
-       case *Mpint:
-               if u.Rune {
-                       i := new(Mpint)
-                       i.Set(u)
-                       v.U = i
-               }
-
-       case *Mpflt:
-               i := new(Mpint)
-               if !i.SetFloat(u) {
-                       if i.checkOverflow(0) {
-                               yyerror("integer too large")
-                       } else {
-                               // The value of u cannot be represented as an integer;
-                               // so we need to print an error message.
-                               // Unfortunately some float values cannot be
-                               // reasonably formatted for inclusion in an error
-                               // message (example: 1 + 1e-100), so first we try to
-                               // format the float; if the truncation resulted in
-                               // something that looks like an integer we omit the
-                               // value from the error message.
-                               // (See issue #11371).
-                               var t big.Float
-                               t.Parse(u.GoString(), 10)
-                               if t.IsInt() {
-                                       yyerror("constant truncated to integer")
-                               } else {
-                                       yyerror("constant %v truncated to integer", u.GoString())
-                               }
-                       }
-               }
-               v.U = i
-
-       case *Mpcplx:
-               i := new(Mpint)
-               if !i.SetFloat(&u.Real) || u.Imag.CmpFloat64(0) != 0 {
-                       yyerror("constant %v truncated to integer", u.GoString())
-               }
-
-               v.U = i
-       }
-
-       return v
-}
-
-func doesoverflow(v Val, t *types.Type) bool {
-       switch u := v.U.(type) {
-       case *Mpint:
-               if !t.IsInteger() {
-                       Fatalf("overflow: %v integer constant", t)
-               }
-               return u.Cmp(minintval[t.Etype]) < 0 || u.Cmp(maxintval[t.Etype]) > 0
-
-       case *Mpflt:
-               if !t.IsFloat() {
-                       Fatalf("overflow: %v floating-point constant", t)
-               }
-               return u.Cmp(minfltval[t.Etype]) <= 0 || u.Cmp(maxfltval[t.Etype]) >= 0
-
-       case *Mpcplx:
-               if !t.IsComplex() {
-                       Fatalf("overflow: %v complex constant", t)
-               }
-               return u.Real.Cmp(minfltval[t.Etype]) <= 0 || u.Real.Cmp(maxfltval[t.Etype]) >= 0 ||
-                       u.Imag.Cmp(minfltval[t.Etype]) <= 0 || u.Imag.Cmp(maxfltval[t.Etype]) >= 0
-       }
-
-       return false
-}
-
-func overflow(v Val, t *types.Type) bool {
-       // v has already been converted
-       // to appropriate form for t.
-       if t == nil || t.Etype == TIDEAL {
-               return false
-       }
-
-       // Only uintptrs may be converted to pointers, which cannot overflow.
-       if t.IsPtr() || t.IsUnsafePtr() {
-               return false
-       }
-
-       if doesoverflow(v, t) {
-               yyerror("constant %v overflows %v", v, t)
-               return true
-       }
-
-       return false
-
-}
-
-func tostr(v Val) Val {
-       switch u := v.U.(type) {
-       case *Mpint:
-               var r rune = 0xFFFD
-               if u.Cmp(minintval[TINT32]) >= 0 && u.Cmp(maxintval[TINT32]) <= 0 {
-                       r = rune(u.Int64())
-               }
-               v.U = string(r)
-       }
-
-       return v
-}
-
-func consttype(n *Node) Ctype {
-       if n == nil || n.Op != OLITERAL {
-               return CTxxx
-       }
-       return n.Val().Ctype()
-}
-
-func Isconst(n *Node, ct Ctype) bool {
-       t := consttype(n)
-
-       // If the caller is asking for CTINT, allow CTRUNE too.
-       // Makes life easier for back ends.
-       return t == ct || (ct == CTINT && t == CTRUNE)
-}
-
-// evconst rewrites constant expressions into OLITERAL nodes.
-func evconst(n *Node) {
-       nl, nr := n.Left, n.Right
-
-       // Pick off just the opcodes that can be constant evaluated.
-       switch op := n.Op; op {
-       case OPLUS, ONEG, OBITNOT, ONOT:
-               if nl.Op == OLITERAL {
-                       setconst(n, unaryOp(op, nl.Val(), n.Type))
-               }
-
-       case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND:
-               if nl.Op == OLITERAL && nr.Op == OLITERAL {
-                       setconst(n, binaryOp(nl.Val(), op, nr.Val()))
-               }
-
-       case OEQ, ONE, OLT, OLE, OGT, OGE:
-               if nl.Op == OLITERAL && nr.Op == OLITERAL {
-                       setboolconst(n, compareOp(nl.Val(), op, nr.Val()))
-               }
-
-       case OLSH, ORSH:
-               if nl.Op == OLITERAL && nr.Op == OLITERAL {
-                       setconst(n, shiftOp(nl.Val(), op, nr.Val()))
-               }
-
-       case OCONV, ORUNESTR:
-               if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
-                       setconst(n, convertVal(nl.Val(), n.Type, true))
-               }
-
-       case OCONVNOP:
-               if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
-                       // set so n.Orig gets OCONV instead of OCONVNOP
-                       n.Op = OCONV
-                       setconst(n, nl.Val())
-               }
-
-       case OADDSTR:
-               // Merge adjacent constants in the argument list.
-               s := n.List.Slice()
-               for i1 := 0; i1 < len(s); i1++ {
-                       if Isconst(s[i1], CTSTR) && i1+1 < len(s) && Isconst(s[i1+1], CTSTR) {
-                               // merge from i1 up to but not including i2
-                               var strs []string
-                               i2 := i1
-                               for i2 < len(s) && Isconst(s[i2], CTSTR) {
-                                       strs = append(strs, s[i2].StringVal())
-                                       i2++
-                               }
-
-                               nl := *s[i1]
-                               nl.Orig = &nl
-                               nl.SetVal(Val{strings.Join(strs, "")})
-                               s[i1] = &nl
-                               s = append(s[:i1+1], s[i2:]...)
-                       }
-               }
-
-               if len(s) == 1 && Isconst(s[0], CTSTR) {
-                       n.Op = OLITERAL
-                       n.SetVal(s[0].Val())
-               } else {
-                       n.List.Set(s)
-               }
-
-       case OCAP, OLEN:
-               switch nl.Type.Etype {
-               case TSTRING:
-                       if Isconst(nl, CTSTR) {
-                               setintconst(n, int64(len(nl.StringVal())))
-                       }
-               case TARRAY:
-                       if !hascallchan(nl) {
-                               setintconst(n, nl.Type.NumElem())
-                       }
-               }
-
-       case OALIGNOF, OOFFSETOF, OSIZEOF:
-               setintconst(n, evalunsafe(n))
-
-       case OREAL, OIMAG:
-               if nl.Op == OLITERAL {
-                       var re, im *Mpflt
-                       switch u := nl.Val().U.(type) {
-                       case *Mpint:
-                               re = newMpflt()
-                               re.SetInt(u)
-                               // im = 0
-                       case *Mpflt:
-                               re = u
-                               // im = 0
-                       case *Mpcplx:
-                               re = &u.Real
-                               im = &u.Imag
-                       default:
-                               Fatalf("impossible")
-                       }
-                       if n.Op == OIMAG {
-                               if im == nil {
-                                       im = newMpflt()
-                               }
-                               re = im
-                       }
-                       setconst(n, Val{re})
-               }
-
-       case OCOMPLEX:
-               if nl.Op == OLITERAL && nr.Op == OLITERAL {
-                       // make it a complex literal
-                       c := newMpcmplx()
-                       c.Real.Set(toflt(nl.Val()).U.(*Mpflt))
-                       c.Imag.Set(toflt(nr.Val()).U.(*Mpflt))
-                       setconst(n, Val{c})
-               }
-       }
-}
-
-func match(x, y Val) (Val, Val) {
-       switch {
-       case x.Ctype() == CTCPLX || y.Ctype() == CTCPLX:
-               return tocplx(x), tocplx(y)
-       case x.Ctype() == CTFLT || y.Ctype() == CTFLT:
-               return toflt(x), toflt(y)
-       }
-
-       // Mixed int/rune are fine.
-       return x, y
-}
-
-func compareOp(x Val, op Op, y Val) bool {
-       x, y = match(x, y)
-
-       switch x.Ctype() {
-       case CTBOOL:
-               x, y := x.U.(bool), y.U.(bool)
-               switch op {
-               case OEQ:
-                       return x == y
-               case ONE:
-                       return x != y
-               }
-
-       case CTINT, CTRUNE:
-               x, y := x.U.(*Mpint), y.U.(*Mpint)
-               return cmpZero(x.Cmp(y), op)
-
-       case CTFLT:
-               x, y := x.U.(*Mpflt), y.U.(*Mpflt)
-               return cmpZero(x.Cmp(y), op)
-
-       case CTCPLX:
-               x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
-               eq := x.Real.Cmp(&y.Real) == 0 && x.Imag.Cmp(&y.Imag) == 0
-               switch op {
-               case OEQ:
-                       return eq
-               case ONE:
-                       return !eq
-               }
-
-       case CTSTR:
-               x, y := x.U.(string), y.U.(string)
-               switch op {
-               case OEQ:
-                       return x == y
-               case ONE:
-                       return x != y
-               case OLT:
-                       return x < y
-               case OLE:
-                       return x <= y
-               case OGT:
-                       return x > y
-               case OGE:
-                       return x >= y
-               }
-       }
-
-       Fatalf("compareOp: bad comparison: %v %v %v", x, op, y)
-       panic("unreachable")
-}
-
-func cmpZero(x int, op Op) bool {
-       switch op {
-       case OEQ:
-               return x == 0
-       case ONE:
-               return x != 0
-       case OLT:
-               return x < 0
-       case OLE:
-               return x <= 0
-       case OGT:
-               return x > 0
-       case OGE:
-               return x >= 0
-       }
-
-       Fatalf("cmpZero: want comparison operator, got %v", op)
-       panic("unreachable")
-}
-
-func binaryOp(x Val, op Op, y Val) Val {
-       x, y = match(x, y)
-
-Outer:
-       switch x.Ctype() {
-       case CTBOOL:
-               x, y := x.U.(bool), y.U.(bool)
-               switch op {
-               case OANDAND:
-                       return Val{U: x && y}
-               case OOROR:
-                       return Val{U: x || y}
-               }
-
-       case CTINT, CTRUNE:
-               x, y := x.U.(*Mpint), y.U.(*Mpint)
-
-               u := new(Mpint)
-               u.Rune = x.Rune || y.Rune
-               u.Set(x)
-               switch op {
-               case OADD:
-                       u.Add(y)
-               case OSUB:
-                       u.Sub(y)
-               case OMUL:
-                       u.Mul(y)
-               case ODIV:
-                       if y.CmpInt64(0) == 0 {
-                               yyerror("division by zero")
-                               return Val{}
-                       }
-                       u.Quo(y)
-               case OMOD:
-                       if y.CmpInt64(0) == 0 {
-                               yyerror("division by zero")
-                               return Val{}
-                       }
-                       u.Rem(y)
-               case OOR:
-                       u.Or(y)
-               case OAND:
-                       u.And(y)
-               case OANDNOT:
-                       u.AndNot(y)
-               case OXOR:
-                       u.Xor(y)
-               default:
-                       break Outer
-               }
-               return Val{U: u}
-
-       case CTFLT:
-               x, y := x.U.(*Mpflt), y.U.(*Mpflt)
-
-               u := newMpflt()
-               u.Set(x)
-               switch op {
-               case OADD:
-                       u.Add(y)
-               case OSUB:
-                       u.Sub(y)
-               case OMUL:
-                       u.Mul(y)
-               case ODIV:
-                       if y.CmpFloat64(0) == 0 {
-                               yyerror("division by zero")
-                               return Val{}
-                       }
-                       u.Quo(y)
-               default:
-                       break Outer
-               }
-               return Val{U: u}
-
-       case CTCPLX:
-               x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
-
-               u := newMpcmplx()
-               u.Real.Set(&x.Real)
-               u.Imag.Set(&x.Imag)
-               switch op {
-               case OADD:
-                       u.Real.Add(&y.Real)
-                       u.Imag.Add(&y.Imag)
-               case OSUB:
-                       u.Real.Sub(&y.Real)
-                       u.Imag.Sub(&y.Imag)
-               case OMUL:
-                       u.Mul(y)
-               case ODIV:
-                       if !u.Div(y) {
-                               yyerror("complex division by zero")
-                               return Val{}
-                       }
-               default:
-                       break Outer
-               }
-               return Val{U: u}
-       }
-
-       Fatalf("binaryOp: bad operation: %v %v %v", x, op, y)
-       panic("unreachable")
-}
-
-func unaryOp(op Op, x Val, t *types.Type) Val {
-       switch op {
-       case OPLUS:
-               switch x.Ctype() {
-               case CTINT, CTRUNE, CTFLT, CTCPLX:
-                       return x
-               }
-
-       case ONEG:
-               switch x.Ctype() {
-               case CTINT, CTRUNE:
-                       x := x.U.(*Mpint)
-                       u := new(Mpint)
-                       u.Rune = x.Rune
-                       u.Set(x)
-                       u.Neg()
-                       return Val{U: u}
-
-               case CTFLT:
-                       x := x.U.(*Mpflt)
-                       u := newMpflt()
-                       u.Set(x)
-                       u.Neg()
-                       return Val{U: u}
-
-               case CTCPLX:
-                       x := x.U.(*Mpcplx)
-                       u := newMpcmplx()
-                       u.Real.Set(&x.Real)
-                       u.Imag.Set(&x.Imag)
-                       u.Real.Neg()
-                       u.Imag.Neg()
-                       return Val{U: u}
-               }
-
-       case OBITNOT:
-               switch x.Ctype() {
-               case CTINT, CTRUNE:
-                       x := x.U.(*Mpint)
-
-                       u := new(Mpint)
-                       u.Rune = x.Rune
-                       if t.IsSigned() || t.IsUntyped() {
-                               // Signed values change sign.
-                               u.SetInt64(-1)
-                       } else {
-                               // Unsigned values invert their bits.
-                               u.Set(maxintval[t.Etype])
-                       }
-                       u.Xor(x)
-                       return Val{U: u}
-               }
-
-       case ONOT:
-               return Val{U: !x.U.(bool)}
-       }
-
-       Fatalf("unaryOp: bad operation: %v %v", op, x)
-       panic("unreachable")
-}
-
-func shiftOp(x Val, op Op, y Val) Val {
-       if x.Ctype() != CTRUNE {
-               x = toint(x)
-       }
-       y = toint(y)
-
-       u := new(Mpint)
-       u.Set(x.U.(*Mpint))
-       u.Rune = x.U.(*Mpint).Rune
-       switch op {
-       case OLSH:
-               u.Lsh(y.U.(*Mpint))
-       case ORSH:
-               u.Rsh(y.U.(*Mpint))
-       default:
-               Fatalf("shiftOp: bad operator: %v", op)
-               panic("unreachable")
-       }
-       return Val{U: u}
-}
-
-// setconst rewrites n as an OLITERAL with value v.
-func setconst(n *Node, v Val) {
-       // If constant folding failed, mark n as broken and give up.
-       if v.U == nil {
-               n.Type = nil
-               return
-       }
-
-       // Ensure n.Orig still points to a semantically-equivalent
-       // expression after we rewrite n into a constant.
-       if n.Orig == n {
-               n.Orig = n.sepcopy()
-       }
-
-       *n = Node{
-               Op:      OLITERAL,
-               Pos:     n.Pos,
-               Orig:    n.Orig,
-               Type:    n.Type,
-               Xoffset: BADWIDTH,
-       }
-       n.SetVal(v)
-       if vt := idealType(v.Ctype()); n.Type.IsUntyped() && n.Type != vt {
-               Fatalf("untyped type mismatch, have: %v, want: %v", n.Type, vt)
-       }
-
-       // Check range.
-       lno := setlineno(n)
-       overflow(v, n.Type)
-       lineno = lno
-
-       if !n.Type.IsUntyped() {
-               switch v.Ctype() {
-               // Truncate precision for non-ideal float.
-               case CTFLT:
-                       n.SetVal(Val{truncfltlit(v.U.(*Mpflt), n.Type)})
-               // Truncate precision for non-ideal complex.
-               case CTCPLX:
-                       n.SetVal(Val{trunccmplxlit(v.U.(*Mpcplx), n.Type)})
-               }
-       }
-}
-
-func setboolconst(n *Node, v bool) {
-       setconst(n, Val{U: v})
-}
-
-func setintconst(n *Node, v int64) {
-       u := new(Mpint)
-       u.SetInt64(v)
-       setconst(n, Val{u})
-}
-
-// nodlit returns a new untyped constant with value v.
-func nodlit(v Val) *Node {
-       n := nod(OLITERAL, nil, nil)
-       n.SetVal(v)
-       n.Type = idealType(v.Ctype())
-       return n
-}
-
-func idealType(ct Ctype) *types.Type {
-       switch ct {
-       case CTSTR:
-               return types.UntypedString
-       case CTBOOL:
-               return types.UntypedBool
-       case CTINT:
-               return types.UntypedInt
-       case CTRUNE:
-               return types.UntypedRune
-       case CTFLT:
-               return types.UntypedFloat
-       case CTCPLX:
-               return types.UntypedComplex
-       case CTNIL:
-               return types.Types[TNIL]
-       }
-       Fatalf("unexpected Ctype: %v", ct)
-       return nil
-}
-
-// defaultlit on both nodes simultaneously;
-// if they're both ideal going in they better
-// get the same type going out.
-// force means must assign concrete (non-ideal) type.
-// The results of defaultlit2 MUST be assigned back to l and r, e.g.
-//     n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
-func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
-       if l.Type == nil || r.Type == nil {
-               return l, r
-       }
-       if !l.Type.IsUntyped() {
-               r = convlit(r, l.Type)
-               return l, r
-       }
-
-       if !r.Type.IsUntyped() {
-               l = convlit(l, r.Type)
-               return l, r
-       }
-
-       if !force {
-               return l, r
-       }
-
-       // Can't mix bool with non-bool, string with non-string, or nil with anything (untyped).
-       if l.Type.IsBoolean() != r.Type.IsBoolean() {
-               return l, r
-       }
-       if l.Type.IsString() != r.Type.IsString() {
-               return l, r
-       }
-       if l.isNil() || r.isNil() {
-               return l, r
-       }
-
-       t := defaultType(mixUntyped(l.Type, r.Type))
-       l = convlit(l, t)
-       r = convlit(r, t)
-       return l, r
-}
-
-func ctype(t *types.Type) Ctype {
-       switch t {
-       case types.UntypedBool:
-               return CTBOOL
-       case types.UntypedString:
-               return CTSTR
-       case types.UntypedInt:
-               return CTINT
-       case types.UntypedRune:
-               return CTRUNE
-       case types.UntypedFloat:
-               return CTFLT
-       case types.UntypedComplex:
-               return CTCPLX
-       }
-       Fatalf("bad type %v", t)
-       panic("unreachable")
-}
-
-func mixUntyped(t1, t2 *types.Type) *types.Type {
-       t := t1
-       if ctype(t2) > ctype(t1) {
-               t = t2
-       }
-       return t
-}
-
-func defaultType(t *types.Type) *types.Type {
-       if !t.IsUntyped() || t.Etype == TNIL {
-               return t
-       }
-
-       switch t {
-       case types.UntypedBool:
-               return types.Types[TBOOL]
-       case types.UntypedString:
-               return types.Types[TSTRING]
-       case types.UntypedInt:
-               return types.Types[TINT]
-       case types.UntypedRune:
-               return types.Runetype
-       case types.UntypedFloat:
-               return types.Types[TFLOAT64]
-       case types.UntypedComplex:
-               return types.Types[TCOMPLEX128]
-       }
-
-       Fatalf("bad type %v", t)
-       return nil
-}
-
-func smallintconst(n *Node) bool {
-       if n.Op == OLITERAL && Isconst(n, CTINT) && n.Type != nil {
-               switch simtype[n.Type.Etype] {
-               case TINT8,
-                       TUINT8,
-                       TINT16,
-                       TUINT16,
-                       TINT32,
-                       TUINT32,
-                       TBOOL:
-                       return true
-
-               case TIDEAL, TINT64, TUINT64, TPTR:
-                       v, ok := n.Val().U.(*Mpint)
-                       if ok && v.Cmp(minintval[TINT32]) >= 0 && v.Cmp(maxintval[TINT32]) <= 0 {
-                               return true
-                       }
-               }
-       }
-
-       return false
-}
-
-// indexconst checks if Node n contains a constant expression
-// representable as a non-negative int and returns its value.
-// If n is not a constant expression, not representable as an
-// integer, or negative, it returns -1. If n is too large, it
-// returns -2.
-func indexconst(n *Node) int64 {
-       if n.Op != OLITERAL {
-               return -1
-       }
-
-       v := toint(n.Val()) // toint returns argument unchanged if not representable as an *Mpint
-       vi, ok := v.U.(*Mpint)
-       if !ok || vi.CmpInt64(0) < 0 {
-               return -1
-       }
-       if vi.Cmp(maxintval[TINT]) > 0 {
-               return -2
-       }
-
-       return vi.Int64()
-}
-
-// isGoConst reports whether n is a Go language constant (as opposed to a
-// compile-time constant).
-//
-// Expressions derived from nil, like string([]byte(nil)), while they
-// may be known at compile time, are not Go language constants.
-func (n *Node) isGoConst() bool {
-       return n.Op == OLITERAL && n.Val().Ctype() != CTNIL
-}
-
-func hascallchan(n *Node) bool {
-       if n == nil {
-               return false
-       }
-       switch n.Op {
-       case OAPPEND,
-               OCALL,
-               OCALLFUNC,
-               OCALLINTER,
-               OCALLMETH,
-               OCAP,
-               OCLOSE,
-               OCOMPLEX,
-               OCOPY,
-               ODELETE,
-               OIMAG,
-               OLEN,
-               OMAKE,
-               ONEW,
-               OPANIC,
-               OPRINT,
-               OPRINTN,
-               OREAL,
-               ORECOVER,
-               ORECV:
-               return true
-       }
-
-       if hascallchan(n.Left) || hascallchan(n.Right) {
-               return true
-       }
-       for _, n1 := range n.List.Slice() {
-               if hascallchan(n1) {
-                       return true
-               }
-       }
-       for _, n2 := range n.Rlist.Slice() {
-               if hascallchan(n2) {
-                       return true
-               }
-       }
-
-       return false
-}
-
-// A constSet represents a set of Go constant expressions.
-type constSet struct {
-       m map[constSetKey]src.XPos
-}
-
-type constSetKey struct {
-       typ *types.Type
-       val interface{}
-}
-
-// add adds constant expression n to s. If a constant expression of
-// equal value and identical type has already been added, then add
-// reports an error about the duplicate value.
-//
-// pos provides position information for where expression n occurred
-// (in case n does not have its own position information). what and
-// where are used in the error message.
-//
-// n must not be an untyped constant.
-func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
-       if n.Op == OCONVIFACE && n.Implicit() {
-               n = n.Left
-       }
-
-       if !n.isGoConst() {
-               return
-       }
-       if n.Type.IsUntyped() {
-               Fatalf("%v is untyped", n)
-       }
-
-       // Consts are only duplicates if they have the same value and
-       // identical types.
-       //
-       // In general, we have to use types.Identical to test type
-       // identity, because == gives false negatives for anonymous
-       // types and the byte/uint8 and rune/int32 builtin type
-       // aliases.  However, this is not a problem here, because
-       // constant expressions are always untyped or have a named
-       // type, and we explicitly handle the builtin type aliases
-       // below.
-       //
-       // This approach may need to be revisited though if we fix
-       // #21866 by treating all type aliases like byte/uint8 and
-       // rune/int32.
-
-       typ := n.Type
-       switch typ {
-       case types.Bytetype:
-               typ = types.Types[TUINT8]
-       case types.Runetype:
-               typ = types.Types[TINT32]
-       }
-       k := constSetKey{typ, n.Val().Interface()}
-
-       if hasUniquePos(n) {
-               pos = n.Pos
-       }
-
-       if s.m == nil {
-               s.m = make(map[constSetKey]src.XPos)
-       }
-
-       if prevPos, isDup := s.m[k]; isDup {
-               yyerrorl(pos, "duplicate %s %s in %s\n\tprevious %s at %v",
-                       what, nodeAndVal(n), where,
-                       what, linestr(prevPos))
-       } else {
-               s.m[k] = pos
-       }
-}
-
-// nodeAndVal reports both an expression and its constant value, if
-// the latter is non-obvious.
-//
-// TODO(mdempsky): This could probably be a fmt.go flag.
-func nodeAndVal(n *Node) string {
-       show := n.String()
-       val := n.Val().Interface()
-       if s := fmt.Sprintf("%#v", val); show != s {
-               show += " (value " + s + ")"
-       }
-       return show
-}

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
deleted file mode 100644 (file)
index 6e90eb4..0000000
--- a/src/cmd/compile/internal/gc/dcl.go
+++ /dev/null
@@ -1,1185 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "bytes"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/src"
-       "fmt"
-       "strings"
-)
-
-// Declaration stack & operations
-
-var externdcl []*Node
-
-func testdclstack() {
-       if !types.IsDclstackValid() {
-               if nerrors != 0 {
-                       errorexit()
-               }
-               Fatalf("mark left on the dclstack")
-       }
-}
-
-// redeclare emits a diagnostic about symbol s being redeclared at pos.
-func redeclare(pos src.XPos, s *types.Sym, where string) {
-       if !s.Lastlineno.IsKnown() {
-               pkg := s.Origpkg
-               if pkg == nil {
-                       pkg = s.Pkg
-               }
-               yyerrorl(pos, "%v redeclared %s\n"+
-                       "\tprevious declaration during import %q", s, where, pkg.Path)
-       } else {
-               prevPos := s.Lastlineno
-
-               // When an import and a declaration collide in separate files,
-               // present the import as the "redeclared", because the declaration
-               // is visible where the import is, but not vice versa.
-               // See issue 4510.
-               if s.Def == nil {
-                       pos, prevPos = prevPos, pos
-               }
-
-               yyerrorl(pos, "%v redeclared %s\n"+
-                       "\tprevious declaration at %v", s, where, linestr(prevPos))
-       }
-}
-
-var vargen int
-
-// declare individual names - var, typ, const
-
-var declare_typegen int
-
-// declare records that Node n declares symbol n.Sym in the specified
-// declaration context.
-func declare(n *Node, ctxt Class) {
-       if n.isBlank() {
-               return
-       }
-
-       if n.Name == nil {
-               // named OLITERAL needs Name; most OLITERALs don't.
-               n.Name = new(Name)
-       }
-
-       s := n.Sym
-
-       // kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
-       if !inimport && !typecheckok && s.Pkg != localpkg {
-               yyerrorl(n.Pos, "cannot declare name %v", s)
-       }
-
-       gen := 0
-       if ctxt == PEXTERN {
-               if s.Name == "init" {
-                       yyerrorl(n.Pos, "cannot declare init - must be func")
-               }
-               if s.Name == "main" && s.Pkg.Name == "main" {
-                       yyerrorl(n.Pos, "cannot declare main - must be func")
-               }
-               externdcl = append(externdcl, n)
-       } else {
-               if Curfn == nil && ctxt == PAUTO {
-                       lineno = n.Pos
-                       Fatalf("automatic outside function")
-               }
-               if Curfn != nil && ctxt != PFUNC {
-                       Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-               }
-               if n.Op == OTYPE {
-                       declare_typegen++
-                       gen = declare_typegen
-               } else if n.Op == ONAME && ctxt == PAUTO && !strings.Contains(s.Name, "·") {
-                       vargen++
-                       gen = vargen
-               }
-               types.Pushdcl(s)
-               n.Name.Curfn = Curfn
-       }
-
-       if ctxt == PAUTO {
-               n.Xoffset = 0
-       }
-
-       if s.Block == types.Block {
-               // functype will print errors about duplicate function arguments.
-               // Don't repeat the error here.
-               if ctxt != PPARAM && ctxt != PPARAMOUT {
-                       redeclare(n.Pos, s, "in this block")
-               }
-       }
-
-       s.Block = types.Block
-       s.Lastlineno = lineno
-       s.Def = asTypesNode(n)
-       n.Name.Vargen = int32(gen)
-       n.SetClass(ctxt)
-       if ctxt == PFUNC {
-               n.Sym.SetFunc(true)
-       }
-
-       autoexport(n, ctxt)
-}
-
-func addvar(n *Node, t *types.Type, ctxt Class) {
-       if n == nil || n.Sym == nil || (n.Op != ONAME && n.Op != ONONAME) || t == nil {
-               Fatalf("addvar: n=%v t=%v nil", n, t)
-       }
-
-       n.Op = ONAME
-       declare(n, ctxt)
-       n.Type = t
-}
-
-// declare variables from grammar
-// new_name_list (type | [type] = expr_list)
-func variter(vl []*Node, t *Node, el []*Node) []*Node {
-       var init []*Node
-       doexpr := len(el) > 0
-
-       if len(el) == 1 && len(vl) > 1 {
-               e := el[0]
-               as2 := nod(OAS2, nil, nil)
-               as2.List.Set(vl)
-               as2.Rlist.Set1(e)
-               for _, v := range vl {
-                       v.Op = ONAME
-                       declare(v, dclcontext)
-                       v.Name.Param.Ntype = t
-                       v.Name.Defn = as2
-                       if Curfn != nil {
-                               init = append(init, nod(ODCL, v, nil))
-                       }
-               }
-
-               return append(init, as2)
-       }
-
-       nel := len(el)
-       for _, v := range vl {
-               var e *Node
-               if doexpr {
-                       if len(el) == 0 {
-                               yyerror("assignment mismatch: %d variables but %d values", len(vl), nel)
-                               break
-                       }
-                       e = el[0]
-                       el = el[1:]
-               }
-
-               v.Op = ONAME
-               declare(v, dclcontext)
-               v.Name.Param.Ntype = t
-
-               if e != nil || Curfn != nil || v.isBlank() {
-                       if Curfn != nil {
-                               init = append(init, nod(ODCL, v, nil))
-                       }
-                       e = nod(OAS, v, e)
-                       init = append(init, e)
-                       if e.Right != nil {
-                               v.Name.Defn = e
-                       }
-               }
-       }
-
-       if len(el) != 0 {
-               yyerror("assignment mismatch: %d variables but %d values", len(vl), nel)
-       }
-       return init
-}
-
-// newnoname returns a new ONONAME Node associated with symbol s.
-func newnoname(s *types.Sym) *Node {
-       if s == nil {
-               Fatalf("newnoname nil")
-       }
-       n := nod(ONONAME, nil, nil)
-       n.Sym = s
-       n.Xoffset = 0
-       return n
-}
-
-// newfuncnamel generates a new name node for a function or method.
-// TODO(rsc): Use an ODCLFUNC node instead. See comment in CL 7360.
-func newfuncnamel(pos src.XPos, s *types.Sym) *Node {
-       n := newnamel(pos, s)
-       n.Func = new(Func)
-       n.Func.SetIsHiddenClosure(Curfn != nil)
-       return n
-}
-
-// this generates a new name node for a name
-// being declared.
-func dclname(s *types.Sym) *Node {
-       n := newname(s)
-       n.Op = ONONAME // caller will correct it
-       return n
-}
-
-func typenod(t *types.Type) *Node {
-       return typenodl(src.NoXPos, t)
-}
-
-func typenodl(pos src.XPos, t *types.Type) *Node {
-       // if we copied another type with *t = *u
-       // then t->nod might be out of date, so
-       // check t->nod->type too
-       if asNode(t.Nod) == nil || asNode(t.Nod).Type != t {
-               t.Nod = asTypesNode(nodl(pos, OTYPE, nil, nil))
-               asNode(t.Nod).Type = t
-               asNode(t.Nod).Sym = t.Sym
-       }
-
-       return asNode(t.Nod)
-}
-
-func anonfield(typ *types.Type) *Node {
-       return symfield(nil, typ)
-}
-
-func namedfield(s string, typ *types.Type) *Node {
-       return symfield(lookup(s), typ)
-}
-
-func symfield(s *types.Sym, typ *types.Type) *Node {
-       n := nodSym(ODCLFIELD, nil, s)
-       n.Type = typ
-       return n
-}
-
-// oldname returns the Node that declares symbol s in the current scope.
-// If no such Node currently exists, an ONONAME Node is returned instead.
-// Automatically creates a new closure variable if the referenced symbol was
-// declared in a different (containing) function.
-func oldname(s *types.Sym) *Node {
-       n := asNode(s.Def)
-       if n == nil {
-               // Maybe a top-level declaration will come along later to
-               // define s. resolve will check s.Def again once all input
-               // source has been processed.
-               return newnoname(s)
-       }
-
-       if Curfn != nil && n.Op == ONAME && n.Name.Curfn != nil && n.Name.Curfn != Curfn {
-               // Inner func is referring to var in outer func.
-               //
-               // TODO(rsc): If there is an outer variable x and we
-               // are parsing x := 5 inside the closure, until we get to
-               // the := it looks like a reference to the outer x so we'll
-               // make x a closure variable unnecessarily.
-               c := n.Name.Param.Innermost
-               if c == nil || c.Name.Curfn != Curfn {
-                       // Do not have a closure var for the active closure yet; make one.
-                       c = newname(s)
-                       c.SetClass(PAUTOHEAP)
-                       c.Name.SetIsClosureVar(true)
-                       c.SetIsDDD(n.IsDDD())
-                       c.Name.Defn = n
-
-                       // Link into list of active closure variables.
-                       // Popped from list in func funcLit.
-                       c.Name.Param.Outer = n.Name.Param.Innermost
-                       n.Name.Param.Innermost = c
-
-                       Curfn.Func.Cvars.Append(c)
-               }
-
-               // return ref to closure var, not original
-               return c
-       }
-
-       return n
-}
-
-// importName is like oldname, but it reports an error if sym is from another package and not exported.
-func importName(sym *types.Sym) *Node {
-       n := oldname(sym)
-       if !types.IsExported(sym.Name) && sym.Pkg != localpkg {
-               n.SetDiag(true)
-               yyerror("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
-       }
-       return n
-}
-
-// := declarations
-func colasname(n *Node) bool {
-       switch n.Op {
-       case ONAME,
-               ONONAME,
-               OPACK,
-               OTYPE,
-               OLITERAL:
-               return n.Sym != nil
-       }
-
-       return false
-}
-
-func colasdefn(left []*Node, defn *Node) {
-       for _, n := range left {
-               if n.Sym != nil {
-                       n.Sym.SetUniq(true)
-               }
-       }
-
-       var nnew, nerr int
-       for i, n := range left {
-               if n.isBlank() {
-                       continue
-               }
-               if !colasname(n) {
-                       yyerrorl(defn.Pos, "non-name %v on left side of :=", n)
-                       nerr++
-                       continue
-               }
-
-               if !n.Sym.Uniq() {
-                       yyerrorl(defn.Pos, "%v repeated on left side of :=", n.Sym)
-                       n.SetDiag(true)
-                       nerr++
-                       continue
-               }
-
-               n.Sym.SetUniq(false)
-               if n.Sym.Block == types.Block {
-                       continue
-               }
-
-               nnew++
-               n = newname(n.Sym)
-               declare(n, dclcontext)
-               n.Name.Defn = defn
-               defn.Ninit.Append(nod(ODCL, n, nil))
-               left[i] = n
-       }
-
-       if nnew == 0 && nerr == 0 {
-               yyerrorl(defn.Pos, "no new variables on left side of :=")
-       }
-}
-
-// declare the arguments in an
-// interface field declaration.
-func ifacedcl(n *Node) {
-       if n.Op != ODCLFIELD || n.Left == nil {
-               Fatalf("ifacedcl")
-       }
-
-       if n.Sym.IsBlank() {
-               yyerror("methods must have a unique non-blank name")
-       }
-}
-
-// declare the function proper
-// and declare the arguments.
-// called in extern-declaration context
-// returns in auto-declaration context.
-func funchdr(n *Node) {
-       // change the declaration context from extern to auto
-       funcStack = append(funcStack, funcStackEnt{Curfn, dclcontext})
-       Curfn = n
-       dclcontext = PAUTO
-
-       types.Markdcl()
-
-       if n.Func.Nname != nil {
-               funcargs(n.Func.Nname.Name.Param.Ntype)
-       } else if n.Func.Ntype != nil {
-               funcargs(n.Func.Ntype)
-       } else {
-               funcargs2(n.Type)
-       }
-}
-
-func funcargs(nt *Node) {
-       if nt.Op != OTFUNC {
-               Fatalf("funcargs %v", nt.Op)
-       }
-
-       // re-start the variable generation number
-       // we want to use small numbers for the return variables,
-       // so let them have the chunk starting at 1.
-       //
-       // TODO(mdempsky): This is ugly, and only necessary because
-       // esc.go uses Vargen to figure out result parameters' index
-       // within the result tuple.
-       vargen = nt.Rlist.Len()
-
-       // declare the receiver and in arguments.
-       if nt.Left != nil {
-               funcarg(nt.Left, PPARAM)
-       }
-       for _, n := range nt.List.Slice() {
-               funcarg(n, PPARAM)
-       }
-
-       oldvargen := vargen
-       vargen = 0
-
-       // declare the out arguments.
-       gen := nt.List.Len()
-       for _, n := range nt.Rlist.Slice() {
-               if n.Sym == nil {
-                       // Name so that escape analysis can track it. ~r stands for 'result'.
-                       n.Sym = lookupN("~r", gen)
-                       gen++
-               }
-               if n.Sym.IsBlank() {
-                       // Give it a name so we can assign to it during return. ~b stands for 'blank'.
-                       // The name must be different from ~r above because if you have
-                       //      func f() (_ int)
-                       //      func g() int
-                       // f is allowed to use a plain 'return' with no arguments, while g is not.
-                       // So the two cases must be distinguished.
-                       n.Sym = lookupN("~b", gen)
-                       gen++
-               }
-
-               funcarg(n, PPARAMOUT)
-       }
-
-       vargen = oldvargen
-}
-
-func funcarg(n *Node, ctxt Class) {
-       if n.Op != ODCLFIELD {
-               Fatalf("funcarg %v", n.Op)
-       }
-       if n.Sym == nil {
-               return
-       }
-
-       n.Right = newnamel(n.Pos, n.Sym)
-       n.Right.Name.Param.Ntype = n.Left
-       n.Right.SetIsDDD(n.IsDDD())
-       declare(n.Right, ctxt)
-
-       vargen++
-       n.Right.Name.Vargen = int32(vargen)
-}
-
-// Same as funcargs, except run over an already constructed TFUNC.
-// This happens during import, where the hidden_fndcl rule has
-// used functype directly to parse the function's type.
-func funcargs2(t *types.Type) {
-       if t.Etype != TFUNC {
-               Fatalf("funcargs2 %v", t)
-       }
-
-       for _, f := range t.Recvs().Fields().Slice() {
-               funcarg2(f, PPARAM)
-       }
-       for _, f := range t.Params().Fields().Slice() {
-               funcarg2(f, PPARAM)
-       }
-       for _, f := range t.Results().Fields().Slice() {
-               funcarg2(f, PPARAMOUT)
-       }
-}
-
-func funcarg2(f *types.Field, ctxt Class) {
-       if f.Sym == nil {
-               return
-       }
-       n := newnamel(f.Pos, f.Sym)
-       f.Nname = asTypesNode(n)
-       n.Type = f.Type
-       n.SetIsDDD(f.IsDDD())
-       declare(n, ctxt)
-}
-
-var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
-
-type funcStackEnt struct {
-       curfn      *Node
-       dclcontext Class
-}
-
-// finish the body.
-// called in auto-declaration context.
-// returns in extern-declaration context.
-func funcbody() {
-       // change the declaration context from auto to previous context
-       types.Popdcl()
-       var e funcStackEnt
-       funcStack, e = funcStack[:len(funcStack)-1], funcStack[len(funcStack)-1]
-       Curfn, dclcontext = e.curfn, e.dclcontext
-}
-
-// structs, functions, and methods.
-// they don't belong here, but where do they belong?
-func checkembeddedtype(t *types.Type) {
-       if t == nil {
-               return
-       }
-
-       if t.Sym == nil && t.IsPtr() {
-               t = t.Elem()
-               if t.IsInterface() {
-                       yyerror("embedded type cannot be a pointer to interface")
-               }
-       }
-
-       if t.IsPtr() || t.IsUnsafePtr() {
-               yyerror("embedded type cannot be a pointer")
-       } else if t.Etype == TFORW && !t.ForwardType().Embedlineno.IsKnown() {
-               t.ForwardType().Embedlineno = lineno
-       }
-}
-
-func structfield(n *Node) *types.Field {
-       lno := lineno
-       lineno = n.Pos
-
-       if n.Op != ODCLFIELD {
-               Fatalf("structfield: oops %v\n", n)
-       }
-
-       f := types.NewField()
-       f.Pos = n.Pos
-       f.Sym = n.Sym
-
-       if n.Left != nil {
-               n.Left = typecheck(n.Left, ctxType)
-               n.Type = n.Left.Type
-               n.Left = nil
-       }
-
-       f.Type = n.Type
-       if f.Type == nil {
-               f.SetBroke(true)
-       }
-
-       if n.Embedded() {
-               checkembeddedtype(n.Type)
-               f.Embedded = 1
-       } else {
-               f.Embedded = 0
-       }
-
-       switch u := n.Val().U.(type) {
-       case string:
-               f.Note = u
-       default:
-               yyerror("field tag must be a string")
-       case nil:
-               // no-op
-       }
-
-       lineno = lno
-       return f
-}
-
-// checkdupfields emits errors for duplicately named fields or methods in
-// a list of struct or interface types.
-func checkdupfields(what string, fss ...[]*types.Field) {
-       seen := make(map[*types.Sym]bool)
-       for _, fs := range fss {
-               for _, f := range fs {
-                       if f.Sym == nil || f.Sym.IsBlank() {
-                               continue
-                       }
-                       if seen[f.Sym] {
-                               yyerrorl(f.Pos, "duplicate %s %s", what, f.Sym.Name)
-                               continue
-                       }
-                       seen[f.Sym] = true
-               }
-       }
-}
-
-// convert a parsed id/type list into
-// a type for struct/interface/arglist
-func tostruct(l []*Node) *types.Type {
-       t := types.New(TSTRUCT)
-
-       fields := make([]*types.Field, len(l))
-       for i, n := range l {
-               f := structfield(n)
-               if f.Broke() {
-                       t.SetBroke(true)
-               }
-               fields[i] = f
-       }
-       t.SetFields(fields)
-
-       checkdupfields("field", t.FieldSlice())
-
-       if !t.Broke() {
-               checkwidth(t)
-       }
-
-       return t
-}
-
-func tofunargs(l []*Node, funarg types.Funarg) *types.Type {
-       t := types.New(TSTRUCT)
-       t.StructType().Funarg = funarg
-
-       fields := make([]*types.Field, len(l))
-       for i, n := range l {
-               f := structfield(n)
-               f.SetIsDDD(n.IsDDD())
-               if n.Right != nil {
-                       n.Right.Type = f.Type
-                       f.Nname = asTypesNode(n.Right)
-               }
-               if f.Broke() {
-                       t.SetBroke(true)
-               }
-               fields[i] = f
-       }
-       t.SetFields(fields)
-       return t
-}
-
-func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
-       t := types.New(TSTRUCT)
-       t.StructType().Funarg = funarg
-       t.SetFields(fields)
-       return t
-}
-
-func interfacefield(n *Node) *types.Field {
-       lno := lineno
-       lineno = n.Pos
-
-       if n.Op != ODCLFIELD {
-               Fatalf("interfacefield: oops %v\n", n)
-       }
-
-       if n.Val().Ctype() != CTxxx {
-               yyerror("interface method cannot have annotation")
-       }
-
-       // MethodSpec = MethodName Signature | InterfaceTypeName .
-       //
-       // If Sym != nil, then Sym is MethodName and Left is Signature.
-       // Otherwise, Left is InterfaceTypeName.
-
-       if n.Left != nil {
-               n.Left = typecheck(n.Left, ctxType)
-               n.Type = n.Left.Type
-               n.Left = nil
-       }
-
-       f := types.NewField()
-       f.Pos = n.Pos
-       f.Sym = n.Sym
-       f.Type = n.Type
-       if f.Type == nil {
-               f.SetBroke(true)
-       }
-
-       lineno = lno
-       return f
-}
-
-func tointerface(l []*Node) *types.Type {
-       if len(l) == 0 {
-               return types.Types[TINTER]
-       }
-       t := types.New(TINTER)
-       var fields []*types.Field
-       for _, n := range l {
-               f := interfacefield(n)
-               if f.Broke() {
-                       t.SetBroke(true)
-               }
-               fields = append(fields, f)
-       }
-       t.SetInterface(fields)
-       return t
-}
-
-func fakeRecv() *Node {
-       return anonfield(types.FakeRecvType())
-}
-
-func fakeRecvField() *types.Field {
-       f := types.NewField()
-       f.Type = types.FakeRecvType()
-       return f
-}
-
-// isifacemethod reports whether (field) m is
-// an interface method. Such methods have the
-// special receiver type types.FakeRecvType().
-func isifacemethod(f *types.Type) bool {
-       return f.Recv().Type == types.FakeRecvType()
-}
-
-// turn a parsed function declaration into a type
-func functype(this *Node, in, out []*Node) *types.Type {
-       t := types.New(TFUNC)
-
-       var rcvr []*Node
-       if this != nil {
-               rcvr = []*Node{this}
-       }
-       t.FuncType().Receiver = tofunargs(rcvr, types.FunargRcvr)
-       t.FuncType().Params = tofunargs(in, types.FunargParams)
-       t.FuncType().Results = tofunargs(out, types.FunargResults)
-
-       checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
-
-       if t.Recvs().Broke() || t.Results().Broke() || t.Params().Broke() {
-               t.SetBroke(true)
-       }
-
-       t.FuncType().Outnamed = t.NumResults() > 0 && origSym(t.Results().Field(0).Sym) != nil
-
-       return t
-}
-
-func functypefield(this *types.Field, in, out []*types.Field) *types.Type {
-       t := types.New(TFUNC)
-
-       var rcvr []*types.Field
-       if this != nil {
-               rcvr = []*types.Field{this}
-       }
-       t.FuncType().Receiver = tofunargsfield(rcvr, types.FunargRcvr)
-       t.FuncType().Params = tofunargsfield(in, types.FunargParams)
-       t.FuncType().Results = tofunargsfield(out, types.FunargResults)
-
-       t.FuncType().Outnamed = t.NumResults() > 0 && origSym(t.Results().Field(0).Sym) != nil
-
-       return t
-}
-
-// origSym returns the original symbol written by the user.
-func origSym(s *types.Sym) *types.Sym {
-       if s == nil {
-               return nil
-       }
-
-       if len(s.Name) > 1 && s.Name[0] == '~' {
-               switch s.Name[1] {
-               case 'r': // originally an unnamed result
-                       return nil
-               case 'b': // originally the blank identifier _
-                       // TODO(mdempsky): Does s.Pkg matter here?
-                       return nblank.Sym
-               }
-               return s
-       }
-
-       if strings.HasPrefix(s.Name, ".anon") {
-               // originally an unnamed or _ name (see subr.go: structargs)
-               return nil
-       }
-
-       return s
-}
-
-// methodSym returns the method symbol representing a method name
-// associated with a specific receiver type.
-//
-// Method symbols can be used to distinguish the same method appearing
-// in different method sets. For example, T.M and (*T).M have distinct
-// method symbols.
-//
-// The returned symbol will be marked as a function.
-func methodSym(recv *types.Type, msym *types.Sym) *types.Sym {
-       sym := methodSymSuffix(recv, msym, "")
-       sym.SetFunc(true)
-       return sym
-}
-
-// methodSymSuffix is like methodsym, but allows attaching a
-// distinguisher suffix. To avoid collisions, the suffix must not
-// start with a letter, number, or period.
-func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym {
-       if msym.IsBlank() {
-               Fatalf("blank method name")
-       }
-
-       rsym := recv.Sym
-       if recv.IsPtr() {
-               if rsym != nil {
-                       Fatalf("declared pointer receiver type: %v", recv)
-               }
-               rsym = recv.Elem().Sym
-       }
-
-       // Find the package the receiver type appeared in. For
-       // anonymous receiver types (i.e., anonymous structs with
-       // embedded fields), use the "go" pseudo-package instead.
-       rpkg := gopkg
-       if rsym != nil {
-               rpkg = rsym.Pkg
-       }
-
-       var b bytes.Buffer
-       if recv.IsPtr() {
-               // The parentheses aren't really necessary, but
-               // they're pretty traditional at this point.
-               fmt.Fprintf(&b, "(%-S)", recv)
-       } else {
-               fmt.Fprintf(&b, "%-S", recv)
-       }
-
-       // A particular receiver type may have multiple non-exported
-       // methods with the same name. To disambiguate them, include a
-       // package qualifier for names that came from a different
-       // package than the receiver type.
-       if !types.IsExported(msym.Name) && msym.Pkg != rpkg {
-               b.WriteString(".")
-               b.WriteString(msym.Pkg.Prefix)
-       }
-
-       b.WriteString(".")
-       b.WriteString(msym.Name)
-       b.WriteString(suffix)
-
-       return rpkg.LookupBytes(b.Bytes())
-}
-
-// Add a method, declared as a function.
-// - msym is the method symbol
-// - t is function type (with receiver)
-// Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
-       if msym == nil {
-               Fatalf("no method symbol")
-       }
-
-       // get parent type sym
-       rf := t.Recv() // ptr to this structure
-       if rf == nil {
-               yyerror("missing receiver")
-               return nil
-       }
-
-       mt := methtype(rf.Type)
-       if mt == nil || mt.Sym == nil {
-               pa := rf.Type
-               t := pa
-               if t != nil && t.IsPtr() {
-                       if t.Sym != nil {
-                               yyerror("invalid receiver type %v (%v is a pointer type)", pa, t)
-                               return nil
-                       }
-                       t = t.Elem()
-               }
-
-               switch {
-               case t == nil || t.Broke():
-                       // rely on typecheck having complained before
-               case t.Sym == nil:
-                       yyerror("invalid receiver type %v (%v is not a defined type)", pa, t)
-               case t.IsPtr():
-                       yyerror("invalid receiver type %v (%v is a pointer type)", pa, t)
-               case t.IsInterface():
-                       yyerror("invalid receiver type %v (%v is an interface type)", pa, t)
-               default:
-                       // Should have picked off all the reasons above,
-                       // but just in case, fall back to generic error.
-                       yyerror("invalid receiver type %v (%L / %L)", pa, pa, t)
-               }
-               return nil
-       }
-
-       if local && mt.Sym.Pkg != localpkg {
-               yyerror("cannot define new methods on non-local type %v", mt)
-               return nil
-       }
-
-       if msym.IsBlank() {
-               return nil
-       }
-
-       if mt.IsStruct() {
-               for _, f := range mt.Fields().Slice() {
-                       if f.Sym == msym {
-                               yyerror("type %v has both field and method named %v", mt, msym)
-                               f.SetBroke(true)
-                               return nil
-                       }
-               }
-       }
-
-       for _, f := range mt.Methods().Slice() {
-               if msym.Name != f.Sym.Name {
-                       continue
-               }
-               // types.Identical only checks that incoming and result parameters match,
-               // so explicitly check that the receiver parameters match too.
-               if !types.Identical(t, f.Type) || !types.Identical(t.Recv().Type, f.Type.Recv().Type) {
-                       yyerror("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
-               }
-               return f
-       }
-
-       f := types.NewField()
-       f.Pos = lineno
-       f.Sym = msym
-       f.Type = t
-       f.SetNointerface(nointerface)
-
-       mt.Methods().Append(f)
-       return f
-}
-
-func funcsymname(s *types.Sym) string {
-       return s.Name + "·f"
-}
-
-// funcsym returns s·f.
-func funcsym(s *types.Sym) *types.Sym {
-       // funcsymsmu here serves to protect not just mutations of funcsyms (below),
-       // but also the package lookup of the func sym name,
-       // since this function gets called concurrently from the backend.
-       // There are no other concurrent package lookups in the backend,
-       // except for the types package, which is protected separately.
-       // Reusing funcsymsmu to also cover this package lookup
-       // avoids a general, broader, expensive package lookup mutex.
-       // Note makefuncsym also does package look-up of func sym names,
-       // but that it is only called serially, from the front end.
-       funcsymsmu.Lock()
-       sf, existed := s.Pkg.LookupOK(funcsymname(s))
-       // Don't export s·f when compiling for dynamic linking.
-       // When dynamically linking, the necessary function
-       // symbols will be created explicitly with makefuncsym.
-       // See the makefuncsym comment for details.
-       if !Ctxt.Flag_dynlink && !existed {
-               funcsyms = append(funcsyms, s)
-       }
-       funcsymsmu.Unlock()
-       return sf
-}
-
-// makefuncsym ensures that s·f is exported.
-// It is only used with -dynlink.
-// When not compiling for dynamic linking,
-// the funcsyms are created as needed by
-// the packages that use them.
-// Normally we emit the s·f stubs as DUPOK syms,
-// but DUPOK doesn't work across shared library boundaries.
-// So instead, when dynamic linking, we only create
-// the s·f stubs in s's package.
-func makefuncsym(s *types.Sym) {
-       if !Ctxt.Flag_dynlink {
-               Fatalf("makefuncsym dynlink")
-       }
-       if s.IsBlank() {
-               return
-       }
-       if compiling_runtime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
-               // runtime.getg(), getclosureptr(), getcallerpc(), and
-               // getcallersp() are not real functions and so do not
-               // get funcsyms.
-               return
-       }
-       if _, existed := s.Pkg.LookupOK(funcsymname(s)); !existed {
-               funcsyms = append(funcsyms, s)
-       }
-}
-
-// setNodeNameFunc marks a node as a function.
-func setNodeNameFunc(n *Node) {
-       if n.Op != ONAME || n.Class() != Pxxx {
-               Fatalf("expected ONAME/Pxxx node, got %v", n)
-       }
-
-       n.SetClass(PFUNC)
-       n.Sym.SetFunc(true)
-}
-
-func dclfunc(sym *types.Sym, tfn *Node) *Node {
-       if tfn.Op != OTFUNC {
-               Fatalf("expected OTFUNC node, got %v", tfn)
-       }
-
-       fn := nod(ODCLFUNC, nil, nil)
-       fn.Func.Nname = newfuncnamel(lineno, sym)
-       fn.Func.Nname.Name.Defn = fn
-       fn.Func.Nname.Name.Param.Ntype = tfn
-       setNodeNameFunc(fn.Func.Nname)
-       funchdr(fn)
-       fn.Func.Nname.Name.Param.Ntype = typecheck(fn.Func.Nname.Name.Param.Ntype, ctxType)
-       return fn
-}
-
-type nowritebarrierrecChecker struct {
-       // extraCalls contains extra function calls that may not be
-       // visible during later analysis. It maps from the ODCLFUNC of
-       // the caller to a list of callees.
-       extraCalls map[*Node][]nowritebarrierrecCall
-
-       // curfn is the current function during AST walks.
-       curfn *Node
-}
-
-type nowritebarrierrecCall struct {
-       target *Node    // ODCLFUNC of caller or callee
-       lineno src.XPos // line of call
-}
-
-type nowritebarrierrecCallSym struct {
-       target *obj.LSym // LSym of callee
-       lineno src.XPos  // line of call
-}
-
-// newNowritebarrierrecChecker creates a nowritebarrierrecChecker. It
-// must be called before transformclosure and walk.
-func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
-       c := &nowritebarrierrecChecker{
-               extraCalls: make(map[*Node][]nowritebarrierrecCall),
-       }
-
-       // Find all systemstack calls and record their targets. In
-       // general, flow analysis can't see into systemstack, but it's
-       // important to handle it for this check, so we model it
-       // directly. This has to happen before transformclosure since
-       // it's a lot harder to work out the argument after.
-       for _, n := range xtop {
-               if n.Op != ODCLFUNC {
-                       continue
-               }
-               c.curfn = n
-               inspect(n, c.findExtraCalls)
-       }
-       c.curfn = nil
-       return c
-}
-
-func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
-       if n.Op != OCALLFUNC {
-               return true
-       }
-       fn := n.Left
-       if fn == nil || fn.Op != ONAME || fn.Class() != PFUNC || fn.Name.Defn == nil {
-               return true
-       }
-       if !isRuntimePkg(fn.Sym.Pkg) || fn.Sym.Name != "systemstack" {
-               return true
-       }
-
-       var callee *Node
-       arg := n.List.First()
-       switch arg.Op {
-       case ONAME:
-               callee = arg.Name.Defn
-       case OCLOSURE:
-               callee = arg.Func.Closure
-       default:
-               Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
-       }
-       if callee.Op != ODCLFUNC {
-               Fatalf("expected ODCLFUNC node, got %+v", callee)
-       }
-       c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos})
-       return true
-}
-
-// recordCall records a call from ODCLFUNC node "from", to function
-// symbol "to" at position pos.
-//
-// This should be done as late as possible during compilation to
-// capture precise call graphs. The target of the call is an LSym
-// because that's all we know after we start SSA.
-//
-// This can be called concurrently for different from Nodes.
-func (c *nowritebarrierrecChecker) recordCall(from *Node, to *obj.LSym, pos src.XPos) {
-       if from.Op != ODCLFUNC {
-               Fatalf("expected ODCLFUNC, got %v", from)
-       }
-       // We record this information on the *Func so this is
-       // concurrent-safe.
-       fn := from.Func
-       if fn.nwbrCalls == nil {
-               fn.nwbrCalls = new([]nowritebarrierrecCallSym)
-       }
-       *fn.nwbrCalls = append(*fn.nwbrCalls, nowritebarrierrecCallSym{to, pos})
-}
-
-func (c *nowritebarrierrecChecker) check() {
-       // We walk the call graph as late as possible so we can
-       // capture all calls created by lowering, but this means we
-       // only get to see the obj.LSyms of calls. symToFunc lets us
-       // get back to the ODCLFUNCs.
-       symToFunc := make(map[*obj.LSym]*Node)
-       // funcs records the back-edges of the BFS call graph walk. It
-       // maps from the ODCLFUNC of each function that must not have
-       // write barriers to the call that inhibits them. Functions
-       // that are directly marked go:nowritebarrierrec are in this
-       // map with a zero-valued nowritebarrierrecCall. This also
-       // acts as the set of marks for the BFS of the call graph.
-       funcs := make(map[*Node]nowritebarrierrecCall)
-       // q is the queue of ODCLFUNC Nodes to visit in BFS order.
-       var q nodeQueue
-
-       for _, n := range xtop {
-               if n.Op != ODCLFUNC {
-                       continue
-               }
-
-               symToFunc[n.Func.lsym] = n
-
-               // Make nowritebarrierrec functions BFS roots.
-               if n.Func.Pragma&Nowritebarrierrec != 0 {
-                       funcs[n] = nowritebarrierrecCall{}
-                       q.pushRight(n)
-               }
-               // Check go:nowritebarrier functions.
-               if n.Func.Pragma&Nowritebarrier != 0 && n.Func.WBPos.IsKnown() {
-                       yyerrorl(n.Func.WBPos, "write barrier prohibited")
-               }
-       }
-
-       // Perform a BFS of the call graph from all
-       // go:nowritebarrierrec functions.
-       enqueue := func(src, target *Node, pos src.XPos) {
-               if target.Func.Pragma&Yeswritebarrierrec != 0 {
-                       // Don't flow into this function.
-                       return
-               }
-               if _, ok := funcs[target]; ok {
-                       // Already found a path to target.
-                       return
-               }
-
-               // Record the path.
-               funcs[target] = nowritebarrierrecCall{target: src, lineno: pos}
-               q.pushRight(target)
-       }
-       for !q.empty() {
-               fn := q.popLeft()
-
-               // Check fn.
-               if fn.Func.WBPos.IsKnown() {
-                       var err bytes.Buffer
-                       call := funcs[fn]
-                       for call.target != nil {
-                               fmt.Fprintf(&err, "\n\t%v: called by %v", linestr(call.lineno), call.target.Func.Nname)
-                               call = funcs[call.target]
-                       }
-                       yyerrorl(fn.Func.WBPos, "write barrier prohibited by caller; %v%s", fn.Func.Nname, err.String())
-                       continue
-               }
-
-               // Enqueue fn's calls.
-               for _, callee := range c.extraCalls[fn] {
-                       enqueue(fn, callee.target, callee.lineno)
-               }
-               if fn.Func.nwbrCalls == nil {
-                       continue
-               }
-               for _, callee := range *fn.Func.nwbrCalls {
-                       target := symToFunc[callee.target]
-                       if target != nil {
-                               enqueue(fn, target, callee.lineno)
-                       }
-               }
-       }
-}

diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
deleted file mode 100644 (file)
index 103949c..0000000
--- a/src/cmd/compile/internal/gc/embed.go
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/syntax"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "encoding/json"
-       "io/ioutil"
-       "log"
-       "path"
-       "sort"
-       "strconv"
-       "strings"
-)
-
-var embedlist []*Node
-
-var embedCfg struct {
-       Patterns map[string][]string
-       Files    map[string]string
-}
-
-func readEmbedCfg(file string) {
-       data, err := ioutil.ReadFile(file)
-       if err != nil {
-               log.Fatalf("-embedcfg: %v", err)
-       }
-       if err := json.Unmarshal(data, &embedCfg); err != nil {
-               log.Fatalf("%s: %v", file, err)
-       }
-       if embedCfg.Patterns == nil {
-               log.Fatalf("%s: invalid embedcfg: missing Patterns", file)
-       }
-       if embedCfg.Files == nil {
-               log.Fatalf("%s: invalid embedcfg: missing Files", file)
-       }
-}
-
-const (
-       embedUnknown = iota
-       embedBytes
-       embedString
-       embedFiles
-)
-
-var numLocalEmbed int
-
-func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []PragmaEmbed) (newExprs []*Node) {
-       haveEmbed := false
-       for _, decl := range p.file.DeclList {
-               imp, ok := decl.(*syntax.ImportDecl)
-               if !ok {
-                       // imports always come first
-                       break
-               }
-               path, _ := strconv.Unquote(imp.Path.Value)
-               if path == "embed" {
-                       haveEmbed = true
-                       break
-               }
-       }
-
-       pos := embeds[0].Pos
-       if !haveEmbed {
-               p.yyerrorpos(pos, "invalid go:embed: missing import \"embed\"")
-               return exprs
-       }
-       if embedCfg.Patterns == nil {
-               p.yyerrorpos(pos, "invalid go:embed: build system did not supply embed configuration")
-               return exprs
-       }
-       if len(names) > 1 {
-               p.yyerrorpos(pos, "go:embed cannot apply to multiple vars")
-               return exprs
-       }
-       if len(exprs) > 0 {
-               p.yyerrorpos(pos, "go:embed cannot apply to var with initializer")
-               return exprs
-       }
-       if typ == nil {
-               // Should not happen, since len(exprs) == 0 now.
-               p.yyerrorpos(pos, "go:embed cannot apply to var without type")
-               return exprs
-       }
-
-       kind := embedKindApprox(typ)
-       if kind == embedUnknown {
-               p.yyerrorpos(pos, "go:embed cannot apply to var of type %v", typ)
-               return exprs
-       }
-
-       // Build list of files to store.
-       have := make(map[string]bool)
-       var list []string
-       for _, e := range embeds {
-               for _, pattern := range e.Patterns {
-                       files, ok := embedCfg.Patterns[pattern]
-                       if !ok {
-                               p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
-                       }
-                       for _, file := range files {
-                               if embedCfg.Files[file] == "" {
-                                       p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map file: %s", file)
-                                       continue
-                               }
-                               if !have[file] {
-                                       have[file] = true
-                                       list = append(list, file)
-                               }
-                               if kind == embedFiles {
-                                       for dir := path.Dir(file); dir != "." && !have[dir]; dir = path.Dir(dir) {
-                                               have[dir] = true
-                                               list = append(list, dir+"/")
-                                       }
-                               }
-                       }
-               }
-       }
-       sort.Slice(list, func(i, j int) bool {
-               return embedFileLess(list[i], list[j])
-       })
-
-       if kind == embedString || kind == embedBytes {
-               if len(list) > 1 {
-                       p.yyerrorpos(pos, "invalid go:embed: multiple files for type %v", typ)
-                       return exprs
-               }
-       }
-
-       v := names[0]
-       if dclcontext != PEXTERN {
-               numLocalEmbed++
-               v = newnamel(v.Pos, lookupN("embed.", numLocalEmbed))
-               v.Sym.Def = asTypesNode(v)
-               v.Name.Param.Ntype = typ
-               v.SetClass(PEXTERN)
-               externdcl = append(externdcl, v)
-               exprs = []*Node{v}
-       }
-
-       v.Name.Param.SetEmbedFiles(list)
-       embedlist = append(embedlist, v)
-       return exprs
-}
-
-// embedKindApprox determines the kind of embedding variable, approximately.
-// The match is approximate because we haven't done scope resolution yet and
-// can't tell whether "string" and "byte" really mean "string" and "byte".
-// The result must be confirmed later, after type checking, using embedKind.
-func embedKindApprox(typ *Node) int {
-       if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && myimportpath == "embed")) {
-               return embedFiles
-       }
-       // These are not guaranteed to match only string and []byte -
-       // maybe the local package has redefined one of those words.
-       // But it's the best we can do now during the noder.
-       // The stricter check happens later, in initEmbed calling embedKind.
-       if typ.Sym != nil && typ.Sym.Name == "string" && typ.Sym.Pkg == localpkg {
-               return embedString
-       }
-       if typ.Op == OTARRAY && typ.Left == nil && typ.Right.Sym != nil && typ.Right.Sym.Name == "byte" && typ.Right.Sym.Pkg == localpkg {
-               return embedBytes
-       }
-       return embedUnknown
-}
-
-// embedKind determines the kind of embedding variable.
-func embedKind(typ *types.Type) int {
-       if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && myimportpath == "embed")) {
-               return embedFiles
-       }
-       if typ == types.Types[TSTRING] {
-               return embedString
-       }
-       if typ.Sym == nil && typ.IsSlice() && typ.Elem() == types.Bytetype {
-               return embedBytes
-       }
-       return embedUnknown
-}
-
-func embedFileNameSplit(name string) (dir, elem string, isDir bool) {
-       if name[len(name)-1] == '/' {
-               isDir = true
-               name = name[:len(name)-1]
-       }
-       i := len(name) - 1
-       for i >= 0 && name[i] != '/' {
-               i--
-       }
-       if i < 0 {
-               return ".", name, isDir
-       }
-       return name[:i], name[i+1:], isDir
-}
-
-// embedFileLess implements the sort order for a list of embedded files.
-// See the comment inside ../../../../embed/embed.go's Files struct for rationale.
-func embedFileLess(x, y string) bool {
-       xdir, xelem, _ := embedFileNameSplit(x)
-       ydir, yelem, _ := embedFileNameSplit(y)
-       return xdir < ydir || xdir == ydir && xelem < yelem
-}
-
-func dumpembeds() {
-       for _, v := range embedlist {
-               initEmbed(v)
-       }
-}
-
-// initEmbed emits the init data for a //go:embed variable,
-// which is either a string, a []byte, or an embed.FS.
-func initEmbed(v *Node) {
-       files := v.Name.Param.EmbedFiles()
-       switch kind := embedKind(v.Type); kind {
-       case embedUnknown:
-               yyerrorl(v.Pos, "go:embed cannot apply to var of type %v", v.Type)
-
-       case embedString, embedBytes:
-               file := files[0]
-               fsym, size, err := fileStringSym(v.Pos, embedCfg.Files[file], kind == embedString, nil)
-               if err != nil {
-                       yyerrorl(v.Pos, "embed %s: %v", file, err)
-               }
-               sym := v.Sym.Linksym()
-               off := 0
-               off = dsymptr(sym, off, fsym, 0)       // data string
-               off = duintptr(sym, off, uint64(size)) // len
-               if kind == embedBytes {
-                       duintptr(sym, off, uint64(size)) // cap for slice
-               }
-
-       case embedFiles:
-               slicedata := Ctxt.Lookup(`"".` + v.Sym.Name + `.files`)
-               off := 0
-               // []files pointed at by Files
-               off = dsymptr(slicedata, off, slicedata, 3*Widthptr) // []file, pointing just past slice
-               off = duintptr(slicedata, off, uint64(len(files)))
-               off = duintptr(slicedata, off, uint64(len(files)))
-
-               // embed/embed.go type file is:
-               //      name string
-               //      data string
-               //      hash [16]byte
-               // Emit one of these per file in the set.
-               const hashSize = 16
-               hash := make([]byte, hashSize)
-               for _, file := range files {
-                       off = dsymptr(slicedata, off, stringsym(v.Pos, file), 0) // file string
-                       off = duintptr(slicedata, off, uint64(len(file)))
-                       if strings.HasSuffix(file, "/") {
-                               // entry for directory - no data
-                               off = duintptr(slicedata, off, 0)
-                               off = duintptr(slicedata, off, 0)
-                               off += hashSize
-                       } else {
-                               fsym, size, err := fileStringSym(v.Pos, embedCfg.Files[file], true, hash)
-                               if err != nil {
-                                       yyerrorl(v.Pos, "embed %s: %v", file, err)
-                               }
-                               off = dsymptr(slicedata, off, fsym, 0) // data string
-                               off = duintptr(slicedata, off, uint64(size))
-                               off = int(slicedata.WriteBytes(Ctxt, int64(off), hash))
-                       }
-               }
-               ggloblsym(slicedata, int32(off), obj.RODATA|obj.LOCAL)
-               sym := v.Sym.Linksym()
-               dsymptr(sym, 0, slicedata, 0)
-       }
-}

diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
deleted file mode 100644 (file)
index 6f328ab..0000000
--- a/src/cmd/compile/internal/gc/esc.go
+++ /dev/null
@@ -1,472 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "fmt"
-)
-
-func escapes(all []*Node) {
-       visitBottomUp(all, escapeFuncs)
-}
-
-const (
-       EscFuncUnknown = 0 + iota
-       EscFuncPlanned
-       EscFuncStarted
-       EscFuncTagged
-)
-
-func min8(a, b int8) int8 {
-       if a < b {
-               return a
-       }
-       return b
-}
-
-func max8(a, b int8) int8 {
-       if a > b {
-               return a
-       }
-       return b
-}
-
-const (
-       EscUnknown = iota
-       EscNone    // Does not escape to heap, result, or parameters.
-       EscHeap    // Reachable from the heap
-       EscNever   // By construction will not escape.
-)
-
-// funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
-func funcSym(fn *Node) *types.Sym {
-       if fn == nil || fn.Func.Nname == nil {
-               return nil
-       }
-       return fn.Func.Nname.Sym
-}
-
-// Mark labels that have no backjumps to them as not increasing e.loopdepth.
-// Walk hasn't generated (goto|label).Left.Sym.Label yet, so we'll cheat
-// and set it to one of the following two. Then in esc we'll clear it again.
-var (
-       looping    Node
-       nonlooping Node
-)
-
-func isSliceSelfAssign(dst, src *Node) bool {
-       // Detect the following special case.
-       //
-       //      func (b *Buffer) Foo() {
-       //              n, m := ...
-       //              b.buf = b.buf[n:m]
-       //      }
-       //
-       // This assignment is a no-op for escape analysis,
-       // it does not store any new pointers into b that were not already there.
-       // However, without this special case b will escape, because we assign to OIND/ODOTPTR.
-       // Here we assume that the statement will not contain calls,
-       // that is, that order will move any calls to init.
-       // Otherwise base ONAME value could change between the moments
-       // when we evaluate it for dst and for src.
-
-       // dst is ONAME dereference.
-       if dst.Op != ODEREF && dst.Op != ODOTPTR || dst.Left.Op != ONAME {
-               return false
-       }
-       // src is a slice operation.
-       switch src.Op {
-       case OSLICE, OSLICE3, OSLICESTR:
-               // OK.
-       case OSLICEARR, OSLICE3ARR:
-               // Since arrays are embedded into containing object,
-               // slice of non-pointer array will introduce a new pointer into b that was not already there
-               // (pointer to b itself). After such assignment, if b contents escape,
-               // b escapes as well. If we ignore such OSLICEARR, we will conclude
-               // that b does not escape when b contents do.
-               //
-               // Pointer to an array is OK since it's not stored inside b directly.
-               // For slicing an array (not pointer to array), there is an implicit OADDR.
-               // We check that to determine non-pointer array slicing.
-               if src.Left.Op == OADDR {
-                       return false
-               }
-       default:
-               return false
-       }
-       // slice is applied to ONAME dereference.
-       if src.Left.Op != ODEREF && src.Left.Op != ODOTPTR || src.Left.Left.Op != ONAME {
-               return false
-       }
-       // dst and src reference the same base ONAME.
-       return dst.Left == src.Left.Left
-}
-
-// isSelfAssign reports whether assignment from src to dst can
-// be ignored by the escape analysis as it's effectively a self-assignment.
-func isSelfAssign(dst, src *Node) bool {
-       if isSliceSelfAssign(dst, src) {
-               return true
-       }
-
-       // Detect trivial assignments that assign back to the same object.
-       //
-       // It covers these cases:
-       //      val.x = val.y
-       //      val.x[i] = val.y[j]
-       //      val.x1.x2 = val.x1.y2
-       //      ... etc
-       //
-       // These assignments do not change assigned object lifetime.
-
-       if dst == nil || src == nil || dst.Op != src.Op {
-               return false
-       }
-
-       switch dst.Op {
-       case ODOT, ODOTPTR:
-               // Safe trailing accessors that are permitted to differ.
-       case OINDEX:
-               if mayAffectMemory(dst.Right) || mayAffectMemory(src.Right) {
-                       return false
-               }
-       default:
-               return false
-       }
-
-       // The expression prefix must be both "safe" and identical.
-       return samesafeexpr(dst.Left, src.Left)
-}
-
-// mayAffectMemory reports whether evaluation of n may affect the program's
-// memory state. If the expression can't affect memory state, then it can be
-// safely ignored by the escape analysis.
-func mayAffectMemory(n *Node) bool {
-       // We may want to use a list of "memory safe" ops instead of generally
-       // "side-effect free", which would include all calls and other ops that can
-       // allocate or change global state. For now, it's safer to start with the latter.
-       //
-       // We're ignoring things like division by zero, index out of range,
-       // and nil pointer dereference here.
-       switch n.Op {
-       case ONAME, OCLOSUREVAR, OLITERAL:
-               return false
-
-       // Left+Right group.
-       case OINDEX, OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
-               return mayAffectMemory(n.Left) || mayAffectMemory(n.Right)
-
-       // Left group.
-       case ODOT, ODOTPTR, ODEREF, OCONVNOP, OCONV, OLEN, OCAP,
-               ONOT, OBITNOT, OPLUS, ONEG, OALIGNOF, OOFFSETOF, OSIZEOF:
-               return mayAffectMemory(n.Left)
-
-       default:
-               return true
-       }
-}
-
-// heapAllocReason returns the reason the given Node must be heap
-// allocated, or the empty string if it doesn't.
-func heapAllocReason(n *Node) string {
-       if n.Type == nil {
-               return ""
-       }
-
-       // Parameters are always passed via the stack.
-       if n.Op == ONAME && (n.Class() == PPARAM || n.Class() == PPARAMOUT) {
-               return ""
-       }
-
-       if n.Type.Width > maxStackVarSize {
-               return "too large for stack"
-       }
-
-       if (n.Op == ONEW || n.Op == OPTRLIT) && n.Type.Elem().Width >= maxImplicitStackVarSize {
-               return "too large for stack"
-       }
-
-       if n.Op == OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
-               return "too large for stack"
-       }
-       if n.Op == OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
-               return "too large for stack"
-       }
-
-       if n.Op == OMAKESLICE {
-               r := n.Right
-               if r == nil {
-                       r = n.Left
-               }
-               if !smallintconst(r) {
-                       return "non-constant size"
-               }
-               if t := n.Type; t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
-                       return "too large for stack"
-               }
-       }
-
-       return ""
-}
-
-// addrescapes tags node n as having had its address taken
-// by "increasing" the "value" of n.Esc to EscHeap.
-// Storage is allocated as necessary to allow the address
-// to be taken.
-func addrescapes(n *Node) {
-       switch n.Op {
-       default:
-               // Unexpected Op, probably due to a previous type error. Ignore.
-
-       case ODEREF, ODOTPTR:
-               // Nothing to do.
-
-       case ONAME:
-               if n == nodfp {
-                       break
-               }
-
-               // if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
-               // on PPARAM it means something different.
-               if n.Class() == PAUTO && n.Esc == EscNever {
-                       break
-               }
-
-               // If a closure reference escapes, mark the outer variable as escaping.
-               if n.Name.IsClosureVar() {
-                       addrescapes(n.Name.Defn)
-                       break
-               }
-
-               if n.Class() != PPARAM && n.Class() != PPARAMOUT && n.Class() != PAUTO {
-                       break
-               }
-
-               // This is a plain parameter or local variable that needs to move to the heap,
-               // but possibly for the function outside the one we're compiling.
-               // That is, if we have:
-               //
-               //      func f(x int) {
-               //              func() {
-               //                      global = &x
-               //              }
-               //      }
-               //
-               // then we're analyzing the inner closure but we need to move x to the
-               // heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
-               oldfn := Curfn
-               Curfn = n.Name.Curfn
-               if Curfn.Func.Closure != nil && Curfn.Op == OCLOSURE {
-                       Curfn = Curfn.Func.Closure
-               }
-               ln := lineno
-               lineno = Curfn.Pos
-               moveToHeap(n)
-               Curfn = oldfn
-               lineno = ln
-
-       // ODOTPTR has already been introduced,
-       // so these are the non-pointer ODOT and OINDEX.
-       // In &x[0], if x is a slice, then x does not
-       // escape--the pointer inside x does, but that
-       // is always a heap pointer anyway.
-       case ODOT, OINDEX, OPAREN, OCONVNOP:
-               if !n.Left.Type.IsSlice() {
-                       addrescapes(n.Left)
-               }
-       }
-}
-
-// moveToHeap records the parameter or local variable n as moved to the heap.
-func moveToHeap(n *Node) {
-       if Debug.r != 0 {
-               Dump("MOVE", n)
-       }
-       if compiling_runtime {
-               yyerror("%v escapes to heap, not allowed in runtime", n)
-       }
-       if n.Class() == PAUTOHEAP {
-               Dump("n", n)
-               Fatalf("double move to heap")
-       }
-
-       // Allocate a local stack variable to hold the pointer to the heap copy.
-       // temp will add it to the function declaration list automatically.
-       heapaddr := temp(types.NewPtr(n.Type))
-       heapaddr.Sym = lookup("&" + n.Sym.Name)
-       heapaddr.Orig.Sym = heapaddr.Sym
-       heapaddr.Pos = n.Pos
-
-       // Unset AutoTemp to persist the &foo variable name through SSA to
-       // liveness analysis.
-       // TODO(mdempsky/drchase): Cleaner solution?
-       heapaddr.Name.SetAutoTemp(false)
-
-       // Parameters have a local stack copy used at function start/end
-       // in addition to the copy in the heap that may live longer than
-       // the function.
-       if n.Class() == PPARAM || n.Class() == PPARAMOUT {
-               if n.Xoffset == BADWIDTH {
-                       Fatalf("addrescapes before param assignment")
-               }
-
-               // We rewrite n below to be a heap variable (indirection of heapaddr).
-               // Preserve a copy so we can still write code referring to the original,
-               // and substitute that copy into the function declaration list
-               // so that analyses of the local (on-stack) variables use it.
-               stackcopy := newname(n.Sym)
-               stackcopy.Type = n.Type
-               stackcopy.Xoffset = n.Xoffset
-               stackcopy.SetClass(n.Class())
-               stackcopy.Name.Param.Heapaddr = heapaddr
-               if n.Class() == PPARAMOUT {
-                       // Make sure the pointer to the heap copy is kept live throughout the function.
-                       // The function could panic at any point, and then a defer could recover.
-                       // Thus, we need the pointer to the heap copy always available so the
-                       // post-deferreturn code can copy the return value back to the stack.
-                       // See issue 16095.
-                       heapaddr.Name.SetIsOutputParamHeapAddr(true)
-               }
-               n.Name.Param.Stackcopy = stackcopy
-
-               // Substitute the stackcopy into the function variable list so that
-               // liveness and other analyses use the underlying stack slot
-               // and not the now-pseudo-variable n.
-               found := false
-               for i, d := range Curfn.Func.Dcl {
-                       if d == n {
-                               Curfn.Func.Dcl[i] = stackcopy
-                               found = true
-                               break
-                       }
-                       // Parameters are before locals, so can stop early.
-                       // This limits the search even in functions with many local variables.
-                       if d.Class() == PAUTO {
-                               break
-                       }
-               }
-               if !found {
-                       Fatalf("cannot find %v in local variable list", n)
-               }
-               Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-       }
-
-       // Modify n in place so that uses of n now mean indirection of the heapaddr.
-       n.SetClass(PAUTOHEAP)
-       n.Xoffset = 0
-       n.Name.Param.Heapaddr = heapaddr
-       n.Esc = EscHeap
-       if Debug.m != 0 {
-               Warnl(n.Pos, "moved to heap: %v", n)
-       }
-}
-
-// This special tag is applied to uintptr variables
-// that we believe may hold unsafe.Pointers for
-// calls into assembly functions.
-const unsafeUintptrTag = "unsafe-uintptr"
-
-// This special tag is applied to uintptr parameters of functions
-// marked go:uintptrescapes.
-const uintptrEscapesTag = "uintptr-escapes"
-
-func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
-       name := func() string {
-               if f.Sym != nil {
-                       return f.Sym.Name
-               }
-               return fmt.Sprintf("arg#%d", narg)
-       }
-
-       if fn.Nbody.Len() == 0 {
-               // Assume that uintptr arguments must be held live across the call.
-               // This is most important for syscall.Syscall.
-               // See golang.org/issue/13372.
-               // This really doesn't have much to do with escape analysis per se,
-               // but we are reusing the ability to annotate an individual function
-               // argument and pass those annotations along to importing code.
-               if f.Type.IsUintptr() {
-                       if Debug.m != 0 {
-                               Warnl(f.Pos, "assuming %v is unsafe uintptr", name())
-                       }
-                       return unsafeUintptrTag
-               }
-
-               if !f.Type.HasPointers() { // don't bother tagging for scalars
-                       return ""
-               }
-
-               var esc EscLeaks
-
-               // External functions are assumed unsafe, unless
-               // //go:noescape is given before the declaration.
-               if fn.Func.Pragma&Noescape != 0 {
-                       if Debug.m != 0 && f.Sym != nil {
-                               Warnl(f.Pos, "%v does not escape", name())
-                       }
-               } else {
-                       if Debug.m != 0 && f.Sym != nil {
-                               Warnl(f.Pos, "leaking param: %v", name())
-                       }
-                       esc.AddHeap(0)
-               }
-
-               return esc.Encode()
-       }
-
-       if fn.Func.Pragma&UintptrEscapes != 0 {
-               if f.Type.IsUintptr() {
-                       if Debug.m != 0 {
-                               Warnl(f.Pos, "marking %v as escaping uintptr", name())
-                       }
-                       return uintptrEscapesTag
-               }
-               if f.IsDDD() && f.Type.Elem().IsUintptr() {
-                       // final argument is ...uintptr.
-                       if Debug.m != 0 {
-                               Warnl(f.Pos, "marking %v as escaping ...uintptr", name())
-                       }
-                       return uintptrEscapesTag
-               }
-       }
-
-       if !f.Type.HasPointers() { // don't bother tagging for scalars
-               return ""
-       }
-
-       // Unnamed parameters are unused and therefore do not escape.
-       if f.Sym == nil || f.Sym.IsBlank() {
-               var esc EscLeaks
-               return esc.Encode()
-       }
-
-       n := asNode(f.Nname)
-       loc := e.oldLoc(n)
-       esc := loc.paramEsc
-       esc.Optimize()
-
-       if Debug.m != 0 && !loc.escapes {
-               if esc.Empty() {
-                       Warnl(f.Pos, "%v does not escape", name())
-               }
-               if x := esc.Heap(); x >= 0 {
-                       if x == 0 {
-                               Warnl(f.Pos, "leaking param: %v", name())
-                       } else {
-                               // TODO(mdempsky): Mention level=x like below?
-                               Warnl(f.Pos, "leaking param content: %v", name())
-                       }
-               }
-               for i := 0; i < numEscResults; i++ {
-                       if x := esc.Result(i); x >= 0 {
-                               res := fn.Type.Results().Field(i).Sym
-                               Warnl(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
-                       }
-               }
-       }
-
-       return esc.Encode()
-}

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
deleted file mode 100644 (file)
index 618bdf7..0000000
--- a/src/cmd/compile/internal/gc/escape.go
+++ /dev/null
@@ -1,1538 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/logopt"
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "fmt"
-       "math"
-       "strings"
-)
-
-// Escape analysis.
-//
-// Here we analyze functions to determine which Go variables
-// (including implicit allocations such as calls to "new" or "make",
-// composite literals, etc.) can be allocated on the stack. The two
-// key invariants we have to ensure are: (1) pointers to stack objects
-// cannot be stored in the heap, and (2) pointers to a stack object
-// cannot outlive that object (e.g., because the declaring function
-// returned and destroyed the object's stack frame, or its space is
-// reused across loop iterations for logically distinct variables).
-//
-// We implement this with a static data-flow analysis of the AST.
-// First, we construct a directed weighted graph where vertices
-// (termed "locations") represent variables allocated by statements
-// and expressions, and edges represent assignments between variables
-// (with weights representing addressing/dereference counts).
-//
-// Next we walk the graph looking for assignment paths that might
-// violate the invariants stated above. If a variable v's address is
-// stored in the heap or elsewhere that may outlive it, then v is
-// marked as requiring heap allocation.
-//
-// To support interprocedural analysis, we also record data-flow from
-// each function's parameters to the heap and to its result
-// parameters. This information is summarized as "parameter tags",
-// which are used at static call sites to improve escape analysis of
-// function arguments.
-
-// Constructing the location graph.
-//
-// Every allocating statement (e.g., variable declaration) or
-// expression (e.g., "new" or "make") is first mapped to a unique
-// "location."
-//
-// We also model every Go assignment as a directed edges between
-// locations. The number of dereference operations minus the number of
-// addressing operations is recorded as the edge's weight (termed
-// "derefs"). For example:
-//
-//     p = &q    // -1
-//     p = q     //  0
-//     p = *q    //  1
-//     p = **q   //  2
-//
-//     p = **&**&q  // 2
-//
-// Note that the & operator can only be applied to addressable
-// expressions, and the expression &x itself is not addressable, so
-// derefs cannot go below -1.
-//
-// Every Go language construct is lowered into this representation,
-// generally without sensitivity to flow, path, or context; and
-// without distinguishing elements within a compound variable. For
-// example:
-//
-//     var x struct { f, g *int }
-//     var u []*int
-//
-//     x.f = u[0]
-//
-// is modeled simply as
-//
-//     x = *u
-//
-// That is, we don't distinguish x.f from x.g, or u[0] from u[1],
-// u[2], etc. However, we do record the implicit dereference involved
-// in indexing a slice.
-
-type Escape struct {
-       allLocs []*EscLocation
-
-       curfn *Node
-
-       // loopDepth counts the current loop nesting depth within
-       // curfn. It increments within each "for" loop and at each
-       // label with a corresponding backwards "goto" (i.e.,
-       // unstructured loop).
-       loopDepth int
-
-       heapLoc  EscLocation
-       blankLoc EscLocation
-}
-
-// An EscLocation represents an abstract location that stores a Go
-// variable.
-type EscLocation struct {
-       n         *Node     // represented variable or expression, if any
-       curfn     *Node     // enclosing function
-       edges     []EscEdge // incoming edges
-       loopDepth int       // loopDepth at declaration
-
-       // derefs and walkgen are used during walkOne to track the
-       // minimal dereferences from the walk root.
-       derefs  int // >= -1
-       walkgen uint32
-
-       // dst and dstEdgeindex track the next immediate assignment
-       // destination location during walkone, along with the index
-       // of the edge pointing back to this location.
-       dst        *EscLocation
-       dstEdgeIdx int
-
-       // queued is used by walkAll to track whether this location is
-       // in the walk queue.
-       queued bool
-
-       // escapes reports whether the represented variable's address
-       // escapes; that is, whether the variable must be heap
-       // allocated.
-       escapes bool
-
-       // transient reports whether the represented expression's
-       // address does not outlive the statement; that is, whether
-       // its storage can be immediately reused.
-       transient bool
-
-       // paramEsc records the represented parameter's leak set.
-       paramEsc EscLeaks
-}
-
-// An EscEdge represents an assignment edge between two Go variables.
-type EscEdge struct {
-       src    *EscLocation
-       derefs int // >= -1
-       notes  *EscNote
-}
-
-// escapeFuncs performs escape analysis on a minimal batch of
-// functions.
-func escapeFuncs(fns []*Node, recursive bool) {
-       for _, fn := range fns {
-               if fn.Op != ODCLFUNC {
-                       Fatalf("unexpected node: %v", fn)
-               }
-       }
-
-       var e Escape
-       e.heapLoc.escapes = true
-
-       // Construct data-flow graph from syntax trees.
-       for _, fn := range fns {
-               e.initFunc(fn)
-       }
-       for _, fn := range fns {
-               e.walkFunc(fn)
-       }
-       e.curfn = nil
-
-       e.walkAll()
-       e.finish(fns)
-}
-
-func (e *Escape) initFunc(fn *Node) {
-       if fn.Op != ODCLFUNC || fn.Esc != EscFuncUnknown {
-               Fatalf("unexpected node: %v", fn)
-       }
-       fn.Esc = EscFuncPlanned
-       if Debug.m > 3 {
-               Dump("escAnalyze", fn)
-       }
-
-       e.curfn = fn
-       e.loopDepth = 1
-
-       // Allocate locations for local variables.
-       for _, dcl := range fn.Func.Dcl {
-               if dcl.Op == ONAME {
-                       e.newLoc(dcl, false)
-               }
-       }
-}
-
-func (e *Escape) walkFunc(fn *Node) {
-       fn.Esc = EscFuncStarted
-
-       // Identify labels that mark the head of an unstructured loop.
-       inspectList(fn.Nbody, func(n *Node) bool {
-               switch n.Op {
-               case OLABEL:
-                       n.Sym.Label = asTypesNode(&nonlooping)
-
-               case OGOTO:
-                       // If we visited the label before the goto,
-                       // then this is a looping label.
-                       if n.Sym.Label == asTypesNode(&nonlooping) {
-                               n.Sym.Label = asTypesNode(&looping)
-                       }
-               }
-
-               return true
-       })
-
-       e.curfn = fn
-       e.loopDepth = 1
-       e.block(fn.Nbody)
-}
-
-// Below we implement the methods for walking the AST and recording
-// data flow edges. Note that because a sub-expression might have
-// side-effects, it's important to always visit the entire AST.
-//
-// For example, write either:
-//
-//     if x {
-//         e.discard(n.Left)
-//     } else {
-//         e.value(k, n.Left)
-//     }
-//
-// or
-//
-//     if x {
-//         k = e.discardHole()
-//     }
-//     e.value(k, n.Left)
-//
-// Do NOT write:
-//
-//    // BAD: possibly loses side-effects within n.Left
-//    if !x {
-//        e.value(k, n.Left)
-//    }
-
-// stmt evaluates a single Go statement.
-func (e *Escape) stmt(n *Node) {
-       if n == nil {
-               return
-       }
-
-       lno := setlineno(n)
-       defer func() {
-               lineno = lno
-       }()
-
-       if Debug.m > 2 {
-               fmt.Printf("%v:[%d] %v stmt: %v\n", linestr(lineno), e.loopDepth, funcSym(e.curfn), n)
-       }
-
-       e.stmts(n.Ninit)
-
-       switch n.Op {
-       default:
-               Fatalf("unexpected stmt: %v", n)
-
-       case ODCLCONST, ODCLTYPE, OEMPTY, OFALL, OINLMARK:
-               // nop
-
-       case OBREAK, OCONTINUE, OGOTO:
-               // TODO(mdempsky): Handle dead code?
-
-       case OBLOCK:
-               e.stmts(n.List)
-
-       case ODCL:
-               // Record loop depth at declaration.
-               if !n.Left.isBlank() {
-                       e.dcl(n.Left)
-               }
-
-       case OLABEL:
-               switch asNode(n.Sym.Label) {
-               case &nonlooping:
-                       if Debug.m > 2 {
-                               fmt.Printf("%v:%v non-looping label\n", linestr(lineno), n)
-                       }
-               case &looping:
-                       if Debug.m > 2 {
-                               fmt.Printf("%v: %v looping label\n", linestr(lineno), n)
-                       }
-                       e.loopDepth++
-               default:
-                       Fatalf("label missing tag")
-               }
-               n.Sym.Label = nil
-
-       case OIF:
-               e.discard(n.Left)
-               e.block(n.Nbody)
-               e.block(n.Rlist)
-
-       case OFOR, OFORUNTIL:
-               e.loopDepth++
-               e.discard(n.Left)
-               e.stmt(n.Right)
-               e.block(n.Nbody)
-               e.loopDepth--
-
-       case ORANGE:
-               // for List = range Right { Nbody }
-               e.loopDepth++
-               ks := e.addrs(n.List)
-               e.block(n.Nbody)
-               e.loopDepth--
-
-               // Right is evaluated outside the loop.
-               k := e.discardHole()
-               if len(ks) >= 2 {
-                       if n.Right.Type.IsArray() {
-                               k = ks[1].note(n, "range")
-                       } else {
-                               k = ks[1].deref(n, "range-deref")
-                       }
-               }
-               e.expr(e.later(k), n.Right)
-
-       case OSWITCH:
-               typesw := n.Left != nil && n.Left.Op == OTYPESW
-
-               var ks []EscHole
-               for _, cas := range n.List.Slice() { // cases
-                       if typesw && n.Left.Left != nil {
-                               cv := cas.Rlist.First()
-                               k := e.dcl(cv) // type switch variables have no ODCL.
-                               if cv.Type.HasPointers() {
-                                       ks = append(ks, k.dotType(cv.Type, cas, "switch case"))
-                               }
-                       }
-
-                       e.discards(cas.List)
-                       e.block(cas.Nbody)
-               }
-
-               if typesw {
-                       e.expr(e.teeHole(ks...), n.Left.Right)
-               } else {
-                       e.discard(n.Left)
-               }
-
-       case OSELECT:
-               for _, cas := range n.List.Slice() {
-                       e.stmt(cas.Left)
-                       e.block(cas.Nbody)
-               }
-       case OSELRECV:
-               e.assign(n.Left, n.Right, "selrecv", n)
-       case OSELRECV2:
-               e.assign(n.Left, n.Right, "selrecv", n)
-               e.assign(n.List.First(), nil, "selrecv", n)
-       case ORECV:
-               // TODO(mdempsky): Consider e.discard(n.Left).
-               e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
-       case OSEND:
-               e.discard(n.Left)
-               e.assignHeap(n.Right, "send", n)
-
-       case OAS, OASOP:
-               e.assign(n.Left, n.Right, "assign", n)
-
-       case OAS2:
-               for i, nl := range n.List.Slice() {
-                       e.assign(nl, n.Rlist.Index(i), "assign-pair", n)
-               }
-
-       case OAS2DOTTYPE: // v, ok = x.(type)
-               e.assign(n.List.First(), n.Right, "assign-pair-dot-type", n)
-               e.assign(n.List.Second(), nil, "assign-pair-dot-type", n)
-       case OAS2MAPR: // v, ok = m[k]
-               e.assign(n.List.First(), n.Right, "assign-pair-mapr", n)
-               e.assign(n.List.Second(), nil, "assign-pair-mapr", n)
-       case OAS2RECV: // v, ok = <-ch
-               e.assign(n.List.First(), n.Right, "assign-pair-receive", n)
-               e.assign(n.List.Second(), nil, "assign-pair-receive", n)
-
-       case OAS2FUNC:
-               e.stmts(n.Right.Ninit)
-               e.call(e.addrs(n.List), n.Right, nil)
-       case ORETURN:
-               results := e.curfn.Type.Results().FieldSlice()
-               for i, v := range n.List.Slice() {
-                       e.assign(asNode(results[i].Nname), v, "return", n)
-               }
-       case OCALLFUNC, OCALLMETH, OCALLINTER, OCLOSE, OCOPY, ODELETE, OPANIC, OPRINT, OPRINTN, ORECOVER:
-               e.call(nil, n, nil)
-       case OGO, ODEFER:
-               e.stmts(n.Left.Ninit)
-               e.call(nil, n.Left, n)
-
-       case ORETJMP:
-               // TODO(mdempsky): What do? esc.go just ignores it.
-       }
-}
-
-func (e *Escape) stmts(l Nodes) {
-       for _, n := range l.Slice() {
-               e.stmt(n)
-       }
-}
-
-// block is like stmts, but preserves loopDepth.
-func (e *Escape) block(l Nodes) {
-       old := e.loopDepth
-       e.stmts(l)
-       e.loopDepth = old
-}
-
-// expr models evaluating an expression n and flowing the result into
-// hole k.
-func (e *Escape) expr(k EscHole, n *Node) {
-       if n == nil {
-               return
-       }
-       e.stmts(n.Ninit)
-       e.exprSkipInit(k, n)
-}
-
-func (e *Escape) exprSkipInit(k EscHole, n *Node) {
-       if n == nil {
-               return
-       }
-
-       lno := setlineno(n)
-       defer func() {
-               lineno = lno
-       }()
-
-       uintptrEscapesHack := k.uintptrEscapesHack
-       k.uintptrEscapesHack = false
-
-       if uintptrEscapesHack && n.Op == OCONVNOP && n.Left.Type.IsUnsafePtr() {
-               // nop
-       } else if k.derefs >= 0 && !n.Type.HasPointers() {
-               k = e.discardHole()
-       }
-
-       switch n.Op {
-       default:
-               Fatalf("unexpected expr: %v", n)
-
-       case OLITERAL, OGETG, OCLOSUREVAR, OTYPE:
-               // nop
-
-       case ONAME:
-               if n.Class() == PFUNC || n.Class() == PEXTERN {
-                       return
-               }
-               e.flow(k, e.oldLoc(n))
-
-       case OPLUS, ONEG, OBITNOT, ONOT:
-               e.discard(n.Left)
-       case OADD, OSUB, OOR, OXOR, OMUL, ODIV, OMOD, OLSH, ORSH, OAND, OANDNOT, OEQ, ONE, OLT, OLE, OGT, OGE, OANDAND, OOROR:
-               e.discard(n.Left)
-               e.discard(n.Right)
-
-       case OADDR:
-               e.expr(k.addr(n, "address-of"), n.Left) // "address-of"
-       case ODEREF:
-               e.expr(k.deref(n, "indirection"), n.Left) // "indirection"
-       case ODOT, ODOTMETH, ODOTINTER:
-               e.expr(k.note(n, "dot"), n.Left)
-       case ODOTPTR:
-               e.expr(k.deref(n, "dot of pointer"), n.Left) // "dot of pointer"
-       case ODOTTYPE, ODOTTYPE2:
-               e.expr(k.dotType(n.Type, n, "dot"), n.Left)
-       case OINDEX:
-               if n.Left.Type.IsArray() {
-                       e.expr(k.note(n, "fixed-array-index-of"), n.Left)
-               } else {
-                       // TODO(mdempsky): Fix why reason text.
-                       e.expr(k.deref(n, "dot of pointer"), n.Left)
-               }
-               e.discard(n.Right)
-       case OINDEXMAP:
-               e.discard(n.Left)
-               e.discard(n.Right)
-       case OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
-               e.expr(k.note(n, "slice"), n.Left)
-               low, high, max := n.SliceBounds()
-               e.discard(low)
-               e.discard(high)
-               e.discard(max)
-
-       case OCONV, OCONVNOP:
-               if checkPtr(e.curfn, 2) && n.Type.IsUnsafePtr() && n.Left.Type.IsPtr() {
-                       // When -d=checkptr=2 is enabled, treat
-                       // conversions to unsafe.Pointer as an
-                       // escaping operation. This allows better
-                       // runtime instrumentation, since we can more
-                       // easily detect object boundaries on the heap
-                       // than the stack.
-                       e.assignHeap(n.Left, "conversion to unsafe.Pointer", n)
-               } else if n.Type.IsUnsafePtr() && n.Left.Type.IsUintptr() {
-                       e.unsafeValue(k, n.Left)
-               } else {
-                       e.expr(k, n.Left)
-               }
-       case OCONVIFACE:
-               if !n.Left.Type.IsInterface() && !isdirectiface(n.Left.Type) {
-                       k = e.spill(k, n)
-               }
-               e.expr(k.note(n, "interface-converted"), n.Left)
-
-       case ORECV:
-               e.discard(n.Left)
-
-       case OCALLMETH, OCALLFUNC, OCALLINTER, OLEN, OCAP, OCOMPLEX, OREAL, OIMAG, OAPPEND, OCOPY:
-               e.call([]EscHole{k}, n, nil)
-
-       case ONEW:
-               e.spill(k, n)
-
-       case OMAKESLICE:
-               e.spill(k, n)
-               e.discard(n.Left)
-               e.discard(n.Right)
-       case OMAKECHAN:
-               e.discard(n.Left)
-       case OMAKEMAP:
-               e.spill(k, n)
-               e.discard(n.Left)
-
-       case ORECOVER:
-               // nop
-
-       case OCALLPART:
-               // Flow the receiver argument to both the closure and
-               // to the receiver parameter.
-
-               closureK := e.spill(k, n)
-
-               m := callpartMethod(n)
-
-               // We don't know how the method value will be called
-               // later, so conservatively assume the result
-               // parameters all flow to the heap.
-               //
-               // TODO(mdempsky): Change ks into a callback, so that
-               // we don't have to create this dummy slice?
-               var ks []EscHole
-               for i := m.Type.NumResults(); i > 0; i-- {
-                       ks = append(ks, e.heapHole())
-               }
-               paramK := e.tagHole(ks, asNode(m.Type.Nname()), m.Type.Recv())
-
-               e.expr(e.teeHole(paramK, closureK), n.Left)
-
-       case OPTRLIT:
-               e.expr(e.spill(k, n), n.Left)
-
-       case OARRAYLIT:
-               for _, elt := range n.List.Slice() {
-                       if elt.Op == OKEY {
-                               elt = elt.Right
-                       }
-                       e.expr(k.note(n, "array literal element"), elt)
-               }
-
-       case OSLICELIT:
-               k = e.spill(k, n)
-               k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
-
-               for _, elt := range n.List.Slice() {
-                       if elt.Op == OKEY {
-                               elt = elt.Right
-                       }
-                       e.expr(k.note(n, "slice-literal-element"), elt)
-               }
-
-       case OSTRUCTLIT:
-               for _, elt := range n.List.Slice() {
-                       e.expr(k.note(n, "struct literal element"), elt.Left)
-               }
-
-       case OMAPLIT:
-               e.spill(k, n)
-
-               // Map keys and values are always stored in the heap.
-               for _, elt := range n.List.Slice() {
-                       e.assignHeap(elt.Left, "map literal key", n)
-                       e.assignHeap(elt.Right, "map literal value", n)
-               }
-
-       case OCLOSURE:
-               k = e.spill(k, n)
-
-               // Link addresses of captured variables to closure.
-               for _, v := range n.Func.Closure.Func.Cvars.Slice() {
-                       if v.Op == OXXX { // unnamed out argument; see dcl.go:/^funcargs
-                               continue
-                       }
-
-                       k := k
-                       if !v.Name.Byval() {
-                               k = k.addr(v, "reference")
-                       }
-
-                       e.expr(k.note(n, "captured by a closure"), v.Name.Defn)
-               }
-
-       case ORUNES2STR, OBYTES2STR, OSTR2RUNES, OSTR2BYTES, ORUNESTR:
-               e.spill(k, n)
-               e.discard(n.Left)
-
-       case OADDSTR:
-               e.spill(k, n)
-
-               // Arguments of OADDSTR never escape;
-               // runtime.concatstrings makes sure of that.
-               e.discards(n.List)
-       }
-}
-
-// unsafeValue evaluates a uintptr-typed arithmetic expression looking
-// for conversions from an unsafe.Pointer.
-func (e *Escape) unsafeValue(k EscHole, n *Node) {
-       if n.Type.Etype != TUINTPTR {
-               Fatalf("unexpected type %v for %v", n.Type, n)
-       }
-
-       e.stmts(n.Ninit)
-
-       switch n.Op {
-       case OCONV, OCONVNOP:
-               if n.Left.Type.IsUnsafePtr() {
-                       e.expr(k, n.Left)
-               } else {
-                       e.discard(n.Left)
-               }
-       case ODOTPTR:
-               if isReflectHeaderDataField(n) {
-                       e.expr(k.deref(n, "reflect.Header.Data"), n.Left)
-               } else {
-                       e.discard(n.Left)
-               }
-       case OPLUS, ONEG, OBITNOT:
-               e.unsafeValue(k, n.Left)
-       case OADD, OSUB, OOR, OXOR, OMUL, ODIV, OMOD, OAND, OANDNOT:
-               e.unsafeValue(k, n.Left)
-               e.unsafeValue(k, n.Right)
-       case OLSH, ORSH:
-               e.unsafeValue(k, n.Left)
-               // RHS need not be uintptr-typed (#32959) and can't meaningfully
-               // flow pointers anyway.
-               e.discard(n.Right)
-       default:
-               e.exprSkipInit(e.discardHole(), n)
-       }
-}
-
-// discard evaluates an expression n for side-effects, but discards
-// its value.
-func (e *Escape) discard(n *Node) {
-       e.expr(e.discardHole(), n)
-}
-
-func (e *Escape) discards(l Nodes) {
-       for _, n := range l.Slice() {
-               e.discard(n)
-       }
-}
-
-// addr evaluates an addressable expression n and returns an EscHole
-// that represents storing into the represented location.
-func (e *Escape) addr(n *Node) EscHole {
-       if n == nil || n.isBlank() {
-               // Can happen at least in OSELRECV.
-               // TODO(mdempsky): Anywhere else?
-               return e.discardHole()
-       }
-
-       k := e.heapHole()
-
-       switch n.Op {
-       default:
-               Fatalf("unexpected addr: %v", n)
-       case ONAME:
-               if n.Class() == PEXTERN {
-                       break
-               }
-               k = e.oldLoc(n).asHole()
-       case ODOT:
-               k = e.addr(n.Left)
-       case OINDEX:
-               e.discard(n.Right)
-               if n.Left.Type.IsArray() {
-                       k = e.addr(n.Left)
-               } else {
-                       e.discard(n.Left)
-               }
-       case ODEREF, ODOTPTR:
-               e.discard(n)
-       case OINDEXMAP:
-               e.discard(n.Left)
-               e.assignHeap(n.Right, "key of map put", n)
-       }
-
-       if !n.Type.HasPointers() {
-               k = e.discardHole()
-       }
-
-       return k
-}
-
-func (e *Escape) addrs(l Nodes) []EscHole {
-       var ks []EscHole
-       for _, n := range l.Slice() {
-               ks = append(ks, e.addr(n))
-       }
-       return ks
-}
-
-// assign evaluates the assignment dst = src.
-func (e *Escape) assign(dst, src *Node, why string, where *Node) {
-       // Filter out some no-op assignments for escape analysis.
-       ignore := dst != nil && src != nil && isSelfAssign(dst, src)
-       if ignore && Debug.m != 0 {
-               Warnl(where.Pos, "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
-       }
-
-       k := e.addr(dst)
-       if dst != nil && dst.Op == ODOTPTR && isReflectHeaderDataField(dst) {
-               e.unsafeValue(e.heapHole().note(where, why), src)
-       } else {
-               if ignore {
-                       k = e.discardHole()
-               }
-               e.expr(k.note(where, why), src)
-       }
-}
-
-func (e *Escape) assignHeap(src *Node, why string, where *Node) {
-       e.expr(e.heapHole().note(where, why), src)
-}
-
-// call evaluates a call expressions, including builtin calls. ks
-// should contain the holes representing where the function callee's
-// results flows; where is the OGO/ODEFER context of the call, if any.
-func (e *Escape) call(ks []EscHole, call, where *Node) {
-       topLevelDefer := where != nil && where.Op == ODEFER && e.loopDepth == 1
-       if topLevelDefer {
-               // force stack allocation of defer record, unless
-               // open-coded defers are used (see ssa.go)
-               where.Esc = EscNever
-       }
-
-       argument := func(k EscHole, arg *Node) {
-               if topLevelDefer {
-                       // Top level defers arguments don't escape to
-                       // heap, but they do need to last until end of
-                       // function.
-                       k = e.later(k)
-               } else if where != nil {
-                       k = e.heapHole()
-               }
-
-               e.expr(k.note(call, "call parameter"), arg)
-       }
-
-       switch call.Op {
-       default:
-               Fatalf("unexpected call op: %v", call.Op)
-
-       case OCALLFUNC, OCALLMETH, OCALLINTER:
-               fixVariadicCall(call)
-
-               // Pick out the function callee, if statically known.
-               var fn *Node
-               switch call.Op {
-               case OCALLFUNC:
-                       switch v := staticValue(call.Left); {
-                       case v.Op == ONAME && v.Class() == PFUNC:
-                               fn = v
-                       case v.Op == OCLOSURE:
-                               fn = v.Func.Closure.Func.Nname
-                       }
-               case OCALLMETH:
-                       fn = asNode(call.Left.Type.FuncType().Nname)
-               }
-
-               fntype := call.Left.Type
-               if fn != nil {
-                       fntype = fn.Type
-               }
-
-               if ks != nil && fn != nil && e.inMutualBatch(fn) {
-                       for i, result := range fn.Type.Results().FieldSlice() {
-                               e.expr(ks[i], asNode(result.Nname))
-                       }
-               }
-
-               if r := fntype.Recv(); r != nil {
-                       argument(e.tagHole(ks, fn, r), call.Left.Left)
-               } else {
-                       // Evaluate callee function expression.
-                       argument(e.discardHole(), call.Left)
-               }
-
-               args := call.List.Slice()
-               for i, param := range fntype.Params().FieldSlice() {
-                       argument(e.tagHole(ks, fn, param), args[i])
-               }
-
-       case OAPPEND:
-               args := call.List.Slice()
-
-               // Appendee slice may flow directly to the result, if
-               // it has enough capacity. Alternatively, a new heap
-               // slice might be allocated, and all slice elements
-               // might flow to heap.
-               appendeeK := ks[0]
-               if args[0].Type.Elem().HasPointers() {
-                       appendeeK = e.teeHole(appendeeK, e.heapHole().deref(call, "appendee slice"))
-               }
-               argument(appendeeK, args[0])
-
-               if call.IsDDD() {
-                       appendedK := e.discardHole()
-                       if args[1].Type.IsSlice() && args[1].Type.Elem().HasPointers() {
-                               appendedK = e.heapHole().deref(call, "appended slice...")
-                       }
-                       argument(appendedK, args[1])
-               } else {
-                       for _, arg := range args[1:] {
-                               argument(e.heapHole(), arg)
-                       }
-               }
-
-       case OCOPY:
-               argument(e.discardHole(), call.Left)
-
-               copiedK := e.discardHole()
-               if call.Right.Type.IsSlice() && call.Right.Type.Elem().HasPointers() {
-                       copiedK = e.heapHole().deref(call, "copied slice")
-               }
-               argument(copiedK, call.Right)
-
-       case OPANIC:
-               argument(e.heapHole(), call.Left)
-
-       case OCOMPLEX:
-               argument(e.discardHole(), call.Left)
-               argument(e.discardHole(), call.Right)
-       case ODELETE, OPRINT, OPRINTN, ORECOVER:
-               for _, arg := range call.List.Slice() {
-                       argument(e.discardHole(), arg)
-               }
-       case OLEN, OCAP, OREAL, OIMAG, OCLOSE:
-               argument(e.discardHole(), call.Left)
-       }
-}
-
-// tagHole returns a hole for evaluating an argument passed to param.
-// ks should contain the holes representing where the function
-// callee's results flows. fn is the statically-known callee function,
-// if any.
-func (e *Escape) tagHole(ks []EscHole, fn *Node, param *types.Field) EscHole {
-       // If this is a dynamic call, we can't rely on param.Note.
-       if fn == nil {
-               return e.heapHole()
-       }
-
-       if e.inMutualBatch(fn) {
-               return e.addr(asNode(param.Nname))
-       }
-
-       // Call to previously tagged function.
-
-       if param.Note == uintptrEscapesTag {
-               k := e.heapHole()
-               k.uintptrEscapesHack = true
-               return k
-       }
-
-       var tagKs []EscHole
-
-       esc := ParseLeaks(param.Note)
-       if x := esc.Heap(); x >= 0 {
-               tagKs = append(tagKs, e.heapHole().shift(x))
-       }
-
-       if ks != nil {
-               for i := 0; i < numEscResults; i++ {
-                       if x := esc.Result(i); x >= 0 {
-                               tagKs = append(tagKs, ks[i].shift(x))
-                       }
-               }
-       }
-
-       return e.teeHole(tagKs...)
-}
-
-// inMutualBatch reports whether function fn is in the batch of
-// mutually recursive functions being analyzed. When this is true,
-// fn has not yet been analyzed, so its parameters and results
-// should be incorporated directly into the flow graph instead of
-// relying on its escape analysis tagging.
-func (e *Escape) inMutualBatch(fn *Node) bool {
-       if fn.Name.Defn != nil && fn.Name.Defn.Esc < EscFuncTagged {
-               if fn.Name.Defn.Esc == EscFuncUnknown {
-                       Fatalf("graph inconsistency")
-               }
-               return true
-       }
-       return false
-}
-
-// An EscHole represents a context for evaluation a Go
-// expression. E.g., when evaluating p in "x = **p", we'd have a hole
-// with dst==x and derefs==2.
-type EscHole struct {
-       dst    *EscLocation
-       derefs int // >= -1
-       notes  *EscNote
-
-       // uintptrEscapesHack indicates this context is evaluating an
-       // argument for a //go:uintptrescapes function.
-       uintptrEscapesHack bool
-}
-
-type EscNote struct {
-       next  *EscNote
-       where *Node
-       why   string
-}
-
-func (k EscHole) note(where *Node, why string) EscHole {
-       if where == nil || why == "" {
-               Fatalf("note: missing where/why")
-       }
-       if Debug.m >= 2 || logopt.Enabled() {
-               k.notes = &EscNote{
-                       next:  k.notes,
-                       where: where,
-                       why:   why,
-               }
-       }
-       return k
-}
-
-func (k EscHole) shift(delta int) EscHole {
-       k.derefs += delta
-       if k.derefs < -1 {
-               Fatalf("derefs underflow: %v", k.derefs)
-       }
-       return k
-}
-
-func (k EscHole) deref(where *Node, why string) EscHole { return k.shift(1).note(where, why) }
-func (k EscHole) addr(where *Node, why string) EscHole  { return k.shift(-1).note(where, why) }
-
-func (k EscHole) dotType(t *types.Type, where *Node, why string) EscHole {
-       if !t.IsInterface() && !isdirectiface(t) {
-               k = k.shift(1)
-       }
-       return k.note(where, why)
-}
-
-// teeHole returns a new hole that flows into each hole of ks,
-// similar to the Unix tee(1) command.
-func (e *Escape) teeHole(ks ...EscHole) EscHole {
-       if len(ks) == 0 {
-               return e.discardHole()
-       }
-       if len(ks) == 1 {
-               return ks[0]
-       }
-       // TODO(mdempsky): Optimize if there's only one non-discard hole?
-
-       // Given holes "l1 = _", "l2 = **_", "l3 = *_", ..., create a
-       // new temporary location ltmp, wire it into place, and return
-       // a hole for "ltmp = _".
-       loc := e.newLoc(nil, true)
-       for _, k := range ks {
-               // N.B., "p = &q" and "p = &tmp; tmp = q" are not
-               // semantically equivalent. To combine holes like "l1
-               // = _" and "l2 = &_", we'd need to wire them as "l1 =
-               // *ltmp" and "l2 = ltmp" and return "ltmp = &_"
-               // instead.
-               if k.derefs < 0 {
-                       Fatalf("teeHole: negative derefs")
-               }
-
-               e.flow(k, loc)
-       }
-       return loc.asHole()
-}
-
-func (e *Escape) dcl(n *Node) EscHole {
-       loc := e.oldLoc(n)
-       loc.loopDepth = e.loopDepth
-       return loc.asHole()
-}
-
-// spill allocates a new location associated with expression n, flows
-// its address to k, and returns a hole that flows values to it. It's
-// intended for use with most expressions that allocate storage.
-func (e *Escape) spill(k EscHole, n *Node) EscHole {
-       loc := e.newLoc(n, true)
-       e.flow(k.addr(n, "spill"), loc)
-       return loc.asHole()
-}
-
-// later returns a new hole that flows into k, but some time later.
-// Its main effect is to prevent immediate reuse of temporary
-// variables introduced during Order.
-func (e *Escape) later(k EscHole) EscHole {
-       loc := e.newLoc(nil, false)
-       e.flow(k, loc)
-       return loc.asHole()
-}
-
-// canonicalNode returns the canonical *Node that n logically
-// represents.
-func canonicalNode(n *Node) *Node {
-       if n != nil && n.Op == ONAME && n.Name.IsClosureVar() {
-               n = n.Name.Defn
-               if n.Name.IsClosureVar() {
-                       Fatalf("still closure var")
-               }
-       }
-
-       return n
-}
-
-func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
-       if e.curfn == nil {
-               Fatalf("e.curfn isn't set")
-       }
-       if n != nil && n.Type != nil && n.Type.NotInHeap() {
-               yyerrorl(n.Pos, "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type)
-       }
-
-       n = canonicalNode(n)
-       loc := &EscLocation{
-               n:         n,
-               curfn:     e.curfn,
-               loopDepth: e.loopDepth,
-               transient: transient,
-       }
-       e.allLocs = append(e.allLocs, loc)
-       if n != nil {
-               if n.Op == ONAME && n.Name.Curfn != e.curfn {
-                       Fatalf("curfn mismatch: %v != %v", n.Name.Curfn, e.curfn)
-               }
-
-               if n.HasOpt() {
-                       Fatalf("%v already has a location", n)
-               }
-               n.SetOpt(loc)
-
-               if why := heapAllocReason(n); why != "" {
-                       e.flow(e.heapHole().addr(n, why), loc)
-               }
-       }
-       return loc
-}
-
-func (e *Escape) oldLoc(n *Node) *EscLocation {
-       n = canonicalNode(n)
-       return n.Opt().(*EscLocation)
-}
-
-func (l *EscLocation) asHole() EscHole {
-       return EscHole{dst: l}
-}
-
-func (e *Escape) flow(k EscHole, src *EscLocation) {
-       dst := k.dst
-       if dst == &e.blankLoc {
-               return
-       }
-       if dst == src && k.derefs >= 0 { // dst = dst, dst = *dst, ...
-               return
-       }
-       if dst.escapes && k.derefs < 0 { // dst = &src
-               if Debug.m >= 2 || logopt.Enabled() {
-                       pos := linestr(src.n.Pos)
-                       if Debug.m >= 2 {
-                               fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
-                       }
-                       explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
-                       if logopt.Enabled() {
-                               logopt.LogOpt(src.n.Pos, "escapes", "escape", e.curfn.funcname(), fmt.Sprintf("%v escapes to heap", src.n), explanation)
-                       }
-
-               }
-               src.escapes = true
-               return
-       }
-
-       // TODO(mdempsky): Deduplicate edges?
-       dst.edges = append(dst.edges, EscEdge{src: src, derefs: k.derefs, notes: k.notes})
-}
-
-func (e *Escape) heapHole() EscHole    { return e.heapLoc.asHole() }
-func (e *Escape) discardHole() EscHole { return e.blankLoc.asHole() }
-
-// walkAll computes the minimal dereferences between all pairs of
-// locations.
-func (e *Escape) walkAll() {
-       // We use a work queue to keep track of locations that we need
-       // to visit, and repeatedly walk until we reach a fixed point.
-       //
-       // We walk once from each location (including the heap), and
-       // then re-enqueue each location on its transition from
-       // transient->!transient and !escapes->escapes, which can each
-       // happen at most once. So we take Θ(len(e.allLocs)) walks.
-
-       // LIFO queue, has enough room for e.allLocs and e.heapLoc.
-       todo := make([]*EscLocation, 0, len(e.allLocs)+1)
-       enqueue := func(loc *EscLocation) {
-               if !loc.queued {
-                       todo = append(todo, loc)
-                       loc.queued = true
-               }
-       }
-
-       for _, loc := range e.allLocs {
-               enqueue(loc)
-       }
-       enqueue(&e.heapLoc)
-
-       var walkgen uint32
-       for len(todo) > 0 {
-               root := todo[len(todo)-1]
-               todo = todo[:len(todo)-1]
-               root.queued = false
-
-               walkgen++
-               e.walkOne(root, walkgen, enqueue)
-       }
-}
-
-// walkOne computes the minimal number of dereferences from root to
-// all other locations.
-func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLocation)) {
-       // The data flow graph has negative edges (from addressing
-       // operations), so we use the Bellman-Ford algorithm. However,
-       // we don't have to worry about infinite negative cycles since
-       // we bound intermediate dereference counts to 0.
-
-       root.walkgen = walkgen
-       root.derefs = 0
-       root.dst = nil
-
-       todo := []*EscLocation{root} // LIFO queue
-       for len(todo) > 0 {
-               l := todo[len(todo)-1]
-               todo = todo[:len(todo)-1]
-
-               base := l.derefs
-
-               // If l.derefs < 0, then l's address flows to root.
-               addressOf := base < 0
-               if addressOf {
-                       // For a flow path like "root = &l; l = x",
-                       // l's address flows to root, but x's does
-                       // not. We recognize this by lower bounding
-                       // base at 0.
-                       base = 0
-
-                       // If l's address flows to a non-transient
-                       // location, then l can't be transiently
-                       // allocated.
-                       if !root.transient && l.transient {
-                               l.transient = false
-                               enqueue(l)
-                       }
-               }
-
-               if e.outlives(root, l) {
-                       // l's value flows to root. If l is a function
-                       // parameter and root is the heap or a
-                       // corresponding result parameter, then record
-                       // that value flow for tagging the function
-                       // later.
-                       if l.isName(PPARAM) {
-                               if (logopt.Enabled() || Debug.m >= 2) && !l.escapes {
-                                       if Debug.m >= 2 {
-                                               fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", linestr(l.n.Pos), l.n, e.explainLoc(root), base)
-                                       }
-                                       explanation := e.explainPath(root, l)
-                                       if logopt.Enabled() {
-                                               logopt.LogOpt(l.n.Pos, "leak", "escape", e.curfn.funcname(),
-                                                       fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), base), explanation)
-                                       }
-                               }
-                               l.leakTo(root, base)
-                       }
-
-                       // If l's address flows somewhere that
-                       // outlives it, then l needs to be heap
-                       // allocated.
-                       if addressOf && !l.escapes {
-                               if logopt.Enabled() || Debug.m >= 2 {
-                                       if Debug.m >= 2 {
-                                               fmt.Printf("%s: %v escapes to heap:\n", linestr(l.n.Pos), l.n)
-                                       }
-                                       explanation := e.explainPath(root, l)
-                                       if logopt.Enabled() {
-                                               logopt.LogOpt(l.n.Pos, "escape", "escape", e.curfn.funcname(), fmt.Sprintf("%v escapes to heap", l.n), explanation)
-                                       }
-                               }
-                               l.escapes = true
-                               enqueue(l)
-                               continue
-                       }
-               }
-
-               for i, edge := range l.edges {
-                       if edge.src.escapes {
-                               continue
-                       }
-                       derefs := base + edge.derefs
-                       if edge.src.walkgen != walkgen || edge.src.derefs > derefs {
-                               edge.src.walkgen = walkgen
-                               edge.src.derefs = derefs
-                               edge.src.dst = l
-                               edge.src.dstEdgeIdx = i
-                               todo = append(todo, edge.src)
-                       }
-               }
-       }
-}
-
-// explainPath prints an explanation of how src flows to the walk root.
-func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
-       visited := make(map[*EscLocation]bool)
-       pos := linestr(src.n.Pos)
-       var explanation []*logopt.LoggedOpt
-       for {
-               // Prevent infinite loop.
-               if visited[src] {
-                       if Debug.m >= 2 {
-                               fmt.Printf("%s:   warning: truncated explanation due to assignment cycle; see golang.org/issue/35518\n", pos)
-                       }
-                       break
-               }
-               visited[src] = true
-               dst := src.dst
-               edge := &dst.edges[src.dstEdgeIdx]
-               if edge.src != src {
-                       Fatalf("path inconsistency: %v != %v", edge.src, src)
-               }
-
-               explanation = e.explainFlow(pos, dst, src, edge.derefs, edge.notes, explanation)
-
-               if dst == root {
-                       break
-               }
-               src = dst
-       }
-
-       return explanation
-}
-
-func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, notes *EscNote, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
-       ops := "&"
-       if derefs >= 0 {
-               ops = strings.Repeat("*", derefs)
-       }
-       print := Debug.m >= 2
-
-       flow := fmt.Sprintf("   flow: %s = %s%v:", e.explainLoc(dst), ops, e.explainLoc(srcloc))
-       if print {
-               fmt.Printf("%s:%s\n", pos, flow)
-       }
-       if logopt.Enabled() {
-               var epos src.XPos
-               if notes != nil {
-                       epos = notes.where.Pos
-               } else if srcloc != nil && srcloc.n != nil {
-                       epos = srcloc.n.Pos
-               }
-               explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", e.curfn.funcname(), flow))
-       }
-
-       for note := notes; note != nil; note = note.next {
-               if print {
-                       fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, linestr(note.where.Pos))
-               }
-               if logopt.Enabled() {
-                       explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos, "escflow", "escape", e.curfn.funcname(),
-                               fmt.Sprintf("     from %v (%v)", note.where, note.why)))
-               }
-       }
-       return explanation
-}
-
-func (e *Escape) explainLoc(l *EscLocation) string {
-       if l == &e.heapLoc {
-               return "{heap}"
-       }
-       if l.n == nil {
-               // TODO(mdempsky): Omit entirely.
-               return "{temp}"
-       }
-       if l.n.Op == ONAME {
-               return fmt.Sprintf("%v", l.n)
-       }
-       return fmt.Sprintf("{storage for %v}", l.n)
-}
-
-// outlives reports whether values stored in l may survive beyond
-// other's lifetime if stack allocated.
-func (e *Escape) outlives(l, other *EscLocation) bool {
-       // The heap outlives everything.
-       if l.escapes {
-               return true
-       }
-
-       // We don't know what callers do with returned values, so
-       // pessimistically we need to assume they flow to the heap and
-       // outlive everything too.
-       if l.isName(PPARAMOUT) {
-               // Exception: Directly called closures can return
-               // locations allocated outside of them without forcing
-               // them to the heap. For example:
-               //
-               //    var u int  // okay to stack allocate
-               //    *(func() *int { return &u }()) = 42
-               if containsClosure(other.curfn, l.curfn) && l.curfn.Func.Closure.Func.Top&ctxCallee != 0 {
-                       return false
-               }
-
-               return true
-       }
-
-       // If l and other are within the same function, then l
-       // outlives other if it was declared outside other's loop
-       // scope. For example:
-       //
-       //    var l *int
-       //    for {
-       //        l = new(int)
-       //    }
-       if l.curfn == other.curfn && l.loopDepth < other.loopDepth {
-               return true
-       }
-
-       // If other is declared within a child closure of where l is
-       // declared, then l outlives it. For example:
-       //
-       //    var l *int
-       //    func() {
-       //        l = new(int)
-       //    }
-       if containsClosure(l.curfn, other.curfn) {
-               return true
-       }
-
-       return false
-}
-
-// containsClosure reports whether c is a closure contained within f.
-func containsClosure(f, c *Node) bool {
-       if f.Op != ODCLFUNC || c.Op != ODCLFUNC {
-               Fatalf("bad containsClosure: %v, %v", f, c)
-       }
-
-       // Common case.
-       if f == c {
-               return false
-       }
-
-       // Closures within function Foo are named like "Foo.funcN..."
-       // TODO(mdempsky): Better way to recognize this.
-       fn := f.Func.Nname.Sym.Name
-       cn := c.Func.Nname.Sym.Name
-       return len(cn) > len(fn) && cn[:len(fn)] == fn && cn[len(fn)] == '.'
-}
-
-// leak records that parameter l leaks to sink.
-func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
-       // If sink is a result parameter and we can fit return bits
-       // into the escape analysis tag, then record a return leak.
-       if sink.isName(PPARAMOUT) && sink.curfn == l.curfn {
-               // TODO(mdempsky): Eliminate dependency on Vargen here.
-               ri := int(sink.n.Name.Vargen) - 1
-               if ri < numEscResults {
-                       // Leak to result parameter.
-                       l.paramEsc.AddResult(ri, derefs)
-                       return
-               }
-       }
-
-       // Otherwise, record as heap leak.
-       l.paramEsc.AddHeap(derefs)
-}
-
-func (e *Escape) finish(fns []*Node) {
-       // Record parameter tags for package export data.
-       for _, fn := range fns {
-               fn.Esc = EscFuncTagged
-
-               narg := 0
-               for _, fs := range &types.RecvsParams {
-                       for _, f := range fs(fn.Type).Fields().Slice() {
-                               narg++
-                               f.Note = e.paramTag(fn, narg, f)
-                       }
-               }
-       }
-
-       for _, loc := range e.allLocs {
-               n := loc.n
-               if n == nil {
-                       continue
-               }
-               n.SetOpt(nil)
-
-               // Update n.Esc based on escape analysis results.
-
-               if loc.escapes {
-                       if n.Op != ONAME {
-                               if Debug.m != 0 {
-                                       Warnl(n.Pos, "%S escapes to heap", n)
-                               }
-                               if logopt.Enabled() {
-                                       logopt.LogOpt(n.Pos, "escape", "escape", e.curfn.funcname())
-                               }
-                       }
-                       n.Esc = EscHeap
-                       addrescapes(n)
-               } else {
-                       if Debug.m != 0 && n.Op != ONAME {
-                               Warnl(n.Pos, "%S does not escape", n)
-                       }
-                       n.Esc = EscNone
-                       if loc.transient {
-                               n.SetTransient(true)
-                       }
-               }
-       }
-}
-
-func (l *EscLocation) isName(c Class) bool {
-       return l.n != nil && l.n.Op == ONAME && l.n.Class() == c
-}
-
-const numEscResults = 7
-
-// An EscLeaks represents a set of assignment flows from a parameter
-// to the heap or to any of its function's (first numEscResults)
-// result parameters.
-type EscLeaks [1 + numEscResults]uint8
-
-// Empty reports whether l is an empty set (i.e., no assignment flows).
-func (l EscLeaks) Empty() bool { return l == EscLeaks{} }
-
-// Heap returns the minimum deref count of any assignment flow from l
-// to the heap. If no such flows exist, Heap returns -1.
-func (l EscLeaks) Heap() int { return l.get(0) }
-
-// Result returns the minimum deref count of any assignment flow from
-// l to its function's i'th result parameter. If no such flows exist,
-// Result returns -1.
-func (l EscLeaks) Result(i int) int { return l.get(1 + i) }
-
-// AddHeap adds an assignment flow from l to the heap.
-func (l *EscLeaks) AddHeap(derefs int) { l.add(0, derefs) }
-
-// AddResult adds an assignment flow from l to its function's i'th
-// result parameter.
-func (l *EscLeaks) AddResult(i, derefs int) { l.add(1+i, derefs) }
-
-func (l *EscLeaks) setResult(i, derefs int) { l.set(1+i, derefs) }
-
-func (l EscLeaks) get(i int) int { return int(l[i]) - 1 }
-
-func (l *EscLeaks) add(i, derefs int) {
-       if old := l.get(i); old < 0 || derefs < old {
-               l.set(i, derefs)
-       }
-}
-
-func (l *EscLeaks) set(i, derefs int) {
-       v := derefs + 1
-       if v < 0 {
-               Fatalf("invalid derefs count: %v", derefs)
-       }
-       if v > math.MaxUint8 {
-               v = math.MaxUint8
-       }
-
-       l[i] = uint8(v)
-}
-
-// Optimize removes result flow paths that are equal in length or
-// longer than the shortest heap flow path.
-func (l *EscLeaks) Optimize() {
-       // If we have a path to the heap, then there's no use in
-       // keeping equal or longer paths elsewhere.
-       if x := l.Heap(); x >= 0 {
-               for i := 0; i < numEscResults; i++ {
-                       if l.Result(i) >= x {
-                               l.setResult(i, -1)
-                       }
-               }
-       }
-}
-
-var leakTagCache = map[EscLeaks]string{}
-
-// Encode converts l into a binary string for export data.
-func (l EscLeaks) Encode() string {
-       if l.Heap() == 0 {
-               // Space optimization: empty string encodes more
-               // efficiently in export data.
-               return ""
-       }
-       if s, ok := leakTagCache[l]; ok {
-               return s
-       }
-
-       n := len(l)
-       for n > 0 && l[n-1] == 0 {
-               n--
-       }
-       s := "esc:" + string(l[:n])
-       leakTagCache[l] = s
-       return s
-}
-
-// ParseLeaks parses a binary string representing an EscLeaks.
-func ParseLeaks(s string) EscLeaks {
-       var l EscLeaks
-       if !strings.HasPrefix(s, "esc:") {
-               l.AddHeap(0)
-               return l
-       }
-       copy(l[:], s[4:])
-       return l
-}

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index c6917e0f810ddb66ee9e8edef76f8e172b9a8cb4..356fcfa6719e2c57dea7772e8e21dc0d5c7ec986 100644 (file)
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -5,229 +5,152 @@
 package gc
 
 import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/inline"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
        "cmd/compile/internal/types"
        "cmd/internal/bio"
-       "cmd/internal/src"
        "fmt"
-)
-
-var (
-       Debug_export int // if set, print debugging information about export data
+       "go/constant"
 )
 
 func exportf(bout *bio.Writer, format string, args ...interface{}) {
        fmt.Fprintf(bout, format, args...)
-       if Debug_export != 0 {
+       if base.Debug.Export != 0 {
                fmt.Printf(format, args...)
        }
 }
 
-var asmlist []*Node
-
-// exportsym marks n for export (or reexport).
-func exportsym(n *Node) {
-       if n.Sym.OnExportList() {
-               return
-       }
-       n.Sym.SetOnExportList(true)
-
-       if Debug.E != 0 {
-               fmt.Printf("export symbol %v\n", n.Sym)
-       }
-
-       exportlist = append(exportlist, n)
-}
-
-func initname(s string) bool {
-       return s == "init"
-}
-
-func autoexport(n *Node, ctxt Class) {
-       if n.Sym.Pkg != localpkg {
-               return
-       }
-       if (ctxt != PEXTERN && ctxt != PFUNC) || dclcontext != PEXTERN {
-               return
-       }
-       if n.Type != nil && n.Type.IsKind(TFUNC) && n.IsMethod() {
-               return
+func dumpexport(bout *bio.Writer) {
+       p := &exporter{marked: make(map[*types.Type]bool)}
+       for _, n := range typecheck.Target.Exports {
+               p.markObject(n)
        }
 
-       if types.IsExported(n.Sym.Name) || initname(n.Sym.Name) {
-               exportsym(n)
-       }
-       if asmhdr != "" && !n.Sym.Asm() {
-               n.Sym.SetAsm(true)
-               asmlist = append(asmlist, n)
-       }
-}
-
-func dumpexport(bout *bio.Writer) {
        // The linker also looks for the $$ marker - use char after $$ to distinguish format.
        exportf(bout, "\n$$B\n") // indicate binary export format
        off := bout.Offset()
-       iexport(bout.Writer)
+       typecheck.WriteExports(bout.Writer)
        size := bout.Offset() - off
        exportf(bout, "\n$$\n")
 
-       if Debug_export != 0 {
-               fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", myimportpath, size)
-       }
-}
-
-func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
-       n := asNode(s.PkgDef())
-       if n == nil {
-               // iimport should have created a stub ONONAME
-               // declaration for all imported symbols. The exception
-               // is declarations for Runtimepkg, which are populated
-               // by loadsys instead.
-               if s.Pkg != Runtimepkg {
-                       Fatalf("missing ONONAME for %v\n", s)
-               }
-
-               n = dclname(s)
-               s.SetPkgDef(asTypesNode(n))
-               s.Importdef = ipkg
-       }
-       if n.Op != ONONAME && n.Op != op {
-               redeclare(lineno, s, fmt.Sprintf("during import %q", ipkg.Path))
+       if base.Debug.Export != 0 {
+               fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", base.Ctxt.Pkgpath, size)
        }
-       return n
 }
 
-// importtype returns the named type declared by symbol s.
-// If no such type has been declared yet, a forward declaration is returned.
-// ipkg is the package being imported
-func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
-       n := importsym(ipkg, s, OTYPE)
-       if n.Op != OTYPE {
-               t := types.New(TFORW)
-               t.Sym = s
-               t.Nod = asTypesNode(n)
-
-               n.Op = OTYPE
-               n.Pos = pos
-               n.Type = t
-               n.SetClass(PEXTERN)
-       }
-
-       t := n.Type
-       if t == nil {
-               Fatalf("importtype %v", s)
+func dumpasmhdr() {
+       b, err := bio.Create(base.Flag.AsmHdr)
+       if err != nil {
+               base.Fatalf("%v", err)
        }
-       return t
-}
+       fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", types.LocalPkg.Name)
+       for _, n := range typecheck.Target.Asms {
+               if n.Sym().IsBlank() {
+                       continue
+               }
+               switch n.Op() {
+               case ir.OLITERAL:
+                       t := n.Val().Kind()
+                       if t == constant.Float || t == constant.Complex {
+                               break
+                       }
+                       fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym().Name, n.Val())
 
-// importobj declares symbol s as an imported object representable by op.
-// ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t *types.Type) *Node {
-       n := importsym(ipkg, s, op)
-       if n.Op != ONONAME {
-               if n.Op == op && (n.Class() != ctxt || !types.Identical(n.Type, t)) {
-                       redeclare(lineno, s, fmt.Sprintf("during import %q", ipkg.Path))
+               case ir.OTYPE:
+                       t := n.Type()
+                       if !t.IsStruct() || t.StructType().Map != nil || t.IsFuncArgStruct() {
+                               break
+                       }
+                       fmt.Fprintf(b, "#define %s__size %d\n", n.Sym().Name, int(t.Width))
+                       for _, f := range t.Fields().Slice() {
+                               if !f.Sym.IsBlank() {
+                                       fmt.Fprintf(b, "#define %s_%s %d\n", n.Sym().Name, f.Sym.Name, int(f.Offset))
+                               }
+                       }
                }
-               return nil
        }
 
-       n.Op = op
-       n.Pos = pos
-       n.SetClass(ctxt)
-       if ctxt == PFUNC {
-               n.Sym.SetFunc(true)
-       }
-       n.Type = t
-       return n
+       b.Close()
 }
 
-// importconst declares symbol s as an imported constant with type t and value val.
-// ipkg is the package being imported
-func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val Val) {
-       n := importobj(ipkg, pos, s, OLITERAL, PEXTERN, t)
-       if n == nil { // TODO: Check that value matches.
-               return
-       }
-
-       n.SetVal(val)
-
-       if Debug.E != 0 {
-               fmt.Printf("import const %v %L = %v\n", s, t, val)
-       }
+type exporter struct {
+       marked map[*types.Type]bool // types already seen by markType
 }
 
-// importfunc declares symbol s as an imported function with type t.
-// ipkg is the package being imported
-func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-       n := importobj(ipkg, pos, s, ONAME, PFUNC, t)
-       if n == nil {
-               return
+// markObject visits a reachable object.
+func (p *exporter) markObject(n ir.Node) {
+       if n.Op() == ir.ONAME {
+               n := n.(*ir.Name)
+               if n.Class == ir.PFUNC {
+                       inline.Inline_Flood(n, typecheck.Export)
+               }
        }
 
-       n.Func = new(Func)
-       t.SetNname(asTypesNode(n))
-
-       if Debug.E != 0 {
-               fmt.Printf("import func %v%S\n", s, t)
-       }
+       p.markType(n.Type())
 }
 
-// importvar declares symbol s as an imported variable with type t.
-// ipkg is the package being imported
-func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-       n := importobj(ipkg, pos, s, ONAME, PEXTERN, t)
-       if n == nil {
+// markType recursively visits types reachable from t to identify
+// functions whose inline bodies may be needed.
+func (p *exporter) markType(t *types.Type) {
+       if p.marked[t] {
                return
        }
-
-       if Debug.E != 0 {
-               fmt.Printf("import var %v %L\n", s, t)
+       p.marked[t] = true
+
+       // If this is a named type, mark all of its associated
+       // methods. Skip interface types because t.Methods contains
+       // only their unexpanded method set (i.e., exclusive of
+       // interface embeddings), and the switch statement below
+       // handles their full method set.
+       if t.Sym() != nil && t.Kind() != types.TINTER {
+               for _, m := range t.Methods().Slice() {
+                       if types.IsExported(m.Sym.Name) {
+                               p.markObject(ir.AsNode(m.Nname))
+                       }
+               }
        }
-}
 
-// importalias declares symbol s as an imported type alias with type t.
-// ipkg is the package being imported
-func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-       n := importobj(ipkg, pos, s, OTYPE, PEXTERN, t)
-       if n == nil {
-               return
-       }
+       // Recursively mark any types that can be produced given a
+       // value of type t: dereferencing a pointer; indexing or
+       // iterating over an array, slice, or map; receiving from a
+       // channel; accessing a struct field or interface method; or
+       // calling a function.
+       //
+       // Notably, we don't mark function parameter types, because
+       // the user already needs some way to construct values of
+       // those types.
+       switch t.Kind() {
+       case types.TPTR, types.TARRAY, types.TSLICE:
+               p.markType(t.Elem())
+
+       case types.TCHAN:
+               if t.ChanDir().CanRecv() {
+                       p.markType(t.Elem())
+               }
 
-       if Debug.E != 0 {
-               fmt.Printf("import type %v = %L\n", s, t)
-       }
-}
+       case types.TMAP:
+               p.markType(t.Key())
+               p.markType(t.Elem())
 
-func dumpasmhdr() {
-       b, err := bio.Create(asmhdr)
-       if err != nil {
-               Fatalf("%v", err)
-       }
-       fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", localpkg.Name)
-       for _, n := range asmlist {
-               if n.Sym.IsBlank() {
-                       continue
-               }
-               switch n.Op {
-               case OLITERAL:
-                       t := n.Val().Ctype()
-                       if t == CTFLT || t == CTCPLX {
-                               break
+       case types.TSTRUCT:
+               for _, f := range t.FieldSlice() {
+                       if types.IsExported(f.Sym.Name) || f.Embedded != 0 {
+                               p.markType(f.Type)
                        }
-                       fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym.Name, n.Val())
+               }
 
-               case OTYPE:
-                       t := n.Type
-                       if !t.IsStruct() || t.StructType().Map != nil || t.IsFuncArgStruct() {
-                               break
-                       }
-                       fmt.Fprintf(b, "#define %s__size %d\n", n.Sym.Name, int(t.Width))
-                       for _, f := range t.Fields().Slice() {
-                               if !f.Sym.IsBlank() {
-                                       fmt.Fprintf(b, "#define %s_%s %d\n", n.Sym.Name, f.Sym.Name, int(f.Offset))
-                               }
+       case types.TFUNC:
+               for _, f := range t.Results().FieldSlice() {
+                       p.markType(f.Type)
+               }
+
+       case types.TINTER:
+               for _, f := range t.FieldSlice() {
+                       if types.IsExported(f.Sym.Name) {
+                               p.markType(f.Type)
                        }
                }
        }
-
-       b.Close()
 }

diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
deleted file mode 100644 (file)
index f92f5d0..0000000
--- a/src/cmd/compile/internal/gc/fmt.go
+++ /dev/null
@@ -1,1986 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "bytes"
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "fmt"
-       "io"
-       "strconv"
-       "strings"
-       "sync"
-       "unicode/utf8"
-)
-
-// A FmtFlag value is a set of flags (or 0).
-// They control how the Xconv functions format their values.
-// See the respective function's documentation for details.
-type FmtFlag int
-
-const ( //                                 fmt.Format flag/prec or verb
-       FmtLeft     FmtFlag = 1 << iota // '-'
-       FmtSharp                        // '#'
-       FmtSign                         // '+'
-       FmtUnsigned                     // internal use only (historic: u flag)
-       FmtShort                        // verb == 'S'       (historic: h flag)
-       FmtLong                         // verb == 'L'       (historic: l flag)
-       FmtComma                        // '.' (== hasPrec)  (historic: , flag)
-       FmtByte                         // '0'               (historic: hh flag)
-)
-
-// fmtFlag computes the (internal) FmtFlag
-// value given the fmt.State and format verb.
-func fmtFlag(s fmt.State, verb rune) FmtFlag {
-       var flag FmtFlag
-       if s.Flag('-') {
-               flag |= FmtLeft
-       }
-       if s.Flag('#') {
-               flag |= FmtSharp
-       }
-       if s.Flag('+') {
-               flag |= FmtSign
-       }
-       if s.Flag(' ') {
-               Fatalf("FmtUnsigned in format string")
-       }
-       if _, ok := s.Precision(); ok {
-               flag |= FmtComma
-       }
-       if s.Flag('0') {
-               flag |= FmtByte
-       }
-       switch verb {
-       case 'S':
-               flag |= FmtShort
-       case 'L':
-               flag |= FmtLong
-       }
-       return flag
-}
-
-// Format conversions:
-// TODO(gri) verify these; eliminate those not used anymore
-//
-//     %v Op           Node opcodes
-//             Flags:  #: print Go syntax (automatic unless mode == FDbg)
-//
-//     %j *Node        Node details
-//             Flags:  0: suppresses things not relevant until walk
-//
-//     %v *Val         Constant values
-//
-//     %v *types.Sym           Symbols
-//     %S              unqualified identifier in any mode
-//             Flags:  +,- #: mode (see below)
-//                     0: in export mode: unqualified identifier if exported, qualified if not
-//
-//     %v *types.Type  Types
-//     %S              omit "func" and receiver in function types
-//     %L              definition instead of name.
-//             Flags:  +,- #: mode (see below)
-//                     ' ' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
-//
-//     %v *Node        Nodes
-//     %S              (only in +/debug mode) suppress recursion
-//     %L              (only in Error mode) print "foo (type Bar)"
-//             Flags:  +,- #: mode (see below)
-//
-//     %v Nodes        Node lists
-//             Flags:  those of *Node
-//                     .: separate items with ',' instead of ';'
-
-// *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
-const (
-       FErr fmtMode = iota
-       FDbg
-       FTypeId
-       FTypeIdName // same as FTypeId, but use package name instead of prefix
-)
-
-// The mode flags '+', '-', and '#' are sticky; they persist through
-// recursions of *Node, *types.Type, and *types.Sym values. The ' ' flag is
-// sticky only on *types.Type recursions and only used in %-/*types.Sym mode.
-//
-// Example: given a *types.Sym: %+v %#v %-v print an identifier properly qualified for debug/export/internal mode
-
-// Useful format combinations:
-// TODO(gri): verify these
-//
-// *Node, Nodes:
-//   %+v    multiline recursive debug dump of *Node/Nodes
-//   %+S    non-recursive debug dump
-//
-// *Node:
-//   %#v    Go format
-//   %L     "foo (type Bar)" for error messages
-//
-// *types.Type:
-//   %#v    Go format
-//   %#L    type definition instead of name
-//   %#S    omit "func" and receiver in function signature
-//
-//   %-v    type identifiers
-//   %-S    type identifiers without "func" and arg names in type signatures (methodsym)
-//   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
-
-// update returns the results of applying f to mode.
-func (f FmtFlag) update(mode fmtMode) (FmtFlag, fmtMode) {
-       switch {
-       case f&FmtSign != 0:
-               mode = FDbg
-       case f&FmtSharp != 0:
-               // ignore (textual export format no longer supported)
-       case f&FmtUnsigned != 0:
-               mode = FTypeIdName
-       case f&FmtLeft != 0:
-               mode = FTypeId
-       }
-
-       f &^= FmtSharp | FmtLeft | FmtSign
-       return f, mode
-}
-
-var goopnames = []string{
-       OADDR:     "&",
-       OADD:      "+",
-       OADDSTR:   "+",
-       OALIGNOF:  "unsafe.Alignof",
-       OANDAND:   "&&",
-       OANDNOT:   "&^",
-       OAND:      "&",
-       OAPPEND:   "append",
-       OAS:       "=",
-       OAS2:      "=",
-       OBREAK:    "break",
-       OCALL:     "function call", // not actual syntax
-       OCAP:      "cap",
-       OCASE:     "case",
-       OCLOSE:    "close",
-       OCOMPLEX:  "complex",
-       OBITNOT:   "^",
-       OCONTINUE: "continue",
-       OCOPY:     "copy",
-       ODELETE:   "delete",
-       ODEFER:    "defer",
-       ODIV:      "/",
-       OEQ:       "==",
-       OFALL:     "fallthrough",
-       OFOR:      "for",
-       OFORUNTIL: "foruntil", // not actual syntax; used to avoid off-end pointer live on backedge.892
-       OGE:       ">=",
-       OGOTO:     "goto",
-       OGT:       ">",
-       OIF:       "if",
-       OIMAG:     "imag",
-       OINLMARK:  "inlmark",
-       ODEREF:    "*",
-       OLEN:      "len",
-       OLE:       "<=",
-       OLSH:      "<<",
-       OLT:       "<",
-       OMAKE:     "make",
-       ONEG:      "-",
-       OMOD:      "%",
-       OMUL:      "*",
-       ONEW:      "new",
-       ONE:       "!=",
-       ONOT:      "!",
-       OOFFSETOF: "unsafe.Offsetof",
-       OOROR:     "||",
-       OOR:       "|",
-       OPANIC:    "panic",
-       OPLUS:     "+",
-       OPRINTN:   "println",
-       OPRINT:    "print",
-       ORANGE:    "range",
-       OREAL:     "real",
-       ORECV:     "<-",
-       ORECOVER:  "recover",
-       ORETURN:   "return",
-       ORSH:      ">>",
-       OSELECT:   "select",
-       OSEND:     "<-",
-       OSIZEOF:   "unsafe.Sizeof",
-       OSUB:      "-",
-       OSWITCH:   "switch",
-       OXOR:      "^",
-}
-
-func (o Op) GoString() string {
-       return fmt.Sprintf("%#v", o)
-}
-
-func (o Op) format(s fmt.State, verb rune, mode fmtMode) {
-       switch verb {
-       case 'v':
-               o.oconv(s, fmtFlag(s, verb), mode)
-
-       default:
-               fmt.Fprintf(s, "%%!%c(Op=%d)", verb, int(o))
-       }
-}
-
-func (o Op) oconv(s fmt.State, flag FmtFlag, mode fmtMode) {
-       if flag&FmtSharp != 0 || mode != FDbg {
-               if int(o) < len(goopnames) && goopnames[o] != "" {
-                       fmt.Fprint(s, goopnames[o])
-                       return
-               }
-       }
-
-       // 'o.String()' instead of just 'o' to avoid infinite recursion
-       fmt.Fprint(s, o.String())
-}
-
-type (
-       fmtMode int
-
-       fmtNodeErr        Node
-       fmtNodeDbg        Node
-       fmtNodeTypeId     Node
-       fmtNodeTypeIdName Node
-
-       fmtOpErr        Op
-       fmtOpDbg        Op
-       fmtOpTypeId     Op
-       fmtOpTypeIdName Op
-
-       fmtTypeErr        types.Type
-       fmtTypeDbg        types.Type
-       fmtTypeTypeId     types.Type
-       fmtTypeTypeIdName types.Type
-
-       fmtSymErr        types.Sym
-       fmtSymDbg        types.Sym
-       fmtSymTypeId     types.Sym
-       fmtSymTypeIdName types.Sym
-
-       fmtNodesErr        Nodes
-       fmtNodesDbg        Nodes
-       fmtNodesTypeId     Nodes
-       fmtNodesTypeIdName Nodes
-)
-
-func (n *fmtNodeErr) Format(s fmt.State, verb rune)        { (*Node)(n).format(s, verb, FErr) }
-func (n *fmtNodeDbg) Format(s fmt.State, verb rune)        { (*Node)(n).format(s, verb, FDbg) }
-func (n *fmtNodeTypeId) Format(s fmt.State, verb rune)     { (*Node)(n).format(s, verb, FTypeId) }
-func (n *fmtNodeTypeIdName) Format(s fmt.State, verb rune) { (*Node)(n).format(s, verb, FTypeIdName) }
-func (n *Node) Format(s fmt.State, verb rune)              { n.format(s, verb, FErr) }
-
-func (o fmtOpErr) Format(s fmt.State, verb rune)        { Op(o).format(s, verb, FErr) }
-func (o fmtOpDbg) Format(s fmt.State, verb rune)        { Op(o).format(s, verb, FDbg) }
-func (o fmtOpTypeId) Format(s fmt.State, verb rune)     { Op(o).format(s, verb, FTypeId) }
-func (o fmtOpTypeIdName) Format(s fmt.State, verb rune) { Op(o).format(s, verb, FTypeIdName) }
-func (o Op) Format(s fmt.State, verb rune)              { o.format(s, verb, FErr) }
-
-func (t *fmtTypeErr) Format(s fmt.State, verb rune) { typeFormat((*types.Type)(t), s, verb, FErr) }
-func (t *fmtTypeDbg) Format(s fmt.State, verb rune) { typeFormat((*types.Type)(t), s, verb, FDbg) }
-func (t *fmtTypeTypeId) Format(s fmt.State, verb rune) {
-       typeFormat((*types.Type)(t), s, verb, FTypeId)
-}
-func (t *fmtTypeTypeIdName) Format(s fmt.State, verb rune) {
-       typeFormat((*types.Type)(t), s, verb, FTypeIdName)
-}
-
-// func (t *types.Type) Format(s fmt.State, verb rune)     // in package types
-
-func (y *fmtSymErr) Format(s fmt.State, verb rune)    { symFormat((*types.Sym)(y), s, verb, FErr) }
-func (y *fmtSymDbg) Format(s fmt.State, verb rune)    { symFormat((*types.Sym)(y), s, verb, FDbg) }
-func (y *fmtSymTypeId) Format(s fmt.State, verb rune) { symFormat((*types.Sym)(y), s, verb, FTypeId) }
-func (y *fmtSymTypeIdName) Format(s fmt.State, verb rune) {
-       symFormat((*types.Sym)(y), s, verb, FTypeIdName)
-}
-
-// func (y *types.Sym) Format(s fmt.State, verb rune)            // in package types  { y.format(s, verb, FErr) }
-
-func (n fmtNodesErr) Format(s fmt.State, verb rune)        { (Nodes)(n).format(s, verb, FErr) }
-func (n fmtNodesDbg) Format(s fmt.State, verb rune)        { (Nodes)(n).format(s, verb, FDbg) }
-func (n fmtNodesTypeId) Format(s fmt.State, verb rune)     { (Nodes)(n).format(s, verb, FTypeId) }
-func (n fmtNodesTypeIdName) Format(s fmt.State, verb rune) { (Nodes)(n).format(s, verb, FTypeIdName) }
-func (n Nodes) Format(s fmt.State, verb rune)              { n.format(s, verb, FErr) }
-
-func (m fmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
-       m.prepareArgs(args)
-       fmt.Fprintf(s, format, args...)
-}
-
-func (m fmtMode) Sprintf(format string, args ...interface{}) string {
-       m.prepareArgs(args)
-       return fmt.Sprintf(format, args...)
-}
-
-func (m fmtMode) Sprint(args ...interface{}) string {
-       m.prepareArgs(args)
-       return fmt.Sprint(args...)
-}
-
-func (m fmtMode) prepareArgs(args []interface{}) {
-       switch m {
-       case FErr:
-               for i, arg := range args {
-                       switch arg := arg.(type) {
-                       case Op:
-                               args[i] = fmtOpErr(arg)
-                       case *Node:
-                               args[i] = (*fmtNodeErr)(arg)
-                       case *types.Type:
-                               args[i] = (*fmtTypeErr)(arg)
-                       case *types.Sym:
-                               args[i] = (*fmtSymErr)(arg)
-                       case Nodes:
-                               args[i] = fmtNodesErr(arg)
-                       case Val, int32, int64, string, types.EType:
-                               // OK: printing these types doesn't depend on mode
-                       default:
-                               Fatalf("mode.prepareArgs type %T", arg)
-                       }
-               }
-       case FDbg:
-               for i, arg := range args {
-                       switch arg := arg.(type) {
-                       case Op:
-                               args[i] = fmtOpDbg(arg)
-                       case *Node:
-                               args[i] = (*fmtNodeDbg)(arg)
-                       case *types.Type:
-                               args[i] = (*fmtTypeDbg)(arg)
-                       case *types.Sym:
-                               args[i] = (*fmtSymDbg)(arg)
-                       case Nodes:
-                               args[i] = fmtNodesDbg(arg)
-                       case Val, int32, int64, string, types.EType:
-                               // OK: printing these types doesn't depend on mode
-                       default:
-                               Fatalf("mode.prepareArgs type %T", arg)
-                       }
-               }
-       case FTypeId:
-               for i, arg := range args {
-                       switch arg := arg.(type) {
-                       case Op:
-                               args[i] = fmtOpTypeId(arg)
-                       case *Node:
-                               args[i] = (*fmtNodeTypeId)(arg)
-                       case *types.Type:
-                               args[i] = (*fmtTypeTypeId)(arg)
-                       case *types.Sym:
-                               args[i] = (*fmtSymTypeId)(arg)
-                       case Nodes:
-                               args[i] = fmtNodesTypeId(arg)
-                       case Val, int32, int64, string, types.EType:
-                               // OK: printing these types doesn't depend on mode
-                       default:
-                               Fatalf("mode.prepareArgs type %T", arg)
-                       }
-               }
-       case FTypeIdName:
-               for i, arg := range args {
-                       switch arg := arg.(type) {
-                       case Op:
-                               args[i] = fmtOpTypeIdName(arg)
-                       case *Node:
-                               args[i] = (*fmtNodeTypeIdName)(arg)
-                       case *types.Type:
-                               args[i] = (*fmtTypeTypeIdName)(arg)
-                       case *types.Sym:
-                               args[i] = (*fmtSymTypeIdName)(arg)
-                       case Nodes:
-                               args[i] = fmtNodesTypeIdName(arg)
-                       case Val, int32, int64, string, types.EType:
-                               // OK: printing these types doesn't depend on mode
-                       default:
-                               Fatalf("mode.prepareArgs type %T", arg)
-                       }
-               }
-       default:
-               Fatalf("mode.prepareArgs mode %d", m)
-       }
-}
-
-func (n *Node) format(s fmt.State, verb rune, mode fmtMode) {
-       switch verb {
-       case 'v', 'S', 'L':
-               n.nconv(s, fmtFlag(s, verb), mode)
-
-       case 'j':
-               n.jconv(s, fmtFlag(s, verb))
-
-       default:
-               fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
-       }
-}
-
-// *Node details
-func (n *Node) jconv(s fmt.State, flag FmtFlag) {
-       c := flag & FmtShort
-
-       // Useful to see which nodes in a Node Dump/dumplist are actually identical
-       if Debug_dumpptrs != 0 {
-               fmt.Fprintf(s, " p(%p)", n)
-       }
-       if c == 0 && n.Name != nil && n.Name.Vargen != 0 {
-               fmt.Fprintf(s, " g(%d)", n.Name.Vargen)
-       }
-
-       if Debug_dumpptrs != 0 && c == 0 && n.Name != nil && n.Name.Defn != nil {
-               // Useful to see where Defn is set and what node it points to
-               fmt.Fprintf(s, " defn(%p)", n.Name.Defn)
-       }
-
-       if n.Pos.IsKnown() {
-               pfx := ""
-               switch n.Pos.IsStmt() {
-               case src.PosNotStmt:
-                       pfx = "_" // "-" would be confusing
-               case src.PosIsStmt:
-                       pfx = "+"
-               }
-               fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos.Line())
-       }
-
-       if c == 0 && n.Xoffset != BADWIDTH {
-               fmt.Fprintf(s, " x(%d)", n.Xoffset)
-       }
-
-       if n.Class() != 0 {
-               fmt.Fprintf(s, " class(%v)", n.Class())
-       }
-
-       if n.Colas() {
-               fmt.Fprintf(s, " colas(%v)", n.Colas())
-       }
-
-       switch n.Esc {
-       case EscUnknown:
-               break
-
-       case EscHeap:
-               fmt.Fprint(s, " esc(h)")
-
-       case EscNone:
-               fmt.Fprint(s, " esc(no)")
-
-       case EscNever:
-               if c == 0 {
-                       fmt.Fprint(s, " esc(N)")
-               }
-
-       default:
-               fmt.Fprintf(s, " esc(%d)", n.Esc)
-       }
-
-       if e, ok := n.Opt().(*EscLocation); ok && e.loopDepth != 0 {
-               fmt.Fprintf(s, " ld(%d)", e.loopDepth)
-       }
-
-       if c == 0 && n.Typecheck() != 0 {
-               fmt.Fprintf(s, " tc(%d)", n.Typecheck())
-       }
-
-       if n.IsDDD() {
-               fmt.Fprintf(s, " isddd(%v)", n.IsDDD())
-       }
-
-       if n.Implicit() {
-               fmt.Fprintf(s, " implicit(%v)", n.Implicit())
-       }
-
-       if n.Embedded() {
-               fmt.Fprintf(s, " embedded")
-       }
-
-       if n.Op == ONAME {
-               if n.Name.Addrtaken() {
-                       fmt.Fprint(s, " addrtaken")
-               }
-               if n.Name.Assigned() {
-                       fmt.Fprint(s, " assigned")
-               }
-               if n.Name.IsClosureVar() {
-                       fmt.Fprint(s, " closurevar")
-               }
-               if n.Name.Captured() {
-                       fmt.Fprint(s, " captured")
-               }
-               if n.Name.IsOutputParamHeapAddr() {
-                       fmt.Fprint(s, " outputparamheapaddr")
-               }
-       }
-       if n.Bounded() {
-               fmt.Fprint(s, " bounded")
-       }
-       if n.NonNil() {
-               fmt.Fprint(s, " nonnil")
-       }
-
-       if c == 0 && n.HasCall() {
-               fmt.Fprint(s, " hascall")
-       }
-
-       if c == 0 && n.Name != nil && n.Name.Used() {
-               fmt.Fprint(s, " used")
-       }
-}
-
-func (v Val) Format(s fmt.State, verb rune) {
-       switch verb {
-       case 'v':
-               v.vconv(s, fmtFlag(s, verb))
-
-       default:
-               fmt.Fprintf(s, "%%!%c(Val=%T)", verb, v)
-       }
-}
-
-func (v Val) vconv(s fmt.State, flag FmtFlag) {
-       switch u := v.U.(type) {
-       case *Mpint:
-               if !u.Rune {
-                       if flag&FmtSharp != 0 {
-                               fmt.Fprint(s, u.String())
-                               return
-                       }
-                       fmt.Fprint(s, u.GoString())
-                       return
-               }
-
-               switch x := u.Int64(); {
-               case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
-                       fmt.Fprintf(s, "'%c'", int(x))
-
-               case 0 <= x && x < 1<<16:
-                       fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
-
-               case 0 <= x && x <= utf8.MaxRune:
-                       fmt.Fprintf(s, "'\\U%08x'", uint64(x))
-
-               default:
-                       fmt.Fprintf(s, "('\\x00' + %v)", u)
-               }
-
-       case *Mpflt:
-               if flag&FmtSharp != 0 {
-                       fmt.Fprint(s, u.String())
-                       return
-               }
-               fmt.Fprint(s, u.GoString())
-               return
-
-       case *Mpcplx:
-               if flag&FmtSharp != 0 {
-                       fmt.Fprint(s, u.String())
-                       return
-               }
-               fmt.Fprint(s, u.GoString())
-               return
-
-       case string:
-               fmt.Fprint(s, strconv.Quote(u))
-
-       case bool:
-               fmt.Fprint(s, u)
-
-       case *NilVal:
-               fmt.Fprint(s, "nil")
-
-       default:
-               fmt.Fprintf(s, "<ctype=%d>", v.Ctype())
-       }
-}
-
-/*
-s%,%,\n%g
-s%\n+%\n%g
-s%^[   ]*T%%g
-s%,.*%%g
-s%.+%  [T&]            = "&",%g
-s%^    ........*\]%&~%g
-s%~    %%g
-*/
-
-func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
-       if flag&FmtShort == 0 {
-               switch mode {
-               case FErr: // This is for the user
-                       if s.Pkg == builtinpkg || s.Pkg == localpkg {
-                               b.WriteString(s.Name)
-                               return
-                       }
-
-                       // If the name was used by multiple packages, display the full path,
-                       if s.Pkg.Name != "" && numImport[s.Pkg.Name] > 1 {
-                               fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
-                               return
-                       }
-                       b.WriteString(s.Pkg.Name)
-                       b.WriteByte('.')
-                       b.WriteString(s.Name)
-                       return
-
-               case FDbg:
-                       b.WriteString(s.Pkg.Name)
-                       b.WriteByte('.')
-                       b.WriteString(s.Name)
-                       return
-
-               case FTypeIdName:
-                       // dcommontype, typehash
-                       b.WriteString(s.Pkg.Name)
-                       b.WriteByte('.')
-                       b.WriteString(s.Name)
-                       return
-
-               case FTypeId:
-                       // (methodsym), typesym, weaksym
-                       b.WriteString(s.Pkg.Prefix)
-                       b.WriteByte('.')
-                       b.WriteString(s.Name)
-                       return
-               }
-       }
-
-       if flag&FmtByte != 0 {
-               // FmtByte (hh) implies FmtShort (h)
-               // skip leading "type." in method name
-               name := s.Name
-               if i := strings.LastIndex(name, "."); i >= 0 {
-                       name = name[i+1:]
-               }
-
-               if mode == FDbg {
-                       fmt.Fprintf(b, "@%q.%s", s.Pkg.Path, name)
-                       return
-               }
-
-               b.WriteString(name)
-               return
-       }
-
-       b.WriteString(s.Name)
-}
-
-var basicnames = []string{
-       TINT:        "int",
-       TUINT:       "uint",
-       TINT8:       "int8",
-       TUINT8:      "uint8",
-       TINT16:      "int16",
-       TUINT16:     "uint16",
-       TINT32:      "int32",
-       TUINT32:     "uint32",
-       TINT64:      "int64",
-       TUINT64:     "uint64",
-       TUINTPTR:    "uintptr",
-       TFLOAT32:    "float32",
-       TFLOAT64:    "float64",
-       TCOMPLEX64:  "complex64",
-       TCOMPLEX128: "complex128",
-       TBOOL:       "bool",
-       TANY:        "any",
-       TSTRING:     "string",
-       TNIL:        "nil",
-       TIDEAL:      "untyped number",
-       TBLANK:      "blank",
-}
-
-var fmtBufferPool = sync.Pool{
-       New: func() interface{} {
-               return new(bytes.Buffer)
-       },
-}
-
-func tconv(t *types.Type, flag FmtFlag, mode fmtMode) string {
-       buf := fmtBufferPool.Get().(*bytes.Buffer)
-       buf.Reset()
-       defer fmtBufferPool.Put(buf)
-
-       tconv2(buf, t, flag, mode, nil)
-       return types.InternString(buf.Bytes())
-}
-
-// tconv2 writes a string representation of t to b.
-// flag and mode control exactly what is printed.
-// Any types x that are already in the visited map get printed as @%d where %d=visited[x].
-// See #16897 before changing the implementation of tconv.
-func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited map[*types.Type]int) {
-       if off, ok := visited[t]; ok {
-               // We've seen this type before, so we're trying to print it recursively.
-               // Print a reference to it instead.
-               fmt.Fprintf(b, "@%d", off)
-               return
-       }
-       if t == nil {
-               b.WriteString("<T>")
-               return
-       }
-       if t.Etype == types.TSSA {
-               b.WriteString(t.Extra.(string))
-               return
-       }
-       if t.Etype == types.TTUPLE {
-               b.WriteString(t.FieldType(0).String())
-               b.WriteByte(',')
-               b.WriteString(t.FieldType(1).String())
-               return
-       }
-
-       if t.Etype == types.TRESULTS {
-               tys := t.Extra.(*types.Results).Types
-               for i, et := range tys {
-                       if i > 0 {
-                               b.WriteByte(',')
-                       }
-                       b.WriteString(et.String())
-               }
-               return
-       }
-
-       flag, mode = flag.update(mode)
-       if mode == FTypeIdName {
-               flag |= FmtUnsigned
-       }
-       if t == types.Bytetype || t == types.Runetype {
-               // in %-T mode collapse rune and byte with their originals.
-               switch mode {
-               case FTypeIdName, FTypeId:
-                       t = types.Types[t.Etype]
-               default:
-                       sconv2(b, t.Sym, FmtShort, mode)
-                       return
-               }
-       }
-       if t == types.Errortype {
-               b.WriteString("error")
-               return
-       }
-
-       // Unless the 'L' flag was specified, if the type has a name, just print that name.
-       if flag&FmtLong == 0 && t.Sym != nil && t != types.Types[t.Etype] {
-               switch mode {
-               case FTypeId, FTypeIdName:
-                       if flag&FmtShort != 0 {
-                               if t.Vargen != 0 {
-                                       sconv2(b, t.Sym, FmtShort, mode)
-                                       fmt.Fprintf(b, "·%d", t.Vargen)
-                                       return
-                               }
-                               sconv2(b, t.Sym, FmtShort, mode)
-                               return
-                       }
-
-                       if mode == FTypeIdName {
-                               sconv2(b, t.Sym, FmtUnsigned, mode)
-                               return
-                       }
-
-                       if t.Sym.Pkg == localpkg && t.Vargen != 0 {
-                               b.WriteString(mode.Sprintf("%v·%d", t.Sym, t.Vargen))
-                               return
-                       }
-               }
-
-               sconv2(b, t.Sym, 0, mode)
-               return
-       }
-
-       if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" {
-               var name string
-               switch t {
-               case types.UntypedBool:
-                       name = "untyped bool"
-               case types.UntypedString:
-                       name = "untyped string"
-               case types.UntypedInt:
-                       name = "untyped int"
-               case types.UntypedRune:
-                       name = "untyped rune"
-               case types.UntypedFloat:
-                       name = "untyped float"
-               case types.UntypedComplex:
-                       name = "untyped complex"
-               default:
-                       name = basicnames[t.Etype]
-               }
-               b.WriteString(name)
-               return
-       }
-
-       if mode == FDbg {
-               b.WriteString(t.Etype.String())
-               b.WriteByte('-')
-               tconv2(b, t, flag, FErr, visited)
-               return
-       }
-
-       // At this point, we might call tconv2 recursively. Add the current type to the visited list so we don't
-       // try to print it recursively.
-       // We record the offset in the result buffer where the type's text starts. This offset serves as a reference
-       // point for any later references to the same type.
-       // Note that we remove the type from the visited map as soon as the recursive call is done.
-       // This prevents encoding types like map[*int]*int as map[*int]@4. (That encoding would work,
-       // but I'd like to use the @ notation only when strictly necessary.)
-       if visited == nil {
-               visited = map[*types.Type]int{}
-       }
-       visited[t] = b.Len()
-       defer delete(visited, t)
-
-       switch t.Etype {
-       case TPTR:
-               b.WriteByte('*')
-               switch mode {
-               case FTypeId, FTypeIdName:
-                       if flag&FmtShort != 0 {
-                               tconv2(b, t.Elem(), FmtShort, mode, visited)
-                               return
-                       }
-               }
-               tconv2(b, t.Elem(), 0, mode, visited)
-
-       case TARRAY:
-               b.WriteByte('[')
-               b.WriteString(strconv.FormatInt(t.NumElem(), 10))
-               b.WriteByte(']')
-               tconv2(b, t.Elem(), 0, mode, visited)
-
-       case TSLICE:
-               b.WriteString("[]")
-               tconv2(b, t.Elem(), 0, mode, visited)
-
-       case TCHAN:
-               switch t.ChanDir() {
-               case types.Crecv:
-                       b.WriteString("<-chan ")
-                       tconv2(b, t.Elem(), 0, mode, visited)
-               case types.Csend:
-                       b.WriteString("chan<- ")
-                       tconv2(b, t.Elem(), 0, mode, visited)
-               default:
-                       b.WriteString("chan ")
-                       if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym == nil && t.Elem().ChanDir() == types.Crecv {
-                               b.WriteByte('(')
-                               tconv2(b, t.Elem(), 0, mode, visited)
-                               b.WriteByte(')')
-                       } else {
-                               tconv2(b, t.Elem(), 0, mode, visited)
-                       }
-               }
-
-       case TMAP:
-               b.WriteString("map[")
-               tconv2(b, t.Key(), 0, mode, visited)
-               b.WriteByte(']')
-               tconv2(b, t.Elem(), 0, mode, visited)
-
-       case TINTER:
-               if t.IsEmptyInterface() {
-                       b.WriteString("interface {}")
-                       break
-               }
-               b.WriteString("interface {")
-               for i, f := range t.Fields().Slice() {
-                       if i != 0 {
-                               b.WriteByte(';')
-                       }
-                       b.WriteByte(' ')
-                       switch {
-                       case f.Sym == nil:
-                               // Check first that a symbol is defined for this type.
-                               // Wrong interface definitions may have types lacking a symbol.
-                               break
-                       case types.IsExported(f.Sym.Name):
-                               sconv2(b, f.Sym, FmtShort, mode)
-                       default:
-                               flag1 := FmtLeft
-                               if flag&FmtUnsigned != 0 {
-                                       flag1 = FmtUnsigned
-                               }
-                               sconv2(b, f.Sym, flag1, mode)
-                       }
-                       tconv2(b, f.Type, FmtShort, mode, visited)
-               }
-               if t.NumFields() != 0 {
-                       b.WriteByte(' ')
-               }
-               b.WriteByte('}')
-
-       case TFUNC:
-               if flag&FmtShort != 0 {
-                       // no leading func
-               } else {
-                       if t.Recv() != nil {
-                               b.WriteString("method")
-                               tconv2(b, t.Recvs(), 0, mode, visited)
-                               b.WriteByte(' ')
-                       }
-                       b.WriteString("func")
-               }
-               tconv2(b, t.Params(), 0, mode, visited)
-
-               switch t.NumResults() {
-               case 0:
-                       // nothing to do
-
-               case 1:
-                       b.WriteByte(' ')
-                       tconv2(b, t.Results().Field(0).Type, 0, mode, visited) // struct->field->field's type
-
-               default:
-                       b.WriteByte(' ')
-                       tconv2(b, t.Results(), 0, mode, visited)
-               }
-
-       case TSTRUCT:
-               if m := t.StructType().Map; m != nil {
-                       mt := m.MapType()
-                       // Format the bucket struct for map[x]y as map.bucket[x]y.
-                       // This avoids a recursive print that generates very long names.
-                       switch t {
-                       case mt.Bucket:
-                               b.WriteString("map.bucket[")
-                       case mt.Hmap:
-                               b.WriteString("map.hdr[")
-                       case mt.Hiter:
-                               b.WriteString("map.iter[")
-                       default:
-                               Fatalf("unknown internal map type")
-                       }
-                       tconv2(b, m.Key(), 0, mode, visited)
-                       b.WriteByte(']')
-                       tconv2(b, m.Elem(), 0, mode, visited)
-                       break
-               }
-
-               if funarg := t.StructType().Funarg; funarg != types.FunargNone {
-                       b.WriteByte('(')
-                       var flag1 FmtFlag
-                       switch mode {
-                       case FTypeId, FTypeIdName, FErr:
-                               // no argument names on function signature, and no "noescape"/"nosplit" tags
-                               flag1 = FmtShort
-                       }
-                       for i, f := range t.Fields().Slice() {
-                               if i != 0 {
-                                       b.WriteString(", ")
-                               }
-                               fldconv(b, f, flag1, mode, visited, funarg)
-                       }
-                       b.WriteByte(')')
-               } else {
-                       b.WriteString("struct {")
-                       for i, f := range t.Fields().Slice() {
-                               if i != 0 {
-                                       b.WriteByte(';')
-                               }
-                               b.WriteByte(' ')
-                               fldconv(b, f, FmtLong, mode, visited, funarg)
-                       }
-                       if t.NumFields() != 0 {
-                               b.WriteByte(' ')
-                       }
-                       b.WriteByte('}')
-               }
-
-       case TFORW:
-               b.WriteString("undefined")
-               if t.Sym != nil {
-                       b.WriteByte(' ')
-                       sconv2(b, t.Sym, 0, mode)
-               }
-
-       case TUNSAFEPTR:
-               b.WriteString("unsafe.Pointer")
-
-       case Txxx:
-               b.WriteString("Txxx")
-       default:
-               // Don't know how to handle - fall back to detailed prints.
-               b.WriteString(mode.Sprintf("%v <%v>", t.Etype, t.Sym))
-       }
-}
-
-// Statements which may be rendered with a simplestmt as init.
-func stmtwithinit(op Op) bool {
-       switch op {
-       case OIF, OFOR, OFORUNTIL, OSWITCH:
-               return true
-       }
-
-       return false
-}
-
-func (n *Node) stmtfmt(s fmt.State, mode fmtMode) {
-       // some statements allow for an init, but at most one,
-       // but we may have an arbitrary number added, eg by typecheck
-       // and inlining. If it doesn't fit the syntax, emit an enclosing
-       // block starting with the init statements.
-
-       // if we can just say "for" n->ninit; ... then do so
-       simpleinit := n.Ninit.Len() == 1 && n.Ninit.First().Ninit.Len() == 0 && stmtwithinit(n.Op)
-
-       // otherwise, print the inits as separate statements
-       complexinit := n.Ninit.Len() != 0 && !simpleinit && (mode != FErr)
-
-       // but if it was for if/for/switch, put in an extra surrounding block to limit the scope
-       extrablock := complexinit && stmtwithinit(n.Op)
-
-       if extrablock {
-               fmt.Fprint(s, "{")
-       }
-
-       if complexinit {
-               mode.Fprintf(s, " %v; ", n.Ninit)
-       }
-
-       switch n.Op {
-       case ODCL:
-               mode.Fprintf(s, "var %v %v", n.Left.Sym, n.Left.Type)
-
-       case ODCLFIELD:
-               if n.Sym != nil {
-                       mode.Fprintf(s, "%v %v", n.Sym, n.Left)
-               } else {
-                       mode.Fprintf(s, "%v", n.Left)
-               }
-
-       // Don't export "v = <N>" initializing statements, hope they're always
-       // preceded by the DCL which will be re-parsed and typechecked to reproduce
-       // the "v = <N>" again.
-       case OAS:
-               if n.Colas() && !complexinit {
-                       mode.Fprintf(s, "%v := %v", n.Left, n.Right)
-               } else {
-                       mode.Fprintf(s, "%v = %v", n.Left, n.Right)
-               }
-
-       case OASOP:
-               if n.Implicit() {
-                       if n.SubOp() == OADD {
-                               mode.Fprintf(s, "%v++", n.Left)
-                       } else {
-                               mode.Fprintf(s, "%v--", n.Left)
-                       }
-                       break
-               }
-
-               mode.Fprintf(s, "%v %#v= %v", n.Left, n.SubOp(), n.Right)
-
-       case OAS2:
-               if n.Colas() && !complexinit {
-                       mode.Fprintf(s, "%.v := %.v", n.List, n.Rlist)
-                       break
-               }
-               fallthrough
-
-       case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-               mode.Fprintf(s, "%.v = %v", n.List, n.Right)
-
-       case ORETURN:
-               mode.Fprintf(s, "return %.v", n.List)
-
-       case ORETJMP:
-               mode.Fprintf(s, "retjmp %v", n.Sym)
-
-       case OINLMARK:
-               mode.Fprintf(s, "inlmark %d", n.Xoffset)
-
-       case OGO:
-               mode.Fprintf(s, "go %v", n.Left)
-
-       case ODEFER:
-               mode.Fprintf(s, "defer %v", n.Left)
-
-       case OIF:
-               if simpleinit {
-                       mode.Fprintf(s, "if %v; %v { %v }", n.Ninit.First(), n.Left, n.Nbody)
-               } else {
-                       mode.Fprintf(s, "if %v { %v }", n.Left, n.Nbody)
-               }
-               if n.Rlist.Len() != 0 {
-                       mode.Fprintf(s, " else { %v }", n.Rlist)
-               }
-
-       case OFOR, OFORUNTIL:
-               opname := "for"
-               if n.Op == OFORUNTIL {
-                       opname = "foruntil"
-               }
-               if mode == FErr { // TODO maybe only if FmtShort, same below
-                       fmt.Fprintf(s, "%s loop", opname)
-                       break
-               }
-
-               fmt.Fprint(s, opname)
-               if simpleinit {
-                       mode.Fprintf(s, " %v;", n.Ninit.First())
-               } else if n.Right != nil {
-                       fmt.Fprint(s, " ;")
-               }
-
-               if n.Left != nil {
-                       mode.Fprintf(s, " %v", n.Left)
-               }
-
-               if n.Right != nil {
-                       mode.Fprintf(s, "; %v", n.Right)
-               } else if simpleinit {
-                       fmt.Fprint(s, ";")
-               }
-
-               if n.Op == OFORUNTIL && n.List.Len() != 0 {
-                       mode.Fprintf(s, "; %v", n.List)
-               }
-
-               mode.Fprintf(s, " { %v }", n.Nbody)
-
-       case ORANGE:
-               if mode == FErr {
-                       fmt.Fprint(s, "for loop")
-                       break
-               }
-
-               if n.List.Len() == 0 {
-                       mode.Fprintf(s, "for range %v { %v }", n.Right, n.Nbody)
-                       break
-               }
-
-               mode.Fprintf(s, "for %.v = range %v { %v }", n.List, n.Right, n.Nbody)
-
-       case OSELECT, OSWITCH:
-               if mode == FErr {
-                       mode.Fprintf(s, "%v statement", n.Op)
-                       break
-               }
-
-               mode.Fprintf(s, "%#v", n.Op)
-               if simpleinit {
-                       mode.Fprintf(s, " %v;", n.Ninit.First())
-               }
-               if n.Left != nil {
-                       mode.Fprintf(s, " %v ", n.Left)
-               }
-
-               mode.Fprintf(s, " { %v }", n.List)
-
-       case OCASE:
-               if n.List.Len() != 0 {
-                       mode.Fprintf(s, "case %.v", n.List)
-               } else {
-                       fmt.Fprint(s, "default")
-               }
-               mode.Fprintf(s, ": %v", n.Nbody)
-
-       case OBREAK, OCONTINUE, OGOTO, OFALL:
-               if n.Sym != nil {
-                       mode.Fprintf(s, "%#v %v", n.Op, n.Sym)
-               } else {
-                       mode.Fprintf(s, "%#v", n.Op)
-               }
-
-       case OEMPTY:
-               break
-
-       case OLABEL:
-               mode.Fprintf(s, "%v: ", n.Sym)
-       }
-
-       if extrablock {
-               fmt.Fprint(s, "}")
-       }
-}
-
-var opprec = []int{
-       OALIGNOF:       8,
-       OAPPEND:        8,
-       OBYTES2STR:     8,
-       OARRAYLIT:      8,
-       OSLICELIT:      8,
-       ORUNES2STR:     8,
-       OCALLFUNC:      8,
-       OCALLINTER:     8,
-       OCALLMETH:      8,
-       OCALL:          8,
-       OCAP:           8,
-       OCLOSE:         8,
-       OCONVIFACE:     8,
-       OCONVNOP:       8,
-       OCONV:          8,
-       OCOPY:          8,
-       ODELETE:        8,
-       OGETG:          8,
-       OLEN:           8,
-       OLITERAL:       8,
-       OMAKESLICE:     8,
-       OMAKESLICECOPY: 8,
-       OMAKE:          8,
-       OMAPLIT:        8,
-       ONAME:          8,
-       ONEW:           8,
-       ONONAME:        8,
-       OOFFSETOF:      8,
-       OPACK:          8,
-       OPANIC:         8,
-       OPAREN:         8,
-       OPRINTN:        8,
-       OPRINT:         8,
-       ORUNESTR:       8,
-       OSIZEOF:        8,
-       OSTR2BYTES:     8,
-       OSTR2RUNES:     8,
-       OSTRUCTLIT:     8,
-       OTARRAY:        8,
-       OTCHAN:         8,
-       OTFUNC:         8,
-       OTINTER:        8,
-       OTMAP:          8,
-       OTSTRUCT:       8,
-       OINDEXMAP:      8,
-       OINDEX:         8,
-       OSLICE:         8,
-       OSLICESTR:      8,
-       OSLICEARR:      8,
-       OSLICE3:        8,
-       OSLICE3ARR:     8,
-       OSLICEHEADER:   8,
-       ODOTINTER:      8,
-       ODOTMETH:       8,
-       ODOTPTR:        8,
-       ODOTTYPE2:      8,
-       ODOTTYPE:       8,
-       ODOT:           8,
-       OXDOT:          8,
-       OCALLPART:      8,
-       OPLUS:          7,
-       ONOT:           7,
-       OBITNOT:        7,
-       ONEG:           7,
-       OADDR:          7,
-       ODEREF:         7,
-       ORECV:          7,
-       OMUL:           6,
-       ODIV:           6,
-       OMOD:           6,
-       OLSH:           6,
-       ORSH:           6,
-       OAND:           6,
-       OANDNOT:        6,
-       OADD:           5,
-       OSUB:           5,
-       OOR:            5,
-       OXOR:           5,
-       OEQ:            4,
-       OLT:            4,
-       OLE:            4,
-       OGE:            4,
-       OGT:            4,
-       ONE:            4,
-       OSEND:          3,
-       OANDAND:        2,
-       OOROR:          1,
-
-       // Statements handled by stmtfmt
-       OAS:         -1,
-       OAS2:        -1,
-       OAS2DOTTYPE: -1,
-       OAS2FUNC:    -1,
-       OAS2MAPR:    -1,
-       OAS2RECV:    -1,
-       OASOP:       -1,
-       OBREAK:      -1,
-       OCASE:       -1,
-       OCONTINUE:   -1,
-       ODCL:        -1,
-       ODCLFIELD:   -1,
-       ODEFER:      -1,
-       OEMPTY:      -1,
-       OFALL:       -1,
-       OFOR:        -1,
-       OFORUNTIL:   -1,
-       OGOTO:       -1,
-       OIF:         -1,
-       OLABEL:      -1,
-       OGO:         -1,
-       ORANGE:      -1,
-       ORETURN:     -1,
-       OSELECT:     -1,
-       OSWITCH:     -1,
-
-       OEND: 0,
-}
-
-func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
-       for n != nil && n.Implicit() && (n.Op == ODEREF || n.Op == OADDR) {
-               n = n.Left
-       }
-
-       if n == nil {
-               fmt.Fprint(s, "<N>")
-               return
-       }
-
-       nprec := opprec[n.Op]
-       if n.Op == OTYPE && n.Sym != nil {
-               nprec = 8
-       }
-
-       if prec > nprec {
-               mode.Fprintf(s, "(%v)", n)
-               return
-       }
-
-       switch n.Op {
-       case OPAREN:
-               mode.Fprintf(s, "(%v)", n.Left)
-
-       case OLITERAL: // this is a bit of a mess
-               if mode == FErr {
-                       if n.Orig != nil && n.Orig != n {
-                               n.Orig.exprfmt(s, prec, mode)
-                               return
-                       }
-                       if n.Sym != nil {
-                               fmt.Fprint(s, smodeString(n.Sym, mode))
-                               return
-                       }
-               }
-               if n.Val().Ctype() == CTNIL && n.Orig != nil && n.Orig != n {
-                       n.Orig.exprfmt(s, prec, mode)
-                       return
-               }
-               if n.Type != nil && !n.Type.IsUntyped() {
-                       // Need parens when type begins with what might
-                       // be misinterpreted as a unary operator: * or <-.
-                       if n.Type.IsPtr() || (n.Type.IsChan() && n.Type.ChanDir() == types.Crecv) {
-                               mode.Fprintf(s, "(%v)(%v)", n.Type, n.Val())
-                               return
-                       } else {
-                               mode.Fprintf(s, "%v(%v)", n.Type, n.Val())
-                               return
-                       }
-               }
-
-               mode.Fprintf(s, "%v", n.Val())
-
-       // Special case: name used as local variable in export.
-       // _ becomes ~b%d internally; print as _ for export
-       case ONAME:
-               if mode == FErr && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' {
-                       fmt.Fprint(s, "_")
-                       return
-               }
-               fallthrough
-       case OPACK, ONONAME:
-               fmt.Fprint(s, smodeString(n.Sym, mode))
-
-       case OTYPE:
-               if n.Type == nil && n.Sym != nil {
-                       fmt.Fprint(s, smodeString(n.Sym, mode))
-                       return
-               }
-               mode.Fprintf(s, "%v", n.Type)
-
-       case OTARRAY:
-               if n.Left != nil {
-                       mode.Fprintf(s, "[%v]%v", n.Left, n.Right)
-                       return
-               }
-               mode.Fprintf(s, "[]%v", n.Right) // happens before typecheck
-
-       case OTMAP:
-               mode.Fprintf(s, "map[%v]%v", n.Left, n.Right)
-
-       case OTCHAN:
-               switch n.TChanDir() {
-               case types.Crecv:
-                       mode.Fprintf(s, "<-chan %v", n.Left)
-
-               case types.Csend:
-                       mode.Fprintf(s, "chan<- %v", n.Left)
-
-               default:
-                       if n.Left != nil && n.Left.Op == OTCHAN && n.Left.Sym == nil && n.Left.TChanDir() == types.Crecv {
-                               mode.Fprintf(s, "chan (%v)", n.Left)
-                       } else {
-                               mode.Fprintf(s, "chan %v", n.Left)
-                       }
-               }
-
-       case OTSTRUCT:
-               fmt.Fprint(s, "<struct>")
-
-       case OTINTER:
-               fmt.Fprint(s, "<inter>")
-
-       case OTFUNC:
-               fmt.Fprint(s, "<func>")
-
-       case OCLOSURE:
-               if mode == FErr {
-                       fmt.Fprint(s, "func literal")
-                       return
-               }
-               if n.Nbody.Len() != 0 {
-                       mode.Fprintf(s, "%v { %v }", n.Type, n.Nbody)
-                       return
-               }
-               mode.Fprintf(s, "%v { %v }", n.Type, n.Func.Closure.Nbody)
-
-       case OCOMPLIT:
-               if mode == FErr {
-                       if n.Implicit() {
-                               mode.Fprintf(s, "... argument")
-                               return
-                       }
-                       if n.Right != nil {
-                               mode.Fprintf(s, "%v{%s}", n.Right, ellipsisIf(n.List.Len() != 0))
-                               return
-                       }
-
-                       fmt.Fprint(s, "composite literal")
-                       return
-               }
-               mode.Fprintf(s, "(%v{ %.v })", n.Right, n.List)
-
-       case OPTRLIT:
-               mode.Fprintf(s, "&%v", n.Left)
-
-       case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
-               if mode == FErr {
-                       mode.Fprintf(s, "%v{%s}", n.Type, ellipsisIf(n.List.Len() != 0))
-                       return
-               }
-               mode.Fprintf(s, "(%v{ %.v })", n.Type, n.List)
-
-       case OKEY:
-               if n.Left != nil && n.Right != nil {
-                       mode.Fprintf(s, "%v:%v", n.Left, n.Right)
-                       return
-               }
-
-               if n.Left == nil && n.Right != nil {
-                       mode.Fprintf(s, ":%v", n.Right)
-                       return
-               }
-               if n.Left != nil && n.Right == nil {
-                       mode.Fprintf(s, "%v:", n.Left)
-                       return
-               }
-               fmt.Fprint(s, ":")
-
-       case OSTRUCTKEY:
-               mode.Fprintf(s, "%v:%v", n.Sym, n.Left)
-
-       case OCALLPART:
-               n.Left.exprfmt(s, nprec, mode)
-               if n.Right == nil || n.Right.Sym == nil {
-                       fmt.Fprint(s, ".<nil>")
-                       return
-               }
-               mode.Fprintf(s, ".%0S", n.Right.Sym)
-
-       case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-               n.Left.exprfmt(s, nprec, mode)
-               if n.Sym == nil {
-                       fmt.Fprint(s, ".<nil>")
-                       return
-               }
-               mode.Fprintf(s, ".%0S", n.Sym)
-
-       case ODOTTYPE, ODOTTYPE2:
-               n.Left.exprfmt(s, nprec, mode)
-               if n.Right != nil {
-                       mode.Fprintf(s, ".(%v)", n.Right)
-                       return
-               }
-               mode.Fprintf(s, ".(%v)", n.Type)
-
-       case OINDEX, OINDEXMAP:
-               n.Left.exprfmt(s, nprec, mode)
-               mode.Fprintf(s, "[%v]", n.Right)
-
-       case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-               n.Left.exprfmt(s, nprec, mode)
-               fmt.Fprint(s, "[")
-               low, high, max := n.SliceBounds()
-               if low != nil {
-                       fmt.Fprint(s, low.modeString(mode))
-               }
-               fmt.Fprint(s, ":")
-               if high != nil {
-                       fmt.Fprint(s, high.modeString(mode))
-               }
-               if n.Op.IsSlice3() {
-                       fmt.Fprint(s, ":")
-                       if max != nil {
-                               fmt.Fprint(s, max.modeString(mode))
-                       }
-               }
-               fmt.Fprint(s, "]")
-
-       case OSLICEHEADER:
-               if n.List.Len() != 2 {
-                       Fatalf("bad OSLICEHEADER list length %d", n.List.Len())
-               }
-               mode.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left, n.List.First(), n.List.Second())
-
-       case OCOMPLEX, OCOPY:
-               if n.Left != nil {
-                       mode.Fprintf(s, "%#v(%v, %v)", n.Op, n.Left, n.Right)
-               } else {
-                       mode.Fprintf(s, "%#v(%.v)", n.Op, n.List)
-               }
-
-       case OCONV,
-               OCONVIFACE,
-               OCONVNOP,
-               OBYTES2STR,
-               ORUNES2STR,
-               OSTR2BYTES,
-               OSTR2RUNES,
-               ORUNESTR:
-               if n.Type == nil || n.Type.Sym == nil {
-                       mode.Fprintf(s, "(%v)", n.Type)
-               } else {
-                       mode.Fprintf(s, "%v", n.Type)
-               }
-               if n.Left != nil {
-                       mode.Fprintf(s, "(%v)", n.Left)
-               } else {
-                       mode.Fprintf(s, "(%.v)", n.List)
-               }
-
-       case OREAL,
-               OIMAG,
-               OAPPEND,
-               OCAP,
-               OCLOSE,
-               ODELETE,
-               OLEN,
-               OMAKE,
-               ONEW,
-               OPANIC,
-               ORECOVER,
-               OALIGNOF,
-               OOFFSETOF,
-               OSIZEOF,
-               OPRINT,
-               OPRINTN:
-               if n.Left != nil {
-                       mode.Fprintf(s, "%#v(%v)", n.Op, n.Left)
-                       return
-               }
-               if n.IsDDD() {
-                       mode.Fprintf(s, "%#v(%.v...)", n.Op, n.List)
-                       return
-               }
-               mode.Fprintf(s, "%#v(%.v)", n.Op, n.List)
-
-       case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
-               n.Left.exprfmt(s, nprec, mode)
-               if n.IsDDD() {
-                       mode.Fprintf(s, "(%.v...)", n.List)
-                       return
-               }
-               mode.Fprintf(s, "(%.v)", n.List)
-
-       case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-               if n.List.Len() != 0 { // pre-typecheck
-                       mode.Fprintf(s, "make(%v, %.v)", n.Type, n.List)
-                       return
-               }
-               if n.Right != nil {
-                       mode.Fprintf(s, "make(%v, %v, %v)", n.Type, n.Left, n.Right)
-                       return
-               }
-               if n.Left != nil && (n.Op == OMAKESLICE || !n.Left.Type.IsUntyped()) {
-                       mode.Fprintf(s, "make(%v, %v)", n.Type, n.Left)
-                       return
-               }
-               mode.Fprintf(s, "make(%v)", n.Type)
-
-       case OMAKESLICECOPY:
-               mode.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type, n.Left, n.Right)
-
-       case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
-               // Unary
-               mode.Fprintf(s, "%#v", n.Op)
-               if n.Left != nil && n.Left.Op == n.Op {
-                       fmt.Fprint(s, " ")
-               }
-               n.Left.exprfmt(s, nprec+1, mode)
-
-               // Binary
-       case OADD,
-               OAND,
-               OANDAND,
-               OANDNOT,
-               ODIV,
-               OEQ,
-               OGE,
-               OGT,
-               OLE,
-               OLT,
-               OLSH,
-               OMOD,
-               OMUL,
-               ONE,
-               OOR,
-               OOROR,
-               ORSH,
-               OSEND,
-               OSUB,
-               OXOR:
-               n.Left.exprfmt(s, nprec, mode)
-               mode.Fprintf(s, " %#v ", n.Op)
-               n.Right.exprfmt(s, nprec+1, mode)
-
-       case OADDSTR:
-               for i, n1 := range n.List.Slice() {
-                       if i != 0 {
-                               fmt.Fprint(s, " + ")
-                       }
-                       n1.exprfmt(s, nprec, mode)
-               }
-       case ODDD:
-               mode.Fprintf(s, "...")
-       default:
-               mode.Fprintf(s, "<node %v>", n.Op)
-       }
-}
-
-func (n *Node) nodefmt(s fmt.State, flag FmtFlag, mode fmtMode) {
-       t := n.Type
-
-       // We almost always want the original.
-       // TODO(gri) Why the special case for OLITERAL?
-       if n.Op != OLITERAL && n.Orig != nil {
-               n = n.Orig
-       }
-
-       if flag&FmtLong != 0 && t != nil {
-               if t.Etype == TNIL {
-                       fmt.Fprint(s, "nil")
-               } else if n.Op == ONAME && n.Name.AutoTemp() {
-                       mode.Fprintf(s, "%v value", t)
-               } else {
-                       mode.Fprintf(s, "%v (type %v)", n, t)
-               }
-               return
-       }
-
-       // TODO inlining produces expressions with ninits. we can't print these yet.
-
-       if opprec[n.Op] < 0 {
-               n.stmtfmt(s, mode)
-               return
-       }
-
-       n.exprfmt(s, 0, mode)
-}
-
-func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
-       recur := flag&FmtShort == 0
-
-       if recur {
-               indent(s)
-               if dumpdepth > 40 {
-                       fmt.Fprint(s, "...")
-                       return
-               }
-
-               if n.Ninit.Len() != 0 {
-                       mode.Fprintf(s, "%v-init%v", n.Op, n.Ninit)
-                       indent(s)
-               }
-       }
-
-       switch n.Op {
-       default:
-               mode.Fprintf(s, "%v%j", n.Op, n)
-
-       case OLITERAL:
-               mode.Fprintf(s, "%v-%v%j", n.Op, n.Val(), n)
-
-       case ONAME, ONONAME:
-               if n.Sym != nil {
-                       mode.Fprintf(s, "%v-%v%j", n.Op, n.Sym, n)
-               } else {
-                       mode.Fprintf(s, "%v%j", n.Op, n)
-               }
-               if recur && n.Type == nil && n.Name != nil && n.Name.Param != nil && n.Name.Param.Ntype != nil {
-                       indent(s)
-                       mode.Fprintf(s, "%v-ntype%v", n.Op, n.Name.Param.Ntype)
-               }
-
-       case OASOP:
-               mode.Fprintf(s, "%v-%v%j", n.Op, n.SubOp(), n)
-
-       case OTYPE:
-               mode.Fprintf(s, "%v %v%j type=%v", n.Op, n.Sym, n, n.Type)
-               if recur && n.Type == nil && n.Name != nil && n.Name.Param != nil && n.Name.Param.Ntype != nil {
-                       indent(s)
-                       mode.Fprintf(s, "%v-ntype%v", n.Op, n.Name.Param.Ntype)
-               }
-       }
-
-       if n.Op == OCLOSURE && n.Func.Closure != nil && n.Func.Closure.Func.Nname.Sym != nil {
-               mode.Fprintf(s, " fnName %v", n.Func.Closure.Func.Nname.Sym)
-       }
-       if n.Sym != nil && n.Op != ONAME {
-               mode.Fprintf(s, " %v", n.Sym)
-       }
-
-       if n.Type != nil {
-               mode.Fprintf(s, " %v", n.Type)
-       }
-
-       if recur {
-               if n.Left != nil {
-                       mode.Fprintf(s, "%v", n.Left)
-               }
-               if n.Right != nil {
-                       mode.Fprintf(s, "%v", n.Right)
-               }
-               if n.Func != nil && n.Func.Closure != nil && n.Func.Closure.Nbody.Len() != 0 {
-                       indent(s)
-                       // The function associated with a closure
-                       mode.Fprintf(s, "%v-clofunc%v", n.Op, n.Func.Closure)
-               }
-               if n.Func != nil && n.Func.Dcl != nil && len(n.Func.Dcl) != 0 {
-                       indent(s)
-                       // The dcls for a func or closure
-                       mode.Fprintf(s, "%v-dcl%v", n.Op, asNodes(n.Func.Dcl))
-               }
-               if n.List.Len() != 0 {
-                       indent(s)
-                       mode.Fprintf(s, "%v-list%v", n.Op, n.List)
-               }
-
-               if n.Rlist.Len() != 0 {
-                       indent(s)
-                       mode.Fprintf(s, "%v-rlist%v", n.Op, n.Rlist)
-               }
-
-               if n.Nbody.Len() != 0 {
-                       indent(s)
-                       mode.Fprintf(s, "%v-body%v", n.Op, n.Nbody)
-               }
-       }
-}
-
-// "%S" suppresses qualifying with package
-func symFormat(s *types.Sym, f fmt.State, verb rune, mode fmtMode) {
-       switch verb {
-       case 'v', 'S':
-               fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
-
-       default:
-               fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
-       }
-}
-
-func smodeString(s *types.Sym, mode fmtMode) string { return sconv(s, 0, mode) }
-
-// See #16897 before changing the implementation of sconv.
-func sconv(s *types.Sym, flag FmtFlag, mode fmtMode) string {
-       if flag&FmtLong != 0 {
-               panic("linksymfmt")
-       }
-
-       if s == nil {
-               return "<S>"
-       }
-
-       if s.Name == "_" {
-               return "_"
-       }
-       buf := fmtBufferPool.Get().(*bytes.Buffer)
-       buf.Reset()
-       defer fmtBufferPool.Put(buf)
-
-       flag, mode = flag.update(mode)
-       symfmt(buf, s, flag, mode)
-       return types.InternString(buf.Bytes())
-}
-
-func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
-       if flag&FmtLong != 0 {
-               panic("linksymfmt")
-       }
-       if s == nil {
-               b.WriteString("<S>")
-               return
-       }
-       if s.Name == "_" {
-               b.WriteString("_")
-               return
-       }
-
-       flag, mode = flag.update(mode)
-       symfmt(b, s, flag, mode)
-}
-
-func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode fmtMode, visited map[*types.Type]int, funarg types.Funarg) {
-       if f == nil {
-               b.WriteString("<T>")
-               return
-       }
-       flag, mode = flag.update(mode)
-       if mode == FTypeIdName {
-               flag |= FmtUnsigned
-       }
-
-       var name string
-       if flag&FmtShort == 0 {
-               s := f.Sym
-
-               // Take the name from the original.
-               if mode == FErr {
-                       s = origSym(s)
-               }
-
-               if s != nil && f.Embedded == 0 {
-                       if funarg != types.FunargNone {
-                               name = asNode(f.Nname).modeString(mode)
-                       } else if flag&FmtLong != 0 {
-                               name = mode.Sprintf("%0S", s)
-                               if !types.IsExported(name) && flag&FmtUnsigned == 0 {
-                                       name = smodeString(s, mode) // qualify non-exported names (used on structs, not on funarg)
-                               }
-                       } else {
-                               name = smodeString(s, mode)
-                       }
-               }
-       }
-
-       if name != "" {
-               b.WriteString(name)
-               b.WriteString(" ")
-       }
-
-       if f.IsDDD() {
-               var et *types.Type
-               if f.Type != nil {
-                       et = f.Type.Elem()
-               }
-               b.WriteString("...")
-               tconv2(b, et, 0, mode, visited)
-       } else {
-               tconv2(b, f.Type, 0, mode, visited)
-       }
-
-       if flag&FmtShort == 0 && funarg == types.FunargNone && f.Note != "" {
-               b.WriteString(" ")
-               b.WriteString(strconv.Quote(f.Note))
-       }
-}
-
-// "%L"  print definition, not name
-// "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *types.Type, s fmt.State, verb rune, mode fmtMode) {
-       switch verb {
-       case 'v', 'S', 'L':
-               fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
-       default:
-               fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
-       }
-}
-
-func (n *Node) String() string                 { return fmt.Sprint(n) }
-func (n *Node) modeString(mode fmtMode) string { return mode.Sprint(n) }
-
-// "%L"  suffix with "(type %T)" where possible
-// "%+S" in debug mode, don't recurse, no multiline output
-func (n *Node) nconv(s fmt.State, flag FmtFlag, mode fmtMode) {
-       if n == nil {
-               fmt.Fprint(s, "<N>")
-               return
-       }
-
-       flag, mode = flag.update(mode)
-
-       switch mode {
-       case FErr:
-               n.nodefmt(s, flag, mode)
-
-       case FDbg:
-               dumpdepth++
-               n.nodedump(s, flag, mode)
-               dumpdepth--
-
-       default:
-               Fatalf("unhandled %%N mode: %d", mode)
-       }
-}
-
-func (l Nodes) format(s fmt.State, verb rune, mode fmtMode) {
-       switch verb {
-       case 'v':
-               l.hconv(s, fmtFlag(s, verb), mode)
-
-       default:
-               fmt.Fprintf(s, "%%!%c(Nodes)", verb)
-       }
-}
-
-func (n Nodes) String() string {
-       return fmt.Sprint(n)
-}
-
-// Flags: all those of %N plus '.': separate with comma's instead of semicolons.
-func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode fmtMode) {
-       if l.Len() == 0 && mode == FDbg {
-               fmt.Fprint(s, "<nil>")
-               return
-       }
-
-       flag, mode = flag.update(mode)
-       sep := "; "
-       if mode == FDbg {
-               sep = "\n"
-       } else if flag&FmtComma != 0 {
-               sep = ", "
-       }
-
-       for i, n := range l.Slice() {
-               fmt.Fprint(s, n.modeString(mode))
-               if i+1 < l.Len() {
-                       fmt.Fprint(s, sep)
-               }
-       }
-}
-
-func dumplist(s string, l Nodes) {
-       fmt.Printf("%s%+v\n", s, l)
-}
-
-func fdumplist(w io.Writer, s string, l Nodes) {
-       fmt.Fprintf(w, "%s%+v\n", s, l)
-}
-
-func Dump(s string, n *Node) {
-       fmt.Printf("%s [%p]%+v\n", s, n, n)
-}
-
-// TODO(gri) make variable local somehow
-var dumpdepth int
-
-// indent prints indentation to s.
-func indent(s fmt.State) {
-       fmt.Fprint(s, "\n")
-       for i := 0; i < dumpdepth; i++ {
-               fmt.Fprint(s, ".   ")
-       }
-}
-
-func ellipsisIf(b bool) string {
-       if b {
-               return "..."
-       }
-       return ""
-}

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
deleted file mode 100644 (file)
index 929653e..0000000
--- a/src/cmd/compile/internal/gc/gen.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/src"
-       "strconv"
-)
-
-// sysfunc looks up Go function name in package runtime. This function
-// must follow the internal calling convention.
-func sysfunc(name string) *obj.LSym {
-       s := Runtimepkg.Lookup(name)
-       s.SetFunc(true)
-       return s.Linksym()
-}
-
-// sysvar looks up a variable (or assembly function) name in package
-// runtime. If this is a function, it may have a special calling
-// convention.
-func sysvar(name string) *obj.LSym {
-       return Runtimepkg.Lookup(name).Linksym()
-}
-
-// isParamStackCopy reports whether this is the on-stack copy of a
-// function parameter that moved to the heap.
-func (n *Node) isParamStackCopy() bool {
-       return n.Op == ONAME && (n.Class() == PPARAM || n.Class() == PPARAMOUT) && n.Name.Param.Heapaddr != nil
-}
-
-// isParamHeapCopy reports whether this is the on-heap copy of
-// a function parameter that moved to the heap.
-func (n *Node) isParamHeapCopy() bool {
-       return n.Op == ONAME && n.Class() == PAUTOHEAP && n.Name.Param.Stackcopy != nil
-}
-
-// autotmpname returns the name for an autotmp variable numbered n.
-func autotmpname(n int) string {
-       // Give each tmp a different name so that they can be registerized.
-       // Add a preceding . to avoid clashing with legal names.
-       const prefix = ".autotmp_"
-       // Start with a buffer big enough to hold a large n.
-       b := []byte(prefix + "      ")[:len(prefix)]
-       b = strconv.AppendInt(b, int64(n), 10)
-       return types.InternString(b)
-}
-
-// make a new Node off the books
-func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
-       if curfn == nil {
-               Fatalf("no curfn for tempAt")
-       }
-       if curfn.Func.Closure != nil && curfn.Op == OCLOSURE {
-               Dump("tempAt", curfn)
-               Fatalf("adding tempAt to wrong closure function")
-       }
-       if t == nil {
-               Fatalf("tempAt called with nil type")
-       }
-
-       s := &types.Sym{
-               Name: autotmpname(len(curfn.Func.Dcl)),
-               Pkg:  localpkg,
-       }
-       n := newnamel(pos, s)
-       s.Def = asTypesNode(n)
-       n.Type = t
-       n.SetClass(PAUTO)
-       n.Esc = EscNever
-       n.Name.Curfn = curfn
-       n.Name.SetUsed(true)
-       n.Name.SetAutoTemp(true)
-       curfn.Func.Dcl = append(curfn.Func.Dcl, n)
-
-       dowidth(t)
-
-       return n.Orig
-}
-
-func temp(t *types.Type) *Node {
-       return tempAt(lineno, Curfn, t)
-}

diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
deleted file mode 100644 (file)
index 274930b..0000000
--- a/src/cmd/compile/internal/gc/go.go
+++ /dev/null
@@ -1,349 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/ssa"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/src"
-       "sync"
-)
-
-const (
-       BADWIDTH = types.BADWIDTH
-)
-
-var (
-       // maximum size variable which we will allocate on the stack.
-       // This limit is for explicit variable declarations like "var x T" or "x := ...".
-       // Note: the flag smallframes can update this value.
-       maxStackVarSize = int64(10 * 1024 * 1024)
-
-       // maximum size of implicit variables that we will allocate on the stack.
-       //   p := new(T)          allocating T on the stack
-       //   p := &T{}            allocating T on the stack
-       //   s := make([]T, n)    allocating [n]T on the stack
-       //   s := []byte("...")   allocating [n]byte on the stack
-       // Note: the flag smallframes can update this value.
-       maxImplicitStackVarSize = int64(64 * 1024)
-
-       // smallArrayBytes is the maximum size of an array which is considered small.
-       // Small arrays will be initialized directly with a sequence of constant stores.
-       // Large arrays will be initialized by copying from a static temp.
-       // 256 bytes was chosen to minimize generated code + statictmp size.
-       smallArrayBytes = int64(256)
-)
-
-// isRuntimePkg reports whether p is package runtime.
-func isRuntimePkg(p *types.Pkg) bool {
-       if compiling_runtime && p == localpkg {
-               return true
-       }
-       return p.Path == "runtime"
-}
-
-// isReflectPkg reports whether p is package reflect.
-func isReflectPkg(p *types.Pkg) bool {
-       if p == localpkg {
-               return myimportpath == "reflect"
-       }
-       return p.Path == "reflect"
-}
-
-// The Class of a variable/function describes the "storage class"
-// of a variable or function. During parsing, storage classes are
-// called declaration contexts.
-type Class uint8
-
-//go:generate stringer -type=Class
-const (
-       Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
-       PEXTERN                // global variables
-       PAUTO                  // local variables
-       PAUTOHEAP              // local variables or parameters moved to heap
-       PPARAM                 // input arguments
-       PPARAMOUT              // output results
-       PFUNC                  // global functions
-
-       // Careful: Class is stored in three bits in Node.flags.
-       _ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
-)
-
-// Slices in the runtime are represented by three components:
-//
-// type slice struct {
-//     ptr unsafe.Pointer
-//     len int
-//     cap int
-// }
-//
-// Strings in the runtime are represented by two components:
-//
-// type string struct {
-//     ptr unsafe.Pointer
-//     len int
-// }
-//
-// These variables are the offsets of fields and sizes of these structs.
-var (
-       slicePtrOffset int64
-       sliceLenOffset int64
-       sliceCapOffset int64
-
-       sizeofSlice  int64
-       sizeofString int64
-)
-
-var pragcgobuf [][]string
-
-var outfile string
-var linkobj string
-
-// nerrors is the number of compiler errors reported
-// since the last call to saveerrors.
-var nerrors int
-
-// nsavederrors is the total number of compiler errors
-// reported before the last call to saveerrors.
-var nsavederrors int
-
-var nsyntaxerrors int
-
-var decldepth int32
-
-var nolocalimports bool
-
-// gc debug flags
-type DebugFlags struct {
-       P, B, C, E,
-       K, L, N, S,
-       W, e, h, j,
-       l, m, r, w int
-}
-
-var Debug DebugFlags
-
-var debugstr string
-
-var Debug_checknil int
-var Debug_typeassert int
-
-var localpkg *types.Pkg // package being compiled
-
-var inimport bool // set during import
-
-var itabpkg *types.Pkg // fake pkg for itab entries
-
-var itablinkpkg *types.Pkg // fake package for runtime itab entries
-
-var Runtimepkg *types.Pkg // fake package runtime
-
-var racepkg *types.Pkg // package runtime/race
-
-var msanpkg *types.Pkg // package runtime/msan
-
-var unsafepkg *types.Pkg // package unsafe
-
-var trackpkg *types.Pkg // fake package for field tracking
-
-var mappkg *types.Pkg // fake package for map zero value
-
-var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver types
-
-var zerosize int64
-
-var myimportpath string
-
-var localimport string
-
-var asmhdr string
-
-var simtype [NTYPE]types.EType
-
-var (
-       isInt     [NTYPE]bool
-       isFloat   [NTYPE]bool
-       isComplex [NTYPE]bool
-       issimple  [NTYPE]bool
-)
-
-var (
-       okforeq    [NTYPE]bool
-       okforadd   [NTYPE]bool
-       okforand   [NTYPE]bool
-       okfornone  [NTYPE]bool
-       okforcmp   [NTYPE]bool
-       okforbool  [NTYPE]bool
-       okforcap   [NTYPE]bool
-       okforlen   [NTYPE]bool
-       okforarith [NTYPE]bool
-       okforconst [NTYPE]bool
-)
-
-var (
-       okfor [OEND][]bool
-       iscmp [OEND]bool
-)
-
-var minintval [NTYPE]*Mpint
-
-var maxintval [NTYPE]*Mpint
-
-var minfltval [NTYPE]*Mpflt
-
-var maxfltval [NTYPE]*Mpflt
-
-var xtop []*Node
-
-var exportlist []*Node
-
-var importlist []*Node // imported functions and methods with inlinable bodies
-
-var (
-       funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
-       funcsyms   []*types.Sym
-)
-
-var dclcontext Class // PEXTERN/PAUTO
-
-var Curfn *Node
-
-var Widthptr int
-
-var Widthreg int
-
-var nblank *Node
-
-var typecheckok bool
-
-var compiling_runtime bool
-
-// Compiling the standard library
-var compiling_std bool
-
-var use_writebarrier bool
-
-var pure_go bool
-
-var flag_installsuffix string
-
-var flag_race bool
-
-var flag_msan bool
-
-var flagDWARF bool
-
-// Whether we are adding any sort of code instrumentation, such as
-// when the race detector is enabled.
-var instrumenting bool
-
-// Whether we are tracking lexical scopes for DWARF.
-var trackScopes bool
-
-// Controls generation of DWARF inlined instance records. Zero
-// disables, 1 emits inlined routines but suppresses var info,
-// and 2 emits inlined routines with tracking of formals/locals.
-var genDwarfInline int
-
-var debuglive int
-
-var Ctxt *obj.Link
-
-var writearchive bool
-
-var nodfp *Node
-
-var disable_checknil int
-
-var autogeneratedPos src.XPos
-
-// interface to back end
-
-type Arch struct {
-       LinkArch *obj.LinkArch
-
-       REGSP     int
-       MAXWIDTH  int64
-       SoftFloat bool
-
-       PadFrame func(int64) int64
-
-       // ZeroRange zeroes a range of memory on stack. It is only inserted
-       // at function entry, and it is ok to clobber registers.
-       ZeroRange func(*Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog
-
-       Ginsnop      func(*Progs) *obj.Prog
-       Ginsnopdefer func(*Progs) *obj.Prog // special ginsnop for deferreturn
-
-       // SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
-       SSAMarkMoves func(*SSAGenState, *ssa.Block)
-
-       // SSAGenValue emits Prog(s) for the Value.
-       SSAGenValue func(*SSAGenState, *ssa.Value)
-
-       // SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
-       // for all values in the block before SSAGenBlock.
-       SSAGenBlock func(s *SSAGenState, b, next *ssa.Block)
-}
-
-var thearch Arch
-
-var (
-       staticuint64s,
-       zerobase *Node
-
-       assertE2I,
-       assertE2I2,
-       assertI2I,
-       assertI2I2,
-       deferproc,
-       deferprocStack,
-       Deferreturn,
-       Duffcopy,
-       Duffzero,
-       gcWriteBarrier,
-       goschedguarded,
-       growslice,
-       msanread,
-       msanwrite,
-       msanmove,
-       newobject,
-       newproc,
-       panicdivide,
-       panicshift,
-       panicdottypeE,
-       panicdottypeI,
-       panicnildottype,
-       panicoverflow,
-       raceread,
-       racereadrange,
-       racewrite,
-       racewriterange,
-       x86HasPOPCNT,
-       x86HasSSE41,
-       x86HasFMA,
-       armHasVFPv4,
-       arm64HasATOMICS,
-       typedmemclr,
-       typedmemmove,
-       Udiv,
-       writeBarrier,
-       zerobaseSym *obj.LSym
-
-       BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
-       ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
-
-       // Wasm
-       WasmMove,
-       WasmZero,
-       WasmDiv,
-       WasmTruncS,
-       WasmTruncU,
-       SigPanic *obj.LSym
-)
-
-// GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
-var GCWriteBarrierReg map[int16]*obj.LSym

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
deleted file mode 100644 (file)
index d599a38..0000000
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ /dev/null
@@ -1,333 +0,0 @@
-// Derived from Inferno utils/6c/txt.c
-// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/txt.c
-//
-//     Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//     Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//     Portions Copyright © 1997-1999 Vita Nuova Limited
-//     Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
-//     Portions Copyright © 2004,2006 Bruce Ellis
-//     Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//     Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
-//     Portions Copyright © 2009 The Go Authors. All rights reserved.
-//
-// 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 gc
-
-import (
-       "cmd/compile/internal/ssa"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
-)
-
-var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839
-
-// Progs accumulates Progs for a function and converts them into machine code.
-type Progs struct {
-       Text      *obj.Prog  // ATEXT Prog for this function
-       next      *obj.Prog  // next Prog
-       pc        int64      // virtual PC; count of Progs
-       pos       src.XPos   // position to use for new Progs
-       curfn     *Node      // fn these Progs are for
-       progcache []obj.Prog // local progcache
-       cacheidx  int        // first free element of progcache
-
-       nextLive LivenessIndex // liveness index for the next Prog
-       prevLive LivenessIndex // last emitted liveness index
-}
-
-// newProgs returns a new Progs for fn.
-// worker indicates which of the backend workers will use the Progs.
-func newProgs(fn *Node, worker int) *Progs {
-       pp := new(Progs)
-       if Ctxt.CanReuseProgs() {
-               sz := len(sharedProgArray) / nBackendWorkers
-               pp.progcache = sharedProgArray[sz*worker : sz*(worker+1)]
-       }
-       pp.curfn = fn
-
-       // prime the pump
-       pp.next = pp.NewProg()
-       pp.clearp(pp.next)
-
-       pp.pos = fn.Pos
-       pp.settext(fn)
-       // PCDATA tables implicitly start with index -1.
-       pp.prevLive = LivenessIndex{-1, false}
-       pp.nextLive = pp.prevLive
-       return pp
-}
-
-func (pp *Progs) NewProg() *obj.Prog {
-       var p *obj.Prog
-       if pp.cacheidx < len(pp.progcache) {
-               p = &pp.progcache[pp.cacheidx]
-               pp.cacheidx++
-       } else {
-               p = new(obj.Prog)
-       }
-       p.Ctxt = Ctxt
-       return p
-}
-
-// Flush converts from pp to machine code.
-func (pp *Progs) Flush() {
-       plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.curfn}
-       obj.Flushplist(Ctxt, plist, pp.NewProg, myimportpath)
-}
-
-// Free clears pp and any associated resources.
-func (pp *Progs) Free() {
-       if Ctxt.CanReuseProgs() {
-               // Clear progs to enable GC and avoid abuse.
-               s := pp.progcache[:pp.cacheidx]
-               for i := range s {
-                       s[i] = obj.Prog{}
-               }
-       }
-       // Clear pp to avoid abuse.
-       *pp = Progs{}
-}
-
-// Prog adds a Prog with instruction As to pp.
-func (pp *Progs) Prog(as obj.As) *obj.Prog {
-       if pp.nextLive.StackMapValid() && pp.nextLive.stackMapIndex != pp.prevLive.stackMapIndex {
-               // Emit stack map index change.
-               idx := pp.nextLive.stackMapIndex
-               pp.prevLive.stackMapIndex = idx
-               p := pp.Prog(obj.APCDATA)
-               Addrconst(&p.From, objabi.PCDATA_StackMapIndex)
-               Addrconst(&p.To, int64(idx))
-       }
-       if pp.nextLive.isUnsafePoint != pp.prevLive.isUnsafePoint {
-               // Emit unsafe-point marker.
-               pp.prevLive.isUnsafePoint = pp.nextLive.isUnsafePoint
-               p := pp.Prog(obj.APCDATA)
-               Addrconst(&p.From, objabi.PCDATA_UnsafePoint)
-               if pp.nextLive.isUnsafePoint {
-                       Addrconst(&p.To, objabi.PCDATA_UnsafePointUnsafe)
-               } else {
-                       Addrconst(&p.To, objabi.PCDATA_UnsafePointSafe)
-               }
-       }
-
-       p := pp.next
-       pp.next = pp.NewProg()
-       pp.clearp(pp.next)
-       p.Link = pp.next
-
-       if !pp.pos.IsKnown() && Debug.K != 0 {
-               Warn("prog: unknown position (line 0)")
-       }
-
-       p.As = as
-       p.Pos = pp.pos
-       if pp.pos.IsStmt() == src.PosIsStmt {
-               // Clear IsStmt for later Progs at this pos provided that as can be marked as a stmt
-               if ssa.LosesStmtMark(as) {
-                       return p
-               }
-               pp.pos = pp.pos.WithNotStmt()
-       }
-       return p
-}
-
-func (pp *Progs) clearp(p *obj.Prog) {
-       obj.Nopout(p)
-       p.As = obj.AEND
-       p.Pc = pp.pc
-       pp.pc++
-}
-
-func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16, foffset int64, ttype obj.AddrType, treg int16, toffset int64) *obj.Prog {
-       q := pp.NewProg()
-       pp.clearp(q)
-       q.As = as
-       q.Pos = p.Pos
-       q.From.Type = ftype
-       q.From.Reg = freg
-       q.From.Offset = foffset
-       q.To.Type = ttype
-       q.To.Reg = treg
-       q.To.Offset = toffset
-       q.Link = p.Link
-       p.Link = q
-       return q
-}
-
-func (pp *Progs) settext(fn *Node) {
-       if pp.Text != nil {
-               Fatalf("Progs.settext called twice")
-       }
-       ptxt := pp.Prog(obj.ATEXT)
-       pp.Text = ptxt
-
-       fn.Func.lsym.Func().Text = ptxt
-       ptxt.From.Type = obj.TYPE_MEM
-       ptxt.From.Name = obj.NAME_EXTERN
-       ptxt.From.Sym = fn.Func.lsym
-}
-
-// initLSym defines f's obj.LSym and initializes it based on the
-// properties of f. This includes setting the symbol flags and ABI and
-// creating and initializing related DWARF symbols.
-//
-// initLSym must be called exactly once per function and must be
-// called for both functions with bodies and functions without bodies.
-func (f *Func) initLSym(hasBody bool) {
-       if f.lsym != nil {
-               Fatalf("Func.initLSym called twice")
-       }
-
-       if nam := f.Nname; !nam.isBlank() {
-               f.lsym = nam.Sym.Linksym()
-               if f.Pragma&Systemstack != 0 {
-                       f.lsym.Set(obj.AttrCFunc, true)
-               }
-
-               var aliasABI obj.ABI
-               needABIAlias := false
-               defABI, hasDefABI := symabiDefs[f.lsym.Name]
-               if hasDefABI && defABI == obj.ABI0 {
-                       // Symbol is defined as ABI0. Create an
-                       // Internal -> ABI0 wrapper.
-                       f.lsym.SetABI(obj.ABI0)
-                       needABIAlias, aliasABI = true, obj.ABIInternal
-               } else {
-                       // No ABI override. Check that the symbol is
-                       // using the expected ABI.
-                       want := obj.ABIInternal
-                       if f.lsym.ABI() != want {
-                               Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.lsym.Name, f.lsym.ABI(), want)
-                       }
-               }
-
-               isLinknameExported := nam.Sym.Linkname != "" && (hasBody || hasDefABI)
-               if abi, ok := symabiRefs[f.lsym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
-                       // Either 1) this symbol is definitely
-                       // referenced as ABI0 from this package; or 2)
-                       // this symbol is defined in this package but
-                       // given a linkname, indicating that it may be
-                       // referenced from another package. Create an
-                       // ABI0 -> Internal wrapper so it can be
-                       // called as ABI0. In case 2, it's important
-                       // that we know it's defined in this package
-                       // since other packages may "pull" symbols
-                       // using linkname and we don't want to create
-                       // duplicate ABI wrappers.
-                       if f.lsym.ABI() != obj.ABI0 {
-                               needABIAlias, aliasABI = true, obj.ABI0
-                       }
-               }
-
-               if needABIAlias {
-                       // These LSyms have the same name as the
-                       // native function, so we create them directly
-                       // rather than looking them up. The uniqueness
-                       // of f.lsym ensures uniqueness of asym.
-                       asym := &obj.LSym{
-                               Name: f.lsym.Name,
-                               Type: objabi.SABIALIAS,
-                               R:    []obj.Reloc{{Sym: f.lsym}}, // 0 size, so "informational"
-                       }
-                       asym.SetABI(aliasABI)
-                       asym.Set(obj.AttrDuplicateOK, true)
-                       Ctxt.ABIAliases = append(Ctxt.ABIAliases, asym)
-               }
-       }
-
-       if !hasBody {
-               // For body-less functions, we only create the LSym.
-               return
-       }
-
-       var flag int
-       if f.Dupok() {
-               flag |= obj.DUPOK
-       }
-       if f.Wrapper() {
-               flag |= obj.WRAPPER
-       }
-       if f.Needctxt() {
-               flag |= obj.NEEDCTXT
-       }
-       if f.Pragma&Nosplit != 0 {
-               flag |= obj.NOSPLIT
-       }
-       if f.ReflectMethod() {
-               flag |= obj.REFLECTMETHOD
-       }
-
-       // Clumsy but important.
-       // See test/recover.go for test cases and src/reflect/value.go
-       // for the actual functions being considered.
-       if myimportpath == "reflect" {
-               switch f.Nname.Sym.Name {
-               case "callReflect", "callMethod":
-                       flag |= obj.WRAPPER
-               }
-       }
-
-       Ctxt.InitTextSym(f.lsym, flag)
-}
-
-func ggloblnod(nam *Node) {
-       s := nam.Sym.Linksym()
-       s.Gotype = ngotype(nam).Linksym()
-       flags := 0
-       if nam.Name.Readonly() {
-               flags = obj.RODATA
-       }
-       if nam.Type != nil && !nam.Type.HasPointers() {
-               flags |= obj.NOPTR
-       }
-       Ctxt.Globl(s, nam.Type.Width, flags)
-       if nam.Name.LibfuzzerExtraCounter() {
-               s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
-       }
-       if nam.Sym.Linkname != "" {
-               // Make sure linkname'd symbol is non-package. When a symbol is
-               // both imported and linkname'd, s.Pkg may not set to "_" in
-               // types.Sym.Linksym because LSym already exists. Set it here.
-               s.Pkg = "_"
-       }
-}
-
-func ggloblsym(s *obj.LSym, width int32, flags int16) {
-       if flags&obj.LOCAL != 0 {
-               s.Set(obj.AttrLocal, true)
-               flags &^= obj.LOCAL
-       }
-       Ctxt.Globl(s, int64(width), int(flags))
-}
-
-func Addrconst(a *obj.Addr, v int64) {
-       a.Sym = nil
-       a.Type = obj.TYPE_CONST
-       a.Offset = v
-}
-
-func Patch(p *obj.Prog, to *obj.Prog) {
-       if p.To.Type != obj.TYPE_BRANCH {
-               Fatalf("patch: not a branch")
-       }
-       p.To.SetTarget(to)
-       p.To.Offset = to.Pc
-}

diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
deleted file mode 100644 (file)
index c0114d0..0000000
--- a/src/cmd/compile/internal/gc/iimport.go
+++ /dev/null
@@ -1,1117 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Indexed package import.
-// See iexport.go for the export data format.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/bio"
-       "cmd/internal/goobj"
-       "cmd/internal/obj"
-       "cmd/internal/src"
-       "encoding/binary"
-       "fmt"
-       "io"
-       "math/big"
-       "os"
-       "strings"
-)
-
-// An iimporterAndOffset identifies an importer and an offset within
-// its data section.
-type iimporterAndOffset struct {
-       p   *iimporter
-       off uint64
-}
-
-var (
-       // declImporter maps from imported identifiers to an importer
-       // and offset where that identifier's declaration can be read.
-       declImporter = map[*types.Sym]iimporterAndOffset{}
-
-       // inlineImporter is like declImporter, but for inline bodies
-       // for function and method symbols.
-       inlineImporter = map[*types.Sym]iimporterAndOffset{}
-)
-
-func expandDecl(n *Node) {
-       if n.Op != ONONAME {
-               return
-       }
-
-       r := importReaderFor(n, declImporter)
-       if r == nil {
-               // Can happen if user tries to reference an undeclared name.
-               return
-       }
-
-       r.doDecl(n)
-}
-
-func expandInline(fn *Node) {
-       if fn.Func.Inl.Body != nil {
-               return
-       }
-
-       r := importReaderFor(fn, inlineImporter)
-       if r == nil {
-               Fatalf("missing import reader for %v", fn)
-       }
-
-       r.doInline(fn)
-}
-
-func importReaderFor(n *Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
-       x, ok := importers[n.Sym]
-       if !ok {
-               return nil
-       }
-
-       return x.p.newReader(x.off, n.Sym.Pkg)
-}
-
-type intReader struct {
-       *bio.Reader
-       pkg *types.Pkg
-}
-
-func (r *intReader) int64() int64 {
-       i, err := binary.ReadVarint(r.Reader)
-       if err != nil {
-               yyerror("import %q: read error: %v", r.pkg.Path, err)
-               errorexit()
-       }
-       return i
-}
-
-func (r *intReader) uint64() uint64 {
-       i, err := binary.ReadUvarint(r.Reader)
-       if err != nil {
-               yyerror("import %q: read error: %v", r.pkg.Path, err)
-               errorexit()
-       }
-       return i
-}
-
-func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType) {
-       ir := &intReader{in, pkg}
-
-       version := ir.uint64()
-       if version != iexportVersion {
-               yyerror("import %q: unknown export format version %d", pkg.Path, version)
-               errorexit()
-       }
-
-       sLen := ir.uint64()
-       dLen := ir.uint64()
-
-       // Map string (and data) section into memory as a single large
-       // string. This reduces heap fragmentation and allows
-       // returning individual substrings very efficiently.
-       data, err := mapFile(in.File(), in.Offset(), int64(sLen+dLen))
-       if err != nil {
-               yyerror("import %q: mapping input: %v", pkg.Path, err)
-               errorexit()
-       }
-       stringData := data[:sLen]
-       declData := data[sLen:]
-
-       in.MustSeek(int64(sLen+dLen), os.SEEK_CUR)
-
-       p := &iimporter{
-               ipkg: pkg,
-
-               pkgCache:     map[uint64]*types.Pkg{},
-               posBaseCache: map[uint64]*src.PosBase{},
-               typCache:     map[uint64]*types.Type{},
-
-               stringData: stringData,
-               declData:   declData,
-       }
-
-       for i, pt := range predeclared() {
-               p.typCache[uint64(i)] = pt
-       }
-
-       // Declaration index.
-       for nPkgs := ir.uint64(); nPkgs > 0; nPkgs-- {
-               pkg := p.pkgAt(ir.uint64())
-               pkgName := p.stringAt(ir.uint64())
-               pkgHeight := int(ir.uint64())
-               if pkg.Name == "" {
-                       pkg.Name = pkgName
-                       pkg.Height = pkgHeight
-                       numImport[pkgName]++
-
-                       // TODO(mdempsky): This belongs somewhere else.
-                       pkg.Lookup("_").Def = asTypesNode(nblank)
-               } else {
-                       if pkg.Name != pkgName {
-                               Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
-                       }
-                       if pkg.Height != pkgHeight {
-                               Fatalf("conflicting package heights %v and %v for path %q", pkg.Height, pkgHeight, pkg.Path)
-                       }
-               }
-
-               for nSyms := ir.uint64(); nSyms > 0; nSyms-- {
-                       s := pkg.Lookup(p.stringAt(ir.uint64()))
-                       off := ir.uint64()
-
-                       if _, ok := declImporter[s]; ok {
-                               continue
-                       }
-                       declImporter[s] = iimporterAndOffset{p, off}
-
-                       // Create stub declaration. If used, this will
-                       // be overwritten by expandDecl.
-                       if s.Def != nil {
-                               Fatalf("unexpected definition for %v: %v", s, asNode(s.Def))
-                       }
-                       s.Def = asTypesNode(npos(src.NoXPos, dclname(s)))
-               }
-       }
-
-       // Inline body index.
-       for nPkgs := ir.uint64(); nPkgs > 0; nPkgs-- {
-               pkg := p.pkgAt(ir.uint64())
-
-               for nSyms := ir.uint64(); nSyms > 0; nSyms-- {
-                       s := pkg.Lookup(p.stringAt(ir.uint64()))
-                       off := ir.uint64()
-
-                       if _, ok := inlineImporter[s]; ok {
-                               continue
-                       }
-                       inlineImporter[s] = iimporterAndOffset{p, off}
-               }
-       }
-
-       // Fingerprint.
-       _, err = io.ReadFull(in, fingerprint[:])
-       if err != nil {
-               yyerror("import %s: error reading fingerprint", pkg.Path)
-               errorexit()
-       }
-       return fingerprint
-}
-
-type iimporter struct {
-       ipkg *types.Pkg
-
-       pkgCache     map[uint64]*types.Pkg
-       posBaseCache map[uint64]*src.PosBase
-       typCache     map[uint64]*types.Type
-
-       stringData string
-       declData   string
-}
-
-func (p *iimporter) stringAt(off uint64) string {
-       var x [binary.MaxVarintLen64]byte
-       n := copy(x[:], p.stringData[off:])
-
-       slen, n := binary.Uvarint(x[:n])
-       if n <= 0 {
-               Fatalf("varint failed")
-       }
-       spos := off + uint64(n)
-       return p.stringData[spos : spos+slen]
-}
-
-func (p *iimporter) posBaseAt(off uint64) *src.PosBase {
-       if posBase, ok := p.posBaseCache[off]; ok {
-               return posBase
-       }
-
-       file := p.stringAt(off)
-       posBase := src.NewFileBase(file, file)
-       p.posBaseCache[off] = posBase
-       return posBase
-}
-
-func (p *iimporter) pkgAt(off uint64) *types.Pkg {
-       if pkg, ok := p.pkgCache[off]; ok {
-               return pkg
-       }
-
-       pkg := p.ipkg
-       if pkgPath := p.stringAt(off); pkgPath != "" {
-               pkg = types.NewPkg(pkgPath, "")
-       }
-       p.pkgCache[off] = pkg
-       return pkg
-}
-
-// An importReader keeps state for reading an individual imported
-// object (declaration or inline body).
-type importReader struct {
-       strings.Reader
-       p *iimporter
-
-       currPkg    *types.Pkg
-       prevBase   *src.PosBase
-       prevLine   int64
-       prevColumn int64
-}
-
-func (p *iimporter) newReader(off uint64, pkg *types.Pkg) *importReader {
-       r := &importReader{
-               p:       p,
-               currPkg: pkg,
-       }
-       // (*strings.Reader).Reset wasn't added until Go 1.7, and we
-       // need to build with Go 1.4.
-       r.Reader = *strings.NewReader(p.declData[off:])
-       return r
-}
-
-func (r *importReader) string() string        { return r.p.stringAt(r.uint64()) }
-func (r *importReader) posBase() *src.PosBase { return r.p.posBaseAt(r.uint64()) }
-func (r *importReader) pkg() *types.Pkg       { return r.p.pkgAt(r.uint64()) }
-
-func (r *importReader) setPkg() {
-       r.currPkg = r.pkg()
-}
-
-func (r *importReader) doDecl(n *Node) {
-       if n.Op != ONONAME {
-               Fatalf("doDecl: unexpected Op for %v: %v", n.Sym, n.Op)
-       }
-
-       tag := r.byte()
-       pos := r.pos()
-
-       switch tag {
-       case 'A':
-               typ := r.typ()
-
-               importalias(r.p.ipkg, pos, n.Sym, typ)
-
-       case 'C':
-               typ, val := r.value()
-
-               importconst(r.p.ipkg, pos, n.Sym, typ, val)
-
-       case 'F':
-               typ := r.signature(nil)
-
-               importfunc(r.p.ipkg, pos, n.Sym, typ)
-               r.funcExt(n)
-
-       case 'T':
-               // Types can be recursive. We need to setup a stub
-               // declaration before recursing.
-               t := importtype(r.p.ipkg, pos, n.Sym)
-
-               // We also need to defer width calculations until
-               // after the underlying type has been assigned.
-               defercheckwidth()
-               underlying := r.typ()
-               setUnderlying(t, underlying)
-               resumecheckwidth()
-
-               if underlying.IsInterface() {
-                       r.typeExt(t)
-                       break
-               }
-
-               ms := make([]*types.Field, r.uint64())
-               for i := range ms {
-                       mpos := r.pos()
-                       msym := r.ident()
-                       recv := r.param()
-                       mtyp := r.signature(recv)
-
-                       f := types.NewField()
-                       f.Pos = mpos
-                       f.Sym = msym
-                       f.Type = mtyp
-                       ms[i] = f
-
-                       m := newfuncnamel(mpos, methodSym(recv.Type, msym))
-                       m.Type = mtyp
-                       m.SetClass(PFUNC)
-                       // methodSym already marked m.Sym as a function.
-
-                       // (comment from parser.go)
-                       // inl.C's inlnode in on a dotmeth node expects to find the inlineable body as
-                       // (dotmeth's type).Nname.Inl, and dotmeth's type has been pulled
-                       // out by typecheck's lookdot as this $$.ttype. So by providing
-                       // this back link here we avoid special casing there.
-                       mtyp.SetNname(asTypesNode(m))
-               }
-               t.Methods().Set(ms)
-
-               r.typeExt(t)
-               for _, m := range ms {
-                       r.methExt(m)
-               }
-
-       case 'V':
-               typ := r.typ()
-
-               importvar(r.p.ipkg, pos, n.Sym, typ)
-               r.varExt(n)
-
-       default:
-               Fatalf("unexpected tag: %v", tag)
-       }
-}
-
-func (p *importReader) value() (typ *types.Type, v Val) {
-       typ = p.typ()
-
-       switch constTypeOf(typ) {
-       case CTNIL:
-               v.U = &NilVal{}
-       case CTBOOL:
-               v.U = p.bool()
-       case CTSTR:
-               v.U = p.string()
-       case CTINT:
-               x := new(Mpint)
-               x.Rune = typ == types.UntypedRune
-               p.mpint(&x.Val, typ)
-               v.U = x
-       case CTFLT:
-               x := newMpflt()
-               p.float(x, typ)
-               v.U = x
-       case CTCPLX:
-               x := newMpcmplx()
-               p.float(&x.Real, typ)
-               p.float(&x.Imag, typ)
-               v.U = x
-       }
-       return
-}
-
-func (p *importReader) mpint(x *big.Int, typ *types.Type) {
-       signed, maxBytes := intSize(typ)
-
-       maxSmall := 256 - maxBytes
-       if signed {
-               maxSmall = 256 - 2*maxBytes
-       }
-       if maxBytes == 1 {
-               maxSmall = 256
-       }
-
-       n, _ := p.ReadByte()
-       if uint(n) < maxSmall {
-               v := int64(n)
-               if signed {
-                       v >>= 1
-                       if n&1 != 0 {
-                               v = ^v
-                       }
-               }
-               x.SetInt64(v)
-               return
-       }
-
-       v := -n
-       if signed {
-               v = -(n &^ 1) >> 1
-       }
-       if v < 1 || uint(v) > maxBytes {
-               Fatalf("weird decoding: %v, %v => %v", n, signed, v)
-       }
-       b := make([]byte, v)
-       p.Read(b)
-       x.SetBytes(b)
-       if signed && n&1 != 0 {
-               x.Neg(x)
-       }
-}
-
-func (p *importReader) float(x *Mpflt, typ *types.Type) {
-       var mant big.Int
-       p.mpint(&mant, typ)
-       m := x.Val.SetInt(&mant)
-       if m.Sign() == 0 {
-               return
-       }
-       m.SetMantExp(m, int(p.int64()))
-}
-
-func (r *importReader) ident() *types.Sym {
-       name := r.string()
-       if name == "" {
-               return nil
-       }
-       pkg := r.currPkg
-       if types.IsExported(name) {
-               pkg = localpkg
-       }
-       return pkg.Lookup(name)
-}
-
-func (r *importReader) qualifiedIdent() *types.Sym {
-       name := r.string()
-       pkg := r.pkg()
-       return pkg.Lookup(name)
-}
-
-func (r *importReader) pos() src.XPos {
-       delta := r.int64()
-       r.prevColumn += delta >> 1
-       if delta&1 != 0 {
-               delta = r.int64()
-               r.prevLine += delta >> 1
-               if delta&1 != 0 {
-                       r.prevBase = r.posBase()
-               }
-       }
-
-       if (r.prevBase == nil || r.prevBase.AbsFilename() == "") && r.prevLine == 0 && r.prevColumn == 0 {
-               // TODO(mdempsky): Remove once we reliably write
-               // position information for all nodes.
-               return src.NoXPos
-       }
-
-       if r.prevBase == nil {
-               Fatalf("missing posbase")
-       }
-       pos := src.MakePos(r.prevBase, uint(r.prevLine), uint(r.prevColumn))
-       return Ctxt.PosTable.XPos(pos)
-}
-
-func (r *importReader) typ() *types.Type {
-       return r.p.typAt(r.uint64())
-}
-
-func (p *iimporter) typAt(off uint64) *types.Type {
-       t, ok := p.typCache[off]
-       if !ok {
-               if off < predeclReserved {
-                       Fatalf("predeclared type missing from cache: %d", off)
-               }
-               t = p.newReader(off-predeclReserved, nil).typ1()
-               p.typCache[off] = t
-       }
-       return t
-}
-
-func (r *importReader) typ1() *types.Type {
-       switch k := r.kind(); k {
-       default:
-               Fatalf("unexpected kind tag in %q: %v", r.p.ipkg.Path, k)
-               return nil
-
-       case definedType:
-               // We might be called from within doInline, in which
-               // case Sym.Def can point to declared parameters
-               // instead of the top-level types. Also, we don't
-               // support inlining functions with local defined
-               // types. Therefore, this must be a package-scope
-               // type.
-               n := asNode(r.qualifiedIdent().PkgDef())
-               if n.Op == ONONAME {
-                       expandDecl(n)
-               }
-               if n.Op != OTYPE {
-                       Fatalf("expected OTYPE, got %v: %v, %v", n.Op, n.Sym, n)
-               }
-               return n.Type
-       case pointerType:
-               return types.NewPtr(r.typ())
-       case sliceType:
-               return types.NewSlice(r.typ())
-       case arrayType:
-               n := r.uint64()
-               return types.NewArray(r.typ(), int64(n))
-       case chanType:
-               dir := types.ChanDir(r.uint64())
-               return types.NewChan(r.typ(), dir)
-       case mapType:
-               return types.NewMap(r.typ(), r.typ())
-
-       case signatureType:
-               r.setPkg()
-               return r.signature(nil)
-
-       case structType:
-               r.setPkg()
-
-               fs := make([]*types.Field, r.uint64())
-               for i := range fs {
-                       pos := r.pos()
-                       sym := r.ident()
-                       typ := r.typ()
-                       emb := r.bool()
-                       note := r.string()
-
-                       f := types.NewField()
-                       f.Pos = pos
-                       f.Sym = sym
-                       f.Type = typ
-                       if emb {
-                               f.Embedded = 1
-                       }
-                       f.Note = note
-                       fs[i] = f
-               }
-
-               t := types.New(TSTRUCT)
-               t.SetPkg(r.currPkg)
-               t.SetFields(fs)
-               return t
-
-       case interfaceType:
-               r.setPkg()
-
-               embeddeds := make([]*types.Field, r.uint64())
-               for i := range embeddeds {
-                       pos := r.pos()
-                       typ := r.typ()
-
-                       f := types.NewField()
-                       f.Pos = pos
-                       f.Type = typ
-                       embeddeds[i] = f
-               }
-
-               methods := make([]*types.Field, r.uint64())
-               for i := range methods {
-                       pos := r.pos()
-                       sym := r.ident()
-                       typ := r.signature(fakeRecvField())
-
-                       f := types.NewField()
-                       f.Pos = pos
-                       f.Sym = sym
-                       f.Type = typ
-                       methods[i] = f
-               }
-
-               t := types.New(TINTER)
-               t.SetPkg(r.currPkg)
-               t.SetInterface(append(embeddeds, methods...))
-
-               // Ensure we expand the interface in the frontend (#25055).
-               checkwidth(t)
-               return t
-       }
-}
-
-func (r *importReader) kind() itag {
-       return itag(r.uint64())
-}
-
-func (r *importReader) signature(recv *types.Field) *types.Type {
-       params := r.paramList()
-       results := r.paramList()
-       if n := len(params); n > 0 {
-               params[n-1].SetIsDDD(r.bool())
-       }
-       t := functypefield(recv, params, results)
-       t.SetPkg(r.currPkg)
-       return t
-}
-
-func (r *importReader) paramList() []*types.Field {
-       fs := make([]*types.Field, r.uint64())
-       for i := range fs {
-               fs[i] = r.param()
-       }
-       return fs
-}
-
-func (r *importReader) param() *types.Field {
-       f := types.NewField()
-       f.Pos = r.pos()
-       f.Sym = r.ident()
-       f.Type = r.typ()
-       return f
-}
-
-func (r *importReader) bool() bool {
-       return r.uint64() != 0
-}
-
-func (r *importReader) int64() int64 {
-       n, err := binary.ReadVarint(r)
-       if err != nil {
-               Fatalf("readVarint: %v", err)
-       }
-       return n
-}
-
-func (r *importReader) uint64() uint64 {
-       n, err := binary.ReadUvarint(r)
-       if err != nil {
-               Fatalf("readVarint: %v", err)
-       }
-       return n
-}
-
-func (r *importReader) byte() byte {
-       x, err := r.ReadByte()
-       if err != nil {
-               Fatalf("declReader.ReadByte: %v", err)
-       }
-       return x
-}
-
-// Compiler-specific extensions.
-
-func (r *importReader) varExt(n *Node) {
-       r.linkname(n.Sym)
-       r.symIdx(n.Sym)
-}
-
-func (r *importReader) funcExt(n *Node) {
-       r.linkname(n.Sym)
-       r.symIdx(n.Sym)
-
-       // Escape analysis.
-       for _, fs := range &types.RecvsParams {
-               for _, f := range fs(n.Type).FieldSlice() {
-                       f.Note = r.string()
-               }
-       }
-
-       // Inline body.
-       if u := r.uint64(); u > 0 {
-               n.Func.Inl = &Inline{
-                       Cost: int32(u - 1),
-               }
-               n.Func.Endlineno = r.pos()
-       }
-}
-
-func (r *importReader) methExt(m *types.Field) {
-       if r.bool() {
-               m.SetNointerface(true)
-       }
-       r.funcExt(asNode(m.Type.Nname()))
-}
-
-func (r *importReader) linkname(s *types.Sym) {
-       s.Linkname = r.string()
-}
-
-func (r *importReader) symIdx(s *types.Sym) {
-       lsym := s.Linksym()
-       idx := int32(r.int64())
-       if idx != -1 {
-               if s.Linkname != "" {
-                       Fatalf("bad index for linknamed symbol: %v %d\n", lsym, idx)
-               }
-               lsym.SymIdx = idx
-               lsym.Set(obj.AttrIndexed, true)
-       }
-}
-
-func (r *importReader) typeExt(t *types.Type) {
-       t.SetNotInHeap(r.bool())
-       i, pi := r.int64(), r.int64()
-       if i != -1 && pi != -1 {
-               typeSymIdx[t] = [2]int64{i, pi}
-       }
-}
-
-// Map imported type T to the index of type descriptor symbols of T and *T,
-// so we can use index to reference the symbol.
-var typeSymIdx = make(map[*types.Type][2]int64)
-
-func (r *importReader) doInline(n *Node) {
-       if len(n.Func.Inl.Body) != 0 {
-               Fatalf("%v already has inline body", n)
-       }
-
-       funchdr(n)
-       body := r.stmtList()
-       funcbody()
-       if body == nil {
-               //
-               // Make sure empty body is not interpreted as
-               // no inlineable body (see also parser.fnbody)
-               // (not doing so can cause significant performance
-               // degradation due to unnecessary calls to empty
-               // functions).
-               body = []*Node{}
-       }
-       n.Func.Inl.Body = body
-
-       importlist = append(importlist, n)
-
-       if Debug.E > 0 && Debug.m > 2 {
-               if Debug.m > 3 {
-                       fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, asNodes(n.Func.Inl.Body))
-               } else {
-                       fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, asNodes(n.Func.Inl.Body))
-               }
-       }
-}
-
-// ----------------------------------------------------------------------------
-// Inlined function bodies
-
-// Approach: Read nodes and use them to create/declare the same data structures
-// as done originally by the (hidden) parser by closely following the parser's
-// original code. In other words, "parsing" the import data (which happens to
-// be encoded in binary rather textual form) is the best way at the moment to
-// re-establish the syntax tree's invariants. At some future point we might be
-// able to avoid this round-about way and create the rewritten nodes directly,
-// possibly avoiding a lot of duplicate work (name resolution, type checking).
-//
-// Refined nodes (e.g., ODOTPTR as a refinement of OXDOT) are exported as their
-// unrefined nodes (since this is what the importer uses). The respective case
-// entries are unreachable in the importer.
-
-func (r *importReader) stmtList() []*Node {
-       var list []*Node
-       for {
-               n := r.node()
-               if n == nil {
-                       break
-               }
-               // OBLOCK nodes may be created when importing ODCL nodes - unpack them
-               if n.Op == OBLOCK {
-                       list = append(list, n.List.Slice()...)
-               } else {
-                       list = append(list, n)
-               }
-
-       }
-       return list
-}
-
-func (r *importReader) caseList(sw *Node) []*Node {
-       namedTypeSwitch := sw.Op == OSWITCH && sw.Left != nil && sw.Left.Op == OTYPESW && sw.Left.Left != nil
-
-       cases := make([]*Node, r.uint64())
-       for i := range cases {
-               cas := nodl(r.pos(), OCASE, nil, nil)
-               cas.List.Set(r.stmtList())
-               if namedTypeSwitch {
-                       // Note: per-case variables will have distinct, dotted
-                       // names after import. That's okay: swt.go only needs
-                       // Sym for diagnostics anyway.
-                       caseVar := newnamel(cas.Pos, r.ident())
-                       declare(caseVar, dclcontext)
-                       cas.Rlist.Set1(caseVar)
-                       caseVar.Name.Defn = sw.Left
-               }
-               cas.Nbody.Set(r.stmtList())
-               cases[i] = cas
-       }
-       return cases
-}
-
-func (r *importReader) exprList() []*Node {
-       var list []*Node
-       for {
-               n := r.expr()
-               if n == nil {
-                       break
-               }
-               list = append(list, n)
-       }
-       return list
-}
-
-func (r *importReader) expr() *Node {
-       n := r.node()
-       if n != nil && n.Op == OBLOCK {
-               Fatalf("unexpected block node: %v", n)
-       }
-       return n
-}
-
-// TODO(gri) split into expr and stmt
-func (r *importReader) node() *Node {
-       switch op := r.op(); op {
-       // expressions
-       // case OPAREN:
-       //      unreachable - unpacked by exporter
-
-       case OLITERAL:
-               pos := r.pos()
-               typ, val := r.value()
-
-               n := npos(pos, nodlit(val))
-               n.Type = typ
-               return n
-
-       case ONONAME:
-               return mkname(r.qualifiedIdent())
-
-       case ONAME:
-               return mkname(r.ident())
-
-       // case OPACK, ONONAME:
-       //      unreachable - should have been resolved by typechecking
-
-       case OTYPE:
-               return typenod(r.typ())
-
-       case OTYPESW:
-               n := nodl(r.pos(), OTYPESW, nil, nil)
-               if s := r.ident(); s != nil {
-                       n.Left = npos(n.Pos, newnoname(s))
-               }
-               n.Right, _ = r.exprsOrNil()
-               return n
-
-       // case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
-       //      unreachable - should have been resolved by typechecking
-
-       // case OCLOSURE:
-       //      unimplemented
-
-       // case OPTRLIT:
-       //      unreachable - mapped to case OADDR below by exporter
-
-       case OSTRUCTLIT:
-               // TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
-               savedlineno := lineno
-               lineno = r.pos()
-               n := nodl(lineno, OCOMPLIT, nil, typenod(r.typ()))
-               n.List.Set(r.elemList()) // special handling of field names
-               lineno = savedlineno
-               return n
-
-       // case OARRAYLIT, OSLICELIT, OMAPLIT:
-       //      unreachable - mapped to case OCOMPLIT below by exporter
-
-       case OCOMPLIT:
-               n := nodl(r.pos(), OCOMPLIT, nil, typenod(r.typ()))
-               n.List.Set(r.exprList())
-               return n
-
-       case OKEY:
-               pos := r.pos()
-               left, right := r.exprsOrNil()
-               return nodl(pos, OKEY, left, right)
-
-       // case OSTRUCTKEY:
-       //      unreachable - handled in case OSTRUCTLIT by elemList
-
-       // case OCALLPART:
-       //      unreachable - mapped to case OXDOT below by exporter
-
-       // case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-       //      unreachable - mapped to case OXDOT below by exporter
-
-       case OXDOT:
-               // see parser.new_dotname
-               return npos(r.pos(), nodSym(OXDOT, r.expr(), r.ident()))
-
-       // case ODOTTYPE, ODOTTYPE2:
-       //      unreachable - mapped to case ODOTTYPE below by exporter
-
-       case ODOTTYPE:
-               n := nodl(r.pos(), ODOTTYPE, r.expr(), nil)
-               n.Type = r.typ()
-               return n
-
-       // case OINDEX, OINDEXMAP, OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-       //      unreachable - mapped to cases below by exporter
-
-       case OINDEX:
-               return nodl(r.pos(), op, r.expr(), r.expr())
-
-       case OSLICE, OSLICE3:
-               n := nodl(r.pos(), op, r.expr(), nil)
-               low, high := r.exprsOrNil()
-               var max *Node
-               if n.Op.IsSlice3() {
-                       max = r.expr()
-               }
-               n.SetSliceBounds(low, high, max)
-               return n
-
-       // case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
-       //      unreachable - mapped to OCONV case below by exporter
-
-       case OCONV:
-               n := nodl(r.pos(), OCONV, r.expr(), nil)
-               n.Type = r.typ()
-               return n
-
-       case OCOPY, OCOMPLEX, OREAL, OIMAG, OAPPEND, OCAP, OCLOSE, ODELETE, OLEN, OMAKE, ONEW, OPANIC, ORECOVER, OPRINT, OPRINTN:
-               n := npos(r.pos(), builtinCall(op))
-               n.List.Set(r.exprList())
-               if op == OAPPEND {
-                       n.SetIsDDD(r.bool())
-               }
-               return n
-
-       // case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
-       //      unreachable - mapped to OCALL case below by exporter
-
-       case OCALL:
-               n := nodl(r.pos(), OCALL, nil, nil)
-               n.Ninit.Set(r.stmtList())
-               n.Left = r.expr()
-               n.List.Set(r.exprList())
-               n.SetIsDDD(r.bool())
-               return n
-
-       case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-               n := npos(r.pos(), builtinCall(OMAKE))
-               n.List.Append(typenod(r.typ()))
-               n.List.Append(r.exprList()...)
-               return n
-
-       // unary expressions
-       case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
-               return nodl(r.pos(), op, r.expr(), nil)
-
-       // binary expressions
-       case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE, OLT,
-               OLSH, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSEND, OSUB, OXOR:
-               return nodl(r.pos(), op, r.expr(), r.expr())
-
-       case OADDSTR:
-               pos := r.pos()
-               list := r.exprList()
-               x := npos(pos, list[0])
-               for _, y := range list[1:] {
-                       x = nodl(pos, OADD, x, y)
-               }
-               return x
-
-       // --------------------------------------------------------------------
-       // statements
-       case ODCL:
-               pos := r.pos()
-               lhs := npos(pos, dclname(r.ident()))
-               typ := typenod(r.typ())
-               return npos(pos, liststmt(variter([]*Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
-
-       // case ODCLFIELD:
-       //      unimplemented
-
-       // case OAS, OASWB:
-       //      unreachable - mapped to OAS case below by exporter
-
-       case OAS:
-               return nodl(r.pos(), OAS, r.expr(), r.expr())
-
-       case OASOP:
-               n := nodl(r.pos(), OASOP, nil, nil)
-               n.SetSubOp(r.op())
-               n.Left = r.expr()
-               if !r.bool() {
-                       n.Right = nodintconst(1)
-                       n.SetImplicit(true)
-               } else {
-                       n.Right = r.expr()
-               }
-               return n
-
-       // case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-       //      unreachable - mapped to OAS2 case below by exporter
-
-       case OAS2:
-               n := nodl(r.pos(), OAS2, nil, nil)
-               n.List.Set(r.exprList())
-               n.Rlist.Set(r.exprList())
-               return n
-
-       case ORETURN:
-               n := nodl(r.pos(), ORETURN, nil, nil)
-               n.List.Set(r.exprList())
-               return n
-
-       // case ORETJMP:
-       //      unreachable - generated by compiler for trampolin routines (not exported)
-
-       case OGO, ODEFER:
-               return nodl(r.pos(), op, r.expr(), nil)
-
-       case OIF:
-               n := nodl(r.pos(), OIF, nil, nil)
-               n.Ninit.Set(r.stmtList())
-               n.Left = r.expr()
-               n.Nbody.Set(r.stmtList())
-               n.Rlist.Set(r.stmtList())
-               return n
-
-       case OFOR:
-               n := nodl(r.pos(), OFOR, nil, nil)
-               n.Ninit.Set(r.stmtList())
-               n.Left, n.Right = r.exprsOrNil()
-               n.Nbody.Set(r.stmtList())
-               return n
-
-       case ORANGE:
-               n := nodl(r.pos(), ORANGE, nil, nil)
-               n.List.Set(r.stmtList())
-               n.Right = r.expr()
-               n.Nbody.Set(r.stmtList())
-               return n
-
-       case OSELECT, OSWITCH:
-               n := nodl(r.pos(), op, nil, nil)
-               n.Ninit.Set(r.stmtList())
-               n.Left, _ = r.exprsOrNil()
-               n.List.Set(r.caseList(n))
-               return n
-
-       // case OCASE:
-       //      handled by caseList
-
-       case OFALL:
-               n := nodl(r.pos(), OFALL, nil, nil)
-               return n
-
-       case OBREAK, OCONTINUE:
-               pos := r.pos()
-               left, _ := r.exprsOrNil()
-               if left != nil {
-                       left = newname(left.Sym)
-               }
-               return nodl(pos, op, left, nil)
-
-       // case OEMPTY:
-       //      unreachable - not emitted by exporter
-
-       case OGOTO, OLABEL:
-               n := nodl(r.pos(), op, nil, nil)
-               n.Sym = lookup(r.string())
-               return n
-
-       case OEND:
-               return nil
-
-       default:
-               Fatalf("cannot import %v (%d) node\n"+
-                       "\t==> please file an issue and assign to gri@", op, int(op))
-               panic("unreachable") // satisfy compiler
-       }
-}
-
-func (r *importReader) op() Op {
-       return Op(r.uint64())
-}
-
-func (r *importReader) elemList() []*Node {
-       c := r.uint64()
-       list := make([]*Node, c)
-       for i := range list {
-               s := r.ident()
-               list[i] = nodSym(OSTRUCTKEY, r.expr(), s)
-       }
-       return list
-}
-
-func (r *importReader) exprsOrNil() (a, b *Node) {
-       ab := r.uint64()
-       if ab&1 != 0 {
-               a = r.expr()
-       }
-       if ab&2 != 0 {
-               b = r.node()
-       }
-       return
-}

diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
deleted file mode 100644 (file)
index ec9cc4b..0000000
--- a/src/cmd/compile/internal/gc/init.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-)
-
-// A function named init is a special case.
-// It is called by the initialization before main is run.
-// To make it unique within a package and also uncallable,
-// the name, normally "pkg.init", is altered to "pkg.init.0".
-var renameinitgen int
-
-// Dummy function for autotmps generated during typechecking.
-var dummyInitFn = nod(ODCLFUNC, nil, nil)
-
-func renameinit() *types.Sym {
-       s := lookupN("init.", renameinitgen)
-       renameinitgen++
-       return s
-}
-
-// fninit makes an initialization record for the package.
-// See runtime/proc.go:initTask for its layout.
-// The 3 tasks for initialization are:
-//   1) Initialize all of the packages the current package depends on.
-//   2) Initialize all the variables that have initializers.
-//   3) Run any init functions.
-func fninit(n []*Node) {
-       nf := initOrder(n)
-
-       var deps []*obj.LSym // initTask records for packages the current package depends on
-       var fns []*obj.LSym  // functions to call for package initialization
-
-       // Find imported packages with init tasks.
-       for _, s := range types.InitSyms {
-               deps = append(deps, s.Linksym())
-       }
-
-       // Make a function that contains all the initialization statements.
-       if len(nf) > 0 {
-               lineno = nf[0].Pos // prolog/epilog gets line number of first init stmt
-               initializers := lookup("init")
-               fn := dclfunc(initializers, nod(OTFUNC, nil, nil))
-               for _, dcl := range dummyInitFn.Func.Dcl {
-                       dcl.Name.Curfn = fn
-               }
-               fn.Func.Dcl = append(fn.Func.Dcl, dummyInitFn.Func.Dcl...)
-               dummyInitFn.Func.Dcl = nil
-
-               fn.Nbody.Set(nf)
-               funcbody()
-
-               fn = typecheck(fn, ctxStmt)
-               Curfn = fn
-               typecheckslice(nf, ctxStmt)
-               Curfn = nil
-               xtop = append(xtop, fn)
-               fns = append(fns, initializers.Linksym())
-       }
-       if dummyInitFn.Func.Dcl != nil {
-               // We only generate temps using dummyInitFn if there
-               // are package-scope initialization statements, so
-               // something's weird if we get here.
-               Fatalf("dummyInitFn still has declarations")
-       }
-       dummyInitFn = nil
-
-       // Record user init functions.
-       for i := 0; i < renameinitgen; i++ {
-               s := lookupN("init.", i)
-               fn := asNode(s.Def).Name.Defn
-               // Skip init functions with empty bodies.
-               if fn.Nbody.Len() == 1 && fn.Nbody.First().Op == OEMPTY {
-                       continue
-               }
-               fns = append(fns, s.Linksym())
-       }
-
-       if len(deps) == 0 && len(fns) == 0 && localpkg.Name != "main" && localpkg.Name != "runtime" {
-               return // nothing to initialize
-       }
-
-       // Make an .inittask structure.
-       sym := lookup(".inittask")
-       nn := newname(sym)
-       nn.Type = types.Types[TUINT8] // dummy type
-       nn.SetClass(PEXTERN)
-       sym.Def = asTypesNode(nn)
-       exportsym(nn)
-       lsym := sym.Linksym()
-       ot := 0
-       ot = duintptr(lsym, ot, 0) // state: not initialized yet
-       ot = duintptr(lsym, ot, uint64(len(deps)))
-       ot = duintptr(lsym, ot, uint64(len(fns)))
-       for _, d := range deps {
-               ot = dsymptr(lsym, ot, d, 0)
-       }
-       for _, f := range fns {
-               ot = dsymptr(lsym, ot, f, 0)
-       }
-       // An initTask has pointers, but none into the Go heap.
-       // It's not quite read only, the state field must be modifiable.
-       ggloblsym(lsym, int32(ot), obj.NOPTR)
-}

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
deleted file mode 100644 (file)
index 4190569..0000000
--- a/src/cmd/compile/internal/gc/inl.go
+++ /dev/null
@@ -1,1495 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-//
-// The inlining facility makes 2 passes: first caninl determines which
-// functions are suitable for inlining, and for those that are it
-// saves a copy of the body. Then inlcalls walks each function body to
-// expand calls to inlinable functions.
-//
-// The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
-// making 1 the default and -l disable. Additional levels (beyond -l) may be buggy and
-// are not supported.
-//      0: disabled
-//      1: 80-nodes leaf functions, oneliners, panic, lazy typechecking (default)
-//      2: (unassigned)
-//      3: (unassigned)
-//      4: allow non-leaf functions
-//
-// At some point this may get another default and become switch-offable with -N.
-//
-// The -d typcheckinl flag enables early typechecking of all imported bodies,
-// which is useful to flush out bugs.
-//
-// The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
-// which calls get inlined or not, more is for debugging, and may go away at any point.
-
-package gc
-
-import (
-       "cmd/compile/internal/logopt"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/src"
-       "fmt"
-       "strings"
-)
-
-// Inlining budget parameters, gathered in one place
-const (
-       inlineMaxBudget       = 80
-       inlineExtraAppendCost = 0
-       // default is to inline if there's at most one call. -l=4 overrides this by using 1 instead.
-       inlineExtraCallCost  = 57              // 57 was benchmarked to provided most benefit with no bad surprises; see https://github.com/golang/go/issues/19348#issuecomment-439370742
-       inlineExtraPanicCost = 1               // do not penalize inlining panics.
-       inlineExtraThrowCost = inlineMaxBudget // with current (2018-05/1.11) code, inlining runtime.throw does not help.
-
-       inlineBigFunctionNodes   = 5000 // Functions with this many nodes are considered "big".
-       inlineBigFunctionMaxCost = 20   // Max cost of inlinee when inlining into a "big" function.
-)
-
-// Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
-// the ->sym can be re-used in the local package, so peel it off the receiver's type.
-func fnpkg(fn *Node) *types.Pkg {
-       if fn.IsMethod() {
-               // method
-               rcvr := fn.Type.Recv().Type
-
-               if rcvr.IsPtr() {
-                       rcvr = rcvr.Elem()
-               }
-               if rcvr.Sym == nil {
-                       Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym, fn, rcvr)
-               }
-               return rcvr.Sym.Pkg
-       }
-
-       // non-method
-       return fn.Sym.Pkg
-}
-
-// Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
-// because they're a copy of an already checked body.
-func typecheckinl(fn *Node) {
-       lno := setlineno(fn)
-
-       expandInline(fn)
-
-       // typecheckinl is only for imported functions;
-       // their bodies may refer to unsafe as long as the package
-       // was marked safe during import (which was checked then).
-       // the ->inl of a local function has been typechecked before caninl copied it.
-       pkg := fnpkg(fn)
-
-       if pkg == localpkg || pkg == nil {
-               return // typecheckinl on local function
-       }
-
-       if Debug.m > 2 || Debug_export != 0 {
-               fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
-       }
-
-       savefn := Curfn
-       Curfn = fn
-       typecheckslice(fn.Func.Inl.Body, ctxStmt)
-       Curfn = savefn
-
-       // During expandInline (which imports fn.Func.Inl.Body),
-       // declarations are added to fn.Func.Dcl by funcHdr(). Move them
-       // to fn.Func.Inl.Dcl for consistency with how local functions
-       // behave. (Append because typecheckinl may be called multiple
-       // times.)
-       fn.Func.Inl.Dcl = append(fn.Func.Inl.Dcl, fn.Func.Dcl...)
-       fn.Func.Dcl = nil
-
-       lineno = lno
-}
-
-// Caninl determines whether fn is inlineable.
-// If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
-// fn and ->nbody will already have been typechecked.
-func caninl(fn *Node) {
-       if fn.Op != ODCLFUNC {
-               Fatalf("caninl %v", fn)
-       }
-       if fn.Func.Nname == nil {
-               Fatalf("caninl no nname %+v", fn)
-       }
-
-       var reason string // reason, if any, that the function was not inlined
-       if Debug.m > 1 || logopt.Enabled() {
-               defer func() {
-                       if reason != "" {
-                               if Debug.m > 1 {
-                                       fmt.Printf("%v: cannot inline %v: %s\n", fn.Line(), fn.Func.Nname, reason)
-                               }
-                               if logopt.Enabled() {
-                                       logopt.LogOpt(fn.Pos, "cannotInlineFunction", "inline", fn.funcname(), reason)
-                               }
-                       }
-               }()
-       }
-
-       // If marked "go:noinline", don't inline
-       if fn.Func.Pragma&Noinline != 0 {
-               reason = "marked go:noinline"
-               return
-       }
-
-       // If marked "go:norace" and -race compilation, don't inline.
-       if flag_race && fn.Func.Pragma&Norace != 0 {
-               reason = "marked go:norace with -race compilation"
-               return
-       }
-
-       // If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-       if Debug_checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
-               reason = "marked go:nocheckptr"
-               return
-       }
-
-       // If marked "go:cgo_unsafe_args", don't inline, since the
-       // function makes assumptions about its argument frame layout.
-       if fn.Func.Pragma&CgoUnsafeArgs != 0 {
-               reason = "marked go:cgo_unsafe_args"
-               return
-       }
-
-       // If marked as "go:uintptrescapes", don't inline, since the
-       // escape information is lost during inlining.
-       if fn.Func.Pragma&UintptrEscapes != 0 {
-               reason = "marked as having an escaping uintptr argument"
-               return
-       }
-
-       // The nowritebarrierrec checker currently works at function
-       // granularity, so inlining yeswritebarrierrec functions can
-       // confuse it (#22342). As a workaround, disallow inlining
-       // them for now.
-       if fn.Func.Pragma&Yeswritebarrierrec != 0 {
-               reason = "marked go:yeswritebarrierrec"
-               return
-       }
-
-       // If fn has no body (is defined outside of Go), cannot inline it.
-       if fn.Nbody.Len() == 0 {
-               reason = "no function body"
-               return
-       }
-
-       if fn.Typecheck() == 0 {
-               Fatalf("caninl on non-typechecked function %v", fn)
-       }
-
-       n := fn.Func.Nname
-       if n.Func.InlinabilityChecked() {
-               return
-       }
-       defer n.Func.SetInlinabilityChecked(true)
-
-       cc := int32(inlineExtraCallCost)
-       if Debug.l == 4 {
-               cc = 1 // this appears to yield better performance than 0.
-       }
-
-       // At this point in the game the function we're looking at may
-       // have "stale" autos, vars that still appear in the Dcl list, but
-       // which no longer have any uses in the function body (due to
-       // elimination by deadcode). We'd like to exclude these dead vars
-       // when creating the "Inline.Dcl" field below; to accomplish this,
-       // the hairyVisitor below builds up a map of used/referenced
-       // locals, and we use this map to produce a pruned Inline.Dcl
-       // list. See issue 25249 for more context.
-
-       visitor := hairyVisitor{
-               budget:        inlineMaxBudget,
-               extraCallCost: cc,
-               usedLocals:    make(map[*Node]bool),
-       }
-       if visitor.visitList(fn.Nbody) {
-               reason = visitor.reason
-               return
-       }
-       if visitor.budget < 0 {
-               reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-visitor.budget, inlineMaxBudget)
-               return
-       }
-
-       n.Func.Inl = &Inline{
-               Cost: inlineMaxBudget - visitor.budget,
-               Dcl:  inlcopylist(pruneUnusedAutos(n.Name.Defn.Func.Dcl, &visitor)),
-               Body: inlcopylist(fn.Nbody.Slice()),
-       }
-
-       // hack, TODO, check for better way to link method nodes back to the thing with the ->inl
-       // this is so export can find the body of a method
-       fn.Type.FuncType().Nname = asTypesNode(n)
-
-       if Debug.m > 1 {
-               fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
-       } else if Debug.m != 0 {
-               fmt.Printf("%v: can inline %v\n", fn.Line(), n)
-       }
-       if logopt.Enabled() {
-               logopt.LogOpt(fn.Pos, "canInlineFunction", "inline", fn.funcname(), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
-       }
-}
-
-// inlFlood marks n's inline body for export and recursively ensures
-// all called functions are marked too.
-func inlFlood(n *Node) {
-       if n == nil {
-               return
-       }
-       if n.Op != ONAME || n.Class() != PFUNC {
-               Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op, n.Class())
-       }
-       if n.Func == nil {
-               Fatalf("inlFlood: missing Func on %v", n)
-       }
-       if n.Func.Inl == nil {
-               return
-       }
-
-       if n.Func.ExportInline() {
-               return
-       }
-       n.Func.SetExportInline(true)
-
-       typecheckinl(n)
-
-       // Recursively identify all referenced functions for
-       // reexport. We want to include even non-called functions,
-       // because after inlining they might be callable.
-       inspectList(asNodes(n.Func.Inl.Body), func(n *Node) bool {
-               switch n.Op {
-               case ONAME:
-                       switch n.Class() {
-                       case PFUNC:
-                               if n.isMethodExpression() {
-                                       inlFlood(asNode(n.Type.Nname()))
-                               } else {
-                                       inlFlood(n)
-                                       exportsym(n)
-                               }
-                       case PEXTERN:
-                               exportsym(n)
-                       }
-
-               case ODOTMETH:
-                       fn := asNode(n.Type.Nname())
-                       inlFlood(fn)
-
-               case OCALLPART:
-                       // Okay, because we don't yet inline indirect
-                       // calls to method values.
-               case OCLOSURE:
-                       // If the closure is inlinable, we'll need to
-                       // flood it too. But today we don't support
-                       // inlining functions that contain closures.
-                       //
-                       // When we do, we'll probably want:
-                       //     inlFlood(n.Func.Closure.Func.Nname)
-                       Fatalf("unexpected closure in inlinable function")
-               }
-               return true
-       })
-}
-
-// hairyVisitor visits a function body to determine its inlining
-// hairiness and whether or not it can be inlined.
-type hairyVisitor struct {
-       budget        int32
-       reason        string
-       extraCallCost int32
-       usedLocals    map[*Node]bool
-}
-
-// Look for anything we want to punt on.
-func (v *hairyVisitor) visitList(ll Nodes) bool {
-       for _, n := range ll.Slice() {
-               if v.visit(n) {
-                       return true
-               }
-       }
-       return false
-}
-
-func (v *hairyVisitor) visit(n *Node) bool {
-       if n == nil {
-               return false
-       }
-
-       switch n.Op {
-       // Call is okay if inlinable and we have the budget for the body.
-       case OCALLFUNC:
-               // Functions that call runtime.getcaller{pc,sp} can not be inlined
-               // because getcaller{pc,sp} expect a pointer to the caller's first argument.
-               //
-               // runtime.throw is a "cheap call" like panic in normal code.
-               if n.Left.Op == ONAME && n.Left.Class() == PFUNC && isRuntimePkg(n.Left.Sym.Pkg) {
-                       fn := n.Left.Sym.Name
-                       if fn == "getcallerpc" || fn == "getcallersp" {
-                               v.reason = "call to " + fn
-                               return true
-                       }
-                       if fn == "throw" {
-                               v.budget -= inlineExtraThrowCost
-                               break
-                       }
-               }
-
-               if isIntrinsicCall(n) {
-                       // Treat like any other node.
-                       break
-               }
-
-               if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
-                       v.budget -= fn.Func.Inl.Cost
-                       break
-               }
-
-               // Call cost for non-leaf inlining.
-               v.budget -= v.extraCallCost
-
-       // Call is okay if inlinable and we have the budget for the body.
-       case OCALLMETH:
-               t := n.Left.Type
-               if t == nil {
-                       Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
-               }
-               if t.Nname() == nil {
-                       Fatalf("no function definition for [%p] %+v\n", t, t)
-               }
-               if isRuntimePkg(n.Left.Sym.Pkg) {
-                       fn := n.Left.Sym.Name
-                       if fn == "heapBits.nextArena" {
-                               // Special case: explicitly allow
-                               // mid-stack inlining of
-                               // runtime.heapBits.next even though
-                               // it calls slow-path
-                               // runtime.heapBits.nextArena.
-                               break
-                       }
-               }
-               if inlfn := asNode(t.FuncType().Nname).Func; inlfn.Inl != nil {
-                       v.budget -= inlfn.Inl.Cost
-                       break
-               }
-               // Call cost for non-leaf inlining.
-               v.budget -= v.extraCallCost
-
-       // Things that are too hairy, irrespective of the budget
-       case OCALL, OCALLINTER:
-               // Call cost for non-leaf inlining.
-               v.budget -= v.extraCallCost
-
-       case OPANIC:
-               v.budget -= inlineExtraPanicCost
-
-       case ORECOVER:
-               // recover matches the argument frame pointer to find
-               // the right panic value, so it needs an argument frame.
-               v.reason = "call to recover"
-               return true
-
-       case OCLOSURE,
-               ORANGE,
-               OSELECT,
-               OGO,
-               ODEFER,
-               ODCLTYPE, // can't print yet
-               ORETJMP:
-               v.reason = "unhandled op " + n.Op.String()
-               return true
-
-       case OAPPEND:
-               v.budget -= inlineExtraAppendCost
-
-       case ODCLCONST, OEMPTY, OFALL:
-               // These nodes don't produce code; omit from inlining budget.
-               return false
-
-       case OLABEL:
-               // TODO(mdempsky): Add support for inlining labeled control statements.
-               if n.labeledControl() != nil {
-                       v.reason = "labeled control"
-                       return true
-               }
-
-       case OBREAK, OCONTINUE:
-               if n.Sym != nil {
-                       // Should have short-circuited due to labeledControl above.
-                       Fatalf("unexpected labeled break/continue: %v", n)
-               }
-
-       case OIF:
-               if Isconst(n.Left, CTBOOL) {
-                       // This if and the condition cost nothing.
-                       return v.visitList(n.Ninit) || v.visitList(n.Nbody) ||
-                               v.visitList(n.Rlist)
-               }
-
-       case ONAME:
-               if n.Class() == PAUTO {
-                       v.usedLocals[n] = true
-               }
-
-       }
-
-       v.budget--
-
-       // When debugging, don't stop early, to get full cost of inlining this function
-       if v.budget < 0 && Debug.m < 2 && !logopt.Enabled() {
-               return true
-       }
-
-       return v.visit(n.Left) || v.visit(n.Right) ||
-               v.visitList(n.List) || v.visitList(n.Rlist) ||
-               v.visitList(n.Ninit) || v.visitList(n.Nbody)
-}
-
-// inlcopylist (together with inlcopy) recursively copies a list of nodes, except
-// that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
-// the body and dcls of an inlineable function.
-func inlcopylist(ll []*Node) []*Node {
-       s := make([]*Node, 0, len(ll))
-       for _, n := range ll {
-               s = append(s, inlcopy(n))
-       }
-       return s
-}
-
-func inlcopy(n *Node) *Node {
-       if n == nil {
-               return nil
-       }
-
-       switch n.Op {
-       case ONAME, OTYPE, OLITERAL:
-               return n
-       }
-
-       m := n.copy()
-       if n.Op != OCALLPART && m.Func != nil {
-               Fatalf("unexpected Func: %v", m)
-       }
-       m.Left = inlcopy(n.Left)
-       m.Right = inlcopy(n.Right)
-       m.List.Set(inlcopylist(n.List.Slice()))
-       m.Rlist.Set(inlcopylist(n.Rlist.Slice()))
-       m.Ninit.Set(inlcopylist(n.Ninit.Slice()))
-       m.Nbody.Set(inlcopylist(n.Nbody.Slice()))
-
-       return m
-}
-
-func countNodes(n *Node) int {
-       if n == nil {
-               return 0
-       }
-       cnt := 1
-       cnt += countNodes(n.Left)
-       cnt += countNodes(n.Right)
-       for _, n1 := range n.Ninit.Slice() {
-               cnt += countNodes(n1)
-       }
-       for _, n1 := range n.Nbody.Slice() {
-               cnt += countNodes(n1)
-       }
-       for _, n1 := range n.List.Slice() {
-               cnt += countNodes(n1)
-       }
-       for _, n1 := range n.Rlist.Slice() {
-               cnt += countNodes(n1)
-       }
-       return cnt
-}
-
-// Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
-// calls made to inlineable functions. This is the external entry point.
-func inlcalls(fn *Node) {
-       savefn := Curfn
-       Curfn = fn
-       maxCost := int32(inlineMaxBudget)
-       if countNodes(fn) >= inlineBigFunctionNodes {
-               maxCost = inlineBigFunctionMaxCost
-       }
-       // Map to keep track of functions that have been inlined at a particular
-       // call site, in order to stop inlining when we reach the beginning of a
-       // recursion cycle again. We don't inline immediately recursive functions,
-       // but allow inlining if there is a recursion cycle of many functions.
-       // Most likely, the inlining will stop before we even hit the beginning of
-       // the cycle again, but the map catches the unusual case.
-       inlMap := make(map[*Node]bool)
-       fn = inlnode(fn, maxCost, inlMap)
-       if fn != Curfn {
-               Fatalf("inlnode replaced curfn")
-       }
-       Curfn = savefn
-}
-
-// Turn an OINLCALL into a statement.
-func inlconv2stmt(n *Node) {
-       n.Op = OBLOCK
-
-       // n->ninit stays
-       n.List.Set(n.Nbody.Slice())
-
-       n.Nbody.Set(nil)
-       n.Rlist.Set(nil)
-}
-
-// Turn an OINLCALL into a single valued expression.
-// The result of inlconv2expr MUST be assigned back to n, e.g.
-//     n.Left = inlconv2expr(n.Left)
-func inlconv2expr(n *Node) *Node {
-       r := n.Rlist.First()
-       return addinit(r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
-}
-
-// Turn the rlist (with the return values) of the OINLCALL in
-// n into an expression list lumping the ninit and body
-// containing the inlined statements on the first list element so
-// order will be preserved Used in return, oas2func and call
-// statements.
-func inlconv2list(n *Node) []*Node {
-       if n.Op != OINLCALL || n.Rlist.Len() == 0 {
-               Fatalf("inlconv2list %+v\n", n)
-       }
-
-       s := n.Rlist.Slice()
-       s[0] = addinit(s[0], append(n.Ninit.Slice(), n.Nbody.Slice()...))
-       return s
-}
-
-func inlnodelist(l Nodes, maxCost int32, inlMap map[*Node]bool) {
-       s := l.Slice()
-       for i := range s {
-               s[i] = inlnode(s[i], maxCost, inlMap)
-       }
-}
-
-// inlnode recurses over the tree to find inlineable calls, which will
-// be turned into OINLCALLs by mkinlcall. When the recursion comes
-// back up will examine left, right, list, rlist, ninit, ntest, nincr,
-// nbody and nelse and use one of the 4 inlconv/glue functions above
-// to turn the OINLCALL into an expression, a statement, or patch it
-// in to this nodes list or rlist as appropriate.
-// NOTE it makes no sense to pass the glue functions down the
-// recursion to the level where the OINLCALL gets created because they
-// have to edit /this/ n, so you'd have to push that one down as well,
-// but then you may as well do it here.  so this is cleaner and
-// shorter and less complicated.
-// The result of inlnode MUST be assigned back to n, e.g.
-//     n.Left = inlnode(n.Left)
-func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
-       if n == nil {
-               return n
-       }
-
-       switch n.Op {
-       case ODEFER, OGO:
-               switch n.Left.Op {
-               case OCALLFUNC, OCALLMETH:
-                       n.Left.SetNoInline(true)
-               }
-
-       // TODO do them here (or earlier),
-       // so escape analysis can avoid more heapmoves.
-       case OCLOSURE:
-               return n
-       case OCALLMETH:
-               // Prevent inlining some reflect.Value methods when using checkptr,
-               // even when package reflect was compiled without it (#35073).
-               if s := n.Left.Sym; Debug_checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
-                       return n
-               }
-       }
-
-       lno := setlineno(n)
-
-       inlnodelist(n.Ninit, maxCost, inlMap)
-       for _, n1 := range n.Ninit.Slice() {
-               if n1.Op == OINLCALL {
-                       inlconv2stmt(n1)
-               }
-       }
-
-       n.Left = inlnode(n.Left, maxCost, inlMap)
-       if n.Left != nil && n.Left.Op == OINLCALL {
-               n.Left = inlconv2expr(n.Left)
-       }
-
-       n.Right = inlnode(n.Right, maxCost, inlMap)
-       if n.Right != nil && n.Right.Op == OINLCALL {
-               if n.Op == OFOR || n.Op == OFORUNTIL {
-                       inlconv2stmt(n.Right)
-               } else if n.Op == OAS2FUNC {
-                       n.Rlist.Set(inlconv2list(n.Right))
-                       n.Right = nil
-                       n.Op = OAS2
-                       n.SetTypecheck(0)
-                       n = typecheck(n, ctxStmt)
-               } else {
-                       n.Right = inlconv2expr(n.Right)
-               }
-       }
-
-       inlnodelist(n.List, maxCost, inlMap)
-       if n.Op == OBLOCK {
-               for _, n2 := range n.List.Slice() {
-                       if n2.Op == OINLCALL {
-                               inlconv2stmt(n2)
-                       }
-               }
-       } else {
-               s := n.List.Slice()
-               for i1, n1 := range s {
-                       if n1 != nil && n1.Op == OINLCALL {
-                               s[i1] = inlconv2expr(s[i1])
-                       }
-               }
-       }
-
-       inlnodelist(n.Rlist, maxCost, inlMap)
-       s := n.Rlist.Slice()
-       for i1, n1 := range s {
-               if n1.Op == OINLCALL {
-                       if n.Op == OIF {
-                               inlconv2stmt(n1)
-                       } else {
-                               s[i1] = inlconv2expr(s[i1])
-                       }
-               }
-       }
-
-       inlnodelist(n.Nbody, maxCost, inlMap)
-       for _, n := range n.Nbody.Slice() {
-               if n.Op == OINLCALL {
-                       inlconv2stmt(n)
-               }
-       }
-
-       // with all the branches out of the way, it is now time to
-       // transmogrify this node itself unless inhibited by the
-       // switch at the top of this function.
-       switch n.Op {
-       case OCALLFUNC, OCALLMETH:
-               if n.NoInline() {
-                       return n
-               }
-       }
-
-       switch n.Op {
-       case OCALLFUNC:
-               if Debug.m > 3 {
-                       fmt.Printf("%v:call to func %+v\n", n.Line(), n.Left)
-               }
-               if isIntrinsicCall(n) {
-                       break
-               }
-               if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
-                       n = mkinlcall(n, fn, maxCost, inlMap)
-               }
-
-       case OCALLMETH:
-               if Debug.m > 3 {
-                       fmt.Printf("%v:call to meth %L\n", n.Line(), n.Left.Right)
-               }
-
-               // typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
-               if n.Left.Type == nil {
-                       Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
-               }
-
-               if n.Left.Type.Nname() == nil {
-                       Fatalf("no function definition for [%p] %+v\n", n.Left.Type, n.Left.Type)
-               }
-
-               n = mkinlcall(n, asNode(n.Left.Type.FuncType().Nname), maxCost, inlMap)
-       }
-
-       lineno = lno
-       return n
-}
-
-// inlCallee takes a function-typed expression and returns the underlying function ONAME
-// that it refers to if statically known. Otherwise, it returns nil.
-func inlCallee(fn *Node) *Node {
-       fn = staticValue(fn)
-       switch {
-       case fn.Op == ONAME && fn.Class() == PFUNC:
-               if fn.isMethodExpression() {
-                       n := asNode(fn.Type.Nname())
-                       // Check that receiver type matches fn.Left.
-                       // TODO(mdempsky): Handle implicit dereference
-                       // of pointer receiver argument?
-                       if n == nil || !types.Identical(n.Type.Recv().Type, fn.Left.Type) {
-                               return nil
-                       }
-                       return n
-               }
-               return fn
-       case fn.Op == OCLOSURE:
-               c := fn.Func.Closure
-               caninl(c)
-               return c.Func.Nname
-       }
-       return nil
-}
-
-func staticValue(n *Node) *Node {
-       for {
-               if n.Op == OCONVNOP {
-                       n = n.Left
-                       continue
-               }
-
-               n1 := staticValue1(n)
-               if n1 == nil {
-                       return n
-               }
-               n = n1
-       }
-}
-
-// staticValue1 implements a simple SSA-like optimization. If n is a local variable
-// that is initialized and never reassigned, staticValue1 returns the initializer
-// expression. Otherwise, it returns nil.
-func staticValue1(n *Node) *Node {
-       if n.Op != ONAME || n.Class() != PAUTO || n.Name.Addrtaken() {
-               return nil
-       }
-
-       defn := n.Name.Defn
-       if defn == nil {
-               return nil
-       }
-
-       var rhs *Node
-FindRHS:
-       switch defn.Op {
-       case OAS:
-               rhs = defn.Right
-       case OAS2:
-               for i, lhs := range defn.List.Slice() {
-                       if lhs == n {
-                               rhs = defn.Rlist.Index(i)
-                               break FindRHS
-                       }
-               }
-               Fatalf("%v missing from LHS of %v", n, defn)
-       default:
-               return nil
-       }
-       if rhs == nil {
-               Fatalf("RHS is nil: %v", defn)
-       }
-
-       unsafe, _ := reassigned(n)
-       if unsafe {
-               return nil
-       }
-
-       return rhs
-}
-
-// reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
-// indicating whether the name has any assignments other than its declaration.
-// The second return value is the first such assignment encountered in the walk, if any. It is mostly
-// useful for -m output documenting the reason for inhibited optimizations.
-// NB: global variables are always considered to be re-assigned.
-// TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(n *Node) (bool, *Node) {
-       if n.Op != ONAME {
-               Fatalf("reassigned %v", n)
-       }
-       // no way to reliably check for no-reassignment of globals, assume it can be
-       if n.Name.Curfn == nil {
-               return true, nil
-       }
-       f := n.Name.Curfn
-       // There just might be a good reason for this although this can be pretty surprising:
-       // local variables inside a closure have Curfn pointing to the OCLOSURE node instead
-       // of the corresponding ODCLFUNC.
-       // We need to walk the function body to check for reassignments so we follow the
-       // linkage to the ODCLFUNC node as that is where body is held.
-       if f.Op == OCLOSURE {
-               f = f.Func.Closure
-       }
-       v := reassignVisitor{name: n}
-       a := v.visitList(f.Nbody)
-       return a != nil, a
-}
-
-type reassignVisitor struct {
-       name *Node
-}
-
-func (v *reassignVisitor) visit(n *Node) *Node {
-       if n == nil {
-               return nil
-       }
-       switch n.Op {
-       case OAS:
-               if n.Left == v.name && n != v.name.Name.Defn {
-                       return n
-               }
-       case OAS2, OAS2FUNC, OAS2MAPR, OAS2DOTTYPE:
-               for _, p := range n.List.Slice() {
-                       if p == v.name && n != v.name.Name.Defn {
-                               return n
-                       }
-               }
-       }
-       if a := v.visit(n.Left); a != nil {
-               return a
-       }
-       if a := v.visit(n.Right); a != nil {
-               return a
-       }
-       if a := v.visitList(n.List); a != nil {
-               return a
-       }
-       if a := v.visitList(n.Rlist); a != nil {
-               return a
-       }
-       if a := v.visitList(n.Ninit); a != nil {
-               return a
-       }
-       if a := v.visitList(n.Nbody); a != nil {
-               return a
-       }
-       return nil
-}
-
-func (v *reassignVisitor) visitList(l Nodes) *Node {
-       for _, n := range l.Slice() {
-               if a := v.visit(n); a != nil {
-                       return a
-               }
-       }
-       return nil
-}
-
-func inlParam(t *types.Field, as *Node, inlvars map[*Node]*Node) *Node {
-       n := asNode(t.Nname)
-       if n == nil || n.isBlank() {
-               return nblank
-       }
-
-       inlvar := inlvars[n]
-       if inlvar == nil {
-               Fatalf("missing inlvar for %v", n)
-       }
-       as.Ninit.Append(nod(ODCL, inlvar, nil))
-       inlvar.Name.Defn = as
-       return inlvar
-}
-
-var inlgen int
-
-// If n is a call node (OCALLFUNC or OCALLMETH), and fn is an ONAME node for a
-// function with an inlinable body, return an OINLCALL node that can replace n.
-// The returned node's Ninit has the parameter assignments, the Nbody is the
-// inlined function body, and (List, Rlist) contain the (input, output)
-// parameters.
-// The result of mkinlcall MUST be assigned back to n, e.g.
-//     n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
-       if fn.Func.Inl == nil {
-               if logopt.Enabled() {
-                       logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-                               fmt.Sprintf("%s cannot be inlined", fn.pkgFuncName()))
-               }
-               return n
-       }
-       if fn.Func.Inl.Cost > maxCost {
-               // The inlined function body is too big. Typically we use this check to restrict
-               // inlining into very big functions.  See issue 26546 and 17566.
-               if logopt.Enabled() {
-                       logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-                               fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func.Inl.Cost, fn.pkgFuncName(), maxCost))
-               }
-               return n
-       }
-
-       if fn == Curfn || fn.Name.Defn == Curfn {
-               // Can't recursively inline a function into itself.
-               if logopt.Enabled() {
-                       logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", Curfn.funcname()))
-               }
-               return n
-       }
-
-       if instrumenting && isRuntimePkg(fn.Sym.Pkg) {
-               // Runtime package must not be instrumented.
-               // Instrument skips runtime package. However, some runtime code can be
-               // inlined into other packages and instrumented there. To avoid this,
-               // we disable inlining of runtime functions when instrumenting.
-               // The example that we observed is inlining of LockOSThread,
-               // which lead to false race reports on m contents.
-               return n
-       }
-
-       if inlMap[fn] {
-               if Debug.m > 1 {
-                       fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", n.Line(), fn, Curfn.funcname())
-               }
-               return n
-       }
-       inlMap[fn] = true
-       defer func() {
-               inlMap[fn] = false
-       }()
-       if Debug_typecheckinl == 0 {
-               typecheckinl(fn)
-       }
-
-       // We have a function node, and it has an inlineable body.
-       if Debug.m > 1 {
-               fmt.Printf("%v: inlining call to %v %#v { %#v }\n", n.Line(), fn.Sym, fn.Type, asNodes(fn.Func.Inl.Body))
-       } else if Debug.m != 0 {
-               fmt.Printf("%v: inlining call to %v\n", n.Line(), fn)
-       }
-       if Debug.m > 2 {
-               fmt.Printf("%v: Before inlining: %+v\n", n.Line(), n)
-       }
-
-       if ssaDump != "" && ssaDump == Curfn.funcname() {
-               ssaDumpInlined = append(ssaDumpInlined, fn)
-       }
-
-       ninit := n.Ninit
-
-       // For normal function calls, the function callee expression
-       // may contain side effects (e.g., added by addinit during
-       // inlconv2expr or inlconv2list). Make sure to preserve these,
-       // if necessary (#42703).
-       if n.Op == OCALLFUNC {
-               callee := n.Left
-               for callee.Op == OCONVNOP {
-                       ninit.AppendNodes(&callee.Ninit)
-                       callee = callee.Left
-               }
-               if callee.Op != ONAME && callee.Op != OCLOSURE {
-                       Fatalf("unexpected callee expression: %v", callee)
-               }
-       }
-
-       // Make temp names to use instead of the originals.
-       inlvars := make(map[*Node]*Node)
-
-       // record formals/locals for later post-processing
-       var inlfvars []*Node
-
-       // Handle captured variables when inlining closures.
-       if fn.Name.Defn != nil {
-               if c := fn.Name.Defn.Func.Closure; c != nil {
-                       for _, v := range c.Func.Closure.Func.Cvars.Slice() {
-                               if v.Op == OXXX {
-                                       continue
-                               }
-
-                               o := v.Name.Param.Outer
-                               // make sure the outer param matches the inlining location
-                               // NB: if we enabled inlining of functions containing OCLOSURE or refined
-                               // the reassigned check via some sort of copy propagation this would most
-                               // likely need to be changed to a loop to walk up to the correct Param
-                               if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.Closure != Curfn) {
-                                       Fatalf("%v: unresolvable capture %v %v\n", n.Line(), fn, v)
-                               }
-
-                               if v.Name.Byval() {
-                                       iv := typecheck(inlvar(v), ctxExpr)
-                                       ninit.Append(nod(ODCL, iv, nil))
-                                       ninit.Append(typecheck(nod(OAS, iv, o), ctxStmt))
-                                       inlvars[v] = iv
-                               } else {
-                                       addr := newname(lookup("&" + v.Sym.Name))
-                                       addr.Type = types.NewPtr(v.Type)
-                                       ia := typecheck(inlvar(addr), ctxExpr)
-                                       ninit.Append(nod(ODCL, ia, nil))
-                                       ninit.Append(typecheck(nod(OAS, ia, nod(OADDR, o, nil)), ctxStmt))
-                                       inlvars[addr] = ia
-
-                                       // When capturing by reference, all occurrence of the captured var
-                                       // must be substituted with dereference of the temporary address
-                                       inlvars[v] = typecheck(nod(ODEREF, ia, nil), ctxExpr)
-                               }
-                       }
-               }
-       }
-
-       for _, ln := range fn.Func.Inl.Dcl {
-               if ln.Op != ONAME {
-                       continue
-               }
-               if ln.Class() == PPARAMOUT { // return values handled below.
-                       continue
-               }
-               if ln.isParamStackCopy() { // ignore the on-stack copy of a parameter that moved to the heap
-                       // TODO(mdempsky): Remove once I'm confident
-                       // this never actually happens. We currently
-                       // perform inlining before escape analysis, so
-                       // nothing should have moved to the heap yet.
-                       Fatalf("impossible: %v", ln)
-               }
-               inlf := typecheck(inlvar(ln), ctxExpr)
-               inlvars[ln] = inlf
-               if genDwarfInline > 0 {
-                       if ln.Class() == PPARAM {
-                               inlf.Name.SetInlFormal(true)
-                       } else {
-                               inlf.Name.SetInlLocal(true)
-                       }
-                       inlf.Pos = ln.Pos
-                       inlfvars = append(inlfvars, inlf)
-               }
-       }
-
-       nreturns := 0
-       inspectList(asNodes(fn.Func.Inl.Body), func(n *Node) bool {
-               if n != nil && n.Op == ORETURN {
-                       nreturns++
-               }
-               return true
-       })
-
-       // We can delay declaring+initializing result parameters if:
-       // (1) there's only one "return" statement in the inlined
-       // function, and (2) the result parameters aren't named.
-       delayretvars := nreturns == 1
-
-       // temporaries for return values.
-       var retvars []*Node
-       for i, t := range fn.Type.Results().Fields().Slice() {
-               var m *Node
-               if n := asNode(t.Nname); n != nil && !n.isBlank() && !strings.HasPrefix(n.Sym.Name, "~r") {
-                       m = inlvar(n)
-                       m = typecheck(m, ctxExpr)
-                       inlvars[n] = m
-                       delayretvars = false // found a named result parameter
-               } else {
-                       // anonymous return values, synthesize names for use in assignment that replaces return
-                       m = retvar(t, i)
-               }
-
-               if genDwarfInline > 0 {
-                       // Don't update the src.Pos on a return variable if it
-                       // was manufactured by the inliner (e.g. "~R2"); such vars
-                       // were not part of the original callee.
-                       if !strings.HasPrefix(m.Sym.Name, "~R") {
-                               m.Name.SetInlFormal(true)
-                               m.Pos = t.Pos
-                               inlfvars = append(inlfvars, m)
-                       }
-               }
-
-               retvars = append(retvars, m)
-       }
-
-       // Assign arguments to the parameters' temp names.
-       as := nod(OAS2, nil, nil)
-       as.SetColas(true)
-       if n.Op == OCALLMETH {
-               if n.Left.Left == nil {
-                       Fatalf("method call without receiver: %+v", n)
-               }
-               as.Rlist.Append(n.Left.Left)
-       }
-       as.Rlist.Append(n.List.Slice()...)
-
-       // For non-dotted calls to variadic functions, we assign the
-       // variadic parameter's temp name separately.
-       var vas *Node
-
-       if recv := fn.Type.Recv(); recv != nil {
-               as.List.Append(inlParam(recv, as, inlvars))
-       }
-       for _, param := range fn.Type.Params().Fields().Slice() {
-               // For ordinary parameters or variadic parameters in
-               // dotted calls, just add the variable to the
-               // assignment list, and we're done.
-               if !param.IsDDD() || n.IsDDD() {
-                       as.List.Append(inlParam(param, as, inlvars))
-                       continue
-               }
-
-               // Otherwise, we need to collect the remaining values
-               // to pass as a slice.
-
-               x := as.List.Len()
-               for as.List.Len() < as.Rlist.Len() {
-                       as.List.Append(argvar(param.Type, as.List.Len()))
-               }
-               varargs := as.List.Slice()[x:]
-
-               vas = nod(OAS, nil, nil)
-               vas.Left = inlParam(param, vas, inlvars)
-               if len(varargs) == 0 {
-                       vas.Right = nodnil()
-                       vas.Right.Type = param.Type
-               } else {
-                       vas.Right = nod(OCOMPLIT, nil, typenod(param.Type))
-                       vas.Right.List.Set(varargs)
-               }
-       }
-
-       if as.Rlist.Len() != 0 {
-               as = typecheck(as, ctxStmt)
-               ninit.Append(as)
-       }
-
-       if vas != nil {
-               vas = typecheck(vas, ctxStmt)
-               ninit.Append(vas)
-       }
-
-       if !delayretvars {
-               // Zero the return parameters.
-               for _, n := range retvars {
-                       ninit.Append(nod(ODCL, n, nil))
-                       ras := nod(OAS, n, nil)
-                       ras = typecheck(ras, ctxStmt)
-                       ninit.Append(ras)
-               }
-       }
-
-       retlabel := autolabel(".i")
-
-       inlgen++
-
-       parent := -1
-       if b := Ctxt.PosTable.Pos(n.Pos).Base(); b != nil {
-               parent = b.InliningIndex()
-       }
-       newIndex := Ctxt.InlTree.Add(parent, n.Pos, fn.Sym.Linksym())
-
-       // Add an inline mark just before the inlined body.
-       // This mark is inline in the code so that it's a reasonable spot
-       // to put a breakpoint. Not sure if that's really necessary or not
-       // (in which case it could go at the end of the function instead).
-       // Note issue 28603.
-       inlMark := nod(OINLMARK, nil, nil)
-       inlMark.Pos = n.Pos.WithIsStmt()
-       inlMark.Xoffset = int64(newIndex)
-       ninit.Append(inlMark)
-
-       if genDwarfInline > 0 {
-               if !fn.Sym.Linksym().WasInlined() {
-                       Ctxt.DwFixups.SetPrecursorFunc(fn.Sym.Linksym(), fn)
-                       fn.Sym.Linksym().Set(obj.AttrWasInlined, true)
-               }
-       }
-
-       subst := inlsubst{
-               retlabel:     retlabel,
-               retvars:      retvars,
-               delayretvars: delayretvars,
-               inlvars:      inlvars,
-               bases:        make(map[*src.PosBase]*src.PosBase),
-               newInlIndex:  newIndex,
-       }
-
-       body := subst.list(asNodes(fn.Func.Inl.Body))
-
-       lab := nodSym(OLABEL, nil, retlabel)
-       body = append(body, lab)
-
-       typecheckslice(body, ctxStmt)
-
-       if genDwarfInline > 0 {
-               for _, v := range inlfvars {
-                       v.Pos = subst.updatedPos(v.Pos)
-               }
-       }
-
-       //dumplist("ninit post", ninit);
-
-       call := nod(OINLCALL, nil, nil)
-       call.Ninit.Set(ninit.Slice())
-       call.Nbody.Set(body)
-       call.Rlist.Set(retvars)
-       call.Type = n.Type
-       call.SetTypecheck(1)
-
-       // transitive inlining
-       // might be nice to do this before exporting the body,
-       // but can't emit the body with inlining expanded.
-       // instead we emit the things that the body needs
-       // and each use must redo the inlining.
-       // luckily these are small.
-       inlnodelist(call.Nbody, maxCost, inlMap)
-       for _, n := range call.Nbody.Slice() {
-               if n.Op == OINLCALL {
-                       inlconv2stmt(n)
-               }
-       }
-
-       if Debug.m > 2 {
-               fmt.Printf("%v: After inlining %+v\n\n", call.Line(), call)
-       }
-
-       return call
-}
-
-// Every time we expand a function we generate a new set of tmpnames,
-// PAUTO's in the calling functions, and link them off of the
-// PPARAM's, PAUTOS and PPARAMOUTs of the called function.
-func inlvar(var_ *Node) *Node {
-       if Debug.m > 3 {
-               fmt.Printf("inlvar %+v\n", var_)
-       }
-
-       n := newname(var_.Sym)
-       n.Type = var_.Type
-       n.SetClass(PAUTO)
-       n.Name.SetUsed(true)
-       n.Name.Curfn = Curfn // the calling function, not the called one
-       n.Name.SetAddrtaken(var_.Name.Addrtaken())
-
-       Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-       return n
-}
-
-// Synthesize a variable to store the inlined function's results in.
-func retvar(t *types.Field, i int) *Node {
-       n := newname(lookupN("~R", i))
-       n.Type = t.Type
-       n.SetClass(PAUTO)
-       n.Name.SetUsed(true)
-       n.Name.Curfn = Curfn // the calling function, not the called one
-       Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-       return n
-}
-
-// Synthesize a variable to store the inlined function's arguments
-// when they come from a multiple return call.
-func argvar(t *types.Type, i int) *Node {
-       n := newname(lookupN("~arg", i))
-       n.Type = t.Elem()
-       n.SetClass(PAUTO)
-       n.Name.SetUsed(true)
-       n.Name.Curfn = Curfn // the calling function, not the called one
-       Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-       return n
-}
-
-// The inlsubst type implements the actual inlining of a single
-// function call.
-type inlsubst struct {
-       // Target of the goto substituted in place of a return.
-       retlabel *types.Sym
-
-       // Temporary result variables.
-       retvars []*Node
-
-       // Whether result variables should be initialized at the
-       // "return" statement.
-       delayretvars bool
-
-       inlvars map[*Node]*Node
-
-       // bases maps from original PosBase to PosBase with an extra
-       // inlined call frame.
-       bases map[*src.PosBase]*src.PosBase
-
-       // newInlIndex is the index of the inlined call frame to
-       // insert for inlined nodes.
-       newInlIndex int
-}
-
-// list inlines a list of nodes.
-func (subst *inlsubst) list(ll Nodes) []*Node {
-       s := make([]*Node, 0, ll.Len())
-       for _, n := range ll.Slice() {
-               s = append(s, subst.node(n))
-       }
-       return s
-}
-
-// node recursively copies a node from the saved pristine body of the
-// inlined function, substituting references to input/output
-// parameters with ones to the tmpnames, and substituting returns with
-// assignments to the output.
-func (subst *inlsubst) node(n *Node) *Node {
-       if n == nil {
-               return nil
-       }
-
-       switch n.Op {
-       case ONAME:
-               if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
-                       if Debug.m > 2 {
-                               fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
-                       }
-                       return inlvar
-               }
-
-               if Debug.m > 2 {
-                       fmt.Printf("not substituting name %+v\n", n)
-               }
-               return n
-
-       case OLITERAL, OTYPE:
-               // If n is a named constant or type, we can continue
-               // using it in the inline copy. Otherwise, make a copy
-               // so we can update the line number.
-               if n.Sym != nil {
-                       return n
-               }
-
-               // Since we don't handle bodies with closures, this return is guaranteed to belong to the current inlined function.
-
-       //              dump("Return before substitution", n);
-       case ORETURN:
-               m := nodSym(OGOTO, nil, subst.retlabel)
-               m.Ninit.Set(subst.list(n.Ninit))
-
-               if len(subst.retvars) != 0 && n.List.Len() != 0 {
-                       as := nod(OAS2, nil, nil)
-
-                       // Make a shallow copy of retvars.
-                       // Otherwise OINLCALL.Rlist will be the same list,
-                       // and later walk and typecheck may clobber it.
-                       for _, n := range subst.retvars {
-                               as.List.Append(n)
-                       }
-                       as.Rlist.Set(subst.list(n.List))
-
-                       if subst.delayretvars {
-                               for _, n := range as.List.Slice() {
-                                       as.Ninit.Append(nod(ODCL, n, nil))
-                                       n.Name.Defn = as
-                               }
-                       }
-
-                       as = typecheck(as, ctxStmt)
-                       m.Ninit.Append(as)
-               }
-
-               typecheckslice(m.Ninit.Slice(), ctxStmt)
-               m = typecheck(m, ctxStmt)
-
-               //              dump("Return after substitution", m);
-               return m
-
-       case OGOTO, OLABEL:
-               m := n.copy()
-               m.Pos = subst.updatedPos(m.Pos)
-               m.Ninit.Set(nil)
-               p := fmt.Sprintf("%s·%d", n.Sym.Name, inlgen)
-               m.Sym = lookup(p)
-
-               return m
-       }
-
-       m := n.copy()
-       m.Pos = subst.updatedPos(m.Pos)
-       m.Ninit.Set(nil)
-
-       if n.Op == OCLOSURE {
-               Fatalf("cannot inline function containing closure: %+v", n)
-       }
-
-       m.Left = subst.node(n.Left)
-       m.Right = subst.node(n.Right)
-       m.List.Set(subst.list(n.List))
-       m.Rlist.Set(subst.list(n.Rlist))
-       m.Ninit.Set(append(m.Ninit.Slice(), subst.list(n.Ninit)...))
-       m.Nbody.Set(subst.list(n.Nbody))
-
-       return m
-}
-
-func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
-       pos := Ctxt.PosTable.Pos(xpos)
-       oldbase := pos.Base() // can be nil
-       newbase := subst.bases[oldbase]
-       if newbase == nil {
-               newbase = src.NewInliningBase(oldbase, subst.newInlIndex)
-               subst.bases[oldbase] = newbase
-       }
-       pos.SetBase(newbase)
-       return Ctxt.PosTable.XPos(pos)
-}
-
-func pruneUnusedAutos(ll []*Node, vis *hairyVisitor) []*Node {
-       s := make([]*Node, 0, len(ll))
-       for _, n := range ll {
-               if n.Class() == PAUTO {
-                       if _, found := vis.usedLocals[n]; !found {
-                               continue
-                       }
-               }
-               s = append(s, n)
-       }
-       return s
-}
-
-// devirtualize replaces interface method calls within fn with direct
-// concrete-type method calls where applicable.
-func devirtualize(fn *Node) {
-       Curfn = fn
-       inspectList(fn.Nbody, func(n *Node) bool {
-               if n.Op == OCALLINTER {
-                       devirtualizeCall(n)
-               }
-               return true
-       })
-}
-
-func devirtualizeCall(call *Node) {
-       recv := staticValue(call.Left.Left)
-       if recv.Op != OCONVIFACE {
-               return
-       }
-
-       typ := recv.Left.Type
-       if typ.IsInterface() {
-               return
-       }
-
-       x := nodl(call.Left.Pos, ODOTTYPE, call.Left.Left, nil)
-       x.Type = typ
-       x = nodlSym(call.Left.Pos, OXDOT, x, call.Left.Sym)
-       x = typecheck(x, ctxExpr|ctxCallee)
-       switch x.Op {
-       case ODOTMETH:
-               if Debug.m != 0 {
-                       Warnl(call.Pos, "devirtualizing %v to %v", call.Left, typ)
-               }
-               call.Op = OCALLMETH
-               call.Left = x
-       case ODOTINTER:
-               // Promoted method from embedded interface-typed field (#42279).
-               if Debug.m != 0 {
-                       Warnl(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
-               }
-               call.Op = OCALLINTER
-               call.Left = x
-       default:
-               // TODO(mdempsky): Turn back into Fatalf after more testing.
-               if Debug.m != 0 {
-                       Warnl(call.Pos, "failed to devirtualize %v (%v)", x, x.Op)
-               }
-               return
-       }
-
-       // Duplicated logic from typecheck for function call return
-       // value types.
-       //
-       // Receiver parameter size may have changed; need to update
-       // call.Type to get correct stack offsets for result
-       // parameters.
-       checkwidth(x.Type)
-       switch ft := x.Type; ft.NumResults() {
-       case 0:
-       case 1:
-               call.Type = ft.Results().Field(0).Type
-       default:
-               call.Type = ft.Results()
-       }
-}

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index a6963a3d66e62c36ad5f8d46a89cbac3ca53e73c..726a0685d57fff33053395c97eb176bd730e0267 100644 (file)
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -2,716 +2,238 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run mkbuiltin.go
-
 package gc
 
 import (
        "bufio"
        "bytes"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/deadcode"
+       "cmd/compile/internal/devirtualize"
+       "cmd/compile/internal/dwarfgen"
+       "cmd/compile/internal/escape"
+       "cmd/compile/internal/inline"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
+       "cmd/compile/internal/noder"
+       "cmd/compile/internal/pkginit"
+       "cmd/compile/internal/reflectdata"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
        "cmd/compile/internal/types"
-       "cmd/internal/bio"
        "cmd/internal/dwarf"
-       "cmd/internal/goobj"
        "cmd/internal/obj"
        "cmd/internal/objabi"
        "cmd/internal/src"
-       "cmd/internal/sys"
        "flag"
        "fmt"
-       "internal/goversion"
-       "io"
-       "io/ioutil"
        "log"
        "os"
-       "path"
-       "regexp"
        "runtime"
-       "sort"
-       "strconv"
-       "strings"
-)
-
-var (
-       buildid      string
-       spectre      string
-       spectreIndex bool
 )
 
-var (
-       Debug_append       int
-       Debug_checkptr     int
-       Debug_closure      int
-       Debug_compilelater int
-       debug_dclstack     int
-       Debug_dumpptrs     int
-       Debug_libfuzzer    int
-       Debug_panic        int
-       Debug_slice        int
-       Debug_vlog         bool
-       Debug_wb           int
-       Debug_pctab        string
-       Debug_locationlist int
-       Debug_typecheckinl int
-       Debug_gendwarfinl  int
-       Debug_softfloat    int
-       Debug_defer        int
-)
-
-// Debug arguments.
-// These can be specified with the -d flag, as in "-d nil"
-// to set the debug_checknil variable.
-// Multiple options can be comma-separated.
-// Each option accepts an optional argument, as in "gcprog=2"
-var debugtab = []struct {
-       name string
-       help string
-       val  interface{} // must be *int or *string
-}{
-       {"append", "print information about append compilation", &Debug_append},
-       {"checkptr", "instrument unsafe pointer conversions", &Debug_checkptr},
-       {"closure", "print information about closure compilation", &Debug_closure},
-       {"compilelater", "compile functions as late as possible", &Debug_compilelater},
-       {"disablenil", "disable nil checks", &disable_checknil},
-       {"dclstack", "run internal dclstack check", &debug_dclstack},
-       {"dumpptrs", "show Node pointer values in Dump/dumplist output", &Debug_dumpptrs},
-       {"gcprog", "print dump of GC programs", &Debug_gcprog},
-       {"libfuzzer", "coverage instrumentation for libfuzzer", &Debug_libfuzzer},
-       {"nil", "print information about nil checks", &Debug_checknil},
-       {"panic", "do not hide any compiler panic", &Debug_panic},
-       {"slice", "print information about slice compilation", &Debug_slice},
-       {"typeassert", "print information about type assertion inlining", &Debug_typeassert},
-       {"wb", "print information about write barriers", &Debug_wb},
-       {"export", "print export data", &Debug_export},
-       {"pctab", "print named pc-value table", &Debug_pctab},
-       {"locationlists", "print information about DWARF location list creation", &Debug_locationlist},
-       {"typecheckinl", "eager typechecking of inline function bodies", &Debug_typecheckinl},
-       {"dwarfinl", "print information about DWARF inlined function creation", &Debug_gendwarfinl},
-       {"softfloat", "force compiler to emit soft-float code", &Debug_softfloat},
-       {"defer", "print information about defer compilation", &Debug_defer},
-       {"fieldtrack", "enable fieldtracking", &objabi.Fieldtrack_enabled},
-}
-
-const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>]
-
-<key> is one of:
-
-`
-
-const debugHelpFooter = `
-<value> is key-specific.
-
-Key "checkptr" supports values:
-       "0": instrumentation disabled
-       "1": conversions involving unsafe.Pointer are instrumented
-       "2": conversions to unsafe.Pointer force heap allocation
-
-Key "pctab" supports values:
-       "pctospadj", "pctofile", "pctoline", "pctoinline", "pctopcdata"
-`
-
-func usage() {
-       fmt.Fprintf(os.Stderr, "usage: compile [options] file.go...\n")
-       objabi.Flagprint(os.Stderr)
-       Exit(2)
-}
-
 func hidePanic() {
-       if Debug_panic == 0 && nsavederrors+nerrors > 0 {
+       if base.Debug.Panic == 0 && base.Errors() > 0 {
                // If we've already complained about things
                // in the program, don't bother complaining
                // about a panic too; let the user clean up
                // the code and try again.
                if err := recover(); err != nil {
-                       errorexit()
+                       if err == "-h" {
+                               panic(err)
+                       }
+                       base.ErrorExit()
                }
        }
 }
 
-// supportsDynlink reports whether or not the code generator for the given
-// architecture supports the -shared and -dynlink flags.
-func supportsDynlink(arch *sys.Arch) bool {
-       return arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X)
-}
-
-// timing data for compiler phases
-var timings Timings
-var benchfile string
-
-var nowritebarrierrecCheck *nowritebarrierrecChecker
-
 // Main parses flags and Go source files specified in the command-line
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
-func Main(archInit func(*Arch)) {
-       timings.Start("fe", "init")
+func Main(archInit func(*ssagen.ArchInfo)) {
+       base.Timer.Start("fe", "init")
 
        defer hidePanic()
 
-       archInit(&thearch)
+       archInit(&ssagen.Arch)
 
-       Ctxt = obj.Linknew(thearch.LinkArch)
-       Ctxt.DiagFunc = yyerror
-       Ctxt.DiagFlush = flusherrors
-       Ctxt.Bso = bufio.NewWriter(os.Stdout)
+       base.Ctxt = obj.Linknew(ssagen.Arch.LinkArch)
+       base.Ctxt.DiagFunc = base.Errorf
+       base.Ctxt.DiagFlush = base.FlushErrors
+       base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
 
        // UseBASEntries is preferred because it shaves about 2% off build time, but LLDB, dsymutil, and dwarfdump
        // on Darwin don't support it properly, especially since macOS 10.14 (Mojave).  This is exposed as a flag
        // to allow testing with LLVM tools on Linux, and to help with reporting this bug to the LLVM project.
        // See bugs 31188 and 21945 (CLs 170638, 98075, 72371).
-       Ctxt.UseBASEntries = Ctxt.Headtype != objabi.Hdarwin
+       base.Ctxt.UseBASEntries = base.Ctxt.Headtype != objabi.Hdarwin
 
-       localpkg = types.NewPkg("", "")
-       localpkg.Prefix = "\"\""
+       types.LocalPkg = types.NewPkg("", "")
+       types.LocalPkg.Prefix = "\"\""
 
        // We won't know localpkg's height until after import
        // processing. In the mean time, set to MaxPkgHeight to ensure
        // height comparisons at least work until then.
-       localpkg.Height = types.MaxPkgHeight
+       types.LocalPkg.Height = types.MaxPkgHeight
 
        // pseudo-package, for scoping
-       builtinpkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
-       builtinpkg.Prefix = "go.builtin"            // not go%2ebuiltin
+       types.BuiltinPkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
+       types.BuiltinPkg.Prefix = "go.builtin"            // not go%2ebuiltin
 
        // pseudo-package, accessed by import "unsafe"
-       unsafepkg = types.NewPkg("unsafe", "unsafe")
+       ir.Pkgs.Unsafe = types.NewPkg("unsafe", "unsafe")
 
        // Pseudo-package that contains the compiler's builtin
        // declarations for package runtime. These are declared in a
        // separate package to avoid conflicts with package runtime's
        // actual declarations, which may differ intentionally but
        // insignificantly.
-       Runtimepkg = types.NewPkg("go.runtime", "runtime")
-       Runtimepkg.Prefix = "runtime"
+       ir.Pkgs.Runtime = types.NewPkg("go.runtime", "runtime")
+       ir.Pkgs.Runtime.Prefix = "runtime"
 
        // pseudo-packages used in symbol tables
-       itabpkg = types.NewPkg("go.itab", "go.itab")
-       itabpkg.Prefix = "go.itab" // not go%2eitab
-
-       itablinkpkg = types.NewPkg("go.itablink", "go.itablink")
-       itablinkpkg.Prefix = "go.itablink" // not go%2eitablink
-
-       trackpkg = types.NewPkg("go.track", "go.track")
-       trackpkg.Prefix = "go.track" // not go%2etrack
-
-       // pseudo-package used for map zero values
-       mappkg = types.NewPkg("go.map", "go.map")
-       mappkg.Prefix = "go.map"
+       ir.Pkgs.Itab = types.NewPkg("go.itab", "go.itab")
+       ir.Pkgs.Itab.Prefix = "go.itab" // not go%2eitab
 
        // pseudo-package used for methods with anonymous receivers
-       gopkg = types.NewPkg("go", "")
+       ir.Pkgs.Go = types.NewPkg("go", "")
 
-       Wasm := objabi.GOARCH == "wasm"
-
-       // Whether the limit for stack-allocated objects is much smaller than normal.
-       // This can be helpful for diagnosing certain causes of GC latency. See #27732.
-       smallFrames := false
-       jsonLogOpt := ""
-
-       flag.BoolVar(&compiling_runtime, "+", false, "compiling runtime")
-       flag.BoolVar(&compiling_std, "std", false, "compiling standard library")
-       flag.StringVar(&localimport, "D", "", "set relative `path` for local imports")
-
-       objabi.Flagcount("%", "debug non-static initializers", &Debug.P)
-       objabi.Flagcount("B", "disable bounds checking", &Debug.B)
-       objabi.Flagcount("C", "disable printing of columns in error messages", &Debug.C)
-       objabi.Flagcount("E", "debug symbol export", &Debug.E)
-       objabi.Flagcount("K", "debug missing line numbers", &Debug.K)
-       objabi.Flagcount("L", "show full file names in error messages", &Debug.L)
-       objabi.Flagcount("N", "disable optimizations", &Debug.N)
-       objabi.Flagcount("S", "print assembly listing", &Debug.S)
-       objabi.Flagcount("W", "debug parse tree after type checking", &Debug.W)
-       objabi.Flagcount("e", "no limit on number of errors reported", &Debug.e)
-       objabi.Flagcount("h", "halt on error", &Debug.h)
-       objabi.Flagcount("j", "debug runtime-initialized variables", &Debug.j)
-       objabi.Flagcount("l", "disable inlining", &Debug.l)
-       objabi.Flagcount("m", "print optimization decisions", &Debug.m)
-       objabi.Flagcount("r", "debug generated wrappers", &Debug.r)
-       objabi.Flagcount("w", "debug type checking", &Debug.w)
-
-       objabi.Flagfn1("I", "add `directory` to import search path", addidir)
-       objabi.AddVersionFlag() // -V
-       flag.StringVar(&asmhdr, "asmhdr", "", "write assembly header to `file`")
-       flag.StringVar(&buildid, "buildid", "", "record `id` as the build id in the export metadata")
-       flag.IntVar(&nBackendWorkers, "c", 1, "concurrency during compilation, 1 means no concurrency")
-       flag.BoolVar(&pure_go, "complete", false, "compiling complete package (no C or assembly)")
-       flag.StringVar(&debugstr, "d", "", "print debug information about items in `list`; try -d help")
-       flag.BoolVar(&flagDWARF, "dwarf", !Wasm, "generate DWARF symbols")
-       flag.BoolVar(&Ctxt.Flag_locationlists, "dwarflocationlists", true, "add location lists to DWARF in optimized mode")
-       flag.IntVar(&genDwarfInline, "gendwarfinl", 2, "generate DWARF inline info records")
-       objabi.Flagfn1("embedcfg", "read go:embed configuration from `file`", readEmbedCfg)
-       objabi.Flagfn1("importmap", "add `definition` of the form source=actual to import map", addImportMap)
-       objabi.Flagfn1("importcfg", "read import configuration from `file`", readImportCfg)
-       flag.StringVar(&flag_installsuffix, "installsuffix", "", "set pkg directory `suffix`")
-       flag.StringVar(&flag_lang, "lang", "", "release to compile for")
-       flag.StringVar(&linkobj, "linkobj", "", "write linker-specific object to `file`")
-       objabi.Flagcount("live", "debug liveness analysis", &debuglive)
-       if sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
-               flag.BoolVar(&flag_msan, "msan", false, "build code compatible with C/C++ memory sanitizer")
-       }
-       flag.BoolVar(&nolocalimports, "nolocalimports", false, "reject local (relative) imports")
-       flag.StringVar(&outfile, "o", "", "write output to `file`")
-       flag.StringVar(&myimportpath, "p", "", "set expected package import `path`")
-       flag.BoolVar(&writearchive, "pack", false, "write to file.a instead of file.o")
-       if sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
-               flag.BoolVar(&flag_race, "race", false, "enable race detector")
-       }
-       flag.StringVar(&spectre, "spectre", spectre, "enable spectre mitigations in `list` (all, index, ret)")
-       if enableTrace {
-               flag.BoolVar(&trace, "t", false, "trace type-checking")
-       }
-       flag.StringVar(&pathPrefix, "trimpath", "", "remove `prefix` from recorded source file paths")
-       flag.BoolVar(&Debug_vlog, "v", false, "increase debug verbosity")
-       flag.BoolVar(&use_writebarrier, "wb", true, "enable write barrier")
-       var flag_shared bool
-       var flag_dynlink bool
-       if supportsDynlink(thearch.LinkArch.Arch) {
-               flag.BoolVar(&flag_shared, "shared", false, "generate code that can be linked into a shared library")
-               flag.BoolVar(&flag_dynlink, "dynlink", false, "support references to Go symbols defined in other shared libraries")
-               flag.BoolVar(&Ctxt.Flag_linkshared, "linkshared", false, "generate code that will be linked against Go shared libraries")
-       }
-       flag.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to `file`")
-       flag.StringVar(&memprofile, "memprofile", "", "write memory profile to `file`")
-       flag.Int64Var(&memprofilerate, "memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-       var goversion string
-       flag.StringVar(&goversion, "goversion", "", "required version of the runtime")
-       var symabisPath string
-       flag.StringVar(&symabisPath, "symabis", "", "read symbol ABIs from `file`")
-       flag.StringVar(&traceprofile, "traceprofile", "", "write an execution trace to `file`")
-       flag.StringVar(&blockprofile, "blockprofile", "", "write block profile to `file`")
-       flag.StringVar(&mutexprofile, "mutexprofile", "", "write mutex profile to `file`")
-       flag.StringVar(&benchfile, "bench", "", "append benchmark times to `file`")
-       flag.BoolVar(&smallFrames, "smallframes", false, "reduce the size limit for stack allocated objects")
-       flag.BoolVar(&Ctxt.UseBASEntries, "dwarfbasentries", Ctxt.UseBASEntries, "use base address selection entries in DWARF")
-       flag.StringVar(&jsonLogOpt, "json", "", "version,destination for JSON compiler/optimizer logging")
-
-       objabi.Flagparse(usage)
-
-       Ctxt.Pkgpath = myimportpath
-
-       for _, f := range strings.Split(spectre, ",") {
-               f = strings.TrimSpace(f)
-               switch f {
-               default:
-                       log.Fatalf("unknown setting -spectre=%s", f)
-               case "":
-                       // nothing
-               case "all":
-                       spectreIndex = true
-                       Ctxt.Retpoline = true
-               case "index":
-                       spectreIndex = true
-               case "ret":
-                       Ctxt.Retpoline = true
-               }
-       }
-
-       if spectreIndex {
-               switch objabi.GOARCH {
-               case "amd64":
-                       // ok
-               default:
-                       log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
-               }
-       }
+       base.DebugSSA = ssa.PhaseOption
+       base.ParseFlags()
 
        // Record flags that affect the build result. (And don't
        // record flags that don't, since that would cause spurious
        // changes in the binary.)
-       recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
-
-       if smallFrames {
-               maxStackVarSize = 128 * 1024
-               maxImplicitStackVarSize = 16 * 1024
-       }
-
-       Ctxt.Flag_shared = flag_dynlink || flag_shared
-       Ctxt.Flag_dynlink = flag_dynlink
-       Ctxt.Flag_optimize = Debug.N == 0
-
-       Ctxt.Debugasm = Debug.S
-       Ctxt.Debugvlog = Debug_vlog
-       if flagDWARF {
-               Ctxt.DebugInfo = debuginfo
-               Ctxt.GenAbstractFunc = genAbstractFunc
-               Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
-       } else {
-               // turn off inline generation if no dwarf at all
-               genDwarfInline = 0
-               Ctxt.Flag_locationlists = false
-       }
-
-       if flag.NArg() < 1 && debugstr != "help" && debugstr != "ssa/help" {
-               usage()
-       }
+       dwarfgen.RecordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
 
-       if goversion != "" && goversion != runtime.Version() {
-               fmt.Printf("compile: version %q does not match go tool version %q\n", runtime.Version(), goversion)
-               Exit(2)
+       if !base.EnableTrace && base.Flag.LowerT {
+               log.Fatalf("compiler not built with support for -t")
        }
 
-       checkLang()
-
-       if symabisPath != "" {
-               readSymABIs(symabisPath, myimportpath)
+       // Enable inlining (after RecordFlags, to avoid recording the rewritten -l).  For now:
+       //      default: inlining on.  (Flag.LowerL == 1)
+       //      -l: inlining off  (Flag.LowerL == 0)
+       //      -l=2, -l=3: inlining on again, with extra debugging (Flag.LowerL > 1)
+       if base.Flag.LowerL <= 1 {
+               base.Flag.LowerL = 1 - base.Flag.LowerL
        }
 
-       thearch.LinkArch.Init(Ctxt)
-
-       if outfile == "" {
-               p := flag.Arg(0)
-               if i := strings.LastIndex(p, "/"); i >= 0 {
-                       p = p[i+1:]
-               }
-               if runtime.GOOS == "windows" {
-                       if i := strings.LastIndex(p, `\`); i >= 0 {
-                               p = p[i+1:]
-                       }
-               }
-               if i := strings.LastIndex(p, "."); i >= 0 {
-                       p = p[:i]
-               }
-               suffix := ".o"
-               if writearchive {
-                       suffix = ".a"
-               }
-               outfile = p + suffix
+       if base.Flag.SmallFrames {
+               ir.MaxStackVarSize = 128 * 1024
+               ir.MaxImplicitStackVarSize = 16 * 1024
        }
 
-       startProfile()
-
-       if flag_race && flag_msan {
-               log.Fatal("cannot use both -race and -msan")
-       }
-       if flag_race || flag_msan {
-               // -race and -msan imply -d=checkptr for now.
-               Debug_checkptr = 1
-       }
-       if ispkgin(omit_pkgs) {
-               flag_race = false
-               flag_msan = false
-       }
-       if flag_race {
-               racepkg = types.NewPkg("runtime/race", "")
-       }
-       if flag_msan {
-               msanpkg = types.NewPkg("runtime/msan", "")
-       }
-       if flag_race || flag_msan {
-               instrumenting = true
-       }
-
-       if compiling_runtime && Debug.N != 0 {
-               log.Fatal("cannot disable optimizations while compiling runtime")
-       }
-       if nBackendWorkers < 1 {
-               log.Fatalf("-c must be at least 1, got %d", nBackendWorkers)
-       }
-       if nBackendWorkers > 1 && !concurrentBackendAllowed() {
-               log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
-       }
-       if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
-               log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
+       if base.Flag.Dwarf {
+               base.Ctxt.DebugInfo = dwarfgen.Info
+               base.Ctxt.GenAbstractFunc = dwarfgen.AbstractFunc
+               base.Ctxt.DwFixups = obj.NewDwarfFixupTable(base.Ctxt)
+       } else {
+               // turn off inline generation if no dwarf at all
+               base.Flag.GenDwarfInl = 0
+               base.Ctxt.Flag_locationlists = false
        }
-
-       // parse -d argument
-       if debugstr != "" {
-       Split:
-               for _, name := range strings.Split(debugstr, ",") {
-                       if name == "" {
-                               continue
-                       }
-                       // display help about the -d option itself and quit
-                       if name == "help" {
-                               fmt.Print(debugHelpHeader)
-                               maxLen := len("ssa/help")
-                               for _, t := range debugtab {
-                                       if len(t.name) > maxLen {
-                                               maxLen = len(t.name)
-                                       }
-                               }
-                               for _, t := range debugtab {
-                                       fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
-                               }
-                               // ssa options have their own help
-                               fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
-                               fmt.Print(debugHelpFooter)
-                               os.Exit(0)
-                       }
-                       val, valstring, haveInt := 1, "", true
-                       if i := strings.IndexAny(name, "=:"); i >= 0 {
-                               var err error
-                               name, valstring = name[:i], name[i+1:]
-                               val, err = strconv.Atoi(valstring)
-                               if err != nil {
-                                       val, haveInt = 1, false
-                               }
-                       }
-                       for _, t := range debugtab {
-                               if t.name != name {
-                                       continue
-                               }
-                               switch vp := t.val.(type) {
-                               case nil:
-                                       // Ignore
-                               case *string:
-                                       *vp = valstring
-                               case *int:
-                                       if !haveInt {
-                                               log.Fatalf("invalid debug value %v", name)
-                                       }
-                                       *vp = val
-                               default:
-                                       panic("bad debugtab type")
-                               }
-                               continue Split
-                       }
-                       // special case for ssa for now
-                       if strings.HasPrefix(name, "ssa/") {
-                               // expect form ssa/phase/flag
-                               // e.g. -d=ssa/generic_cse/time
-                               // _ in phase name also matches space
-                               phase := name[4:]
-                               flag := "debug" // default flag is debug
-                               if i := strings.Index(phase, "/"); i >= 0 {
-                                       flag = phase[i+1:]
-                                       phase = phase[:i]
-                               }
-                               err := ssa.PhaseOption(phase, flag, val, valstring)
-                               if err != "" {
-                                       log.Fatalf(err)
-                               }
-                               continue Split
-                       }
-                       log.Fatalf("unknown debug key -d %s\n", name)
-               }
+       if base.Ctxt.Flag_locationlists && len(base.Ctxt.Arch.DWARFRegisters) == 0 {
+               log.Fatalf("location lists requested but register mapping not available on %v", base.Ctxt.Arch.Name)
        }
 
-       if compiling_runtime {
-               // Runtime can't use -d=checkptr, at least not yet.
-               Debug_checkptr = 0
+       types.ParseLangFlag()
 
-               // Fuzzing the runtime isn't interesting either.
-               Debug_libfuzzer = 0
+       if base.Flag.SymABIs != "" {
+               ssagen.ReadSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
        }
 
-       // set via a -d flag
-       Ctxt.Debugpcln = Debug_pctab
-       if flagDWARF {
-               dwarf.EnableLogging(Debug_gendwarfinl != 0)
+       if base.Compiling(base.NoInstrumentPkgs) {
+               base.Flag.Race = false
+               base.Flag.MSan = false
        }
 
-       if Debug_softfloat != 0 {
-               thearch.SoftFloat = true
-       }
-
-       // enable inlining.  for now:
-       //      default: inlining on.  (Debug.l == 1)
-       //      -l: inlining off  (Debug.l == 0)
-       //      -l=2, -l=3: inlining on again, with extra debugging (Debug.l > 1)
-       if Debug.l <= 1 {
-               Debug.l = 1 - Debug.l
+       ssagen.Arch.LinkArch.Init(base.Ctxt)
+       startProfile()
+       if base.Flag.Race || base.Flag.MSan {
+               base.Flag.Cfg.Instrumenting = true
        }
-
-       if jsonLogOpt != "" { // parse version,destination from json logging optimization.
-               logopt.LogJsonOption(jsonLogOpt)
+       if base.Flag.Dwarf {
+               dwarf.EnableLogging(base.Debug.DwarfInl != 0)
        }
-
-       ssaDump = os.Getenv("GOSSAFUNC")
-       ssaDir = os.Getenv("GOSSADIR")
-       if ssaDump != "" {
-               if strings.HasSuffix(ssaDump, "+") {
-                       ssaDump = ssaDump[:len(ssaDump)-1]
-                       ssaDumpStdout = true
-               }
-               spl := strings.Split(ssaDump, ":")
-               if len(spl) > 1 {
-                       ssaDump = spl[0]
-                       ssaDumpCFG = spl[1]
-               }
+       if base.Debug.SoftFloat != 0 {
+               ssagen.Arch.SoftFloat = true
        }
 
-       trackScopes = flagDWARF
-
-       Widthptr = thearch.LinkArch.PtrSize
-       Widthreg = thearch.LinkArch.RegSize
-
-       // initialize types package
-       // (we need to do this to break dependencies that otherwise
-       // would lead to import cycles)
-       types.Widthptr = Widthptr
-       types.Dowidth = dowidth
-       types.Fatalf = Fatalf
-       types.Sconv = func(s *types.Sym, flag, mode int) string {
-               return sconv(s, FmtFlag(flag), fmtMode(mode))
+       if base.Flag.JSON != "" { // parse version,destination from json logging optimization.
+               logopt.LogJsonOption(base.Flag.JSON)
        }
-       types.Tconv = func(t *types.Type, flag, mode int) string {
-               return tconv(t, FmtFlag(flag), fmtMode(mode))
-       }
-       types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-               symFormat(sym, s, verb, fmtMode(mode))
-       }
-       types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-               typeFormat(t, s, verb, fmtMode(mode))
-       }
-       types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-               return typenamesym(t).Linksym()
-       }
-       types.FmtLeft = int(FmtLeft)
-       types.FmtUnsigned = int(FmtUnsigned)
-       types.FErr = int(FErr)
-       types.Ctxt = Ctxt
-
-       initUniverse()
 
-       dclcontext = PEXTERN
-       nerrors = 0
+       ir.EscFmt = escape.Fmt
+       ir.IsIntrinsicCall = ssagen.IsIntrinsicCall
+       inline.SSADumpInline = ssagen.DumpInline
+       ssagen.InitEnv()
+       ssagen.InitTables()
 
-       autogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
+       types.PtrSize = ssagen.Arch.LinkArch.PtrSize
+       types.RegSize = ssagen.Arch.LinkArch.RegSize
+       types.MaxWidth = ssagen.Arch.MAXWIDTH
 
-       timings.Start("fe", "loadsys")
-       loadsys()
+       typecheck.Target = new(ir.Package)
 
-       timings.Start("fe", "parse")
-       lines := parseFiles(flag.Args())
-       timings.Stop()
-       timings.AddEvent(int64(lines), "lines")
+       typecheck.NeedITab = func(t, iface *types.Type) { reflectdata.ITabAddr(t, iface) }
+       typecheck.NeedRuntimeType = reflectdata.NeedRuntimeType // TODO(rsc): TypeSym for lock?
 
-       finishUniverse()
+       base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
-       recordPackageName()
+       typecheck.InitUniverse()
 
-       typecheckok = true
+       // Parse and typecheck input.
+       noder.LoadPackage(flag.Args())
 
-       // Process top-level declarations in phases.
+       dwarfgen.RecordPackageName()
+       ssagen.CgoSymABIs()
 
-       // Phase 1: const, type, and names and types of funcs.
-       //   This will gather all the information about types
-       //   and methods but doesn't depend on any of it.
-       //
-       //   We also defer type alias declarations until phase 2
-       //   to avoid cycles like #18640.
-       //   TODO(gri) Remove this again once we have a fix for #25838.
-
-       // Don't use range--typecheck can add closures to xtop.
-       timings.Start("fe", "typecheck", "top1")
-       for i := 0; i < len(xtop); i++ {
-               n := xtop[i]
-               if op := n.Op; op != ODCL && op != OAS && op != OAS2 && (op != ODCLTYPE || !n.Left.Name.Param.Alias()) {
-                       xtop[i] = typecheck(n, ctxStmt)
-               }
-       }
-
-       // Phase 2: Variable assignments.
-       //   To check interface assignments, depends on phase 1.
-
-       // Don't use range--typecheck can add closures to xtop.
-       timings.Start("fe", "typecheck", "top2")
-       for i := 0; i < len(xtop); i++ {
-               n := xtop[i]
-               if op := n.Op; op == ODCL || op == OAS || op == OAS2 || op == ODCLTYPE && n.Left.Name.Param.Alias() {
-                       xtop[i] = typecheck(n, ctxStmt)
-               }
+       // Build init task.
+       if initTask := pkginit.Task(); initTask != nil {
+               typecheck.Export(initTask)
        }
 
-       // Phase 3: Type check function bodies.
-       // Don't use range--typecheck can add closures to xtop.
-       timings.Start("fe", "typecheck", "func")
-       var fcount int64
-       for i := 0; i < len(xtop); i++ {
-               n := xtop[i]
-               if n.Op == ODCLFUNC {
-                       Curfn = n
-                       decldepth = 1
-                       saveerrors()
-                       typecheckslice(Curfn.Nbody.Slice(), ctxStmt)
-                       checkreturn(Curfn)
-                       if nerrors != 0 {
-                               Curfn.Nbody.Set(nil) // type errors; do not compile
-                       }
-                       // Now that we've checked whether n terminates,
-                       // we can eliminate some obviously dead code.
-                       deadcode(Curfn)
-                       fcount++
+       // Eliminate some obviously dead code.
+       // Must happen after typechecking.
+       for _, n := range typecheck.Target.Decls {
+               if n.Op() == ir.ODCLFUNC {
+                       deadcode.Func(n.(*ir.Func))
                }
        }
-       // With all types checked, it's now safe to verify map keys. One single
-       // check past phase 9 isn't sufficient, as we may exit with other errors
-       // before then, thus skipping map key errors.
-       checkMapKeys()
-       timings.AddEvent(fcount, "funcs")
-
-       if nsavederrors+nerrors != 0 {
-               errorexit()
-       }
-
-       fninit(xtop)
 
-       // Phase 4: Decide how to capture closed variables.
-       // This needs to run before escape analysis,
-       // because variables captured by value do not escape.
-       timings.Start("fe", "capturevars")
-       for _, n := range xtop {
-               if n.Op == ODCLFUNC && n.Func.Closure != nil {
-                       Curfn = n
-                       capturevars(n)
-               }
+       // Compute Addrtaken for names.
+       // We need to wait until typechecking is done so that when we see &x[i]
+       // we know that x has its address taken if x is an array, but not if x is a slice.
+       // We compute Addrtaken in bulk here.
+       // After this phase, we maintain Addrtaken incrementally.
+       if typecheck.DirtyAddrtaken {
+               typecheck.ComputeAddrtaken(typecheck.Target.Decls)
+               typecheck.DirtyAddrtaken = false
        }
-       capturevarscomplete = true
+       typecheck.IncrementalAddrtaken = true
 
-       Curfn = nil
-
-       if nsavederrors+nerrors != 0 {
-               errorexit()
-       }
-
-       // Phase 5: Inlining
-       timings.Start("fe", "inlining")
-       if Debug_typecheckinl != 0 {
+       if base.Debug.TypecheckInl != 0 {
                // Typecheck imported function bodies if Debug.l > 1,
                // otherwise lazily when used or re-exported.
-               for _, n := range importlist {
-                       if n.Func.Inl != nil {
-                               saveerrors()
-                               typecheckinl(n)
-                       }
-               }
-
-               if nsavederrors+nerrors != 0 {
-                       errorexit()
-               }
+               typecheck.AllImportedBodies()
        }
 
-       if Debug.l != 0 {
-               // Find functions that can be inlined and clone them before walk expands them.
-               visitBottomUp(xtop, func(list []*Node, recursive bool) {
-                       numfns := numNonClosures(list)
-                       for _, n := range list {
-                               if !recursive || numfns > 1 {
-                                       // We allow inlining if there is no
-                                       // recursion, or the recursion cycle is
-                                       // across more than one function.
-                                       caninl(n)
-                               } else {
-                                       if Debug.m > 1 {
-                                               fmt.Printf("%v: cannot inline %v: recursive\n", n.Line(), n.Func.Nname)
-                                       }
-                               }
-                               inlcalls(n)
-                       }
-               })
+       // Inlining
+       base.Timer.Start("fe", "inlining")
+       if base.Flag.LowerL != 0 {
+               inline.InlinePackage()
        }
 
-       for _, n := range xtop {
-               if n.Op == ODCLFUNC {
-                       devirtualize(n)
+       // Devirtualize.
+       for _, n := range typecheck.Target.Decls {
+               if n.Op() == ir.ODCLFUNC {
+                       devirtualize.Func(n.(*ir.Func))
                }
        }
-       Curfn = nil
+       ir.CurFunc = nil
 
-       // Phase 6: Escape analysis.
+       // Escape analysis.
        // Required for moving heap allocations onto stack,
        // which in turn is required by the closure implementation,
        // which stores the addresses of stack variables into the closure.
@@ -719,140 +241,86 @@ func Main(archInit func(*Arch)) {
        // or else the stack copier will not update it.
        // Large values are also moved off stack in escape analysis;
        // because large values may contain pointers, it must happen early.
-       timings.Start("fe", "escapes")
-       escapes(xtop)
+       base.Timer.Start("fe", "escapes")
+       escape.Funcs(typecheck.Target.Decls)
 
        // Collect information for go:nowritebarrierrec
-       // checking. This must happen before transformclosure.
+       // checking. This must happen before transforming closures during Walk
        // We'll do the final check after write barriers are
        // inserted.
-       if compiling_runtime {
-               nowritebarrierrecCheck = newNowritebarrierrecChecker()
-       }
-
-       // Phase 7: Transform closure bodies to properly reference captured variables.
-       // This needs to happen before walk, because closures must be transformed
-       // before walk reaches a call of a closure.
-       timings.Start("fe", "xclosures")
-       for _, n := range xtop {
-               if n.Op == ODCLFUNC && n.Func.Closure != nil {
-                       Curfn = n
-                       transformclosure(n)
-               }
+       if base.Flag.CompilingRuntime {
+               ssagen.EnableNoWriteBarrierRecCheck()
        }
 
        // Prepare for SSA compilation.
-       // This must be before peekitabs, because peekitabs
+       // This must be before CompileITabs, because CompileITabs
        // can trigger function compilation.
-       initssaconfig()
+       typecheck.InitRuntime()
+       ssagen.InitConfig()
 
        // Just before compilation, compile itabs found on
        // the right side of OCONVIFACE so that methods
        // can be de-virtualized during compilation.
-       Curfn = nil
-       peekitabs()
-
-       // Phase 8: Compile top level functions.
-       // Don't use range--walk can add functions to xtop.
-       timings.Start("be", "compilefuncs")
-       fcount = 0
-       for i := 0; i < len(xtop); i++ {
-               n := xtop[i]
-               if n.Op == ODCLFUNC {
-                       funccompile(n)
+       ir.CurFunc = nil
+       reflectdata.CompileITabs()
+
+       // Compile top level functions.
+       // Don't use range--walk can add functions to Target.Decls.
+       base.Timer.Start("be", "compilefuncs")
+       fcount := int64(0)
+       for i := 0; i < len(typecheck.Target.Decls); i++ {
+               if fn, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
+                       enqueueFunc(fn)
                        fcount++
                }
        }
-       timings.AddEvent(fcount, "funcs")
+       base.Timer.AddEvent(fcount, "funcs")
 
        compileFunctions()
 
-       if nowritebarrierrecCheck != nil {
-               // Write barriers are now known. Check the
-               // call graph.
-               nowritebarrierrecCheck.check()
-               nowritebarrierrecCheck = nil
+       if base.Flag.CompilingRuntime {
+               // Write barriers are now known. Check the call graph.
+               ssagen.NoWriteBarrierRecCheck()
        }
 
        // Finalize DWARF inline routine DIEs, then explicitly turn off
        // DWARF inlining gen so as to avoid problems with generated
        // method wrappers.
-       if Ctxt.DwFixups != nil {
-               Ctxt.DwFixups.Finalize(myimportpath, Debug_gendwarfinl != 0)
-               Ctxt.DwFixups = nil
-               genDwarfInline = 0
-       }
-
-       // Phase 9: Check external declarations.
-       timings.Start("be", "externaldcls")
-       for i, n := range externdcl {
-               if n.Op == ONAME {
-                       externdcl[i] = typecheck(externdcl[i], ctxExpr)
-               }
-       }
-       // Check the map keys again, since we typechecked the external
-       // declarations.
-       checkMapKeys()
-
-       if nerrors+nsavederrors != 0 {
-               errorexit()
+       if base.Ctxt.DwFixups != nil {
+               base.Ctxt.DwFixups.Finalize(base.Ctxt.Pkgpath, base.Debug.DwarfInl != 0)
+               base.Ctxt.DwFixups = nil
+               base.Flag.GenDwarfInl = 0
        }
 
        // Write object data to disk.
-       timings.Start("be", "dumpobj")
+       base.Timer.Start("be", "dumpobj")
        dumpdata()
-       Ctxt.NumberSyms()
+       base.Ctxt.NumberSyms()
        dumpobj()
-       if asmhdr != "" {
+       if base.Flag.AsmHdr != "" {
                dumpasmhdr()
        }
 
-       // Check whether any of the functions we have compiled have gigantic stack frames.
-       sort.Slice(largeStackFrames, func(i, j int) bool {
-               return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
-       })
-       for _, large := range largeStackFrames {
-               if large.callee != 0 {
-                       yyerrorl(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
-               } else {
-                       yyerrorl(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
-               }
-       }
+       ssagen.CheckLargeStacks()
+       typecheck.CheckFuncStack()
 
-       if len(funcStack) != 0 {
-               Fatalf("funcStack is non-empty: %v", len(funcStack))
-       }
        if len(compilequeue) != 0 {
-               Fatalf("%d uncompiled functions", len(compilequeue))
+               base.Fatalf("%d uncompiled functions", len(compilequeue))
        }
 
-       logopt.FlushLoggedOpts(Ctxt, myimportpath)
-
-       if nerrors+nsavederrors != 0 {
-               errorexit()
-       }
+       logopt.FlushLoggedOpts(base.Ctxt, base.Ctxt.Pkgpath)
+       base.ExitIfErrors()
 
-       flusherrors()
-       timings.Stop()
+       base.FlushErrors()
+       base.Timer.Stop()
 
-       if benchfile != "" {
-               if err := writebench(benchfile); err != nil {
+       if base.Flag.Bench != "" {
+               if err := writebench(base.Flag.Bench); err != nil {
                        log.Fatalf("cannot write benchmark data: %v", err)
                }
        }
 }
 
-// numNonClosures returns the number of functions in list which are not closures.
-func numNonClosures(list []*Node) int {
-       count := 0
-       for _, n := range list {
-               if n.Func.Closure == nil {
-                       count++
-               }
-       }
-       return count
-}
-
 func writebench(filename string) error {
        f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
        if err != nil {
@@ -863,7 +331,7 @@ func writebench(filename string) error {
        fmt.Fprintln(&buf, "commit:", objabi.Version)
        fmt.Fprintln(&buf, "goos:", runtime.GOOS)
        fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
-       timings.Write(&buf, "BenchmarkCompile:"+myimportpath+":")
+       base.Timer.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
 
        n, err := f.Write(buf.Bytes())
        if err != nil {
@@ -876,735 +344,6 @@ func writebench(filename string) error {
        return f.Close()
 }
 
-var (
-       importMap   = map[string]string{}
-       packageFile map[string]string // nil means not in use
-)
-
-func addImportMap(s string) {
-       if strings.Count(s, "=") != 1 {
-               log.Fatal("-importmap argument must be of the form source=actual")
-       }
-       i := strings.Index(s, "=")
-       source, actual := s[:i], s[i+1:]
-       if source == "" || actual == "" {
-               log.Fatal("-importmap argument must be of the form source=actual; source and actual must be non-empty")
-       }
-       importMap[source] = actual
-}
-
-func readImportCfg(file string) {
-       packageFile = map[string]string{}
-       data, err := ioutil.ReadFile(file)
-       if err != nil {
-               log.Fatalf("-importcfg: %v", err)
-       }
-
-       for lineNum, line := range strings.Split(string(data), "\n") {
-               lineNum++ // 1-based
-               line = strings.TrimSpace(line)
-               if line == "" || strings.HasPrefix(line, "#") {
-                       continue
-               }
-
-               var verb, args string
-               if i := strings.Index(line, " "); i < 0 {
-                       verb = line
-               } else {
-                       verb, args = line[:i], strings.TrimSpace(line[i+1:])
-               }
-               var before, after string
-               if i := strings.Index(args, "="); i >= 0 {
-                       before, after = args[:i], args[i+1:]
-               }
-               switch verb {
-               default:
-                       log.Fatalf("%s:%d: unknown directive %q", file, lineNum, verb)
-               case "importmap":
-                       if before == "" || after == "" {
-                               log.Fatalf(`%s:%d: invalid importmap: syntax is "importmap old=new"`, file, lineNum)
-                       }
-                       importMap[before] = after
-               case "packagefile":
-                       if before == "" || after == "" {
-                               log.Fatalf(`%s:%d: invalid packagefile: syntax is "packagefile path=filename"`, file, lineNum)
-                       }
-                       packageFile[before] = after
-               }
-       }
-}
-
-// symabiDefs and symabiRefs record the defined and referenced ABIs of
-// symbols required by non-Go code. These are keyed by link symbol
-// name, where the local package prefix is always `"".`
-var symabiDefs, symabiRefs map[string]obj.ABI
-
-// readSymABIs reads a symabis file that specifies definitions and
-// references of text symbols by ABI.
-//
-// The symabis format is a set of lines, where each line is a sequence
-// of whitespace-separated fields. The first field is a verb and is
-// either "def" for defining a symbol ABI or "ref" for referencing a
-// symbol using an ABI. For both "def" and "ref", the second field is
-// the symbol name and the third field is the ABI name, as one of the
-// named cmd/internal/obj.ABI constants.
-func readSymABIs(file, myimportpath string) {
-       data, err := ioutil.ReadFile(file)
-       if err != nil {
-               log.Fatalf("-symabis: %v", err)
-       }
-
-       symabiDefs = make(map[string]obj.ABI)
-       symabiRefs = make(map[string]obj.ABI)
-
-       localPrefix := ""
-       if myimportpath != "" {
-               // Symbols in this package may be written either as
-               // "".X or with the package's import path already in
-               // the symbol.
-               localPrefix = objabi.PathToPrefix(myimportpath) + "."
-       }
-
-       for lineNum, line := range strings.Split(string(data), "\n") {
-               lineNum++ // 1-based
-               line = strings.TrimSpace(line)
-               if line == "" || strings.HasPrefix(line, "#") {
-                       continue
-               }
-
-               parts := strings.Fields(line)
-               switch parts[0] {
-               case "def", "ref":
-                       // Parse line.
-                       if len(parts) != 3 {
-                               log.Fatalf(`%s:%d: invalid symabi: syntax is "%s sym abi"`, file, lineNum, parts[0])
-                       }
-                       sym, abistr := parts[1], parts[2]
-                       abi, valid := obj.ParseABI(abistr)
-                       if !valid {
-                               log.Fatalf(`%s:%d: invalid symabi: unknown abi "%s"`, file, lineNum, abistr)
-                       }
-
-                       // If the symbol is already prefixed with
-                       // myimportpath, rewrite it to start with ""
-                       // so it matches the compiler's internal
-                       // symbol names.
-                       if localPrefix != "" && strings.HasPrefix(sym, localPrefix) {
-                               sym = `"".` + sym[len(localPrefix):]
-                       }
-
-                       // Record for later.
-                       if parts[0] == "def" {
-                               symabiDefs[sym] = abi
-                       } else {
-                               symabiRefs[sym] = abi
-                       }
-               default:
-                       log.Fatalf(`%s:%d: invalid symabi type "%s"`, file, lineNum, parts[0])
-               }
-       }
-}
-
-func saveerrors() {
-       nsavederrors += nerrors
-       nerrors = 0
-}
-
-func arsize(b *bufio.Reader, name string) int {
-       var buf [ArhdrSize]byte
-       if _, err := io.ReadFull(b, buf[:]); err != nil {
-               return -1
-       }
-       aname := strings.Trim(string(buf[0:16]), " ")
-       if !strings.HasPrefix(aname, name) {
-               return -1
-       }
-       asize := strings.Trim(string(buf[48:58]), " ")
-       i, _ := strconv.Atoi(asize)
-       return i
-}
-
-var idirs []string
-
-func addidir(dir string) {
-       if dir != "" {
-               idirs = append(idirs, dir)
-       }
-}
-
-func isDriveLetter(b byte) bool {
-       return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
-}
-
-// is this path a local name? begins with ./ or ../ or /
-func islocalname(name string) bool {
-       return strings.HasPrefix(name, "/") ||
-               runtime.GOOS == "windows" && len(name) >= 3 && isDriveLetter(name[0]) && name[1] == ':' && name[2] == '/' ||
-               strings.HasPrefix(name, "./") || name == "." ||
-               strings.HasPrefix(name, "../") || name == ".."
-}
-
-func findpkg(name string) (file string, ok bool) {
-       if islocalname(name) {
-               if nolocalimports {
-                       return "", false
-               }
-
-               if packageFile != nil {
-                       file, ok = packageFile[name]
-                       return file, ok
-               }
-
-               // try .a before .6.  important for building libraries:
-               // if there is an array.6 in the array.a library,
-               // want to find all of array.a, not just array.6.
-               file = fmt.Sprintf("%s.a", name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-               file = fmt.Sprintf("%s.o", name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-               return "", false
-       }
-
-       // local imports should be canonicalized already.
-       // don't want to see "encoding/../encoding/base64"
-       // as different from "encoding/base64".
-       if q := path.Clean(name); q != name {
-               yyerror("non-canonical import path %q (should be %q)", name, q)
-               return "", false
-       }
-
-       if packageFile != nil {
-               file, ok = packageFile[name]
-               return file, ok
-       }
-
-       for _, dir := range idirs {
-               file = fmt.Sprintf("%s/%s.a", dir, name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-               file = fmt.Sprintf("%s/%s.o", dir, name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-       }
-
-       if objabi.GOROOT != "" {
-               suffix := ""
-               suffixsep := ""
-               if flag_installsuffix != "" {
-                       suffixsep = "_"
-                       suffix = flag_installsuffix
-               } else if flag_race {
-                       suffixsep = "_"
-                       suffix = "race"
-               } else if flag_msan {
-                       suffixsep = "_"
-                       suffix = "msan"
-               }
-
-               file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-               file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-               if _, err := os.Stat(file); err == nil {
-                       return file, true
-               }
-       }
-
-       return "", false
-}
-
-// loadsys loads the definitions for the low-level runtime functions,
-// so that the compiler can generate calls to them,
-// but does not make them visible to user code.
-func loadsys() {
-       types.Block = 1
-
-       inimport = true
-       typecheckok = true
-
-       typs := runtimeTypes()
-       for _, d := range &runtimeDecls {
-               sym := Runtimepkg.Lookup(d.name)
-               typ := typs[d.typ]
-               switch d.tag {
-               case funcTag:
-                       importfunc(Runtimepkg, src.NoXPos, sym, typ)
-               case varTag:
-                       importvar(Runtimepkg, src.NoXPos, sym, typ)
-               default:
-                       Fatalf("unhandled declaration tag %v", d.tag)
-               }
-       }
-
-       typecheckok = false
-       inimport = false
-}
-
-// myheight tracks the local package's height based on packages
-// imported so far.
-var myheight int
-
-func importfile(f *Val) *types.Pkg {
-       path_, ok := f.U.(string)
-       if !ok {
-               yyerror("import path must be a string")
-               return nil
-       }
-
-       if len(path_) == 0 {
-               yyerror("import path is empty")
-               return nil
-       }
-
-       if isbadimport(path_, false) {
-               return nil
-       }
-
-       // The package name main is no longer reserved,
-       // but we reserve the import path "main" to identify
-       // the main package, just as we reserve the import
-       // path "math" to identify the standard math package.
-       if path_ == "main" {
-               yyerror("cannot import \"main\"")
-               errorexit()
-       }
-
-       if myimportpath != "" && path_ == myimportpath {
-               yyerror("import %q while compiling that package (import cycle)", path_)
-               errorexit()
-       }
-
-       if mapped, ok := importMap[path_]; ok {
-               path_ = mapped
-       }
-
-       if path_ == "unsafe" {
-               return unsafepkg
-       }
-
-       if islocalname(path_) {
-               if path_[0] == '/' {
-                       yyerror("import path cannot be absolute path")
-                       return nil
-               }
-
-               prefix := Ctxt.Pathname
-               if localimport != "" {
-                       prefix = localimport
-               }
-               path_ = path.Join(prefix, path_)
-
-               if isbadimport(path_, true) {
-                       return nil
-               }
-       }
-
-       file, found := findpkg(path_)
-       if !found {
-               yyerror("can't find import: %q", path_)
-               errorexit()
-       }
-
-       importpkg := types.NewPkg(path_, "")
-       if importpkg.Imported {
-               return importpkg
-       }
-
-       importpkg.Imported = true
-
-       imp, err := bio.Open(file)
-       if err != nil {
-               yyerror("can't open import: %q: %v", path_, err)
-               errorexit()
-       }
-       defer imp.Close()
-
-       // check object header
-       p, err := imp.ReadString('\n')
-       if err != nil {
-               yyerror("import %s: reading input: %v", file, err)
-               errorexit()
-       }
-
-       if p == "!<arch>\n" { // package archive
-               // package export block should be first
-               sz := arsize(imp.Reader, "__.PKGDEF")
-               if sz <= 0 {
-                       yyerror("import %s: not a package file", file)
-                       errorexit()
-               }
-               p, err = imp.ReadString('\n')
-               if err != nil {
-                       yyerror("import %s: reading input: %v", file, err)
-                       errorexit()
-               }
-       }
-
-       if !strings.HasPrefix(p, "go object ") {
-               yyerror("import %s: not a go object file: %s", file, p)
-               errorexit()
-       }
-       q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-       if p[10:] != q {
-               yyerror("import %s: object is [%s] expected [%s]", file, p[10:], q)
-               errorexit()
-       }
-
-       // process header lines
-       for {
-               p, err = imp.ReadString('\n')
-               if err != nil {
-                       yyerror("import %s: reading input: %v", file, err)
-                       errorexit()
-               }
-               if p == "\n" {
-                       break // header ends with blank line
-               }
-       }
-
-       // In the importfile, if we find:
-       // $$\n  (textual format): not supported anymore
-       // $$B\n (binary format) : import directly, then feed the lexer a dummy statement
-
-       // look for $$
-       var c byte
-       for {
-               c, err = imp.ReadByte()
-               if err != nil {
-                       break
-               }
-               if c == '$' {
-                       c, err = imp.ReadByte()
-                       if c == '$' || err != nil {
-                               break
-                       }
-               }
-       }
-
-       // get character after $$
-       if err == nil {
-               c, _ = imp.ReadByte()
-       }
-
-       var fingerprint goobj.FingerprintType
-       switch c {
-       case '\n':
-               yyerror("cannot import %s: old export format no longer supported (recompile library)", path_)
-               return nil
-
-       case 'B':
-               if Debug_export != 0 {
-                       fmt.Printf("importing %s (%s)\n", path_, file)
-               }
-               imp.ReadByte() // skip \n after $$B
-
-               c, err = imp.ReadByte()
-               if err != nil {
-                       yyerror("import %s: reading input: %v", file, err)
-                       errorexit()
-               }
-
-               // Indexed format is distinguished by an 'i' byte,
-               // whereas previous export formats started with 'c', 'd', or 'v'.
-               if c != 'i' {
-                       yyerror("import %s: unexpected package format byte: %v", file, c)
-                       errorexit()
-               }
-               fingerprint = iimport(importpkg, imp)
-
-       default:
-               yyerror("no import in %q", path_)
-               errorexit()
-       }
-
-       // assume files move (get installed) so don't record the full path
-       if packageFile != nil {
-               // If using a packageFile map, assume path_ can be recorded directly.
-               Ctxt.AddImport(path_, fingerprint)
-       } else {
-               // For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
-               Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
-       }
-
-       if importpkg.Height >= myheight {
-               myheight = importpkg.Height + 1
-       }
-
-       return importpkg
-}
-
-func pkgnotused(lineno src.XPos, path string, name string) {
-       // If the package was imported with a name other than the final
-       // import path element, show it explicitly in the error message.
-       // Note that this handles both renamed imports and imports of
-       // packages containing unconventional package declarations.
-       // Note that this uses / always, even on Windows, because Go import
-       // paths always use forward slashes.
-       elem := path
-       if i := strings.LastIndex(elem, "/"); i >= 0 {
-               elem = elem[i+1:]
-       }
-       if name == "" || elem == name {
-               yyerrorl(lineno, "imported and not used: %q", path)
-       } else {
-               yyerrorl(lineno, "imported and not used: %q as %s", path, name)
-       }
-}
-
-func mkpackage(pkgname string) {
-       if localpkg.Name == "" {
-               if pkgname == "_" {
-                       yyerror("invalid package name _")
-               }
-               localpkg.Name = pkgname
-       } else {
-               if pkgname != localpkg.Name {
-                       yyerror("package %s; expected %s", pkgname, localpkg.Name)
-               }
-       }
-}
-
-func clearImports() {
-       type importedPkg struct {
-               pos  src.XPos
-               path string
-               name string
-       }
-       var unused []importedPkg
-
-       for _, s := range localpkg.Syms {
-               n := asNode(s.Def)
-               if n == nil {
-                       continue
-               }
-               if n.Op == OPACK {
-                       // throw away top-level package name left over
-                       // from previous file.
-                       // leave s->block set to cause redeclaration
-                       // errors if a conflicting top-level name is
-                       // introduced by a different file.
-                       if !n.Name.Used() && nsyntaxerrors == 0 {
-                               unused = append(unused, importedPkg{n.Pos, n.Name.Pkg.Path, s.Name})
-                       }
-                       s.Def = nil
-                       continue
-               }
-               if IsAlias(s) {
-                       // throw away top-level name left over
-                       // from previous import . "x"
-                       if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && nsyntaxerrors == 0 {
-                               unused = append(unused, importedPkg{n.Name.Pack.Pos, n.Name.Pack.Name.Pkg.Path, ""})
-                               n.Name.Pack.Name.SetUsed(true)
-                       }
-                       s.Def = nil
-                       continue
-               }
-       }
-
-       sort.Slice(unused, func(i, j int) bool { return unused[i].pos.Before(unused[j].pos) })
-       for _, pkg := range unused {
-               pkgnotused(pkg.pos, pkg.path, pkg.name)
-       }
-}
-
-func IsAlias(sym *types.Sym) bool {
-       return sym.Def != nil && asNode(sym.Def).Sym != sym
-}
-
-// By default, assume any debug flags are incompatible with concurrent
-// compilation. A few are safe and potentially in common use for
-// normal compiles, though; return true for those.
-func concurrentFlagOk() bool {
-       // Report whether any debug flag that would prevent concurrent
-       // compilation is set, by zeroing out the allowed ones and then
-       // checking if the resulting struct is zero.
-       d := Debug
-       d.B = 0 // disable bounds checking
-       d.C = 0 // disable printing of columns in error messages
-       d.e = 0 // no limit on errors; errors all come from non-concurrent code
-       d.N = 0 // disable optimizations
-       d.l = 0 // disable inlining
-       d.w = 0 // all printing happens before compilation
-       d.W = 0 // all printing happens before compilation
-       d.S = 0 // printing disassembly happens at the end (but see concurrentBackendAllowed below)
-
-       return d == DebugFlags{}
-}
-
-func concurrentBackendAllowed() bool {
-       if !concurrentFlagOk() {
-               return false
-       }
-
-       // Debug.S by itself is ok, because all printing occurs
-       // while writing the object file, and that is non-concurrent.
-       // Adding Debug_vlog, however, causes Debug.S to also print
-       // while flushing the plist, which happens concurrently.
-       if Debug_vlog || debugstr != "" || debuglive > 0 {
-               return false
-       }
-       // TODO: Test and delete this condition.
-       if objabi.Fieldtrack_enabled != 0 {
-               return false
-       }
-       // TODO: fix races and enable the following flags
-       if Ctxt.Flag_shared || Ctxt.Flag_dynlink || flag_race {
-               return false
-       }
-       return true
-}
-
-// recordFlags records the specified command-line flags to be placed
-// in the DWARF info.
-func recordFlags(flags ...string) {
-       if myimportpath == "" {
-               // We can't record the flags if we don't know what the
-               // package name is.
-               return
-       }
-
-       type BoolFlag interface {
-               IsBoolFlag() bool
-       }
-       type CountFlag interface {
-               IsCountFlag() bool
-       }
-       var cmd bytes.Buffer
-       for _, name := range flags {
-               f := flag.Lookup(name)
-               if f == nil {
-                       continue
-               }
-               getter := f.Value.(flag.Getter)
-               if getter.String() == f.DefValue {
-                       // Flag has default value, so omit it.
-                       continue
-               }
-               if bf, ok := f.Value.(BoolFlag); ok && bf.IsBoolFlag() {
-                       val, ok := getter.Get().(bool)
-                       if ok && val {
-                               fmt.Fprintf(&cmd, " -%s", f.Name)
-                               continue
-                       }
-               }
-               if cf, ok := f.Value.(CountFlag); ok && cf.IsCountFlag() {
-                       val, ok := getter.Get().(int)
-                       if ok && val == 1 {
-                               fmt.Fprintf(&cmd, " -%s", f.Name)
-                               continue
-                       }
-               }
-               fmt.Fprintf(&cmd, " -%s=%v", f.Name, getter.Get())
-       }
-
-       if cmd.Len() == 0 {
-               return
-       }
-       s := Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + myimportpath)
-       s.Type = objabi.SDWARFCUINFO
-       // Sometimes (for example when building tests) we can link
-       // together two package main archives. So allow dups.
-       s.Set(obj.AttrDuplicateOK, true)
-       Ctxt.Data = append(Ctxt.Data, s)
-       s.P = cmd.Bytes()[1:]
-}
-
-// recordPackageName records the name of the package being
-// compiled, so that the linker can save it in the compile unit's DIE.
-func recordPackageName() {
-       s := Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + myimportpath)
-       s.Type = objabi.SDWARFCUINFO
-       // Sometimes (for example when building tests) we can link
-       // together two package main archives. So allow dups.
-       s.Set(obj.AttrDuplicateOK, true)
-       Ctxt.Data = append(Ctxt.Data, s)
-       s.P = []byte(localpkg.Name)
-}
-
-// flag_lang is the language version we are compiling for, set by the -lang flag.
-var flag_lang string
-
-// currentLang returns the current language version.
-func currentLang() string {
-       return fmt.Sprintf("go1.%d", goversion.Version)
-}
-
-// goVersionRE is a regular expression that matches the valid
-// arguments to the -lang flag.
-var goVersionRE = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
-
-// A lang is a language version broken into major and minor numbers.
-type lang struct {
-       major, minor int
-}
-
-// langWant is the desired language version set by the -lang flag.
-// If the -lang flag is not set, this is the zero value, meaning that
-// any language version is supported.
-var langWant lang
-
-// langSupported reports whether language version major.minor is
-// supported in a particular package.
-func langSupported(major, minor int, pkg *types.Pkg) bool {
-       if pkg == nil {
-               // TODO(mdempsky): Set Pkg for local types earlier.
-               pkg = localpkg
-       }
-       if pkg != localpkg {
-               // Assume imported packages passed type-checking.
-               return true
-       }
-
-       if langWant.major == 0 && langWant.minor == 0 {
-               return true
-       }
-       return langWant.major > major || (langWant.major == major && langWant.minor >= minor)
-}
-
-// checkLang verifies that the -lang flag holds a valid value, and
-// exits if not. It initializes data used by langSupported.
-func checkLang() {
-       if flag_lang == "" {
-               return
-       }
-
-       var err error
-       langWant, err = parseLang(flag_lang)
-       if err != nil {
-               log.Fatalf("invalid value %q for -lang: %v", flag_lang, err)
-       }
-
-       if def := currentLang(); flag_lang != def {
-               defVers, err := parseLang(def)
-               if err != nil {
-                       log.Fatalf("internal error parsing default lang %q: %v", def, err)
-               }
-               if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
-                       log.Fatalf("invalid value %q for -lang: max known version is %q", flag_lang, def)
-               }
-       }
-}
-
-// parseLang parses a -lang option into a langVer.
-func parseLang(s string) (lang, error) {
-       matches := goVersionRE.FindStringSubmatch(s)
-       if matches == nil {
-               return lang{}, fmt.Errorf(`should be something like "go1.12"`)
-       }
-       major, err := strconv.Atoi(matches[1])
-       if err != nil {
-               return lang{}, err
-       }
-       minor, err := strconv.Atoi(matches[2])
-       if err != nil {
-               return lang{}, err
-       }
-       return lang{major: major, minor: minor}, nil
+func makePos(b *src.PosBase, line, col uint) src.XPos {
+       return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
 }

diff --git a/src/cmd/compile/internal/gc/mpfloat.go b/src/cmd/compile/internal/gc/mpfloat.go
deleted file mode 100644 (file)
index 401aef3..0000000
--- a/src/cmd/compile/internal/gc/mpfloat.go
+++ /dev/null
@@ -1,357 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "fmt"
-       "math"
-       "math/big"
-)
-
-// implements float arithmetic
-
-const (
-       // Maximum size in bits for Mpints before signalling
-       // overflow and also mantissa precision for Mpflts.
-       Mpprec = 512
-       // Turn on for constant arithmetic debugging output.
-       Mpdebug = false
-)
-
-// Mpflt represents a floating-point constant.
-type Mpflt struct {
-       Val big.Float
-}
-
-// Mpcplx represents a complex constant.
-type Mpcplx struct {
-       Real Mpflt
-       Imag Mpflt
-}
-
-// Use newMpflt (not new(Mpflt)!) to get the correct default precision.
-func newMpflt() *Mpflt {
-       var a Mpflt
-       a.Val.SetPrec(Mpprec)
-       return &a
-}
-
-// Use newMpcmplx (not new(Mpcplx)!) to get the correct default precision.
-func newMpcmplx() *Mpcplx {
-       var a Mpcplx
-       a.Real = *newMpflt()
-       a.Imag = *newMpflt()
-       return &a
-}
-
-func (a *Mpflt) SetInt(b *Mpint) {
-       if b.checkOverflow(0) {
-               // sign doesn't really matter but copy anyway
-               a.Val.SetInf(b.Val.Sign() < 0)
-               return
-       }
-       a.Val.SetInt(&b.Val)
-}
-
-func (a *Mpflt) Set(b *Mpflt) {
-       a.Val.Set(&b.Val)
-}
-
-func (a *Mpflt) Add(b *Mpflt) {
-       if Mpdebug {
-               fmt.Printf("\n%v + %v", a, b)
-       }
-
-       a.Val.Add(&a.Val, &b.Val)
-
-       if Mpdebug {
-               fmt.Printf(" = %v\n\n", a)
-       }
-}
-
-func (a *Mpflt) AddFloat64(c float64) {
-       var b Mpflt
-
-       b.SetFloat64(c)
-       a.Add(&b)
-}
-
-func (a *Mpflt) Sub(b *Mpflt) {
-       if Mpdebug {
-               fmt.Printf("\n%v - %v", a, b)
-       }
-
-       a.Val.Sub(&a.Val, &b.Val)
-
-       if Mpdebug {
-               fmt.Printf(" = %v\n\n", a)
-       }
-}
-
-func (a *Mpflt) Mul(b *Mpflt) {
-       if Mpdebug {
-               fmt.Printf("%v\n * %v\n", a, b)
-       }
-
-       a.Val.Mul(&a.Val, &b.Val)
-
-       if Mpdebug {
-               fmt.Printf(" = %v\n\n", a)
-       }
-}
-
-func (a *Mpflt) MulFloat64(c float64) {
-       var b Mpflt
-
-       b.SetFloat64(c)
-       a.Mul(&b)
-}
-
-func (a *Mpflt) Quo(b *Mpflt) {
-       if Mpdebug {
-               fmt.Printf("%v\n / %v\n", a, b)
-       }
-
-       a.Val.Quo(&a.Val, &b.Val)
-
-       if Mpdebug {
-               fmt.Printf(" = %v\n\n", a)
-       }
-}
-
-func (a *Mpflt) Cmp(b *Mpflt) int {
-       return a.Val.Cmp(&b.Val)
-}
-
-func (a *Mpflt) CmpFloat64(c float64) int {
-       if c == 0 {
-               return a.Val.Sign() // common case shortcut
-       }
-       return a.Val.Cmp(big.NewFloat(c))
-}
-
-func (a *Mpflt) Float64() float64 {
-       x, _ := a.Val.Float64()
-
-       // check for overflow
-       if math.IsInf(x, 0) && nsavederrors+nerrors == 0 {
-               Fatalf("ovf in Mpflt Float64")
-       }
-
-       return x + 0 // avoid -0 (should not be needed, but be conservative)
-}
-
-func (a *Mpflt) Float32() float64 {
-       x32, _ := a.Val.Float32()
-       x := float64(x32)
-
-       // check for overflow
-       if math.IsInf(x, 0) && nsavederrors+nerrors == 0 {
-               Fatalf("ovf in Mpflt Float32")
-       }
-
-       return x + 0 // avoid -0 (should not be needed, but be conservative)
-}
-
-func (a *Mpflt) SetFloat64(c float64) {
-       if Mpdebug {
-               fmt.Printf("\nconst %g", c)
-       }
-
-       // convert -0 to 0
-       if c == 0 {
-               c = 0
-       }
-       a.Val.SetFloat64(c)
-
-       if Mpdebug {
-               fmt.Printf(" = %v\n", a)
-       }
-}
-
-func (a *Mpflt) Neg() {
-       // avoid -0
-       if a.Val.Sign() != 0 {
-               a.Val.Neg(&a.Val)
-       }
-}
-
-func (a *Mpflt) SetString(as string) {
-       f, _, err := a.Val.Parse(as, 0)
-       if err != nil {
-               yyerror("malformed constant: %s (%v)", as, err)
-               a.Val.SetFloat64(0)
-               return
-       }
-
-       if f.IsInf() {
-               yyerror("constant too large: %s", as)
-               a.Val.SetFloat64(0)
-               return
-       }
-
-       // -0 becomes 0
-       if f.Sign() == 0 && f.Signbit() {
-               a.Val.SetFloat64(0)
-       }
-}
-
-func (f *Mpflt) String() string {
-       return f.Val.Text('b', 0)
-}
-
-func (fvp *Mpflt) GoString() string {
-       // determine sign
-       sign := ""
-       f := &fvp.Val
-       if f.Sign() < 0 {
-               sign = "-"
-               f = new(big.Float).Abs(f)
-       }
-
-       // Don't try to convert infinities (will not terminate).
-       if f.IsInf() {
-               return sign + "Inf"
-       }
-
-       // Use exact fmt formatting if in float64 range (common case):
-       // proceed if f doesn't underflow to 0 or overflow to inf.
-       if x, _ := f.Float64(); f.Sign() == 0 == (x == 0) && !math.IsInf(x, 0) {
-               return fmt.Sprintf("%s%.6g", sign, x)
-       }
-
-       // Out of float64 range. Do approximate manual to decimal
-       // conversion to avoid precise but possibly slow Float
-       // formatting.
-       // f = mant * 2**exp
-       var mant big.Float
-       exp := f.MantExp(&mant) // 0.5 <= mant < 1.0
-
-       // approximate float64 mantissa m and decimal exponent d
-       // f ~ m * 10**d
-       m, _ := mant.Float64()                     // 0.5 <= m < 1.0
-       d := float64(exp) * (math.Ln2 / math.Ln10) // log_10(2)
-
-       // adjust m for truncated (integer) decimal exponent e
-       e := int64(d)
-       m *= math.Pow(10, d-float64(e))
-
-       // ensure 1 <= m < 10
-       switch {
-       case m < 1-0.5e-6:
-               // The %.6g format below rounds m to 5 digits after the
-               // decimal point. Make sure that m*10 < 10 even after
-               // rounding up: m*10 + 0.5e-5 < 10 => m < 1 - 0.5e6.
-               m *= 10
-               e--
-       case m >= 10:
-               m /= 10
-               e++
-       }
-
-       return fmt.Sprintf("%s%.6ge%+d", sign, m, e)
-}
-
-// complex multiply v *= rv
-//     (a, b) * (c, d) = (a*c - b*d, b*c + a*d)
-func (v *Mpcplx) Mul(rv *Mpcplx) {
-       var ac, ad, bc, bd Mpflt
-
-       ac.Set(&v.Real)
-       ac.Mul(&rv.Real) // ac
-
-       bd.Set(&v.Imag)
-       bd.Mul(&rv.Imag) // bd
-
-       bc.Set(&v.Imag)
-       bc.Mul(&rv.Real) // bc
-
-       ad.Set(&v.Real)
-       ad.Mul(&rv.Imag) // ad
-
-       v.Real.Set(&ac)
-       v.Real.Sub(&bd) // ac-bd
-
-       v.Imag.Set(&bc)
-       v.Imag.Add(&ad) // bc+ad
-}
-
-// complex divide v /= rv
-//     (a, b) / (c, d) = ((a*c + b*d), (b*c - a*d))/(c*c + d*d)
-func (v *Mpcplx) Div(rv *Mpcplx) bool {
-       if rv.Real.CmpFloat64(0) == 0 && rv.Imag.CmpFloat64(0) == 0 {
-               return false
-       }
-
-       var ac, ad, bc, bd, cc_plus_dd Mpflt
-
-       cc_plus_dd.Set(&rv.Real)
-       cc_plus_dd.Mul(&rv.Real) // cc
-
-       ac.Set(&rv.Imag)
-       ac.Mul(&rv.Imag)    // dd
-       cc_plus_dd.Add(&ac) // cc+dd
-
-       // We already checked that c and d are not both zero, but we can't
-       // assume that c²+d² != 0 follows, because for tiny values of c
-       // and/or d c²+d² can underflow to zero.  Check that c²+d² is
-       // nonzero, return if it's not.
-       if cc_plus_dd.CmpFloat64(0) == 0 {
-               return false
-       }
-
-       ac.Set(&v.Real)
-       ac.Mul(&rv.Real) // ac
-
-       bd.Set(&v.Imag)
-       bd.Mul(&rv.Imag) // bd
-
-       bc.Set(&v.Imag)
-       bc.Mul(&rv.Real) // bc
-
-       ad.Set(&v.Real)
-       ad.Mul(&rv.Imag) // ad
-
-       v.Real.Set(&ac)
-       v.Real.Add(&bd)         // ac+bd
-       v.Real.Quo(&cc_plus_dd) // (ac+bd)/(cc+dd)
-
-       v.Imag.Set(&bc)
-       v.Imag.Sub(&ad)         // bc-ad
-       v.Imag.Quo(&cc_plus_dd) // (bc+ad)/(cc+dd)
-
-       return true
-}
-
-func (v *Mpcplx) String() string {
-       return fmt.Sprintf("(%s+%si)", v.Real.String(), v.Imag.String())
-}
-
-func (v *Mpcplx) GoString() string {
-       var re string
-       sre := v.Real.CmpFloat64(0)
-       if sre != 0 {
-               re = v.Real.GoString()
-       }
-
-       var im string
-       sim := v.Imag.CmpFloat64(0)
-       if sim != 0 {
-               im = v.Imag.GoString()
-       }
-
-       switch {
-       case sre == 0 && sim == 0:
-               return "0"
-       case sre == 0:
-               return im + "i"
-       case sim == 0:
-               return re
-       case sim < 0:
-               return fmt.Sprintf("(%s%si)", re, im)
-       default:
-               return fmt.Sprintf("(%s+%si)", re, im)
-       }
-}

diff --git a/src/cmd/compile/internal/gc/mpint.go b/src/cmd/compile/internal/gc/mpint.go
deleted file mode 100644 (file)
index 340350b..0000000
--- a/src/cmd/compile/internal/gc/mpint.go
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "fmt"
-       "math/big"
-)
-
-// implements integer arithmetic
-
-// Mpint represents an integer constant.
-type Mpint struct {
-       Val  big.Int
-       Ovf  bool // set if Val overflowed compiler limit (sticky)
-       Rune bool // set if syntax indicates default type rune
-}
-
-func (a *Mpint) SetOverflow() {
-       a.Val.SetUint64(1) // avoid spurious div-zero errors
-       a.Ovf = true
-}
-
-func (a *Mpint) checkOverflow(extra int) bool {
-       // We don't need to be precise here, any reasonable upper limit would do.
-       // For now, use existing limit so we pass all the tests unchanged.
-       if a.Val.BitLen()+extra > Mpprec {
-               a.SetOverflow()
-       }
-       return a.Ovf
-}
-
-func (a *Mpint) Set(b *Mpint) {
-       a.Val.Set(&b.Val)
-}
-
-func (a *Mpint) SetFloat(b *Mpflt) bool {
-       // avoid converting huge floating-point numbers to integers
-       // (2*Mpprec is large enough to permit all tests to pass)
-       if b.Val.MantExp(nil) > 2*Mpprec {
-               a.SetOverflow()
-               return false
-       }
-
-       if _, acc := b.Val.Int(&a.Val); acc == big.Exact {
-               return true
-       }
-
-       const delta = 16 // a reasonably small number of bits > 0
-       var t big.Float
-       t.SetPrec(Mpprec - delta)
-
-       // try rounding down a little
-       t.SetMode(big.ToZero)
-       t.Set(&b.Val)
-       if _, acc := t.Int(&a.Val); acc == big.Exact {
-               return true
-       }
-
-       // try rounding up a little
-       t.SetMode(big.AwayFromZero)
-       t.Set(&b.Val)
-       if _, acc := t.Int(&a.Val); acc == big.Exact {
-               return true
-       }
-
-       a.Ovf = false
-       return false
-}
-
-func (a *Mpint) Add(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Add")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Add(&a.Val, &b.Val)
-
-       if a.checkOverflow(0) {
-               yyerror("constant addition overflow")
-       }
-}
-
-func (a *Mpint) Sub(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Sub")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Sub(&a.Val, &b.Val)
-
-       if a.checkOverflow(0) {
-               yyerror("constant subtraction overflow")
-       }
-}
-
-func (a *Mpint) Mul(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Mul")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Mul(&a.Val, &b.Val)
-
-       if a.checkOverflow(0) {
-               yyerror("constant multiplication overflow")
-       }
-}
-
-func (a *Mpint) Quo(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Quo")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Quo(&a.Val, &b.Val)
-
-       if a.checkOverflow(0) {
-               // can only happen for div-0 which should be checked elsewhere
-               yyerror("constant division overflow")
-       }
-}
-
-func (a *Mpint) Rem(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Rem")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Rem(&a.Val, &b.Val)
-
-       if a.checkOverflow(0) {
-               // should never happen
-               yyerror("constant modulo overflow")
-       }
-}
-
-func (a *Mpint) Or(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Or")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Or(&a.Val, &b.Val)
-}
-
-func (a *Mpint) And(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint And")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.And(&a.Val, &b.Val)
-}
-
-func (a *Mpint) AndNot(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint AndNot")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.AndNot(&a.Val, &b.Val)
-}
-
-func (a *Mpint) Xor(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Xor")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       a.Val.Xor(&a.Val, &b.Val)
-}
-
-func (a *Mpint) Lsh(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Lsh")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       s := b.Int64()
-       if s < 0 || s >= Mpprec {
-               msg := "shift count too large"
-               if s < 0 {
-                       msg = "invalid negative shift count"
-               }
-               yyerror("%s: %d", msg, s)
-               a.SetInt64(0)
-               return
-       }
-
-       if a.checkOverflow(int(s)) {
-               yyerror("constant shift overflow")
-               return
-       }
-       a.Val.Lsh(&a.Val, uint(s))
-}
-
-func (a *Mpint) Rsh(b *Mpint) {
-       if a.Ovf || b.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("ovf in Mpint Rsh")
-               }
-               a.SetOverflow()
-               return
-       }
-
-       s := b.Int64()
-       if s < 0 {
-               yyerror("invalid negative shift count: %d", s)
-               if a.Val.Sign() < 0 {
-                       a.SetInt64(-1)
-               } else {
-                       a.SetInt64(0)
-               }
-               return
-       }
-
-       a.Val.Rsh(&a.Val, uint(s))
-}
-
-func (a *Mpint) Cmp(b *Mpint) int {
-       return a.Val.Cmp(&b.Val)
-}
-
-func (a *Mpint) CmpInt64(c int64) int {
-       if c == 0 {
-               return a.Val.Sign() // common case shortcut
-       }
-       return a.Val.Cmp(big.NewInt(c))
-}
-
-func (a *Mpint) Neg() {
-       a.Val.Neg(&a.Val)
-}
-
-func (a *Mpint) Int64() int64 {
-       if a.Ovf {
-               if nsavederrors+nerrors == 0 {
-                       Fatalf("constant overflow")
-               }
-               return 0
-       }
-
-       return a.Val.Int64()
-}
-
-func (a *Mpint) SetInt64(c int64) {
-       a.Val.SetInt64(c)
-}
-
-func (a *Mpint) SetString(as string) {
-       _, ok := a.Val.SetString(as, 0)
-       if !ok {
-               // The lexer checks for correct syntax of the literal
-               // and reports detailed errors. Thus SetString should
-               // never fail (in theory it might run out of memory,
-               // but that wouldn't be reported as an error here).
-               Fatalf("malformed integer constant: %s", as)
-               return
-       }
-       if a.checkOverflow(0) {
-               yyerror("constant too large: %s", as)
-       }
-}
-
-func (a *Mpint) GoString() string {
-       return a.Val.String()
-}
-
-func (a *Mpint) String() string {
-       return fmt.Sprintf("%#x", &a.Val)
-}

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
deleted file mode 100644 (file)
index 67d24ef..0000000
--- a/src/cmd/compile/internal/gc/noder.go
+++ /dev/null
@@ -1,1756 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "fmt"
-       "os"
-       "path/filepath"
-       "runtime"
-       "strconv"
-       "strings"
-       "unicode"
-       "unicode/utf8"
-
-       "cmd/compile/internal/syntax"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
-)
-
-// parseFiles concurrently parses files into *syntax.File structures.
-// Each declaration in every *syntax.File is converted to a syntax tree
-// and its root represented by *Node is appended to xtop.
-// Returns the total count of parsed lines.
-func parseFiles(filenames []string) uint {
-       noders := make([]*noder, 0, len(filenames))
-       // Limit the number of simultaneously open files.
-       sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
-
-       for _, filename := range filenames {
-               p := &noder{
-                       basemap: make(map[*syntax.PosBase]*src.PosBase),
-                       err:     make(chan syntax.Error),
-               }
-               noders = append(noders, p)
-
-               go func(filename string) {
-                       sem <- struct{}{}
-                       defer func() { <-sem }()
-                       defer close(p.err)
-                       base := syntax.NewFileBase(filename)
-
-                       f, err := os.Open(filename)
-                       if err != nil {
-                               p.error(syntax.Error{Msg: err.Error()})
-                               return
-                       }
-                       defer f.Close()
-
-                       p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
-               }(filename)
-       }
-
-       var lines uint
-       for _, p := range noders {
-               for e := range p.err {
-                       p.yyerrorpos(e.Pos, "%s", e.Msg)
-               }
-
-               p.node()
-               lines += p.file.Lines
-               p.file = nil // release memory
-
-               if nsyntaxerrors != 0 {
-                       errorexit()
-               }
-               // Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
-               testdclstack()
-       }
-
-       localpkg.Height = myheight
-
-       return lines
-}
-
-// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
-func (p *noder) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
-       // fast path: most likely PosBase hasn't changed
-       if p.basecache.last == b0 {
-               return p.basecache.base
-       }
-
-       b1, ok := p.basemap[b0]
-       if !ok {
-               fn := b0.Filename()
-               if b0.IsFileBase() {
-                       b1 = src.NewFileBase(fn, absFilename(fn))
-               } else {
-                       // line directive base
-                       p0 := b0.Pos()
-                       p0b := p0.Base()
-                       if p0b == b0 {
-                               panic("infinite recursion in makeSrcPosBase")
-                       }
-                       p1 := src.MakePos(p.makeSrcPosBase(p0b), p0.Line(), p0.Col())
-                       b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
-               }
-               p.basemap[b0] = b1
-       }
-
-       // update cache
-       p.basecache.last = b0
-       p.basecache.base = b1
-
-       return b1
-}
-
-func (p *noder) makeXPos(pos syntax.Pos) (_ src.XPos) {
-       return Ctxt.PosTable.XPos(src.MakePos(p.makeSrcPosBase(pos.Base()), pos.Line(), pos.Col()))
-}
-
-func (p *noder) yyerrorpos(pos syntax.Pos, format string, args ...interface{}) {
-       yyerrorl(p.makeXPos(pos), format, args...)
-}
-
-var pathPrefix string
-
-// TODO(gri) Can we eliminate fileh in favor of absFilename?
-func fileh(name string) string {
-       return objabi.AbsFile("", name, pathPrefix)
-}
-
-func absFilename(name string) string {
-       return objabi.AbsFile(Ctxt.Pathname, name, pathPrefix)
-}
-
-// noder transforms package syntax's AST into a Node tree.
-type noder struct {
-       basemap   map[*syntax.PosBase]*src.PosBase
-       basecache struct {
-               last *syntax.PosBase
-               base *src.PosBase
-       }
-
-       file           *syntax.File
-       linknames      []linkname
-       pragcgobuf     [][]string
-       err            chan syntax.Error
-       scope          ScopeID
-       importedUnsafe bool
-       importedEmbed  bool
-
-       // scopeVars is a stack tracking the number of variables declared in the
-       // current function at the moment each open scope was opened.
-       scopeVars []int
-
-       lastCloseScopePos syntax.Pos
-}
-
-func (p *noder) funcBody(fn *Node, block *syntax.BlockStmt) {
-       oldScope := p.scope
-       p.scope = 0
-       funchdr(fn)
-
-       if block != nil {
-               body := p.stmts(block.List)
-               if body == nil {
-                       body = []*Node{nod(OEMPTY, nil, nil)}
-               }
-               fn.Nbody.Set(body)
-
-               lineno = p.makeXPos(block.Rbrace)
-               fn.Func.Endlineno = lineno
-       }
-
-       funcbody()
-       p.scope = oldScope
-}
-
-func (p *noder) openScope(pos syntax.Pos) {
-       types.Markdcl()
-
-       if trackScopes {
-               Curfn.Func.Parents = append(Curfn.Func.Parents, p.scope)
-               p.scopeVars = append(p.scopeVars, len(Curfn.Func.Dcl))
-               p.scope = ScopeID(len(Curfn.Func.Parents))
-
-               p.markScope(pos)
-       }
-}
-
-func (p *noder) closeScope(pos syntax.Pos) {
-       p.lastCloseScopePos = pos
-       types.Popdcl()
-
-       if trackScopes {
-               scopeVars := p.scopeVars[len(p.scopeVars)-1]
-               p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
-               if scopeVars == len(Curfn.Func.Dcl) {
-                       // no variables were declared in this scope, so we can retract it.
-
-                       if int(p.scope) != len(Curfn.Func.Parents) {
-                               Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
-                       }
-
-                       p.scope = Curfn.Func.Parents[p.scope-1]
-                       Curfn.Func.Parents = Curfn.Func.Parents[:len(Curfn.Func.Parents)-1]
-
-                       nmarks := len(Curfn.Func.Marks)
-                       Curfn.Func.Marks[nmarks-1].Scope = p.scope
-                       prevScope := ScopeID(0)
-                       if nmarks >= 2 {
-                               prevScope = Curfn.Func.Marks[nmarks-2].Scope
-                       }
-                       if Curfn.Func.Marks[nmarks-1].Scope == prevScope {
-                               Curfn.Func.Marks = Curfn.Func.Marks[:nmarks-1]
-                       }
-                       return
-               }
-
-               p.scope = Curfn.Func.Parents[p.scope-1]
-
-               p.markScope(pos)
-       }
-}
-
-func (p *noder) markScope(pos syntax.Pos) {
-       xpos := p.makeXPos(pos)
-       if i := len(Curfn.Func.Marks); i > 0 && Curfn.Func.Marks[i-1].Pos == xpos {
-               Curfn.Func.Marks[i-1].Scope = p.scope
-       } else {
-               Curfn.Func.Marks = append(Curfn.Func.Marks, Mark{xpos, p.scope})
-       }
-}
-
-// closeAnotherScope is like closeScope, but it reuses the same mark
-// position as the last closeScope call. This is useful for "for" and
-// "if" statements, as their implicit blocks always end at the same
-// position as an explicit block.
-func (p *noder) closeAnotherScope() {
-       p.closeScope(p.lastCloseScopePos)
-}
-
-// linkname records a //go:linkname directive.
-type linkname struct {
-       pos    syntax.Pos
-       local  string
-       remote string
-}
-
-func (p *noder) node() {
-       types.Block = 1
-       p.importedUnsafe = false
-       p.importedEmbed = false
-
-       p.setlineno(p.file.PkgName)
-       mkpackage(p.file.PkgName.Value)
-
-       if pragma, ok := p.file.Pragma.(*Pragma); ok {
-               pragma.Flag &^= GoBuildPragma
-               p.checkUnused(pragma)
-       }
-
-       xtop = append(xtop, p.decls(p.file.DeclList)...)
-
-       for _, n := range p.linknames {
-               if !p.importedUnsafe {
-                       p.yyerrorpos(n.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
-                       continue
-               }
-               s := lookup(n.local)
-               if n.remote != "" {
-                       s.Linkname = n.remote
-               } else {
-                       // Use the default object symbol name if the
-                       // user didn't provide one.
-                       if myimportpath == "" {
-                               p.yyerrorpos(n.pos, "//go:linkname requires linkname argument or -p compiler flag")
-                       } else {
-                               s.Linkname = objabi.PathToPrefix(myimportpath) + "." + n.local
-                       }
-               }
-       }
-
-       // The linker expects an ABI0 wrapper for all cgo-exported
-       // functions.
-       for _, prag := range p.pragcgobuf {
-               switch prag[0] {
-               case "cgo_export_static", "cgo_export_dynamic":
-                       if symabiRefs == nil {
-                               symabiRefs = make(map[string]obj.ABI)
-                       }
-                       symabiRefs[prag[1]] = obj.ABI0
-               }
-       }
-
-       pragcgobuf = append(pragcgobuf, p.pragcgobuf...)
-       lineno = src.NoXPos
-       clearImports()
-}
-
-func (p *noder) decls(decls []syntax.Decl) (l []*Node) {
-       var cs constState
-
-       for _, decl := range decls {
-               p.setlineno(decl)
-               switch decl := decl.(type) {
-               case *syntax.ImportDecl:
-                       p.importDecl(decl)
-
-               case *syntax.VarDecl:
-                       l = append(l, p.varDecl(decl)...)
-
-               case *syntax.ConstDecl:
-                       l = append(l, p.constDecl(decl, &cs)...)
-
-               case *syntax.TypeDecl:
-                       l = append(l, p.typeDecl(decl))
-
-               case *syntax.FuncDecl:
-                       l = append(l, p.funcDecl(decl))
-
-               default:
-                       panic("unhandled Decl")
-               }
-       }
-
-       return
-}
-
-func (p *noder) importDecl(imp *syntax.ImportDecl) {
-       if imp.Path.Bad {
-               return // avoid follow-on errors if there was a syntax error
-       }
-
-       if pragma, ok := imp.Pragma.(*Pragma); ok {
-               p.checkUnused(pragma)
-       }
-
-       val := p.basicLit(imp.Path)
-       ipkg := importfile(&val)
-       if ipkg == nil {
-               if nerrors == 0 {
-                       Fatalf("phase error in import")
-               }
-               return
-       }
-
-       if ipkg == unsafepkg {
-               p.importedUnsafe = true
-       }
-       if ipkg.Path == "embed" {
-               p.importedEmbed = true
-       }
-
-       ipkg.Direct = true
-
-       var my *types.Sym
-       if imp.LocalPkgName != nil {
-               my = p.name(imp.LocalPkgName)
-       } else {
-               my = lookup(ipkg.Name)
-       }
-
-       pack := p.nod(imp, OPACK, nil, nil)
-       pack.Sym = my
-       pack.Name.Pkg = ipkg
-
-       switch my.Name {
-       case ".":
-               importdot(ipkg, pack)
-               return
-       case "init":
-               yyerrorl(pack.Pos, "cannot import package as init - init must be a func")
-               return
-       case "_":
-               return
-       }
-       if my.Def != nil {
-               redeclare(pack.Pos, my, "as imported package name")
-       }
-       my.Def = asTypesNode(pack)
-       my.Lastlineno = pack.Pos
-       my.Block = 1 // at top level
-}
-
-func (p *noder) varDecl(decl *syntax.VarDecl) []*Node {
-       names := p.declNames(decl.NameList)
-       typ := p.typeExprOrNil(decl.Type)
-
-       var exprs []*Node
-       if decl.Values != nil {
-               exprs = p.exprList(decl.Values)
-       }
-
-       if pragma, ok := decl.Pragma.(*Pragma); ok {
-               if len(pragma.Embeds) > 0 {
-                       if !p.importedEmbed {
-                               // This check can't be done when building the list pragma.Embeds
-                               // because that list is created before the noder starts walking over the file,
-                               // so at that point it hasn't seen the imports.
-                               // We're left to check now, just before applying the //go:embed lines.
-                               for _, e := range pragma.Embeds {
-                                       p.yyerrorpos(e.Pos, "//go:embed only allowed in Go files that import \"embed\"")
-                               }
-                       } else {
-                               exprs = varEmbed(p, names, typ, exprs, pragma.Embeds)
-                       }
-                       pragma.Embeds = nil
-               }
-               p.checkUnused(pragma)
-       }
-
-       p.setlineno(decl)
-       return variter(names, typ, exprs)
-}
-
-// constState tracks state between constant specifiers within a
-// declaration group. This state is kept separate from noder so nested
-// constant declarations are handled correctly (e.g., issue 15550).
-type constState struct {
-       group  *syntax.Group
-       typ    *Node
-       values []*Node
-       iota   int64
-}
-
-func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
-       if decl.Group == nil || decl.Group != cs.group {
-               *cs = constState{
-                       group: decl.Group,
-               }
-       }
-
-       if pragma, ok := decl.Pragma.(*Pragma); ok {
-               p.checkUnused(pragma)
-       }
-
-       names := p.declNames(decl.NameList)
-       typ := p.typeExprOrNil(decl.Type)
-
-       var values []*Node
-       if decl.Values != nil {
-               values = p.exprList(decl.Values)
-               cs.typ, cs.values = typ, values
-       } else {
-               if typ != nil {
-                       yyerror("const declaration cannot have type without expression")
-               }
-               typ, values = cs.typ, cs.values
-       }
-
-       nn := make([]*Node, 0, len(names))
-       for i, n := range names {
-               if i >= len(values) {
-                       yyerror("missing value in const declaration")
-                       break
-               }
-               v := values[i]
-               if decl.Values == nil {
-                       v = treecopy(v, n.Pos)
-               }
-
-               n.Op = OLITERAL
-               declare(n, dclcontext)
-
-               n.Name.Param.Ntype = typ
-               n.Name.Defn = v
-               n.SetIota(cs.iota)
-
-               nn = append(nn, p.nod(decl, ODCLCONST, n, nil))
-       }
-
-       if len(values) > len(names) {
-               yyerror("extra expression in const declaration")
-       }
-
-       cs.iota++
-
-       return nn
-}
-
-func (p *noder) typeDecl(decl *syntax.TypeDecl) *Node {
-       n := p.declName(decl.Name)
-       n.Op = OTYPE
-       declare(n, dclcontext)
-
-       // decl.Type may be nil but in that case we got a syntax error during parsing
-       typ := p.typeExprOrNil(decl.Type)
-
-       param := n.Name.Param
-       param.Ntype = typ
-       param.SetAlias(decl.Alias)
-       if pragma, ok := decl.Pragma.(*Pragma); ok {
-               if !decl.Alias {
-                       param.SetPragma(pragma.Flag & TypePragmas)
-                       pragma.Flag &^= TypePragmas
-               }
-               p.checkUnused(pragma)
-       }
-
-       nod := p.nod(decl, ODCLTYPE, n, nil)
-       if param.Alias() && !langSupported(1, 9, localpkg) {
-               yyerrorl(nod.Pos, "type aliases only supported as of -lang=go1.9")
-       }
-       return nod
-}
-
-func (p *noder) declNames(names []*syntax.Name) []*Node {
-       nodes := make([]*Node, 0, len(names))
-       for _, name := range names {
-               nodes = append(nodes, p.declName(name))
-       }
-       return nodes
-}
-
-func (p *noder) declName(name *syntax.Name) *Node {
-       n := dclname(p.name(name))
-       n.Pos = p.pos(name)
-       return n
-}
-
-func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
-       name := p.name(fun.Name)
-       t := p.signature(fun.Recv, fun.Type)
-       f := p.nod(fun, ODCLFUNC, nil, nil)
-
-       if fun.Recv == nil {
-               if name.Name == "init" {
-                       name = renameinit()
-                       if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-                               yyerrorl(f.Pos, "func init must have no arguments and no return values")
-                       }
-               }
-
-               if localpkg.Name == "main" && name.Name == "main" {
-                       if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-                               yyerrorl(f.Pos, "func main must have no arguments and no return values")
-                       }
-               }
-       } else {
-               f.Func.Shortname = name
-               name = nblank.Sym // filled in by typecheckfunc
-       }
-
-       f.Func.Nname = newfuncnamel(p.pos(fun.Name), name)
-       f.Func.Nname.Name.Defn = f
-       f.Func.Nname.Name.Param.Ntype = t
-
-       if pragma, ok := fun.Pragma.(*Pragma); ok {
-               f.Func.Pragma = pragma.Flag & FuncPragmas
-               if pragma.Flag&Systemstack != 0 && pragma.Flag&Nosplit != 0 {
-                       yyerrorl(f.Pos, "go:nosplit and go:systemstack cannot be combined")
-               }
-               pragma.Flag &^= FuncPragmas
-               p.checkUnused(pragma)
-       }
-
-       if fun.Recv == nil {
-               declare(f.Func.Nname, PFUNC)
-       }
-
-       p.funcBody(f, fun.Body)
-
-       if fun.Body != nil {
-               if f.Func.Pragma&Noescape != 0 {
-                       yyerrorl(f.Pos, "can only use //go:noescape with external func implementations")
-               }
-       } else {
-               if pure_go || strings.HasPrefix(f.funcname(), "init.") {
-                       // Linknamed functions are allowed to have no body. Hopefully
-                       // the linkname target has a body. See issue 23311.
-                       isLinknamed := false
-                       for _, n := range p.linknames {
-                               if f.funcname() == n.local {
-                                       isLinknamed = true
-                                       break
-                               }
-                       }
-                       if !isLinknamed {
-                               yyerrorl(f.Pos, "missing function body")
-                       }
-               }
-       }
-
-       return f
-}
-
-func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *Node {
-       n := p.nod(typ, OTFUNC, nil, nil)
-       if recv != nil {
-               n.Left = p.param(recv, false, false)
-       }
-       n.List.Set(p.params(typ.ParamList, true))
-       n.Rlist.Set(p.params(typ.ResultList, false))
-       return n
-}
-
-func (p *noder) params(params []*syntax.Field, dddOk bool) []*Node {
-       nodes := make([]*Node, 0, len(params))
-       for i, param := range params {
-               p.setlineno(param)
-               nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
-       }
-       return nodes
-}
-
-func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
-       var name *types.Sym
-       if param.Name != nil {
-               name = p.name(param.Name)
-       }
-
-       typ := p.typeExpr(param.Type)
-       n := p.nodSym(param, ODCLFIELD, typ, name)
-
-       // rewrite ...T parameter
-       if typ.Op == ODDD {
-               if !dddOk {
-                       // We mark these as syntax errors to get automatic elimination
-                       // of multiple such errors per line (see yyerrorl in subr.go).
-                       yyerror("syntax error: cannot use ... in receiver or result parameter list")
-               } else if !final {
-                       if param.Name == nil {
-                               yyerror("syntax error: cannot use ... with non-final parameter")
-                       } else {
-                               p.yyerrorpos(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
-                       }
-               }
-               typ.Op = OTARRAY
-               typ.Right = typ.Left
-               typ.Left = nil
-               n.SetIsDDD(true)
-               if n.Left != nil {
-                       n.Left.SetIsDDD(true)
-               }
-       }
-
-       return n
-}
-
-func (p *noder) exprList(expr syntax.Expr) []*Node {
-       if list, ok := expr.(*syntax.ListExpr); ok {
-               return p.exprs(list.ElemList)
-       }
-       return []*Node{p.expr(expr)}
-}
-
-func (p *noder) exprs(exprs []syntax.Expr) []*Node {
-       nodes := make([]*Node, 0, len(exprs))
-       for _, expr := range exprs {
-               nodes = append(nodes, p.expr(expr))
-       }
-       return nodes
-}
-
-func (p *noder) expr(expr syntax.Expr) *Node {
-       p.setlineno(expr)
-       switch expr := expr.(type) {
-       case nil, *syntax.BadExpr:
-               return nil
-       case *syntax.Name:
-               return p.mkname(expr)
-       case *syntax.BasicLit:
-               n := nodlit(p.basicLit(expr))
-               n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
-               return n
-       case *syntax.CompositeLit:
-               n := p.nod(expr, OCOMPLIT, nil, nil)
-               if expr.Type != nil {
-                       n.Right = p.expr(expr.Type)
-               }
-               l := p.exprs(expr.ElemList)
-               for i, e := range l {
-                       l[i] = p.wrapname(expr.ElemList[i], e)
-               }
-               n.List.Set(l)
-               lineno = p.makeXPos(expr.Rbrace)
-               return n
-       case *syntax.KeyValueExpr:
-               // use position of expr.Key rather than of expr (which has position of ':')
-               return p.nod(expr.Key, OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
-       case *syntax.FuncLit:
-               return p.funcLit(expr)
-       case *syntax.ParenExpr:
-               return p.nod(expr, OPAREN, p.expr(expr.X), nil)
-       case *syntax.SelectorExpr:
-               // parser.new_dotname
-               obj := p.expr(expr.X)
-               if obj.Op == OPACK {
-                       obj.Name.SetUsed(true)
-                       return importName(obj.Name.Pkg.Lookup(expr.Sel.Value))
-               }
-               n := nodSym(OXDOT, obj, p.name(expr.Sel))
-               n.Pos = p.pos(expr) // lineno may have been changed by p.expr(expr.X)
-               return n
-       case *syntax.IndexExpr:
-               return p.nod(expr, OINDEX, p.expr(expr.X), p.expr(expr.Index))
-       case *syntax.SliceExpr:
-               op := OSLICE
-               if expr.Full {
-                       op = OSLICE3
-               }
-               n := p.nod(expr, op, p.expr(expr.X), nil)
-               var index [3]*Node
-               for i, x := range &expr.Index {
-                       if x != nil {
-                               index[i] = p.expr(x)
-                       }
-               }
-               n.SetSliceBounds(index[0], index[1], index[2])
-               return n
-       case *syntax.AssertExpr:
-               return p.nod(expr, ODOTTYPE, p.expr(expr.X), p.typeExpr(expr.Type))
-       case *syntax.Operation:
-               if expr.Op == syntax.Add && expr.Y != nil {
-                       return p.sum(expr)
-               }
-               x := p.expr(expr.X)
-               if expr.Y == nil {
-                       return p.nod(expr, p.unOp(expr.Op), x, nil)
-               }
-               return p.nod(expr, p.binOp(expr.Op), x, p.expr(expr.Y))
-       case *syntax.CallExpr:
-               n := p.nod(expr, OCALL, p.expr(expr.Fun), nil)
-               n.List.Set(p.exprs(expr.ArgList))
-               n.SetIsDDD(expr.HasDots)
-               return n
-
-       case *syntax.ArrayType:
-               var len *Node
-               if expr.Len != nil {
-                       len = p.expr(expr.Len)
-               } else {
-                       len = p.nod(expr, ODDD, nil, nil)
-               }
-               return p.nod(expr, OTARRAY, len, p.typeExpr(expr.Elem))
-       case *syntax.SliceType:
-               return p.nod(expr, OTARRAY, nil, p.typeExpr(expr.Elem))
-       case *syntax.DotsType:
-               return p.nod(expr, ODDD, p.typeExpr(expr.Elem), nil)
-       case *syntax.StructType:
-               return p.structType(expr)
-       case *syntax.InterfaceType:
-               return p.interfaceType(expr)
-       case *syntax.FuncType:
-               return p.signature(nil, expr)
-       case *syntax.MapType:
-               return p.nod(expr, OTMAP, p.typeExpr(expr.Key), p.typeExpr(expr.Value))
-       case *syntax.ChanType:
-               n := p.nod(expr, OTCHAN, p.typeExpr(expr.Elem), nil)
-               n.SetTChanDir(p.chanDir(expr.Dir))
-               return n
-
-       case *syntax.TypeSwitchGuard:
-               n := p.nod(expr, OTYPESW, nil, p.expr(expr.X))
-               if expr.Lhs != nil {
-                       n.Left = p.declName(expr.Lhs)
-                       if n.Left.isBlank() {
-                               yyerror("invalid variable name %v in type switch", n.Left)
-                       }
-               }
-               return n
-       }
-       panic("unhandled Expr")
-}
-
-// sum efficiently handles very large summation expressions (such as
-// in issue #16394). In particular, it avoids left recursion and
-// collapses string literals.
-func (p *noder) sum(x syntax.Expr) *Node {
-       // While we need to handle long sums with asymptotic
-       // efficiency, the vast majority of sums are very small: ~95%
-       // have only 2 or 3 operands, and ~99% of string literals are
-       // never concatenated.
-
-       adds := make([]*syntax.Operation, 0, 2)
-       for {
-               add, ok := x.(*syntax.Operation)
-               if !ok || add.Op != syntax.Add || add.Y == nil {
-                       break
-               }
-               adds = append(adds, add)
-               x = add.X
-       }
-
-       // nstr is the current rightmost string literal in the
-       // summation (if any), and chunks holds its accumulated
-       // substrings.
-       //
-       // Consider the expression x + "a" + "b" + "c" + y. When we
-       // reach the string literal "a", we assign nstr to point to
-       // its corresponding Node and initialize chunks to {"a"}.
-       // Visiting the subsequent string literals "b" and "c", we
-       // simply append their values to chunks. Finally, when we
-       // reach the non-constant operand y, we'll join chunks to form
-       // "abc" and reassign the "a" string literal's value.
-       //
-       // N.B., we need to be careful about named string constants
-       // (indicated by Sym != nil) because 1) we can't modify their
-       // value, as doing so would affect other uses of the string
-       // constant, and 2) they may have types, which we need to
-       // handle correctly. For now, we avoid these problems by
-       // treating named string constants the same as non-constant
-       // operands.
-       var nstr *Node
-       chunks := make([]string, 0, 1)
-
-       n := p.expr(x)
-       if Isconst(n, CTSTR) && n.Sym == nil {
-               nstr = n
-               chunks = append(chunks, nstr.StringVal())
-       }
-
-       for i := len(adds) - 1; i >= 0; i-- {
-               add := adds[i]
-
-               r := p.expr(add.Y)
-               if Isconst(r, CTSTR) && r.Sym == nil {
-                       if nstr != nil {
-                               // Collapse r into nstr instead of adding to n.
-                               chunks = append(chunks, r.StringVal())
-                               continue
-                       }
-
-                       nstr = r
-                       chunks = append(chunks, nstr.StringVal())
-               } else {
-                       if len(chunks) > 1 {
-                               nstr.SetVal(Val{U: strings.Join(chunks, "")})
-                       }
-                       nstr = nil
-                       chunks = chunks[:0]
-               }
-               n = p.nod(add, OADD, n, r)
-       }
-       if len(chunks) > 1 {
-               nstr.SetVal(Val{U: strings.Join(chunks, "")})
-       }
-
-       return n
-}
-
-func (p *noder) typeExpr(typ syntax.Expr) *Node {
-       // TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
-       return p.expr(typ)
-}
-
-func (p *noder) typeExprOrNil(typ syntax.Expr) *Node {
-       if typ != nil {
-               return p.expr(typ)
-       }
-       return nil
-}
-
-func (p *noder) chanDir(dir syntax.ChanDir) types.ChanDir {
-       switch dir {
-       case 0:
-               return types.Cboth
-       case syntax.SendOnly:
-               return types.Csend
-       case syntax.RecvOnly:
-               return types.Crecv
-       }
-       panic("unhandled ChanDir")
-}
-
-func (p *noder) structType(expr *syntax.StructType) *Node {
-       l := make([]*Node, 0, len(expr.FieldList))
-       for i, field := range expr.FieldList {
-               p.setlineno(field)
-               var n *Node
-               if field.Name == nil {
-                       n = p.embedded(field.Type)
-               } else {
-                       n = p.nodSym(field, ODCLFIELD, p.typeExpr(field.Type), p.name(field.Name))
-               }
-               if i < len(expr.TagList) && expr.TagList[i] != nil {
-                       n.SetVal(p.basicLit(expr.TagList[i]))
-               }
-               l = append(l, n)
-       }
-
-       p.setlineno(expr)
-       n := p.nod(expr, OTSTRUCT, nil, nil)
-       n.List.Set(l)
-       return n
-}
-
-func (p *noder) interfaceType(expr *syntax.InterfaceType) *Node {
-       l := make([]*Node, 0, len(expr.MethodList))
-       for _, method := range expr.MethodList {
-               p.setlineno(method)
-               var n *Node
-               if method.Name == nil {
-                       n = p.nodSym(method, ODCLFIELD, importName(p.packname(method.Type)), nil)
-               } else {
-                       mname := p.name(method.Name)
-                       sig := p.typeExpr(method.Type)
-                       sig.Left = fakeRecv()
-                       n = p.nodSym(method, ODCLFIELD, sig, mname)
-                       ifacedcl(n)
-               }
-               l = append(l, n)
-       }
-
-       n := p.nod(expr, OTINTER, nil, nil)
-       n.List.Set(l)
-       return n
-}
-
-func (p *noder) packname(expr syntax.Expr) *types.Sym {
-       switch expr := expr.(type) {
-       case *syntax.Name:
-               name := p.name(expr)
-               if n := oldname(name); n.Name != nil && n.Name.Pack != nil {
-                       n.Name.Pack.Name.SetUsed(true)
-               }
-               return name
-       case *syntax.SelectorExpr:
-               name := p.name(expr.X.(*syntax.Name))
-               def := asNode(name.Def)
-               if def == nil {
-                       yyerror("undefined: %v", name)
-                       return name
-               }
-               var pkg *types.Pkg
-               if def.Op != OPACK {
-                       yyerror("%v is not a package", name)
-                       pkg = localpkg
-               } else {
-                       def.Name.SetUsed(true)
-                       pkg = def.Name.Pkg
-               }
-               return pkg.Lookup(expr.Sel.Value)
-       }
-       panic(fmt.Sprintf("unexpected packname: %#v", expr))
-}
-
-func (p *noder) embedded(typ syntax.Expr) *Node {
-       op, isStar := typ.(*syntax.Operation)
-       if isStar {
-               if op.Op != syntax.Mul || op.Y != nil {
-                       panic("unexpected Operation")
-               }
-               typ = op.X
-       }
-
-       sym := p.packname(typ)
-       n := p.nodSym(typ, ODCLFIELD, importName(sym), lookup(sym.Name))
-       n.SetEmbedded(true)
-
-       if isStar {
-               n.Left = p.nod(op, ODEREF, n.Left, nil)
-       }
-       return n
-}
-
-func (p *noder) stmts(stmts []syntax.Stmt) []*Node {
-       return p.stmtsFall(stmts, false)
-}
-
-func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*Node {
-       var nodes []*Node
-       for i, stmt := range stmts {
-               s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
-               if s == nil {
-               } else if s.Op == OBLOCK && s.Ninit.Len() == 0 {
-                       nodes = append(nodes, s.List.Slice()...)
-               } else {
-                       nodes = append(nodes, s)
-               }
-       }
-       return nodes
-}
-
-func (p *noder) stmt(stmt syntax.Stmt) *Node {
-       return p.stmtFall(stmt, false)
-}
-
-func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
-       p.setlineno(stmt)
-       switch stmt := stmt.(type) {
-       case *syntax.EmptyStmt:
-               return nil
-       case *syntax.LabeledStmt:
-               return p.labeledStmt(stmt, fallOK)
-       case *syntax.BlockStmt:
-               l := p.blockStmt(stmt)
-               if len(l) == 0 {
-                       // TODO(mdempsky): Line number?
-                       return nod(OEMPTY, nil, nil)
-               }
-               return liststmt(l)
-       case *syntax.ExprStmt:
-               return p.wrapname(stmt, p.expr(stmt.X))
-       case *syntax.SendStmt:
-               return p.nod(stmt, OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
-       case *syntax.DeclStmt:
-               return liststmt(p.decls(stmt.DeclList))
-       case *syntax.AssignStmt:
-               if stmt.Op != 0 && stmt.Op != syntax.Def {
-                       n := p.nod(stmt, OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
-                       n.SetImplicit(stmt.Rhs == syntax.ImplicitOne)
-                       n.SetSubOp(p.binOp(stmt.Op))
-                       return n
-               }
-
-               n := p.nod(stmt, OAS, nil, nil) // assume common case
-
-               rhs := p.exprList(stmt.Rhs)
-               lhs := p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def)
-
-               if len(lhs) == 1 && len(rhs) == 1 {
-                       // common case
-                       n.Left = lhs[0]
-                       n.Right = rhs[0]
-               } else {
-                       n.Op = OAS2
-                       n.List.Set(lhs)
-                       n.Rlist.Set(rhs)
-               }
-               return n
-
-       case *syntax.BranchStmt:
-               var op Op
-               switch stmt.Tok {
-               case syntax.Break:
-                       op = OBREAK
-               case syntax.Continue:
-                       op = OCONTINUE
-               case syntax.Fallthrough:
-                       if !fallOK {
-                               yyerror("fallthrough statement out of place")
-                       }
-                       op = OFALL
-               case syntax.Goto:
-                       op = OGOTO
-               default:
-                       panic("unhandled BranchStmt")
-               }
-               n := p.nod(stmt, op, nil, nil)
-               if stmt.Label != nil {
-                       n.Sym = p.name(stmt.Label)
-               }
-               return n
-       case *syntax.CallStmt:
-               var op Op
-               switch stmt.Tok {
-               case syntax.Defer:
-                       op = ODEFER
-               case syntax.Go:
-                       op = OGO
-               default:
-                       panic("unhandled CallStmt")
-               }
-               return p.nod(stmt, op, p.expr(stmt.Call), nil)
-       case *syntax.ReturnStmt:
-               var results []*Node
-               if stmt.Results != nil {
-                       results = p.exprList(stmt.Results)
-               }
-               n := p.nod(stmt, ORETURN, nil, nil)
-               n.List.Set(results)
-               if n.List.Len() == 0 && Curfn != nil {
-                       for _, ln := range Curfn.Func.Dcl {
-                               if ln.Class() == PPARAM {
-                                       continue
-                               }
-                               if ln.Class() != PPARAMOUT {
-                                       break
-                               }
-                               if asNode(ln.Sym.Def) != ln {
-                                       yyerror("%s is shadowed during return", ln.Sym.Name)
-                               }
-                       }
-               }
-               return n
-       case *syntax.IfStmt:
-               return p.ifStmt(stmt)
-       case *syntax.ForStmt:
-               return p.forStmt(stmt)
-       case *syntax.SwitchStmt:
-               return p.switchStmt(stmt)
-       case *syntax.SelectStmt:
-               return p.selectStmt(stmt)
-       }
-       panic("unhandled Stmt")
-}
-
-func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
-       if !colas {
-               return p.exprList(expr)
-       }
-
-       defn.SetColas(true)
-
-       var exprs []syntax.Expr
-       if list, ok := expr.(*syntax.ListExpr); ok {
-               exprs = list.ElemList
-       } else {
-               exprs = []syntax.Expr{expr}
-       }
-
-       res := make([]*Node, len(exprs))
-       seen := make(map[*types.Sym]bool, len(exprs))
-
-       newOrErr := false
-       for i, expr := range exprs {
-               p.setlineno(expr)
-               res[i] = nblank
-
-               name, ok := expr.(*syntax.Name)
-               if !ok {
-                       p.yyerrorpos(expr.Pos(), "non-name %v on left side of :=", p.expr(expr))
-                       newOrErr = true
-                       continue
-               }
-
-               sym := p.name(name)
-               if sym.IsBlank() {
-                       continue
-               }
-
-               if seen[sym] {
-                       p.yyerrorpos(expr.Pos(), "%v repeated on left side of :=", sym)
-                       newOrErr = true
-                       continue
-               }
-               seen[sym] = true
-
-               if sym.Block == types.Block {
-                       res[i] = oldname(sym)
-                       continue
-               }
-
-               newOrErr = true
-               n := newname(sym)
-               declare(n, dclcontext)
-               n.Name.Defn = defn
-               defn.Ninit.Append(nod(ODCL, n, nil))
-               res[i] = n
-       }
-
-       if !newOrErr {
-               yyerrorl(defn.Pos, "no new variables on left side of :=")
-       }
-       return res
-}
-
-func (p *noder) blockStmt(stmt *syntax.BlockStmt) []*Node {
-       p.openScope(stmt.Pos())
-       nodes := p.stmts(stmt.List)
-       p.closeScope(stmt.Rbrace)
-       return nodes
-}
-
-func (p *noder) ifStmt(stmt *syntax.IfStmt) *Node {
-       p.openScope(stmt.Pos())
-       n := p.nod(stmt, OIF, nil, nil)
-       if stmt.Init != nil {
-               n.Ninit.Set1(p.stmt(stmt.Init))
-       }
-       if stmt.Cond != nil {
-               n.Left = p.expr(stmt.Cond)
-       }
-       n.Nbody.Set(p.blockStmt(stmt.Then))
-       if stmt.Else != nil {
-               e := p.stmt(stmt.Else)
-               if e.Op == OBLOCK && e.Ninit.Len() == 0 {
-                       n.Rlist.Set(e.List.Slice())
-               } else {
-                       n.Rlist.Set1(e)
-               }
-       }
-       p.closeAnotherScope()
-       return n
-}
-
-func (p *noder) forStmt(stmt *syntax.ForStmt) *Node {
-       p.openScope(stmt.Pos())
-       var n *Node
-       if r, ok := stmt.Init.(*syntax.RangeClause); ok {
-               if stmt.Cond != nil || stmt.Post != nil {
-                       panic("unexpected RangeClause")
-               }
-
-               n = p.nod(r, ORANGE, nil, p.expr(r.X))
-               if r.Lhs != nil {
-                       n.List.Set(p.assignList(r.Lhs, n, r.Def))
-               }
-       } else {
-               n = p.nod(stmt, OFOR, nil, nil)
-               if stmt.Init != nil {
-                       n.Ninit.Set1(p.stmt(stmt.Init))
-               }
-               if stmt.Cond != nil {
-                       n.Left = p.expr(stmt.Cond)
-               }
-               if stmt.Post != nil {
-                       n.Right = p.stmt(stmt.Post)
-               }
-       }
-       n.Nbody.Set(p.blockStmt(stmt.Body))
-       p.closeAnotherScope()
-       return n
-}
-
-func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *Node {
-       p.openScope(stmt.Pos())
-       n := p.nod(stmt, OSWITCH, nil, nil)
-       if stmt.Init != nil {
-               n.Ninit.Set1(p.stmt(stmt.Init))
-       }
-       if stmt.Tag != nil {
-               n.Left = p.expr(stmt.Tag)
-       }
-
-       tswitch := n.Left
-       if tswitch != nil && tswitch.Op != OTYPESW {
-               tswitch = nil
-       }
-       n.List.Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
-
-       p.closeScope(stmt.Rbrace)
-       return n
-}
-
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace syntax.Pos) []*Node {
-       nodes := make([]*Node, 0, len(clauses))
-       for i, clause := range clauses {
-               p.setlineno(clause)
-               if i > 0 {
-                       p.closeScope(clause.Pos())
-               }
-               p.openScope(clause.Pos())
-
-               n := p.nod(clause, OCASE, nil, nil)
-               if clause.Cases != nil {
-                       n.List.Set(p.exprList(clause.Cases))
-               }
-               if tswitch != nil && tswitch.Left != nil {
-                       nn := newname(tswitch.Left.Sym)
-                       declare(nn, dclcontext)
-                       n.Rlist.Set1(nn)
-                       // keep track of the instances for reporting unused
-                       nn.Name.Defn = tswitch
-               }
-
-               // Trim trailing empty statements. We omit them from
-               // the Node AST anyway, and it's easier to identify
-               // out-of-place fallthrough statements without them.
-               body := clause.Body
-               for len(body) > 0 {
-                       if _, ok := body[len(body)-1].(*syntax.EmptyStmt); !ok {
-                               break
-                       }
-                       body = body[:len(body)-1]
-               }
-
-               n.Nbody.Set(p.stmtsFall(body, true))
-               if l := n.Nbody.Len(); l > 0 && n.Nbody.Index(l-1).Op == OFALL {
-                       if tswitch != nil {
-                               yyerror("cannot fallthrough in type switch")
-                       }
-                       if i+1 == len(clauses) {
-                               yyerror("cannot fallthrough final case in switch")
-                       }
-               }
-
-               nodes = append(nodes, n)
-       }
-       if len(clauses) > 0 {
-               p.closeScope(rbrace)
-       }
-       return nodes
-}
-
-func (p *noder) selectStmt(stmt *syntax.SelectStmt) *Node {
-       n := p.nod(stmt, OSELECT, nil, nil)
-       n.List.Set(p.commClauses(stmt.Body, stmt.Rbrace))
-       return n
-}
-
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*Node {
-       nodes := make([]*Node, 0, len(clauses))
-       for i, clause := range clauses {
-               p.setlineno(clause)
-               if i > 0 {
-                       p.closeScope(clause.Pos())
-               }
-               p.openScope(clause.Pos())
-
-               n := p.nod(clause, OCASE, nil, nil)
-               if clause.Comm != nil {
-                       n.List.Set1(p.stmt(clause.Comm))
-               }
-               n.Nbody.Set(p.stmts(clause.Body))
-               nodes = append(nodes, n)
-       }
-       if len(clauses) > 0 {
-               p.closeScope(rbrace)
-       }
-       return nodes
-}
-
-func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *Node {
-       lhs := p.nodSym(label, OLABEL, nil, p.name(label.Label))
-
-       var ls *Node
-       if label.Stmt != nil { // TODO(mdempsky): Should always be present.
-               ls = p.stmtFall(label.Stmt, fallOK)
-       }
-
-       lhs.Name.Defn = ls
-       l := []*Node{lhs}
-       if ls != nil {
-               if ls.Op == OBLOCK && ls.Ninit.Len() == 0 {
-                       l = append(l, ls.List.Slice()...)
-               } else {
-                       l = append(l, ls)
-               }
-       }
-       return liststmt(l)
-}
-
-var unOps = [...]Op{
-       syntax.Recv: ORECV,
-       syntax.Mul:  ODEREF,
-       syntax.And:  OADDR,
-
-       syntax.Not: ONOT,
-       syntax.Xor: OBITNOT,
-       syntax.Add: OPLUS,
-       syntax.Sub: ONEG,
-}
-
-func (p *noder) unOp(op syntax.Operator) Op {
-       if uint64(op) >= uint64(len(unOps)) || unOps[op] == 0 {
-               panic("invalid Operator")
-       }
-       return unOps[op]
-}
-
-var binOps = [...]Op{
-       syntax.OrOr:   OOROR,
-       syntax.AndAnd: OANDAND,
-
-       syntax.Eql: OEQ,
-       syntax.Neq: ONE,
-       syntax.Lss: OLT,
-       syntax.Leq: OLE,
-       syntax.Gtr: OGT,
-       syntax.Geq: OGE,
-
-       syntax.Add: OADD,
-       syntax.Sub: OSUB,
-       syntax.Or:  OOR,
-       syntax.Xor: OXOR,
-
-       syntax.Mul:    OMUL,
-       syntax.Div:    ODIV,
-       syntax.Rem:    OMOD,
-       syntax.And:    OAND,
-       syntax.AndNot: OANDNOT,
-       syntax.Shl:    OLSH,
-       syntax.Shr:    ORSH,
-}
-
-func (p *noder) binOp(op syntax.Operator) Op {
-       if uint64(op) >= uint64(len(binOps)) || binOps[op] == 0 {
-               panic("invalid Operator")
-       }
-       return binOps[op]
-}
-
-// checkLangCompat reports an error if the representation of a numeric
-// literal is not compatible with the current language version.
-func checkLangCompat(lit *syntax.BasicLit) {
-       s := lit.Value
-       if len(s) <= 2 || langSupported(1, 13, localpkg) {
-               return
-       }
-       // len(s) > 2
-       if strings.Contains(s, "_") {
-               yyerrorv("go1.13", "underscores in numeric literals")
-               return
-       }
-       if s[0] != '0' {
-               return
-       }
-       base := s[1]
-       if base == 'b' || base == 'B' {
-               yyerrorv("go1.13", "binary literals")
-               return
-       }
-       if base == 'o' || base == 'O' {
-               yyerrorv("go1.13", "0o/0O-style octal literals")
-               return
-       }
-       if lit.Kind != syntax.IntLit && (base == 'x' || base == 'X') {
-               yyerrorv("go1.13", "hexadecimal floating-point literals")
-       }
-}
-
-func (p *noder) basicLit(lit *syntax.BasicLit) Val {
-       // We don't use the errors of the conversion routines to determine
-       // if a literal string is valid because the conversion routines may
-       // accept a wider syntax than the language permits. Rely on lit.Bad
-       // instead.
-       switch s := lit.Value; lit.Kind {
-       case syntax.IntLit:
-               checkLangCompat(lit)
-               x := new(Mpint)
-               if !lit.Bad {
-                       x.SetString(s)
-               }
-               return Val{U: x}
-
-       case syntax.FloatLit:
-               checkLangCompat(lit)
-               x := newMpflt()
-               if !lit.Bad {
-                       x.SetString(s)
-               }
-               return Val{U: x}
-
-       case syntax.ImagLit:
-               checkLangCompat(lit)
-               x := newMpcmplx()
-               if !lit.Bad {
-                       x.Imag.SetString(strings.TrimSuffix(s, "i"))
-               }
-               return Val{U: x}
-
-       case syntax.RuneLit:
-               x := new(Mpint)
-               x.Rune = true
-               if !lit.Bad {
-                       u, _ := strconv.Unquote(s)
-                       var r rune
-                       if len(u) == 1 {
-                               r = rune(u[0])
-                       } else {
-                               r, _ = utf8.DecodeRuneInString(u)
-                       }
-                       x.SetInt64(int64(r))
-               }
-               return Val{U: x}
-
-       case syntax.StringLit:
-               var x string
-               if !lit.Bad {
-                       if len(s) > 0 && s[0] == '`' {
-                               // strip carriage returns from raw string
-                               s = strings.Replace(s, "\r", "", -1)
-                       }
-                       x, _ = strconv.Unquote(s)
-               }
-               return Val{U: x}
-
-       default:
-               panic("unhandled BasicLit kind")
-       }
-}
-
-func (p *noder) name(name *syntax.Name) *types.Sym {
-       return lookup(name.Value)
-}
-
-func (p *noder) mkname(name *syntax.Name) *Node {
-       // TODO(mdempsky): Set line number?
-       return mkname(p.name(name))
-}
-
-func (p *noder) wrapname(n syntax.Node, x *Node) *Node {
-       // These nodes do not carry line numbers.
-       // Introduce a wrapper node to give them the correct line.
-       switch x.Op {
-       case OTYPE, OLITERAL:
-               if x.Sym == nil {
-                       break
-               }
-               fallthrough
-       case ONAME, ONONAME, OPACK:
-               x = p.nod(n, OPAREN, x, nil)
-               x.SetImplicit(true)
-       }
-       return x
-}
-
-func (p *noder) nod(orig syntax.Node, op Op, left, right *Node) *Node {
-       return nodl(p.pos(orig), op, left, right)
-}
-
-func (p *noder) nodSym(orig syntax.Node, op Op, left *Node, sym *types.Sym) *Node {
-       n := nodSym(op, left, sym)
-       n.Pos = p.pos(orig)
-       return n
-}
-
-func (p *noder) pos(n syntax.Node) src.XPos {
-       // TODO(gri): orig.Pos() should always be known - fix package syntax
-       xpos := lineno
-       if pos := n.Pos(); pos.IsKnown() {
-               xpos = p.makeXPos(pos)
-       }
-       return xpos
-}
-
-func (p *noder) setlineno(n syntax.Node) {
-       if n != nil {
-               lineno = p.pos(n)
-       }
-}
-
-// error is called concurrently if files are parsed concurrently.
-func (p *noder) error(err error) {
-       p.err <- err.(syntax.Error)
-}
-
-// pragmas that are allowed in the std lib, but don't have
-// a syntax.Pragma value (see lex.go) associated with them.
-var allowedStdPragmas = map[string]bool{
-       "go:cgo_export_static":  true,
-       "go:cgo_export_dynamic": true,
-       "go:cgo_import_static":  true,
-       "go:cgo_import_dynamic": true,
-       "go:cgo_ldflag":         true,
-       "go:cgo_dynamic_linker": true,
-       "go:embed":              true,
-       "go:generate":           true,
-}
-
-// *Pragma is the value stored in a syntax.Pragma during parsing.
-type Pragma struct {
-       Flag   PragmaFlag  // collected bits
-       Pos    []PragmaPos // position of each individual flag
-       Embeds []PragmaEmbed
-}
-
-type PragmaPos struct {
-       Flag PragmaFlag
-       Pos  syntax.Pos
-}
-
-type PragmaEmbed struct {
-       Pos      syntax.Pos
-       Patterns []string
-}
-
-func (p *noder) checkUnused(pragma *Pragma) {
-       for _, pos := range pragma.Pos {
-               if pos.Flag&pragma.Flag != 0 {
-                       p.yyerrorpos(pos.Pos, "misplaced compiler directive")
-               }
-       }
-       if len(pragma.Embeds) > 0 {
-               for _, e := range pragma.Embeds {
-                       p.yyerrorpos(e.Pos, "misplaced go:embed directive")
-               }
-       }
-}
-
-func (p *noder) checkUnusedDuringParse(pragma *Pragma) {
-       for _, pos := range pragma.Pos {
-               if pos.Flag&pragma.Flag != 0 {
-                       p.error(syntax.Error{Pos: pos.Pos, Msg: "misplaced compiler directive"})
-               }
-       }
-       if len(pragma.Embeds) > 0 {
-               for _, e := range pragma.Embeds {
-                       p.error(syntax.Error{Pos: e.Pos, Msg: "misplaced go:embed directive"})
-               }
-       }
-}
-
-// pragma is called concurrently if files are parsed concurrently.
-func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.Pragma) syntax.Pragma {
-       pragma, _ := old.(*Pragma)
-       if pragma == nil {
-               pragma = new(Pragma)
-       }
-
-       if text == "" {
-               // unused pragma; only called with old != nil.
-               p.checkUnusedDuringParse(pragma)
-               return nil
-       }
-
-       if strings.HasPrefix(text, "line ") {
-               // line directives are handled by syntax package
-               panic("unreachable")
-       }
-
-       if !blankLine {
-               // directive must be on line by itself
-               p.error(syntax.Error{Pos: pos, Msg: "misplaced compiler directive"})
-               return pragma
-       }
-
-       switch {
-       case strings.HasPrefix(text, "go:linkname "):
-               f := strings.Fields(text)
-               if !(2 <= len(f) && len(f) <= 3) {
-                       p.error(syntax.Error{Pos: pos, Msg: "usage: //go:linkname localname [linkname]"})
-                       break
-               }
-               // The second argument is optional. If omitted, we use
-               // the default object symbol name for this and
-               // linkname only serves to mark this symbol as
-               // something that may be referenced via the object
-               // symbol name from another package.
-               var target string
-               if len(f) == 3 {
-                       target = f[2]
-               }
-               p.linknames = append(p.linknames, linkname{pos, f[1], target})
-
-       case text == "go:embed", strings.HasPrefix(text, "go:embed "):
-               args, err := parseGoEmbed(text[len("go:embed"):])
-               if err != nil {
-                       p.error(syntax.Error{Pos: pos, Msg: err.Error()})
-               }
-               if len(args) == 0 {
-                       p.error(syntax.Error{Pos: pos, Msg: "usage: //go:embed pattern..."})
-                       break
-               }
-               pragma.Embeds = append(pragma.Embeds, PragmaEmbed{pos, args})
-
-       case strings.HasPrefix(text, "go:cgo_import_dynamic "):
-               // This is permitted for general use because Solaris
-               // code relies on it in golang.org/x/sys/unix and others.
-               fields := pragmaFields(text)
-               if len(fields) >= 4 {
-                       lib := strings.Trim(fields[3], `"`)
-                       if lib != "" && !safeArg(lib) && !isCgoGeneratedFile(pos) {
-                               p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("invalid library name %q in cgo_import_dynamic directive", lib)})
-                       }
-                       p.pragcgo(pos, text)
-                       pragma.Flag |= pragmaFlag("go:cgo_import_dynamic")
-                       break
-               }
-               fallthrough
-       case strings.HasPrefix(text, "go:cgo_"):
-               // For security, we disallow //go:cgo_* directives other
-               // than cgo_import_dynamic outside cgo-generated files.
-               // Exception: they are allowed in the standard library, for runtime and syscall.
-               if !isCgoGeneratedFile(pos) && !compiling_std {
-                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in cgo-generated code", text)})
-               }
-               p.pragcgo(pos, text)
-               fallthrough // because of //go:cgo_unsafe_args
-       default:
-               verb := text
-               if i := strings.Index(text, " "); i >= 0 {
-                       verb = verb[:i]
-               }
-               flag := pragmaFlag(verb)
-               const runtimePragmas = Systemstack | Nowritebarrier | Nowritebarrierrec | Yeswritebarrierrec
-               if !compiling_runtime && flag&runtimePragmas != 0 {
-                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in runtime", verb)})
-               }
-               if flag == 0 && !allowedStdPragmas[verb] && compiling_std {
-                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s is not allowed in the standard library", verb)})
-               }
-               pragma.Flag |= flag
-               pragma.Pos = append(pragma.Pos, PragmaPos{flag, pos})
-       }
-
-       return pragma
-}
-
-// isCgoGeneratedFile reports whether pos is in a file
-// generated by cgo, which is to say a file with name
-// beginning with "_cgo_". Such files are allowed to
-// contain cgo directives, and for security reasons
-// (primarily misuse of linker flags), other files are not.
-// See golang.org/issue/23672.
-func isCgoGeneratedFile(pos syntax.Pos) bool {
-       return strings.HasPrefix(filepath.Base(filepath.Clean(fileh(pos.Base().Filename()))), "_cgo_")
-}
-
-// safeArg reports whether arg is a "safe" command-line argument,
-// meaning that when it appears in a command-line, it probably
-// doesn't have some special meaning other than its own name.
-// This is copied from SafeArg in cmd/go/internal/load/pkg.go.
-func safeArg(name string) bool {
-       if name == "" {
-               return false
-       }
-       c := name[0]
-       return '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '.' || c == '_' || c == '/' || c >= utf8.RuneSelf
-}
-
-func mkname(sym *types.Sym) *Node {
-       n := oldname(sym)
-       if n.Name != nil && n.Name.Pack != nil {
-               n.Name.Pack.Name.SetUsed(true)
-       }
-       return n
-}
-
-// parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
-// It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
-// go/build/read.go also processes these strings and contains similar logic.
-func parseGoEmbed(args string) ([]string, error) {
-       var list []string
-       for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
-               var path string
-       Switch:
-               switch args[0] {
-               default:
-                       i := len(args)
-                       for j, c := range args {
-                               if unicode.IsSpace(c) {
-                                       i = j
-                                       break
-                               }
-                       }
-                       path = args[:i]
-                       args = args[i:]
-
-               case '`':
-                       i := strings.Index(args[1:], "`")
-                       if i < 0 {
-                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-                       }
-                       path = args[1 : 1+i]
-                       args = args[1+i+1:]
-
-               case '"':
-                       i := 1
-                       for ; i < len(args); i++ {
-                               if args[i] == '\\' {
-                                       i++
-                                       continue
-                               }
-                               if args[i] == '"' {
-                                       q, err := strconv.Unquote(args[:i+1])
-                                       if err != nil {
-                                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
-                                       }
-                                       path = q
-                                       args = args[i+1:]
-                                       break Switch
-                               }
-                       }
-                       if i >= len(args) {
-                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-                       }
-               }
-
-               if args != "" {
-                       r, _ := utf8.DecodeRuneInString(args)
-                       if !unicode.IsSpace(r) {
-                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-                       }
-               }
-               list = append(list, path)
-       }
-       return list, nil
-}

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 32aa7c5bb1ae0958739d95e42815c221fbf8586c..0472af74419e57975f3cabf26e9ed3acef776837 100644 (file)
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -5,28 +5,21 @@
 package gc
 
 import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/typecheck"
        "cmd/compile/internal/types"
+       "cmd/internal/archive"
        "cmd/internal/bio"
        "cmd/internal/obj"
        "cmd/internal/objabi"
-       "cmd/internal/src"
-       "crypto/sha256"
        "encoding/json"
        "fmt"
-       "io"
-       "io/ioutil"
-       "os"
-       "sort"
-       "strconv"
 )
 
-// architecture-independent object file output
-const ArhdrSize = 60
-
-func formathdr(arhdr []byte, name string, size int64) {
-       copy(arhdr[:], fmt.Sprintf("%-16s%-12d%-6d%-6d%-8o%-10d`\n", name, 0, 0, 0, 0644, size))
-}
-
 // These modes say which kind of object file to generate.
 // The default use of the toolchain is to set both bits,
 // generating a combined compiler+linker object, one that
@@ -46,20 +39,20 @@ const (
 )
 
 func dumpobj() {
-       if linkobj == "" {
-               dumpobj1(outfile, modeCompilerObj|modeLinkerObj)
+       if base.Flag.LinkObj == "" {
+               dumpobj1(base.Flag.LowerO, modeCompilerObj|modeLinkerObj)
                return
        }
-       dumpobj1(outfile, modeCompilerObj)
-       dumpobj1(linkobj, modeLinkerObj)
+       dumpobj1(base.Flag.LowerO, modeCompilerObj)
+       dumpobj1(base.Flag.LinkObj, modeLinkerObj)
 }
 
 func dumpobj1(outfile string, mode int) {
        bout, err := bio.Create(outfile)
        if err != nil {
-               flusherrors()
+               base.FlushErrors()
                fmt.Printf("can't create %s: %v\n", outfile, err)
-               errorexit()
+               base.ErrorExit()
        }
        defer bout.Close()
        bout.WriteString("!<arch>\n")
@@ -78,17 +71,17 @@ func dumpobj1(outfile string, mode int) {
 
 func printObjHeader(bout *bio.Writer) {
        fmt.Fprintf(bout, "go object %s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-       if buildid != "" {
-               fmt.Fprintf(bout, "build id %q\n", buildid)
+       if base.Flag.BuildID != "" {
+               fmt.Fprintf(bout, "build id %q\n", base.Flag.BuildID)
        }
-       if localpkg.Name == "main" {
+       if types.LocalPkg.Name == "main" {
                fmt.Fprintf(bout, "main\n")
        }
        fmt.Fprintf(bout, "\n") // header ends with blank line
 }
 
 func startArchiveEntry(bout *bio.Writer) int64 {
-       var arhdr [ArhdrSize]byte
+       var arhdr [archive.HeaderSize]byte
        bout.Write(arhdr[:])
        return bout.Offset()
 }
@@ -99,10 +92,10 @@ func finishArchiveEntry(bout *bio.Writer, start int64, name string) {
        if size&1 != 0 {
                bout.WriteByte(0)
        }
-       bout.MustSeek(start-ArhdrSize, 0)
+       bout.MustSeek(start-archive.HeaderSize, 0)
 
-       var arhdr [ArhdrSize]byte
-       formathdr(arhdr[:], name, size)
+       var arhdr [archive.HeaderSize]byte
+       archive.FormatHeader(arhdr[:], name, size)
        bout.Write(arhdr[:])
        bout.Flush()
        bout.MustSeek(start+size+(size&1), 0)
@@ -114,22 +107,21 @@ func dumpCompilerObj(bout *bio.Writer) {
 }
 
 func dumpdata() {
-       externs := len(externdcl)
-       xtops := len(xtop)
-
-       dumpglobls()
-       addptabs()
-       exportlistLen := len(exportlist)
-       addsignats(externdcl)
-       dumpsignats()
-       dumptabs()
-       ptabsLen := len(ptabs)
-       itabsLen := len(itabs)
-       dumpimportstrings()
-       dumpbasictypes()
+       numExterns := len(typecheck.Target.Externs)
+       numDecls := len(typecheck.Target.Decls)
+
+       dumpglobls(typecheck.Target.Externs)
+       reflectdata.CollectPTabs()
+       numExports := len(typecheck.Target.Exports)
+       addsignats(typecheck.Target.Externs)
+       reflectdata.WriteRuntimeTypes()
+       reflectdata.WriteTabs()
+       numPTabs, numITabs := reflectdata.CountTabs()
+       reflectdata.WriteImportStrings()
+       reflectdata.WriteBasicTypes()
        dumpembeds()
 
-       // Calls to dumpsignats can generate functions,
+       // Calls to WriteRuntimeTypes can generate functions,
        // like method wrappers and hash and equality routines.
        // Compile any generated functions, process any new resulting types, repeat.
        // This can't loop forever, because there is no way to generate an infinite
@@ -137,169 +129,108 @@ func dumpdata() {
        // In the typical case, we loop 0 or 1 times.
        // It was not until issue 24761 that we found any code that required a loop at all.
        for {
-               for i := xtops; i < len(xtop); i++ {
-                       n := xtop[i]
-                       if n.Op == ODCLFUNC {
-                               funccompile(n)
+               for i := numDecls; i < len(typecheck.Target.Decls); i++ {
+                       if n, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
+                               enqueueFunc(n)
                        }
                }
-               xtops = len(xtop)
+               numDecls = len(typecheck.Target.Decls)
                compileFunctions()
-               dumpsignats()
-               if xtops == len(xtop) {
+               reflectdata.WriteRuntimeTypes()
+               if numDecls == len(typecheck.Target.Decls) {
                        break
                }
        }
 
        // Dump extra globals.
-       tmp := externdcl
+       dumpglobls(typecheck.Target.Externs[numExterns:])
 
-       if externdcl != nil {
-               externdcl = externdcl[externs:]
-       }
-       dumpglobls()
-       externdcl = tmp
-
-       if zerosize > 0 {
-               zero := mappkg.Lookup("zero")
-               ggloblsym(zero.Linksym(), int32(zerosize), obj.DUPOK|obj.RODATA)
+       if reflectdata.ZeroSize > 0 {
+               zero := base.PkgLinksym("go.map", "zero", obj.ABI0)
+               objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
        }
 
+       staticdata.WriteFuncSyms()
        addGCLocals()
 
-       if exportlistLen != len(exportlist) {
-               Fatalf("exportlist changed after compile functions loop")
+       if numExports != len(typecheck.Target.Exports) {
+               base.Fatalf("Target.Exports changed after compile functions loop")
        }
-       if ptabsLen != len(ptabs) {
-               Fatalf("ptabs changed after compile functions loop")
+       newNumPTabs, newNumITabs := reflectdata.CountTabs()
+       if newNumPTabs != numPTabs {
+               base.Fatalf("ptabs changed after compile functions loop")
        }
-       if itabsLen != len(itabs) {
-               Fatalf("itabs changed after compile functions loop")
+       if newNumITabs != numITabs {
+               base.Fatalf("itabs changed after compile functions loop")
        }
 }
 
 func dumpLinkerObj(bout *bio.Writer) {
        printObjHeader(bout)
 
-       if len(pragcgobuf) != 0 {
+       if len(typecheck.Target.CgoPragmas) != 0 {
                // write empty export section; must be before cgo section
                fmt.Fprintf(bout, "\n$$\n\n$$\n\n")
                fmt.Fprintf(bout, "\n$$  // cgo\n")
-               if err := json.NewEncoder(bout).Encode(pragcgobuf); err != nil {
-                       Fatalf("serializing pragcgobuf: %v", err)
+               if err := json.NewEncoder(bout).Encode(typecheck.Target.CgoPragmas); err != nil {
+                       base.Fatalf("serializing pragcgobuf: %v", err)
                }
                fmt.Fprintf(bout, "\n$$\n\n")
        }
 
        fmt.Fprintf(bout, "\n!\n")
 
-       obj.WriteObjFile(Ctxt, bout)
-}
-
-func addptabs() {
-       if !Ctxt.Flag_dynlink || localpkg.Name != "main" {
-               return
-       }
-       for _, exportn := range exportlist {
-               s := exportn.Sym
-               n := asNode(s.Def)
-               if n == nil {
-                       continue
-               }
-               if n.Op != ONAME {
-                       continue
-               }
-               if !types.IsExported(s.Name) {
-                       continue
-               }
-               if s.Pkg.Name != "main" {
-                       continue
-               }
-               if n.Type.Etype == TFUNC && n.Class() == PFUNC {
-                       // function
-                       ptabs = append(ptabs, ptabEntry{s: s, t: asNode(s.Def).Type})
-               } else {
-                       // variable
-                       ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(asNode(s.Def).Type)})
-               }
-       }
+       obj.WriteObjFile(base.Ctxt, bout)
 }
 
-func dumpGlobal(n *Node) {
-       if n.Type == nil {
-               Fatalf("external %v nil type\n", n)
+func dumpGlobal(n *ir.Name) {
+       if n.Type() == nil {
+               base.Fatalf("external %v nil type\n", n)
        }
-       if n.Class() == PFUNC {
+       if n.Class == ir.PFUNC {
                return
        }
-       if n.Sym.Pkg != localpkg {
+       if n.Sym().Pkg != types.LocalPkg {
                return
        }
-       dowidth(n.Type)
+       types.CalcSize(n.Type())
        ggloblnod(n)
 }
 
-func dumpGlobalConst(n *Node) {
+func dumpGlobalConst(n ir.Node) {
        // only export typed constants
-       t := n.Type
+       t := n.Type()
        if t == nil {
                return
        }
-       if n.Sym.Pkg != localpkg {
+       if n.Sym().Pkg != types.LocalPkg {
                return
        }
        // only export integer constants for now
-       switch t.Etype {
-       case TINT8:
-       case TINT16:
-       case TINT32:
-       case TINT64:
-       case TINT:
-       case TUINT8:
-       case TUINT16:
-       case TUINT32:
-       case TUINT64:
-       case TUINT:
-       case TUINTPTR:
-               // ok
-       case TIDEAL:
-               if !Isconst(n, CTINT) {
-                       return
-               }
-               x := n.Val().U.(*Mpint)
-               if x.Cmp(minintval[TINT]) < 0 || x.Cmp(maxintval[TINT]) > 0 {
+       if !t.IsInteger() {
+               return
+       }
+       v := n.Val()
+       if t.IsUntyped() {
+               // Export untyped integers as int (if they fit).
+               t = types.Types[types.TINT]
+               if ir.ConstOverflow(v, t) {
                        return
                }
-               // Ideal integers we export as int (if they fit).
-               t = types.Types[TINT]
-       default:
-               return
        }
-       Ctxt.DwarfIntConst(myimportpath, n.Sym.Name, typesymname(t), n.Int64Val())
+       base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, types.TypeSymName(t), ir.IntVal(t, v))
 }
 
-func dumpglobls() {
+func dumpglobls(externs []ir.Node) {
        // add globals
-       for _, n := range externdcl {
-               switch n.Op {
-               case ONAME:
-                       dumpGlobal(n)
-               case OLITERAL:
+       for _, n := range externs {
+               switch n.Op() {
+               case ir.ONAME:
+                       dumpGlobal(n.(*ir.Name))
+               case ir.OLITERAL:
                        dumpGlobalConst(n)
                }
        }
-
-       sort.Slice(funcsyms, func(i, j int) bool {
-               return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
-       })
-       for _, s := range funcsyms {
-               sf := s.Pkg.Lookup(funcsymname(s)).Linksym()
-               dsymptr(sf, 0, s.Linksym(), 0)
-               ggloblsym(sf, int32(Widthptr), obj.DUPOK|obj.RODATA)
-       }
-
-       // Do not reprocess funcsyms on next dumpglobls call.
-       funcsyms = nil
 }
 
 // addGCLocals adds gcargs, gclocals, gcregs, and stack object symbols to Ctxt.Data.
@@ -307,332 +238,60 @@ func dumpglobls() {
 // This is done during the sequential phase after compilation, since
 // global symbols can't be declared during parallel compilation.
 func addGCLocals() {
-       for _, s := range Ctxt.Text {
+       for _, s := range base.Ctxt.Text {
                fn := s.Func()
                if fn == nil {
                        continue
                }
                for _, gcsym := range []*obj.LSym{fn.GCArgs, fn.GCLocals} {
                        if gcsym != nil && !gcsym.OnList() {
-                               ggloblsym(gcsym, int32(len(gcsym.P)), obj.RODATA|obj.DUPOK)
+                               objw.Global(gcsym, int32(len(gcsym.P)), obj.RODATA|obj.DUPOK)
                        }
                }
                if x := fn.StackObjects; x != nil {
                        attr := int16(obj.RODATA)
-                       ggloblsym(x, int32(len(x.P)), attr)
+                       objw.Global(x, int32(len(x.P)), attr)
                        x.Set(obj.AttrStatic, true)
                }
                if x := fn.OpenCodedDeferInfo; x != nil {
-                       ggloblsym(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
+                       objw.Global(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
                }
        }
 }
 
-func duintxx(s *obj.LSym, off int, v uint64, wid int) int {
-       if off&(wid-1) != 0 {
-               Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
+func ggloblnod(nam *ir.Name) {
+       s := nam.Linksym()
+       s.Gotype = reflectdata.TypeLinksym(nam.Type())
+       flags := 0
+       if nam.Readonly() {
+               flags = obj.RODATA
        }
-       s.WriteInt(Ctxt, int64(off), wid, int64(v))
-       return off + wid
-}
-
-func duint8(s *obj.LSym, off int, v uint8) int {
-       return duintxx(s, off, uint64(v), 1)
-}
-
-func duint16(s *obj.LSym, off int, v uint16) int {
-       return duintxx(s, off, uint64(v), 2)
-}
-
-func duint32(s *obj.LSym, off int, v uint32) int {
-       return duintxx(s, off, uint64(v), 4)
-}
-
-func duintptr(s *obj.LSym, off int, v uint64) int {
-       return duintxx(s, off, v, Widthptr)
-}
-
-func dbvec(s *obj.LSym, off int, bv bvec) int {
-       // Runtime reads the bitmaps as byte arrays. Oblige.
-       for j := 0; int32(j) < bv.n; j += 8 {
-               word := bv.b[j/32]
-               off = duint8(s, off, uint8(word>>(uint(j)%32)))
+       if nam.Type() != nil && !nam.Type().HasPointers() {
+               flags |= obj.NOPTR
        }
-       return off
-}
-
-const (
-       stringSymPrefix  = "go.string."
-       stringSymPattern = ".gostring.%d.%x"
-)
-
-// stringsym returns a symbol containing the string s.
-// The symbol contains the string data, not a string header.
-func stringsym(pos src.XPos, s string) (data *obj.LSym) {
-       var symname string
-       if len(s) > 100 {
-               // Huge strings are hashed to avoid long names in object files.
-               // Indulge in some paranoia by writing the length of s, too,
-               // as protection against length extension attacks.
-               // Same pattern is known to fileStringSym below.
-               h := sha256.New()
-               io.WriteString(h, s)
-               symname = fmt.Sprintf(stringSymPattern, len(s), h.Sum(nil))
-       } else {
-               // Small strings get named directly by their contents.
-               symname = strconv.Quote(s)
+       base.Ctxt.Globl(s, nam.Type().Width, flags)
+       if nam.LibfuzzerExtraCounter() {
+               s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
        }
-
-       symdata := Ctxt.Lookup(stringSymPrefix + symname)
-       if !symdata.OnList() {
-               off := dstringdata(symdata, 0, s, pos, "string")
-               ggloblsym(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
-               symdata.Set(obj.AttrContentAddressable, true)
+       if nam.Sym().Linkname != "" {
+               // Make sure linkname'd symbol is non-package. When a symbol is
+               // both imported and linkname'd, s.Pkg may not set to "_" in
+               // types.Sym.Linksym because LSym already exists. Set it here.
+               s.Pkg = "_"
        }
-
-       return symdata
 }
 
-// fileStringSym returns a symbol for the contents and the size of file.
-// If readonly is true, the symbol shares storage with any literal string
-// or other file with the same content and is placed in a read-only section.
-// If readonly is false, the symbol is a read-write copy separate from any other,
-// for use as the backing store of a []byte.
-// The content hash of file is copied into hash. (If hash is nil, nothing is copied.)
-// The returned symbol contains the data itself, not a string header.
-func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.LSym, int64, error) {
-       f, err := os.Open(file)
-       if err != nil {
-               return nil, 0, err
+func dumpembeds() {
+       for _, v := range typecheck.Target.Embeds {
+               staticdata.WriteEmbed(v)
        }
-       defer f.Close()
-       info, err := f.Stat()
-       if err != nil {
-               return nil, 0, err
-       }
-       if !info.Mode().IsRegular() {
-               return nil, 0, fmt.Errorf("not a regular file")
-       }
-       size := info.Size()
-       if size <= 1*1024 {
-               data, err := ioutil.ReadAll(f)
-               if err != nil {
-                       return nil, 0, err
-               }
-               if int64(len(data)) != size {
-                       return nil, 0, fmt.Errorf("file changed between reads")
-               }
-               var sym *obj.LSym
-               if readonly {
-                       sym = stringsym(pos, string(data))
-               } else {
-                       sym = slicedata(pos, string(data)).Sym.Linksym()
-               }
-               if len(hash) > 0 {
-                       sum := sha256.Sum256(data)
-                       copy(hash, sum[:])
-               }
-               return sym, size, nil
-       }
-       if size > 2e9 {
-               // ggloblsym takes an int32,
-               // and probably the rest of the toolchain
-               // can't handle such big symbols either.
-               // See golang.org/issue/9862.
-               return nil, 0, fmt.Errorf("file too large")
-       }
-
-       // File is too big to read and keep in memory.
-       // Compute hash if needed for read-only content hashing or if the caller wants it.
-       var sum []byte
-       if readonly || len(hash) > 0 {
-               h := sha256.New()
-               n, err := io.Copy(h, f)
-               if err != nil {
-                       return nil, 0, err
-               }
-               if n != size {
-                       return nil, 0, fmt.Errorf("file changed between reads")
-               }
-               sum = h.Sum(nil)
-               copy(hash, sum)
-       }
-
-       var symdata *obj.LSym
-       if readonly {
-               symname := fmt.Sprintf(stringSymPattern, size, sum)
-               symdata = Ctxt.Lookup(stringSymPrefix + symname)
-               if !symdata.OnList() {
-                       info := symdata.NewFileInfo()
-                       info.Name = file
-                       info.Size = size
-                       ggloblsym(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
-                       // Note: AttrContentAddressable cannot be set here,
-                       // because the content-addressable-handling code
-                       // does not know about file symbols.
-               }
-       } else {
-               // Emit a zero-length data symbol
-               // and then fix up length and content to use file.
-               symdata = slicedata(pos, "").Sym.Linksym()
-               symdata.Size = size
-               symdata.Type = objabi.SNOPTRDATA
-               info := symdata.NewFileInfo()
-               info.Name = file
-               info.Size = size
-       }
-
-       return symdata, size, nil
-}
-
-var slicedataGen int
-
-func slicedata(pos src.XPos, s string) *Node {
-       slicedataGen++
-       symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
-       sym := localpkg.Lookup(symname)
-       symnode := newname(sym)
-       sym.Def = asTypesNode(symnode)
-
-       lsym := sym.Linksym()
-       off := dstringdata(lsym, 0, s, pos, "slice")
-       ggloblsym(lsym, int32(off), obj.NOPTR|obj.LOCAL)
-
-       return symnode
 }
 
-func slicebytes(nam *Node, s string) {
-       if nam.Op != ONAME {
-               Fatalf("slicebytes %v", nam)
-       }
-       slicesym(nam, slicedata(nam.Pos, s), int64(len(s)))
-}
-
-func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
-       // Objects that are too large will cause the data section to overflow right away,
-       // causing a cryptic error message by the linker. Check for oversize objects here
-       // and provide a useful error message instead.
-       if int64(len(t)) > 2e9 {
-               yyerrorl(pos, "%v with length %v is too big", what, len(t))
-               return 0
-       }
-
-       s.WriteString(Ctxt, int64(off), len(t), t)
-       return off + len(t)
-}
-
-func dsymptr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
-       off = int(Rnd(int64(off), int64(Widthptr)))
-       s.WriteAddr(Ctxt, int64(off), Widthptr, x, int64(xoff))
-       off += Widthptr
-       return off
-}
-
-func dsymptrOff(s *obj.LSym, off int, x *obj.LSym) int {
-       s.WriteOff(Ctxt, int64(off), x, 0)
-       off += 4
-       return off
-}
-
-func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
-       s.WriteWeakOff(Ctxt, int64(off), x, 0)
-       off += 4
-       return off
-}
-
-// slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
-// arr must be an ONAME. slicesym does not modify n.
-func slicesym(n, arr *Node, lencap int64) {
-       s := n.Sym.Linksym()
-       base := n.Xoffset
-       if arr.Op != ONAME {
-               Fatalf("slicesym non-name arr %v", arr)
-       }
-       s.WriteAddr(Ctxt, base, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
-       s.WriteInt(Ctxt, base+sliceLenOffset, Widthptr, lencap)
-       s.WriteInt(Ctxt, base+sliceCapOffset, Widthptr, lencap)
-}
-
-// addrsym writes the static address of a to n. a must be an ONAME.
-// Neither n nor a is modified.
-func addrsym(n, a *Node) {
-       if n.Op != ONAME {
-               Fatalf("addrsym n op %v", n.Op)
-       }
-       if n.Sym == nil {
-               Fatalf("addrsym nil n sym")
-       }
-       if a.Op != ONAME {
-               Fatalf("addrsym a op %v", a.Op)
-       }
-       s := n.Sym.Linksym()
-       s.WriteAddr(Ctxt, n.Xoffset, Widthptr, a.Sym.Linksym(), a.Xoffset)
-}
-
-// pfuncsym writes the static address of f to n. f must be a global function.
-// Neither n nor f is modified.
-func pfuncsym(n, f *Node) {
-       if n.Op != ONAME {
-               Fatalf("pfuncsym n op %v", n.Op)
-       }
-       if n.Sym == nil {
-               Fatalf("pfuncsym nil n sym")
-       }
-       if f.Class() != PFUNC {
-               Fatalf("pfuncsym class not PFUNC %d", f.Class())
-       }
-       s := n.Sym.Linksym()
-       s.WriteAddr(Ctxt, n.Xoffset, Widthptr, funcsym(f.Sym).Linksym(), f.Xoffset)
-}
-
-// litsym writes the static literal c to n.
-// Neither n nor c is modified.
-func litsym(n, c *Node, wid int) {
-       if n.Op != ONAME {
-               Fatalf("litsym n op %v", n.Op)
-       }
-       if c.Op != OLITERAL {
-               Fatalf("litsym c op %v", c.Op)
-       }
-       if n.Sym == nil {
-               Fatalf("litsym nil n sym")
-       }
-       s := n.Sym.Linksym()
-       switch u := c.Val().U.(type) {
-       case bool:
-               i := int64(obj.Bool2int(u))
-               s.WriteInt(Ctxt, n.Xoffset, wid, i)
-
-       case *Mpint:
-               s.WriteInt(Ctxt, n.Xoffset, wid, u.Int64())
-
-       case *Mpflt:
-               f := u.Float64()
-               switch n.Type.Etype {
-               case TFLOAT32:
-                       s.WriteFloat32(Ctxt, n.Xoffset, float32(f))
-               case TFLOAT64:
-                       s.WriteFloat64(Ctxt, n.Xoffset, f)
-               }
-
-       case *Mpcplx:
-               r := u.Real.Float64()
-               i := u.Imag.Float64()
-               switch n.Type.Etype {
-               case TCOMPLEX64:
-                       s.WriteFloat32(Ctxt, n.Xoffset, float32(r))
-                       s.WriteFloat32(Ctxt, n.Xoffset+4, float32(i))
-               case TCOMPLEX128:
-                       s.WriteFloat64(Ctxt, n.Xoffset, r)
-                       s.WriteFloat64(Ctxt, n.Xoffset+8, i)
+func addsignats(dcls []ir.Node) {
+       // copy types from dcl list to signatset
+       for _, n := range dcls {
+               if n.Op() == ir.OTYPE {
+                       reflectdata.NeedRuntimeType(n.Type())
                }
-
-       case string:
-               symdata := stringsym(n.Pos, u)
-               s.WriteAddr(Ctxt, n.Xoffset, Widthptr, symdata, 0)
-               s.WriteInt(Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(u)))
-
-       default:
-               Fatalf("litsym unhandled OLITERAL %v", c)
        }
 }

diff --git a/src/cmd/compile/internal/gc/op_string.go b/src/cmd/compile/internal/gc/op_string.go
deleted file mode 100644 (file)
index 41d5883..0000000
--- a/src/cmd/compile/internal/gc/op_string.go
+++ /dev/null
@@ -1,175 +0,0 @@
-// Code generated by "stringer -type=Op -trimprefix=O"; DO NOT EDIT.
-
-package gc
-
-import "strconv"
-
-func _() {
-       // An "invalid array index" compiler error signifies that the constant values have changed.
-       // Re-run the stringer command to generate them again.
-       var x [1]struct{}
-       _ = x[OXXX-0]
-       _ = x[ONAME-1]
-       _ = x[ONONAME-2]
-       _ = x[OTYPE-3]
-       _ = x[OPACK-4]
-       _ = x[OLITERAL-5]
-       _ = x[OADD-6]
-       _ = x[OSUB-7]
-       _ = x[OOR-8]
-       _ = x[OXOR-9]
-       _ = x[OADDSTR-10]
-       _ = x[OADDR-11]
-       _ = x[OANDAND-12]
-       _ = x[OAPPEND-13]
-       _ = x[OBYTES2STR-14]
-       _ = x[OBYTES2STRTMP-15]
-       _ = x[ORUNES2STR-16]
-       _ = x[OSTR2BYTES-17]
-       _ = x[OSTR2BYTESTMP-18]
-       _ = x[OSTR2RUNES-19]
-       _ = x[OAS-20]
-       _ = x[OAS2-21]
-       _ = x[OAS2DOTTYPE-22]
-       _ = x[OAS2FUNC-23]
-       _ = x[OAS2MAPR-24]
-       _ = x[OAS2RECV-25]
-       _ = x[OASOP-26]
-       _ = x[OCALL-27]
-       _ = x[OCALLFUNC-28]
-       _ = x[OCALLMETH-29]
-       _ = x[OCALLINTER-30]
-       _ = x[OCALLPART-31]
-       _ = x[OCAP-32]
-       _ = x[OCLOSE-33]
-       _ = x[OCLOSURE-34]
-       _ = x[OCOMPLIT-35]
-       _ = x[OMAPLIT-36]
-       _ = x[OSTRUCTLIT-37]
-       _ = x[OARRAYLIT-38]
-       _ = x[OSLICELIT-39]
-       _ = x[OPTRLIT-40]
-       _ = x[OCONV-41]
-       _ = x[OCONVIFACE-42]
-       _ = x[OCONVNOP-43]
-       _ = x[OCOPY-44]
-       _ = x[ODCL-45]
-       _ = x[ODCLFUNC-46]
-       _ = x[ODCLFIELD-47]
-       _ = x[ODCLCONST-48]
-       _ = x[ODCLTYPE-49]
-       _ = x[ODELETE-50]
-       _ = x[ODOT-51]
-       _ = x[ODOTPTR-52]
-       _ = x[ODOTMETH-53]
-       _ = x[ODOTINTER-54]
-       _ = x[OXDOT-55]
-       _ = x[ODOTTYPE-56]
-       _ = x[ODOTTYPE2-57]
-       _ = x[OEQ-58]
-       _ = x[ONE-59]
-       _ = x[OLT-60]
-       _ = x[OLE-61]
-       _ = x[OGE-62]
-       _ = x[OGT-63]
-       _ = x[ODEREF-64]
-       _ = x[OINDEX-65]
-       _ = x[OINDEXMAP-66]
-       _ = x[OKEY-67]
-       _ = x[OSTRUCTKEY-68]
-       _ = x[OLEN-69]
-       _ = x[OMAKE-70]
-       _ = x[OMAKECHAN-71]
-       _ = x[OMAKEMAP-72]
-       _ = x[OMAKESLICE-73]
-       _ = x[OMAKESLICECOPY-74]
-       _ = x[OMUL-75]
-       _ = x[ODIV-76]
-       _ = x[OMOD-77]
-       _ = x[OLSH-78]
-       _ = x[ORSH-79]
-       _ = x[OAND-80]
-       _ = x[OANDNOT-81]
-       _ = x[ONEW-82]
-       _ = x[ONEWOBJ-83]
-       _ = x[ONOT-84]
-       _ = x[OBITNOT-85]
-       _ = x[OPLUS-86]
-       _ = x[ONEG-87]
-       _ = x[OOROR-88]
-       _ = x[OPANIC-89]
-       _ = x[OPRINT-90]
-       _ = x[OPRINTN-91]
-       _ = x[OPAREN-92]
-       _ = x[OSEND-93]
-       _ = x[OSLICE-94]
-       _ = x[OSLICEARR-95]
-       _ = x[OSLICESTR-96]
-       _ = x[OSLICE3-97]
-       _ = x[OSLICE3ARR-98]
-       _ = x[OSLICEHEADER-99]
-       _ = x[ORECOVER-100]
-       _ = x[ORECV-101]
-       _ = x[ORUNESTR-102]
-       _ = x[OSELRECV-103]
-       _ = x[OSELRECV2-104]
-       _ = x[OIOTA-105]
-       _ = x[OREAL-106]
-       _ = x[OIMAG-107]
-       _ = x[OCOMPLEX-108]
-       _ = x[OALIGNOF-109]
-       _ = x[OOFFSETOF-110]
-       _ = x[OSIZEOF-111]
-       _ = x[OBLOCK-112]
-       _ = x[OBREAK-113]
-       _ = x[OCASE-114]
-       _ = x[OCONTINUE-115]
-       _ = x[ODEFER-116]
-       _ = x[OEMPTY-117]
-       _ = x[OFALL-118]
-       _ = x[OFOR-119]
-       _ = x[OFORUNTIL-120]
-       _ = x[OGOTO-121]
-       _ = x[OIF-122]
-       _ = x[OLABEL-123]
-       _ = x[OGO-124]
-       _ = x[ORANGE-125]
-       _ = x[ORETURN-126]
-       _ = x[OSELECT-127]
-       _ = x[OSWITCH-128]
-       _ = x[OTYPESW-129]
-       _ = x[OTCHAN-130]
-       _ = x[OTMAP-131]
-       _ = x[OTSTRUCT-132]
-       _ = x[OTINTER-133]
-       _ = x[OTFUNC-134]
-       _ = x[OTARRAY-135]
-       _ = x[ODDD-136]
-       _ = x[OINLCALL-137]
-       _ = x[OEFACE-138]
-       _ = x[OITAB-139]
-       _ = x[OIDATA-140]
-       _ = x[OSPTR-141]
-       _ = x[OCLOSUREVAR-142]
-       _ = x[OCFUNC-143]
-       _ = x[OCHECKNIL-144]
-       _ = x[OVARDEF-145]
-       _ = x[OVARKILL-146]
-       _ = x[OVARLIVE-147]
-       _ = x[ORESULT-148]
-       _ = x[OINLMARK-149]
-       _ = x[ORETJMP-150]
-       _ = x[OGETG-151]
-       _ = x[OEND-152]
-}
-
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
-
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 36, 39, 45, 49, 55, 61, 70, 82, 91, 100, 112, 121, 123, 126, 136, 143, 150, 157, 161, 165, 173, 181, 190, 198, 201, 206, 213, 220, 226, 235, 243, 251, 257, 261, 270, 277, 281, 284, 291, 299, 307, 314, 320, 323, 329, 336, 344, 348, 355, 363, 365, 367, 369, 371, 373, 375, 380, 385, 393, 396, 405, 408, 412, 420, 427, 436, 449, 452, 455, 458, 461, 464, 467, 473, 476, 482, 485, 491, 495, 498, 502, 507, 512, 518, 523, 527, 532, 540, 548, 554, 563, 574, 581, 585, 592, 599, 607, 611, 615, 619, 626, 633, 641, 647, 652, 657, 661, 669, 674, 679, 683, 686, 694, 698, 700, 705, 707, 712, 718, 724, 730, 736, 741, 745, 752, 758, 763, 769, 772, 779, 784, 788, 793, 797, 807, 812, 820, 826, 833, 840, 846, 853, 859, 863, 866}
-
-func (i Op) String() string {
-       if i >= Op(len(_Op_index)-1) {
-               return "Op(" + strconv.FormatInt(int64(i), 10) + ")"
-       }
-       return _Op_name[_Op_index[i]:_Op_index[i+1]]
-}

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
deleted file mode 100644 (file)
index 30e1535..0000000
--- a/src/cmd/compile/internal/gc/order.go
+++ /dev/null
@@ -1,1441 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "fmt"
-)
-
-// Rewrite tree to use separate statements to enforce
-// order of evaluation. Makes walk easier, because it
-// can (after this runs) reorder at will within an expression.
-//
-// Rewrite m[k] op= r into m[k] = m[k] op r if op is / or %.
-//
-// Introduce temporaries as needed by runtime routines.
-// For example, the map runtime routines take the map key
-// by reference, so make sure all map keys are addressable
-// by copying them to temporaries as needed.
-// The same is true for channel operations.
-//
-// Arrange that map index expressions only appear in direct
-// assignments x = m[k] or m[k] = x, never in larger expressions.
-//
-// Arrange that receive expressions only appear in direct assignments
-// x = <-c or as standalone statements <-c, never in larger expressions.
-
-// TODO(rsc): The temporary introduction during multiple assignments
-// should be moved into this file, so that the temporaries can be cleaned
-// and so that conversions implicit in the OAS2FUNC and OAS2RECV
-// nodes can be made explicit and then have their temporaries cleaned.
-
-// TODO(rsc): Goto and multilevel break/continue can jump over
-// inserted VARKILL annotations. Work out a way to handle these.
-// The current implementation is safe, in that it will execute correctly.
-// But it won't reuse temporaries as aggressively as it might, and
-// it can result in unnecessary zeroing of those variables in the function
-// prologue.
-
-// Order holds state during the ordering process.
-type Order struct {
-       out  []*Node            // list of generated statements
-       temp []*Node            // stack of temporary variables
-       free map[string][]*Node // free list of unused temporaries, by type.LongString().
-}
-
-// Order rewrites fn.Nbody to apply the ordering constraints
-// described in the comment at the top of the file.
-func order(fn *Node) {
-       if Debug.W > 1 {
-               s := fmt.Sprintf("\nbefore order %v", fn.Func.Nname.Sym)
-               dumplist(s, fn.Nbody)
-       }
-
-       orderBlock(&fn.Nbody, map[string][]*Node{})
-}
-
-// newTemp allocates a new temporary with the given type,
-// pushes it onto the temp stack, and returns it.
-// If clear is true, newTemp emits code to zero the temporary.
-func (o *Order) newTemp(t *types.Type, clear bool) *Node {
-       var v *Node
-       // Note: LongString is close to the type equality we want,
-       // but not exactly. We still need to double-check with types.Identical.
-       key := t.LongString()
-       a := o.free[key]
-       for i, n := range a {
-               if types.Identical(t, n.Type) {
-                       v = a[i]
-                       a[i] = a[len(a)-1]
-                       a = a[:len(a)-1]
-                       o.free[key] = a
-                       break
-               }
-       }
-       if v == nil {
-               v = temp(t)
-       }
-       if clear {
-               a := nod(OAS, v, nil)
-               a = typecheck(a, ctxStmt)
-               o.out = append(o.out, a)
-       }
-
-       o.temp = append(o.temp, v)
-       return v
-}
-
-// copyExpr behaves like newTemp but also emits
-// code to initialize the temporary to the value n.
-//
-// The clear argument is provided for use when the evaluation
-// of tmp = n turns into a function call that is passed a pointer
-// to the temporary as the output space. If the call blocks before
-// tmp has been written, the garbage collector will still treat the
-// temporary as live, so we must zero it before entering that call.
-// Today, this only happens for channel receive operations.
-// (The other candidate would be map access, but map access
-// returns a pointer to the result data instead of taking a pointer
-// to be filled in.)
-func (o *Order) copyExpr(n *Node, t *types.Type, clear bool) *Node {
-       v := o.newTemp(t, clear)
-       a := nod(OAS, v, n)
-       a = typecheck(a, ctxStmt)
-       o.out = append(o.out, a)
-       return v
-}
-
-// cheapExpr returns a cheap version of n.
-// The definition of cheap is that n is a variable or constant.
-// If not, cheapExpr allocates a new tmp, emits tmp = n,
-// and then returns tmp.
-func (o *Order) cheapExpr(n *Node) *Node {
-       if n == nil {
-               return nil
-       }
-
-       switch n.Op {
-       case ONAME, OLITERAL:
-               return n
-       case OLEN, OCAP:
-               l := o.cheapExpr(n.Left)
-               if l == n.Left {
-                       return n
-               }
-               a := n.sepcopy()
-               a.Left = l
-               return typecheck(a, ctxExpr)
-       }
-
-       return o.copyExpr(n, n.Type, false)
-}
-
-// safeExpr returns a safe version of n.
-// The definition of safe is that n can appear multiple times
-// without violating the semantics of the original program,
-// and that assigning to the safe version has the same effect
-// as assigning to the original n.
-//
-// The intended use is to apply to x when rewriting x += y into x = x + y.
-func (o *Order) safeExpr(n *Node) *Node {
-       switch n.Op {
-       case ONAME, OLITERAL:
-               return n
-
-       case ODOT, OLEN, OCAP:
-               l := o.safeExpr(n.Left)
-               if l == n.Left {
-                       return n
-               }
-               a := n.sepcopy()
-               a.Left = l
-               return typecheck(a, ctxExpr)
-
-       case ODOTPTR, ODEREF:
-               l := o.cheapExpr(n.Left)
-               if l == n.Left {
-                       return n
-               }
-               a := n.sepcopy()
-               a.Left = l
-               return typecheck(a, ctxExpr)
-
-       case OINDEX, OINDEXMAP:
-               var l *Node
-               if n.Left.Type.IsArray() {
-                       l = o.safeExpr(n.Left)
-               } else {
-                       l = o.cheapExpr(n.Left)
-               }
-               r := o.cheapExpr(n.Right)
-               if l == n.Left && r == n.Right {
-                       return n
-               }
-               a := n.sepcopy()
-               a.Left = l
-               a.Right = r
-               return typecheck(a, ctxExpr)
-
-       default:
-               Fatalf("order.safeExpr %v", n.Op)
-               return nil // not reached
-       }
-}
-
-// isaddrokay reports whether it is okay to pass n's address to runtime routines.
-// Taking the address of a variable makes the liveness and optimization analyses
-// lose track of where the variable's lifetime ends. To avoid hurting the analyses
-// of ordinary stack variables, those are not 'isaddrokay'. Temporaries are okay,
-// because we emit explicit VARKILL instructions marking the end of those
-// temporaries' lifetimes.
-func isaddrokay(n *Node) bool {
-       return islvalue(n) && (n.Op != ONAME || n.Class() == PEXTERN || n.IsAutoTmp())
-}
-
-// addrTemp ensures that n is okay to pass by address to runtime routines.
-// If the original argument n is not okay, addrTemp creates a tmp, emits
-// tmp = n, and then returns tmp.
-// The result of addrTemp MUST be assigned back to n, e.g.
-//     n.Left = o.addrTemp(n.Left)
-func (o *Order) addrTemp(n *Node) *Node {
-       if consttype(n) != CTxxx {
-               // TODO: expand this to all static composite literal nodes?
-               n = defaultlit(n, nil)
-               dowidth(n.Type)
-               vstat := readonlystaticname(n.Type)
-               var s InitSchedule
-               s.staticassign(vstat, n)
-               if s.out != nil {
-                       Fatalf("staticassign of const generated code: %+v", n)
-               }
-               vstat = typecheck(vstat, ctxExpr)
-               return vstat
-       }
-       if isaddrokay(n) {
-               return n
-       }
-       return o.copyExpr(n, n.Type, false)
-}
-
-// mapKeyTemp prepares n to be a key in a map runtime call and returns n.
-// It should only be used for map runtime calls which have *_fast* versions.
-func (o *Order) mapKeyTemp(t *types.Type, n *Node) *Node {
-       // Most map calls need to take the address of the key.
-       // Exception: map*_fast* calls. See golang.org/issue/19015.
-       if mapfast(t) == mapslow {
-               return o.addrTemp(n)
-       }
-       return n
-}
-
-// mapKeyReplaceStrConv replaces OBYTES2STR by OBYTES2STRTMP
-// in n to avoid string allocations for keys in map lookups.
-// Returns a bool that signals if a modification was made.
-//
-// For:
-//  x = m[string(k)]
-//  x = m[T1{... Tn{..., string(k), ...}]
-// where k is []byte, T1 to Tn is a nesting of struct and array literals,
-// the allocation of backing bytes for the string can be avoided
-// by reusing the []byte backing array. These are special cases
-// for avoiding allocations when converting byte slices to strings.
-// It would be nice to handle these generally, but because
-// []byte keys are not allowed in maps, the use of string(k)
-// comes up in important cases in practice. See issue 3512.
-func mapKeyReplaceStrConv(n *Node) bool {
-       var replaced bool
-       switch n.Op {
-       case OBYTES2STR:
-               n.Op = OBYTES2STRTMP
-               replaced = true
-       case OSTRUCTLIT:
-               for _, elem := range n.List.Slice() {
-                       if mapKeyReplaceStrConv(elem.Left) {
-                               replaced = true
-                       }
-               }
-       case OARRAYLIT:
-               for _, elem := range n.List.Slice() {
-                       if elem.Op == OKEY {
-                               elem = elem.Right
-                       }
-                       if mapKeyReplaceStrConv(elem) {
-                               replaced = true
-                       }
-               }
-       }
-       return replaced
-}
-
-type ordermarker int
-
-// markTemp returns the top of the temporary variable stack.
-func (o *Order) markTemp() ordermarker {
-       return ordermarker(len(o.temp))
-}
-
-// popTemp pops temporaries off the stack until reaching the mark,
-// which must have been returned by markTemp.
-func (o *Order) popTemp(mark ordermarker) {
-       for _, n := range o.temp[mark:] {
-               key := n.Type.LongString()
-               o.free[key] = append(o.free[key], n)
-       }
-       o.temp = o.temp[:mark]
-}
-
-// cleanTempNoPop emits VARKILL instructions to *out
-// for each temporary above the mark on the temporary stack.
-// It does not pop the temporaries from the stack.
-func (o *Order) cleanTempNoPop(mark ordermarker) []*Node {
-       var out []*Node
-       for i := len(o.temp) - 1; i >= int(mark); i-- {
-               n := o.temp[i]
-               kill := nod(OVARKILL, n, nil)
-               kill = typecheck(kill, ctxStmt)
-               out = append(out, kill)
-       }
-       return out
-}
-
-// cleanTemp emits VARKILL instructions for each temporary above the
-// mark on the temporary stack and removes them from the stack.
-func (o *Order) cleanTemp(top ordermarker) {
-       o.out = append(o.out, o.cleanTempNoPop(top)...)
-       o.popTemp(top)
-}
-
-// stmtList orders each of the statements in the list.
-func (o *Order) stmtList(l Nodes) {
-       s := l.Slice()
-       for i := range s {
-               orderMakeSliceCopy(s[i:])
-               o.stmt(s[i])
-       }
-}
-
-// orderMakeSliceCopy matches the pattern:
-//  m = OMAKESLICE([]T, x); OCOPY(m, s)
-// and rewrites it to:
-//  m = OMAKESLICECOPY([]T, x, s); nil
-func orderMakeSliceCopy(s []*Node) {
-       if Debug.N != 0 || instrumenting {
-               return
-       }
-
-       if len(s) < 2 {
-               return
-       }
-
-       asn := s[0]
-       copyn := s[1]
-
-       if asn == nil || asn.Op != OAS {
-               return
-       }
-       if asn.Left.Op != ONAME {
-               return
-       }
-       if asn.Left.isBlank() {
-               return
-       }
-       maken := asn.Right
-       if maken == nil || maken.Op != OMAKESLICE {
-               return
-       }
-       if maken.Esc == EscNone {
-               return
-       }
-       if maken.Left == nil || maken.Right != nil {
-               return
-       }
-       if copyn.Op != OCOPY {
-               return
-       }
-       if copyn.Left.Op != ONAME {
-               return
-       }
-       if asn.Left.Sym != copyn.Left.Sym {
-               return
-       }
-       if copyn.Right.Op != ONAME {
-               return
-       }
-
-       if copyn.Left.Sym == copyn.Right.Sym {
-               return
-       }
-
-       maken.Op = OMAKESLICECOPY
-       maken.Right = copyn.Right
-       // Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-       maken.SetBounded(maken.Left.Op == OLEN && samesafeexpr(maken.Left.Left, copyn.Right))
-
-       maken = typecheck(maken, ctxExpr)
-
-       s[1] = nil // remove separate copy call
-
-       return
-}
-
-// edge inserts coverage instrumentation for libfuzzer.
-func (o *Order) edge() {
-       if Debug_libfuzzer == 0 {
-               return
-       }
-
-       // Create a new uint8 counter to be allocated in section
-       // __libfuzzer_extra_counters.
-       counter := staticname(types.Types[TUINT8])
-       counter.Name.SetLibfuzzerExtraCounter(true)
-
-       // counter += 1
-       incr := nod(OASOP, counter, nodintconst(1))
-       incr.SetSubOp(OADD)
-       incr = typecheck(incr, ctxStmt)
-
-       o.out = append(o.out, incr)
-}
-
-// orderBlock orders the block of statements in n into a new slice,
-// and then replaces the old slice in n with the new slice.
-// free is a map that can be used to obtain temporary variables by type.
-func orderBlock(n *Nodes, free map[string][]*Node) {
-       var order Order
-       order.free = free
-       mark := order.markTemp()
-       order.edge()
-       order.stmtList(*n)
-       order.cleanTemp(mark)
-       n.Set(order.out)
-}
-
-// exprInPlace orders the side effects in *np and
-// leaves them as the init list of the final *np.
-// The result of exprInPlace MUST be assigned back to n, e.g.
-//     n.Left = o.exprInPlace(n.Left)
-func (o *Order) exprInPlace(n *Node) *Node {
-       var order Order
-       order.free = o.free
-       n = order.expr(n, nil)
-       n = addinit(n, order.out)
-
-       // insert new temporaries from order
-       // at head of outer list.
-       o.temp = append(o.temp, order.temp...)
-       return n
-}
-
-// orderStmtInPlace orders the side effects of the single statement *np
-// and replaces it with the resulting statement list.
-// The result of orderStmtInPlace MUST be assigned back to n, e.g.
-//     n.Left = orderStmtInPlace(n.Left)
-// free is a map that can be used to obtain temporary variables by type.
-func orderStmtInPlace(n *Node, free map[string][]*Node) *Node {
-       var order Order
-       order.free = free
-       mark := order.markTemp()
-       order.stmt(n)
-       order.cleanTemp(mark)
-       return liststmt(order.out)
-}
-
-// init moves n's init list to o.out.
-func (o *Order) init(n *Node) {
-       if n.mayBeShared() {
-               // For concurrency safety, don't mutate potentially shared nodes.
-               // First, ensure that no work is required here.
-               if n.Ninit.Len() > 0 {
-                       Fatalf("order.init shared node with ninit")
-               }
-               return
-       }
-       o.stmtList(n.Ninit)
-       n.Ninit.Set(nil)
-}
-
-// call orders the call expression n.
-// n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
-func (o *Order) call(n *Node) {
-       if n.Ninit.Len() > 0 {
-               // Caller should have already called o.init(n).
-               Fatalf("%v with unexpected ninit", n.Op)
-       }
-
-       // Builtin functions.
-       if n.Op != OCALLFUNC && n.Op != OCALLMETH && n.Op != OCALLINTER {
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               o.exprList(n.List)
-               return
-       }
-
-       fixVariadicCall(n)
-       n.Left = o.expr(n.Left, nil)
-       o.exprList(n.List)
-
-       if n.Op == OCALLINTER {
-               return
-       }
-       keepAlive := func(arg *Node) {
-               // If the argument is really a pointer being converted to uintptr,
-               // arrange for the pointer to be kept alive until the call returns,
-               // by copying it into a temp and marking that temp
-               // still alive when we pop the temp stack.
-               if arg.Op == OCONVNOP && arg.Left.Type.IsUnsafePtr() {
-                       x := o.copyExpr(arg.Left, arg.Left.Type, false)
-                       arg.Left = x
-                       x.Name.SetAddrtaken(true) // ensure SSA keeps the x variable
-                       n.Nbody.Append(typecheck(nod(OVARLIVE, x, nil), ctxStmt))
-               }
-       }
-
-       // Check for "unsafe-uintptr" tag provided by escape analysis.
-       for i, param := range n.Left.Type.Params().FieldSlice() {
-               if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
-                       if arg := n.List.Index(i); arg.Op == OSLICELIT {
-                               for _, elt := range arg.List.Slice() {
-                                       keepAlive(elt)
-                               }
-                       } else {
-                               keepAlive(arg)
-                       }
-               }
-       }
-}
-
-// mapAssign appends n to o.out, introducing temporaries
-// to make sure that all map assignments have the form m[k] = x.
-// (Note: expr has already been called on n, so we know k is addressable.)
-//
-// If n is the multiple assignment form ..., m[k], ... = ..., x, ..., the rewrite is
-//     t1 = m
-//     t2 = k
-//     ...., t3, ... = ..., x, ...
-//     t1[t2] = t3
-//
-// The temporaries t1, t2 are needed in case the ... being assigned
-// contain m or k. They are usually unnecessary, but in the unnecessary
-// cases they are also typically registerizable, so not much harm done.
-// And this only applies to the multiple-assignment form.
-// We could do a more precise analysis if needed, like in walk.go.
-func (o *Order) mapAssign(n *Node) {
-       switch n.Op {
-       default:
-               Fatalf("order.mapAssign %v", n.Op)
-
-       case OAS, OASOP:
-               if n.Left.Op == OINDEXMAP {
-                       // Make sure we evaluate the RHS before starting the map insert.
-                       // We need to make sure the RHS won't panic.  See issue 22881.
-                       if n.Right.Op == OAPPEND {
-                               s := n.Right.List.Slice()[1:]
-                               for i, n := range s {
-                                       s[i] = o.cheapExpr(n)
-                               }
-                       } else {
-                               n.Right = o.cheapExpr(n.Right)
-                       }
-               }
-               o.out = append(o.out, n)
-
-       case OAS2, OAS2DOTTYPE, OAS2MAPR, OAS2FUNC:
-               var post []*Node
-               for i, m := range n.List.Slice() {
-                       switch {
-                       case m.Op == OINDEXMAP:
-                               if !m.Left.IsAutoTmp() {
-                                       m.Left = o.copyExpr(m.Left, m.Left.Type, false)
-                               }
-                               if !m.Right.IsAutoTmp() {
-                                       m.Right = o.copyExpr(m.Right, m.Right.Type, false)
-                               }
-                               fallthrough
-                       case instrumenting && n.Op == OAS2FUNC && !m.isBlank():
-                               t := o.newTemp(m.Type, false)
-                               n.List.SetIndex(i, t)
-                               a := nod(OAS, m, t)
-                               a = typecheck(a, ctxStmt)
-                               post = append(post, a)
-                       }
-               }
-
-               o.out = append(o.out, n)
-               o.out = append(o.out, post...)
-       }
-}
-
-// stmt orders the statement n, appending to o.out.
-// Temporaries created during the statement are cleaned
-// up using VARKILL instructions as possible.
-func (o *Order) stmt(n *Node) {
-       if n == nil {
-               return
-       }
-
-       lno := setlineno(n)
-       o.init(n)
-
-       switch n.Op {
-       default:
-               Fatalf("order.stmt %v", n.Op)
-
-       case OVARKILL, OVARLIVE, OINLMARK:
-               o.out = append(o.out, n)
-
-       case OAS:
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, n.Left)
-               o.mapAssign(n)
-               o.cleanTemp(t)
-
-       case OASOP:
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-
-               if instrumenting || n.Left.Op == OINDEXMAP && (n.SubOp() == ODIV || n.SubOp() == OMOD) {
-                       // Rewrite m[k] op= r into m[k] = m[k] op r so
-                       // that we can ensure that if op panics
-                       // because r is zero, the panic happens before
-                       // the map assignment.
-
-                       n.Left = o.safeExpr(n.Left)
-
-                       l := treecopy(n.Left, src.NoXPos)
-                       if l.Op == OINDEXMAP {
-                               l.SetIndexMapLValue(false)
-                       }
-                       l = o.copyExpr(l, n.Left.Type, false)
-                       n.Right = nod(n.SubOp(), l, n.Right)
-                       n.Right = typecheck(n.Right, ctxExpr)
-                       n.Right = o.expr(n.Right, nil)
-
-                       n.Op = OAS
-                       n.ResetAux()
-               }
-
-               o.mapAssign(n)
-               o.cleanTemp(t)
-
-       case OAS2:
-               t := o.markTemp()
-               o.exprList(n.List)
-               o.exprList(n.Rlist)
-               o.mapAssign(n)
-               o.cleanTemp(t)
-
-       // Special: avoid copy of func call n.Right
-       case OAS2FUNC:
-               t := o.markTemp()
-               o.exprList(n.List)
-               o.init(n.Right)
-               o.call(n.Right)
-               o.as2(n)
-               o.cleanTemp(t)
-
-       // Special: use temporary variables to hold result,
-       // so that runtime can take address of temporary.
-       // No temporary for blank assignment.
-       //
-       // OAS2MAPR: make sure key is addressable if needed,
-       //           and make sure OINDEXMAP is not copied out.
-       case OAS2DOTTYPE, OAS2RECV, OAS2MAPR:
-               t := o.markTemp()
-               o.exprList(n.List)
-
-               switch r := n.Right; r.Op {
-               case ODOTTYPE2, ORECV:
-                       r.Left = o.expr(r.Left, nil)
-               case OINDEXMAP:
-                       r.Left = o.expr(r.Left, nil)
-                       r.Right = o.expr(r.Right, nil)
-                       // See similar conversion for OINDEXMAP below.
-                       _ = mapKeyReplaceStrConv(r.Right)
-                       r.Right = o.mapKeyTemp(r.Left.Type, r.Right)
-               default:
-                       Fatalf("order.stmt: %v", r.Op)
-               }
-
-               o.okAs2(n)
-               o.cleanTemp(t)
-
-       // Special: does not save n onto out.
-       case OBLOCK, OEMPTY:
-               o.stmtList(n.List)
-
-       // Special: n->left is not an expression; save as is.
-       case OBREAK,
-               OCONTINUE,
-               ODCL,
-               ODCLCONST,
-               ODCLTYPE,
-               OFALL,
-               OGOTO,
-               OLABEL,
-               ORETJMP:
-               o.out = append(o.out, n)
-
-       // Special: handle call arguments.
-       case OCALLFUNC, OCALLINTER, OCALLMETH:
-               t := o.markTemp()
-               o.call(n)
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       case OCLOSE,
-               OCOPY,
-               OPRINT,
-               OPRINTN,
-               ORECOVER,
-               ORECV:
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               o.exprList(n.List)
-               o.exprList(n.Rlist)
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       // Special: order arguments to inner call but not call itself.
-       case ODEFER, OGO:
-               t := o.markTemp()
-               o.init(n.Left)
-               o.call(n.Left)
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       case ODELETE:
-               t := o.markTemp()
-               n.List.SetFirst(o.expr(n.List.First(), nil))
-               n.List.SetSecond(o.expr(n.List.Second(), nil))
-               n.List.SetSecond(o.mapKeyTemp(n.List.First().Type, n.List.Second()))
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       // Clean temporaries from condition evaluation at
-       // beginning of loop body and after for statement.
-       case OFOR:
-               t := o.markTemp()
-               n.Left = o.exprInPlace(n.Left)
-               n.Nbody.Prepend(o.cleanTempNoPop(t)...)
-               orderBlock(&n.Nbody, o.free)
-               n.Right = orderStmtInPlace(n.Right, o.free)
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       // Clean temporaries from condition at
-       // beginning of both branches.
-       case OIF:
-               t := o.markTemp()
-               n.Left = o.exprInPlace(n.Left)
-               n.Nbody.Prepend(o.cleanTempNoPop(t)...)
-               n.Rlist.Prepend(o.cleanTempNoPop(t)...)
-               o.popTemp(t)
-               orderBlock(&n.Nbody, o.free)
-               orderBlock(&n.Rlist, o.free)
-               o.out = append(o.out, n)
-
-       // Special: argument will be converted to interface using convT2E
-       // so make sure it is an addressable temporary.
-       case OPANIC:
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               if !n.Left.Type.IsInterface() {
-                       n.Left = o.addrTemp(n.Left)
-               }
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       case ORANGE:
-               // n.Right is the expression being ranged over.
-               // order it, and then make a copy if we need one.
-               // We almost always do, to ensure that we don't
-               // see any value changes made during the loop.
-               // Usually the copy is cheap (e.g., array pointer,
-               // chan, slice, string are all tiny).
-               // The exception is ranging over an array value
-               // (not a slice, not a pointer to array),
-               // which must make a copy to avoid seeing updates made during
-               // the range body. Ranging over an array value is uncommon though.
-
-               // Mark []byte(str) range expression to reuse string backing storage.
-               // It is safe because the storage cannot be mutated.
-               if n.Right.Op == OSTR2BYTES {
-                       n.Right.Op = OSTR2BYTESTMP
-               }
-
-               t := o.markTemp()
-               n.Right = o.expr(n.Right, nil)
-
-               orderBody := true
-               switch n.Type.Etype {
-               default:
-                       Fatalf("order.stmt range %v", n.Type)
-
-               case TARRAY, TSLICE:
-                       if n.List.Len() < 2 || n.List.Second().isBlank() {
-                               // for i := range x will only use x once, to compute len(x).
-                               // No need to copy it.
-                               break
-                       }
-                       fallthrough
-
-               case TCHAN, TSTRING:
-                       // chan, string, slice, array ranges use value multiple times.
-                       // make copy.
-                       r := n.Right
-
-                       if r.Type.IsString() && r.Type != types.Types[TSTRING] {
-                               r = nod(OCONV, r, nil)
-                               r.Type = types.Types[TSTRING]
-                               r = typecheck(r, ctxExpr)
-                       }
-
-                       n.Right = o.copyExpr(r, r.Type, false)
-
-               case TMAP:
-                       if isMapClear(n) {
-                               // Preserve the body of the map clear pattern so it can
-                               // be detected during walk. The loop body will not be used
-                               // when optimizing away the range loop to a runtime call.
-                               orderBody = false
-                               break
-                       }
-
-                       // copy the map value in case it is a map literal.
-                       // TODO(rsc): Make tmp = literal expressions reuse tmp.
-                       // For maps tmp is just one word so it hardly matters.
-                       r := n.Right
-                       n.Right = o.copyExpr(r, r.Type, false)
-
-                       // prealloc[n] is the temp for the iterator.
-                       // hiter contains pointers and needs to be zeroed.
-                       prealloc[n] = o.newTemp(hiter(n.Type), true)
-               }
-               o.exprListInPlace(n.List)
-               if orderBody {
-                       orderBlock(&n.Nbody, o.free)
-               }
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       case ORETURN:
-               o.exprList(n.List)
-               o.out = append(o.out, n)
-
-       // Special: clean case temporaries in each block entry.
-       // Select must enter one of its blocks, so there is no
-       // need for a cleaning at the end.
-       // Doubly special: evaluation order for select is stricter
-       // than ordinary expressions. Even something like p.c
-       // has to be hoisted into a temporary, so that it cannot be
-       // reordered after the channel evaluation for a different
-       // case (if p were nil, then the timing of the fault would
-       // give this away).
-       case OSELECT:
-               t := o.markTemp()
-
-               for _, n2 := range n.List.Slice() {
-                       if n2.Op != OCASE {
-                               Fatalf("order select case %v", n2.Op)
-                       }
-                       r := n2.Left
-                       setlineno(n2)
-
-                       // Append any new body prologue to ninit.
-                       // The next loop will insert ninit into nbody.
-                       if n2.Ninit.Len() != 0 {
-                               Fatalf("order select ninit")
-                       }
-                       if r == nil {
-                               continue
-                       }
-                       switch r.Op {
-                       default:
-                               Dump("select case", r)
-                               Fatalf("unknown op in select %v", r.Op)
-
-                       // If this is case x := <-ch or case x, y := <-ch, the case has
-                       // the ODCL nodes to declare x and y. We want to delay that
-                       // declaration (and possible allocation) until inside the case body.
-                       // Delete the ODCL nodes here and recreate them inside the body below.
-                       case OSELRECV, OSELRECV2:
-                               if r.Colas() {
-                                       i := 0
-                                       if r.Ninit.Len() != 0 && r.Ninit.First().Op == ODCL && r.Ninit.First().Left == r.Left {
-                                               i++
-                                       }
-                                       if i < r.Ninit.Len() && r.Ninit.Index(i).Op == ODCL && r.List.Len() != 0 && r.Ninit.Index(i).Left == r.List.First() {
-                                               i++
-                                       }
-                                       if i >= r.Ninit.Len() {
-                                               r.Ninit.Set(nil)
-                                       }
-                               }
-
-                               if r.Ninit.Len() != 0 {
-                                       dumplist("ninit", r.Ninit)
-                                       Fatalf("ninit on select recv")
-                               }
-
-                               // case x = <-c
-                               // case x, ok = <-c
-                               // r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
-                               // r->left == N means 'case <-c'.
-                               // c is always evaluated; x and ok are only evaluated when assigned.
-                               r.Right.Left = o.expr(r.Right.Left, nil)
-
-                               if !r.Right.Left.IsAutoTmp() {
-                                       r.Right.Left = o.copyExpr(r.Right.Left, r.Right.Left.Type, false)
-                               }
-
-                               // Introduce temporary for receive and move actual copy into case body.
-                               // avoids problems with target being addressed, as usual.
-                               // NOTE: If we wanted to be clever, we could arrange for just one
-                               // temporary per distinct type, sharing the temp among all receives
-                               // with that temp. Similarly one ok bool could be shared among all
-                               // the x,ok receives. Not worth doing until there's a clear need.
-                               if r.Left != nil && r.Left.isBlank() {
-                                       r.Left = nil
-                               }
-                               if r.Left != nil {
-                                       // use channel element type for temporary to avoid conversions,
-                                       // such as in case interfacevalue = <-intchan.
-                                       // the conversion happens in the OAS instead.
-                                       tmp1 := r.Left
-
-                                       if r.Colas() {
-                                               tmp2 := nod(ODCL, tmp1, nil)
-                                               tmp2 = typecheck(tmp2, ctxStmt)
-                                               n2.Ninit.Append(tmp2)
-                                       }
-
-                                       r.Left = o.newTemp(r.Right.Left.Type.Elem(), r.Right.Left.Type.Elem().HasPointers())
-                                       tmp2 := nod(OAS, tmp1, r.Left)
-                                       tmp2 = typecheck(tmp2, ctxStmt)
-                                       n2.Ninit.Append(tmp2)
-                               }
-
-                               if r.List.Len() != 0 && r.List.First().isBlank() {
-                                       r.List.Set(nil)
-                               }
-                               if r.List.Len() != 0 {
-                                       tmp1 := r.List.First()
-                                       if r.Colas() {
-                                               tmp2 := nod(ODCL, tmp1, nil)
-                                               tmp2 = typecheck(tmp2, ctxStmt)
-                                               n2.Ninit.Append(tmp2)
-                                       }
-
-                                       r.List.Set1(o.newTemp(types.Types[TBOOL], false))
-                                       tmp2 := okas(tmp1, r.List.First())
-                                       tmp2 = typecheck(tmp2, ctxStmt)
-                                       n2.Ninit.Append(tmp2)
-                               }
-                               orderBlock(&n2.Ninit, o.free)
-
-                       case OSEND:
-                               if r.Ninit.Len() != 0 {
-                                       dumplist("ninit", r.Ninit)
-                                       Fatalf("ninit on select send")
-                               }
-
-                               // case c <- x
-                               // r->left is c, r->right is x, both are always evaluated.
-                               r.Left = o.expr(r.Left, nil)
-
-                               if !r.Left.IsAutoTmp() {
-                                       r.Left = o.copyExpr(r.Left, r.Left.Type, false)
-                               }
-                               r.Right = o.expr(r.Right, nil)
-                               if !r.Right.IsAutoTmp() {
-                                       r.Right = o.copyExpr(r.Right, r.Right.Type, false)
-                               }
-                       }
-               }
-               // Now that we have accumulated all the temporaries, clean them.
-               // Also insert any ninit queued during the previous loop.
-               // (The temporary cleaning must follow that ninit work.)
-               for _, n3 := range n.List.Slice() {
-                       orderBlock(&n3.Nbody, o.free)
-                       n3.Nbody.Prepend(o.cleanTempNoPop(t)...)
-
-                       // TODO(mdempsky): Is this actually necessary?
-                       // walkselect appears to walk Ninit.
-                       n3.Nbody.Prepend(n3.Ninit.Slice()...)
-                       n3.Ninit.Set(nil)
-               }
-
-               o.out = append(o.out, n)
-               o.popTemp(t)
-
-       // Special: value being sent is passed as a pointer; make it addressable.
-       case OSEND:
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               if instrumenting {
-                       // Force copying to the stack so that (chan T)(nil) <- x
-                       // is still instrumented as a read of x.
-                       n.Right = o.copyExpr(n.Right, n.Right.Type, false)
-               } else {
-                       n.Right = o.addrTemp(n.Right)
-               }
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
-       // TODO(rsc): Clean temporaries more aggressively.
-       // Note that because walkswitch will rewrite some of the
-       // switch into a binary search, this is not as easy as it looks.
-       // (If we ran that code here we could invoke order.stmt on
-       // the if-else chain instead.)
-       // For now just clean all the temporaries at the end.
-       // In practice that's fine.
-       case OSWITCH:
-               if Debug_libfuzzer != 0 && !hasDefaultCase(n) {
-                       // Add empty "default:" case for instrumentation.
-                       n.List.Append(nod(OCASE, nil, nil))
-               }
-
-               t := o.markTemp()
-               n.Left = o.expr(n.Left, nil)
-               for _, ncas := range n.List.Slice() {
-                       if ncas.Op != OCASE {
-                               Fatalf("order switch case %v", ncas.Op)
-                       }
-                       o.exprListInPlace(ncas.List)
-                       orderBlock(&ncas.Nbody, o.free)
-               }
-
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-       }
-
-       lineno = lno
-}
-
-func hasDefaultCase(n *Node) bool {
-       for _, ncas := range n.List.Slice() {
-               if ncas.Op != OCASE {
-                       Fatalf("expected case, found %v", ncas.Op)
-               }
-               if ncas.List.Len() == 0 {
-                       return true
-               }
-       }
-       return false
-}
-
-// exprList orders the expression list l into o.
-func (o *Order) exprList(l Nodes) {
-       s := l.Slice()
-       for i := range s {
-               s[i] = o.expr(s[i], nil)
-       }
-}
-
-// exprListInPlace orders the expression list l but saves
-// the side effects on the individual expression ninit lists.
-func (o *Order) exprListInPlace(l Nodes) {
-       s := l.Slice()
-       for i := range s {
-               s[i] = o.exprInPlace(s[i])
-       }
-}
-
-// prealloc[x] records the allocation to use for x.
-var prealloc = map[*Node]*Node{}
-
-// expr orders a single expression, appending side
-// effects to o.out as needed.
-// If this is part of an assignment lhs = *np, lhs is given.
-// Otherwise lhs == nil. (When lhs != nil it may be possible
-// to avoid copying the result of the expression to a temporary.)
-// The result of expr MUST be assigned back to n, e.g.
-//     n.Left = o.expr(n.Left, lhs)
-func (o *Order) expr(n, lhs *Node) *Node {
-       if n == nil {
-               return n
-       }
-
-       lno := setlineno(n)
-       o.init(n)
-
-       switch n.Op {
-       default:
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               o.exprList(n.List)
-               o.exprList(n.Rlist)
-
-       // Addition of strings turns into a function call.
-       // Allocate a temporary to hold the strings.
-       // Fewer than 5 strings use direct runtime helpers.
-       case OADDSTR:
-               o.exprList(n.List)
-
-               if n.List.Len() > 5 {
-                       t := types.NewArray(types.Types[TSTRING], int64(n.List.Len()))
-                       prealloc[n] = o.newTemp(t, false)
-               }
-
-               // Mark string(byteSlice) arguments to reuse byteSlice backing
-               // buffer during conversion. String concatenation does not
-               // memorize the strings for later use, so it is safe.
-               // However, we can do it only if there is at least one non-empty string literal.
-               // Otherwise if all other arguments are empty strings,
-               // concatstrings will return the reference to the temp string
-               // to the caller.
-               hasbyte := false
-
-               haslit := false
-               for _, n1 := range n.List.Slice() {
-                       hasbyte = hasbyte || n1.Op == OBYTES2STR
-                       haslit = haslit || n1.Op == OLITERAL && len(n1.StringVal()) != 0
-               }
-
-               if haslit && hasbyte {
-                       for _, n2 := range n.List.Slice() {
-                               if n2.Op == OBYTES2STR {
-                                       n2.Op = OBYTES2STRTMP
-                               }
-                       }
-               }
-
-       case OINDEXMAP:
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               needCopy := false
-
-               if !n.IndexMapLValue() {
-                       // Enforce that any []byte slices we are not copying
-                       // can not be changed before the map index by forcing
-                       // the map index to happen immediately following the
-                       // conversions. See copyExpr a few lines below.
-                       needCopy = mapKeyReplaceStrConv(n.Right)
-
-                       if instrumenting {
-                               // Race detector needs the copy so it can
-                               // call treecopy on the result.
-                               needCopy = true
-                       }
-               }
-
-               // key must be addressable
-               n.Right = o.mapKeyTemp(n.Left.Type, n.Right)
-               if needCopy {
-                       n = o.copyExpr(n, n.Type, false)
-               }
-
-       // concrete type (not interface) argument might need an addressable
-       // temporary to pass to the runtime conversion routine.
-       case OCONVIFACE:
-               n.Left = o.expr(n.Left, nil)
-               if n.Left.Type.IsInterface() {
-                       break
-               }
-               if _, needsaddr := convFuncName(n.Left.Type, n.Type); needsaddr || isStaticCompositeLiteral(n.Left) {
-                       // Need a temp if we need to pass the address to the conversion function.
-                       // We also process static composite literal node here, making a named static global
-                       // whose address we can put directly in an interface (see OCONVIFACE case in walk).
-                       n.Left = o.addrTemp(n.Left)
-               }
-
-       case OCONVNOP:
-               if n.Type.IsKind(TUNSAFEPTR) && n.Left.Type.IsKind(TUINTPTR) && (n.Left.Op == OCALLFUNC || n.Left.Op == OCALLINTER || n.Left.Op == OCALLMETH) {
-                       // When reordering unsafe.Pointer(f()) into a separate
-                       // statement, the conversion and function call must stay
-                       // together. See golang.org/issue/15329.
-                       o.init(n.Left)
-                       o.call(n.Left)
-                       if lhs == nil || lhs.Op != ONAME || instrumenting {
-                               n = o.copyExpr(n, n.Type, false)
-                       }
-               } else {
-                       n.Left = o.expr(n.Left, nil)
-               }
-
-       case OANDAND, OOROR:
-               // ... = LHS && RHS
-               //
-               // var r bool
-               // r = LHS
-               // if r {       // or !r, for OROR
-               //     r = RHS
-               // }
-               // ... = r
-
-               r := o.newTemp(n.Type, false)
-
-               // Evaluate left-hand side.
-               lhs := o.expr(n.Left, nil)
-               o.out = append(o.out, typecheck(nod(OAS, r, lhs), ctxStmt))
-
-               // Evaluate right-hand side, save generated code.
-               saveout := o.out
-               o.out = nil
-               t := o.markTemp()
-               o.edge()
-               rhs := o.expr(n.Right, nil)
-               o.out = append(o.out, typecheck(nod(OAS, r, rhs), ctxStmt))
-               o.cleanTemp(t)
-               gen := o.out
-               o.out = saveout
-
-               // If left-hand side doesn't cause a short-circuit, issue right-hand side.
-               nif := nod(OIF, r, nil)
-               if n.Op == OANDAND {
-                       nif.Nbody.Set(gen)
-               } else {
-                       nif.Rlist.Set(gen)
-               }
-               o.out = append(o.out, nif)
-               n = r
-
-       case OCALLFUNC,
-               OCALLINTER,
-               OCALLMETH,
-               OCAP,
-               OCOMPLEX,
-               OCOPY,
-               OIMAG,
-               OLEN,
-               OMAKECHAN,
-               OMAKEMAP,
-               OMAKESLICE,
-               OMAKESLICECOPY,
-               ONEW,
-               OREAL,
-               ORECOVER,
-               OSTR2BYTES,
-               OSTR2BYTESTMP,
-               OSTR2RUNES:
-
-               if isRuneCount(n) {
-                       // len([]rune(s)) is rewritten to runtime.countrunes(s) later.
-                       n.Left.Left = o.expr(n.Left.Left, nil)
-               } else {
-                       o.call(n)
-               }
-
-               if lhs == nil || lhs.Op != ONAME || instrumenting {
-                       n = o.copyExpr(n, n.Type, false)
-               }
-
-       case OAPPEND:
-               // Check for append(x, make([]T, y)...) .
-               if isAppendOfMake(n) {
-                       n.List.SetFirst(o.expr(n.List.First(), nil))             // order x
-                       n.List.Second().Left = o.expr(n.List.Second().Left, nil) // order y
-               } else {
-                       o.exprList(n.List)
-               }
-
-               if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.List.First()) {
-                       n = o.copyExpr(n, n.Type, false)
-               }
-
-       case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
-               n.Left = o.expr(n.Left, nil)
-               low, high, max := n.SliceBounds()
-               low = o.expr(low, nil)
-               low = o.cheapExpr(low)
-               high = o.expr(high, nil)
-               high = o.cheapExpr(high)
-               max = o.expr(max, nil)
-               max = o.cheapExpr(max)
-               n.SetSliceBounds(low, high, max)
-               if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.Left) {
-                       n = o.copyExpr(n, n.Type, false)
-               }
-
-       case OCLOSURE:
-               if n.Transient() && n.Func.Closure.Func.Cvars.Len() > 0 {
-                       prealloc[n] = o.newTemp(closureType(n), false)
-               }
-
-       case OSLICELIT, OCALLPART:
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-               o.exprList(n.List)
-               o.exprList(n.Rlist)
-               if n.Transient() {
-                       var t *types.Type
-                       switch n.Op {
-                       case OSLICELIT:
-                               t = types.NewArray(n.Type.Elem(), n.Right.Int64Val())
-                       case OCALLPART:
-                               t = partialCallType(n)
-                       }
-                       prealloc[n] = o.newTemp(t, false)
-               }
-
-       case ODOTTYPE, ODOTTYPE2:
-               n.Left = o.expr(n.Left, nil)
-               if !isdirectiface(n.Type) || instrumenting {
-                       n = o.copyExpr(n, n.Type, true)
-               }
-
-       case ORECV:
-               n.Left = o.expr(n.Left, nil)
-               n = o.copyExpr(n, n.Type, true)
-
-       case OEQ, ONE, OLT, OLE, OGT, OGE:
-               n.Left = o.expr(n.Left, nil)
-               n.Right = o.expr(n.Right, nil)
-
-               t := n.Left.Type
-               switch {
-               case t.IsString():
-                       // Mark string(byteSlice) arguments to reuse byteSlice backing
-                       // buffer during conversion. String comparison does not
-                       // memorize the strings for later use, so it is safe.
-                       if n.Left.Op == OBYTES2STR {
-                               n.Left.Op = OBYTES2STRTMP
-                       }
-                       if n.Right.Op == OBYTES2STR {
-                               n.Right.Op = OBYTES2STRTMP
-                       }
-
-               case t.IsStruct() || t.IsArray():
-                       // for complex comparisons, we need both args to be
-                       // addressable so we can pass them to the runtime.
-                       n.Left = o.addrTemp(n.Left)
-                       n.Right = o.addrTemp(n.Right)
-               }
-       case OMAPLIT:
-               // Order map by converting:
-               //   map[int]int{
-               //     a(): b(),
-               //     c(): d(),
-               //     e(): f(),
-               //   }
-               // to
-               //   m := map[int]int{}
-               //   m[a()] = b()
-               //   m[c()] = d()
-               //   m[e()] = f()
-               // Then order the result.
-               // Without this special case, order would otherwise compute all
-               // the keys and values before storing any of them to the map.
-               // See issue 26552.
-               entries := n.List.Slice()
-               statics := entries[:0]
-               var dynamics []*Node
-               for _, r := range entries {
-                       if r.Op != OKEY {
-                               Fatalf("OMAPLIT entry not OKEY: %v\n", r)
-                       }
-
-                       if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
-                               dynamics = append(dynamics, r)
-                               continue
-                       }
-
-                       // Recursively ordering some static entries can change them to dynamic;
-                       // e.g., OCONVIFACE nodes. See #31777.
-                       r = o.expr(r, nil)
-                       if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
-                               dynamics = append(dynamics, r)
-                               continue
-                       }
-
-                       statics = append(statics, r)
-               }
-               n.List.Set(statics)
-
-               if len(dynamics) == 0 {
-                       break
-               }
-
-               // Emit the creation of the map (with all its static entries).
-               m := o.newTemp(n.Type, false)
-               as := nod(OAS, m, n)
-               typecheck(as, ctxStmt)
-               o.stmt(as)
-               n = m
-
-               // Emit eval+insert of dynamic entries, one at a time.
-               for _, r := range dynamics {
-                       as := nod(OAS, nod(OINDEX, n, r.Left), r.Right)
-                       typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
-                       o.stmt(as)
-               }
-       }
-
-       lineno = lno
-       return n
-}
-
-// okas creates and returns an assignment of val to ok,
-// including an explicit conversion if necessary.
-func okas(ok, val *Node) *Node {
-       if !ok.isBlank() {
-               val = conv(val, ok.Type)
-       }
-       return nod(OAS, ok, val)
-}
-
-// as2 orders OAS2XXXX nodes. It creates temporaries to ensure left-to-right assignment.
-// The caller should order the right-hand side of the assignment before calling order.as2.
-// It rewrites,
-//     a, b, a = ...
-// as
-//     tmp1, tmp2, tmp3 = ...
-//     a, b, a = tmp1, tmp2, tmp3
-// This is necessary to ensure left to right assignment order.
-func (o *Order) as2(n *Node) {
-       tmplist := []*Node{}
-       left := []*Node{}
-       for ni, l := range n.List.Slice() {
-               if !l.isBlank() {
-                       tmp := o.newTemp(l.Type, l.Type.HasPointers())
-                       n.List.SetIndex(ni, tmp)
-                       tmplist = append(tmplist, tmp)
-                       left = append(left, l)
-               }
-       }
-
-       o.out = append(o.out, n)
-
-       as := nod(OAS2, nil, nil)
-       as.List.Set(left)
-       as.Rlist.Set(tmplist)
-       as = typecheck(as, ctxStmt)
-       o.stmt(as)
-}
-
-// okAs2 orders OAS2XXX with ok.
-// Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *Order) okAs2(n *Node) {
-       var tmp1, tmp2 *Node
-       if !n.List.First().isBlank() {
-               typ := n.Right.Type
-               tmp1 = o.newTemp(typ, typ.HasPointers())
-       }
-
-       if !n.List.Second().isBlank() {
-               tmp2 = o.newTemp(types.Types[TBOOL], false)
-       }
-
-       o.out = append(o.out, n)
-
-       if tmp1 != nil {
-               r := nod(OAS, n.List.First(), tmp1)
-               r = typecheck(r, ctxStmt)
-               o.mapAssign(r)
-               n.List.SetFirst(tmp1)
-       }
-       if tmp2 != nil {
-               r := okas(n.List.Second(), tmp2)
-               r = typecheck(r, ctxStmt)
-               o.mapAssign(r)
-               n.List.SetSecond(tmp2)
-       }
-}

diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
deleted file mode 100644 (file)
index 353f4b0..0000000
--- a/src/cmd/compile/internal/gc/pgen.go
+++ /dev/null
@@ -1,798 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/ssa"
-       "cmd/compile/internal/types"
-       "cmd/internal/dwarf"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
-       "cmd/internal/sys"
-       "internal/race"
-       "math/rand"
-       "sort"
-       "sync"
-       "time"
-)
-
-// "Portable" code generation.
-
-var (
-       nBackendWorkers int     // number of concurrent backend workers, set by a compiler flag
-       compilequeue    []*Node // functions waiting to be compiled
-)
-
-func emitptrargsmap(fn *Node) {
-       if fn.funcname() == "_" || fn.Func.Nname.Sym.Linkname != "" {
-               return
-       }
-       lsym := Ctxt.Lookup(fn.Func.lsym.Name + ".args_stackmap")
-
-       nptr := int(fn.Type.ArgWidth() / int64(Widthptr))
-       bv := bvalloc(int32(nptr) * 2)
-       nbitmap := 1
-       if fn.Type.NumResults() > 0 {
-               nbitmap = 2
-       }
-       off := duint32(lsym, 0, uint32(nbitmap))
-       off = duint32(lsym, off, uint32(bv.n))
-
-       if fn.IsMethod() {
-               onebitwalktype1(fn.Type.Recvs(), 0, bv)
-       }
-       if fn.Type.NumParams() > 0 {
-               onebitwalktype1(fn.Type.Params(), 0, bv)
-       }
-       off = dbvec(lsym, off, bv)
-
-       if fn.Type.NumResults() > 0 {
-               onebitwalktype1(fn.Type.Results(), 0, bv)
-               off = dbvec(lsym, off, bv)
-       }
-
-       ggloblsym(lsym, int32(off), obj.RODATA|obj.LOCAL)
-}
-
-// cmpstackvarlt reports whether the stack variable a sorts before b.
-//
-// Sort the list of stack variables. Autos after anything else,
-// within autos, unused after used, within used, things with
-// pointers first, zeroed things first, and then decreasing size.
-// Because autos are laid out in decreasing addresses
-// on the stack, pointers first, zeroed things first and decreasing size
-// really means, in memory, things with pointers needing zeroing at
-// the top of the stack and increasing in size.
-// Non-autos sort on offset.
-func cmpstackvarlt(a, b *Node) bool {
-       if (a.Class() == PAUTO) != (b.Class() == PAUTO) {
-               return b.Class() == PAUTO
-       }
-
-       if a.Class() != PAUTO {
-               return a.Xoffset < b.Xoffset
-       }
-
-       if a.Name.Used() != b.Name.Used() {
-               return a.Name.Used()
-       }
-
-       ap := a.Type.HasPointers()
-       bp := b.Type.HasPointers()
-       if ap != bp {
-               return ap
-       }
-
-       ap = a.Name.Needzero()
-       bp = b.Name.Needzero()
-       if ap != bp {
-               return ap
-       }
-
-       if a.Type.Width != b.Type.Width {
-               return a.Type.Width > b.Type.Width
-       }
-
-       return a.Sym.Name < b.Sym.Name
-}
-
-// byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
-type byStackVar []*Node
-
-func (s byStackVar) Len() int           { return len(s) }
-func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
-func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-func (s *ssafn) AllocFrame(f *ssa.Func) {
-       s.stksize = 0
-       s.stkptrsize = 0
-       fn := s.curfn.Func
-
-       // Mark the PAUTO's unused.
-       for _, ln := range fn.Dcl {
-               if ln.Class() == PAUTO {
-                       ln.Name.SetUsed(false)
-               }
-       }
-
-       for _, l := range f.RegAlloc {
-               if ls, ok := l.(ssa.LocalSlot); ok {
-                       ls.N.(*Node).Name.SetUsed(true)
-               }
-       }
-
-       scratchUsed := false
-       for _, b := range f.Blocks {
-               for _, v := range b.Values {
-                       if n, ok := v.Aux.(*Node); ok {
-                               switch n.Class() {
-                               case PPARAM, PPARAMOUT:
-                                       // Don't modify nodfp; it is a global.
-                                       if n != nodfp {
-                                               n.Name.SetUsed(true)
-                                       }
-                               case PAUTO:
-                                       n.Name.SetUsed(true)
-                               }
-                       }
-                       if !scratchUsed {
-                               scratchUsed = v.Op.UsesScratch()
-                       }
-
-               }
-       }
-
-       if f.Config.NeedsFpScratch && scratchUsed {
-               s.scratchFpMem = tempAt(src.NoXPos, s.curfn, types.Types[TUINT64])
-       }
-
-       sort.Sort(byStackVar(fn.Dcl))
-
-       // Reassign stack offsets of the locals that are used.
-       lastHasPtr := false
-       for i, n := range fn.Dcl {
-               if n.Op != ONAME || n.Class() != PAUTO {
-                       continue
-               }
-               if !n.Name.Used() {
-                       fn.Dcl = fn.Dcl[:i]
-                       break
-               }
-
-               dowidth(n.Type)
-               w := n.Type.Width
-               if w >= thearch.MAXWIDTH || w < 0 {
-                       Fatalf("bad width")
-               }
-               if w == 0 && lastHasPtr {
-                       // Pad between a pointer-containing object and a zero-sized object.
-                       // This prevents a pointer to the zero-sized object from being interpreted
-                       // as a pointer to the pointer-containing object (and causing it
-                       // to be scanned when it shouldn't be). See issue 24993.
-                       w = 1
-               }
-               s.stksize += w
-               s.stksize = Rnd(s.stksize, int64(n.Type.Align))
-               if n.Type.HasPointers() {
-                       s.stkptrsize = s.stksize
-                       lastHasPtr = true
-               } else {
-                       lastHasPtr = false
-               }
-               if thearch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
-                       s.stksize = Rnd(s.stksize, int64(Widthptr))
-               }
-               n.Xoffset = -s.stksize
-       }
-
-       s.stksize = Rnd(s.stksize, int64(Widthreg))
-       s.stkptrsize = Rnd(s.stkptrsize, int64(Widthreg))
-}
-
-func funccompile(fn *Node) {
-       if Curfn != nil {
-               Fatalf("funccompile %v inside %v", fn.Func.Nname.Sym, Curfn.Func.Nname.Sym)
-       }
-
-       if fn.Type == nil {
-               if nerrors == 0 {
-                       Fatalf("funccompile missing type")
-               }
-               return
-       }
-
-       // assign parameter offsets
-       dowidth(fn.Type)
-
-       if fn.Nbody.Len() == 0 {
-               // Initialize ABI wrappers if necessary.
-               fn.Func.initLSym(false)
-               emitptrargsmap(fn)
-               return
-       }
-
-       dclcontext = PAUTO
-       Curfn = fn
-
-       compile(fn)
-
-       Curfn = nil
-       dclcontext = PEXTERN
-}
-
-func compile(fn *Node) {
-       saveerrors()
-
-       order(fn)
-       if nerrors != 0 {
-               return
-       }
-
-       // Set up the function's LSym early to avoid data races with the assemblers.
-       // Do this before walk, as walk needs the LSym to set attributes/relocations
-       // (e.g. in markTypeUsedInInterface).
-       fn.Func.initLSym(true)
-
-       walk(fn)
-       if nerrors != 0 {
-               return
-       }
-       if instrumenting {
-               instrument(fn)
-       }
-
-       // From this point, there should be no uses of Curfn. Enforce that.
-       Curfn = nil
-
-       if fn.funcname() == "_" {
-               // We don't need to generate code for this function, just report errors in its body.
-               // At this point we've generated any errors needed.
-               // (Beyond here we generate only non-spec errors, like "stack frame too large".)
-               // See issue 29870.
-               return
-       }
-
-       // Make sure type syms are declared for all types that might
-       // be types of stack objects. We need to do this here
-       // because symbols must be allocated before the parallel
-       // phase of the compiler.
-       for _, n := range fn.Func.Dcl {
-               switch n.Class() {
-               case PPARAM, PPARAMOUT, PAUTO:
-                       if livenessShouldTrack(n) && n.Name.Addrtaken() {
-                               dtypesym(n.Type)
-                               // Also make sure we allocate a linker symbol
-                               // for the stack object data, for the same reason.
-                               if fn.Func.lsym.Func().StackObjects == nil {
-                                       fn.Func.lsym.Func().StackObjects = Ctxt.Lookup(fn.Func.lsym.Name + ".stkobj")
-                               }
-                       }
-               }
-       }
-
-       if compilenow(fn) {
-               compileSSA(fn, 0)
-       } else {
-               compilequeue = append(compilequeue, fn)
-       }
-}
-
-// compilenow reports whether to compile immediately.
-// If functions are not compiled immediately,
-// they are enqueued in compilequeue,
-// which is drained by compileFunctions.
-func compilenow(fn *Node) bool {
-       // Issue 38068: if this function is a method AND an inline
-       // candidate AND was not inlined (yet), put it onto the compile
-       // queue instead of compiling it immediately. This is in case we
-       // wind up inlining it into a method wrapper that is generated by
-       // compiling a function later on in the xtop list.
-       if fn.IsMethod() && isInlinableButNotInlined(fn) {
-               return false
-       }
-       return nBackendWorkers == 1 && Debug_compilelater == 0
-}
-
-// isInlinableButNotInlined returns true if 'fn' was marked as an
-// inline candidate but then never inlined (presumably because we
-// found no call sites).
-func isInlinableButNotInlined(fn *Node) bool {
-       if fn.Func.Nname.Func.Inl == nil {
-               return false
-       }
-       if fn.Sym == nil {
-               return true
-       }
-       return !fn.Sym.Linksym().WasInlined()
-}
-
-const maxStackSize = 1 << 30
-
-// compileSSA builds an SSA backend function,
-// uses it to generate a plist,
-// and flushes that plist to machine code.
-// worker indicates which of the backend workers is doing the processing.
-func compileSSA(fn *Node, worker int) {
-       f := buildssa(fn, worker)
-       // Note: check arg size to fix issue 25507.
-       if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type.ArgWidth() >= maxStackSize {
-               largeStackFramesMu.Lock()
-               largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type.ArgWidth(), pos: fn.Pos})
-               largeStackFramesMu.Unlock()
-               return
-       }
-       pp := newProgs(fn, worker)
-       defer pp.Free()
-       genssa(f, pp)
-       // Check frame size again.
-       // The check above included only the space needed for local variables.
-       // After genssa, the space needed includes local variables and the callee arg region.
-       // We must do this check prior to calling pp.Flush.
-       // If there are any oversized stack frames,
-       // the assembler may emit inscrutable complaints about invalid instructions.
-       if pp.Text.To.Offset >= maxStackSize {
-               largeStackFramesMu.Lock()
-               locals := f.Frontend().(*ssafn).stksize
-               largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos})
-               largeStackFramesMu.Unlock()
-               return
-       }
-
-       pp.Flush() // assemble, fill in boilerplate, etc.
-       // fieldtrack must be called after pp.Flush. See issue 20014.
-       fieldtrack(pp.Text.From.Sym, fn.Func.FieldTrack)
-}
-
-func init() {
-       if race.Enabled {
-               rand.Seed(time.Now().UnixNano())
-       }
-}
-
-// compileFunctions compiles all functions in compilequeue.
-// It fans out nBackendWorkers to do the work
-// and waits for them to complete.
-func compileFunctions() {
-       if len(compilequeue) != 0 {
-               sizeCalculationDisabled = true // not safe to calculate sizes concurrently
-               if race.Enabled {
-                       // Randomize compilation order to try to shake out races.
-                       tmp := make([]*Node, len(compilequeue))
-                       perm := rand.Perm(len(compilequeue))
-                       for i, v := range perm {
-                               tmp[v] = compilequeue[i]
-                       }
-                       copy(compilequeue, tmp)
-               } else {
-                       // Compile the longest functions first,
-                       // since they're most likely to be the slowest.
-                       // This helps avoid stragglers.
-                       sort.Slice(compilequeue, func(i, j int) bool {
-                               return compilequeue[i].Nbody.Len() > compilequeue[j].Nbody.Len()
-                       })
-               }
-               var wg sync.WaitGroup
-               Ctxt.InParallel = true
-               c := make(chan *Node, nBackendWorkers)
-               for i := 0; i < nBackendWorkers; i++ {
-                       wg.Add(1)
-                       go func(worker int) {
-                               for fn := range c {
-                                       compileSSA(fn, worker)
-                               }
-                               wg.Done()
-                       }(i)
-               }
-               for _, fn := range compilequeue {
-                       c <- fn
-               }
-               close(c)
-               compilequeue = nil
-               wg.Wait()
-               Ctxt.InParallel = false
-               sizeCalculationDisabled = false
-       }
-}
-
-func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
-       fn := curfn.(*Node)
-       if fn.Func.Nname != nil {
-               if expect := fn.Func.Nname.Sym.Linksym(); fnsym != expect {
-                       Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
-               }
-       }
-
-       var apdecls []*Node
-       // Populate decls for fn.
-       for _, n := range fn.Func.Dcl {
-               if n.Op != ONAME { // might be OTYPE or OLITERAL
-                       continue
-               }
-               switch n.Class() {
-               case PAUTO:
-                       if !n.Name.Used() {
-                               // Text == nil -> generating abstract function
-                               if fnsym.Func().Text != nil {
-                                       Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
-                               }
-                               continue
-                       }
-               case PPARAM, PPARAMOUT:
-               default:
-                       continue
-               }
-               apdecls = append(apdecls, n)
-               fnsym.Func().RecordAutoType(ngotype(n).Linksym())
-       }
-
-       decls, dwarfVars := createDwarfVars(fnsym, fn.Func, apdecls)
-
-       // For each type referenced by the functions auto vars but not
-       // already referenced by a dwarf var, attach a dummy relocation to
-       // the function symbol to insure that the type included in DWARF
-       // processing during linking.
-       typesyms := []*obj.LSym{}
-       for t, _ := range fnsym.Func().Autot {
-               typesyms = append(typesyms, t)
-       }
-       sort.Sort(obj.BySymName(typesyms))
-       for _, sym := range typesyms {
-               r := obj.Addrel(infosym)
-               r.Sym = sym
-               r.Type = objabi.R_USETYPE
-       }
-       fnsym.Func().Autot = nil
-
-       var varScopes []ScopeID
-       for _, decl := range decls {
-               pos := declPos(decl)
-               varScopes = append(varScopes, findScope(fn.Func.Marks, pos))
-       }
-
-       scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
-       var inlcalls dwarf.InlCalls
-       if genDwarfInline > 0 {
-               inlcalls = assembleInlines(fnsym, dwarfVars)
-       }
-       return scopes, inlcalls
-}
-
-func declPos(decl *Node) src.XPos {
-       if decl.Name.Defn != nil && (decl.Name.Captured() || decl.Name.Byval()) {
-               // It's not clear which position is correct for captured variables here:
-               // * decl.Pos is the wrong position for captured variables, in the inner
-               //   function, but it is the right position in the outer function.
-               // * decl.Name.Defn is nil for captured variables that were arguments
-               //   on the outer function, however the decl.Pos for those seems to be
-               //   correct.
-               // * decl.Name.Defn is the "wrong" thing for variables declared in the
-               //   header of a type switch, it's their position in the header, rather
-               //   than the position of the case statement. In principle this is the
-               //   right thing, but here we prefer the latter because it makes each
-               //   instance of the header variable local to the lexical block of its
-               //   case statement.
-               // This code is probably wrong for type switch variables that are also
-               // captured.
-               return decl.Name.Defn.Pos
-       }
-       return decl.Pos
-}
-
-// createSimpleVars creates a DWARF entry for every variable declared in the
-// function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []*Node) ([]*Node, []*dwarf.Var, map[*Node]bool) {
-       var vars []*dwarf.Var
-       var decls []*Node
-       selected := make(map[*Node]bool)
-       for _, n := range apDecls {
-               if n.IsAutoTmp() {
-                       continue
-               }
-
-               decls = append(decls, n)
-               vars = append(vars, createSimpleVar(fnsym, n))
-               selected[n] = true
-       }
-       return decls, vars, selected
-}
-
-func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
-       var abbrev int
-       offs := n.Xoffset
-
-       switch n.Class() {
-       case PAUTO:
-               abbrev = dwarf.DW_ABRV_AUTO
-               if Ctxt.FixedFrameSize() == 0 {
-                       offs -= int64(Widthptr)
-               }
-               if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
-                       // There is a word space for FP on ARM64 even if the frame pointer is disabled
-                       offs -= int64(Widthptr)
-               }
-
-       case PPARAM, PPARAMOUT:
-               abbrev = dwarf.DW_ABRV_PARAM
-               offs += Ctxt.FixedFrameSize()
-       default:
-               Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
-       }
-
-       typename := dwarf.InfoPrefix + typesymname(n.Type)
-       delete(fnsym.Func().Autot, ngotype(n).Linksym())
-       inlIndex := 0
-       if genDwarfInline > 1 {
-               if n.Name.InlFormal() || n.Name.InlLocal() {
-                       inlIndex = posInlIndex(n.Pos) + 1
-                       if n.Name.InlFormal() {
-                               abbrev = dwarf.DW_ABRV_PARAM
-                       }
-               }
-       }
-       declpos := Ctxt.InnermostPos(declPos(n))
-       return &dwarf.Var{
-               Name:          n.Sym.Name,
-               IsReturnValue: n.Class() == PPARAMOUT,
-               IsInlFormal:   n.Name.InlFormal(),
-               Abbrev:        abbrev,
-               StackOffset:   int32(offs),
-               Type:          Ctxt.Lookup(typename),
-               DeclFile:      declpos.RelFilename(),
-               DeclLine:      declpos.RelLine(),
-               DeclCol:       declpos.Col(),
-               InlIndex:      int32(inlIndex),
-               ChildIndex:    -1,
-       }
-}
-
-// createComplexVars creates recomposed DWARF vars with location lists,
-// suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *Func) ([]*Node, []*dwarf.Var, map[*Node]bool) {
-       debugInfo := fn.DebugInfo
-
-       // Produce a DWARF variable entry for each user variable.
-       var decls []*Node
-       var vars []*dwarf.Var
-       ssaVars := make(map[*Node]bool)
-
-       for varID, dvar := range debugInfo.Vars {
-               n := dvar.(*Node)
-               ssaVars[n] = true
-               for _, slot := range debugInfo.VarSlots[varID] {
-                       ssaVars[debugInfo.Slots[slot].N.(*Node)] = true
-               }
-
-               if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
-                       decls = append(decls, n)
-                       vars = append(vars, dvar)
-               }
-       }
-
-       return decls, vars, ssaVars
-}
-
-// createDwarfVars process fn, returning a list of DWARF variables and the
-// Nodes they represent.
-func createDwarfVars(fnsym *obj.LSym, fn *Func, apDecls []*Node) ([]*Node, []*dwarf.Var) {
-       // Collect a raw list of DWARF vars.
-       var vars []*dwarf.Var
-       var decls []*Node
-       var selected map[*Node]bool
-       if Ctxt.Flag_locationlists && Ctxt.Flag_optimize && fn.DebugInfo != nil {
-               decls, vars, selected = createComplexVars(fnsym, fn)
-       } else {
-               decls, vars, selected = createSimpleVars(fnsym, apDecls)
-       }
-
-       dcl := apDecls
-       if fnsym.WasInlined() {
-               dcl = preInliningDcls(fnsym)
-       }
-
-       // If optimization is enabled, the list above will typically be
-       // missing some of the original pre-optimization variables in the
-       // function (they may have been promoted to registers, folded into
-       // constants, dead-coded away, etc).  Input arguments not eligible
-       // for SSA optimization are also missing.  Here we add back in entries
-       // for selected missing vars. Note that the recipe below creates a
-       // conservative location. The idea here is that we want to
-       // communicate to the user that "yes, there is a variable named X
-       // in this function, but no, I don't have enough information to
-       // reliably report its contents."
-       // For non-SSA-able arguments, however, the correct information
-       // is known -- they have a single home on the stack.
-       for _, n := range dcl {
-               if _, found := selected[n]; found {
-                       continue
-               }
-               c := n.Sym.Name[0]
-               if c == '.' || n.Type.IsUntyped() {
-                       continue
-               }
-               if n.Class() == PPARAM && !canSSAType(n.Type) {
-                       // SSA-able args get location lists, and may move in and
-                       // out of registers, so those are handled elsewhere.
-                       // Autos and named output params seem to get handled
-                       // with VARDEF, which creates location lists.
-                       // Args not of SSA-able type are treated here; they
-                       // are homed on the stack in a single place for the
-                       // entire call.
-                       vars = append(vars, createSimpleVar(fnsym, n))
-                       decls = append(decls, n)
-                       continue
-               }
-               typename := dwarf.InfoPrefix + typesymname(n.Type)
-               decls = append(decls, n)
-               abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
-               isReturnValue := (n.Class() == PPARAMOUT)
-               if n.Class() == PPARAM || n.Class() == PPARAMOUT {
-                       abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-               } else if n.Class() == PAUTOHEAP {
-                       // If dcl in question has been promoted to heap, do a bit
-                       // of extra work to recover original class (auto or param);
-                       // see issue 30908. This insures that we get the proper
-                       // signature in the abstract function DIE, but leaves a
-                       // misleading location for the param (we want pointer-to-heap
-                       // and not stack).
-                       // TODO(thanm): generate a better location expression
-                       stackcopy := n.Name.Param.Stackcopy
-                       if stackcopy != nil && (stackcopy.Class() == PPARAM || stackcopy.Class() == PPARAMOUT) {
-                               abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-                               isReturnValue = (stackcopy.Class() == PPARAMOUT)
-                       }
-               }
-               inlIndex := 0
-               if genDwarfInline > 1 {
-                       if n.Name.InlFormal() || n.Name.InlLocal() {
-                               inlIndex = posInlIndex(n.Pos) + 1
-                               if n.Name.InlFormal() {
-                                       abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-                               }
-                       }
-               }
-               declpos := Ctxt.InnermostPos(n.Pos)
-               vars = append(vars, &dwarf.Var{
-                       Name:          n.Sym.Name,
-                       IsReturnValue: isReturnValue,
-                       Abbrev:        abbrev,
-                       StackOffset:   int32(n.Xoffset),
-                       Type:          Ctxt.Lookup(typename),
-                       DeclFile:      declpos.RelFilename(),
-                       DeclLine:      declpos.RelLine(),
-                       DeclCol:       declpos.Col(),
-                       InlIndex:      int32(inlIndex),
-                       ChildIndex:    -1,
-               })
-               // Record go type of to insure that it gets emitted by the linker.
-               fnsym.Func().RecordAutoType(ngotype(n).Linksym())
-       }
-
-       return decls, vars
-}
-
-// Given a function that was inlined at some point during the
-// compilation, return a sorted list of nodes corresponding to the
-// autos/locals in that function prior to inlining. If this is a
-// function that is not local to the package being compiled, then the
-// names of the variables may have been "versioned" to avoid conflicts
-// with local vars; disregard this versioning when sorting.
-func preInliningDcls(fnsym *obj.LSym) []*Node {
-       fn := Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*Node)
-       var rdcl []*Node
-       for _, n := range fn.Func.Inl.Dcl {
-               c := n.Sym.Name[0]
-               // Avoid reporting "_" parameters, since if there are more than
-               // one, it can result in a collision later on, as in #23179.
-               if unversion(n.Sym.Name) == "_" || c == '.' || n.Type.IsUntyped() {
-                       continue
-               }
-               rdcl = append(rdcl, n)
-       }
-       return rdcl
-}
-
-// stackOffset returns the stack location of a LocalSlot relative to the
-// stack pointer, suitable for use in a DWARF location entry. This has nothing
-// to do with its offset in the user variable.
-func stackOffset(slot ssa.LocalSlot) int32 {
-       n := slot.N.(*Node)
-       var base int64
-       switch n.Class() {
-       case PAUTO:
-               if Ctxt.FixedFrameSize() == 0 {
-                       base -= int64(Widthptr)
-               }
-               if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
-                       // There is a word space for FP on ARM64 even if the frame pointer is disabled
-                       base -= int64(Widthptr)
-               }
-       case PPARAM, PPARAMOUT:
-               base += Ctxt.FixedFrameSize()
-       }
-       return int32(base + n.Xoffset + slot.Off)
-}
-
-// createComplexVar builds a single DWARF variable entry and location list.
-func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
-       debug := fn.DebugInfo
-       n := debug.Vars[varID].(*Node)
-
-       var abbrev int
-       switch n.Class() {
-       case PAUTO:
-               abbrev = dwarf.DW_ABRV_AUTO_LOCLIST
-       case PPARAM, PPARAMOUT:
-               abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-       default:
-               return nil
-       }
-
-       gotype := ngotype(n).Linksym()
-       delete(fnsym.Func().Autot, gotype)
-       typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
-       inlIndex := 0
-       if genDwarfInline > 1 {
-               if n.Name.InlFormal() || n.Name.InlLocal() {
-                       inlIndex = posInlIndex(n.Pos) + 1
-                       if n.Name.InlFormal() {
-                               abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-                       }
-               }
-       }
-       declpos := Ctxt.InnermostPos(n.Pos)
-       dvar := &dwarf.Var{
-               Name:          n.Sym.Name,
-               IsReturnValue: n.Class() == PPARAMOUT,
-               IsInlFormal:   n.Name.InlFormal(),
-               Abbrev:        abbrev,
-               Type:          Ctxt.Lookup(typename),
-               // The stack offset is used as a sorting key, so for decomposed
-               // variables just give it the first one. It's not used otherwise.
-               // This won't work well if the first slot hasn't been assigned a stack
-               // location, but it's not obvious how to do better.
-               StackOffset: stackOffset(debug.Slots[debug.VarSlots[varID][0]]),
-               DeclFile:    declpos.RelFilename(),
-               DeclLine:    declpos.RelLine(),
-               DeclCol:     declpos.Col(),
-               InlIndex:    int32(inlIndex),
-               ChildIndex:  -1,
-       }
-       list := debug.LocationLists[varID]
-       if len(list) != 0 {
-               dvar.PutLocationList = func(listSym, startPC dwarf.Sym) {
-                       debug.PutLocationList(list, Ctxt, listSym.(*obj.LSym), startPC.(*obj.LSym))
-               }
-       }
-       return dvar
-}
-
-// fieldtrack adds R_USEFIELD relocations to fnsym to record any
-// struct fields that it used.
-func fieldtrack(fnsym *obj.LSym, tracked map[*types.Sym]struct{}) {
-       if fnsym == nil {
-               return
-       }
-       if objabi.Fieldtrack_enabled == 0 || len(tracked) == 0 {
-               return
-       }
-
-       trackSyms := make([]*types.Sym, 0, len(tracked))
-       for sym := range tracked {
-               trackSyms = append(trackSyms, sym)
-       }
-       sort.Sort(symByName(trackSyms))
-       for _, sym := range trackSyms {
-               r := obj.Addrel(fnsym)
-               r.Sym = sym.Linksym()
-               r.Type = objabi.R_USEFIELD
-       }
-}
-
-type symByName []*types.Sym
-
-func (a symByName) Len() int           { return len(a) }
-func (a symByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
-func (a symByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
deleted file mode 100644 (file)
index b1db298..0000000
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "reflect"
-       "sort"
-       "testing"
-)
-
-func typeWithoutPointers() *types.Type {
-       t := types.New(TSTRUCT)
-       f := &types.Field{Type: types.New(TINT)}
-       t.SetFields([]*types.Field{f})
-       return t
-}
-
-func typeWithPointers() *types.Type {
-       t := types.New(TSTRUCT)
-       f := &types.Field{Type: types.NewPtr(types.New(TINT))}
-       t.SetFields([]*types.Field{f})
-       return t
-}
-
-func markUsed(n *Node) *Node {
-       n.Name.SetUsed(true)
-       return n
-}
-
-func markNeedZero(n *Node) *Node {
-       n.Name.SetNeedzero(true)
-       return n
-}
-
-func nodeWithClass(n Node, c Class) *Node {
-       n.SetClass(c)
-       n.Name = new(Name)
-       return &n
-}
-
-// Test all code paths for cmpstackvarlt.
-func TestCmpstackvar(t *testing.T) {
-       testdata := []struct {
-               a, b *Node
-               lt   bool
-       }{
-               {
-                       nodeWithClass(Node{}, PAUTO),
-                       nodeWithClass(Node{}, PFUNC),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{}, PFUNC),
-                       nodeWithClass(Node{}, PAUTO),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Xoffset: 0}, PFUNC),
-                       nodeWithClass(Node{Xoffset: 10}, PFUNC),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Xoffset: 20}, PFUNC),
-                       nodeWithClass(Node{Xoffset: 10}, PFUNC),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Xoffset: 10}, PFUNC),
-                       nodeWithClass(Node{Xoffset: 10}, PFUNC),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Xoffset: 10}, PPARAM),
-                       nodeWithClass(Node{Xoffset: 20}, PPARAMOUT),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Xoffset: 10}, PPARAMOUT),
-                       nodeWithClass(Node{Xoffset: 20}, PPARAM),
-                       true,
-               },
-               {
-                       markUsed(nodeWithClass(Node{}, PAUTO)),
-                       nodeWithClass(Node{}, PAUTO),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{}, PAUTO),
-                       markUsed(nodeWithClass(Node{}, PAUTO)),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Type: typeWithoutPointers()}, PAUTO),
-                       nodeWithClass(Node{Type: typeWithPointers()}, PAUTO),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Type: typeWithPointers()}, PAUTO),
-                       nodeWithClass(Node{Type: typeWithoutPointers()}, PAUTO),
-                       true,
-               },
-               {
-                       markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
-                       nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
-                       markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}}, PAUTO),
-                       nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}}, PAUTO),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}}, PAUTO),
-                       nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}}, PAUTO),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-                       true,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-                       false,
-               },
-               {
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-                       nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-                       false,
-               },
-       }
-       for _, d := range testdata {
-               got := cmpstackvarlt(d.a, d.b)
-               if got != d.lt {
-                       t.Errorf("want %#v < %#v", d.a, d.b)
-               }
-               // If we expect a < b to be true, check that b < a is false.
-               if d.lt && cmpstackvarlt(d.b, d.a) {
-                       t.Errorf("unexpected %#v < %#v", d.b, d.a)
-               }
-       }
-}
-
-func TestStackvarSort(t *testing.T) {
-       inp := []*Node{
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               markUsed(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-               nodeWithClass(Node{Type: typeWithoutPointers(), Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-               markNeedZero(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-               nodeWithClass(Node{Type: &types.Type{Width: 1}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{Width: 2}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-       }
-       want := []*Node{
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-               markUsed(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-               markNeedZero(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-               nodeWithClass(Node{Type: &types.Type{Width: 2}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{Width: 1}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-               nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-               nodeWithClass(Node{Type: typeWithoutPointers(), Sym: &types.Sym{}}, PAUTO),
-       }
-       sort.Sort(byStackVar(inp))
-       if !reflect.DeepEqual(want, inp) {
-               t.Error("sort failed")
-               for i := range inp {
-                       g := inp[i]
-                       w := want[i]
-                       eq := reflect.DeepEqual(w, g)
-                       if !eq {
-                               t.Log(i, w, g)
-                       }
-               }
-       }
-}

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
deleted file mode 100644 (file)
index 1b4d765..0000000
--- a/src/cmd/compile/internal/gc/range.go
+++ /dev/null
@@ -1,628 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/sys"
-       "unicode/utf8"
-)
-
-// range
-func typecheckrange(n *Node) {
-       // Typechecking order is important here:
-       // 0. first typecheck range expression (slice/map/chan),
-       //      it is evaluated only once and so logically it is not part of the loop.
-       // 1. typecheck produced values,
-       //      this part can declare new vars and so it must be typechecked before body,
-       //      because body can contain a closure that captures the vars.
-       // 2. decldepth++ to denote loop body.
-       // 3. typecheck body.
-       // 4. decldepth--.
-       typecheckrangeExpr(n)
-
-       // second half of dance, the first half being typecheckrangeExpr
-       n.SetTypecheck(1)
-       ls := n.List.Slice()
-       for i1, n1 := range ls {
-               if n1.Typecheck() == 0 {
-                       ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-               }
-       }
-
-       decldepth++
-       typecheckslice(n.Nbody.Slice(), ctxStmt)
-       decldepth--
-}
-
-func typecheckrangeExpr(n *Node) {
-       n.Right = typecheck(n.Right, ctxExpr)
-
-       t := n.Right.Type
-       if t == nil {
-               return
-       }
-       // delicate little dance.  see typecheckas2
-       ls := n.List.Slice()
-       for i1, n1 := range ls {
-               if n1.Name == nil || n1.Name.Defn != n {
-                       ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-               }
-       }
-
-       if t.IsPtr() && t.Elem().IsArray() {
-               t = t.Elem()
-       }
-       n.Type = t
-
-       var t1, t2 *types.Type
-       toomany := false
-       switch t.Etype {
-       default:
-               yyerrorl(n.Pos, "cannot range over %L", n.Right)
-               return
-
-       case TARRAY, TSLICE:
-               t1 = types.Types[TINT]
-               t2 = t.Elem()
-
-       case TMAP:
-               t1 = t.Key()
-               t2 = t.Elem()
-
-       case TCHAN:
-               if !t.ChanDir().CanRecv() {
-                       yyerrorl(n.Pos, "invalid operation: range %v (receive from send-only type %v)", n.Right, n.Right.Type)
-                       return
-               }
-
-               t1 = t.Elem()
-               t2 = nil
-               if n.List.Len() == 2 {
-                       toomany = true
-               }
-
-       case TSTRING:
-               t1 = types.Types[TINT]
-               t2 = types.Runetype
-       }
-
-       if n.List.Len() > 2 || toomany {
-               yyerrorl(n.Pos, "too many variables in range")
-       }
-
-       var v1, v2 *Node
-       if n.List.Len() != 0 {
-               v1 = n.List.First()
-       }
-       if n.List.Len() > 1 {
-               v2 = n.List.Second()
-       }
-
-       // this is not only an optimization but also a requirement in the spec.
-       // "if the second iteration variable is the blank identifier, the range
-       // clause is equivalent to the same clause with only the first variable
-       // present."
-       if v2.isBlank() {
-               if v1 != nil {
-                       n.List.Set1(v1)
-               }
-               v2 = nil
-       }
-
-       if v1 != nil {
-               if v1.Name != nil && v1.Name.Defn == n {
-                       v1.Type = t1
-               } else if v1.Type != nil {
-                       if op, why := assignop(t1, v1.Type); op == OXXX {
-                               yyerrorl(n.Pos, "cannot assign type %v to %L in range%s", t1, v1, why)
-                       }
-               }
-               checkassign(n, v1)
-       }
-
-       if v2 != nil {
-               if v2.Name != nil && v2.Name.Defn == n {
-                       v2.Type = t2
-               } else if v2.Type != nil {
-                       if op, why := assignop(t2, v2.Type); op == OXXX {
-                               yyerrorl(n.Pos, "cannot assign type %v to %L in range%s", t2, v2, why)
-                       }
-               }
-               checkassign(n, v2)
-       }
-}
-
-func cheapComputableIndex(width int64) bool {
-       switch thearch.LinkArch.Family {
-       // MIPS does not have R+R addressing
-       // Arm64 may lack ability to generate this code in our assembler,
-       // but the architecture supports it.
-       case sys.PPC64, sys.S390X:
-               return width == 1
-       case sys.AMD64, sys.I386, sys.ARM64, sys.ARM:
-               switch width {
-               case 1, 2, 4, 8:
-                       return true
-               }
-       }
-       return false
-}
-
-// walkrange transforms various forms of ORANGE into
-// simpler forms.  The result must be assigned back to n.
-// Node n may also be modified in place, and may also be
-// the returned node.
-func walkrange(n *Node) *Node {
-       if isMapClear(n) {
-               m := n.Right
-               lno := setlineno(m)
-               n = mapClear(m)
-               lineno = lno
-               return n
-       }
-
-       // variable name conventions:
-       //      ohv1, hv1, hv2: hidden (old) val 1, 2
-       //      ha, hit: hidden aggregate, iterator
-       //      hn, hp: hidden len, pointer
-       //      hb: hidden bool
-       //      a, v1, v2: not hidden aggregate, val 1, 2
-
-       t := n.Type
-
-       a := n.Right
-       lno := setlineno(a)
-       n.Right = nil
-
-       var v1, v2 *Node
-       l := n.List.Len()
-       if l > 0 {
-               v1 = n.List.First()
-       }
-
-       if l > 1 {
-               v2 = n.List.Second()
-       }
-
-       if v2.isBlank() {
-               v2 = nil
-       }
-
-       if v1.isBlank() && v2 == nil {
-               v1 = nil
-       }
-
-       if v1 == nil && v2 != nil {
-               Fatalf("walkrange: v2 != nil while v1 == nil")
-       }
-
-       // n.List has no meaning anymore, clear it
-       // to avoid erroneous processing by racewalk.
-       n.List.Set(nil)
-
-       var ifGuard *Node
-
-       translatedLoopOp := OFOR
-
-       var body []*Node
-       var init []*Node
-       switch t.Etype {
-       default:
-               Fatalf("walkrange")
-
-       case TARRAY, TSLICE:
-               if arrayClear(n, v1, v2, a) {
-                       lineno = lno
-                       return n
-               }
-
-               // order.stmt arranged for a copy of the array/slice variable if needed.
-               ha := a
-
-               hv1 := temp(types.Types[TINT])
-               hn := temp(types.Types[TINT])
-
-               init = append(init, nod(OAS, hv1, nil))
-               init = append(init, nod(OAS, hn, nod(OLEN, ha, nil)))
-
-               n.Left = nod(OLT, hv1, hn)
-               n.Right = nod(OAS, hv1, nod(OADD, hv1, nodintconst(1)))
-
-               // for range ha { body }
-               if v1 == nil {
-                       break
-               }
-
-               // for v1 := range ha { body }
-               if v2 == nil {
-                       body = []*Node{nod(OAS, v1, hv1)}
-                       break
-               }
-
-               // for v1, v2 := range ha { body }
-               if cheapComputableIndex(n.Type.Elem().Width) {
-                       // v1, v2 = hv1, ha[hv1]
-                       tmp := nod(OINDEX, ha, hv1)
-                       tmp.SetBounded(true)
-                       // Use OAS2 to correctly handle assignments
-                       // of the form "v1, a[v1] := range".
-                       a := nod(OAS2, nil, nil)
-                       a.List.Set2(v1, v2)
-                       a.Rlist.Set2(hv1, tmp)
-                       body = []*Node{a}
-                       break
-               }
-
-               // TODO(austin): OFORUNTIL is a strange beast, but is
-               // necessary for expressing the control flow we need
-               // while also making "break" and "continue" work. It
-               // would be nice to just lower ORANGE during SSA, but
-               // racewalk needs to see many of the operations
-               // involved in ORANGE's implementation. If racewalk
-               // moves into SSA, consider moving ORANGE into SSA and
-               // eliminating OFORUNTIL.
-
-               // TODO(austin): OFORUNTIL inhibits bounds-check
-               // elimination on the index variable (see #20711).
-               // Enhance the prove pass to understand this.
-               ifGuard = nod(OIF, nil, nil)
-               ifGuard.Left = nod(OLT, hv1, hn)
-               translatedLoopOp = OFORUNTIL
-
-               hp := temp(types.NewPtr(n.Type.Elem()))
-               tmp := nod(OINDEX, ha, nodintconst(0))
-               tmp.SetBounded(true)
-               init = append(init, nod(OAS, hp, nod(OADDR, tmp, nil)))
-
-               // Use OAS2 to correctly handle assignments
-               // of the form "v1, a[v1] := range".
-               a := nod(OAS2, nil, nil)
-               a.List.Set2(v1, v2)
-               a.Rlist.Set2(hv1, nod(ODEREF, hp, nil))
-               body = append(body, a)
-
-               // Advance pointer as part of the late increment.
-               //
-               // This runs *after* the condition check, so we know
-               // advancing the pointer is safe and won't go past the
-               // end of the allocation.
-               a = nod(OAS, hp, addptr(hp, t.Elem().Width))
-               a = typecheck(a, ctxStmt)
-               n.List.Set1(a)
-
-       case TMAP:
-               // order.stmt allocated the iterator for us.
-               // we only use a once, so no copy needed.
-               ha := a
-
-               hit := prealloc[n]
-               th := hit.Type
-               n.Left = nil
-               keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
-               elemsym := th.Field(1).Sym // ditto
-
-               fn := syslook("mapiterinit")
-
-               fn = substArgTypes(fn, t.Key(), t.Elem(), th)
-               init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nod(OADDR, hit, nil)))
-               n.Left = nod(ONE, nodSym(ODOT, hit, keysym), nodnil())
-
-               fn = syslook("mapiternext")
-               fn = substArgTypes(fn, th)
-               n.Right = mkcall1(fn, nil, nil, nod(OADDR, hit, nil))
-
-               key := nodSym(ODOT, hit, keysym)
-               key = nod(ODEREF, key, nil)
-               if v1 == nil {
-                       body = nil
-               } else if v2 == nil {
-                       body = []*Node{nod(OAS, v1, key)}
-               } else {
-                       elem := nodSym(ODOT, hit, elemsym)
-                       elem = nod(ODEREF, elem, nil)
-                       a := nod(OAS2, nil, nil)
-                       a.List.Set2(v1, v2)
-                       a.Rlist.Set2(key, elem)
-                       body = []*Node{a}
-               }
-
-       case TCHAN:
-               // order.stmt arranged for a copy of the channel variable.
-               ha := a
-
-               n.Left = nil
-
-               hv1 := temp(t.Elem())
-               hv1.SetTypecheck(1)
-               if t.Elem().HasPointers() {
-                       init = append(init, nod(OAS, hv1, nil))
-               }
-               hb := temp(types.Types[TBOOL])
-
-               n.Left = nod(ONE, hb, nodbool(false))
-               a := nod(OAS2RECV, nil, nil)
-               a.SetTypecheck(1)
-               a.List.Set2(hv1, hb)
-               a.Right = nod(ORECV, ha, nil)
-               n.Left.Ninit.Set1(a)
-               if v1 == nil {
-                       body = nil
-               } else {
-                       body = []*Node{nod(OAS, v1, hv1)}
-               }
-               // Zero hv1. This prevents hv1 from being the sole, inaccessible
-               // reference to an otherwise GC-able value during the next channel receive.
-               // See issue 15281.
-               body = append(body, nod(OAS, hv1, nil))
-
-       case TSTRING:
-               // Transform string range statements like "for v1, v2 = range a" into
-               //
-               // ha := a
-               // for hv1 := 0; hv1 < len(ha); {
-               //   hv1t := hv1
-               //   hv2 := rune(ha[hv1])
-               //   if hv2 < utf8.RuneSelf {
-               //      hv1++
-               //   } else {
-               //      hv2, hv1 = decoderune(ha, hv1)
-               //   }
-               //   v1, v2 = hv1t, hv2
-               //   // original body
-               // }
-
-               // order.stmt arranged for a copy of the string variable.
-               ha := a
-
-               hv1 := temp(types.Types[TINT])
-               hv1t := temp(types.Types[TINT])
-               hv2 := temp(types.Runetype)
-
-               // hv1 := 0
-               init = append(init, nod(OAS, hv1, nil))
-
-               // hv1 < len(ha)
-               n.Left = nod(OLT, hv1, nod(OLEN, ha, nil))
-
-               if v1 != nil {
-                       // hv1t = hv1
-                       body = append(body, nod(OAS, hv1t, hv1))
-               }
-
-               // hv2 := rune(ha[hv1])
-               nind := nod(OINDEX, ha, hv1)
-               nind.SetBounded(true)
-               body = append(body, nod(OAS, hv2, conv(nind, types.Runetype)))
-
-               // if hv2 < utf8.RuneSelf
-               nif := nod(OIF, nil, nil)
-               nif.Left = nod(OLT, hv2, nodintconst(utf8.RuneSelf))
-
-               // hv1++
-               nif.Nbody.Set1(nod(OAS, hv1, nod(OADD, hv1, nodintconst(1))))
-
-               // } else {
-               eif := nod(OAS2, nil, nil)
-               nif.Rlist.Set1(eif)
-
-               // hv2, hv1 = decoderune(ha, hv1)
-               eif.List.Set2(hv2, hv1)
-               fn := syslook("decoderune")
-               eif.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, ha, hv1))
-
-               body = append(body, nif)
-
-               if v1 != nil {
-                       if v2 != nil {
-                               // v1, v2 = hv1t, hv2
-                               a := nod(OAS2, nil, nil)
-                               a.List.Set2(v1, v2)
-                               a.Rlist.Set2(hv1t, hv2)
-                               body = append(body, a)
-                       } else {
-                               // v1 = hv1t
-                               body = append(body, nod(OAS, v1, hv1t))
-                       }
-               }
-       }
-
-       n.Op = translatedLoopOp
-       typecheckslice(init, ctxStmt)
-
-       if ifGuard != nil {
-               ifGuard.Ninit.Append(init...)
-               ifGuard = typecheck(ifGuard, ctxStmt)
-       } else {
-               n.Ninit.Append(init...)
-       }
-
-       typecheckslice(n.Left.Ninit.Slice(), ctxStmt)
-
-       n.Left = typecheck(n.Left, ctxExpr)
-       n.Left = defaultlit(n.Left, nil)
-       n.Right = typecheck(n.Right, ctxStmt)
-       typecheckslice(body, ctxStmt)
-       n.Nbody.Prepend(body...)
-
-       if ifGuard != nil {
-               ifGuard.Nbody.Set1(n)
-               n = ifGuard
-       }
-
-       n = walkstmt(n)
-
-       lineno = lno
-       return n
-}
-
-// isMapClear checks if n is of the form:
-//
-// for k := range m {
-//   delete(m, k)
-// }
-//
-// where == for keys of map m is reflexive.
-func isMapClear(n *Node) bool {
-       if Debug.N != 0 || instrumenting {
-               return false
-       }
-
-       if n.Op != ORANGE || n.Type.Etype != TMAP || n.List.Len() != 1 {
-               return false
-       }
-
-       k := n.List.First()
-       if k == nil || k.isBlank() {
-               return false
-       }
-
-       // Require k to be a new variable name.
-       if k.Name == nil || k.Name.Defn != n {
-               return false
-       }
-
-       if n.Nbody.Len() != 1 {
-               return false
-       }
-
-       stmt := n.Nbody.First() // only stmt in body
-       if stmt == nil || stmt.Op != ODELETE {
-               return false
-       }
-
-       m := n.Right
-       if !samesafeexpr(stmt.List.First(), m) || !samesafeexpr(stmt.List.Second(), k) {
-               return false
-       }
-
-       // Keys where equality is not reflexive can not be deleted from maps.
-       if !isreflexive(m.Type.Key()) {
-               return false
-       }
-
-       return true
-}
-
-// mapClear constructs a call to runtime.mapclear for the map m.
-func mapClear(m *Node) *Node {
-       t := m.Type
-
-       // instantiate mapclear(typ *type, hmap map[any]any)
-       fn := syslook("mapclear")
-       fn = substArgTypes(fn, t.Key(), t.Elem())
-       n := mkcall1(fn, nil, nil, typename(t), m)
-
-       n = typecheck(n, ctxStmt)
-       n = walkstmt(n)
-
-       return n
-}
-
-// Lower n into runtime·memclr if possible, for
-// fast zeroing of slices and arrays (issue 5373).
-// Look for instances of
-//
-// for i := range a {
-//     a[i] = zero
-// }
-//
-// in which the evaluation of a is side-effect-free.
-//
-// Parameters are as in walkrange: "for v1, v2 = range a".
-func arrayClear(n, v1, v2, a *Node) bool {
-       if Debug.N != 0 || instrumenting {
-               return false
-       }
-
-       if v1 == nil || v2 != nil {
-               return false
-       }
-
-       if n.Nbody.Len() != 1 || n.Nbody.First() == nil {
-               return false
-       }
-
-       stmt := n.Nbody.First() // only stmt in body
-       if stmt.Op != OAS || stmt.Left.Op != OINDEX {
-               return false
-       }
-
-       if !samesafeexpr(stmt.Left.Left, a) || !samesafeexpr(stmt.Left.Right, v1) {
-               return false
-       }
-
-       elemsize := n.Type.Elem().Width
-       if elemsize <= 0 || !isZero(stmt.Right) {
-               return false
-       }
-
-       // Convert to
-       // if len(a) != 0 {
-       //      hp = &a[0]
-       //      hn = len(a)*sizeof(elem(a))
-       //      memclr{NoHeap,Has}Pointers(hp, hn)
-       //      i = len(a) - 1
-       // }
-       n.Op = OIF
-
-       n.Nbody.Set(nil)
-       n.Left = nod(ONE, nod(OLEN, a, nil), nodintconst(0))
-
-       // hp = &a[0]
-       hp := temp(types.Types[TUNSAFEPTR])
-
-       tmp := nod(OINDEX, a, nodintconst(0))
-       tmp.SetBounded(true)
-       tmp = nod(OADDR, tmp, nil)
-       tmp = convnop(tmp, types.Types[TUNSAFEPTR])
-       n.Nbody.Append(nod(OAS, hp, tmp))
-
-       // hn = len(a) * sizeof(elem(a))
-       hn := temp(types.Types[TUINTPTR])
-
-       tmp = nod(OLEN, a, nil)
-       tmp = nod(OMUL, tmp, nodintconst(elemsize))
-       tmp = conv(tmp, types.Types[TUINTPTR])
-       n.Nbody.Append(nod(OAS, hn, tmp))
-
-       var fn *Node
-       if a.Type.Elem().HasPointers() {
-               // memclrHasPointers(hp, hn)
-               Curfn.Func.setWBPos(stmt.Pos)
-               fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
-       } else {
-               // memclrNoHeapPointers(hp, hn)
-               fn = mkcall("memclrNoHeapPointers", nil, nil, hp, hn)
-       }
-
-       n.Nbody.Append(fn)
-
-       // i = len(a) - 1
-       v1 = nod(OAS, v1, nod(OSUB, nod(OLEN, a, nil), nodintconst(1)))
-
-       n.Nbody.Append(v1)
-
-       n.Left = typecheck(n.Left, ctxExpr)
-       n.Left = defaultlit(n.Left, nil)
-       typecheckslice(n.Nbody.Slice(), ctxStmt)
-       n = walkstmt(n)
-       return true
-}
-
-// addptr returns (*T)(uintptr(p) + n).
-func addptr(p *Node, n int64) *Node {
-       t := p.Type
-
-       p = nod(OCONVNOP, p, nil)
-       p.Type = types.Types[TUINTPTR]
-
-       p = nod(OADD, p, nodintconst(n))
-
-       p = nod(OCONVNOP, p, nil)
-       p.Type = t
-
-       return p
-}

diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
deleted file mode 100644 (file)
index 97e0424..0000000
--- a/src/cmd/compile/internal/gc/select.go
+++ /dev/null
@@ -1,387 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import "cmd/compile/internal/types"
-
-// select
-func typecheckselect(sel *Node) {
-       var def *Node
-       lno := setlineno(sel)
-       typecheckslice(sel.Ninit.Slice(), ctxStmt)
-       for _, ncase := range sel.List.Slice() {
-               if ncase.Op != OCASE {
-                       setlineno(ncase)
-                       Fatalf("typecheckselect %v", ncase.Op)
-               }
-
-               if ncase.List.Len() == 0 {
-                       // default
-                       if def != nil {
-                               yyerrorl(ncase.Pos, "multiple defaults in select (first at %v)", def.Line())
-                       } else {
-                               def = ncase
-                       }
-               } else if ncase.List.Len() > 1 {
-                       yyerrorl(ncase.Pos, "select cases cannot be lists")
-               } else {
-                       ncase.List.SetFirst(typecheck(ncase.List.First(), ctxStmt))
-                       n := ncase.List.First()
-                       ncase.Left = n
-                       ncase.List.Set(nil)
-                       switch n.Op {
-                       default:
-                               pos := n.Pos
-                               if n.Op == ONAME {
-                                       // We don't have the right position for ONAME nodes (see #15459 and
-                                       // others). Using ncase.Pos for now as it will provide the correct
-                                       // line number (assuming the expression follows the "case" keyword
-                                       // on the same line). This matches the approach before 1.10.
-                                       pos = ncase.Pos
-                               }
-                               yyerrorl(pos, "select case must be receive, send or assign recv")
-
-                       // convert x = <-c into OSELRECV(x, <-c).
-                       // remove implicit conversions; the eventual assignment
-                       // will reintroduce them.
-                       case OAS:
-                               if (n.Right.Op == OCONVNOP || n.Right.Op == OCONVIFACE) && n.Right.Implicit() {
-                                       n.Right = n.Right.Left
-                               }
-
-                               if n.Right.Op != ORECV {
-                                       yyerrorl(n.Pos, "select assignment must have receive on right hand side")
-                                       break
-                               }
-
-                               n.Op = OSELRECV
-
-                               // convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
-                       case OAS2RECV:
-                               if n.Right.Op != ORECV {
-                                       yyerrorl(n.Pos, "select assignment must have receive on right hand side")
-                                       break
-                               }
-
-                               n.Op = OSELRECV2
-                               n.Left = n.List.First()
-                               n.List.Set1(n.List.Second())
-
-                               // convert <-c into OSELRECV(N, <-c)
-                       case ORECV:
-                               n = nodl(n.Pos, OSELRECV, nil, n)
-
-                               n.SetTypecheck(1)
-                               ncase.Left = n
-
-                       case OSEND:
-                               break
-                       }
-               }
-
-               typecheckslice(ncase.Nbody.Slice(), ctxStmt)
-       }
-
-       lineno = lno
-}
-
-func walkselect(sel *Node) {
-       lno := setlineno(sel)
-       if sel.Nbody.Len() != 0 {
-               Fatalf("double walkselect")
-       }
-
-       init := sel.Ninit.Slice()
-       sel.Ninit.Set(nil)
-
-       init = append(init, walkselectcases(&sel.List)...)
-       sel.List.Set(nil)
-
-       sel.Nbody.Set(init)
-       walkstmtlist(sel.Nbody.Slice())
-
-       lineno = lno
-}
-
-func walkselectcases(cases *Nodes) []*Node {
-       ncas := cases.Len()
-       sellineno := lineno
-
-       // optimization: zero-case select
-       if ncas == 0 {
-               return []*Node{mkcall("block", nil, nil)}
-       }
-
-       // optimization: one-case select: single op.
-       if ncas == 1 {
-               cas := cases.First()
-               setlineno(cas)
-               l := cas.Ninit.Slice()
-               if cas.Left != nil { // not default:
-                       n := cas.Left
-                       l = append(l, n.Ninit.Slice()...)
-                       n.Ninit.Set(nil)
-                       switch n.Op {
-                       default:
-                               Fatalf("select %v", n.Op)
-
-                       case OSEND:
-                               // already ok
-
-                       case OSELRECV, OSELRECV2:
-                               if n.Op == OSELRECV || n.List.Len() == 0 {
-                                       if n.Left == nil {
-                                               n = n.Right
-                                       } else {
-                                               n.Op = OAS
-                                       }
-                                       break
-                               }
-
-                               if n.Left == nil {
-                                       nblank = typecheck(nblank, ctxExpr|ctxAssign)
-                                       n.Left = nblank
-                               }
-
-                               n.Op = OAS2
-                               n.List.Prepend(n.Left)
-                               n.Rlist.Set1(n.Right)
-                               n.Right = nil
-                               n.Left = nil
-                               n.SetTypecheck(0)
-                               n = typecheck(n, ctxStmt)
-                       }
-
-                       l = append(l, n)
-               }
-
-               l = append(l, cas.Nbody.Slice()...)
-               l = append(l, nod(OBREAK, nil, nil))
-               return l
-       }
-
-       // convert case value arguments to addresses.
-       // this rewrite is used by both the general code and the next optimization.
-       var dflt *Node
-       for _, cas := range cases.Slice() {
-               setlineno(cas)
-               n := cas.Left
-               if n == nil {
-                       dflt = cas
-                       continue
-               }
-               switch n.Op {
-               case OSEND:
-                       n.Right = nod(OADDR, n.Right, nil)
-                       n.Right = typecheck(n.Right, ctxExpr)
-
-               case OSELRECV, OSELRECV2:
-                       if n.Op == OSELRECV2 && n.List.Len() == 0 {
-                               n.Op = OSELRECV
-                       }
-
-                       if n.Left != nil {
-                               n.Left = nod(OADDR, n.Left, nil)
-                               n.Left = typecheck(n.Left, ctxExpr)
-                       }
-               }
-       }
-
-       // optimization: two-case select but one is default: single non-blocking op.
-       if ncas == 2 && dflt != nil {
-               cas := cases.First()
-               if cas == dflt {
-                       cas = cases.Second()
-               }
-
-               n := cas.Left
-               setlineno(n)
-               r := nod(OIF, nil, nil)
-               r.Ninit.Set(cas.Ninit.Slice())
-               switch n.Op {
-               default:
-                       Fatalf("select %v", n.Op)
-
-               case OSEND:
-                       // if selectnbsend(c, v) { body } else { default body }
-                       ch := n.Left
-                       r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), types.Types[TBOOL], &r.Ninit, ch, n.Right)
-
-               case OSELRECV:
-                       // if selectnbrecv(&v, c) { body } else { default body }
-                       ch := n.Right.Left
-                       elem := n.Left
-                       if elem == nil {
-                               elem = nodnil()
-                       }
-                       r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, ch)
-
-               case OSELRECV2:
-                       // if selectnbrecv2(&v, &received, c) { body } else { default body }
-                       ch := n.Right.Left
-                       elem := n.Left
-                       if elem == nil {
-                               elem = nodnil()
-                       }
-                       receivedp := nod(OADDR, n.List.First(), nil)
-                       receivedp = typecheck(receivedp, ctxExpr)
-                       r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, receivedp, ch)
-               }
-
-               r.Left = typecheck(r.Left, ctxExpr)
-               r.Nbody.Set(cas.Nbody.Slice())
-               r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
-               return []*Node{r, nod(OBREAK, nil, nil)}
-       }
-
-       if dflt != nil {
-               ncas--
-       }
-       casorder := make([]*Node, ncas)
-       nsends, nrecvs := 0, 0
-
-       var init []*Node
-
-       // generate sel-struct
-       lineno = sellineno
-       selv := temp(types.NewArray(scasetype(), int64(ncas)))
-       r := nod(OAS, selv, nil)
-       r = typecheck(r, ctxStmt)
-       init = append(init, r)
-
-       // No initialization for order; runtime.selectgo is responsible for that.
-       order := temp(types.NewArray(types.Types[TUINT16], 2*int64(ncas)))
-
-       var pc0, pcs *Node
-       if flag_race {
-               pcs = temp(types.NewArray(types.Types[TUINTPTR], int64(ncas)))
-               pc0 = typecheck(nod(OADDR, nod(OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
-       } else {
-               pc0 = nodnil()
-       }
-
-       // register cases
-       for _, cas := range cases.Slice() {
-               setlineno(cas)
-
-               init = append(init, cas.Ninit.Slice()...)
-               cas.Ninit.Set(nil)
-
-               n := cas.Left
-               if n == nil { // default:
-                       continue
-               }
-
-               var i int
-               var c, elem *Node
-               switch n.Op {
-               default:
-                       Fatalf("select %v", n.Op)
-               case OSEND:
-                       i = nsends
-                       nsends++
-                       c = n.Left
-                       elem = n.Right
-               case OSELRECV, OSELRECV2:
-                       nrecvs++
-                       i = ncas - nrecvs
-                       c = n.Right.Left
-                       elem = n.Left
-               }
-
-               casorder[i] = cas
-
-               setField := func(f string, val *Node) {
-                       r := nod(OAS, nodSym(ODOT, nod(OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
-                       r = typecheck(r, ctxStmt)
-                       init = append(init, r)
-               }
-
-               c = convnop(c, types.Types[TUNSAFEPTR])
-               setField("c", c)
-               if elem != nil {
-                       elem = convnop(elem, types.Types[TUNSAFEPTR])
-                       setField("elem", elem)
-               }
-
-               // TODO(mdempsky): There should be a cleaner way to
-               // handle this.
-               if flag_race {
-                       r = mkcall("selectsetpc", nil, nil, nod(OADDR, nod(OINDEX, pcs, nodintconst(int64(i))), nil))
-                       init = append(init, r)
-               }
-       }
-       if nsends+nrecvs != ncas {
-               Fatalf("walkselectcases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
-       }
-
-       // run the select
-       lineno = sellineno
-       chosen := temp(types.Types[TINT])
-       recvOK := temp(types.Types[TBOOL])
-       r = nod(OAS2, nil, nil)
-       r.List.Set2(chosen, recvOK)
-       fn := syslook("selectgo")
-       r.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
-       r = typecheck(r, ctxStmt)
-       init = append(init, r)
-
-       // selv and order are no longer alive after selectgo.
-       init = append(init, nod(OVARKILL, selv, nil))
-       init = append(init, nod(OVARKILL, order, nil))
-       if flag_race {
-               init = append(init, nod(OVARKILL, pcs, nil))
-       }
-
-       // dispatch cases
-       dispatch := func(cond, cas *Node) {
-               cond = typecheck(cond, ctxExpr)
-               cond = defaultlit(cond, nil)
-
-               r := nod(OIF, cond, nil)
-
-               if n := cas.Left; n != nil && n.Op == OSELRECV2 {
-                       x := nod(OAS, n.List.First(), recvOK)
-                       x = typecheck(x, ctxStmt)
-                       r.Nbody.Append(x)
-               }
-
-               r.Nbody.AppendNodes(&cas.Nbody)
-               r.Nbody.Append(nod(OBREAK, nil, nil))
-               init = append(init, r)
-       }
-
-       if dflt != nil {
-               setlineno(dflt)
-               dispatch(nod(OLT, chosen, nodintconst(0)), dflt)
-       }
-       for i, cas := range casorder {
-               setlineno(cas)
-               dispatch(nod(OEQ, chosen, nodintconst(int64(i))), cas)
-       }
-
-       return init
-}
-
-// bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
-func bytePtrToIndex(n *Node, i int64) *Node {
-       s := nod(OADDR, nod(OINDEX, n, nodintconst(i)), nil)
-       t := types.NewPtr(types.Types[TUINT8])
-       return convnop(s, t)
-}
-
-var scase *types.Type
-
-// Keep in sync with src/runtime/select.go.
-func scasetype() *types.Type {
-       if scase == nil {
-               scase = tostruct([]*Node{
-                       namedfield("c", types.Types[TUNSAFEPTR]),
-                       namedfield("elem", types.Types[TUNSAFEPTR]),
-               })
-               scase.SetNoalg(true)
-       }
-       return scase
-}

diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
deleted file mode 100644 (file)
index 212fcc0..0000000
--- a/src/cmd/compile/internal/gc/sinit.go
+++ /dev/null
@@ -1,1172 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "fmt"
-)
-
-type InitEntry struct {
-       Xoffset int64 // struct, array only
-       Expr    *Node // bytes of run-time computed expressions
-}
-
-type InitPlan struct {
-       E []InitEntry
-}
-
-// An InitSchedule is used to decompose assignment statements into
-// static and dynamic initialization parts. Static initializations are
-// handled by populating variables' linker symbol data, while dynamic
-// initializations are accumulated to be executed in order.
-type InitSchedule struct {
-       // out is the ordered list of dynamic initialization
-       // statements.
-       out []*Node
-
-       initplans map[*Node]*InitPlan
-       inittemps map[*Node]*Node
-}
-
-func (s *InitSchedule) append(n *Node) {
-       s.out = append(s.out, n)
-}
-
-// staticInit adds an initialization statement n to the schedule.
-func (s *InitSchedule) staticInit(n *Node) {
-       if !s.tryStaticInit(n) {
-               if Debug.P != 0 {
-                       Dump("nonstatic", n)
-               }
-               s.append(n)
-       }
-}
-
-// tryStaticInit attempts to statically execute an initialization
-// statement and reports whether it succeeded.
-func (s *InitSchedule) tryStaticInit(n *Node) bool {
-       // Only worry about simple "l = r" assignments. Multiple
-       // variable/expression OAS2 assignments have already been
-       // replaced by multiple simple OAS assignments, and the other
-       // OAS2* assignments mostly necessitate dynamic execution
-       // anyway.
-       if n.Op != OAS {
-               return false
-       }
-       if n.Left.isBlank() && candiscard(n.Right) {
-               return true
-       }
-       lno := setlineno(n)
-       defer func() { lineno = lno }()
-       return s.staticassign(n.Left, n.Right)
-}
-
-// like staticassign but we are copying an already
-// initialized value r.
-func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
-       if r.Op != ONAME {
-               return false
-       }
-       if r.Class() == PFUNC {
-               pfuncsym(l, r)
-               return true
-       }
-       if r.Class() != PEXTERN || r.Sym.Pkg != localpkg {
-               return false
-       }
-       if r.Name.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
-               return false
-       }
-       if r.Name.Defn.Op != OAS {
-               return false
-       }
-       if r.Type.IsString() { // perhaps overwritten by cmd/link -X (#34675)
-               return false
-       }
-       orig := r
-       r = r.Name.Defn.Right
-
-       for r.Op == OCONVNOP && !types.Identical(r.Type, l.Type) {
-               r = r.Left
-       }
-
-       switch r.Op {
-       case ONAME:
-               if s.staticcopy(l, r) {
-                       return true
-               }
-               // We may have skipped past one or more OCONVNOPs, so
-               // use conv to ensure r is assignable to l (#13263).
-               s.append(nod(OAS, l, conv(r, l.Type)))
-               return true
-
-       case OLITERAL:
-               if isZero(r) {
-                       return true
-               }
-               litsym(l, r, int(l.Type.Width))
-               return true
-
-       case OADDR:
-               if a := r.Left; a.Op == ONAME {
-                       addrsym(l, a)
-                       return true
-               }
-
-       case OPTRLIT:
-               switch r.Left.Op {
-               case OARRAYLIT, OSLICELIT, OSTRUCTLIT, OMAPLIT:
-                       // copy pointer
-                       addrsym(l, s.inittemps[r])
-                       return true
-               }
-
-       case OSLICELIT:
-               // copy slice
-               a := s.inittemps[r]
-               slicesym(l, a, r.Right.Int64Val())
-               return true
-
-       case OARRAYLIT, OSTRUCTLIT:
-               p := s.initplans[r]
-
-               n := l.copy()
-               for i := range p.E {
-                       e := &p.E[i]
-                       n.Xoffset = l.Xoffset + e.Xoffset
-                       n.Type = e.Expr.Type
-                       if e.Expr.Op == OLITERAL {
-                               litsym(n, e.Expr, int(n.Type.Width))
-                               continue
-                       }
-                       ll := n.sepcopy()
-                       if s.staticcopy(ll, e.Expr) {
-                               continue
-                       }
-                       // Requires computation, but we're
-                       // copying someone else's computation.
-                       rr := orig.sepcopy()
-                       rr.Type = ll.Type
-                       rr.Xoffset += e.Xoffset
-                       setlineno(rr)
-                       s.append(nod(OAS, ll, rr))
-               }
-
-               return true
-       }
-
-       return false
-}
-
-func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
-       for r.Op == OCONVNOP {
-               r = r.Left
-       }
-
-       switch r.Op {
-       case ONAME:
-               return s.staticcopy(l, r)
-
-       case OLITERAL:
-               if isZero(r) {
-                       return true
-               }
-               litsym(l, r, int(l.Type.Width))
-               return true
-
-       case OADDR:
-               var nam Node
-               if stataddr(&nam, r.Left) {
-                       addrsym(l, &nam)
-                       return true
-               }
-               fallthrough
-
-       case OPTRLIT:
-               switch r.Left.Op {
-               case OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT:
-                       // Init pointer.
-                       a := staticname(r.Left.Type)
-
-                       s.inittemps[r] = a
-                       addrsym(l, a)
-
-                       // Init underlying literal.
-                       if !s.staticassign(a, r.Left) {
-                               s.append(nod(OAS, a, r.Left))
-                       }
-                       return true
-               }
-               //dump("not static ptrlit", r);
-
-       case OSTR2BYTES:
-               if l.Class() == PEXTERN && r.Left.Op == OLITERAL {
-                       sval := r.Left.StringVal()
-                       slicebytes(l, sval)
-                       return true
-               }
-
-       case OSLICELIT:
-               s.initplan(r)
-               // Init slice.
-               bound := r.Right.Int64Val()
-               ta := types.NewArray(r.Type.Elem(), bound)
-               ta.SetNoalg(true)
-               a := staticname(ta)
-               s.inittemps[r] = a
-               slicesym(l, a, bound)
-               // Fall through to init underlying array.
-               l = a
-               fallthrough
-
-       case OARRAYLIT, OSTRUCTLIT:
-               s.initplan(r)
-
-               p := s.initplans[r]
-               n := l.copy()
-               for i := range p.E {
-                       e := &p.E[i]
-                       n.Xoffset = l.Xoffset + e.Xoffset
-                       n.Type = e.Expr.Type
-                       if e.Expr.Op == OLITERAL {
-                               litsym(n, e.Expr, int(n.Type.Width))
-                               continue
-                       }
-                       setlineno(e.Expr)
-                       a := n.sepcopy()
-                       if !s.staticassign(a, e.Expr) {
-                               s.append(nod(OAS, a, e.Expr))
-                       }
-               }
-
-               return true
-
-       case OMAPLIT:
-               break
-
-       case OCLOSURE:
-               if hasemptycvars(r) {
-                       if Debug_closure > 0 {
-                               Warnl(r.Pos, "closure converted to global")
-                       }
-                       // Closures with no captured variables are globals,
-                       // so the assignment can be done at link time.
-                       pfuncsym(l, r.Func.Closure.Func.Nname)
-                       return true
-               }
-               closuredebugruntimecheck(r)
-
-       case OCONVIFACE:
-               // This logic is mirrored in isStaticCompositeLiteral.
-               // If you change something here, change it there, and vice versa.
-
-               // Determine the underlying concrete type and value we are converting from.
-               val := r
-               for val.Op == OCONVIFACE {
-                       val = val.Left
-               }
-               if val.Type.IsInterface() {
-                       // val is an interface type.
-                       // If val is nil, we can statically initialize l;
-                       // both words are zero and so there no work to do, so report success.
-                       // If val is non-nil, we have no concrete type to record,
-                       // and we won't be able to statically initialize its value, so report failure.
-                       return Isconst(val, CTNIL)
-               }
-
-               markTypeUsedInInterface(val.Type, l.Sym.Linksym())
-
-               var itab *Node
-               if l.Type.IsEmptyInterface() {
-                       itab = typename(val.Type)
-               } else {
-                       itab = itabname(val.Type, l.Type)
-               }
-
-               // Create a copy of l to modify while we emit data.
-               n := l.copy()
-
-               // Emit itab, advance offset.
-               addrsym(n, itab.Left) // itab is an OADDR node
-               n.Xoffset += int64(Widthptr)
-
-               // Emit data.
-               if isdirectiface(val.Type) {
-                       if Isconst(val, CTNIL) {
-                               // Nil is zero, nothing to do.
-                               return true
-                       }
-                       // Copy val directly into n.
-                       n.Type = val.Type
-                       setlineno(val)
-                       a := n.sepcopy()
-                       if !s.staticassign(a, val) {
-                               s.append(nod(OAS, a, val))
-                       }
-               } else {
-                       // Construct temp to hold val, write pointer to temp into n.
-                       a := staticname(val.Type)
-                       s.inittemps[val] = a
-                       if !s.staticassign(a, val) {
-                               s.append(nod(OAS, a, val))
-                       }
-                       addrsym(n, a)
-               }
-
-               return true
-       }
-
-       //dump("not static", r);
-       return false
-}
-
-// initContext is the context in which static data is populated.
-// It is either in an init function or in any other function.
-// Static data populated in an init function will be written either
-// zero times (as a readonly, static data symbol) or
-// one time (during init function execution).
-// Either way, there is no opportunity for races or further modification,
-// so the data can be written to a (possibly readonly) data symbol.
-// Static data populated in any other function needs to be local to
-// that function to allow multiple instances of that function
-// to execute concurrently without clobbering each others' data.
-type initContext uint8
-
-const (
-       inInitFunction initContext = iota
-       inNonInitFunction
-)
-
-func (c initContext) String() string {
-       if c == inInitFunction {
-               return "inInitFunction"
-       }
-       return "inNonInitFunction"
-}
-
-// from here down is the walk analysis
-// of composite literals.
-// most of the work is to generate
-// data statements for the constant
-// part of the composite literal.
-
-var statuniqgen int // name generator for static temps
-
-// staticname returns a name backed by a (writable) static data symbol.
-// Use readonlystaticname for read-only node.
-func staticname(t *types.Type) *Node {
-       // Don't use lookupN; it interns the resulting string, but these are all unique.
-       n := newname(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
-       statuniqgen++
-       addvar(n, t, PEXTERN)
-       n.Sym.Linksym().Set(obj.AttrLocal, true)
-       return n
-}
-
-// readonlystaticname returns a name backed by a (writable) static data symbol.
-func readonlystaticname(t *types.Type) *Node {
-       n := staticname(t)
-       n.MarkReadonly()
-       n.Sym.Linksym().Set(obj.AttrContentAddressable, true)
-       return n
-}
-
-func (n *Node) isSimpleName() bool {
-       return n.Op == ONAME && n.Class() != PAUTOHEAP && n.Class() != PEXTERN
-}
-
-func litas(l *Node, r *Node, init *Nodes) {
-       a := nod(OAS, l, r)
-       a = typecheck(a, ctxStmt)
-       a = walkexpr(a, init)
-       init.Append(a)
-}
-
-// initGenType is a bitmap indicating the types of generation that will occur for a static value.
-type initGenType uint8
-
-const (
-       initDynamic initGenType = 1 << iota // contains some dynamic values, for which init code will be generated
-       initConst                           // contains some constant values, which may be written into data symbols
-)
-
-// getdyn calculates the initGenType for n.
-// If top is false, getdyn is recursing.
-func getdyn(n *Node, top bool) initGenType {
-       switch n.Op {
-       default:
-               if n.isGoConst() {
-                       return initConst
-               }
-               return initDynamic
-
-       case OSLICELIT:
-               if !top {
-                       return initDynamic
-               }
-               if n.Right.Int64Val()/4 > int64(n.List.Len()) {
-                       // <25% of entries have explicit values.
-                       // Very rough estimation, it takes 4 bytes of instructions
-                       // to initialize 1 byte of result. So don't use a static
-                       // initializer if the dynamic initialization code would be
-                       // smaller than the static value.
-                       // See issue 23780.
-                       return initDynamic
-               }
-
-       case OARRAYLIT, OSTRUCTLIT:
-       }
-
-       var mode initGenType
-       for _, n1 := range n.List.Slice() {
-               switch n1.Op {
-               case OKEY:
-                       n1 = n1.Right
-               case OSTRUCTKEY:
-                       n1 = n1.Left
-               }
-               mode |= getdyn(n1, false)
-               if mode == initDynamic|initConst {
-                       break
-               }
-       }
-       return mode
-}
-
-// isStaticCompositeLiteral reports whether n is a compile-time constant.
-func isStaticCompositeLiteral(n *Node) bool {
-       switch n.Op {
-       case OSLICELIT:
-               return false
-       case OARRAYLIT:
-               for _, r := range n.List.Slice() {
-                       if r.Op == OKEY {
-                               r = r.Right
-                       }
-                       if !isStaticCompositeLiteral(r) {
-                               return false
-                       }
-               }
-               return true
-       case OSTRUCTLIT:
-               for _, r := range n.List.Slice() {
-                       if r.Op != OSTRUCTKEY {
-                               Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
-                       }
-                       if !isStaticCompositeLiteral(r.Left) {
-                               return false
-                       }
-               }
-               return true
-       case OLITERAL:
-               return true
-       case OCONVIFACE:
-               // See staticassign's OCONVIFACE case for comments.
-               val := n
-               for val.Op == OCONVIFACE {
-                       val = val.Left
-               }
-               if val.Type.IsInterface() {
-                       return Isconst(val, CTNIL)
-               }
-               if isdirectiface(val.Type) && Isconst(val, CTNIL) {
-                       return true
-               }
-               return isStaticCompositeLiteral(val)
-       }
-       return false
-}
-
-// initKind is a kind of static initialization: static, dynamic, or local.
-// Static initialization represents literals and
-// literal components of composite literals.
-// Dynamic initialization represents non-literals and
-// non-literal components of composite literals.
-// LocalCode initialization represents initialization
-// that occurs purely in generated code local to the function of use.
-// Initialization code is sometimes generated in passes,
-// first static then dynamic.
-type initKind uint8
-
-const (
-       initKindStatic initKind = iota + 1
-       initKindDynamic
-       initKindLocalCode
-)
-
-// fixedlit handles struct, array, and slice literals.
-// TODO: expand documentation.
-func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes) {
-       isBlank := var_ == nblank
-       var splitnode func(*Node) (a *Node, value *Node)
-       switch n.Op {
-       case OARRAYLIT, OSLICELIT:
-               var k int64
-               splitnode = func(r *Node) (*Node, *Node) {
-                       if r.Op == OKEY {
-                               k = indexconst(r.Left)
-                               if k < 0 {
-                                       Fatalf("fixedlit: invalid index %v", r.Left)
-                               }
-                               r = r.Right
-                       }
-                       a := nod(OINDEX, var_, nodintconst(k))
-                       k++
-                       if isBlank {
-                               a = nblank
-                       }
-                       return a, r
-               }
-       case OSTRUCTLIT:
-               splitnode = func(r *Node) (*Node, *Node) {
-                       if r.Op != OSTRUCTKEY {
-                               Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
-                       }
-                       if r.Sym.IsBlank() || isBlank {
-                               return nblank, r.Left
-                       }
-                       setlineno(r)
-                       return nodSym(ODOT, var_, r.Sym), r.Left
-               }
-       default:
-               Fatalf("fixedlit bad op: %v", n.Op)
-       }
-
-       for _, r := range n.List.Slice() {
-               a, value := splitnode(r)
-               if a == nblank && candiscard(value) {
-                       continue
-               }
-
-               switch value.Op {
-               case OSLICELIT:
-                       if (kind == initKindStatic && ctxt == inNonInitFunction) || (kind == initKindDynamic && ctxt == inInitFunction) {
-                               slicelit(ctxt, value, a, init)
-                               continue
-                       }
-
-               case OARRAYLIT, OSTRUCTLIT:
-                       fixedlit(ctxt, kind, value, a, init)
-                       continue
-               }
-
-               islit := value.isGoConst()
-               if (kind == initKindStatic && !islit) || (kind == initKindDynamic && islit) {
-                       continue
-               }
-
-               // build list of assignments: var[index] = expr
-               setlineno(a)
-               a = nod(OAS, a, value)
-               a = typecheck(a, ctxStmt)
-               switch kind {
-               case initKindStatic:
-                       genAsStatic(a)
-               case initKindDynamic, initKindLocalCode:
-                       a = orderStmtInPlace(a, map[string][]*Node{})
-                       a = walkstmt(a)
-                       init.Append(a)
-               default:
-                       Fatalf("fixedlit: bad kind %d", kind)
-               }
-
-       }
-}
-
-func isSmallSliceLit(n *Node) bool {
-       if n.Op != OSLICELIT {
-               return false
-       }
-
-       r := n.Right
-
-       return smallintconst(r) && (n.Type.Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type.Elem().Width)
-}
-
-func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
-       // make an array type corresponding the number of elements we have
-       t := types.NewArray(n.Type.Elem(), n.Right.Int64Val())
-       dowidth(t)
-
-       if ctxt == inNonInitFunction {
-               // put everything into static array
-               vstat := staticname(t)
-
-               fixedlit(ctxt, initKindStatic, n, vstat, init)
-               fixedlit(ctxt, initKindDynamic, n, vstat, init)
-
-               // copy static to slice
-               var_ = typecheck(var_, ctxExpr|ctxAssign)
-               var nam Node
-               if !stataddr(&nam, var_) || nam.Class() != PEXTERN {
-                       Fatalf("slicelit: %v", var_)
-               }
-               slicesym(&nam, vstat, t.NumElem())
-               return
-       }
-
-       // recipe for var = []t{...}
-       // 1. make a static array
-       //      var vstat [...]t
-       // 2. assign (data statements) the constant part
-       //      vstat = constpart{}
-       // 3. make an auto pointer to array and allocate heap to it
-       //      var vauto *[...]t = new([...]t)
-       // 4. copy the static array to the auto array
-       //      *vauto = vstat
-       // 5. for each dynamic part assign to the array
-       //      vauto[i] = dynamic part
-       // 6. assign slice of allocated heap to var
-       //      var = vauto[:]
-       //
-       // an optimization is done if there is no constant part
-       //      3. var vauto *[...]t = new([...]t)
-       //      5. vauto[i] = dynamic part
-       //      6. var = vauto[:]
-
-       // if the literal contains constants,
-       // make static initialized array (1),(2)
-       var vstat *Node
-
-       mode := getdyn(n, true)
-       if mode&initConst != 0 && !isSmallSliceLit(n) {
-               if ctxt == inInitFunction {
-                       vstat = readonlystaticname(t)
-               } else {
-                       vstat = staticname(t)
-               }
-               fixedlit(ctxt, initKindStatic, n, vstat, init)
-       }
-
-       // make new auto *array (3 declare)
-       vauto := temp(types.NewPtr(t))
-
-       // set auto to point at new temp or heap (3 assign)
-       var a *Node
-       if x := prealloc[n]; x != nil {
-               // temp allocated during order.go for dddarg
-               if !types.Identical(t, x.Type) {
-                       panic("dotdotdot base type does not match order's assigned type")
-               }
-
-               if vstat == nil {
-                       a = nod(OAS, x, nil)
-                       a = typecheck(a, ctxStmt)
-                       init.Append(a) // zero new temp
-               } else {
-                       // Declare that we're about to initialize all of x.
-                       // (Which happens at the *vauto = vstat below.)
-                       init.Append(nod(OVARDEF, x, nil))
-               }
-
-               a = nod(OADDR, x, nil)
-       } else if n.Esc == EscNone {
-               a = temp(t)
-               if vstat == nil {
-                       a = nod(OAS, temp(t), nil)
-                       a = typecheck(a, ctxStmt)
-                       init.Append(a) // zero new temp
-                       a = a.Left
-               } else {
-                       init.Append(nod(OVARDEF, a, nil))
-               }
-
-               a = nod(OADDR, a, nil)
-       } else {
-               a = nod(ONEW, nil, nil)
-               a.List.Set1(typenod(t))
-       }
-
-       a = nod(OAS, vauto, a)
-       a = typecheck(a, ctxStmt)
-       a = walkexpr(a, init)
-       init.Append(a)
-
-       if vstat != nil {
-               // copy static to heap (4)
-               a = nod(ODEREF, vauto, nil)
-
-               a = nod(OAS, a, vstat)
-               a = typecheck(a, ctxStmt)
-               a = walkexpr(a, init)
-               init.Append(a)
-       }
-
-       // put dynamics into array (5)
-       var index int64
-       for _, value := range n.List.Slice() {
-               if value.Op == OKEY {
-                       index = indexconst(value.Left)
-                       if index < 0 {
-                               Fatalf("slicelit: invalid index %v", value.Left)
-                       }
-                       value = value.Right
-               }
-               a := nod(OINDEX, vauto, nodintconst(index))
-               a.SetBounded(true)
-               index++
-
-               // TODO need to check bounds?
-
-               switch value.Op {
-               case OSLICELIT:
-                       break
-
-               case OARRAYLIT, OSTRUCTLIT:
-                       k := initKindDynamic
-                       if vstat == nil {
-                               // Generate both static and dynamic initializations.
-                               // See issue #31987.
-                               k = initKindLocalCode
-                       }
-                       fixedlit(ctxt, k, value, a, init)
-                       continue
-               }
-
-               if vstat != nil && value.isGoConst() { // already set by copy from static value
-                       continue
-               }
-
-               // build list of vauto[c] = expr
-               setlineno(value)
-               a = nod(OAS, a, value)
-
-               a = typecheck(a, ctxStmt)
-               a = orderStmtInPlace(a, map[string][]*Node{})
-               a = walkstmt(a)
-               init.Append(a)
-       }
-
-       // make slice out of heap (6)
-       a = nod(OAS, var_, nod(OSLICE, vauto, nil))
-
-       a = typecheck(a, ctxStmt)
-       a = orderStmtInPlace(a, map[string][]*Node{})
-       a = walkstmt(a)
-       init.Append(a)
-}
-
-func maplit(n *Node, m *Node, init *Nodes) {
-       // make the map var
-       a := nod(OMAKE, nil, nil)
-       a.Esc = n.Esc
-       a.List.Set2(typenod(n.Type), nodintconst(int64(n.List.Len())))
-       litas(m, a, init)
-
-       entries := n.List.Slice()
-
-       // The order pass already removed any dynamic (runtime-computed) entries.
-       // All remaining entries are static. Double-check that.
-       for _, r := range entries {
-               if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
-                       Fatalf("maplit: entry is not a literal: %v", r)
-               }
-       }
-
-       if len(entries) > 25 {
-               // For a large number of entries, put them in an array and loop.
-
-               // build types [count]Tindex and [count]Tvalue
-               tk := types.NewArray(n.Type.Key(), int64(len(entries)))
-               te := types.NewArray(n.Type.Elem(), int64(len(entries)))
-
-               tk.SetNoalg(true)
-               te.SetNoalg(true)
-
-               dowidth(tk)
-               dowidth(te)
-
-               // make and initialize static arrays
-               vstatk := readonlystaticname(tk)
-               vstate := readonlystaticname(te)
-
-               datak := nod(OARRAYLIT, nil, nil)
-               datae := nod(OARRAYLIT, nil, nil)
-               for _, r := range entries {
-                       datak.List.Append(r.Left)
-                       datae.List.Append(r.Right)
-               }
-               fixedlit(inInitFunction, initKindStatic, datak, vstatk, init)
-               fixedlit(inInitFunction, initKindStatic, datae, vstate, init)
-
-               // loop adding structure elements to map
-               // for i = 0; i < len(vstatk); i++ {
-               //      map[vstatk[i]] = vstate[i]
-               // }
-               i := temp(types.Types[TINT])
-               rhs := nod(OINDEX, vstate, i)
-               rhs.SetBounded(true)
-
-               kidx := nod(OINDEX, vstatk, i)
-               kidx.SetBounded(true)
-               lhs := nod(OINDEX, m, kidx)
-
-               zero := nod(OAS, i, nodintconst(0))
-               cond := nod(OLT, i, nodintconst(tk.NumElem()))
-               incr := nod(OAS, i, nod(OADD, i, nodintconst(1)))
-               body := nod(OAS, lhs, rhs)
-
-               loop := nod(OFOR, cond, incr)
-               loop.Nbody.Set1(body)
-               loop.Ninit.Set1(zero)
-
-               loop = typecheck(loop, ctxStmt)
-               loop = walkstmt(loop)
-               init.Append(loop)
-               return
-       }
-       // For a small number of entries, just add them directly.
-
-       // Build list of var[c] = expr.
-       // Use temporaries so that mapassign1 can have addressable key, elem.
-       // TODO(josharian): avoid map key temporaries for mapfast_* assignments with literal keys.
-       tmpkey := temp(m.Type.Key())
-       tmpelem := temp(m.Type.Elem())
-
-       for _, r := range entries {
-               index, elem := r.Left, r.Right
-
-               setlineno(index)
-               a := nod(OAS, tmpkey, index)
-               a = typecheck(a, ctxStmt)
-               a = walkstmt(a)
-               init.Append(a)
-
-               setlineno(elem)
-               a = nod(OAS, tmpelem, elem)
-               a = typecheck(a, ctxStmt)
-               a = walkstmt(a)
-               init.Append(a)
-
-               setlineno(tmpelem)
-               a = nod(OAS, nod(OINDEX, m, tmpkey), tmpelem)
-               a = typecheck(a, ctxStmt)
-               a = walkstmt(a)
-               init.Append(a)
-       }
-
-       a = nod(OVARKILL, tmpkey, nil)
-       a = typecheck(a, ctxStmt)
-       init.Append(a)
-       a = nod(OVARKILL, tmpelem, nil)
-       a = typecheck(a, ctxStmt)
-       init.Append(a)
-}
-
-func anylit(n *Node, var_ *Node, init *Nodes) {
-       t := n.Type
-       switch n.Op {
-       default:
-               Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
-
-       case ONAME:
-               a := nod(OAS, var_, n)
-               a = typecheck(a, ctxStmt)
-               init.Append(a)
-
-       case OPTRLIT:
-               if !t.IsPtr() {
-                       Fatalf("anylit: not ptr")
-               }
-
-               var r *Node
-               if n.Right != nil {
-                       // n.Right is stack temporary used as backing store.
-                       init.Append(nod(OAS, n.Right, nil)) // zero backing store, just in case (#18410)
-                       r = nod(OADDR, n.Right, nil)
-                       r = typecheck(r, ctxExpr)
-               } else {
-                       r = nod(ONEW, nil, nil)
-                       r.SetTypecheck(1)
-                       r.Type = t
-                       r.Esc = n.Esc
-               }
-
-               r = walkexpr(r, init)
-               a := nod(OAS, var_, r)
-
-               a = typecheck(a, ctxStmt)
-               init.Append(a)
-
-               var_ = nod(ODEREF, var_, nil)
-               var_ = typecheck(var_, ctxExpr|ctxAssign)
-               anylit(n.Left, var_, init)
-
-       case OSTRUCTLIT, OARRAYLIT:
-               if !t.IsStruct() && !t.IsArray() {
-                       Fatalf("anylit: not struct/array")
-               }
-
-               if var_.isSimpleName() && n.List.Len() > 4 {
-                       // lay out static data
-                       vstat := readonlystaticname(t)
-
-                       ctxt := inInitFunction
-                       if n.Op == OARRAYLIT {
-                               ctxt = inNonInitFunction
-                       }
-                       fixedlit(ctxt, initKindStatic, n, vstat, init)
-
-                       // copy static to var
-                       a := nod(OAS, var_, vstat)
-
-                       a = typecheck(a, ctxStmt)
-                       a = walkexpr(a, init)
-                       init.Append(a)
-
-                       // add expressions to automatic
-                       fixedlit(inInitFunction, initKindDynamic, n, var_, init)
-                       break
-               }
-
-               var components int64
-               if n.Op == OARRAYLIT {
-                       components = t.NumElem()
-               } else {
-                       components = int64(t.NumFields())
-               }
-               // initialization of an array or struct with unspecified components (missing fields or arrays)
-               if var_.isSimpleName() || int64(n.List.Len()) < components {
-                       a := nod(OAS, var_, nil)
-                       a = typecheck(a, ctxStmt)
-                       a = walkexpr(a, init)
-                       init.Append(a)
-               }
-
-               fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
-
-       case OSLICELIT:
-               slicelit(inInitFunction, n, var_, init)
-
-       case OMAPLIT:
-               if !t.IsMap() {
-                       Fatalf("anylit: not map")
-               }
-               maplit(n, var_, init)
-       }
-}
-
-func oaslit(n *Node, init *Nodes) bool {
-       if n.Left == nil || n.Right == nil {
-               // not a special composite literal assignment
-               return false
-       }
-       if n.Left.Type == nil || n.Right.Type == nil {
-               // not a special composite literal assignment
-               return false
-       }
-       if !n.Left.isSimpleName() {
-               // not a special composite literal assignment
-               return false
-       }
-       if !types.Identical(n.Left.Type, n.Right.Type) {
-               // not a special composite literal assignment
-               return false
-       }
-
-       switch n.Right.Op {
-       default:
-               // not a special composite literal assignment
-               return false
-
-       case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
-               if vmatch1(n.Left, n.Right) {
-                       // not a special composite literal assignment
-                       return false
-               }
-               anylit(n.Right, n.Left, init)
-       }
-
-       n.Op = OEMPTY
-       n.Right = nil
-       return true
-}
-
-func getlit(lit *Node) int {
-       if smallintconst(lit) {
-               return int(lit.Int64Val())
-       }
-       return -1
-}
-
-// stataddr sets nam to the static address of n and reports whether it succeeded.
-func stataddr(nam *Node, n *Node) bool {
-       if n == nil {
-               return false
-       }
-
-       switch n.Op {
-       case ONAME:
-               *nam = *n
-               return true
-
-       case ODOT:
-               if !stataddr(nam, n.Left) {
-                       break
-               }
-               nam.Xoffset += n.Xoffset
-               nam.Type = n.Type
-               return true
-
-       case OINDEX:
-               if n.Left.Type.IsSlice() {
-                       break
-               }
-               if !stataddr(nam, n.Left) {
-                       break
-               }
-               l := getlit(n.Right)
-               if l < 0 {
-                       break
-               }
-
-               // Check for overflow.
-               if n.Type.Width != 0 && thearch.MAXWIDTH/n.Type.Width <= int64(l) {
-                       break
-               }
-               nam.Xoffset += int64(l) * n.Type.Width
-               nam.Type = n.Type
-               return true
-       }
-
-       return false
-}
-
-func (s *InitSchedule) initplan(n *Node) {
-       if s.initplans[n] != nil {
-               return
-       }
-       p := new(InitPlan)
-       s.initplans[n] = p
-       switch n.Op {
-       default:
-               Fatalf("initplan")
-
-       case OARRAYLIT, OSLICELIT:
-               var k int64
-               for _, a := range n.List.Slice() {
-                       if a.Op == OKEY {
-                               k = indexconst(a.Left)
-                               if k < 0 {
-                                       Fatalf("initplan arraylit: invalid index %v", a.Left)
-                               }
-                               a = a.Right
-                       }
-                       s.addvalue(p, k*n.Type.Elem().Width, a)
-                       k++
-               }
-
-       case OSTRUCTLIT:
-               for _, a := range n.List.Slice() {
-                       if a.Op != OSTRUCTKEY {
-                               Fatalf("initplan structlit")
-                       }
-                       if a.Sym.IsBlank() {
-                               continue
-                       }
-                       s.addvalue(p, a.Xoffset, a.Left)
-               }
-
-       case OMAPLIT:
-               for _, a := range n.List.Slice() {
-                       if a.Op != OKEY {
-                               Fatalf("initplan maplit")
-                       }
-                       s.addvalue(p, -1, a.Right)
-               }
-       }
-}
-
-func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *Node) {
-       // special case: zero can be dropped entirely
-       if isZero(n) {
-               return
-       }
-
-       // special case: inline struct and array (not slice) literals
-       if isvaluelit(n) {
-               s.initplan(n)
-               q := s.initplans[n]
-               for _, qe := range q.E {
-                       // qe is a copy; we are not modifying entries in q.E
-                       qe.Xoffset += xoffset
-                       p.E = append(p.E, qe)
-               }
-               return
-       }
-
-       // add to plan
-       p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
-}
-
-func isZero(n *Node) bool {
-       switch n.Op {
-       case OLITERAL:
-               switch u := n.Val().U.(type) {
-               default:
-                       Dump("unexpected literal", n)
-                       Fatalf("isZero")
-               case *NilVal:
-                       return true
-               case string:
-                       return u == ""
-               case bool:
-                       return !u
-               case *Mpint:
-                       return u.CmpInt64(0) == 0
-               case *Mpflt:
-                       return u.CmpFloat64(0) == 0
-               case *Mpcplx:
-                       return u.Real.CmpFloat64(0) == 0 && u.Imag.CmpFloat64(0) == 0
-               }
-
-       case OARRAYLIT:
-               for _, n1 := range n.List.Slice() {
-                       if n1.Op == OKEY {
-                               n1 = n1.Right
-                       }
-                       if !isZero(n1) {
-                               return false
-                       }
-               }
-               return true
-
-       case OSTRUCTLIT:
-               for _, n1 := range n.List.Slice() {
-                       if !isZero(n1.Left) {
-                               return false
-                       }
-               }
-               return true
-       }
-
-       return false
-}
-
-func isvaluelit(n *Node) bool {
-       return n.Op == OARRAYLIT || n.Op == OSTRUCTLIT
-}
-
-func genAsStatic(as *Node) {
-       if as.Left.Type == nil {
-               Fatalf("genAsStatic as.Left not typechecked")
-       }
-
-       var nam Node
-       if !stataddr(&nam, as.Left) || (nam.Class() != PEXTERN && as.Left != nblank) {
-               Fatalf("genAsStatic: lhs %v", as.Left)
-       }
-
-       switch {
-       case as.Right.Op == OLITERAL:
-               litsym(&nam, as.Right, int(as.Right.Type.Width))
-       case as.Right.Op == ONAME && as.Right.Class() == PFUNC:
-               pfuncsym(&nam, as.Right)
-       default:
-               Fatalf("genAsStatic: rhs %v", as.Right)
-       }
-}

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
deleted file mode 100644 (file)
index defefd7..0000000
--- a/src/cmd/compile/internal/gc/subr.go
+++ /dev/null
@@ -1,1918 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
-       "crypto/md5"
-       "encoding/binary"
-       "fmt"
-       "os"
-       "runtime/debug"
-       "sort"
-       "strconv"
-       "strings"
-       "sync"
-       "unicode"
-       "unicode/utf8"
-)
-
-type Error struct {
-       pos src.XPos
-       msg string
-}
-
-var errors []Error
-
-// largeStack is info about a function whose stack frame is too large (rare).
-type largeStack struct {
-       locals int64
-       args   int64
-       callee int64
-       pos    src.XPos
-}
-
-var (
-       largeStackFramesMu sync.Mutex // protects largeStackFrames
-       largeStackFrames   []largeStack
-)
-
-func errorexit() {
-       flusherrors()
-       if outfile != "" {
-               os.Remove(outfile)
-       }
-       os.Exit(2)
-}
-
-func adderrorname(n *Node) {
-       if n.Op != ODOT {
-               return
-       }
-       old := fmt.Sprintf("%v: undefined: %v\n", n.Line(), n.Left)
-       if len(errors) > 0 && errors[len(errors)-1].pos.Line() == n.Pos.Line() && errors[len(errors)-1].msg == old {
-               errors[len(errors)-1].msg = fmt.Sprintf("%v: undefined: %v in %v\n", n.Line(), n.Left, n)
-       }
-}
-
-func adderr(pos src.XPos, format string, args ...interface{}) {
-       msg := fmt.Sprintf(format, args...)
-       // Only add the position if know the position.
-       // See issue golang.org/issue/11361.
-       if pos.IsKnown() {
-               msg = fmt.Sprintf("%v: %s", linestr(pos), msg)
-       }
-       errors = append(errors, Error{
-               pos: pos,
-               msg: msg + "\n",
-       })
-}
-
-// byPos sorts errors by source position.
-type byPos []Error
-
-func (x byPos) Len() int           { return len(x) }
-func (x byPos) Less(i, j int) bool { return x[i].pos.Before(x[j].pos) }
-func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-
-// flusherrors sorts errors seen so far by line number, prints them to stdout,
-// and empties the errors array.
-func flusherrors() {
-       Ctxt.Bso.Flush()
-       if len(errors) == 0 {
-               return
-       }
-       sort.Stable(byPos(errors))
-       for i, err := range errors {
-               if i == 0 || err.msg != errors[i-1].msg {
-                       fmt.Printf("%s", err.msg)
-               }
-       }
-       errors = errors[:0]
-}
-
-func hcrash() {
-       if Debug.h != 0 {
-               flusherrors()
-               if outfile != "" {
-                       os.Remove(outfile)
-               }
-               var x *int
-               *x = 0
-       }
-}
-
-func linestr(pos src.XPos) string {
-       return Ctxt.OutermostPos(pos).Format(Debug.C == 0, Debug.L == 1)
-}
-
-// lasterror keeps track of the most recently issued error.
-// It is used to avoid multiple error messages on the same
-// line.
-var lasterror struct {
-       syntax src.XPos // source position of last syntax error
-       other  src.XPos // source position of last non-syntax error
-       msg    string   // error message of last non-syntax error
-}
-
-// sameline reports whether two positions a, b are on the same line.
-func sameline(a, b src.XPos) bool {
-       p := Ctxt.PosTable.Pos(a)
-       q := Ctxt.PosTable.Pos(b)
-       return p.Base() == q.Base() && p.Line() == q.Line()
-}
-
-func yyerrorl(pos src.XPos, format string, args ...interface{}) {
-       msg := fmt.Sprintf(format, args...)
-
-       if strings.HasPrefix(msg, "syntax error") {
-               nsyntaxerrors++
-               // only one syntax error per line, no matter what error
-               if sameline(lasterror.syntax, pos) {
-                       return
-               }
-               lasterror.syntax = pos
-       } else {
-               // only one of multiple equal non-syntax errors per line
-               // (flusherrors shows only one of them, so we filter them
-               // here as best as we can (they may not appear in order)
-               // so that we don't count them here and exit early, and
-               // then have nothing to show for.)
-               if sameline(lasterror.other, pos) && lasterror.msg == msg {
-                       return
-               }
-               lasterror.other = pos
-               lasterror.msg = msg
-       }
-
-       adderr(pos, "%s", msg)
-
-       hcrash()
-       nerrors++
-       if nsavederrors+nerrors >= 10 && Debug.e == 0 {
-               flusherrors()
-               fmt.Printf("%v: too many errors\n", linestr(pos))
-               errorexit()
-       }
-}
-
-func yyerrorv(lang string, format string, args ...interface{}) {
-       what := fmt.Sprintf(format, args...)
-       yyerrorl(lineno, "%s requires %s or later (-lang was set to %s; check go.mod)", what, lang, flag_lang)
-}
-
-func yyerror(format string, args ...interface{}) {
-       yyerrorl(lineno, format, args...)
-}
-
-func Warn(fmt_ string, args ...interface{}) {
-       Warnl(lineno, fmt_, args...)
-}
-
-func Warnl(line src.XPos, fmt_ string, args ...interface{}) {
-       adderr(line, fmt_, args...)
-       if Debug.m != 0 {
-               flusherrors()
-       }
-}
-
-func Fatalf(fmt_ string, args ...interface{}) {
-       flusherrors()
-
-       if Debug_panic != 0 || nsavederrors+nerrors == 0 {
-               fmt.Printf("%v: internal compiler error: ", linestr(lineno))
-               fmt.Printf(fmt_, args...)
-               fmt.Printf("\n")
-
-               // If this is a released compiler version, ask for a bug report.
-               if strings.HasPrefix(objabi.Version, "go") {
-                       fmt.Printf("\n")
-                       fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
-                       fmt.Printf("https://golang.org/issue/new\n")
-               } else {
-                       // Not a release; dump a stack trace, too.
-                       fmt.Println()
-                       os.Stdout.Write(debug.Stack())
-                       fmt.Println()
-               }
-       }
-
-       hcrash()
-       errorexit()
-}
-
-// hasUniquePos reports whether n has a unique position that can be
-// used for reporting error messages.
-//
-// It's primarily used to distinguish references to named objects,
-// whose Pos will point back to their declaration position rather than
-// their usage position.
-func hasUniquePos(n *Node) bool {
-       switch n.Op {
-       case ONAME, OPACK:
-               return false
-       case OLITERAL, OTYPE:
-               if n.Sym != nil {
-                       return false
-               }
-       }
-
-       if !n.Pos.IsKnown() {
-               if Debug.K != 0 {
-                       Warn("setlineno: unknown position (line 0)")
-               }
-               return false
-       }
-
-       return true
-}
-
-func setlineno(n *Node) src.XPos {
-       lno := lineno
-       if n != nil && hasUniquePos(n) {
-               lineno = n.Pos
-       }
-       return lno
-}
-
-func lookup(name string) *types.Sym {
-       return localpkg.Lookup(name)
-}
-
-// lookupN looks up the symbol starting with prefix and ending with
-// the decimal n. If prefix is too long, lookupN panics.
-func lookupN(prefix string, n int) *types.Sym {
-       var buf [20]byte // plenty long enough for all current users
-       copy(buf[:], prefix)
-       b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
-       return localpkg.LookupBytes(b)
-}
-
-// autolabel generates a new Name node for use with
-// an automatically generated label.
-// prefix is a short mnemonic (e.g. ".s" for switch)
-// to help with debugging.
-// It should begin with "." to avoid conflicts with
-// user labels.
-func autolabel(prefix string) *types.Sym {
-       if prefix[0] != '.' {
-               Fatalf("autolabel prefix must start with '.', have %q", prefix)
-       }
-       fn := Curfn
-       if Curfn == nil {
-               Fatalf("autolabel outside function")
-       }
-       n := fn.Func.Label
-       fn.Func.Label++
-       return lookupN(prefix, int(n))
-}
-
-// find all the exported symbols in package opkg
-// and make them available in the current package
-func importdot(opkg *types.Pkg, pack *Node) {
-       n := 0
-       for _, s := range opkg.Syms {
-               if s.Def == nil {
-                       continue
-               }
-               if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
-                       continue
-               }
-               s1 := lookup(s.Name)
-               if s1.Def != nil {
-                       pkgerror := fmt.Sprintf("during import %q", opkg.Path)
-                       redeclare(lineno, s1, pkgerror)
-                       continue
-               }
-
-               s1.Def = s.Def
-               s1.Block = s.Block
-               if asNode(s1.Def).Name == nil {
-                       Dump("s1def", asNode(s1.Def))
-                       Fatalf("missing Name")
-               }
-               asNode(s1.Def).Name.Pack = pack
-               s1.Origpkg = opkg
-               n++
-       }
-
-       if n == 0 {
-               // can't possibly be used - there were no symbols
-               yyerrorl(pack.Pos, "imported and not used: %q", opkg.Path)
-       }
-}
-
-func nod(op Op, nleft, nright *Node) *Node {
-       return nodl(lineno, op, nleft, nright)
-}
-
-func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
-       var n *Node
-       switch op {
-       case OCLOSURE, ODCLFUNC:
-               var x struct {
-                       n Node
-                       f Func
-               }
-               n = &x.n
-               n.Func = &x.f
-       case ONAME:
-               Fatalf("use newname instead")
-       case OLABEL, OPACK:
-               var x struct {
-                       n Node
-                       m Name
-               }
-               n = &x.n
-               n.Name = &x.m
-       default:
-               n = new(Node)
-       }
-       n.Op = op
-       n.Left = nleft
-       n.Right = nright
-       n.Pos = pos
-       n.Xoffset = BADWIDTH
-       n.Orig = n
-       return n
-}
-
-// newname returns a new ONAME Node associated with symbol s.
-func newname(s *types.Sym) *Node {
-       n := newnamel(lineno, s)
-       n.Name.Curfn = Curfn
-       return n
-}
-
-// newnamel returns a new ONAME Node associated with symbol s at position pos.
-// The caller is responsible for setting n.Name.Curfn.
-func newnamel(pos src.XPos, s *types.Sym) *Node {
-       if s == nil {
-               Fatalf("newnamel nil")
-       }
-
-       var x struct {
-               n Node
-               m Name
-               p Param
-       }
-       n := &x.n
-       n.Name = &x.m
-       n.Name.Param = &x.p
-
-       n.Op = ONAME
-       n.Pos = pos
-       n.Orig = n
-
-       n.Sym = s
-       return n
-}
-
-// nodSym makes a Node with Op op and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodSym(op Op, left *Node, sym *types.Sym) *Node {
-       return nodlSym(lineno, op, left, sym)
-}
-
-// nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodlSym(pos src.XPos, op Op, left *Node, sym *types.Sym) *Node {
-       n := nodl(pos, op, left, nil)
-       n.Sym = sym
-       return n
-}
-
-// rawcopy returns a shallow copy of n.
-// Note: copy or sepcopy (rather than rawcopy) is usually the
-//       correct choice (see comment with Node.copy, below).
-func (n *Node) rawcopy() *Node {
-       copy := *n
-       return &copy
-}
-
-// sepcopy returns a separate shallow copy of n, with the copy's
-// Orig pointing to itself.
-func (n *Node) sepcopy() *Node {
-       copy := *n
-       copy.Orig = &copy
-       return &copy
-}
-
-// copy returns shallow copy of n and adjusts the copy's Orig if
-// necessary: In general, if n.Orig points to itself, the copy's
-// Orig should point to itself as well. Otherwise, if n is modified,
-// the copy's Orig node appears modified, too, and then doesn't
-// represent the original node anymore.
-// (This caused the wrong complit Op to be used when printing error
-// messages; see issues #26855, #27765).
-func (n *Node) copy() *Node {
-       copy := *n
-       if n.Orig == n {
-               copy.Orig = &copy
-       }
-       return &copy
-}
-
-// methcmp sorts methods by symbol.
-type methcmp []*types.Field
-
-func (x methcmp) Len() int           { return len(x) }
-func (x methcmp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x methcmp) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
-
-func nodintconst(v int64) *Node {
-       u := new(Mpint)
-       u.SetInt64(v)
-       return nodlit(Val{u})
-}
-
-func nodnil() *Node {
-       return nodlit(Val{new(NilVal)})
-}
-
-func nodbool(b bool) *Node {
-       return nodlit(Val{b})
-}
-
-func nodstr(s string) *Node {
-       return nodlit(Val{s})
-}
-
-// treecopy recursively copies n, with the exception of
-// ONAME, OLITERAL, OTYPE, and ONONAME leaves.
-// If pos.IsKnown(), it sets the source position of newly
-// allocated nodes to pos.
-func treecopy(n *Node, pos src.XPos) *Node {
-       if n == nil {
-               return nil
-       }
-
-       switch n.Op {
-       default:
-               m := n.sepcopy()
-               m.Left = treecopy(n.Left, pos)
-               m.Right = treecopy(n.Right, pos)
-               m.List.Set(listtreecopy(n.List.Slice(), pos))
-               if pos.IsKnown() {
-                       m.Pos = pos
-               }
-               if m.Name != nil && n.Op != ODCLFIELD {
-                       Dump("treecopy", n)
-                       Fatalf("treecopy Name")
-               }
-               return m
-
-       case OPACK:
-               // OPACK nodes are never valid in const value declarations,
-               // but allow them like any other declared symbol to avoid
-               // crashing (golang.org/issue/11361).
-               fallthrough
-
-       case ONAME, ONONAME, OLITERAL, OTYPE:
-               return n
-
-       }
-}
-
-// isNil reports whether n represents the universal untyped zero value "nil".
-func (n *Node) isNil() bool {
-       // Check n.Orig because constant propagation may produce typed nil constants,
-       // which don't exist in the Go spec.
-       return Isconst(n.Orig, CTNIL)
-}
-
-func isptrto(t *types.Type, et types.EType) bool {
-       if t == nil {
-               return false
-       }
-       if !t.IsPtr() {
-               return false
-       }
-       t = t.Elem()
-       if t == nil {
-               return false
-       }
-       if t.Etype != et {
-               return false
-       }
-       return true
-}
-
-func (n *Node) isBlank() bool {
-       if n == nil {
-               return false
-       }
-       return n.Sym.IsBlank()
-}
-
-// methtype returns the underlying type, if any,
-// that owns methods with receiver parameter t.
-// The result is either a named type or an anonymous struct.
-func methtype(t *types.Type) *types.Type {
-       if t == nil {
-               return nil
-       }
-
-       // Strip away pointer if it's there.
-       if t.IsPtr() {
-               if t.Sym != nil {
-                       return nil
-               }
-               t = t.Elem()
-               if t == nil {
-                       return nil
-               }
-       }
-
-       // Must be a named type or anonymous struct.
-       if t.Sym == nil && !t.IsStruct() {
-               return nil
-       }
-
-       // Check types.
-       if issimple[t.Etype] {
-               return t
-       }
-       switch t.Etype {
-       case TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRING, TSTRUCT:
-               return t
-       }
-       return nil
-}
-
-// Is type src assignment compatible to type dst?
-// If so, return op code to use in conversion.
-// If not, return OXXX. In this case, the string return parameter may
-// hold a reason why. In all other cases, it'll be the empty string.
-func assignop(src, dst *types.Type) (Op, string) {
-       if src == dst {
-               return OCONVNOP, ""
-       }
-       if src == nil || dst == nil || src.Etype == TFORW || dst.Etype == TFORW || src.Orig == nil || dst.Orig == nil {
-               return OXXX, ""
-       }
-
-       // 1. src type is identical to dst.
-       if types.Identical(src, dst) {
-               return OCONVNOP, ""
-       }
-
-       // 2. src and dst have identical underlying types
-       // and either src or dst is not a named type or
-       // both are empty interface types.
-       // For assignable but different non-empty interface types,
-       // we want to recompute the itab. Recomputing the itab ensures
-       // that itabs are unique (thus an interface with a compile-time
-       // type I has an itab with interface type I).
-       if types.Identical(src.Orig, dst.Orig) {
-               if src.IsEmptyInterface() {
-                       // Conversion between two empty interfaces
-                       // requires no code.
-                       return OCONVNOP, ""
-               }
-               if (src.Sym == nil || dst.Sym == nil) && !src.IsInterface() {
-                       // Conversion between two types, at least one unnamed,
-                       // needs no conversion. The exception is nonempty interfaces
-                       // which need to have their itab updated.
-                       return OCONVNOP, ""
-               }
-       }
-
-       // 3. dst is an interface type and src implements dst.
-       if dst.IsInterface() && src.Etype != TNIL {
-               var missing, have *types.Field
-               var ptr int
-               if implements(src, dst, &missing, &have, &ptr) {
-                       return OCONVIFACE, ""
-               }
-
-               // we'll have complained about this method anyway, suppress spurious messages.
-               if have != nil && have.Sym == missing.Sym && (have.Type.Broke() || missing.Type.Broke()) {
-                       return OCONVIFACE, ""
-               }
-
-               var why string
-               if isptrto(src, TINTER) {
-                       why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", src)
-               } else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
-                       why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
-               } else if have != nil && have.Sym == missing.Sym {
-                       why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+
-                               "\t\thave %v%0S\n\t\twant %v%0S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-               } else if ptr != 0 {
-                       why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", src, dst, missing.Sym)
-               } else if have != nil {
-                       why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+
-                               "\t\thave %v%0S\n\t\twant %v%0S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-               } else {
-                       why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
-               }
-
-               return OXXX, why
-       }
-
-       if isptrto(dst, TINTER) {
-               why := fmt.Sprintf(":\n\t%v is pointer to interface, not interface", dst)
-               return OXXX, why
-       }
-
-       if src.IsInterface() && dst.Etype != TBLANK {
-               var missing, have *types.Field
-               var ptr int
-               var why string
-               if implements(dst, src, &missing, &have, &ptr) {
-                       why = ": need type assertion"
-               }
-               return OXXX, why
-       }
-
-       // 4. src is a bidirectional channel value, dst is a channel type,
-       // src and dst have identical element types, and
-       // either src or dst is not a named type.
-       if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
-               if types.Identical(src.Elem(), dst.Elem()) && (src.Sym == nil || dst.Sym == nil) {
-                       return OCONVNOP, ""
-               }
-       }
-
-       // 5. src is the predeclared identifier nil and dst is a nillable type.
-       if src.Etype == TNIL {
-               switch dst.Etype {
-               case TPTR,
-                       TFUNC,
-                       TMAP,
-                       TCHAN,
-                       TINTER,
-                       TSLICE:
-                       return OCONVNOP, ""
-               }
-       }
-
-       // 6. rule about untyped constants - already converted by defaultlit.
-
-       // 7. Any typed value can be assigned to the blank identifier.
-       if dst.Etype == TBLANK {
-               return OCONVNOP, ""
-       }
-
-       return OXXX, ""
-}
-
-// Can we convert a value of type src to a value of type dst?
-// If so, return op code to use in conversion (maybe OCONVNOP).
-// If not, return OXXX. In this case, the string return parameter may
-// hold a reason why. In all other cases, it'll be the empty string.
-// srcConstant indicates whether the value of type src is a constant.
-func convertop(srcConstant bool, src, dst *types.Type) (Op, string) {
-       if src == dst {
-               return OCONVNOP, ""
-       }
-       if src == nil || dst == nil {
-               return OXXX, ""
-       }
-
-       // Conversions from regular to go:notinheap are not allowed
-       // (unless it's unsafe.Pointer). These are runtime-specific
-       // rules.
-       // (a) Disallow (*T) to (*U) where T is go:notinheap but U isn't.
-       if src.IsPtr() && dst.IsPtr() && dst.Elem().NotInHeap() && !src.Elem().NotInHeap() {
-               why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable), but %v is not", dst.Elem(), src.Elem())
-               return OXXX, why
-       }
-       // (b) Disallow string to []T where T is go:notinheap.
-       if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Etype == types.Bytetype.Etype || dst.Elem().Etype == types.Runetype.Etype) {
-               why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
-               return OXXX, why
-       }
-
-       // 1. src can be assigned to dst.
-       op, why := assignop(src, dst)
-       if op != OXXX {
-               return op, why
-       }
-
-       // The rules for interfaces are no different in conversions
-       // than assignments. If interfaces are involved, stop now
-       // with the good message from assignop.
-       // Otherwise clear the error.
-       if src.IsInterface() || dst.IsInterface() {
-               return OXXX, why
-       }
-
-       // 2. Ignoring struct tags, src and dst have identical underlying types.
-       if types.IdenticalIgnoreTags(src.Orig, dst.Orig) {
-               return OCONVNOP, ""
-       }
-
-       // 3. src and dst are unnamed pointer types and, ignoring struct tags,
-       // their base types have identical underlying types.
-       if src.IsPtr() && dst.IsPtr() && src.Sym == nil && dst.Sym == nil {
-               if types.IdenticalIgnoreTags(src.Elem().Orig, dst.Elem().Orig) {
-                       return OCONVNOP, ""
-               }
-       }
-
-       // 4. src and dst are both integer or floating point types.
-       if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
-               if simtype[src.Etype] == simtype[dst.Etype] {
-                       return OCONVNOP, ""
-               }
-               return OCONV, ""
-       }
-
-       // 5. src and dst are both complex types.
-       if src.IsComplex() && dst.IsComplex() {
-               if simtype[src.Etype] == simtype[dst.Etype] {
-                       return OCONVNOP, ""
-               }
-               return OCONV, ""
-       }
-
-       // Special case for constant conversions: any numeric
-       // conversion is potentially okay. We'll validate further
-       // within evconst. See #38117.
-       if srcConstant && (src.IsInteger() || src.IsFloat() || src.IsComplex()) && (dst.IsInteger() || dst.IsFloat() || dst.IsComplex()) {
-               return OCONV, ""
-       }
-
-       // 6. src is an integer or has type []byte or []rune
-       // and dst is a string type.
-       if src.IsInteger() && dst.IsString() {
-               return ORUNESTR, ""
-       }
-
-       if src.IsSlice() && dst.IsString() {
-               if src.Elem().Etype == types.Bytetype.Etype {
-                       return OBYTES2STR, ""
-               }
-               if src.Elem().Etype == types.Runetype.Etype {
-                       return ORUNES2STR, ""
-               }
-       }
-
-       // 7. src is a string and dst is []byte or []rune.
-       // String to slice.
-       if src.IsString() && dst.IsSlice() {
-               if dst.Elem().Etype == types.Bytetype.Etype {
-                       return OSTR2BYTES, ""
-               }
-               if dst.Elem().Etype == types.Runetype.Etype {
-                       return OSTR2RUNES, ""
-               }
-       }
-
-       // 8. src is a pointer or uintptr and dst is unsafe.Pointer.
-       if (src.IsPtr() || src.IsUintptr()) && dst.IsUnsafePtr() {
-               return OCONVNOP, ""
-       }
-
-       // 9. src is unsafe.Pointer and dst is a pointer or uintptr.
-       if src.IsUnsafePtr() && (dst.IsPtr() || dst.IsUintptr()) {
-               return OCONVNOP, ""
-       }
-
-       // src is map and dst is a pointer to corresponding hmap.
-       // This rule is needed for the implementation detail that
-       // go gc maps are implemented as a pointer to a hmap struct.
-       if src.Etype == TMAP && dst.IsPtr() &&
-               src.MapType().Hmap == dst.Elem() {
-               return OCONVNOP, ""
-       }
-
-       return OXXX, ""
-}
-
-func assignconv(n *Node, t *types.Type, context string) *Node {
-       return assignconvfn(n, t, func() string { return context })
-}
-
-// Convert node n for assignment to type t.
-func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
-       if n == nil || n.Type == nil || n.Type.Broke() {
-               return n
-       }
-
-       if t.Etype == TBLANK && n.Type.Etype == TNIL {
-               yyerror("use of untyped nil")
-       }
-
-       n = convlit1(n, t, false, context)
-       if n.Type == nil {
-               return n
-       }
-       if t.Etype == TBLANK {
-               return n
-       }
-
-       // Convert ideal bool from comparison to plain bool
-       // if the next step is non-bool (like interface{}).
-       if n.Type == types.UntypedBool && !t.IsBoolean() {
-               if n.Op == ONAME || n.Op == OLITERAL {
-                       r := nod(OCONVNOP, n, nil)
-                       r.Type = types.Types[TBOOL]
-                       r.SetTypecheck(1)
-                       r.SetImplicit(true)
-                       n = r
-               }
-       }
-
-       if types.Identical(n.Type, t) {
-               return n
-       }
-
-       op, why := assignop(n.Type, t)
-       if op == OXXX {
-               yyerror("cannot use %L as type %v in %s%s", n, t, context(), why)
-               op = OCONV
-       }
-
-       r := nod(op, n, nil)
-       r.Type = t
-       r.SetTypecheck(1)
-       r.SetImplicit(true)
-       r.Orig = n.Orig
-       return r
-}
-
-// IsMethod reports whether n is a method.
-// n must be a function or a method.
-func (n *Node) IsMethod() bool {
-       return n.Type.Recv() != nil
-}
-
-// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
-// n must be a slice expression. max is nil if n is a simple slice expression.
-func (n *Node) SliceBounds() (low, high, max *Node) {
-       if n.List.Len() == 0 {
-               return nil, nil, nil
-       }
-
-       switch n.Op {
-       case OSLICE, OSLICEARR, OSLICESTR:
-               s := n.List.Slice()
-               return s[0], s[1], nil
-       case OSLICE3, OSLICE3ARR:
-               s := n.List.Slice()
-               return s[0], s[1], s[2]
-       }
-       Fatalf("SliceBounds op %v: %v", n.Op, n)
-       return nil, nil, nil
-}
-
-// SetSliceBounds sets n's slice bounds, where n is a slice expression.
-// n must be a slice expression. If max is non-nil, n must be a full slice expression.
-func (n *Node) SetSliceBounds(low, high, max *Node) {
-       switch n.Op {
-       case OSLICE, OSLICEARR, OSLICESTR:
-               if max != nil {
-                       Fatalf("SetSliceBounds %v given three bounds", n.Op)
-               }
-               s := n.List.Slice()
-               if s == nil {
-                       if low == nil && high == nil {
-                               return
-                       }
-                       n.List.Set2(low, high)
-                       return
-               }
-               s[0] = low
-               s[1] = high
-               return
-       case OSLICE3, OSLICE3ARR:
-               s := n.List.Slice()
-               if s == nil {
-                       if low == nil && high == nil && max == nil {
-                               return
-                       }
-                       n.List.Set3(low, high, max)
-                       return
-               }
-               s[0] = low
-               s[1] = high
-               s[2] = max
-               return
-       }
-       Fatalf("SetSliceBounds op %v: %v", n.Op, n)
-}
-
-// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
-// o must be a slicing op.
-func (o Op) IsSlice3() bool {
-       switch o {
-       case OSLICE, OSLICEARR, OSLICESTR:
-               return false
-       case OSLICE3, OSLICE3ARR:
-               return true
-       }
-       Fatalf("IsSlice3 op %v", o)
-       return false
-}
-
-// backingArrayPtrLen extracts the pointer and length from a slice or string.
-// This constructs two nodes referring to n, so n must be a cheapexpr.
-func (n *Node) backingArrayPtrLen() (ptr, len *Node) {
-       var init Nodes
-       c := cheapexpr(n, &init)
-       if c != n || init.Len() != 0 {
-               Fatalf("backingArrayPtrLen not cheap: %v", n)
-       }
-       ptr = nod(OSPTR, n, nil)
-       if n.Type.IsString() {
-               ptr.Type = types.Types[TUINT8].PtrTo()
-       } else {
-               ptr.Type = n.Type.Elem().PtrTo()
-       }
-       len = nod(OLEN, n, nil)
-       len.Type = types.Types[TINT]
-       return ptr, len
-}
-
-// labeledControl returns the control flow Node (for, switch, select)
-// associated with the label n, if any.
-func (n *Node) labeledControl() *Node {
-       if n.Op != OLABEL {
-               Fatalf("labeledControl %v", n.Op)
-       }
-       ctl := n.Name.Defn
-       if ctl == nil {
-               return nil
-       }
-       switch ctl.Op {
-       case OFOR, OFORUNTIL, OSWITCH, OSELECT:
-               return ctl
-       }
-       return nil
-}
-
-func syslook(name string) *Node {
-       s := Runtimepkg.Lookup(name)
-       if s == nil || s.Def == nil {
-               Fatalf("syslook: can't find runtime.%s", name)
-       }
-       return asNode(s.Def)
-}
-
-// typehash computes a hash value for type t to use in type switch statements.
-func typehash(t *types.Type) uint32 {
-       p := t.LongString()
-
-       // Using MD5 is overkill, but reduces accidental collisions.
-       h := md5.Sum([]byte(p))
-       return binary.LittleEndian.Uint32(h[:4])
-}
-
-// updateHasCall checks whether expression n contains any function
-// calls and sets the n.HasCall flag if so.
-func updateHasCall(n *Node) {
-       if n == nil {
-               return
-       }
-       n.SetHasCall(calcHasCall(n))
-}
-
-func calcHasCall(n *Node) bool {
-       if n.Ninit.Len() != 0 {
-               // TODO(mdempsky): This seems overly conservative.
-               return true
-       }
-
-       switch n.Op {
-       case OLITERAL, ONAME, OTYPE:
-               if n.HasCall() {
-                       Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
-               }
-               return false
-       case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER:
-               return true
-       case OANDAND, OOROR:
-               // hard with instrumented code
-               if instrumenting {
-                       return true
-               }
-       case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR,
-               ODEREF, ODOTPTR, ODOTTYPE, ODIV, OMOD:
-               // These ops might panic, make sure they are done
-               // before we start marshaling args for a call. See issue 16760.
-               return true
-
-       // When using soft-float, these ops might be rewritten to function calls
-       // so we ensure they are evaluated first.
-       case OADD, OSUB, ONEG, OMUL:
-               if thearch.SoftFloat && (isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) {
-                       return true
-               }
-       case OLT, OEQ, ONE, OLE, OGE, OGT:
-               if thearch.SoftFloat && (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype]) {
-                       return true
-               }
-       case OCONV:
-               if thearch.SoftFloat && ((isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) || (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype])) {
-                       return true
-               }
-       }
-
-       if n.Left != nil && n.Left.HasCall() {
-               return true
-       }
-       if n.Right != nil && n.Right.HasCall() {
-               return true
-       }
-       return false
-}
-
-func badtype(op Op, tl, tr *types.Type) {
-       var s string
-       if tl != nil {
-               s += fmt.Sprintf("\n\t%v", tl)
-       }
-       if tr != nil {
-               s += fmt.Sprintf("\n\t%v", tr)
-       }
-
-       // common mistake: *struct and *interface.
-       if tl != nil && tr != nil && tl.IsPtr() && tr.IsPtr() {
-               if tl.Elem().IsStruct() && tr.Elem().IsInterface() {
-                       s += "\n\t(*struct vs *interface)"
-               } else if tl.Elem().IsInterface() && tr.Elem().IsStruct() {
-                       s += "\n\t(*interface vs *struct)"
-               }
-       }
-
-       yyerror("illegal types for operand: %v%s", op, s)
-}
-
-// brcom returns !(op).
-// For example, brcom(==) is !=.
-func brcom(op Op) Op {
-       switch op {
-       case OEQ:
-               return ONE
-       case ONE:
-               return OEQ
-       case OLT:
-               return OGE
-       case OGT:
-               return OLE
-       case OLE:
-               return OGT
-       case OGE:
-               return OLT
-       }
-       Fatalf("brcom: no com for %v\n", op)
-       return op
-}
-
-// brrev returns reverse(op).
-// For example, Brrev(<) is >.
-func brrev(op Op) Op {
-       switch op {
-       case OEQ:
-               return OEQ
-       case ONE:
-               return ONE
-       case OLT:
-               return OGT
-       case OGT:
-               return OLT
-       case OLE:
-               return OGE
-       case OGE:
-               return OLE
-       }
-       Fatalf("brrev: no rev for %v\n", op)
-       return op
-}
-
-// return side effect-free n, appending side effects to init.
-// result is assignable if n is.
-func safeexpr(n *Node, init *Nodes) *Node {
-       if n == nil {
-               return nil
-       }
-
-       if n.Ninit.Len() != 0 {
-               walkstmtlist(n.Ninit.Slice())
-               init.AppendNodes(&n.Ninit)
-       }
-
-       switch n.Op {
-       case ONAME, OLITERAL:
-               return n
-
-       case ODOT, OLEN, OCAP:
-               l := safeexpr(n.Left, init)
-               if l == n.Left {
-                       return n
-               }
-               r := n.copy()
-               r.Left = l
-               r = typecheck(r, ctxExpr)
-               r = walkexpr(r, init)
-               return r
-
-       case ODOTPTR, ODEREF:
-               l := safeexpr(n.Left, init)
-               if l == n.Left {
-                       return n
-               }
-               a := n.copy()
-               a.Left = l
-               a = walkexpr(a, init)
-               return a
-
-       case OINDEX, OINDEXMAP:
-               l := safeexpr(n.Left, init)
-               r := safeexpr(n.Right, init)
-               if l == n.Left && r == n.Right {
-                       return n
-               }
-               a := n.copy()
-               a.Left = l
-               a.Right = r
-               a = walkexpr(a, init)
-               return a
-
-       case OSTRUCTLIT, OARRAYLIT, OSLICELIT:
-               if isStaticCompositeLiteral(n) {
-                       return n
-               }
-       }
-
-       // make a copy; must not be used as an lvalue
-       if islvalue(n) {
-               Fatalf("missing lvalue case in safeexpr: %v", n)
-       }
-       return cheapexpr(n, init)
-}
-
-func copyexpr(n *Node, t *types.Type, init *Nodes) *Node {
-       l := temp(t)
-       a := nod(OAS, l, n)
-       a = typecheck(a, ctxStmt)
-       a = walkexpr(a, init)
-       init.Append(a)
-       return l
-}
-
-// return side-effect free and cheap n, appending side effects to init.
-// result may not be assignable.
-func cheapexpr(n *Node, init *Nodes) *Node {
-       switch n.Op {
-       case ONAME, OLITERAL:
-               return n
-       }
-
-       return copyexpr(n, n.Type, init)
-}
-
-// Code to resolve elided DOTs in embedded types.
-
-// A Dlist stores a pointer to a TFIELD Type embedded within
-// a TSTRUCT or TINTER Type.
-type Dlist struct {
-       field *types.Field
-}
-
-// dotlist is used by adddot1 to record the path of embedded fields
-// used to access a target field or method.
-// Must be non-nil so that dotpath returns a non-nil slice even if d is zero.
-var dotlist = make([]Dlist, 10)
-
-// lookdot0 returns the number of fields or methods named s associated
-// with Type t. If exactly one exists, it will be returned in *save
-// (if save is not nil).
-func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) int {
-       u := t
-       if u.IsPtr() {
-               u = u.Elem()
-       }
-
-       c := 0
-       if u.IsStruct() || u.IsInterface() {
-               for _, f := range u.Fields().Slice() {
-                       if f.Sym == s || (ignorecase && f.IsMethod() && strings.EqualFold(f.Sym.Name, s.Name)) {
-                               if save != nil {
-                                       *save = f
-                               }
-                               c++
-                       }
-               }
-       }
-
-       u = t
-       if t.Sym != nil && t.IsPtr() && !t.Elem().IsPtr() {
-               // If t is a defined pointer type, then x.m is shorthand for (*x).m.
-               u = t.Elem()
-       }
-       u = methtype(u)
-       if u != nil {
-               for _, f := range u.Methods().Slice() {
-                       if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
-                               if save != nil {
-                                       *save = f
-                               }
-                               c++
-                       }
-               }
-       }
-
-       return c
-}
-
-// adddot1 returns the number of fields or methods named s at depth d in Type t.
-// If exactly one exists, it will be returned in *save (if save is not nil),
-// and dotlist will contain the path of embedded fields traversed to find it,
-// in reverse order. If none exist, more will indicate whether t contains any
-// embedded fields at depth d, so callers can decide whether to retry at
-// a greater depth.
-func adddot1(s *types.Sym, t *types.Type, d int, save **types.Field, ignorecase bool) (c int, more bool) {
-       if t.Recur() {
-               return
-       }
-       t.SetRecur(true)
-       defer t.SetRecur(false)
-
-       var u *types.Type
-       d--
-       if d < 0 {
-               // We've reached our target depth. If t has any fields/methods
-               // named s, then we're done. Otherwise, we still need to check
-               // below for embedded fields.
-               c = lookdot0(s, t, save, ignorecase)
-               if c != 0 {
-                       return c, false
-               }
-       }
-
-       u = t
-       if u.IsPtr() {
-               u = u.Elem()
-       }
-       if !u.IsStruct() && !u.IsInterface() {
-               return c, false
-       }
-
-       for _, f := range u.Fields().Slice() {
-               if f.Embedded == 0 || f.Sym == nil {
-                       continue
-               }
-               if d < 0 {
-                       // Found an embedded field at target depth.
-                       return c, true
-               }
-               a, more1 := adddot1(s, f.Type, d, save, ignorecase)
-               if a != 0 && c == 0 {
-                       dotlist[d].field = f
-               }
-               c += a
-               if more1 {
-                       more = true
-               }
-       }
-
-       return c, more
-}
-
-// dotpath computes the unique shortest explicit selector path to fully qualify
-// a selection expression x.f, where x is of type t and f is the symbol s.
-// If no such path exists, dotpath returns nil.
-// If there are multiple shortest paths to the same depth, ambig is true.
-func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (path []Dlist, ambig bool) {
-       // The embedding of types within structs imposes a tree structure onto
-       // types: structs parent the types they embed, and types parent their
-       // fields or methods. Our goal here is to find the shortest path to
-       // a field or method named s in the subtree rooted at t. To accomplish
-       // that, we iteratively perform depth-first searches of increasing depth
-       // until we either find the named field/method or exhaust the tree.
-       for d := 0; ; d++ {
-               if d > len(dotlist) {
-                       dotlist = append(dotlist, Dlist{})
-               }
-               if c, more := adddot1(s, t, d, save, ignorecase); c == 1 {
-                       return dotlist[:d], false
-               } else if c > 1 {
-                       return nil, true
-               } else if !more {
-                       return nil, false
-               }
-       }
-}
-
-// in T.field
-// find missing fields that
-// will give shortest unique addressing.
-// modify the tree with missing type names.
-func adddot(n *Node) *Node {
-       n.Left = typecheck(n.Left, ctxType|ctxExpr)
-       if n.Left.Diag() {
-               n.SetDiag(true)
-       }
-       t := n.Left.Type
-       if t == nil {
-               return n
-       }
-
-       if n.Left.Op == OTYPE {
-               return n
-       }
-
-       s := n.Sym
-       if s == nil {
-               return n
-       }
-
-       switch path, ambig := dotpath(s, t, nil, false); {
-       case path != nil:
-               // rebuild elided dots
-               for c := len(path) - 1; c >= 0; c-- {
-                       n.Left = nodSym(ODOT, n.Left, path[c].field.Sym)
-                       n.Left.SetImplicit(true)
-               }
-       case ambig:
-               yyerror("ambiguous selector %v", n)
-               n.Left = nil
-       }
-
-       return n
-}
-
-// Code to help generate trampoline functions for methods on embedded
-// types. These are approx the same as the corresponding adddot
-// routines except that they expect to be called with unique tasks and
-// they return the actual methods.
-
-type Symlink struct {
-       field *types.Field
-}
-
-var slist []Symlink
-
-func expand0(t *types.Type) {
-       u := t
-       if u.IsPtr() {
-               u = u.Elem()
-       }
-
-       if u.IsInterface() {
-               for _, f := range u.Fields().Slice() {
-                       if f.Sym.Uniq() {
-                               continue
-                       }
-                       f.Sym.SetUniq(true)
-                       slist = append(slist, Symlink{field: f})
-               }
-
-               return
-       }
-
-       u = methtype(t)
-       if u != nil {
-               for _, f := range u.Methods().Slice() {
-                       if f.Sym.Uniq() {
-                               continue
-                       }
-                       f.Sym.SetUniq(true)
-                       slist = append(slist, Symlink{field: f})
-               }
-       }
-}
-
-func expand1(t *types.Type, top bool) {
-       if t.Recur() {
-               return
-       }
-       t.SetRecur(true)
-
-       if !top {
-               expand0(t)
-       }
-
-       u := t
-       if u.IsPtr() {
-               u = u.Elem()
-       }
-
-       if u.IsStruct() || u.IsInterface() {
-               for _, f := range u.Fields().Slice() {
-                       if f.Embedded == 0 {
-                               continue
-                       }
-                       if f.Sym == nil {
-                               continue
-                       }
-                       expand1(f.Type, false)
-               }
-       }
-
-       t.SetRecur(false)
-}
-
-func expandmeth(t *types.Type) {
-       if t == nil || t.AllMethods().Len() != 0 {
-               return
-       }
-
-       // mark top-level method symbols
-       // so that expand1 doesn't consider them.
-       for _, f := range t.Methods().Slice() {
-               f.Sym.SetUniq(true)
-       }
-
-       // generate all reachable methods
-       slist = slist[:0]
-       expand1(t, true)
-
-       // check each method to be uniquely reachable
-       var ms []*types.Field
-       for i, sl := range slist {
-               slist[i].field = nil
-               sl.field.Sym.SetUniq(false)
-
-               var f *types.Field
-               path, _ := dotpath(sl.field.Sym, t, &f, false)
-               if path == nil {
-                       continue
-               }
-
-               // dotpath may have dug out arbitrary fields, we only want methods.
-               if !f.IsMethod() {
-                       continue
-               }
-
-               // add it to the base type method list
-               f = f.Copy()
-               f.Embedded = 1 // needs a trampoline
-               for _, d := range path {
-                       if d.field.Type.IsPtr() {
-                               f.Embedded = 2
-                               break
-                       }
-               }
-               ms = append(ms, f)
-       }
-
-       for _, f := range t.Methods().Slice() {
-               f.Sym.SetUniq(false)
-       }
-
-       ms = append(ms, t.Methods().Slice()...)
-       sort.Sort(methcmp(ms))
-       t.AllMethods().Set(ms)
-}
-
-// Given funarg struct list, return list of ODCLFIELD Node fn args.
-func structargs(tl *types.Type, mustname bool) []*Node {
-       var args []*Node
-       gen := 0
-       for _, t := range tl.Fields().Slice() {
-               s := t.Sym
-               if mustname && (s == nil || s.Name == "_") {
-                       // invent a name so that we can refer to it in the trampoline
-                       s = lookupN(".anon", gen)
-                       gen++
-               }
-               a := symfield(s, t.Type)
-               a.Pos = t.Pos
-               a.SetIsDDD(t.IsDDD())
-               args = append(args, a)
-       }
-
-       return args
-}
-
-// Generate a wrapper function to convert from
-// a receiver of type T to a receiver of type U.
-// That is,
-//
-//     func (t T) M() {
-//             ...
-//     }
-//
-// already exists; this function generates
-//
-//     func (u U) M() {
-//             u.M()
-//     }
-//
-// where the types T and U are such that u.M() is valid
-// and calls the T.M method.
-// The resulting function is for use in method tables.
-//
-//     rcvr - U
-//     method - M func (t T)(), a TFIELD type struct
-//     newnam - the eventual mangled name of this function
-func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
-       if false && Debug.r != 0 {
-               fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
-       }
-
-       // Only generate (*T).M wrappers for T.M in T's own package.
-       if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
-               rcvr.Elem().Sym != nil && rcvr.Elem().Sym.Pkg != localpkg {
-               return
-       }
-
-       // Only generate I.M wrappers for I in I's own package
-       // but keep doing it for error.Error (was issue #29304).
-       if rcvr.IsInterface() && rcvr.Sym != nil && rcvr.Sym.Pkg != localpkg && rcvr != types.Errortype {
-               return
-       }
-
-       lineno = autogeneratedPos
-       dclcontext = PEXTERN
-
-       tfn := nod(OTFUNC, nil, nil)
-       tfn.Left = namedfield(".this", rcvr)
-       tfn.List.Set(structargs(method.Type.Params(), true))
-       tfn.Rlist.Set(structargs(method.Type.Results(), false))
-
-       fn := dclfunc(newnam, tfn)
-       fn.Func.SetDupok(true)
-
-       nthis := asNode(tfn.Type.Recv().Nname)
-
-       methodrcvr := method.Type.Recv().Type
-
-       // generate nil pointer check for better error
-       if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
-               // generating wrapper from *T to T.
-               n := nod(OIF, nil, nil)
-               n.Left = nod(OEQ, nthis, nodnil())
-               call := nod(OCALL, syslook("panicwrap"), nil)
-               n.Nbody.Set1(call)
-               fn.Nbody.Append(n)
-       }
-
-       dot := adddot(nodSym(OXDOT, nthis, method.Sym))
-
-       // generate call
-       // It's not possible to use a tail call when dynamic linking on ppc64le. The
-       // bad scenario is when a local call is made to the wrapper: the wrapper will
-       // call the implementation, which might be in a different module and so set
-       // the TOC to the appropriate value for that module. But if it returns
-       // directly to the wrapper's caller, nothing will reset it to the correct
-       // value for that function.
-       if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && Ctxt.Flag_dynlink) {
-               // generate tail call: adjust pointer receiver and jump to embedded method.
-               dot = dot.Left // skip final .M
-               // TODO(mdempsky): Remove dependency on dotlist.
-               if !dotlist[0].field.Type.IsPtr() {
-                       dot = nod(OADDR, dot, nil)
-               }
-               as := nod(OAS, nthis, convnop(dot, rcvr))
-               fn.Nbody.Append(as)
-               fn.Nbody.Append(nodSym(ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
-       } else {
-               fn.Func.SetWrapper(true) // ignore frame for panic+recover matching
-               call := nod(OCALL, dot, nil)
-               call.List.Set(paramNnames(tfn.Type))
-               call.SetIsDDD(tfn.Type.IsVariadic())
-               if method.Type.NumResults() > 0 {
-                       n := nod(ORETURN, nil, nil)
-                       n.List.Set1(call)
-                       call = n
-               }
-               fn.Nbody.Append(call)
-       }
-
-       if false && Debug.r != 0 {
-               dumplist("genwrapper body", fn.Nbody)
-       }
-
-       funcbody()
-       if debug_dclstack != 0 {
-               testdclstack()
-       }
-
-       fn = typecheck(fn, ctxStmt)
-
-       Curfn = fn
-       typecheckslice(fn.Nbody.Slice(), ctxStmt)
-
-       // Inline calls within (*T).M wrappers. This is safe because we only
-       // generate those wrappers within the same compilation unit as (T).M.
-       // TODO(mdempsky): Investigate why we can't enable this more generally.
-       if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym != nil {
-               inlcalls(fn)
-       }
-       escapeFuncs([]*Node{fn}, false)
-
-       Curfn = nil
-       xtop = append(xtop, fn)
-}
-
-func paramNnames(ft *types.Type) []*Node {
-       args := make([]*Node, ft.NumParams())
-       for i, f := range ft.Params().FieldSlice() {
-               args[i] = asNode(f.Nname)
-       }
-       return args
-}
-
-func hashmem(t *types.Type) *Node {
-       sym := Runtimepkg.Lookup("memhash")
-
-       n := newname(sym)
-       setNodeNameFunc(n)
-       n.Type = functype(nil, []*Node{
-               anonfield(types.NewPtr(t)),
-               anonfield(types.Types[TUINTPTR]),
-               anonfield(types.Types[TUINTPTR]),
-       }, []*Node{
-               anonfield(types.Types[TUINTPTR]),
-       })
-       return n
-}
-
-func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field, followptr bool) {
-       if t == nil {
-               return nil, false
-       }
-
-       path, ambig := dotpath(s, t, &m, ignorecase)
-       if path == nil {
-               if ambig {
-                       yyerror("%v.%v is ambiguous", t, s)
-               }
-               return nil, false
-       }
-
-       for _, d := range path {
-               if d.field.Type.IsPtr() {
-                       followptr = true
-                       break
-               }
-       }
-
-       if !m.IsMethod() {
-               yyerror("%v.%v is a field, not a method", t, s)
-               return nil, followptr
-       }
-
-       return m, followptr
-}
-
-func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool {
-       t0 := t
-       if t == nil {
-               return false
-       }
-
-       if t.IsInterface() {
-               i := 0
-               tms := t.Fields().Slice()
-               for _, im := range iface.Fields().Slice() {
-                       for i < len(tms) && tms[i].Sym != im.Sym {
-                               i++
-                       }
-                       if i == len(tms) {
-                               *m = im
-                               *samename = nil
-                               *ptr = 0
-                               return false
-                       }
-                       tm := tms[i]
-                       if !types.Identical(tm.Type, im.Type) {
-                               *m = im
-                               *samename = tm
-                               *ptr = 0
-                               return false
-                       }
-               }
-
-               return true
-       }
-
-       t = methtype(t)
-       var tms []*types.Field
-       if t != nil {
-               expandmeth(t)
-               tms = t.AllMethods().Slice()
-       }
-       i := 0
-       for _, im := range iface.Fields().Slice() {
-               if im.Broke() {
-                       continue
-               }
-               for i < len(tms) && tms[i].Sym != im.Sym {
-                       i++
-               }
-               if i == len(tms) {
-                       *m = im
-                       *samename, _ = ifacelookdot(im.Sym, t, true)
-                       *ptr = 0
-                       return false
-               }
-               tm := tms[i]
-               if tm.Nointerface() || !types.Identical(tm.Type, im.Type) {
-                       *m = im
-                       *samename = tm
-                       *ptr = 0
-                       return false
-               }
-               followptr := tm.Embedded == 2
-
-               // if pointer receiver in method,
-               // the method does not exist for value types.
-               rcvr := tm.Type.Recv().Type
-               if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !isifacemethod(tm.Type) {
-                       if false && Debug.r != 0 {
-                               yyerror("interface pointer mismatch")
-                       }
-
-                       *m = im
-                       *samename = nil
-                       *ptr = 1
-                       return false
-               }
-       }
-
-       // We're going to emit an OCONVIFACE.
-       // Call itabname so that (t, iface)
-       // gets added to itabs early, which allows
-       // us to de-virtualize calls through this
-       // type/interface pair later. See peekitabs in reflect.go
-       if isdirectiface(t0) && !iface.IsEmptyInterface() {
-               itabname(t0, iface)
-       }
-       return true
-}
-
-func listtreecopy(l []*Node, pos src.XPos) []*Node {
-       var out []*Node
-       for _, n := range l {
-               out = append(out, treecopy(n, pos))
-       }
-       return out
-}
-
-func liststmt(l []*Node) *Node {
-       n := nod(OBLOCK, nil, nil)
-       n.List.Set(l)
-       if len(l) != 0 {
-               n.Pos = l[0].Pos
-       }
-       return n
-}
-
-func (l Nodes) asblock() *Node {
-       n := nod(OBLOCK, nil, nil)
-       n.List = l
-       if l.Len() != 0 {
-               n.Pos = l.First().Pos
-       }
-       return n
-}
-
-func ngotype(n *Node) *types.Sym {
-       if n.Type != nil {
-               return typenamesym(n.Type)
-       }
-       return nil
-}
-
-// The result of addinit MUST be assigned back to n, e.g.
-//     n.Left = addinit(n.Left, init)
-func addinit(n *Node, init []*Node) *Node {
-       if len(init) == 0 {
-               return n
-       }
-       if n.mayBeShared() {
-               // Introduce OCONVNOP to hold init list.
-               n = nod(OCONVNOP, n, nil)
-               n.Type = n.Left.Type
-               n.SetTypecheck(1)
-       }
-
-       n.Ninit.Prepend(init...)
-       n.SetHasCall(true)
-       return n
-}
-
-// The linker uses the magic symbol prefixes "go." and "type."
-// Avoid potential confusion between import paths and symbols
-// by rejecting these reserved imports for now. Also, people
-// "can do weird things in GOPATH and we'd prefer they didn't
-// do _that_ weird thing" (per rsc). See also #4257.
-var reservedimports = []string{
-       "go",
-       "type",
-}
-
-func isbadimport(path string, allowSpace bool) bool {
-       if strings.Contains(path, "\x00") {
-               yyerror("import path contains NUL")
-               return true
-       }
-
-       for _, ri := range reservedimports {
-               if path == ri {
-                       yyerror("import path %q is reserved and cannot be used", path)
-                       return true
-               }
-       }
-
-       for _, r := range path {
-               if r == utf8.RuneError {
-                       yyerror("import path contains invalid UTF-8 sequence: %q", path)
-                       return true
-               }
-
-               if r < 0x20 || r == 0x7f {
-                       yyerror("import path contains control character: %q", path)
-                       return true
-               }
-
-               if r == '\\' {
-                       yyerror("import path contains backslash; use slash: %q", path)
-                       return true
-               }
-
-               if !allowSpace && unicode.IsSpace(r) {
-                       yyerror("import path contains space character: %q", path)
-                       return true
-               }
-
-               if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
-                       yyerror("import path contains invalid character '%c': %q", r, path)
-                       return true
-               }
-       }
-
-       return false
-}
-
-// Can this type be stored directly in an interface word?
-// Yes, if the representation is a single pointer.
-func isdirectiface(t *types.Type) bool {
-       if t.Broke() {
-               return false
-       }
-
-       switch t.Etype {
-       case TPTR:
-               // Pointers to notinheap types must be stored indirectly. See issue 42076.
-               return !t.Elem().NotInHeap()
-       case TCHAN,
-               TMAP,
-               TFUNC,
-               TUNSAFEPTR:
-               return true
-
-       case TARRAY:
-               // Array of 1 direct iface type can be direct.
-               return t.NumElem() == 1 && isdirectiface(t.Elem())
-
-       case TSTRUCT:
-               // Struct with 1 field of direct iface type can be direct.
-               return t.NumFields() == 1 && isdirectiface(t.Field(0).Type)
-       }
-
-       return false
-}
-
-// itabType loads the _type field from a runtime.itab struct.
-func itabType(itab *Node) *Node {
-       typ := nodSym(ODOTPTR, itab, nil)
-       typ.Type = types.NewPtr(types.Types[TUINT8])
-       typ.SetTypecheck(1)
-       typ.Xoffset = int64(Widthptr) // offset of _type in runtime.itab
-       typ.SetBounded(true)          // guaranteed not to fault
-       return typ
-}
-
-// ifaceData loads the data field from an interface.
-// The concrete type must be known to have type t.
-// It follows the pointer if !isdirectiface(t).
-func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
-       if t.IsInterface() {
-               Fatalf("ifaceData interface: %v", t)
-       }
-       ptr := nodlSym(pos, OIDATA, n, nil)
-       if isdirectiface(t) {
-               ptr.Type = t
-               ptr.SetTypecheck(1)
-               return ptr
-       }
-       ptr.Type = types.NewPtr(t)
-       ptr.SetTypecheck(1)
-       ind := nodl(pos, ODEREF, ptr, nil)
-       ind.Type = t
-       ind.SetTypecheck(1)
-       ind.SetBounded(true)
-       return ind
-}
-
-// typePos returns the position associated with t.
-// This is where t was declared or where it appeared as a type expression.
-func typePos(t *types.Type) src.XPos {
-       n := asNode(t.Nod)
-       if n == nil || !n.Pos.IsKnown() {
-               Fatalf("bad type: %v", t)
-       }
-       return n.Pos
-}

diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
deleted file mode 100644 (file)
index 8d9fbe3..0000000
--- a/src/cmd/compile/internal/gc/swt.go
+++ /dev/null
@@ -1,756 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
-       "sort"
-)
-
-// typecheckswitch typechecks a switch statement.
-func typecheckswitch(n *Node) {
-       typecheckslice(n.Ninit.Slice(), ctxStmt)
-       if n.Left != nil && n.Left.Op == OTYPESW {
-               typecheckTypeSwitch(n)
-       } else {
-               typecheckExprSwitch(n)
-       }
-}
-
-func typecheckTypeSwitch(n *Node) {
-       n.Left.Right = typecheck(n.Left.Right, ctxExpr)
-       t := n.Left.Right.Type
-       if t != nil && !t.IsInterface() {
-               yyerrorl(n.Pos, "cannot type switch on non-interface value %L", n.Left.Right)
-               t = nil
-       }
-
-       // We don't actually declare the type switch's guarded
-       // declaration itself. So if there are no cases, we won't
-       // notice that it went unused.
-       if v := n.Left.Left; v != nil && !v.isBlank() && n.List.Len() == 0 {
-               yyerrorl(v.Pos, "%v declared but not used", v.Sym)
-       }
-
-       var defCase, nilCase *Node
-       var ts typeSet
-       for _, ncase := range n.List.Slice() {
-               ls := ncase.List.Slice()
-               if len(ls) == 0 { // default:
-                       if defCase != nil {
-                               yyerrorl(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
-                       } else {
-                               defCase = ncase
-                       }
-               }
-
-               for i := range ls {
-                       ls[i] = typecheck(ls[i], ctxExpr|ctxType)
-                       n1 := ls[i]
-                       if t == nil || n1.Type == nil {
-                               continue
-                       }
-
-                       var missing, have *types.Field
-                       var ptr int
-                       switch {
-                       case n1.isNil(): // case nil:
-                               if nilCase != nil {
-                                       yyerrorl(ncase.Pos, "multiple nil cases in type switch (first at %v)", nilCase.Line())
-                               } else {
-                                       nilCase = ncase
-                               }
-                       case n1.Op != OTYPE:
-                               yyerrorl(ncase.Pos, "%L is not a type", n1)
-                       case !n1.Type.IsInterface() && !implements(n1.Type, t, &missing, &have, &ptr) && !missing.Broke():
-                               if have != nil && !have.Broke() {
-                                       yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-                                               " (wrong type for %v method)\n\thave %v%S\n\twant %v%S", n.Left.Right, n1.Type, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-                               } else if ptr != 0 {
-                                       yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-                                               " (%v method has pointer receiver)", n.Left.Right, n1.Type, missing.Sym)
-                               } else {
-                                       yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-                                               " (missing %v method)", n.Left.Right, n1.Type, missing.Sym)
-                               }
-                       }
-
-                       if n1.Op == OTYPE {
-                               ts.add(ncase.Pos, n1.Type)
-                       }
-               }
-
-               if ncase.Rlist.Len() != 0 {
-                       // Assign the clause variable's type.
-                       vt := t
-                       if len(ls) == 1 {
-                               if ls[0].Op == OTYPE {
-                                       vt = ls[0].Type
-                               } else if ls[0].Op != OLITERAL { // TODO(mdempsky): Should be !ls[0].isNil()
-                                       // Invalid single-type case;
-                                       // mark variable as broken.
-                                       vt = nil
-                               }
-                       }
-
-                       // TODO(mdempsky): It should be possible to
-                       // still typecheck the case body.
-                       if vt == nil {
-                               continue
-                       }
-
-                       nvar := ncase.Rlist.First()
-                       nvar.Type = vt
-                       nvar = typecheck(nvar, ctxExpr|ctxAssign)
-                       ncase.Rlist.SetFirst(nvar)
-               }
-
-               typecheckslice(ncase.Nbody.Slice(), ctxStmt)
-       }
-}
-
-type typeSet struct {
-       m map[string][]typeSetEntry
-}
-
-type typeSetEntry struct {
-       pos src.XPos
-       typ *types.Type
-}
-
-func (s *typeSet) add(pos src.XPos, typ *types.Type) {
-       if s.m == nil {
-               s.m = make(map[string][]typeSetEntry)
-       }
-
-       // LongString does not uniquely identify types, so we need to
-       // disambiguate collisions with types.Identical.
-       // TODO(mdempsky): Add a method that *is* unique.
-       ls := typ.LongString()
-       prevs := s.m[ls]
-       for _, prev := range prevs {
-               if types.Identical(typ, prev.typ) {
-                       yyerrorl(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, linestr(prev.pos))
-                       return
-               }
-       }
-       s.m[ls] = append(prevs, typeSetEntry{pos, typ})
-}
-
-func typecheckExprSwitch(n *Node) {
-       t := types.Types[TBOOL]
-       if n.Left != nil {
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               t = n.Left.Type
-       }
-
-       var nilonly string
-       if t != nil {
-               switch {
-               case t.IsMap():
-                       nilonly = "map"
-               case t.Etype == TFUNC:
-                       nilonly = "func"
-               case t.IsSlice():
-                       nilonly = "slice"
-
-               case !IsComparable(t):
-                       if t.IsStruct() {
-                               yyerrorl(n.Pos, "cannot switch on %L (struct containing %v cannot be compared)", n.Left, IncomparableField(t).Type)
-                       } else {
-                               yyerrorl(n.Pos, "cannot switch on %L", n.Left)
-                       }
-                       t = nil
-               }
-       }
-
-       var defCase *Node
-       var cs constSet
-       for _, ncase := range n.List.Slice() {
-               ls := ncase.List.Slice()
-               if len(ls) == 0 { // default:
-                       if defCase != nil {
-                               yyerrorl(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
-                       } else {
-                               defCase = ncase
-                       }
-               }
-
-               for i := range ls {
-                       setlineno(ncase)
-                       ls[i] = typecheck(ls[i], ctxExpr)
-                       ls[i] = defaultlit(ls[i], t)
-                       n1 := ls[i]
-                       if t == nil || n1.Type == nil {
-                               continue
-                       }
-
-                       if nilonly != "" && !n1.isNil() {
-                               yyerrorl(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
-                       } else if t.IsInterface() && !n1.Type.IsInterface() && !IsComparable(n1.Type) {
-                               yyerrorl(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)
-                       } else {
-                               op1, _ := assignop(n1.Type, t)
-                               op2, _ := assignop(t, n1.Type)
-                               if op1 == OXXX && op2 == OXXX {
-                                       if n.Left != nil {
-                                               yyerrorl(ncase.Pos, "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left, n1.Type, t)
-                                       } else {
-                                               yyerrorl(ncase.Pos, "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type)
-                                       }
-                               }
-                       }
-
-                       // Don't check for duplicate bools. Although the spec allows it,
-                       // (1) the compiler hasn't checked it in the past, so compatibility mandates it, and
-                       // (2) it would disallow useful things like
-                       //       case GOARCH == "arm" && GOARM == "5":
-                       //       case GOARCH == "arm":
-                       //     which would both evaluate to false for non-ARM compiles.
-                       if !n1.Type.IsBoolean() {
-                               cs.add(ncase.Pos, n1, "case", "switch")
-                       }
-               }
-
-               typecheckslice(ncase.Nbody.Slice(), ctxStmt)
-       }
-}
-
-// walkswitch walks a switch statement.
-func walkswitch(sw *Node) {
-       // Guard against double walk, see #25776.
-       if sw.List.Len() == 0 && sw.Nbody.Len() > 0 {
-               return // Was fatal, but eliminating every possible source of double-walking is hard
-       }
-
-       if sw.Left != nil && sw.Left.Op == OTYPESW {
-               walkTypeSwitch(sw)
-       } else {
-               walkExprSwitch(sw)
-       }
-}
-
-// walkExprSwitch generates an AST implementing sw.  sw is an
-// expression switch.
-func walkExprSwitch(sw *Node) {
-       lno := setlineno(sw)
-
-       cond := sw.Left
-       sw.Left = nil
-
-       // convert switch {...} to switch true {...}
-       if cond == nil {
-               cond = nodbool(true)
-               cond = typecheck(cond, ctxExpr)
-               cond = defaultlit(cond, nil)
-       }
-
-       // Given "switch string(byteslice)",
-       // with all cases being side-effect free,
-       // use a zero-cost alias of the byte slice.
-       // Do this before calling walkexpr on cond,
-       // because walkexpr will lower the string
-       // conversion into a runtime call.
-       // See issue 24937 for more discussion.
-       if cond.Op == OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
-               cond.Op = OBYTES2STRTMP
-       }
-
-       cond = walkexpr(cond, &sw.Ninit)
-       if cond.Op != OLITERAL {
-               cond = copyexpr(cond, cond.Type, &sw.Nbody)
-       }
-
-       lineno = lno
-
-       s := exprSwitch{
-               exprname: cond,
-       }
-
-       var defaultGoto *Node
-       var body Nodes
-       for _, ncase := range sw.List.Slice() {
-               label := autolabel(".s")
-               jmp := npos(ncase.Pos, nodSym(OGOTO, nil, label))
-
-               // Process case dispatch.
-               if ncase.List.Len() == 0 {
-                       if defaultGoto != nil {
-                               Fatalf("duplicate default case not detected during typechecking")
-                       }
-                       defaultGoto = jmp
-               }
-
-               for _, n1 := range ncase.List.Slice() {
-                       s.Add(ncase.Pos, n1, jmp)
-               }
-
-               // Process body.
-               body.Append(npos(ncase.Pos, nodSym(OLABEL, nil, label)))
-               body.Append(ncase.Nbody.Slice()...)
-               if fall, pos := hasFall(ncase.Nbody.Slice()); !fall {
-                       br := nod(OBREAK, nil, nil)
-                       br.Pos = pos
-                       body.Append(br)
-               }
-       }
-       sw.List.Set(nil)
-
-       if defaultGoto == nil {
-               br := nod(OBREAK, nil, nil)
-               br.Pos = br.Pos.WithNotStmt()
-               defaultGoto = br
-       }
-
-       s.Emit(&sw.Nbody)
-       sw.Nbody.Append(defaultGoto)
-       sw.Nbody.AppendNodes(&body)
-       walkstmtlist(sw.Nbody.Slice())
-}
-
-// An exprSwitch walks an expression switch.
-type exprSwitch struct {
-       exprname *Node // value being switched on
-
-       done    Nodes
-       clauses []exprClause
-}
-
-type exprClause struct {
-       pos    src.XPos
-       lo, hi *Node
-       jmp    *Node
-}
-
-func (s *exprSwitch) Add(pos src.XPos, expr, jmp *Node) {
-       c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
-       if okforcmp[s.exprname.Type.Etype] && expr.Op == OLITERAL {
-               s.clauses = append(s.clauses, c)
-               return
-       }
-
-       s.flush()
-       s.clauses = append(s.clauses, c)
-       s.flush()
-}
-
-func (s *exprSwitch) Emit(out *Nodes) {
-       s.flush()
-       out.AppendNodes(&s.done)
-}
-
-func (s *exprSwitch) flush() {
-       cc := s.clauses
-       s.clauses = nil
-       if len(cc) == 0 {
-               return
-       }
-
-       // Caution: If len(cc) == 1, then cc[0] might not an OLITERAL.
-       // The code below is structured to implicitly handle this case
-       // (e.g., sort.Slice doesn't need to invoke the less function
-       // when there's only a single slice element).
-
-       if s.exprname.Type.IsString() && len(cc) >= 2 {
-               // Sort strings by length and then by value. It is
-               // much cheaper to compare lengths than values, and
-               // all we need here is consistency. We respect this
-               // sorting below.
-               sort.Slice(cc, func(i, j int) bool {
-                       si := cc[i].lo.StringVal()
-                       sj := cc[j].lo.StringVal()
-                       if len(si) != len(sj) {
-                               return len(si) < len(sj)
-                       }
-                       return si < sj
-               })
-
-               // runLen returns the string length associated with a
-               // particular run of exprClauses.
-               runLen := func(run []exprClause) int64 { return int64(len(run[0].lo.StringVal())) }
-
-               // Collapse runs of consecutive strings with the same length.
-               var runs [][]exprClause
-               start := 0
-               for i := 1; i < len(cc); i++ {
-                       if runLen(cc[start:]) != runLen(cc[i:]) {
-                               runs = append(runs, cc[start:i])
-                               start = i
-                       }
-               }
-               runs = append(runs, cc[start:])
-
-               // Perform two-level binary search.
-               nlen := nod(OLEN, s.exprname, nil)
-               binarySearch(len(runs), &s.done,
-                       func(i int) *Node {
-                               return nod(OLE, nlen, nodintconst(runLen(runs[i-1])))
-                       },
-                       func(i int, nif *Node) {
-                               run := runs[i]
-                               nif.Left = nod(OEQ, nlen, nodintconst(runLen(run)))
-                               s.search(run, &nif.Nbody)
-                       },
-               )
-               return
-       }
-
-       sort.Slice(cc, func(i, j int) bool {
-               return compareOp(cc[i].lo.Val(), OLT, cc[j].lo.Val())
-       })
-
-       // Merge consecutive integer cases.
-       if s.exprname.Type.IsInteger() {
-               merged := cc[:1]
-               for _, c := range cc[1:] {
-                       last := &merged[len(merged)-1]
-                       if last.jmp == c.jmp && last.hi.Int64Val()+1 == c.lo.Int64Val() {
-                               last.hi = c.lo
-                       } else {
-                               merged = append(merged, c)
-                       }
-               }
-               cc = merged
-       }
-
-       s.search(cc, &s.done)
-}
-
-func (s *exprSwitch) search(cc []exprClause, out *Nodes) {
-       binarySearch(len(cc), out,
-               func(i int) *Node {
-                       return nod(OLE, s.exprname, cc[i-1].hi)
-               },
-               func(i int, nif *Node) {
-                       c := &cc[i]
-                       nif.Left = c.test(s.exprname)
-                       nif.Nbody.Set1(c.jmp)
-               },
-       )
-}
-
-func (c *exprClause) test(exprname *Node) *Node {
-       // Integer range.
-       if c.hi != c.lo {
-               low := nodl(c.pos, OGE, exprname, c.lo)
-               high := nodl(c.pos, OLE, exprname, c.hi)
-               return nodl(c.pos, OANDAND, low, high)
-       }
-
-       // Optimize "switch true { ...}" and "switch false { ... }".
-       if Isconst(exprname, CTBOOL) && !c.lo.Type.IsInterface() {
-               if exprname.BoolVal() {
-                       return c.lo
-               } else {
-                       return nodl(c.pos, ONOT, c.lo, nil)
-               }
-       }
-
-       return nodl(c.pos, OEQ, exprname, c.lo)
-}
-
-func allCaseExprsAreSideEffectFree(sw *Node) bool {
-       // In theory, we could be more aggressive, allowing any
-       // side-effect-free expressions in cases, but it's a bit
-       // tricky because some of that information is unavailable due
-       // to the introduction of temporaries during order.
-       // Restricting to constants is simple and probably powerful
-       // enough.
-
-       for _, ncase := range sw.List.Slice() {
-               if ncase.Op != OCASE {
-                       Fatalf("switch string(byteslice) bad op: %v", ncase.Op)
-               }
-               for _, v := range ncase.List.Slice() {
-                       if v.Op != OLITERAL {
-                               return false
-                       }
-               }
-       }
-       return true
-}
-
-// hasFall reports whether stmts ends with a "fallthrough" statement.
-func hasFall(stmts []*Node) (bool, src.XPos) {
-       // Search backwards for the index of the fallthrough
-       // statement. Do not assume it'll be in the last
-       // position, since in some cases (e.g. when the statement
-       // list contains autotmp_ variables), one or more OVARKILL
-       // nodes will be at the end of the list.
-
-       i := len(stmts) - 1
-       for i >= 0 && stmts[i].Op == OVARKILL {
-               i--
-       }
-       if i < 0 {
-               return false, src.NoXPos
-       }
-       return stmts[i].Op == OFALL, stmts[i].Pos
-}
-
-// walkTypeSwitch generates an AST that implements sw, where sw is a
-// type switch.
-func walkTypeSwitch(sw *Node) {
-       var s typeSwitch
-       s.facename = sw.Left.Right
-       sw.Left = nil
-
-       s.facename = walkexpr(s.facename, &sw.Ninit)
-       s.facename = copyexpr(s.facename, s.facename.Type, &sw.Nbody)
-       s.okname = temp(types.Types[TBOOL])
-
-       // Get interface descriptor word.
-       // For empty interfaces this will be the type.
-       // For non-empty interfaces this will be the itab.
-       itab := nod(OITAB, s.facename, nil)
-
-       // For empty interfaces, do:
-       //     if e._type == nil {
-       //         do nil case if it exists, otherwise default
-       //     }
-       //     h := e._type.hash
-       // Use a similar strategy for non-empty interfaces.
-       ifNil := nod(OIF, nil, nil)
-       ifNil.Left = nod(OEQ, itab, nodnil())
-       lineno = lineno.WithNotStmt() // disable statement marks after the first check.
-       ifNil.Left = typecheck(ifNil.Left, ctxExpr)
-       ifNil.Left = defaultlit(ifNil.Left, nil)
-       // ifNil.Nbody assigned at end.
-       sw.Nbody.Append(ifNil)
-
-       // Load hash from type or itab.
-       dotHash := nodSym(ODOTPTR, itab, nil)
-       dotHash.Type = types.Types[TUINT32]
-       dotHash.SetTypecheck(1)
-       if s.facename.Type.IsEmptyInterface() {
-               dotHash.Xoffset = int64(2 * Widthptr) // offset of hash in runtime._type
-       } else {
-               dotHash.Xoffset = int64(2 * Widthptr) // offset of hash in runtime.itab
-       }
-       dotHash.SetBounded(true) // guaranteed not to fault
-       s.hashname = copyexpr(dotHash, dotHash.Type, &sw.Nbody)
-
-       br := nod(OBREAK, nil, nil)
-       var defaultGoto, nilGoto *Node
-       var body Nodes
-       for _, ncase := range sw.List.Slice() {
-               var caseVar *Node
-               if ncase.Rlist.Len() != 0 {
-                       caseVar = ncase.Rlist.First()
-               }
-
-               // For single-type cases with an interface type,
-               // we initialize the case variable as part of the type assertion.
-               // In other cases, we initialize it in the body.
-               var singleType *types.Type
-               if ncase.List.Len() == 1 && ncase.List.First().Op == OTYPE {
-                       singleType = ncase.List.First().Type
-               }
-               caseVarInitialized := false
-
-               label := autolabel(".s")
-               jmp := npos(ncase.Pos, nodSym(OGOTO, nil, label))
-
-               if ncase.List.Len() == 0 { // default:
-                       if defaultGoto != nil {
-                               Fatalf("duplicate default case not detected during typechecking")
-                       }
-                       defaultGoto = jmp
-               }
-
-               for _, n1 := range ncase.List.Slice() {
-                       if n1.isNil() { // case nil:
-                               if nilGoto != nil {
-                                       Fatalf("duplicate nil case not detected during typechecking")
-                               }
-                               nilGoto = jmp
-                               continue
-                       }
-
-                       if singleType != nil && singleType.IsInterface() {
-                               s.Add(ncase.Pos, n1.Type, caseVar, jmp)
-                               caseVarInitialized = true
-                       } else {
-                               s.Add(ncase.Pos, n1.Type, nil, jmp)
-                       }
-               }
-
-               body.Append(npos(ncase.Pos, nodSym(OLABEL, nil, label)))
-               if caseVar != nil && !caseVarInitialized {
-                       val := s.facename
-                       if singleType != nil {
-                               // We have a single concrete type. Extract the data.
-                               if singleType.IsInterface() {
-                                       Fatalf("singleType interface should have been handled in Add")
-                               }
-                               val = ifaceData(ncase.Pos, s.facename, singleType)
-                       }
-                       l := []*Node{
-                               nodl(ncase.Pos, ODCL, caseVar, nil),
-                               nodl(ncase.Pos, OAS, caseVar, val),
-                       }
-                       typecheckslice(l, ctxStmt)
-                       body.Append(l...)
-               }
-               body.Append(ncase.Nbody.Slice()...)
-               body.Append(br)
-       }
-       sw.List.Set(nil)
-
-       if defaultGoto == nil {
-               defaultGoto = br
-       }
-       if nilGoto == nil {
-               nilGoto = defaultGoto
-       }
-       ifNil.Nbody.Set1(nilGoto)
-
-       s.Emit(&sw.Nbody)
-       sw.Nbody.Append(defaultGoto)
-       sw.Nbody.AppendNodes(&body)
-
-       walkstmtlist(sw.Nbody.Slice())
-}
-
-// A typeSwitch walks a type switch.
-type typeSwitch struct {
-       // Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
-       facename *Node // value being type-switched on
-       hashname *Node // type hash of the value being type-switched on
-       okname   *Node // boolean used for comma-ok type assertions
-
-       done    Nodes
-       clauses []typeClause
-}
-
-type typeClause struct {
-       hash uint32
-       body Nodes
-}
-
-func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *Node) {
-       var body Nodes
-       if caseVar != nil {
-               l := []*Node{
-                       nodl(pos, ODCL, caseVar, nil),
-                       nodl(pos, OAS, caseVar, nil),
-               }
-               typecheckslice(l, ctxStmt)
-               body.Append(l...)
-       } else {
-               caseVar = nblank
-       }
-
-       // cv, ok = iface.(type)
-       as := nodl(pos, OAS2, nil, nil)
-       as.List.Set2(caseVar, s.okname) // cv, ok =
-       dot := nodl(pos, ODOTTYPE, s.facename, nil)
-       dot.Type = typ // iface.(type)
-       as.Rlist.Set1(dot)
-       as = typecheck(as, ctxStmt)
-       as = walkexpr(as, &body)
-       body.Append(as)
-
-       // if ok { goto label }
-       nif := nodl(pos, OIF, nil, nil)
-       nif.Left = s.okname
-       nif.Nbody.Set1(jmp)
-       body.Append(nif)
-
-       if !typ.IsInterface() {
-               s.clauses = append(s.clauses, typeClause{
-                       hash: typehash(typ),
-                       body: body,
-               })
-               return
-       }
-
-       s.flush()
-       s.done.AppendNodes(&body)
-}
-
-func (s *typeSwitch) Emit(out *Nodes) {
-       s.flush()
-       out.AppendNodes(&s.done)
-}
-
-func (s *typeSwitch) flush() {
-       cc := s.clauses
-       s.clauses = nil
-       if len(cc) == 0 {
-               return
-       }
-
-       sort.Slice(cc, func(i, j int) bool { return cc[i].hash < cc[j].hash })
-
-       // Combine adjacent cases with the same hash.
-       merged := cc[:1]
-       for _, c := range cc[1:] {
-               last := &merged[len(merged)-1]
-               if last.hash == c.hash {
-                       last.body.AppendNodes(&c.body)
-               } else {
-                       merged = append(merged, c)
-               }
-       }
-       cc = merged
-
-       binarySearch(len(cc), &s.done,
-               func(i int) *Node {
-                       return nod(OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
-               },
-               func(i int, nif *Node) {
-                       // TODO(mdempsky): Omit hash equality check if
-                       // there's only one type.
-                       c := cc[i]
-                       nif.Left = nod(OEQ, s.hashname, nodintconst(int64(c.hash)))
-                       nif.Nbody.AppendNodes(&c.body)
-               },
-       )
-}
-
-// binarySearch constructs a binary search tree for handling n cases,
-// and appends it to out. It's used for efficiently implementing
-// switch statements.
-//
-// less(i) should return a boolean expression. If it evaluates true,
-// then cases before i will be tested; otherwise, cases i and later.
-//
-// base(i, nif) should setup nif (an OIF node) to test case i. In
-// particular, it should set nif.Left and nif.Nbody.
-func binarySearch(n int, out *Nodes, less func(i int) *Node, base func(i int, nif *Node)) {
-       const binarySearchMin = 4 // minimum number of cases for binary search
-
-       var do func(lo, hi int, out *Nodes)
-       do = func(lo, hi int, out *Nodes) {
-               n := hi - lo
-               if n < binarySearchMin {
-                       for i := lo; i < hi; i++ {
-                               nif := nod(OIF, nil, nil)
-                               base(i, nif)
-                               lineno = lineno.WithNotStmt()
-                               nif.Left = typecheck(nif.Left, ctxExpr)
-                               nif.Left = defaultlit(nif.Left, nil)
-                               out.Append(nif)
-                               out = &nif.Rlist
-                       }
-                       return
-               }
-
-               half := lo + n/2
-               nif := nod(OIF, nil, nil)
-               nif.Left = less(half)
-               lineno = lineno.WithNotStmt()
-               nif.Left = typecheck(nif.Left, ctxExpr)
-               nif.Left = defaultlit(nif.Left, nil)
-               do(lo, half, &nif.Nbody)
-               do(half, hi, &nif.Rlist)
-               out.Append(nif)
-       }
-
-       do(0, n, out)
-}

diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
deleted file mode 100644 (file)
index 4335833..0000000
--- a/src/cmd/compile/internal/gc/syntax.go
+++ /dev/null
@@ -1,1191 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// “Abstract” syntax representation.
-
-package gc
-
-import (
-       "cmd/compile/internal/ssa"
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
-       "sort"
-)
-
-// A Node is a single node in the syntax tree.
-// Actually the syntax tree is a syntax DAG, because there is only one
-// node with Op=ONAME for a given instance of a variable x.
-// The same is true for Op=OTYPE and Op=OLITERAL. See Node.mayBeShared.
-type Node struct {
-       // Tree structure.
-       // Generic recursive walks should follow these fields.
-       Left  *Node
-       Right *Node
-       Ninit Nodes
-       Nbody Nodes
-       List  Nodes
-       Rlist Nodes
-
-       // most nodes
-       Type *types.Type
-       Orig *Node // original form, for printing, and tracking copies of ONAMEs
-
-       // func
-       Func *Func
-
-       // ONAME, OTYPE, OPACK, OLABEL, some OLITERAL
-       Name *Name
-
-       Sym *types.Sym  // various
-       E   interface{} // Opt or Val, see methods below
-
-       // Various. Usually an offset into a struct. For example:
-       // - ONAME nodes that refer to local variables use it to identify their stack frame position.
-       // - ODOT, ODOTPTR, and ORESULT use it to indicate offset relative to their base address.
-       // - OSTRUCTKEY uses it to store the named field's offset.
-       // - Named OLITERALs use it to store their ambient iota value.
-       // - OINLMARK stores an index into the inlTree data structure.
-       // - OCLOSURE uses it to store ambient iota value, if any.
-       // Possibly still more uses. If you find any, document them.
-       Xoffset int64
-
-       Pos src.XPos
-
-       flags bitset32
-
-       Esc uint16 // EscXXX
-
-       Op  Op
-       aux uint8
-}
-
-func (n *Node) ResetAux() {
-       n.aux = 0
-}
-
-func (n *Node) SubOp() Op {
-       switch n.Op {
-       case OASOP, ONAME:
-       default:
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       return Op(n.aux)
-}
-
-func (n *Node) SetSubOp(op Op) {
-       switch n.Op {
-       case OASOP, ONAME:
-       default:
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       n.aux = uint8(op)
-}
-
-func (n *Node) IndexMapLValue() bool {
-       if n.Op != OINDEXMAP {
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       return n.aux != 0
-}
-
-func (n *Node) SetIndexMapLValue(b bool) {
-       if n.Op != OINDEXMAP {
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       if b {
-               n.aux = 1
-       } else {
-               n.aux = 0
-       }
-}
-
-func (n *Node) TChanDir() types.ChanDir {
-       if n.Op != OTCHAN {
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       return types.ChanDir(n.aux)
-}
-
-func (n *Node) SetTChanDir(dir types.ChanDir) {
-       if n.Op != OTCHAN {
-               Fatalf("unexpected op: %v", n.Op)
-       }
-       n.aux = uint8(dir)
-}
-
-func (n *Node) IsSynthetic() bool {
-       name := n.Sym.Name
-       return name[0] == '.' || name[0] == '~'
-}
-
-// IsAutoTmp indicates if n was created by the compiler as a temporary,
-// based on the setting of the .AutoTemp flag in n's Name.
-func (n *Node) IsAutoTmp() bool {
-       if n == nil || n.Op != ONAME {
-               return false
-       }
-       return n.Name.AutoTemp()
-}
-
-const (
-       nodeClass, _     = iota, 1 << iota // PPARAM, PAUTO, PEXTERN, etc; three bits; first in the list because frequently accessed
-       _, _                               // second nodeClass bit
-       _, _                               // third nodeClass bit
-       nodeWalkdef, _                     // tracks state during typecheckdef; 2 == loop detected; two bits
-       _, _                               // second nodeWalkdef bit
-       nodeTypecheck, _                   // tracks state during typechecking; 2 == loop detected; two bits
-       _, _                               // second nodeTypecheck bit
-       nodeInitorder, _                   // tracks state during init1; two bits
-       _, _                               // second nodeInitorder bit
-       _, nodeHasBreak
-       _, nodeNoInline  // used internally by inliner to indicate that a function call should not be inlined; set for OCALLFUNC and OCALLMETH only
-       _, nodeImplicit  // implicit OADDR or ODEREF; ++/-- statement represented as OASOP
-       _, nodeIsDDD     // is the argument variadic
-       _, nodeDiag      // already printed error about this
-       _, nodeColas     // OAS resulting from :=
-       _, nodeNonNil    // guaranteed to be non-nil
-       _, nodeTransient // storage can be reused immediately after this statement
-       _, nodeBounded   // bounds check unnecessary
-       _, nodeHasCall   // expression contains a function call
-       _, nodeLikely    // if statement condition likely
-       _, nodeHasVal    // node.E contains a Val
-       _, nodeHasOpt    // node.E contains an Opt
-       _, nodeEmbedded  // ODCLFIELD embedded type
-)
-
-func (n *Node) Class() Class     { return Class(n.flags.get3(nodeClass)) }
-func (n *Node) Walkdef() uint8   { return n.flags.get2(nodeWalkdef) }
-func (n *Node) Typecheck() uint8 { return n.flags.get2(nodeTypecheck) }
-func (n *Node) Initorder() uint8 { return n.flags.get2(nodeInitorder) }
-
-func (n *Node) HasBreak() bool  { return n.flags&nodeHasBreak != 0 }
-func (n *Node) NoInline() bool  { return n.flags&nodeNoInline != 0 }
-func (n *Node) Implicit() bool  { return n.flags&nodeImplicit != 0 }
-func (n *Node) IsDDD() bool     { return n.flags&nodeIsDDD != 0 }
-func (n *Node) Diag() bool      { return n.flags&nodeDiag != 0 }
-func (n *Node) Colas() bool     { return n.flags&nodeColas != 0 }
-func (n *Node) NonNil() bool    { return n.flags&nodeNonNil != 0 }
-func (n *Node) Transient() bool { return n.flags&nodeTransient != 0 }
-func (n *Node) Bounded() bool   { return n.flags&nodeBounded != 0 }
-func (n *Node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
-func (n *Node) Likely() bool    { return n.flags&nodeLikely != 0 }
-func (n *Node) HasVal() bool    { return n.flags&nodeHasVal != 0 }
-func (n *Node) HasOpt() bool    { return n.flags&nodeHasOpt != 0 }
-func (n *Node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
-
-func (n *Node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
-func (n *Node) SetWalkdef(b uint8)   { n.flags.set2(nodeWalkdef, b) }
-func (n *Node) SetTypecheck(b uint8) { n.flags.set2(nodeTypecheck, b) }
-func (n *Node) SetInitorder(b uint8) { n.flags.set2(nodeInitorder, b) }
-
-func (n *Node) SetHasBreak(b bool)  { n.flags.set(nodeHasBreak, b) }
-func (n *Node) SetNoInline(b bool)  { n.flags.set(nodeNoInline, b) }
-func (n *Node) SetImplicit(b bool)  { n.flags.set(nodeImplicit, b) }
-func (n *Node) SetIsDDD(b bool)     { n.flags.set(nodeIsDDD, b) }
-func (n *Node) SetDiag(b bool)      { n.flags.set(nodeDiag, b) }
-func (n *Node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
-func (n *Node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
-func (n *Node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
-func (n *Node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-func (n *Node) SetHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
-func (n *Node) SetHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
-func (n *Node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
-
-// MarkNonNil marks a pointer n as being guaranteed non-nil,
-// on all code paths, at all times.
-// During conversion to SSA, non-nil pointers won't have nil checks
-// inserted before dereferencing. See state.exprPtr.
-func (n *Node) MarkNonNil() {
-       if !n.Type.IsPtr() && !n.Type.IsUnsafePtr() {
-               Fatalf("MarkNonNil(%v), type %v", n, n.Type)
-       }
-       n.flags.set(nodeNonNil, true)
-}
-
-// SetBounded indicates whether operation n does not need safety checks.
-// When n is an index or slice operation, n does not need bounds checks.
-// When n is a dereferencing operation, n does not need nil checks.
-// When n is a makeslice+copy operation, n does not need length and cap checks.
-func (n *Node) SetBounded(b bool) {
-       switch n.Op {
-       case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
-               // No bounds checks needed.
-       case ODOTPTR, ODEREF:
-               // No nil check needed.
-       case OMAKESLICECOPY:
-               // No length and cap checks needed
-               // since new slice and copied over slice data have same length.
-       default:
-               Fatalf("SetBounded(%v)", n)
-       }
-       n.flags.set(nodeBounded, b)
-}
-
-// MarkReadonly indicates that n is an ONAME with readonly contents.
-func (n *Node) MarkReadonly() {
-       if n.Op != ONAME {
-               Fatalf("Node.MarkReadonly %v", n.Op)
-       }
-       n.Name.SetReadonly(true)
-       // Mark the linksym as readonly immediately
-       // so that the SSA backend can use this information.
-       // It will be overridden later during dumpglobls.
-       n.Sym.Linksym().Type = objabi.SRODATA
-}
-
-// Val returns the Val for the node.
-func (n *Node) Val() Val {
-       if !n.HasVal() {
-               return Val{}
-       }
-       return Val{n.E}
-}
-
-// SetVal sets the Val for the node, which must not have been used with SetOpt.
-func (n *Node) SetVal(v Val) {
-       if n.HasOpt() {
-               Debug.h = 1
-               Dump("have Opt", n)
-               Fatalf("have Opt")
-       }
-       n.SetHasVal(true)
-       n.E = v.U
-}
-
-// Opt returns the optimizer data for the node.
-func (n *Node) Opt() interface{} {
-       if !n.HasOpt() {
-               return nil
-       }
-       return n.E
-}
-
-// SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
-// SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
-func (n *Node) SetOpt(x interface{}) {
-       if x == nil && n.HasVal() {
-               return
-       }
-       if n.HasVal() {
-               Debug.h = 1
-               Dump("have Val", n)
-               Fatalf("have Val")
-       }
-       n.SetHasOpt(true)
-       n.E = x
-}
-
-func (n *Node) Iota() int64 {
-       return n.Xoffset
-}
-
-func (n *Node) SetIota(x int64) {
-       n.Xoffset = x
-}
-
-// mayBeShared reports whether n may occur in multiple places in the AST.
-// Extra care must be taken when mutating such a node.
-func (n *Node) mayBeShared() bool {
-       switch n.Op {
-       case ONAME, OLITERAL, OTYPE:
-               return true
-       }
-       return false
-}
-
-// isMethodExpression reports whether n represents a method expression T.M.
-func (n *Node) isMethodExpression() bool {
-       return n.Op == ONAME && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME
-}
-
-// funcname returns the name (without the package) of the function n.
-func (n *Node) funcname() string {
-       if n == nil || n.Func == nil || n.Func.Nname == nil {
-               return "<nil>"
-       }
-       return n.Func.Nname.Sym.Name
-}
-
-// pkgFuncName returns the name of the function referenced by n, with package prepended.
-// This differs from the compiler's internal convention where local functions lack a package
-// because the ultimate consumer of this is a human looking at an IDE; package is only empty
-// if the compilation package is actually the empty string.
-func (n *Node) pkgFuncName() string {
-       var s *types.Sym
-       if n == nil {
-               return "<nil>"
-       }
-       if n.Op == ONAME {
-               s = n.Sym
-       } else {
-               if n.Func == nil || n.Func.Nname == nil {
-                       return "<nil>"
-               }
-               s = n.Func.Nname.Sym
-       }
-       pkg := s.Pkg
-
-       p := myimportpath
-       if pkg != nil && pkg.Path != "" {
-               p = pkg.Path
-       }
-       if p == "" {
-               return s.Name
-       }
-       return p + "." + s.Name
-}
-
-// The compiler needs *Node to be assignable to cmd/compile/internal/ssa.Sym.
-func (n *Node) CanBeAnSSASym() {
-}
-
-// Name holds Node fields used only by named nodes (ONAME, OTYPE, OPACK, OLABEL, some OLITERAL).
-type Name struct {
-       Pack *Node      // real package for import . names
-       Pkg  *types.Pkg // pkg for OPACK nodes
-       // For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
-       // For a closure var, the ONAME node of the outer captured variable
-       Defn *Node
-       // The ODCLFUNC node (for a static function/method or a closure) in which
-       // local variable or param is declared.
-       Curfn     *Node
-       Param     *Param // additional fields for ONAME, OTYPE
-       Decldepth int32  // declaration loop depth, increased for every loop or label
-       // Unique number for ONAME nodes within a function. Function outputs
-       // (results) are numbered starting at one, followed by function inputs
-       // (parameters), and then local variables. Vargen is used to distinguish
-       // local variables/params with the same name.
-       Vargen int32
-       flags  bitset16
-}
-
-const (
-       nameCaptured = 1 << iota // is the variable captured by a closure
-       nameReadonly
-       nameByval                 // is the variable captured by value or by reference
-       nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
-       nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
-       nameUsed                  // for variable declared and not used error
-       nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original at n.Name.Defn
-       nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
-       nameAssigned              // is the variable ever assigned to
-       nameAddrtaken             // address taken, even if not moved to heap
-       nameInlFormal             // PAUTO created by inliner, derived from callee formal
-       nameInlLocal              // PAUTO created by inliner, derived from callee local
-       nameOpenDeferSlot         // if temporary var storing info for open-coded defers
-       nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-)
-
-func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
-func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
-func (n *Name) Byval() bool                 { return n.flags&nameByval != 0 }
-func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
-func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
-func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
-func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
-func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
-func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
-func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
-func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
-func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
-
-func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
-func (n *Name) SetReadonly(b bool)              { n.flags.set(nameReadonly, b) }
-func (n *Name) SetByval(b bool)                 { n.flags.set(nameByval, b) }
-func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
-func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
-func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
-func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
-func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
-func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
-func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
-func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
-func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
-func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
-
-type Param struct {
-       Ntype    *Node
-       Heapaddr *Node // temp holding heap address of param
-
-       // ONAME PAUTOHEAP
-       Stackcopy *Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
-
-       // ONAME closure linkage
-       // Consider:
-       //
-       //      func f() {
-       //              x := 1 // x1
-       //              func() {
-       //                      use(x) // x2
-       //                      func() {
-       //                              use(x) // x3
-       //                              --- parser is here ---
-       //                      }()
-       //              }()
-       //      }
-       //
-       // There is an original declaration of x and then a chain of mentions of x
-       // leading into the current function. Each time x is mentioned in a new closure,
-       // we create a variable representing x for use in that specific closure,
-       // since the way you get to x is different in each closure.
-       //
-       // Let's number the specific variables as shown in the code:
-       // x1 is the original x, x2 is when mentioned in the closure,
-       // and x3 is when mentioned in the closure in the closure.
-       //
-       // We keep these linked (assume N > 1):
-       //
-       //   - x1.Defn = original declaration statement for x (like most variables)
-       //   - x1.Innermost = current innermost closure x (in this case x3), or nil for none
-       //   - x1.IsClosureVar() = false
-       //
-       //   - xN.Defn = x1, N > 1
-       //   - xN.IsClosureVar() = true, N > 1
-       //   - x2.Outer = nil
-       //   - xN.Outer = x(N-1), N > 2
-       //
-       //
-       // When we look up x in the symbol table, we always get x1.
-       // Then we can use x1.Innermost (if not nil) to get the x
-       // for the innermost known closure function,
-       // but the first reference in a closure will find either no x1.Innermost
-       // or an x1.Innermost with .Funcdepth < Funcdepth.
-       // In that case, a new xN must be created, linked in with:
-       //
-       //     xN.Defn = x1
-       //     xN.Outer = x1.Innermost
-       //     x1.Innermost = xN
-       //
-       // When we finish the function, we'll process its closure variables
-       // and find xN and pop it off the list using:
-       //
-       //     x1 := xN.Defn
-       //     x1.Innermost = xN.Outer
-       //
-       // We leave x1.Innermost set so that we can still get to the original
-       // variable quickly. Not shown here, but once we're
-       // done parsing a function and no longer need xN.Outer for the
-       // lexical x reference links as described above, funcLit
-       // recomputes xN.Outer as the semantic x reference link tree,
-       // even filling in x in intermediate closures that might not
-       // have mentioned it along the way to inner closures that did.
-       // See funcLit for details.
-       //
-       // During the eventual compilation, then, for closure variables we have:
-       //
-       //     xN.Defn = original variable
-       //     xN.Outer = variable captured in next outward scope
-       //                to make closure where xN appears
-       //
-       // Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
-       // and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
-       Innermost *Node
-       Outer     *Node
-
-       // OTYPE & ONAME //go:embed info,
-       // sharing storage to reduce gc.Param size.
-       // Extra is nil, or else *Extra is a *paramType or an *embedFileList.
-       Extra *interface{}
-}
-
-type paramType struct {
-       flag  PragmaFlag
-       alias bool
-}
-
-type embedFileList []string
-
-// Pragma returns the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) Pragma() PragmaFlag {
-       if p.Extra == nil {
-               return 0
-       }
-       return (*p.Extra).(*paramType).flag
-}
-
-// SetPragma sets the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) SetPragma(flag PragmaFlag) {
-       if p.Extra == nil {
-               if flag == 0 {
-                       return
-               }
-               p.Extra = new(interface{})
-               *p.Extra = &paramType{flag: flag}
-               return
-       }
-       (*p.Extra).(*paramType).flag = flag
-}
-
-// Alias reports whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) Alias() bool {
-       if p.Extra == nil {
-               return false
-       }
-       t, ok := (*p.Extra).(*paramType)
-       if !ok {
-               return false
-       }
-       return t.alias
-}
-
-// SetAlias sets whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) SetAlias(alias bool) {
-       if p.Extra == nil {
-               if !alias {
-                       return
-               }
-               p.Extra = new(interface{})
-               *p.Extra = &paramType{alias: alias}
-               return
-       }
-       (*p.Extra).(*paramType).alias = alias
-}
-
-// EmbedFiles returns the list of embedded files for p,
-// which must be for an ONAME var.
-func (p *Param) EmbedFiles() []string {
-       if p.Extra == nil {
-               return nil
-       }
-       return *(*p.Extra).(*embedFileList)
-}
-
-// SetEmbedFiles sets the list of embedded files for p,
-// which must be for an ONAME var.
-func (p *Param) SetEmbedFiles(list []string) {
-       if p.Extra == nil {
-               if len(list) == 0 {
-                       return
-               }
-               f := embedFileList(list)
-               p.Extra = new(interface{})
-               *p.Extra = &f
-               return
-       }
-       *(*p.Extra).(*embedFileList) = list
-}
-
-// Functions
-//
-// A simple function declaration is represented as an ODCLFUNC node f
-// and an ONAME node n. They're linked to one another through
-// f.Func.Nname == n and n.Name.Defn == f. When functions are
-// referenced by name in an expression, the function's ONAME node is
-// used directly.
-//
-// Function names have n.Class() == PFUNC. This distinguishes them
-// from variables of function type.
-//
-// Confusingly, n.Func and f.Func both exist, but commonly point to
-// different Funcs. (Exception: an OCALLPART's Func does point to its
-// ODCLFUNC's Func.)
-//
-// A method declaration is represented like functions, except n.Sym
-// will be the qualified method name (e.g., "T.m") and
-// f.Func.Shortname is the bare method name (e.g., "m").
-//
-// Method expressions are represented as ONAME/PFUNC nodes like
-// function names, but their Left and Right fields still point to the
-// type and method, respectively. They can be distinguished from
-// normal functions with isMethodExpression. Also, unlike function
-// name nodes, method expression nodes exist for each method
-// expression. The declaration ONAME can be accessed with
-// x.Type.Nname(), where x is the method expression ONAME node.
-//
-// Method values are represented by ODOTMETH/ODOTINTER when called
-// immediately, and OCALLPART otherwise. They are like method
-// expressions, except that for ODOTMETH/ODOTINTER the method name is
-// stored in Sym instead of Right.
-//
-// Closures are represented by OCLOSURE node c. They link back and
-// forth with the ODCLFUNC via Func.Closure; that is, c.Func.Closure
-// == f and f.Func.Closure == c.
-//
-// Function bodies are stored in f.Nbody, and inline function bodies
-// are stored in n.Func.Inl. Pragmas are stored in f.Func.Pragma.
-//
-// Imported functions skip the ODCLFUNC, so n.Name.Defn is nil. They
-// also use Dcl instead of Inldcl.
-
-// Func holds Node fields used only with function-like nodes.
-type Func struct {
-       Shortname *types.Sym
-       // Extra entry code for the function. For example, allocate and initialize
-       // memory for escaping parameters. However, just for OCLOSURE, Enter is a
-       // list of ONAME nodes of captured variables
-       Enter Nodes
-       Exit  Nodes
-       // ONAME nodes for closure params, each should have closurevar set
-       Cvars Nodes
-       // ONAME nodes for all params/locals for this func/closure, does NOT
-       // include closurevars until transformclosure runs.
-       Dcl []*Node
-
-       // Parents records the parent scope of each scope within a
-       // function. The root scope (0) has no parent, so the i'th
-       // scope's parent is stored at Parents[i-1].
-       Parents []ScopeID
-
-       // Marks records scope boundary changes.
-       Marks []Mark
-
-       // Closgen tracks how many closures have been generated within
-       // this function. Used by closurename for creating unique
-       // function names.
-       Closgen int
-
-       FieldTrack map[*types.Sym]struct{}
-       DebugInfo  *ssa.FuncDebug
-       Ntype      *Node // signature
-       Top        int   // top context (ctxCallee, etc)
-       Closure    *Node // OCLOSURE <-> ODCLFUNC (see header comment above)
-       Nname      *Node // The ONAME node associated with an ODCLFUNC (both have same Type)
-       lsym       *obj.LSym
-
-       Inl *Inline
-
-       Label int32 // largest auto-generated label in this function
-
-       Endlineno src.XPos
-       WBPos     src.XPos // position of first write barrier; see SetWBPos
-
-       Pragma PragmaFlag // go:xxx function annotations
-
-       flags      bitset16
-       numDefers  int // number of defer calls in the function
-       numReturns int // number of explicit returns in the function
-
-       // nwbrCalls records the LSyms of functions called by this
-       // function for go:nowritebarrierrec analysis. Only filled in
-       // if nowritebarrierrecCheck != nil.
-       nwbrCalls *[]nowritebarrierrecCallSym
-}
-
-// An Inline holds fields used for function bodies that can be inlined.
-type Inline struct {
-       Cost int32 // heuristic cost of inlining this function
-
-       // Copies of Func.Dcl and Nbody for use during inlining.
-       Dcl  []*Node
-       Body []*Node
-}
-
-// A Mark represents a scope boundary.
-type Mark struct {
-       // Pos is the position of the token that marks the scope
-       // change.
-       Pos src.XPos
-
-       // Scope identifies the innermost scope to the right of Pos.
-       Scope ScopeID
-}
-
-// A ScopeID represents a lexical scope within a function.
-type ScopeID int32
-
-const (
-       funcDupok         = 1 << iota // duplicate definitions ok
-       funcWrapper                   // is method wrapper
-       funcNeedctxt                  // function uses context register (has closure variables)
-       funcReflectMethod             // function calls reflect.Type.Method or MethodByName
-       // true if closure inside a function; false if a simple function or a
-       // closure in a global variable initialization
-       funcIsHiddenClosure
-       funcHasDefer                 // contains a defer statement
-       funcNilCheckDisabled         // disable nil checks when compiling this function
-       funcInlinabilityChecked      // inliner has already determined whether the function is inlinable
-       funcExportInline             // include inline body in export data
-       funcInstrumentBody           // add race/msan instrumentation during SSA construction
-       funcOpenCodedDeferDisallowed // can't do open-coded defers
-)
-
-func (f *Func) Dupok() bool                    { return f.flags&funcDupok != 0 }
-func (f *Func) Wrapper() bool                  { return f.flags&funcWrapper != 0 }
-func (f *Func) Needctxt() bool                 { return f.flags&funcNeedctxt != 0 }
-func (f *Func) ReflectMethod() bool            { return f.flags&funcReflectMethod != 0 }
-func (f *Func) IsHiddenClosure() bool          { return f.flags&funcIsHiddenClosure != 0 }
-func (f *Func) HasDefer() bool                 { return f.flags&funcHasDefer != 0 }
-func (f *Func) NilCheckDisabled() bool         { return f.flags&funcNilCheckDisabled != 0 }
-func (f *Func) InlinabilityChecked() bool      { return f.flags&funcInlinabilityChecked != 0 }
-func (f *Func) ExportInline() bool             { return f.flags&funcExportInline != 0 }
-func (f *Func) InstrumentBody() bool           { return f.flags&funcInstrumentBody != 0 }
-func (f *Func) OpenCodedDeferDisallowed() bool { return f.flags&funcOpenCodedDeferDisallowed != 0 }
-
-func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
-func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
-func (f *Func) SetNeedctxt(b bool)                 { f.flags.set(funcNeedctxt, b) }
-func (f *Func) SetReflectMethod(b bool)            { f.flags.set(funcReflectMethod, b) }
-func (f *Func) SetIsHiddenClosure(b bool)          { f.flags.set(funcIsHiddenClosure, b) }
-func (f *Func) SetHasDefer(b bool)                 { f.flags.set(funcHasDefer, b) }
-func (f *Func) SetNilCheckDisabled(b bool)         { f.flags.set(funcNilCheckDisabled, b) }
-func (f *Func) SetInlinabilityChecked(b bool)      { f.flags.set(funcInlinabilityChecked, b) }
-func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInline, b) }
-func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
-func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
-
-func (f *Func) setWBPos(pos src.XPos) {
-       if Debug_wb != 0 {
-               Warnl(pos, "write barrier")
-       }
-       if !f.WBPos.IsKnown() {
-               f.WBPos = pos
-       }
-}
-
-//go:generate stringer -type=Op -trimprefix=O
-
-type Op uint8
-
-// Node ops.
-const (
-       OXXX Op = iota
-
-       // names
-       ONAME // var or func name
-       // Unnamed arg or return value: f(int, string) (int, error) { etc }
-       // Also used for a qualified package identifier that hasn't been resolved yet.
-       ONONAME
-       OTYPE    // type name
-       OPACK    // import
-       OLITERAL // literal
-
-       // expressions
-       OADD          // Left + Right
-       OSUB          // Left - Right
-       OOR           // Left | Right
-       OXOR          // Left ^ Right
-       OADDSTR       // +{List} (string addition, list elements are strings)
-       OADDR         // &Left
-       OANDAND       // Left && Right
-       OAPPEND       // append(List); after walk, Left may contain elem type descriptor
-       OBYTES2STR    // Type(Left) (Type is string, Left is a []byte)
-       OBYTES2STRTMP // Type(Left) (Type is string, Left is a []byte, ephemeral)
-       ORUNES2STR    // Type(Left) (Type is string, Left is a []rune)
-       OSTR2BYTES    // Type(Left) (Type is []byte, Left is a string)
-       OSTR2BYTESTMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
-       OSTR2RUNES    // Type(Left) (Type is []rune, Left is a string)
-       // Left = Right or (if Colas=true) Left := Right
-       // If Colas, then Ninit includes a DCL node for Left.
-       OAS
-       // List = Rlist (x, y, z = a, b, c) or (if Colas=true) List := Rlist
-       // If Colas, then Ninit includes DCL nodes for List
-       OAS2
-       OAS2DOTTYPE // List = Right (x, ok = I.(int))
-       OAS2FUNC    // List = Right (x, y = f())
-       OAS2MAPR    // List = Right (x, ok = m["foo"])
-       OAS2RECV    // List = Right (x, ok = <-c)
-       OASOP       // Left Etype= Right (x += y)
-       OCALL       // Left(List) (function call, method call or type conversion)
-
-       // OCALLFUNC, OCALLMETH, and OCALLINTER have the same structure.
-       // Prior to walk, they are: Left(List), where List is all regular arguments.
-       // After walk, List is a series of assignments to temporaries,
-       // and Rlist is an updated set of arguments.
-       // Nbody is all OVARLIVE nodes that are attached to OCALLxxx.
-       // TODO(josharian/khr): Use Ninit instead of List for the assignments to temporaries. See CL 114797.
-       OCALLFUNC  // Left(List/Rlist) (function call f(args))
-       OCALLMETH  // Left(List/Rlist) (direct method call x.Method(args))
-       OCALLINTER // Left(List/Rlist) (interface method call x.Method(args))
-       OCALLPART  // Left.Right (method expression x.Method, not called)
-       OCAP       // cap(Left)
-       OCLOSE     // close(Left)
-       OCLOSURE   // func Type { Func.Closure.Nbody } (func literal)
-       OCOMPLIT   // Right{List} (composite literal, not yet lowered to specific form)
-       OMAPLIT    // Type{List} (composite literal, Type is map)
-       OSTRUCTLIT // Type{List} (composite literal, Type is struct)
-       OARRAYLIT  // Type{List} (composite literal, Type is array)
-       OSLICELIT  // Type{List} (composite literal, Type is slice) Right.Int64() = slice length.
-       OPTRLIT    // &Left (left is composite literal)
-       OCONV      // Type(Left) (type conversion)
-       OCONVIFACE // Type(Left) (type conversion, to interface)
-       OCONVNOP   // Type(Left) (type conversion, no effect)
-       OCOPY      // copy(Left, Right)
-       ODCL       // var Left (declares Left of type Left.Type)
-
-       // Used during parsing but don't last.
-       ODCLFUNC  // func f() or func (r) f()
-       ODCLFIELD // struct field, interface field, or func/method argument/return value.
-       ODCLCONST // const pi = 3.14
-       ODCLTYPE  // type Int int or type Int = int
-
-       ODELETE        // delete(List)
-       ODOT           // Left.Sym (Left is of struct type)
-       ODOTPTR        // Left.Sym (Left is of pointer to struct type)
-       ODOTMETH       // Left.Sym (Left is non-interface, Right is method name)
-       ODOTINTER      // Left.Sym (Left is interface, Right is method name)
-       OXDOT          // Left.Sym (before rewrite to one of the preceding)
-       ODOTTYPE       // Left.Right or Left.Type (.Right during parsing, .Type once resolved); after walk, .Right contains address of interface type descriptor and .Right.Right contains address of concrete type descriptor
-       ODOTTYPE2      // Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor
-       OEQ            // Left == Right
-       ONE            // Left != Right
-       OLT            // Left < Right
-       OLE            // Left <= Right
-       OGE            // Left >= Right
-       OGT            // Left > Right
-       ODEREF         // *Left
-       OINDEX         // Left[Right] (index of array or slice)
-       OINDEXMAP      // Left[Right] (index of map)
-       OKEY           // Left:Right (key:value in struct/array/map literal)
-       OSTRUCTKEY     // Sym:Left (key:value in struct literal, after type checking)
-       OLEN           // len(Left)
-       OMAKE          // make(List) (before type checking converts to one of the following)
-       OMAKECHAN      // make(Type, Left) (type is chan)
-       OMAKEMAP       // make(Type, Left) (type is map)
-       OMAKESLICE     // make(Type, Left, Right) (type is slice)
-       OMAKESLICECOPY // makeslicecopy(Type, Left, Right) (type is slice; Left is length and Right is the copied from slice)
-       // OMAKESLICECOPY is created by the order pass and corresponds to:
-       //  s = make(Type, Left); copy(s, Right)
-       //
-       // Bounded can be set on the node when Left == len(Right) is known at compile time.
-       //
-       // This node is created so the walk pass can optimize this pattern which would
-       // otherwise be hard to detect after the order pass.
-       OMUL         // Left * Right
-       ODIV         // Left / Right
-       OMOD         // Left % Right
-       OLSH         // Left << Right
-       ORSH         // Left >> Right
-       OAND         // Left & Right
-       OANDNOT      // Left &^ Right
-       ONEW         // new(Left); corresponds to calls to new in source code
-       ONEWOBJ      // runtime.newobject(n.Type); introduced by walk; Left is type descriptor
-       ONOT         // !Left
-       OBITNOT      // ^Left
-       OPLUS        // +Left
-       ONEG         // -Left
-       OOROR        // Left || Right
-       OPANIC       // panic(Left)
-       OPRINT       // print(List)
-       OPRINTN      // println(List)
-       OPAREN       // (Left)
-       OSEND        // Left <- Right
-       OSLICE       // Left[List[0] : List[1]] (Left is untypechecked or slice)
-       OSLICEARR    // Left[List[0] : List[1]] (Left is array)
-       OSLICESTR    // Left[List[0] : List[1]] (Left is string)
-       OSLICE3      // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
-       OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is array)
-       OSLICEHEADER // sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity)
-       ORECOVER     // recover()
-       ORECV        // <-Left
-       ORUNESTR     // Type(Left) (Type is string, Left is rune)
-       OSELRECV     // Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV)
-       OSELRECV2    // List = <-Right.Left: (appears as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
-       OIOTA        // iota
-       OREAL        // real(Left)
-       OIMAG        // imag(Left)
-       OCOMPLEX     // complex(Left, Right) or complex(List[0]) where List[0] is a 2-result function call
-       OALIGNOF     // unsafe.Alignof(Left)
-       OOFFSETOF    // unsafe.Offsetof(Left)
-       OSIZEOF      // unsafe.Sizeof(Left)
-
-       // statements
-       OBLOCK // { List } (block of code)
-       OBREAK // break [Sym]
-       // OCASE:  case List: Nbody (List==nil means default)
-       //   For OTYPESW, List is a OTYPE node for the specified type (or OLITERAL
-       //   for nil), and, if a type-switch variable is specified, Rlist is an
-       //   ONAME for the version of the type-switch variable with the specified
-       //   type.
-       OCASE
-       OCONTINUE // continue [Sym]
-       ODEFER    // defer Left (Left must be call)
-       OEMPTY    // no-op (empty statement)
-       OFALL     // fallthrough
-       OFOR      // for Ninit; Left; Right { Nbody }
-       // OFORUNTIL is like OFOR, but the test (Left) is applied after the body:
-       //      Ninit
-       //      top: { Nbody }   // Execute the body at least once
-       //      cont: Right
-       //      if Left {        // And then test the loop condition
-       //              List     // Before looping to top, execute List
-       //              goto top
-       //      }
-       // OFORUNTIL is created by walk. There's no way to write this in Go code.
-       OFORUNTIL
-       OGOTO   // goto Sym
-       OIF     // if Ninit; Left { Nbody } else { Rlist }
-       OLABEL  // Sym:
-       OGO     // go Left (Left must be call)
-       ORANGE  // for List = range Right { Nbody }
-       ORETURN // return List
-       OSELECT // select { List } (List is list of OCASE)
-       OSWITCH // switch Ninit; Left { List } (List is a list of OCASE)
-       // OTYPESW:  Left := Right.(type) (appears as .Left of OSWITCH)
-       //   Left is nil if there is no type-switch variable
-       OTYPESW
-
-       // types
-       OTCHAN   // chan int
-       OTMAP    // map[string]int
-       OTSTRUCT // struct{}
-       OTINTER  // interface{}
-       // OTFUNC: func() - Left is receiver field, List is list of param fields, Rlist is
-       // list of result fields.
-       OTFUNC
-       OTARRAY // []int, [8]int, [N]int or [...]int
-
-       // misc
-       ODDD        // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
-       OINLCALL    // intermediary representation of an inlined call.
-       OEFACE      // itable and data words of an empty-interface value.
-       OITAB       // itable word of an interface value.
-       OIDATA      // data word of an interface value in Left
-       OSPTR       // base pointer of a slice or string.
-       OCLOSUREVAR // variable reference at beginning of closure function
-       OCFUNC      // reference to c function pointer (not go func value)
-       OCHECKNIL   // emit code to ensure pointer/interface not nil
-       OVARDEF     // variable is about to be fully initialized
-       OVARKILL    // variable is dead
-       OVARLIVE    // variable is alive
-       ORESULT     // result of a function call; Xoffset is stack offset
-       OINLMARK    // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
-
-       // arch-specific opcodes
-       ORETJMP // return to other function
-       OGETG   // runtime.getg() (read g pointer)
-
-       OEND
-)
-
-// Nodes is a pointer to a slice of *Node.
-// For fields that are not used in most nodes, this is used instead of
-// a slice to save space.
-type Nodes struct{ slice *[]*Node }
-
-// asNodes returns a slice of *Node as a Nodes value.
-func asNodes(s []*Node) Nodes {
-       return Nodes{&s}
-}
-
-// Slice returns the entries in Nodes as a slice.
-// Changes to the slice entries (as in s[i] = n) will be reflected in
-// the Nodes.
-func (n Nodes) Slice() []*Node {
-       if n.slice == nil {
-               return nil
-       }
-       return *n.slice
-}
-
-// Len returns the number of entries in Nodes.
-func (n Nodes) Len() int {
-       if n.slice == nil {
-               return 0
-       }
-       return len(*n.slice)
-}
-
-// Index returns the i'th element of Nodes.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) Index(i int) *Node {
-       return (*n.slice)[i]
-}
-
-// First returns the first element of Nodes (same as n.Index(0)).
-// It panics if n has no elements.
-func (n Nodes) First() *Node {
-       return (*n.slice)[0]
-}
-
-// Second returns the second element of Nodes (same as n.Index(1)).
-// It panics if n has fewer than two elements.
-func (n Nodes) Second() *Node {
-       return (*n.slice)[1]
-}
-
-// Set sets n to a slice.
-// This takes ownership of the slice.
-func (n *Nodes) Set(s []*Node) {
-       if len(s) == 0 {
-               n.slice = nil
-       } else {
-               // Copy s and take address of t rather than s to avoid
-               // allocation in the case where len(s) == 0 (which is
-               // over 3x more common, dynamically, for make.bash).
-               t := s
-               n.slice = &t
-       }
-}
-
-// Set1 sets n to a slice containing a single node.
-func (n *Nodes) Set1(n1 *Node) {
-       n.slice = &[]*Node{n1}
-}
-
-// Set2 sets n to a slice containing two nodes.
-func (n *Nodes) Set2(n1, n2 *Node) {
-       n.slice = &[]*Node{n1, n2}
-}
-
-// Set3 sets n to a slice containing three nodes.
-func (n *Nodes) Set3(n1, n2, n3 *Node) {
-       n.slice = &[]*Node{n1, n2, n3}
-}
-
-// MoveNodes sets n to the contents of n2, then clears n2.
-func (n *Nodes) MoveNodes(n2 *Nodes) {
-       n.slice = n2.slice
-       n2.slice = nil
-}
-
-// SetIndex sets the i'th element of Nodes to node.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) SetIndex(i int, node *Node) {
-       (*n.slice)[i] = node
-}
-
-// SetFirst sets the first element of Nodes to node.
-// It panics if n does not have at least one elements.
-func (n Nodes) SetFirst(node *Node) {
-       (*n.slice)[0] = node
-}
-
-// SetSecond sets the second element of Nodes to node.
-// It panics if n does not have at least two elements.
-func (n Nodes) SetSecond(node *Node) {
-       (*n.slice)[1] = node
-}
-
-// Addr returns the address of the i'th element of Nodes.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) Addr(i int) **Node {
-       return &(*n.slice)[i]
-}
-
-// Append appends entries to Nodes.
-func (n *Nodes) Append(a ...*Node) {
-       if len(a) == 0 {
-               return
-       }
-       if n.slice == nil {
-               s := make([]*Node, len(a))
-               copy(s, a)
-               n.slice = &s
-               return
-       }
-       *n.slice = append(*n.slice, a...)
-}
-
-// Prepend prepends entries to Nodes.
-// If a slice is passed in, this will take ownership of it.
-func (n *Nodes) Prepend(a ...*Node) {
-       if len(a) == 0 {
-               return
-       }
-       if n.slice == nil {
-               n.slice = &a
-       } else {
-               *n.slice = append(a, *n.slice...)
-       }
-}
-
-// AppendNodes appends the contents of *n2 to n, then clears n2.
-func (n *Nodes) AppendNodes(n2 *Nodes) {
-       switch {
-       case n2.slice == nil:
-       case n.slice == nil:
-               n.slice = n2.slice
-       default:
-               *n.slice = append(*n.slice, *n2.slice...)
-       }
-       n2.slice = nil
-}
-
-// inspect invokes f on each node in an AST in depth-first order.
-// If f(n) returns false, inspect skips visiting n's children.
-func inspect(n *Node, f func(*Node) bool) {
-       if n == nil || !f(n) {
-               return
-       }
-       inspectList(n.Ninit, f)
-       inspect(n.Left, f)
-       inspect(n.Right, f)
-       inspectList(n.List, f)
-       inspectList(n.Nbody, f)
-       inspectList(n.Rlist, f)
-}
-
-func inspectList(l Nodes, f func(*Node) bool) {
-       for _, n := range l.Slice() {
-               inspect(n, f)
-       }
-}
-
-// nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
-// a ready-to-use empty queue.
-type nodeQueue struct {
-       ring       []*Node
-       head, tail int
-}
-
-// empty reports whether q contains no Nodes.
-func (q *nodeQueue) empty() bool {
-       return q.head == q.tail
-}
-
-// pushRight appends n to the right of the queue.
-func (q *nodeQueue) pushRight(n *Node) {
-       if len(q.ring) == 0 {
-               q.ring = make([]*Node, 16)
-       } else if q.head+len(q.ring) == q.tail {
-               // Grow the ring.
-               nring := make([]*Node, len(q.ring)*2)
-               // Copy the old elements.
-               part := q.ring[q.head%len(q.ring):]
-               if q.tail-q.head <= len(part) {
-                       part = part[:q.tail-q.head]
-                       copy(nring, part)
-               } else {
-                       pos := copy(nring, part)
-                       copy(nring[pos:], q.ring[:q.tail%len(q.ring)])
-               }
-               q.ring, q.head, q.tail = nring, 0, q.tail-q.head
-       }
-
-       q.ring[q.tail%len(q.ring)] = n
-       q.tail++
-}
-
-// popLeft pops a node from the left of the queue. It panics if q is
-// empty.
-func (q *nodeQueue) popLeft() *Node {
-       if q.empty() {
-               panic("dequeue empty")
-       }
-       n := q.ring[q.head%len(q.ring)]
-       q.head++
-       return n
-}
-
-// NodeSet is a set of Nodes.
-type NodeSet map[*Node]struct{}
-
-// Has reports whether s contains n.
-func (s NodeSet) Has(n *Node) bool {
-       _, isPresent := s[n]
-       return isPresent
-}
-
-// Add adds n to s.
-func (s *NodeSet) Add(n *Node) {
-       if *s == nil {
-               *s = make(map[*Node]struct{})
-       }
-       (*s)[n] = struct{}{}
-}
-
-// Sorted returns s sorted according to less.
-func (s NodeSet) Sorted(less func(*Node, *Node) bool) []*Node {
-       var res []*Node
-       for n := range s {
-               res = append(res, n)
-       }
-       sort.Slice(res, func(i, j int) bool { return less(res[i], res[j]) })
-       return res
-}

diff --git a/src/cmd/compile/internal/gc/trace.go b/src/cmd/compile/internal/gc/trace.go
index ed4b5a268ddc69dd62115ab16d743a5fb8a8f8e3..c6eb23a09091c0c98350dc5cb2458a2efe26c5e5 100644 (file)
--- a/src/cmd/compile/internal/gc/trace.go
+++ b/src/cmd/compile/internal/gc/trace.go
@@ -9,6 +9,8 @@ package gc
 import (
        "os"
        tracepkg "runtime/trace"
+
+       "cmd/compile/internal/base"
 )
 
 func init() {
@@ -18,10 +20,10 @@ func init() {
 func traceHandlerGo17(traceprofile string) {
        f, err := os.Create(traceprofile)
        if err != nil {
-               Fatalf("%v", err)
+               base.Fatalf("%v", err)
        }
        if err := tracepkg.Start(f); err != nil {
-               Fatalf("%v", err)
+               base.Fatalf("%v", err)
        }
-       atExit(tracepkg.Stop)
+       base.AtExit(tracepkg.Stop)
 }

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
deleted file mode 100644 (file)
index c0b0503..0000000
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ /dev/null
@@ -1,4019 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "fmt"
-       "strings"
-)
-
-// To enable tracing support (-t flag), set enableTrace to true.
-const enableTrace = false
-
-var trace bool
-var traceIndent []byte
-var skipDowidthForTracing bool
-
-func tracePrint(title string, n *Node) func(np **Node) {
-       indent := traceIndent
-
-       // guard against nil
-       var pos, op string
-       var tc uint8
-       if n != nil {
-               pos = linestr(n.Pos)
-               op = n.Op.String()
-               tc = n.Typecheck()
-       }
-
-       skipDowidthForTracing = true
-       defer func() { skipDowidthForTracing = false }()
-       fmt.Printf("%s: %s%s %p %s %v tc=%d\n", pos, indent, title, n, op, n, tc)
-       traceIndent = append(traceIndent, ". "...)
-
-       return func(np **Node) {
-               traceIndent = traceIndent[:len(traceIndent)-2]
-
-               // if we have a result, use that
-               if np != nil {
-                       n = *np
-               }
-
-               // guard against nil
-               // use outer pos, op so we don't get empty pos/op if n == nil (nicer output)
-               var tc uint8
-               var typ *types.Type
-               if n != nil {
-                       pos = linestr(n.Pos)
-                       op = n.Op.String()
-                       tc = n.Typecheck()
-                       typ = n.Type
-               }
-
-               skipDowidthForTracing = true
-               defer func() { skipDowidthForTracing = false }()
-               fmt.Printf("%s: %s=> %p %s %v tc=%d type=%#L\n", pos, indent, n, op, n, tc, typ)
-       }
-}
-
-const (
-       ctxStmt    = 1 << iota // evaluated at statement level
-       ctxExpr                // evaluated in value context
-       ctxType                // evaluated in type context
-       ctxCallee              // call-only expressions are ok
-       ctxMultiOK             // multivalue function returns are ok
-       ctxAssign              // assigning to expression
-)
-
-// type checks the whole tree of an expression.
-// calculates expression types.
-// evaluates compile time constants.
-// marks variables that escape the local frame.
-// rewrites n.Op to be more specific in some cases.
-
-var typecheckdefstack []*Node
-
-// resolve ONONAME to definition, if any.
-func resolve(n *Node) (res *Node) {
-       if n == nil || n.Op != ONONAME {
-               return n
-       }
-
-       // only trace if there's work to do
-       if enableTrace && trace {
-               defer tracePrint("resolve", n)(&res)
-       }
-
-       if n.Sym.Pkg != localpkg {
-               if inimport {
-                       Fatalf("recursive inimport")
-               }
-               inimport = true
-               expandDecl(n)
-               inimport = false
-               return n
-       }
-
-       r := asNode(n.Sym.Def)
-       if r == nil {
-               return n
-       }
-
-       if r.Op == OIOTA {
-               if x := getIotaValue(); x >= 0 {
-                       return nodintconst(x)
-               }
-               return n
-       }
-
-       return r
-}
-
-func typecheckslice(l []*Node, top int) {
-       for i := range l {
-               l[i] = typecheck(l[i], top)
-       }
-}
-
-var _typekind = []string{
-       TINT:        "int",
-       TUINT:       "uint",
-       TINT8:       "int8",
-       TUINT8:      "uint8",
-       TINT16:      "int16",
-       TUINT16:     "uint16",
-       TINT32:      "int32",
-       TUINT32:     "uint32",
-       TINT64:      "int64",
-       TUINT64:     "uint64",
-       TUINTPTR:    "uintptr",
-       TCOMPLEX64:  "complex64",
-       TCOMPLEX128: "complex128",
-       TFLOAT32:    "float32",
-       TFLOAT64:    "float64",
-       TBOOL:       "bool",
-       TSTRING:     "string",
-       TPTR:        "pointer",
-       TUNSAFEPTR:  "unsafe.Pointer",
-       TSTRUCT:     "struct",
-       TINTER:      "interface",
-       TCHAN:       "chan",
-       TMAP:        "map",
-       TARRAY:      "array",
-       TSLICE:      "slice",
-       TFUNC:       "func",
-       TNIL:        "nil",
-       TIDEAL:      "untyped number",
-}
-
-func typekind(t *types.Type) string {
-       if t.IsUntyped() {
-               return fmt.Sprintf("%v", t)
-       }
-       et := t.Etype
-       if int(et) < len(_typekind) {
-               s := _typekind[et]
-               if s != "" {
-                       return s
-               }
-       }
-       return fmt.Sprintf("etype=%d", et)
-}
-
-func cycleFor(start *Node) []*Node {
-       // Find the start node in typecheck_tcstack.
-       // We know that it must exist because each time we mark
-       // a node with n.SetTypecheck(2) we push it on the stack,
-       // and each time we mark a node with n.SetTypecheck(2) we
-       // pop it from the stack. We hit a cycle when we encounter
-       // a node marked 2 in which case is must be on the stack.
-       i := len(typecheck_tcstack) - 1
-       for i > 0 && typecheck_tcstack[i] != start {
-               i--
-       }
-
-       // collect all nodes with same Op
-       var cycle []*Node
-       for _, n := range typecheck_tcstack[i:] {
-               if n.Op == start.Op {
-                       cycle = append(cycle, n)
-               }
-       }
-
-       return cycle
-}
-
-func cycleTrace(cycle []*Node) string {
-       var s string
-       for i, n := range cycle {
-               s += fmt.Sprintf("\n\t%v: %v uses %v", n.Line(), n, cycle[(i+1)%len(cycle)])
-       }
-       return s
-}
-
-var typecheck_tcstack []*Node
-
-// typecheck type checks node n.
-// The result of typecheck MUST be assigned back to n, e.g.
-//     n.Left = typecheck(n.Left, top)
-func typecheck(n *Node, top int) (res *Node) {
-       // cannot type check until all the source has been parsed
-       if !typecheckok {
-               Fatalf("early typecheck")
-       }
-
-       if n == nil {
-               return nil
-       }
-
-       // only trace if there's work to do
-       if enableTrace && trace {
-               defer tracePrint("typecheck", n)(&res)
-       }
-
-       lno := setlineno(n)
-
-       // Skip over parens.
-       for n.Op == OPAREN {
-               n = n.Left
-       }
-
-       // Resolve definition of name and value of iota lazily.
-       n = resolve(n)
-
-       // Skip typecheck if already done.
-       // But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
-       if n.Typecheck() == 1 {
-               switch n.Op {
-               case ONAME, OTYPE, OLITERAL, OPACK:
-                       break
-
-               default:
-                       lineno = lno
-                       return n
-               }
-       }
-
-       if n.Typecheck() == 2 {
-               // Typechecking loop. Trying printing a meaningful message,
-               // otherwise a stack trace of typechecking.
-               switch n.Op {
-               // We can already diagnose variables used as types.
-               case ONAME:
-                       if top&(ctxExpr|ctxType) == ctxType {
-                               yyerror("%v is not a type", n)
-                       }
-
-               case OTYPE:
-                       // Only report a type cycle if we are expecting a type.
-                       // Otherwise let other code report an error.
-                       if top&ctxType == ctxType {
-                               // A cycle containing only alias types is an error
-                               // since it would expand indefinitely when aliases
-                               // are substituted.
-                               cycle := cycleFor(n)
-                               for _, n1 := range cycle {
-                                       if n1.Name != nil && !n1.Name.Param.Alias() {
-                                               // Cycle is ok. But if n is an alias type and doesn't
-                                               // have a type yet, we have a recursive type declaration
-                                               // with aliases that we can't handle properly yet.
-                                               // Report an error rather than crashing later.
-                                               if n.Name != nil && n.Name.Param.Alias() && n.Type == nil {
-                                                       lineno = n.Pos
-                                                       Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
-                                               }
-                                               lineno = lno
-                                               return n
-                                       }
-                               }
-                               yyerrorl(n.Pos, "invalid recursive type alias %v%s", n, cycleTrace(cycle))
-                       }
-
-               case OLITERAL:
-                       if top&(ctxExpr|ctxType) == ctxType {
-                               yyerror("%v is not a type", n)
-                               break
-                       }
-                       yyerrorl(n.Pos, "constant definition loop%s", cycleTrace(cycleFor(n)))
-               }
-
-               if nsavederrors+nerrors == 0 {
-                       var trace string
-                       for i := len(typecheck_tcstack) - 1; i >= 0; i-- {
-                               x := typecheck_tcstack[i]
-                               trace += fmt.Sprintf("\n\t%v %v", x.Line(), x)
-                       }
-                       yyerror("typechecking loop involving %v%s", n, trace)
-               }
-
-               lineno = lno
-               return n
-       }
-
-       n.SetTypecheck(2)
-
-       typecheck_tcstack = append(typecheck_tcstack, n)
-       n = typecheck1(n, top)
-
-       n.SetTypecheck(1)
-
-       last := len(typecheck_tcstack) - 1
-       typecheck_tcstack[last] = nil
-       typecheck_tcstack = typecheck_tcstack[:last]
-
-       lineno = lno
-       return n
-}
-
-// indexlit implements typechecking of untyped values as
-// array/slice indexes. It is almost equivalent to defaultlit
-// but also accepts untyped numeric values representable as
-// value of type int (see also checkmake for comparison).
-// The result of indexlit MUST be assigned back to n, e.g.
-//     n.Left = indexlit(n.Left)
-func indexlit(n *Node) *Node {
-       if n != nil && n.Type != nil && n.Type.Etype == TIDEAL {
-               return defaultlit(n, types.Types[TINT])
-       }
-       return n
-}
-
-// The result of typecheck1 MUST be assigned back to n, e.g.
-//     n.Left = typecheck1(n.Left, top)
-func typecheck1(n *Node, top int) (res *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheck1", n)(&res)
-       }
-
-       switch n.Op {
-       case OLITERAL, ONAME, ONONAME, OTYPE:
-               if n.Sym == nil {
-                       break
-               }
-
-               if n.Op == ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
-                       yyerror("use of builtin %v not in function call", n.Sym)
-                       n.Type = nil
-                       return n
-               }
-
-               typecheckdef(n)
-               if n.Op == ONONAME {
-                       n.Type = nil
-                       return n
-               }
-       }
-
-       ok := 0
-       switch n.Op {
-       // until typecheck is complete, do nothing.
-       default:
-               Dump("typecheck", n)
-
-               Fatalf("typecheck %v", n.Op)
-
-       // names
-       case OLITERAL:
-               ok |= ctxExpr
-
-               if n.Type == nil && n.Val().Ctype() == CTSTR {
-                       n.Type = types.UntypedString
-               }
-
-       case ONONAME:
-               ok |= ctxExpr
-
-       case ONAME:
-               if n.Name.Decldepth == 0 {
-                       n.Name.Decldepth = decldepth
-               }
-               if n.SubOp() != 0 {
-                       ok |= ctxCallee
-                       break
-               }
-
-               if top&ctxAssign == 0 {
-                       // not a write to the variable
-                       if n.isBlank() {
-                               yyerror("cannot use _ as value")
-                               n.Type = nil
-                               return n
-                       }
-
-                       n.Name.SetUsed(true)
-               }
-
-               ok |= ctxExpr
-
-       case OPACK:
-               yyerror("use of package %v without selector", n.Sym)
-               n.Type = nil
-               return n
-
-       case ODDD:
-               break
-
-       // types (ODEREF is with exprs)
-       case OTYPE:
-               ok |= ctxType
-
-               if n.Type == nil {
-                       return n
-               }
-
-       case OTARRAY:
-               ok |= ctxType
-               r := typecheck(n.Right, ctxType)
-               if r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               var t *types.Type
-               if n.Left == nil {
-                       t = types.NewSlice(r.Type)
-               } else if n.Left.Op == ODDD {
-                       if !n.Diag() {
-                               n.SetDiag(true)
-                               yyerror("use of [...] array outside of array literal")
-                       }
-                       n.Type = nil
-                       return n
-               } else {
-                       n.Left = indexlit(typecheck(n.Left, ctxExpr))
-                       l := n.Left
-                       if consttype(l) != CTINT {
-                               switch {
-                               case l.Type == nil:
-                                       // Error already reported elsewhere.
-                               case l.Type.IsInteger() && l.Op != OLITERAL:
-                                       yyerror("non-constant array bound %v", l)
-                               default:
-                                       yyerror("invalid array bound %v", l)
-                               }
-                               n.Type = nil
-                               return n
-                       }
-
-                       v := l.Val()
-                       if doesoverflow(v, types.Types[TINT]) {
-                               yyerror("array bound is too large")
-                               n.Type = nil
-                               return n
-                       }
-
-                       bound := v.U.(*Mpint).Int64()
-                       if bound < 0 {
-                               yyerror("array bound must be non-negative")
-                               n.Type = nil
-                               return n
-                       }
-                       t = types.NewArray(r.Type, bound)
-               }
-
-               setTypeNode(n, t)
-               n.Left = nil
-               n.Right = nil
-               checkwidth(t)
-
-       case OTMAP:
-               ok |= ctxType
-               n.Left = typecheck(n.Left, ctxType)
-               n.Right = typecheck(n.Right, ctxType)
-               l := n.Left
-               r := n.Right
-               if l.Type == nil || r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               if l.Type.NotInHeap() {
-                       yyerror("incomplete (or unallocatable) map key not allowed")
-               }
-               if r.Type.NotInHeap() {
-                       yyerror("incomplete (or unallocatable) map value not allowed")
-               }
-
-               setTypeNode(n, types.NewMap(l.Type, r.Type))
-               mapqueue = append(mapqueue, n) // check map keys when all types are settled
-               n.Left = nil
-               n.Right = nil
-
-       case OTCHAN:
-               ok |= ctxType
-               n.Left = typecheck(n.Left, ctxType)
-               l := n.Left
-               if l.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               if l.Type.NotInHeap() {
-                       yyerror("chan of incomplete (or unallocatable) type not allowed")
-               }
-
-               setTypeNode(n, types.NewChan(l.Type, n.TChanDir()))
-               n.Left = nil
-               n.ResetAux()
-
-       case OTSTRUCT:
-               ok |= ctxType
-               setTypeNode(n, tostruct(n.List.Slice()))
-               n.List.Set(nil)
-
-       case OTINTER:
-               ok |= ctxType
-               setTypeNode(n, tointerface(n.List.Slice()))
-
-       case OTFUNC:
-               ok |= ctxType
-               setTypeNode(n, functype(n.Left, n.List.Slice(), n.Rlist.Slice()))
-               n.Left = nil
-               n.List.Set(nil)
-               n.Rlist.Set(nil)
-
-       // type or expr
-       case ODEREF:
-               n.Left = typecheck(n.Left, ctxExpr|ctxType)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if l.Op == OTYPE {
-                       ok |= ctxType
-                       setTypeNode(n, types.NewPtr(l.Type))
-                       n.Left = nil
-                       // Ensure l.Type gets dowidth'd for the backend. Issue 20174.
-                       checkwidth(l.Type)
-                       break
-               }
-
-               if !t.IsPtr() {
-                       if top&(ctxExpr|ctxStmt) != 0 {
-                               yyerror("invalid indirect of %L", n.Left)
-                               n.Type = nil
-                               return n
-                       }
-
-                       break
-               }
-
-               ok |= ctxExpr
-               n.Type = t.Elem()
-
-       // arithmetic exprs
-       case OASOP,
-               OADD,
-               OAND,
-               OANDAND,
-               OANDNOT,
-               ODIV,
-               OEQ,
-               OGE,
-               OGT,
-               OLE,
-               OLT,
-               OLSH,
-               ORSH,
-               OMOD,
-               OMUL,
-               ONE,
-               OOR,
-               OOROR,
-               OSUB,
-               OXOR:
-               var l *Node
-               var op Op
-               var r *Node
-               if n.Op == OASOP {
-                       ok |= ctxStmt
-                       n.Left = typecheck(n.Left, ctxExpr)
-                       n.Right = typecheck(n.Right, ctxExpr)
-                       l = n.Left
-                       r = n.Right
-                       checkassign(n, n.Left)
-                       if l.Type == nil || r.Type == nil {
-                               n.Type = nil
-                               return n
-                       }
-                       if n.Implicit() && !okforarith[l.Type.Etype] {
-                               yyerror("invalid operation: %v (non-numeric type %v)", n, l.Type)
-                               n.Type = nil
-                               return n
-                       }
-                       // TODO(marvin): Fix Node.EType type union.
-                       op = n.SubOp()
-               } else {
-                       ok |= ctxExpr
-                       n.Left = typecheck(n.Left, ctxExpr)
-                       n.Right = typecheck(n.Right, ctxExpr)
-                       l = n.Left
-                       r = n.Right
-                       if l.Type == nil || r.Type == nil {
-                               n.Type = nil
-                               return n
-                       }
-                       op = n.Op
-               }
-               if op == OLSH || op == ORSH {
-                       r = defaultlit(r, types.Types[TUINT])
-                       n.Right = r
-                       t := r.Type
-                       if !t.IsInteger() {
-                               yyerror("invalid operation: %v (shift count type %v, must be integer)", n, r.Type)
-                               n.Type = nil
-                               return n
-                       }
-                       if t.IsSigned() && !langSupported(1, 13, curpkg()) {
-                               yyerrorv("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type)
-                               n.Type = nil
-                               return n
-                       }
-                       t = l.Type
-                       if t != nil && t.Etype != TIDEAL && !t.IsInteger() {
-                               yyerror("invalid operation: %v (shift of type %v)", n, t)
-                               n.Type = nil
-                               return n
-                       }
-
-                       // no defaultlit for left
-                       // the outer context gives the type
-                       n.Type = l.Type
-                       if (l.Type == types.UntypedFloat || l.Type == types.UntypedComplex) && r.Op == OLITERAL {
-                               n.Type = types.UntypedInt
-                       }
-
-                       break
-               }
-
-               // For "x == x && len(s)", it's better to report that "len(s)" (type int)
-               // can't be used with "&&" than to report that "x == x" (type untyped bool)
-               // can't be converted to int (see issue #41500).
-               if n.Op == OANDAND || n.Op == OOROR {
-                       if !n.Left.Type.IsBoolean() {
-                               yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Left.Type))
-                               n.Type = nil
-                               return n
-                       }
-                       if !n.Right.Type.IsBoolean() {
-                               yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Right.Type))
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               // ideal mixed with non-ideal
-               l, r = defaultlit2(l, r, false)
-
-               n.Left = l
-               n.Right = r
-               if l.Type == nil || r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               t := l.Type
-               if t.Etype == TIDEAL {
-                       t = r.Type
-               }
-               et := t.Etype
-               if et == TIDEAL {
-                       et = TINT
-               }
-               aop := OXXX
-               if iscmp[n.Op] && t.Etype != TIDEAL && !types.Identical(l.Type, r.Type) {
-                       // comparison is okay as long as one side is
-                       // assignable to the other.  convert so they have
-                       // the same type.
-                       //
-                       // the only conversion that isn't a no-op is concrete == interface.
-                       // in that case, check comparability of the concrete type.
-                       // The conversion allocates, so only do it if the concrete type is huge.
-                       converted := false
-                       if r.Type.Etype != TBLANK {
-                               aop, _ = assignop(l.Type, r.Type)
-                               if aop != OXXX {
-                                       if r.Type.IsInterface() && !l.Type.IsInterface() && !IsComparable(l.Type) {
-                                               yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type))
-                                               n.Type = nil
-                                               return n
-                                       }
-
-                                       dowidth(l.Type)
-                                       if r.Type.IsInterface() == l.Type.IsInterface() || l.Type.Width >= 1<<16 {
-                                               l = nod(aop, l, nil)
-                                               l.Type = r.Type
-                                               l.SetTypecheck(1)
-                                               n.Left = l
-                                       }
-
-                                       t = r.Type
-                                       converted = true
-                               }
-                       }
-
-                       if !converted && l.Type.Etype != TBLANK {
-                               aop, _ = assignop(r.Type, l.Type)
-                               if aop != OXXX {
-                                       if l.Type.IsInterface() && !r.Type.IsInterface() && !IsComparable(r.Type) {
-                                               yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type))
-                                               n.Type = nil
-                                               return n
-                                       }
-
-                                       dowidth(r.Type)
-                                       if r.Type.IsInterface() == l.Type.IsInterface() || r.Type.Width >= 1<<16 {
-                                               r = nod(aop, r, nil)
-                                               r.Type = l.Type
-                                               r.SetTypecheck(1)
-                                               n.Right = r
-                                       }
-
-                                       t = l.Type
-                               }
-                       }
-
-                       et = t.Etype
-               }
-
-               if t.Etype != TIDEAL && !types.Identical(l.Type, r.Type) {
-                       l, r = defaultlit2(l, r, true)
-                       if l.Type == nil || r.Type == nil {
-                               n.Type = nil
-                               return n
-                       }
-                       if l.Type.IsInterface() == r.Type.IsInterface() || aop == 0 {
-                               yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               if t.Etype == TIDEAL {
-                       t = mixUntyped(l.Type, r.Type)
-               }
-               if dt := defaultType(t); !okfor[op][dt.Etype] {
-                       yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
-                       n.Type = nil
-                       return n
-               }
-
-               // okfor allows any array == array, map == map, func == func.
-               // restrict to slice/map/func == nil and nil == slice/map/func.
-               if l.Type.IsArray() && !IsComparable(l.Type) {
-                       yyerror("invalid operation: %v (%v cannot be compared)", n, l.Type)
-                       n.Type = nil
-                       return n
-               }
-
-               if l.Type.IsSlice() && !l.isNil() && !r.isNil() {
-                       yyerror("invalid operation: %v (slice can only be compared to nil)", n)
-                       n.Type = nil
-                       return n
-               }
-
-               if l.Type.IsMap() && !l.isNil() && !r.isNil() {
-                       yyerror("invalid operation: %v (map can only be compared to nil)", n)
-                       n.Type = nil
-                       return n
-               }
-
-               if l.Type.Etype == TFUNC && !l.isNil() && !r.isNil() {
-                       yyerror("invalid operation: %v (func can only be compared to nil)", n)
-                       n.Type = nil
-                       return n
-               }
-
-               if l.Type.IsStruct() {
-                       if f := IncomparableField(l.Type); f != nil {
-                               yyerror("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               if iscmp[n.Op] {
-                       evconst(n)
-                       t = types.UntypedBool
-                       if n.Op != OLITERAL {
-                               l, r = defaultlit2(l, r, true)
-                               n.Left = l
-                               n.Right = r
-                       }
-               }
-
-               if et == TSTRING && n.Op == OADD {
-                       // create OADDSTR node with list of strings in x + y + z + (w + v) + ...
-                       n.Op = OADDSTR
-
-                       if l.Op == OADDSTR {
-                               n.List.Set(l.List.Slice())
-                       } else {
-                               n.List.Set1(l)
-                       }
-                       if r.Op == OADDSTR {
-                               n.List.AppendNodes(&r.List)
-                       } else {
-                               n.List.Append(r)
-                       }
-                       n.Left = nil
-                       n.Right = nil
-               }
-
-               if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
-                       if r.Val().U.(*Mpint).CmpInt64(0) == 0 {
-                               yyerror("division by zero")
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               n.Type = t
-
-       case OBITNOT, ONEG, ONOT, OPLUS:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !okfor[n.Op][defaultType(t).Etype] {
-                       yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(t))
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = t
-
-       // exprs
-       case OADDR:
-               ok |= ctxExpr
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               if n.Left.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               switch n.Left.Op {
-               case OARRAYLIT, OMAPLIT, OSLICELIT, OSTRUCTLIT:
-                       n.Op = OPTRLIT
-
-               default:
-                       checklvalue(n.Left, "take the address of")
-                       r := outervalue(n.Left)
-                       if r.Op == ONAME {
-                               if r.Orig != r {
-                                       Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
-                               }
-                               r.Name.SetAddrtaken(true)
-                               if r.Name.IsClosureVar() && !capturevarscomplete {
-                                       // Mark the original variable as Addrtaken so that capturevars
-                                       // knows not to pass it by value.
-                                       // But if the capturevars phase is complete, don't touch it,
-                                       // in case l.Name's containing function has not yet been compiled.
-                                       r.Name.Defn.Name.SetAddrtaken(true)
-                               }
-                       }
-                       n.Left = defaultlit(n.Left, nil)
-                       if n.Left.Type == nil {
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               n.Type = types.NewPtr(n.Left.Type)
-
-       case OCOMPLIT:
-               ok |= ctxExpr
-               n = typecheckcomplit(n)
-               if n.Type == nil {
-                       return n
-               }
-
-       case OXDOT, ODOT:
-               if n.Op == OXDOT {
-                       n = adddot(n)
-                       n.Op = ODOT
-                       if n.Left == nil {
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               n.Left = typecheck(n.Left, ctxExpr|ctxType)
-
-               n.Left = defaultlit(n.Left, nil)
-
-               t := n.Left.Type
-               if t == nil {
-                       adderrorname(n)
-                       n.Type = nil
-                       return n
-               }
-
-               s := n.Sym
-
-               if n.Left.Op == OTYPE {
-                       n = typecheckMethodExpr(n)
-                       if n.Type == nil {
-                               return n
-                       }
-                       ok = ctxExpr
-                       break
-               }
-
-               if t.IsPtr() && !t.Elem().IsInterface() {
-                       t = t.Elem()
-                       if t == nil {
-                               n.Type = nil
-                               return n
-                       }
-                       n.Op = ODOTPTR
-                       checkwidth(t)
-               }
-
-               if n.Sym.IsBlank() {
-                       yyerror("cannot refer to blank field or method")
-                       n.Type = nil
-                       return n
-               }
-
-               if lookdot(n, t, 0) == nil {
-                       // Legitimate field or method lookup failed, try to explain the error
-                       switch {
-                       case t.IsEmptyInterface():
-                               yyerror("%v undefined (type %v is interface with no methods)", n, n.Left.Type)
-
-                       case t.IsPtr() && t.Elem().IsInterface():
-                               // Pointer to interface is almost always a mistake.
-                               yyerror("%v undefined (type %v is pointer to interface, not interface)", n, n.Left.Type)
-
-                       case lookdot(n, t, 1) != nil:
-                               // Field or method matches by name, but it is not exported.
-                               yyerror("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym)
-
-                       default:
-                               if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
-                                       yyerror("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left.Type, n.Sym, mt.Sym)
-                               } else {
-                                       yyerror("%v undefined (type %v has no field or method %v)", n, n.Left.Type, n.Sym)
-                               }
-                       }
-                       n.Type = nil
-                       return n
-               }
-
-               switch n.Op {
-               case ODOTINTER, ODOTMETH:
-                       if top&ctxCallee != 0 {
-                               ok |= ctxCallee
-                       } else {
-                               typecheckpartialcall(n, s)
-                               ok |= ctxExpr
-                       }
-
-               default:
-                       ok |= ctxExpr
-               }
-
-       case ODOTTYPE:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsInterface() {
-                       yyerror("invalid type assertion: %v (non-interface type %v on left)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               if n.Right != nil {
-                       n.Right = typecheck(n.Right, ctxType)
-                       n.Type = n.Right.Type
-                       n.Right = nil
-                       if n.Type == nil {
-                               return n
-                       }
-               }
-
-               if n.Type != nil && !n.Type.IsInterface() {
-                       var missing, have *types.Field
-                       var ptr int
-                       if !implements(n.Type, t, &missing, &have, &ptr) {
-                               if have != nil && have.Sym == missing.Sym {
-                                       yyerror("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
-                                               "\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-                               } else if ptr != 0 {
-                                       yyerror("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type, t, missing.Sym)
-                               } else if have != nil {
-                                       yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
-                                               "\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-                               } else {
-                                       yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type, t, missing.Sym)
-                               }
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-       case OINDEX:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               n.Left = implicitstar(n.Left)
-               l := n.Left
-               n.Right = typecheck(n.Right, ctxExpr)
-               r := n.Right
-               t := l.Type
-               if t == nil || r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               switch t.Etype {
-               default:
-                       yyerror("invalid operation: %v (type %v does not support indexing)", n, t)
-                       n.Type = nil
-                       return n
-
-               case TSTRING, TARRAY, TSLICE:
-                       n.Right = indexlit(n.Right)
-                       if t.IsString() {
-                               n.Type = types.Bytetype
-                       } else {
-                               n.Type = t.Elem()
-                       }
-                       why := "string"
-                       if t.IsArray() {
-                               why = "array"
-                       } else if t.IsSlice() {
-                               why = "slice"
-                       }
-
-                       if n.Right.Type != nil && !n.Right.Type.IsInteger() {
-                               yyerror("non-integer %s index %v", why, n.Right)
-                               break
-                       }
-
-                       if !n.Bounded() && Isconst(n.Right, CTINT) {
-                               x := n.Right.Int64Val()
-                               if x < 0 {
-                                       yyerror("invalid %s index %v (index must be non-negative)", why, n.Right)
-                               } else if t.IsArray() && x >= t.NumElem() {
-                                       yyerror("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
-                               } else if Isconst(n.Left, CTSTR) && x >= int64(len(n.Left.StringVal())) {
-                                       yyerror("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
-                               } else if n.Right.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
-                                       yyerror("invalid %s index %v (index too large)", why, n.Right)
-                               }
-                       }
-
-               case TMAP:
-                       n.Right = assignconv(n.Right, t.Key(), "map index")
-                       n.Type = t.Elem()
-                       n.Op = OINDEXMAP
-                       n.ResetAux()
-               }
-
-       case ORECV:
-               ok |= ctxStmt | ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsChan() {
-                       yyerror("invalid operation: %v (receive from non-chan type %v)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               if !t.ChanDir().CanRecv() {
-                       yyerror("invalid operation: %v (receive from send-only type %v)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = t.Elem()
-
-       case OSEND:
-               ok |= ctxStmt
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Right = typecheck(n.Right, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               t := n.Left.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsChan() {
-                       yyerror("invalid operation: %v (send to non-chan type %v)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               if !t.ChanDir().CanSend() {
-                       yyerror("invalid operation: %v (send to receive-only type %v)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               n.Right = assignconv(n.Right, t.Elem(), "send")
-               if n.Right.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               n.Type = nil
-
-       case OSLICEHEADER:
-               // Errors here are Fatalf instead of yyerror because only the compiler
-               // can construct an OSLICEHEADER node.
-               // Components used in OSLICEHEADER that are supplied by parsed source code
-               // have already been typechecked in e.g. OMAKESLICE earlier.
-               ok |= ctxExpr
-
-               t := n.Type
-               if t == nil {
-                       Fatalf("no type specified for OSLICEHEADER")
-               }
-
-               if !t.IsSlice() {
-                       Fatalf("invalid type %v for OSLICEHEADER", n.Type)
-               }
-
-               if n.Left == nil || n.Left.Type == nil || !n.Left.Type.IsUnsafePtr() {
-                       Fatalf("need unsafe.Pointer for OSLICEHEADER")
-               }
-
-               if x := n.List.Len(); x != 2 {
-                       Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
-               }
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               l := typecheck(n.List.First(), ctxExpr)
-               c := typecheck(n.List.Second(), ctxExpr)
-               l = defaultlit(l, types.Types[TINT])
-               c = defaultlit(c, types.Types[TINT])
-
-               if Isconst(l, CTINT) && l.Int64Val() < 0 {
-                       Fatalf("len for OSLICEHEADER must be non-negative")
-               }
-
-               if Isconst(c, CTINT) && c.Int64Val() < 0 {
-                       Fatalf("cap for OSLICEHEADER must be non-negative")
-               }
-
-               if Isconst(l, CTINT) && Isconst(c, CTINT) && l.Val().U.(*Mpint).Cmp(c.Val().U.(*Mpint)) > 0 {
-                       Fatalf("len larger than cap for OSLICEHEADER")
-               }
-
-               n.List.SetFirst(l)
-               n.List.SetSecond(c)
-
-       case OMAKESLICECOPY:
-               // Errors here are Fatalf instead of yyerror because only the compiler
-               // can construct an OMAKESLICECOPY node.
-               // Components used in OMAKESCLICECOPY that are supplied by parsed source code
-               // have already been typechecked in OMAKE and OCOPY earlier.
-               ok |= ctxExpr
-
-               t := n.Type
-
-               if t == nil {
-                       Fatalf("no type specified for OMAKESLICECOPY")
-               }
-
-               if !t.IsSlice() {
-                       Fatalf("invalid type %v for OMAKESLICECOPY", n.Type)
-               }
-
-               if n.Left == nil {
-                       Fatalf("missing len argument for OMAKESLICECOPY")
-               }
-
-               if n.Right == nil {
-                       Fatalf("missing slice argument to copy for OMAKESLICECOPY")
-               }
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Right = typecheck(n.Right, ctxExpr)
-
-               n.Left = defaultlit(n.Left, types.Types[TINT])
-
-               if !n.Left.Type.IsInteger() && n.Type.Etype != TIDEAL {
-                       yyerror("non-integer len argument in OMAKESLICECOPY")
-               }
-
-               if Isconst(n.Left, CTINT) {
-                       if n.Left.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
-                               Fatalf("len for OMAKESLICECOPY too large")
-                       }
-                       if n.Left.Int64Val() < 0 {
-                               Fatalf("len for OMAKESLICECOPY must be non-negative")
-                       }
-               }
-
-       case OSLICE, OSLICE3:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               low, high, max := n.SliceBounds()
-               hasmax := n.Op.IsSlice3()
-               low = typecheck(low, ctxExpr)
-               high = typecheck(high, ctxExpr)
-               max = typecheck(max, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               low = indexlit(low)
-               high = indexlit(high)
-               max = indexlit(max)
-               n.SetSliceBounds(low, high, max)
-               l := n.Left
-               if l.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               if l.Type.IsArray() {
-                       if !islvalue(n.Left) {
-                               yyerror("invalid operation %v (slice of unaddressable value)", n)
-                               n.Type = nil
-                               return n
-                       }
-
-                       n.Left = nod(OADDR, n.Left, nil)
-                       n.Left.SetImplicit(true)
-                       n.Left = typecheck(n.Left, ctxExpr)
-                       l = n.Left
-               }
-               t := l.Type
-               var tp *types.Type
-               if t.IsString() {
-                       if hasmax {
-                               yyerror("invalid operation %v (3-index slice of string)", n)
-                               n.Type = nil
-                               return n
-                       }
-                       n.Type = t
-                       n.Op = OSLICESTR
-               } else if t.IsPtr() && t.Elem().IsArray() {
-                       tp = t.Elem()
-                       n.Type = types.NewSlice(tp.Elem())
-                       dowidth(n.Type)
-                       if hasmax {
-                               n.Op = OSLICE3ARR
-                       } else {
-                               n.Op = OSLICEARR
-                       }
-               } else if t.IsSlice() {
-                       n.Type = t
-               } else {
-                       yyerror("cannot slice %v (type %v)", l, t)
-                       n.Type = nil
-                       return n
-               }
-
-               if low != nil && !checksliceindex(l, low, tp) {
-                       n.Type = nil
-                       return n
-               }
-               if high != nil && !checksliceindex(l, high, tp) {
-                       n.Type = nil
-                       return n
-               }
-               if max != nil && !checksliceindex(l, max, tp) {
-                       n.Type = nil
-                       return n
-               }
-               if !checksliceconst(low, high) || !checksliceconst(low, max) || !checksliceconst(high, max) {
-                       n.Type = nil
-                       return n
-               }
-
-       // call and call like
-       case OCALL:
-               typecheckslice(n.Ninit.Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
-               n.Left = typecheck(n.Left, ctxExpr|ctxType|ctxCallee)
-               if n.Left.Diag() {
-                       n.SetDiag(true)
-               }
-
-               l := n.Left
-
-               if l.Op == ONAME && l.SubOp() != 0 {
-                       if n.IsDDD() && l.SubOp() != OAPPEND {
-                               yyerror("invalid use of ... with builtin %v", l)
-                       }
-
-                       // builtin: OLEN, OCAP, etc.
-                       n.Op = l.SubOp()
-                       n.Left = n.Right
-                       n.Right = nil
-                       n = typecheck1(n, top)
-                       return n
-               }
-
-               n.Left = defaultlit(n.Left, nil)
-               l = n.Left
-               if l.Op == OTYPE {
-                       if n.IsDDD() {
-                               if !l.Type.Broke() {
-                                       yyerror("invalid use of ... in type conversion to %v", l.Type)
-                               }
-                               n.SetDiag(true)
-                       }
-
-                       // pick off before type-checking arguments
-                       ok |= ctxExpr
-
-                       // turn CALL(type, arg) into CONV(arg) w/ type
-                       n.Left = nil
-
-                       n.Op = OCONV
-                       n.Type = l.Type
-                       if !onearg(n, "conversion to %v", l.Type) {
-                               n.Type = nil
-                               return n
-                       }
-                       n = typecheck1(n, top)
-                       return n
-               }
-
-               typecheckargs(n)
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               checkwidth(t)
-
-               switch l.Op {
-               case ODOTINTER:
-                       n.Op = OCALLINTER
-
-               case ODOTMETH:
-                       n.Op = OCALLMETH
-
-                       // typecheckaste was used here but there wasn't enough
-                       // information further down the call chain to know if we
-                       // were testing a method receiver for unexported fields.
-                       // It isn't necessary, so just do a sanity check.
-                       tp := t.Recv().Type
-
-                       if l.Left == nil || !types.Identical(l.Left.Type, tp) {
-                               Fatalf("method receiver")
-                       }
-
-               default:
-                       n.Op = OCALLFUNC
-                       if t.Etype != TFUNC {
-                               name := l.String()
-                               if isBuiltinFuncName(name) && l.Name.Defn != nil {
-                                       // be more specific when the function
-                                       // name matches a predeclared function
-                                       yyerror("cannot call non-function %s (type %v), declared at %s",
-                                               name, t, linestr(l.Name.Defn.Pos))
-                               } else {
-                                       yyerror("cannot call non-function %s (type %v)", name, t)
-                               }
-                               n.Type = nil
-                               return n
-                       }
-               }
-
-               typecheckaste(OCALL, n.Left, n.IsDDD(), t.Params(), n.List, func() string { return fmt.Sprintf("argument to %v", n.Left) })
-               ok |= ctxStmt
-               if t.NumResults() == 0 {
-                       break
-               }
-               ok |= ctxExpr
-               if t.NumResults() == 1 {
-                       n.Type = l.Type.Results().Field(0).Type
-
-                       if n.Op == OCALLFUNC && n.Left.Op == ONAME && isRuntimePkg(n.Left.Sym.Pkg) && n.Left.Sym.Name == "getg" {
-                               // Emit code for runtime.getg() directly instead of calling function.
-                               // Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
-                               // so that the ordering pass can make sure to preserve the semantics of the original code
-                               // (in particular, the exact time of the function call) by introducing temporaries.
-                               // In this case, we know getg() always returns the same result within a given function
-                               // and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
-                               n.Op = OGETG
-                       }
-
-                       break
-               }
-
-               // multiple return
-               if top&(ctxMultiOK|ctxStmt) == 0 {
-                       yyerror("multiple-value %v() in single-value context", l)
-                       break
-               }
-
-               n.Type = l.Type.Results()
-
-       case OALIGNOF, OOFFSETOF, OSIZEOF:
-               ok |= ctxExpr
-               if !onearg(n, "%v", n.Op) {
-                       n.Type = nil
-                       return n
-               }
-               n.Type = types.Types[TUINTPTR]
-
-       case OCAP, OLEN:
-               ok |= ctxExpr
-               if !onearg(n, "%v", n.Op) {
-                       n.Type = nil
-                       return n
-               }
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               n.Left = implicitstar(n.Left)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               var ok bool
-               if n.Op == OLEN {
-                       ok = okforlen[t.Etype]
-               } else {
-                       ok = okforcap[t.Etype]
-               }
-               if !ok {
-                       yyerror("invalid argument %L for %v", l, n.Op)
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = types.Types[TINT]
-
-       case OREAL, OIMAG:
-               ok |= ctxExpr
-               if !onearg(n, "%v", n.Op) {
-                       n.Type = nil
-                       return n
-               }
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               // Determine result type.
-               switch t.Etype {
-               case TIDEAL:
-                       n.Type = types.UntypedFloat
-               case TCOMPLEX64:
-                       n.Type = types.Types[TFLOAT32]
-               case TCOMPLEX128:
-                       n.Type = types.Types[TFLOAT64]
-               default:
-                       yyerror("invalid argument %L for %v", l, n.Op)
-                       n.Type = nil
-                       return n
-               }
-
-       case OCOMPLEX:
-               ok |= ctxExpr
-               typecheckargs(n)
-               if !twoarg(n) {
-                       n.Type = nil
-                       return n
-               }
-               l := n.Left
-               r := n.Right
-               if l.Type == nil || r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               l, r = defaultlit2(l, r, false)
-               if l.Type == nil || r.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               n.Left = l
-               n.Right = r
-
-               if !types.Identical(l.Type, r.Type) {
-                       yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
-                       n.Type = nil
-                       return n
-               }
-
-               var t *types.Type
-               switch l.Type.Etype {
-               default:
-                       yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type)
-                       n.Type = nil
-                       return n
-
-               case TIDEAL:
-                       t = types.UntypedComplex
-
-               case TFLOAT32:
-                       t = types.Types[TCOMPLEX64]
-
-               case TFLOAT64:
-                       t = types.Types[TCOMPLEX128]
-               }
-               n.Type = t
-
-       case OCLOSE:
-               if !onearg(n, "%v", n.Op) {
-                       n.Type = nil
-                       return n
-               }
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               l := n.Left
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsChan() {
-                       yyerror("invalid operation: %v (non-chan type %v)", n, t)
-                       n.Type = nil
-                       return n
-               }
-
-               if !t.ChanDir().CanSend() {
-                       yyerror("invalid operation: %v (cannot close receive-only channel)", n)
-                       n.Type = nil
-                       return n
-               }
-
-               ok |= ctxStmt
-
-       case ODELETE:
-               ok |= ctxStmt
-               typecheckargs(n)
-               args := n.List
-               if args.Len() == 0 {
-                       yyerror("missing arguments to delete")
-                       n.Type = nil
-                       return n
-               }
-
-               if args.Len() == 1 {
-                       yyerror("missing second (key) argument to delete")
-                       n.Type = nil
-                       return n
-               }
-
-               if args.Len() != 2 {
-                       yyerror("too many arguments to delete")
-                       n.Type = nil
-                       return n
-               }
-
-               l := args.First()
-               r := args.Second()
-               if l.Type != nil && !l.Type.IsMap() {
-                       yyerror("first argument to delete must be map; have %L", l.Type)
-                       n.Type = nil
-                       return n
-               }
-
-               args.SetSecond(assignconv(r, l.Type.Key(), "delete"))
-
-       case OAPPEND:
-               ok |= ctxExpr
-               typecheckargs(n)
-               args := n.List
-               if args.Len() == 0 {
-                       yyerror("missing arguments to append")
-                       n.Type = nil
-                       return n
-               }
-
-               t := args.First().Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = t
-               if !t.IsSlice() {
-                       if Isconst(args.First(), CTNIL) {
-                               yyerror("first argument to append must be typed slice; have untyped nil")
-                               n.Type = nil
-                               return n
-                       }
-
-                       yyerror("first argument to append must be slice; have %L", t)
-                       n.Type = nil
-                       return n
-               }
-
-               if n.IsDDD() {
-                       if args.Len() == 1 {
-                               yyerror("cannot use ... on first argument to append")
-                               n.Type = nil
-                               return n
-                       }
-
-                       if args.Len() != 2 {
-                               yyerror("too many arguments to append")
-                               n.Type = nil
-                               return n
-                       }
-
-                       if t.Elem().IsKind(TUINT8) && args.Second().Type.IsString() {
-                               args.SetSecond(defaultlit(args.Second(), types.Types[TSTRING]))
-                               break
-                       }
-
-                       args.SetSecond(assignconv(args.Second(), t.Orig, "append"))
-                       break
-               }
-
-               as := args.Slice()[1:]
-               for i, n := range as {
-                       if n.Type == nil {
-                               continue
-                       }
-                       as[i] = assignconv(n, t.Elem(), "append")
-                       checkwidth(as[i].Type) // ensure width is calculated for backend
-               }
-
-       case OCOPY:
-               ok |= ctxStmt | ctxExpr
-               typecheckargs(n)
-               if !twoarg(n) {
-                       n.Type = nil
-                       return n
-               }
-               n.Type = types.Types[TINT]
-               if n.Left.Type == nil || n.Right.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               n.Left = defaultlit(n.Left, nil)
-               n.Right = defaultlit(n.Right, nil)
-               if n.Left.Type == nil || n.Right.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               // copy([]byte, string)
-               if n.Left.Type.IsSlice() && n.Right.Type.IsString() {
-                       if types.Identical(n.Left.Type.Elem(), types.Bytetype) {
-                               break
-                       }
-                       yyerror("arguments to copy have different element types: %L and string", n.Left.Type)
-                       n.Type = nil
-                       return n
-               }
-
-               if !n.Left.Type.IsSlice() || !n.Right.Type.IsSlice() {
-                       if !n.Left.Type.IsSlice() && !n.Right.Type.IsSlice() {
-                               yyerror("arguments to copy must be slices; have %L, %L", n.Left.Type, n.Right.Type)
-                       } else if !n.Left.Type.IsSlice() {
-                               yyerror("first argument to copy should be slice; have %L", n.Left.Type)
-                       } else {
-                               yyerror("second argument to copy should be slice or string; have %L", n.Right.Type)
-                       }
-                       n.Type = nil
-                       return n
-               }
-
-               if !types.Identical(n.Left.Type.Elem(), n.Right.Type.Elem()) {
-                       yyerror("arguments to copy have different element types: %L and %L", n.Left.Type, n.Right.Type)
-                       n.Type = nil
-                       return n
-               }
-
-       case OCONV:
-               ok |= ctxExpr
-               checkwidth(n.Type) // ensure width is calculated for backend
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = convlit1(n.Left, n.Type, true, nil)
-               t := n.Left.Type
-               if t == nil || n.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               var why string
-               n.Op, why = convertop(n.Left.Op == OLITERAL, t, n.Type)
-               if n.Op == OXXX {
-                       if !n.Diag() && !n.Type.Broke() && !n.Left.Diag() {
-                               yyerror("cannot convert %L to type %v%s", n.Left, n.Type, why)
-                               n.SetDiag(true)
-                       }
-                       n.Op = OCONV
-                       n.Type = nil
-                       return n
-               }
-
-               switch n.Op {
-               case OCONVNOP:
-                       if t.Etype == n.Type.Etype {
-                               switch t.Etype {
-                               case TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128:
-                                       // Floating point casts imply rounding and
-                                       // so the conversion must be kept.
-                                       n.Op = OCONV
-                               }
-                       }
-
-               // do not convert to []byte literal. See CL 125796.
-               // generated code and compiler memory footprint is better without it.
-               case OSTR2BYTES:
-                       break
-
-               case OSTR2RUNES:
-                       if n.Left.Op == OLITERAL {
-                               n = stringtoruneslit(n)
-                       }
-               }
-
-       case OMAKE:
-               ok |= ctxExpr
-               args := n.List.Slice()
-               if len(args) == 0 {
-                       yyerror("missing argument to make")
-                       n.Type = nil
-                       return n
-               }
-
-               n.List.Set(nil)
-               l := args[0]
-               l = typecheck(l, ctxType)
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-
-               i := 1
-               switch t.Etype {
-               default:
-                       yyerror("cannot make type %v", t)
-                       n.Type = nil
-                       return n
-
-               case TSLICE:
-                       if i >= len(args) {
-                               yyerror("missing len argument to make(%v)", t)
-                               n.Type = nil
-                               return n
-                       }
-
-                       l = args[i]
-                       i++
-                       l = typecheck(l, ctxExpr)
-                       var r *Node
-                       if i < len(args) {
-                               r = args[i]
-                               i++
-                               r = typecheck(r, ctxExpr)
-                       }
-
-                       if l.Type == nil || (r != nil && r.Type == nil) {
-                               n.Type = nil
-                               return n
-                       }
-                       if !checkmake(t, "len", &l) || r != nil && !checkmake(t, "cap", &r) {
-                               n.Type = nil
-                               return n
-                       }
-                       if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && l.Val().U.(*Mpint).Cmp(r.Val().U.(*Mpint)) > 0 {
-                               yyerror("len larger than cap in make(%v)", t)
-                               n.Type = nil
-                               return n
-                       }
-
-                       n.Left = l
-                       n.Right = r
-                       n.Op = OMAKESLICE
-
-               case TMAP:
-                       if i < len(args) {
-                               l = args[i]
-                               i++
-                               l = typecheck(l, ctxExpr)
-                               l = defaultlit(l, types.Types[TINT])
-                               if l.Type == nil {
-                                       n.Type = nil
-                                       return n
-                               }
-                               if !checkmake(t, "size", &l) {
-                                       n.Type = nil
-                                       return n
-                               }
-                               n.Left = l
-                       } else {
-                               n.Left = nodintconst(0)
-                       }
-                       n.Op = OMAKEMAP
-
-               case TCHAN:
-                       l = nil
-                       if i < len(args) {
-                               l = args[i]
-                               i++
-                               l = typecheck(l, ctxExpr)
-                               l = defaultlit(l, types.Types[TINT])
-                               if l.Type == nil {
-                                       n.Type = nil
-                                       return n
-                               }
-                               if !checkmake(t, "buffer", &l) {
-                                       n.Type = nil
-                                       return n
-                               }
-                               n.Left = l
-                       } else {
-                               n.Left = nodintconst(0)
-                       }
-                       n.Op = OMAKECHAN
-               }
-
-               if i < len(args) {
-                       yyerror("too many arguments to make(%v)", t)
-                       n.Op = OMAKE
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = t
-
-       case ONEW:
-               ok |= ctxExpr
-               args := n.List
-               if args.Len() == 0 {
-                       yyerror("missing argument to new")
-                       n.Type = nil
-                       return n
-               }
-
-               l := args.First()
-               l = typecheck(l, ctxType)
-               t := l.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if args.Len() > 1 {
-                       yyerror("too many arguments to new(%v)", t)
-                       n.Type = nil
-                       return n
-               }
-
-               n.Left = l
-               n.Type = types.NewPtr(t)
-
-       case OPRINT, OPRINTN:
-               ok |= ctxStmt
-               typecheckargs(n)
-               ls := n.List.Slice()
-               for i1, n1 := range ls {
-                       // Special case for print: int constant is int64, not int.
-                       if Isconst(n1, CTINT) {
-                               ls[i1] = defaultlit(ls[i1], types.Types[TINT64])
-                       } else {
-                               ls[i1] = defaultlit(ls[i1], nil)
-                       }
-               }
-
-       case OPANIC:
-               ok |= ctxStmt
-               if !onearg(n, "panic") {
-                       n.Type = nil
-                       return n
-               }
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, types.Types[TINTER])
-               if n.Left.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-
-       case ORECOVER:
-               ok |= ctxExpr | ctxStmt
-               if n.List.Len() != 0 {
-                       yyerror("too many arguments to recover")
-                       n.Type = nil
-                       return n
-               }
-
-               n.Type = types.Types[TINTER]
-
-       case OCLOSURE:
-               ok |= ctxExpr
-               typecheckclosure(n, top)
-               if n.Type == nil {
-                       return n
-               }
-
-       case OITAB:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               t := n.Left.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsInterface() {
-                       Fatalf("OITAB of %v", t)
-               }
-               n.Type = types.NewPtr(types.Types[TUINTPTR])
-
-       case OIDATA:
-               // Whoever creates the OIDATA node must know a priori the concrete type at that moment,
-               // usually by just having checked the OITAB.
-               Fatalf("cannot typecheck interface data %v", n)
-
-       case OSPTR:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               t := n.Left.Type
-               if t == nil {
-                       n.Type = nil
-                       return n
-               }
-               if !t.IsSlice() && !t.IsString() {
-                       Fatalf("OSPTR of %v", t)
-               }
-               if t.IsString() {
-                       n.Type = types.NewPtr(types.Types[TUINT8])
-               } else {
-                       n.Type = types.NewPtr(t.Elem())
-               }
-
-       case OCLOSUREVAR:
-               ok |= ctxExpr
-
-       case OCFUNC:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Type = types.Types[TUINTPTR]
-
-       case OCONVNOP:
-               ok |= ctxExpr
-               n.Left = typecheck(n.Left, ctxExpr)
-
-       // statements
-       case OAS:
-               ok |= ctxStmt
-
-               typecheckas(n)
-
-               // Code that creates temps does not bother to set defn, so do it here.
-               if n.Left.Op == ONAME && n.Left.IsAutoTmp() {
-                       n.Left.Name.Defn = n
-               }
-
-       case OAS2:
-               ok |= ctxStmt
-               typecheckas2(n)
-
-       case OBREAK,
-               OCONTINUE,
-               ODCL,
-               OEMPTY,
-               OGOTO,
-               OFALL,
-               OVARKILL,
-               OVARLIVE:
-               ok |= ctxStmt
-
-       case OLABEL:
-               ok |= ctxStmt
-               decldepth++
-               if n.Sym.IsBlank() {
-                       // Empty identifier is valid but useless.
-                       // Eliminate now to simplify life later.
-                       // See issues 7538, 11589, 11593.
-                       n.Op = OEMPTY
-                       n.Left = nil
-               }
-
-       case ODEFER:
-               ok |= ctxStmt
-               n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
-               if !n.Left.Diag() {
-                       checkdefergo(n)
-               }
-
-       case OGO:
-               ok |= ctxStmt
-               n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
-               checkdefergo(n)
-
-       case OFOR, OFORUNTIL:
-               ok |= ctxStmt
-               typecheckslice(n.Ninit.Slice(), ctxStmt)
-               decldepth++
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               if n.Left != nil {
-                       t := n.Left.Type
-                       if t != nil && !t.IsBoolean() {
-                               yyerror("non-bool %L used as for condition", n.Left)
-                       }
-               }
-               n.Right = typecheck(n.Right, ctxStmt)
-               if n.Op == OFORUNTIL {
-                       typecheckslice(n.List.Slice(), ctxStmt)
-               }
-               typecheckslice(n.Nbody.Slice(), ctxStmt)
-               decldepth--
-
-       case OIF:
-               ok |= ctxStmt
-               typecheckslice(n.Ninit.Slice(), ctxStmt)
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               if n.Left != nil {
-                       t := n.Left.Type
-                       if t != nil && !t.IsBoolean() {
-                               yyerror("non-bool %L used as if condition", n.Left)
-                       }
-               }
-               typecheckslice(n.Nbody.Slice(), ctxStmt)
-               typecheckslice(n.Rlist.Slice(), ctxStmt)
-
-       case ORETURN:
-               ok |= ctxStmt
-               typecheckargs(n)
-               if Curfn == nil {
-                       yyerror("return outside function")
-                       n.Type = nil
-                       return n
-               }
-
-               if Curfn.Type.FuncType().Outnamed && n.List.Len() == 0 {
-                       break
-               }
-               typecheckaste(ORETURN, nil, false, Curfn.Type.Results(), n.List, func() string { return "return argument" })
-
-       case ORETJMP:
-               ok |= ctxStmt
-
-       case OSELECT:
-               ok |= ctxStmt
-               typecheckselect(n)
-
-       case OSWITCH:
-               ok |= ctxStmt
-               typecheckswitch(n)
-
-       case ORANGE:
-               ok |= ctxStmt
-               typecheckrange(n)
-
-       case OTYPESW:
-               yyerror("use of .(type) outside type switch")
-               n.Type = nil
-               return n
-
-       case ODCLFUNC:
-               ok |= ctxStmt
-               typecheckfunc(n)
-
-       case ODCLCONST:
-               ok |= ctxStmt
-               n.Left = typecheck(n.Left, ctxExpr)
-
-       case ODCLTYPE:
-               ok |= ctxStmt
-               n.Left = typecheck(n.Left, ctxType)
-               checkwidth(n.Left.Type)
-       }
-
-       t := n.Type
-       if t != nil && !t.IsFuncArgStruct() && n.Op != OTYPE {
-               switch t.Etype {
-               case TFUNC, // might have TANY; wait until it's called
-                       TANY, TFORW, TIDEAL, TNIL, TBLANK:
-                       break
-
-               default:
-                       checkwidth(t)
-               }
-       }
-
-       evconst(n)
-       if n.Op == OTYPE && top&ctxType == 0 {
-               if !n.Type.Broke() {
-                       yyerror("type %v is not an expression", n.Type)
-               }
-               n.Type = nil
-               return n
-       }
-
-       if top&(ctxExpr|ctxType) == ctxType && n.Op != OTYPE {
-               yyerror("%v is not a type", n)
-               n.Type = nil
-               return n
-       }
-
-       // TODO(rsc): simplify
-       if (top&(ctxCallee|ctxExpr|ctxType) != 0) && top&ctxStmt == 0 && ok&(ctxExpr|ctxType|ctxCallee) == 0 {
-               yyerror("%v used as value", n)
-               n.Type = nil
-               return n
-       }
-
-       if (top&ctxStmt != 0) && top&(ctxCallee|ctxExpr|ctxType) == 0 && ok&ctxStmt == 0 {
-               if !n.Diag() {
-                       yyerror("%v evaluated but not used", n)
-                       n.SetDiag(true)
-               }
-
-               n.Type = nil
-               return n
-       }
-
-       return n
-}
-
-func typecheckargs(n *Node) {
-       if n.List.Len() != 1 || n.IsDDD() {
-               typecheckslice(n.List.Slice(), ctxExpr)
-               return
-       }
-
-       typecheckslice(n.List.Slice(), ctxExpr|ctxMultiOK)
-       t := n.List.First().Type
-       if t == nil || !t.IsFuncArgStruct() {
-               return
-       }
-
-       // Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
-
-       // Save n as n.Orig for fmt.go.
-       if n.Orig == n {
-               n.Orig = n.sepcopy()
-       }
-
-       as := nod(OAS2, nil, nil)
-       as.Rlist.AppendNodes(&n.List)
-
-       // If we're outside of function context, then this call will
-       // be executed during the generated init function. However,
-       // init.go hasn't yet created it. Instead, associate the
-       // temporary variables with dummyInitFn for now, and init.go
-       // will reassociate them later when it's appropriate.
-       static := Curfn == nil
-       if static {
-               Curfn = dummyInitFn
-       }
-       for _, f := range t.FieldSlice() {
-               t := temp(f.Type)
-               as.Ninit.Append(nod(ODCL, t, nil))
-               as.List.Append(t)
-               n.List.Append(t)
-       }
-       if static {
-               Curfn = nil
-       }
-
-       as = typecheck(as, ctxStmt)
-       n.Ninit.Append(as)
-}
-
-func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
-       t := r.Type
-       if t == nil {
-               return false
-       }
-       if !t.IsInteger() {
-               yyerror("invalid slice index %v (type %v)", r, t)
-               return false
-       }
-
-       if r.Op == OLITERAL {
-               if r.Int64Val() < 0 {
-                       yyerror("invalid slice index %v (index must be non-negative)", r)
-                       return false
-               } else if tp != nil && tp.NumElem() >= 0 && r.Int64Val() > tp.NumElem() {
-                       yyerror("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
-                       return false
-               } else if Isconst(l, CTSTR) && r.Int64Val() > int64(len(l.StringVal())) {
-                       yyerror("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
-                       return false
-               } else if r.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
-                       yyerror("invalid slice index %v (index too large)", r)
-                       return false
-               }
-       }
-
-       return true
-}
-
-func checksliceconst(lo *Node, hi *Node) bool {
-       if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && lo.Val().U.(*Mpint).Cmp(hi.Val().U.(*Mpint)) > 0 {
-               yyerror("invalid slice index: %v > %v", lo, hi)
-               return false
-       }
-
-       return true
-}
-
-func checkdefergo(n *Node) {
-       what := "defer"
-       if n.Op == OGO {
-               what = "go"
-       }
-
-       switch n.Left.Op {
-       // ok
-       case OCALLINTER,
-               OCALLMETH,
-               OCALLFUNC,
-               OCLOSE,
-               OCOPY,
-               ODELETE,
-               OPANIC,
-               OPRINT,
-               OPRINTN,
-               ORECOVER:
-               return
-
-       case OAPPEND,
-               OCAP,
-               OCOMPLEX,
-               OIMAG,
-               OLEN,
-               OMAKE,
-               OMAKESLICE,
-               OMAKECHAN,
-               OMAKEMAP,
-               ONEW,
-               OREAL,
-               OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-               if n.Left.Orig != nil && n.Left.Orig.Op == OCONV {
-                       break
-               }
-               yyerrorl(n.Pos, "%s discards result of %v", what, n.Left)
-               return
-       }
-
-       // type is broken or missing, most likely a method call on a broken type
-       // we will warn about the broken type elsewhere. no need to emit a potentially confusing error
-       if n.Left.Type == nil || n.Left.Type.Broke() {
-               return
-       }
-
-       if !n.Diag() {
-               // The syntax made sure it was a call, so this must be
-               // a conversion.
-               n.SetDiag(true)
-               yyerrorl(n.Pos, "%s requires function call, not conversion", what)
-       }
-}
-
-// The result of implicitstar MUST be assigned back to n, e.g.
-//     n.Left = implicitstar(n.Left)
-func implicitstar(n *Node) *Node {
-       // insert implicit * if needed for fixed array
-       t := n.Type
-       if t == nil || !t.IsPtr() {
-               return n
-       }
-       t = t.Elem()
-       if t == nil {
-               return n
-       }
-       if !t.IsArray() {
-               return n
-       }
-       n = nod(ODEREF, n, nil)
-       n.SetImplicit(true)
-       n = typecheck(n, ctxExpr)
-       return n
-}
-
-func onearg(n *Node, f string, args ...interface{}) bool {
-       if n.Left != nil {
-               return true
-       }
-       if n.List.Len() == 0 {
-               p := fmt.Sprintf(f, args...)
-               yyerror("missing argument to %s: %v", p, n)
-               return false
-       }
-
-       if n.List.Len() > 1 {
-               p := fmt.Sprintf(f, args...)
-               yyerror("too many arguments to %s: %v", p, n)
-               n.Left = n.List.First()
-               n.List.Set(nil)
-               return false
-       }
-
-       n.Left = n.List.First()
-       n.List.Set(nil)
-       return true
-}
-
-func twoarg(n *Node) bool {
-       if n.Left != nil {
-               return true
-       }
-       if n.List.Len() != 2 {
-               if n.List.Len() < 2 {
-                       yyerror("not enough arguments in call to %v", n)
-               } else {
-                       yyerror("too many arguments in call to %v", n)
-               }
-               return false
-       }
-       n.Left = n.List.First()
-       n.Right = n.List.Second()
-       n.List.Set(nil)
-       return true
-}
-
-func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
-       var r *types.Field
-       for _, f := range fs.Slice() {
-               if dostrcmp != 0 && f.Sym.Name == s.Name {
-                       return f
-               }
-               if dostrcmp == 2 && strings.EqualFold(f.Sym.Name, s.Name) {
-                       return f
-               }
-               if f.Sym != s {
-                       continue
-               }
-               if r != nil {
-                       if errnode != nil {
-                               yyerror("ambiguous selector %v", errnode)
-                       } else if t.IsPtr() {
-                               yyerror("ambiguous selector (%v).%v", t, s)
-                       } else {
-                               yyerror("ambiguous selector %v.%v", t, s)
-                       }
-                       break
-               }
-
-               r = f
-       }
-
-       return r
-}
-
-// typecheckMethodExpr checks selector expressions (ODOT) where the
-// base expression is a type expression (OTYPE).
-func typecheckMethodExpr(n *Node) (res *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckMethodExpr", n)(&res)
-       }
-
-       t := n.Left.Type
-
-       // Compute the method set for t.
-       var ms *types.Fields
-       if t.IsInterface() {
-               ms = t.Fields()
-       } else {
-               mt := methtype(t)
-               if mt == nil {
-                       yyerror("%v undefined (type %v has no method %v)", n, t, n.Sym)
-                       n.Type = nil
-                       return n
-               }
-               expandmeth(mt)
-               ms = mt.AllMethods()
-
-               // The method expression T.m requires a wrapper when T
-               // is different from m's declared receiver type. We
-               // normally generate these wrappers while writing out
-               // runtime type descriptors, which is always done for
-               // types declared at package scope. However, we need
-               // to make sure to generate wrappers for anonymous
-               // receiver types too.
-               if mt.Sym == nil {
-                       addsignat(t)
-               }
-       }
-
-       s := n.Sym
-       m := lookdot1(n, s, t, ms, 0)
-       if m == nil {
-               if lookdot1(n, s, t, ms, 1) != nil {
-                       yyerror("%v undefined (cannot refer to unexported method %v)", n, s)
-               } else if _, ambig := dotpath(s, t, nil, false); ambig {
-                       yyerror("%v undefined (ambiguous selector)", n) // method or field
-               } else {
-                       yyerror("%v undefined (type %v has no method %v)", n, t, s)
-               }
-               n.Type = nil
-               return n
-       }
-
-       if !isMethodApplicable(t, m) {
-               yyerror("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
-               n.Type = nil
-               return n
-       }
-
-       n.Op = ONAME
-       if n.Name == nil {
-               n.Name = new(Name)
-       }
-       n.Right = newname(n.Sym)
-       n.Sym = methodSym(t, n.Sym)
-       n.Type = methodfunc(m.Type, n.Left.Type)
-       n.Xoffset = 0
-       n.SetClass(PFUNC)
-       // methodSym already marked n.Sym as a function.
-
-       // Issue 25065. Make sure that we emit the symbol for a local method.
-       if Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == localpkg) {
-               makefuncsym(n.Sym)
-       }
-
-       return n
-}
-
-// isMethodApplicable reports whether method m can be called on a
-// value of type t. This is necessary because we compute a single
-// method set for both T and *T, but some *T methods are not
-// applicable to T receivers.
-func isMethodApplicable(t *types.Type, m *types.Field) bool {
-       return t.IsPtr() || !m.Type.Recv().Type.IsPtr() || isifacemethod(m.Type) || m.Embedded == 2
-}
-
-func derefall(t *types.Type) *types.Type {
-       for t != nil && t.IsPtr() {
-               t = t.Elem()
-       }
-       return t
-}
-
-func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
-       s := n.Sym
-
-       dowidth(t)
-       var f1 *types.Field
-       if t.IsStruct() || t.IsInterface() {
-               f1 = lookdot1(n, s, t, t.Fields(), dostrcmp)
-       }
-
-       var f2 *types.Field
-       if n.Left.Type == t || n.Left.Type.Sym == nil {
-               mt := methtype(t)
-               if mt != nil {
-                       f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
-               }
-       }
-
-       if f1 != nil {
-               if dostrcmp > 1 || f1.Broke() {
-                       // Already in the process of diagnosing an error.
-                       return f1
-               }
-               if f2 != nil {
-                       yyerror("%v is both field and method", n.Sym)
-               }
-               if f1.Offset == BADWIDTH {
-                       Fatalf("lookdot badwidth %v %p", f1, f1)
-               }
-               n.Xoffset = f1.Offset
-               n.Type = f1.Type
-               if t.IsInterface() {
-                       if n.Left.Type.IsPtr() {
-                               n.Left = nod(ODEREF, n.Left, nil) // implicitstar
-                               n.Left.SetImplicit(true)
-                               n.Left = typecheck(n.Left, ctxExpr)
-                       }
-
-                       n.Op = ODOTINTER
-               } else {
-                       n.SetOpt(f1)
-               }
-
-               return f1
-       }
-
-       if f2 != nil {
-               if dostrcmp > 1 {
-                       // Already in the process of diagnosing an error.
-                       return f2
-               }
-               tt := n.Left.Type
-               dowidth(tt)
-               rcvr := f2.Type.Recv().Type
-               if !types.Identical(rcvr, tt) {
-                       if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
-                               checklvalue(n.Left, "call pointer method on")
-                               n.Left = nod(OADDR, n.Left, nil)
-                               n.Left.SetImplicit(true)
-                               n.Left = typecheck(n.Left, ctxType|ctxExpr)
-                       } else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-                               n.Left = nod(ODEREF, n.Left, nil)
-                               n.Left.SetImplicit(true)
-                               n.Left = typecheck(n.Left, ctxType|ctxExpr)
-                       } else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
-                               yyerror("calling method %v with receiver %L requires explicit dereference", n.Sym, n.Left)
-                               for tt.IsPtr() {
-                                       // Stop one level early for method with pointer receiver.
-                                       if rcvr.IsPtr() && !tt.Elem().IsPtr() {
-                                               break
-                                       }
-                                       n.Left = nod(ODEREF, n.Left, nil)
-                                       n.Left.SetImplicit(true)
-                                       n.Left = typecheck(n.Left, ctxType|ctxExpr)
-                                       tt = tt.Elem()
-                               }
-                       } else {
-                               Fatalf("method mismatch: %v for %v", rcvr, tt)
-                       }
-               }
-
-               pll := n
-               ll := n.Left
-               for ll.Left != nil && (ll.Op == ODOT || ll.Op == ODOTPTR || ll.Op == ODEREF) {
-                       pll = ll
-                       ll = ll.Left
-               }
-               if pll.Implicit() && ll.Type.IsPtr() && ll.Type.Sym != nil && asNode(ll.Type.Sym.Def) != nil && asNode(ll.Type.Sym.Def).Op == OTYPE {
-                       // It is invalid to automatically dereference a named pointer type when selecting a method.
-                       // Make n.Left == ll to clarify error message.
-                       n.Left = ll
-                       return nil
-               }
-
-               n.Sym = methodSym(n.Left.Type, f2.Sym)
-               n.Xoffset = f2.Offset
-               n.Type = f2.Type
-               n.Op = ODOTMETH
-
-               return f2
-       }
-
-       return nil
-}
-
-func nokeys(l Nodes) bool {
-       for _, n := range l.Slice() {
-               if n.Op == OKEY || n.Op == OSTRUCTKEY {
-                       return false
-               }
-       }
-       return true
-}
-
-func hasddd(t *types.Type) bool {
-       for _, tl := range t.Fields().Slice() {
-               if tl.IsDDD() {
-                       return true
-               }
-       }
-
-       return false
-}
-
-// typecheck assignment: type list = expression list
-func typecheckaste(op Op, call *Node, isddd bool, tstruct *types.Type, nl Nodes, desc func() string) {
-       var t *types.Type
-       var i int
-
-       lno := lineno
-       defer func() { lineno = lno }()
-
-       if tstruct.Broke() {
-               return
-       }
-
-       var n *Node
-       if nl.Len() == 1 {
-               n = nl.First()
-       }
-
-       n1 := tstruct.NumFields()
-       n2 := nl.Len()
-       if !hasddd(tstruct) {
-               if n2 > n1 {
-                       goto toomany
-               }
-               if n2 < n1 {
-                       goto notenough
-               }
-       } else {
-               if !isddd {
-                       if n2 < n1-1 {
-                               goto notenough
-                       }
-               } else {
-                       if n2 > n1 {
-                               goto toomany
-                       }
-                       if n2 < n1 {
-                               goto notenough
-                       }
-               }
-       }
-
-       i = 0
-       for _, tl := range tstruct.Fields().Slice() {
-               t = tl.Type
-               if tl.IsDDD() {
-                       if isddd {
-                               if i >= nl.Len() {
-                                       goto notenough
-                               }
-                               if nl.Len()-i > 1 {
-                                       goto toomany
-                               }
-                               n = nl.Index(i)
-                               setlineno(n)
-                               if n.Type != nil {
-                                       nl.SetIndex(i, assignconvfn(n, t, desc))
-                               }
-                               return
-                       }
-
-                       // TODO(mdempsky): Make into ... call with implicit slice.
-                       for ; i < nl.Len(); i++ {
-                               n = nl.Index(i)
-                               setlineno(n)
-                               if n.Type != nil {
-                                       nl.SetIndex(i, assignconvfn(n, t.Elem(), desc))
-                               }
-                       }
-                       return
-               }
-
-               if i >= nl.Len() {
-                       goto notenough
-               }
-               n = nl.Index(i)
-               setlineno(n)
-               if n.Type != nil {
-                       nl.SetIndex(i, assignconvfn(n, t, desc))
-               }
-               i++
-       }
-
-       if i < nl.Len() {
-               goto toomany
-       }
-       if isddd {
-               if call != nil {
-                       yyerror("invalid use of ... in call to %v", call)
-               } else {
-                       yyerror("invalid use of ... in %v", op)
-               }
-       }
-       return
-
-notenough:
-       if n == nil || (!n.Diag() && n.Type != nil) {
-               details := errorDetails(nl, tstruct, isddd)
-               if call != nil {
-                       // call is the expression being called, not the overall call.
-                       // Method expressions have the form T.M, and the compiler has
-                       // rewritten those to ONAME nodes but left T in Left.
-                       if call.isMethodExpression() {
-                               yyerror("not enough arguments in call to method expression %v%s", call, details)
-                       } else {
-                               yyerror("not enough arguments in call to %v%s", call, details)
-                       }
-               } else {
-                       yyerror("not enough arguments to %v%s", op, details)
-               }
-               if n != nil {
-                       n.SetDiag(true)
-               }
-       }
-       return
-
-toomany:
-       details := errorDetails(nl, tstruct, isddd)
-       if call != nil {
-               yyerror("too many arguments in call to %v%s", call, details)
-       } else {
-               yyerror("too many arguments to %v%s", op, details)
-       }
-}
-
-func errorDetails(nl Nodes, tstruct *types.Type, isddd bool) string {
-       // If we don't know any type at a call site, let's suppress any return
-       // message signatures. See Issue https://golang.org/issues/19012.
-       if tstruct == nil {
-               return ""
-       }
-       // If any node has an unknown type, suppress it as well
-       for _, n := range nl.Slice() {
-               if n.Type == nil {
-                       return ""
-               }
-       }
-       return fmt.Sprintf("\n\thave %s\n\twant %v", nl.sigerr(isddd), tstruct)
-}
-
-// sigrepr is a type's representation to the outside world,
-// in string representations of return signatures
-// e.g in error messages about wrong arguments to return.
-func sigrepr(t *types.Type, isddd bool) string {
-       switch t {
-       case types.UntypedString:
-               return "string"
-       case types.UntypedBool:
-               return "bool"
-       }
-
-       if t.Etype == TIDEAL {
-               // "untyped number" is not commonly used
-               // outside of the compiler, so let's use "number".
-               // TODO(mdempsky): Revisit this.
-               return "number"
-       }
-
-       // Turn []T... argument to ...T for clearer error message.
-       if isddd {
-               if !t.IsSlice() {
-                       Fatalf("bad type for ... argument: %v", t)
-               }
-               return "..." + t.Elem().String()
-       }
-       return t.String()
-}
-
-// sigerr returns the signature of the types at the call or return.
-func (nl Nodes) sigerr(isddd bool) string {
-       if nl.Len() < 1 {
-               return "()"
-       }
-
-       var typeStrings []string
-       for i, n := range nl.Slice() {
-               isdddArg := isddd && i == nl.Len()-1
-               typeStrings = append(typeStrings, sigrepr(n.Type, isdddArg))
-       }
-
-       return fmt.Sprintf("(%s)", strings.Join(typeStrings, ", "))
-}
-
-// type check composite
-func fielddup(name string, hash map[string]bool) {
-       if hash[name] {
-               yyerror("duplicate field name in struct literal: %s", name)
-               return
-       }
-       hash[name] = true
-}
-
-// iscomptype reports whether type t is a composite literal type.
-func iscomptype(t *types.Type) bool {
-       switch t.Etype {
-       case TARRAY, TSLICE, TSTRUCT, TMAP:
-               return true
-       default:
-               return false
-       }
-}
-
-// pushtype adds elided type information for composite literals if
-// appropriate, and returns the resulting expression.
-func pushtype(n *Node, t *types.Type) *Node {
-       if n == nil || n.Op != OCOMPLIT || n.Right != nil {
-               return n
-       }
-
-       switch {
-       case iscomptype(t):
-               // For T, return T{...}.
-               n.Right = typenod(t)
-
-       case t.IsPtr() && iscomptype(t.Elem()):
-               // For *T, return &T{...}.
-               n.Right = typenod(t.Elem())
-
-               n = nodl(n.Pos, OADDR, n, nil)
-               n.SetImplicit(true)
-       }
-
-       return n
-}
-
-// The result of typecheckcomplit MUST be assigned back to n, e.g.
-//     n.Left = typecheckcomplit(n.Left)
-func typecheckcomplit(n *Node) (res *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckcomplit", n)(&res)
-       }
-
-       lno := lineno
-       defer func() {
-               lineno = lno
-       }()
-
-       if n.Right == nil {
-               yyerrorl(n.Pos, "missing type in composite literal")
-               n.Type = nil
-               return n
-       }
-
-       // Save original node (including n.Right)
-       n.Orig = n.copy()
-
-       setlineno(n.Right)
-
-       // Need to handle [...]T arrays specially.
-       if n.Right.Op == OTARRAY && n.Right.Left != nil && n.Right.Left.Op == ODDD {
-               n.Right.Right = typecheck(n.Right.Right, ctxType)
-               if n.Right.Right.Type == nil {
-                       n.Type = nil
-                       return n
-               }
-               elemType := n.Right.Right.Type
-
-               length := typecheckarraylit(elemType, -1, n.List.Slice(), "array literal")
-
-               n.Op = OARRAYLIT
-               n.Type = types.NewArray(elemType, length)
-               n.Right = nil
-               return n
-       }
-
-       n.Right = typecheck(n.Right, ctxType)
-       t := n.Right.Type
-       if t == nil {
-               n.Type = nil
-               return n
-       }
-       n.Type = t
-
-       switch t.Etype {
-       default:
-               yyerror("invalid composite literal type %v", t)
-               n.Type = nil
-
-       case TARRAY:
-               typecheckarraylit(t.Elem(), t.NumElem(), n.List.Slice(), "array literal")
-               n.Op = OARRAYLIT
-               n.Right = nil
-
-       case TSLICE:
-               length := typecheckarraylit(t.Elem(), -1, n.List.Slice(), "slice literal")
-               n.Op = OSLICELIT
-               n.Right = nodintconst(length)
-
-       case TMAP:
-               var cs constSet
-               for i3, l := range n.List.Slice() {
-                       setlineno(l)
-                       if l.Op != OKEY {
-                               n.List.SetIndex(i3, typecheck(l, ctxExpr))
-                               yyerror("missing key in map literal")
-                               continue
-                       }
-
-                       r := l.Left
-                       r = pushtype(r, t.Key())
-                       r = typecheck(r, ctxExpr)
-                       l.Left = assignconv(r, t.Key(), "map key")
-                       cs.add(lineno, l.Left, "key", "map literal")
-
-                       r = l.Right
-                       r = pushtype(r, t.Elem())
-                       r = typecheck(r, ctxExpr)
-                       l.Right = assignconv(r, t.Elem(), "map value")
-               }
-
-               n.Op = OMAPLIT
-               n.Right = nil
-
-       case TSTRUCT:
-               // Need valid field offsets for Xoffset below.
-               dowidth(t)
-
-               errored := false
-               if n.List.Len() != 0 && nokeys(n.List) {
-                       // simple list of variables
-                       ls := n.List.Slice()
-                       for i, n1 := range ls {
-                               setlineno(n1)
-                               n1 = typecheck(n1, ctxExpr)
-                               ls[i] = n1
-                               if i >= t.NumFields() {
-                                       if !errored {
-                                               yyerror("too many values in %v", n)
-                                               errored = true
-                                       }
-                                       continue
-                               }
-
-                               f := t.Field(i)
-                               s := f.Sym
-                               if s != nil && !types.IsExported(s.Name) && s.Pkg != localpkg {
-                                       yyerror("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
-                               }
-                               // No pushtype allowed here. Must name fields for that.
-                               n1 = assignconv(n1, f.Type, "field value")
-                               n1 = nodSym(OSTRUCTKEY, n1, f.Sym)
-                               n1.Xoffset = f.Offset
-                               ls[i] = n1
-                       }
-                       if len(ls) < t.NumFields() {
-                               yyerror("too few values in %v", n)
-                       }
-               } else {
-                       hash := make(map[string]bool)
-
-                       // keyed list
-                       ls := n.List.Slice()
-                       for i, l := range ls {
-                               setlineno(l)
-
-                               if l.Op == OKEY {
-                                       key := l.Left
-
-                                       l.Op = OSTRUCTKEY
-                                       l.Left = l.Right
-                                       l.Right = nil
-
-                                       // An OXDOT uses the Sym field to hold
-                                       // the field to the right of the dot,
-                                       // so s will be non-nil, but an OXDOT
-                                       // is never a valid struct literal key.
-                                       if key.Sym == nil || key.Op == OXDOT || key.Sym.IsBlank() {
-                                               yyerror("invalid field name %v in struct initializer", key)
-                                               l.Left = typecheck(l.Left, ctxExpr)
-                                               continue
-                                       }
-
-                                       // Sym might have resolved to name in other top-level
-                                       // package, because of import dot. Redirect to correct sym
-                                       // before we do the lookup.
-                                       s := key.Sym
-                                       if s.Pkg != localpkg && types.IsExported(s.Name) {
-                                               s1 := lookup(s.Name)
-                                               if s1.Origpkg == s.Pkg {
-                                                       s = s1
-                                               }
-                                       }
-                                       l.Sym = s
-                               }
-
-                               if l.Op != OSTRUCTKEY {
-                                       if !errored {
-                                               yyerror("mixture of field:value and value initializers")
-                                               errored = true
-                                       }
-                                       ls[i] = typecheck(ls[i], ctxExpr)
-                                       continue
-                               }
-
-                               f := lookdot1(nil, l.Sym, t, t.Fields(), 0)
-                               if f == nil {
-                                       if ci := lookdot1(nil, l.Sym, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
-                                               if visible(ci.Sym) {
-                                                       yyerror("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym, t, ci.Sym)
-                                               } else if nonexported(l.Sym) && l.Sym.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
-                                                       yyerror("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym, t)
-                                               } else {
-                                                       yyerror("unknown field '%v' in struct literal of type %v", l.Sym, t)
-                                               }
-                                               continue
-                                       }
-                                       var f *types.Field
-                                       p, _ := dotpath(l.Sym, t, &f, true)
-                                       if p == nil || f.IsMethod() {
-                                               yyerror("unknown field '%v' in struct literal of type %v", l.Sym, t)
-                                               continue
-                                       }
-                                       // dotpath returns the parent embedded types in reverse order.
-                                       var ep []string
-                                       for ei := len(p) - 1; ei >= 0; ei-- {
-                                               ep = append(ep, p[ei].field.Sym.Name)
-                                       }
-                                       ep = append(ep, l.Sym.Name)
-                                       yyerror("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
-                                       continue
-                               }
-                               fielddup(f.Sym.Name, hash)
-                               l.Xoffset = f.Offset
-
-                               // No pushtype allowed here. Tried and rejected.
-                               l.Left = typecheck(l.Left, ctxExpr)
-                               l.Left = assignconv(l.Left, f.Type, "field value")
-                       }
-               }
-
-               n.Op = OSTRUCTLIT
-               n.Right = nil
-       }
-
-       return n
-}
-
-// typecheckarraylit type-checks a sequence of slice/array literal elements.
-func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx string) int64 {
-       // If there are key/value pairs, create a map to keep seen
-       // keys so we can check for duplicate indices.
-       var indices map[int64]bool
-       for _, elt := range elts {
-               if elt.Op == OKEY {
-                       indices = make(map[int64]bool)
-                       break
-               }
-       }
-
-       var key, length int64
-       for i, elt := range elts {
-               setlineno(elt)
-               vp := &elts[i]
-               if elt.Op == OKEY {
-                       elt.Left = typecheck(elt.Left, ctxExpr)
-                       key = indexconst(elt.Left)
-                       if key < 0 {
-                               if !elt.Left.Diag() {
-                                       if key == -2 {
-                                               yyerror("index too large")
-                                       } else {
-                                               yyerror("index must be non-negative integer constant")
-                                       }
-                                       elt.Left.SetDiag(true)
-                               }
-                               key = -(1 << 30) // stay negative for a while
-                       }
-                       vp = &elt.Right
-               }
-
-               r := *vp
-               r = pushtype(r, elemType)
-               r = typecheck(r, ctxExpr)
-               *vp = assignconv(r, elemType, ctx)
-
-               if key >= 0 {
-                       if indices != nil {
-                               if indices[key] {
-                                       yyerror("duplicate index in %s: %d", ctx, key)
-                               } else {
-                                       indices[key] = true
-                               }
-                       }
-
-                       if bound >= 0 && key >= bound {
-                               yyerror("array index %d out of bounds [0:%d]", key, bound)
-                               bound = -1
-                       }
-               }
-
-               key++
-               if key > length {
-                       length = key
-               }
-       }
-
-       return length
-}
-
-// visible reports whether sym is exported or locally defined.
-func visible(sym *types.Sym) bool {
-       return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == localpkg)
-}
-
-// nonexported reports whether sym is an unexported field.
-func nonexported(sym *types.Sym) bool {
-       return sym != nil && !types.IsExported(sym.Name)
-}
-
-// lvalue etc
-func islvalue(n *Node) bool {
-       switch n.Op {
-       case OINDEX:
-               if n.Left.Type != nil && n.Left.Type.IsArray() {
-                       return islvalue(n.Left)
-               }
-               if n.Left.Type != nil && n.Left.Type.IsString() {
-                       return false
-               }
-               fallthrough
-       case ODEREF, ODOTPTR, OCLOSUREVAR:
-               return true
-
-       case ODOT:
-               return islvalue(n.Left)
-
-       case ONAME:
-               if n.Class() == PFUNC {
-                       return false
-               }
-               return true
-       }
-
-       return false
-}
-
-func checklvalue(n *Node, verb string) {
-       if !islvalue(n) {
-               yyerror("cannot %s %v", verb, n)
-       }
-}
-
-func checkassign(stmt *Node, n *Node) {
-       // Variables declared in ORANGE are assigned on every iteration.
-       if n.Name == nil || n.Name.Defn != stmt || stmt.Op == ORANGE {
-               r := outervalue(n)
-               if r.Op == ONAME {
-                       r.Name.SetAssigned(true)
-                       if r.Name.IsClosureVar() {
-                               r.Name.Defn.Name.SetAssigned(true)
-                       }
-               }
-       }
-
-       if islvalue(n) {
-               return
-       }
-       if n.Op == OINDEXMAP {
-               n.SetIndexMapLValue(true)
-               return
-       }
-
-       // have already complained about n being invalid
-       if n.Type == nil {
-               return
-       }
-
-       switch {
-       case n.Op == ODOT && n.Left.Op == OINDEXMAP:
-               yyerror("cannot assign to struct field %v in map", n)
-       case (n.Op == OINDEX && n.Left.Type.IsString()) || n.Op == OSLICESTR:
-               yyerror("cannot assign to %v (strings are immutable)", n)
-       case n.Op == OLITERAL && n.Sym != nil && n.isGoConst():
-               yyerror("cannot assign to %v (declared const)", n)
-       default:
-               yyerror("cannot assign to %v", n)
-       }
-       n.Type = nil
-}
-
-func checkassignlist(stmt *Node, l Nodes) {
-       for _, n := range l.Slice() {
-               checkassign(stmt, n)
-       }
-}
-
-// samesafeexpr checks whether it is safe to reuse one of l and r
-// instead of computing both. samesafeexpr assumes that l and r are
-// used in the same statement or expression. In order for it to be
-// safe to reuse l or r, they must:
-// * be the same expression
-// * not have side-effects (no function calls, no channel ops);
-//   however, panics are ok
-// * not cause inappropriate aliasing; e.g. two string to []byte
-//   conversions, must result in two distinct slices
-//
-// The handling of OINDEXMAP is subtle. OINDEXMAP can occur both
-// as an lvalue (map assignment) and an rvalue (map access). This is
-// currently OK, since the only place samesafeexpr gets used on an
-// lvalue expression is for OSLICE and OAPPEND optimizations, and it
-// is correct in those settings.
-func samesafeexpr(l *Node, r *Node) bool {
-       if l.Op != r.Op || !types.Identical(l.Type, r.Type) {
-               return false
-       }
-
-       switch l.Op {
-       case ONAME, OCLOSUREVAR:
-               return l == r
-
-       case ODOT, ODOTPTR:
-               return l.Sym != nil && r.Sym != nil && l.Sym == r.Sym && samesafeexpr(l.Left, r.Left)
-
-       case ODEREF, OCONVNOP,
-               ONOT, OBITNOT, OPLUS, ONEG:
-               return samesafeexpr(l.Left, r.Left)
-
-       case OCONV:
-               // Some conversions can't be reused, such as []byte(str).
-               // Allow only numeric-ish types. This is a bit conservative.
-               return issimple[l.Type.Etype] && samesafeexpr(l.Left, r.Left)
-
-       case OINDEX, OINDEXMAP,
-               OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
-               return samesafeexpr(l.Left, r.Left) && samesafeexpr(l.Right, r.Right)
-
-       case OLITERAL:
-               return eqval(l.Val(), r.Val())
-       }
-
-       return false
-}
-
-// type check assignment.
-// if this assignment is the definition of a var on the left side,
-// fill in the var's type.
-func typecheckas(n *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckas", n)(nil)
-       }
-
-       // delicate little dance.
-       // the definition of n may refer to this assignment
-       // as its definition, in which case it will call typecheckas.
-       // in that case, do not call typecheck back, or it will cycle.
-       // if the variable has a type (ntype) then typechecking
-       // will not look at defn, so it is okay (and desirable,
-       // so that the conversion below happens).
-       n.Left = resolve(n.Left)
-
-       if n.Left.Name == nil || n.Left.Name.Defn != n || n.Left.Name.Param.Ntype != nil {
-               n.Left = typecheck(n.Left, ctxExpr|ctxAssign)
-       }
-
-       // Use ctxMultiOK so we can emit an "N variables but M values" error
-       // to be consistent with typecheckas2 (#26616).
-       n.Right = typecheck(n.Right, ctxExpr|ctxMultiOK)
-       checkassign(n, n.Left)
-       if n.Right != nil && n.Right.Type != nil {
-               if n.Right.Type.IsFuncArgStruct() {
-                       yyerror("assignment mismatch: 1 variable but %v returns %d values", n.Right.Left, n.Right.Type.NumFields())
-                       // Multi-value RHS isn't actually valid for OAS; nil out
-                       // to indicate failed typechecking.
-                       n.Right.Type = nil
-               } else if n.Left.Type != nil {
-                       n.Right = assignconv(n.Right, n.Left.Type, "assignment")
-               }
-       }
-
-       if n.Left.Name != nil && n.Left.Name.Defn == n && n.Left.Name.Param.Ntype == nil {
-               n.Right = defaultlit(n.Right, nil)
-               n.Left.Type = n.Right.Type
-       }
-
-       // second half of dance.
-       // now that right is done, typecheck the left
-       // just to get it over with.  see dance above.
-       n.SetTypecheck(1)
-
-       if n.Left.Typecheck() == 0 {
-               n.Left = typecheck(n.Left, ctxExpr|ctxAssign)
-       }
-       if !n.Left.isBlank() {
-               checkwidth(n.Left.Type) // ensure width is calculated for backend
-       }
-}
-
-func checkassignto(src *types.Type, dst *Node) {
-       if op, why := assignop(src, dst.Type); op == OXXX {
-               yyerror("cannot assign %v to %L in multiple assignment%s", src, dst, why)
-               return
-       }
-}
-
-func typecheckas2(n *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckas2", n)(nil)
-       }
-
-       ls := n.List.Slice()
-       for i1, n1 := range ls {
-               // delicate little dance.
-               n1 = resolve(n1)
-               ls[i1] = n1
-
-               if n1.Name == nil || n1.Name.Defn != n || n1.Name.Param.Ntype != nil {
-                       ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-               }
-       }
-
-       cl := n.List.Len()
-       cr := n.Rlist.Len()
-       if cl > 1 && cr == 1 {
-               n.Rlist.SetFirst(typecheck(n.Rlist.First(), ctxExpr|ctxMultiOK))
-       } else {
-               typecheckslice(n.Rlist.Slice(), ctxExpr)
-       }
-       checkassignlist(n, n.List)
-
-       var l *Node
-       var r *Node
-       if cl == cr {
-               // easy
-               ls := n.List.Slice()
-               rs := n.Rlist.Slice()
-               for il, nl := range ls {
-                       nr := rs[il]
-                       if nl.Type != nil && nr.Type != nil {
-                               rs[il] = assignconv(nr, nl.Type, "assignment")
-                       }
-                       if nl.Name != nil && nl.Name.Defn == n && nl.Name.Param.Ntype == nil {
-                               rs[il] = defaultlit(rs[il], nil)
-                               nl.Type = rs[il].Type
-                       }
-               }
-
-               goto out
-       }
-
-       l = n.List.First()
-       r = n.Rlist.First()
-
-       // x,y,z = f()
-       if cr == 1 {
-               if r.Type == nil {
-                       goto out
-               }
-               switch r.Op {
-               case OCALLMETH, OCALLINTER, OCALLFUNC:
-                       if !r.Type.IsFuncArgStruct() {
-                               break
-                       }
-                       cr = r.Type.NumFields()
-                       if cr != cl {
-                               goto mismatch
-                       }
-                       n.Op = OAS2FUNC
-                       n.Right = r
-                       n.Rlist.Set(nil)
-                       for i, l := range n.List.Slice() {
-                               f := r.Type.Field(i)
-                               if f.Type != nil && l.Type != nil {
-                                       checkassignto(f.Type, l)
-                               }
-                               if l.Name != nil && l.Name.Defn == n && l.Name.Param.Ntype == nil {
-                                       l.Type = f.Type
-                               }
-                       }
-                       goto out
-               }
-       }
-
-       // x, ok = y
-       if cl == 2 && cr == 1 {
-               if r.Type == nil {
-                       goto out
-               }
-               switch r.Op {
-               case OINDEXMAP, ORECV, ODOTTYPE:
-                       switch r.Op {
-                       case OINDEXMAP:
-                               n.Op = OAS2MAPR
-                       case ORECV:
-                               n.Op = OAS2RECV
-                       case ODOTTYPE:
-                               n.Op = OAS2DOTTYPE
-                               r.Op = ODOTTYPE2
-                       }
-                       n.Right = r
-                       n.Rlist.Set(nil)
-                       if l.Type != nil {
-                               checkassignto(r.Type, l)
-                       }
-                       if l.Name != nil && l.Name.Defn == n {
-                               l.Type = r.Type
-                       }
-                       l := n.List.Second()
-                       if l.Type != nil && !l.Type.IsBoolean() {
-                               checkassignto(types.Types[TBOOL], l)
-                       }
-                       if l.Name != nil && l.Name.Defn == n && l.Name.Param.Ntype == nil {
-                               l.Type = types.Types[TBOOL]
-                       }
-                       goto out
-               }
-       }
-
-mismatch:
-       switch r.Op {
-       default:
-               yyerror("assignment mismatch: %d variables but %d values", cl, cr)
-       case OCALLFUNC, OCALLMETH, OCALLINTER:
-               yyerror("assignment mismatch: %d variables but %v returns %d values", cl, r.Left, cr)
-       }
-
-       // second half of dance
-out:
-       n.SetTypecheck(1)
-       ls = n.List.Slice()
-       for i1, n1 := range ls {
-               if n1.Typecheck() == 0 {
-                       ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-               }
-       }
-}
-
-// type check function definition
-func typecheckfunc(n *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckfunc", n)(nil)
-       }
-
-       for _, ln := range n.Func.Dcl {
-               if ln.Op == ONAME && (ln.Class() == PPARAM || ln.Class() == PPARAMOUT) {
-                       ln.Name.Decldepth = 1
-               }
-       }
-
-       n.Func.Nname = typecheck(n.Func.Nname, ctxExpr|ctxAssign)
-       t := n.Func.Nname.Type
-       if t == nil {
-               return
-       }
-       n.Type = t
-       t.FuncType().Nname = asTypesNode(n.Func.Nname)
-       rcvr := t.Recv()
-       if rcvr != nil && n.Func.Shortname != nil {
-               m := addmethod(n.Func.Shortname, t, true, n.Func.Pragma&Nointerface != 0)
-               if m == nil {
-                       return
-               }
-
-               n.Func.Nname.Sym = methodSym(rcvr.Type, n.Func.Shortname)
-               declare(n.Func.Nname, PFUNC)
-       }
-
-       if Ctxt.Flag_dynlink && !inimport && n.Func.Nname != nil {
-               makefuncsym(n.Func.Nname.Sym)
-       }
-}
-
-// The result of stringtoruneslit MUST be assigned back to n, e.g.
-//     n.Left = stringtoruneslit(n.Left)
-func stringtoruneslit(n *Node) *Node {
-       if n.Left.Op != OLITERAL || n.Left.Val().Ctype() != CTSTR {
-               Fatalf("stringtoarraylit %v", n)
-       }
-
-       var l []*Node
-       i := 0
-       for _, r := range n.Left.StringVal() {
-               l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
-               i++
-       }
-
-       nn := nod(OCOMPLIT, nil, typenod(n.Type))
-       nn.List.Set(l)
-       nn = typecheck(nn, ctxExpr)
-       return nn
-}
-
-var mapqueue []*Node
-
-func checkMapKeys() {
-       for _, n := range mapqueue {
-               k := n.Type.MapType().Key
-               if !k.Broke() && !IsComparable(k) {
-                       yyerrorl(n.Pos, "invalid map key type %v", k)
-               }
-       }
-       mapqueue = nil
-}
-
-func setUnderlying(t, underlying *types.Type) {
-       if underlying.Etype == TFORW {
-               // This type isn't computed yet; when it is, update n.
-               underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
-               return
-       }
-
-       n := asNode(t.Nod)
-       ft := t.ForwardType()
-       cache := t.Cache
-
-       // TODO(mdempsky): Fix Type rekinding.
-       *t = *underlying
-
-       // Restore unnecessarily clobbered attributes.
-       t.Nod = asTypesNode(n)
-       t.Sym = n.Sym
-       if n.Name != nil {
-               t.Vargen = n.Name.Vargen
-       }
-       t.Cache = cache
-       t.SetDeferwidth(false)
-
-       // spec: "The declared type does not inherit any methods bound
-       // to the existing type, but the method set of an interface
-       // type [...] remains unchanged."
-       if !t.IsInterface() {
-               *t.Methods() = types.Fields{}
-               *t.AllMethods() = types.Fields{}
-       }
-
-       // Propagate go:notinheap pragma from the Name to the Type.
-       if n.Name != nil && n.Name.Param != nil && n.Name.Param.Pragma()&NotInHeap != 0 {
-               t.SetNotInHeap(true)
-       }
-
-       // Update types waiting on this type.
-       for _, w := range ft.Copyto {
-               setUnderlying(w, t)
-       }
-
-       // Double-check use of type as embedded type.
-       if ft.Embedlineno.IsKnown() {
-               if t.IsPtr() || t.IsUnsafePtr() {
-                       yyerrorl(ft.Embedlineno, "embedded type cannot be a pointer")
-               }
-       }
-}
-
-func typecheckdeftype(n *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckdeftype", n)(nil)
-       }
-
-       n.SetTypecheck(1)
-       n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-       t := n.Name.Param.Ntype.Type
-       if t == nil {
-               n.SetDiag(true)
-               n.Type = nil
-       } else if n.Type == nil {
-               n.SetDiag(true)
-       } else {
-               // copy new type and clear fields
-               // that don't come along.
-               setUnderlying(n.Type, t)
-       }
-}
-
-func typecheckdef(n *Node) {
-       if enableTrace && trace {
-               defer tracePrint("typecheckdef", n)(nil)
-       }
-
-       lno := setlineno(n)
-
-       if n.Op == ONONAME {
-               if !n.Diag() {
-                       n.SetDiag(true)
-
-                       // Note: adderrorname looks for this string and
-                       // adds context about the outer expression
-                       yyerrorl(lineno, "undefined: %v", n.Sym)
-               }
-               lineno = lno
-               return
-       }
-
-       if n.Walkdef() == 1 {
-               lineno = lno
-               return
-       }
-
-       typecheckdefstack = append(typecheckdefstack, n)
-       if n.Walkdef() == 2 {
-               flusherrors()
-               fmt.Printf("typecheckdef loop:")
-               for i := len(typecheckdefstack) - 1; i >= 0; i-- {
-                       n := typecheckdefstack[i]
-                       fmt.Printf(" %v", n.Sym)
-               }
-               fmt.Printf("\n")
-               Fatalf("typecheckdef loop")
-       }
-
-       n.SetWalkdef(2)
-
-       if n.Type != nil || n.Sym == nil { // builtin or no name
-               goto ret
-       }
-
-       switch n.Op {
-       default:
-               Fatalf("typecheckdef %v", n.Op)
-
-       case OLITERAL:
-               if n.Name.Param.Ntype != nil {
-                       n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-                       n.Type = n.Name.Param.Ntype.Type
-                       n.Name.Param.Ntype = nil
-                       if n.Type == nil {
-                               n.SetDiag(true)
-                               goto ret
-                       }
-               }
-
-               e := n.Name.Defn
-               n.Name.Defn = nil
-               if e == nil {
-                       Dump("typecheckdef nil defn", n)
-                       yyerrorl(n.Pos, "xxx")
-               }
-
-               e = typecheck(e, ctxExpr)
-               if e.Type == nil {
-                       goto ret
-               }
-               if !e.isGoConst() {
-                       if !e.Diag() {
-                               if Isconst(e, CTNIL) {
-                                       yyerrorl(n.Pos, "const initializer cannot be nil")
-                               } else {
-                                       yyerrorl(n.Pos, "const initializer %v is not a constant", e)
-                               }
-                               e.SetDiag(true)
-                       }
-                       goto ret
-               }
-
-               t := n.Type
-               if t != nil {
-                       if !okforconst[t.Etype] {
-                               yyerrorl(n.Pos, "invalid constant type %v", t)
-                               goto ret
-                       }
-
-                       if !e.Type.IsUntyped() && !types.Identical(t, e.Type) {
-                               yyerrorl(n.Pos, "cannot use %L as type %v in const initializer", e, t)
-                               goto ret
-                       }
-
-                       e = convlit(e, t)
-               }
-
-               n.SetVal(e.Val())
-               n.Type = e.Type
-
-       case ONAME:
-               if n.Name.Param.Ntype != nil {
-                       n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-                       n.Type = n.Name.Param.Ntype.Type
-                       if n.Type == nil {
-                               n.SetDiag(true)
-                               goto ret
-                       }
-               }
-
-               if n.Type != nil {
-                       break
-               }
-               if n.Name.Defn == nil {
-                       if n.SubOp() != 0 { // like OPRINTN
-                               break
-                       }
-                       if nsavederrors+nerrors > 0 {
-                               // Can have undefined variables in x := foo
-                               // that make x have an n.name.Defn == nil.
-                               // If there are other errors anyway, don't
-                               // bother adding to the noise.
-                               break
-                       }
-
-                       Fatalf("var without type, init: %v", n.Sym)
-               }
-
-               if n.Name.Defn.Op == ONAME {
-                       n.Name.Defn = typecheck(n.Name.Defn, ctxExpr)
-                       n.Type = n.Name.Defn.Type
-                       break
-               }
-
-               n.Name.Defn = typecheck(n.Name.Defn, ctxStmt) // fills in n.Type
-
-       case OTYPE:
-               if p := n.Name.Param; p.Alias() {
-                       // Type alias declaration: Simply use the rhs type - no need
-                       // to create a new type.
-                       // If we have a syntax error, p.Ntype may be nil.
-                       if p.Ntype != nil {
-                               p.Ntype = typecheck(p.Ntype, ctxType)
-                               n.Type = p.Ntype.Type
-                               if n.Type == nil {
-                                       n.SetDiag(true)
-                                       goto ret
-                               }
-                               // For package-level type aliases, set n.Sym.Def so we can identify
-                               // it as a type alias during export. See also #31959.
-                               if n.Name.Curfn == nil {
-                                       n.Sym.Def = asTypesNode(p.Ntype)
-                               }
-                       }
-                       break
-               }
-
-               // regular type declaration
-               defercheckwidth()
-               n.SetWalkdef(1)
-               setTypeNode(n, types.New(TFORW))
-               n.Type.Sym = n.Sym
-               nerrors0 := nerrors
-               typecheckdeftype(n)
-               if n.Type.Etype == TFORW && nerrors > nerrors0 {
-                       // Something went wrong during type-checking,
-                       // but it was reported. Silence future errors.
-                       n.Type.SetBroke(true)
-               }
-               resumecheckwidth()
-       }
-
-ret:
-       if n.Op != OLITERAL && n.Type != nil && n.Type.IsUntyped() {
-               Fatalf("got %v for %v", n.Type, n)
-       }
-       last := len(typecheckdefstack) - 1
-       if typecheckdefstack[last] != n {
-               Fatalf("typecheckdefstack mismatch")
-       }
-       typecheckdefstack[last] = nil
-       typecheckdefstack = typecheckdefstack[:last]
-
-       lineno = lno
-       n.SetWalkdef(1)
-}
-
-func checkmake(t *types.Type, arg string, np **Node) bool {
-       n := *np
-       if !n.Type.IsInteger() && n.Type.Etype != TIDEAL {
-               yyerror("non-integer %s argument in make(%v) - %v", arg, t, n.Type)
-               return false
-       }
-
-       // Do range checks for constants before defaultlit
-       // to avoid redundant "constant NNN overflows int" errors.
-       switch consttype(n) {
-       case CTINT, CTRUNE, CTFLT, CTCPLX:
-               v := toint(n.Val()).U.(*Mpint)
-               if v.CmpInt64(0) < 0 {
-                       yyerror("negative %s argument in make(%v)", arg, t)
-                       return false
-               }
-               if v.Cmp(maxintval[TINT]) > 0 {
-                       yyerror("%s argument too large in make(%v)", arg, t)
-                       return false
-               }
-       }
-
-       // defaultlit is necessary for non-constants too: n might be 1.1<<k.
-       // TODO(gri) The length argument requirements for (array/slice) make
-       // are the same as for index expressions. Factor the code better;
-       // for instance, indexlit might be called here and incorporate some
-       // of the bounds checks done for make.
-       n = defaultlit(n, types.Types[TINT])
-       *np = n
-
-       return true
-}
-
-func markbreak(n *Node, implicit *Node) {
-       if n == nil {
-               return
-       }
-
-       switch n.Op {
-       case OBREAK:
-               if n.Sym == nil {
-                       if implicit != nil {
-                               implicit.SetHasBreak(true)
-                       }
-               } else {
-                       lab := asNode(n.Sym.Label)
-                       if lab != nil {
-                               lab.SetHasBreak(true)
-                       }
-               }
-       case OFOR, OFORUNTIL, OSWITCH, OTYPESW, OSELECT, ORANGE:
-               implicit = n
-               fallthrough
-       default:
-               markbreak(n.Left, implicit)
-               markbreak(n.Right, implicit)
-               markbreaklist(n.Ninit, implicit)
-               markbreaklist(n.Nbody, implicit)
-               markbreaklist(n.List, implicit)
-               markbreaklist(n.Rlist, implicit)
-       }
-}
-
-func markbreaklist(l Nodes, implicit *Node) {
-       s := l.Slice()
-       for i := 0; i < len(s); i++ {
-               n := s[i]
-               if n == nil {
-                       continue
-               }
-               if n.Op == OLABEL && i+1 < len(s) && n.Name.Defn == s[i+1] {
-                       switch n.Name.Defn.Op {
-                       case OFOR, OFORUNTIL, OSWITCH, OTYPESW, OSELECT, ORANGE:
-                               n.Sym.Label = asTypesNode(n.Name.Defn)
-                               markbreak(n.Name.Defn, n.Name.Defn)
-                               n.Sym.Label = nil
-                               i++
-                               continue
-                       }
-               }
-
-               markbreak(n, implicit)
-       }
-}
-
-// isterminating reports whether the Nodes list ends with a terminating statement.
-func (l Nodes) isterminating() bool {
-       s := l.Slice()
-       c := len(s)
-       if c == 0 {
-               return false
-       }
-       return s[c-1].isterminating()
-}
-
-// Isterminating reports whether the node n, the last one in a
-// statement list, is a terminating statement.
-func (n *Node) isterminating() bool {
-       switch n.Op {
-       // NOTE: OLABEL is treated as a separate statement,
-       // not a separate prefix, so skipping to the last statement
-       // in the block handles the labeled statement case by
-       // skipping over the label. No case OLABEL here.
-
-       case OBLOCK:
-               return n.List.isterminating()
-
-       case OGOTO, ORETURN, ORETJMP, OPANIC, OFALL:
-               return true
-
-       case OFOR, OFORUNTIL:
-               if n.Left != nil {
-                       return false
-               }
-               if n.HasBreak() {
-                       return false
-               }
-               return true
-
-       case OIF:
-               return n.Nbody.isterminating() && n.Rlist.isterminating()
-
-       case OSWITCH, OTYPESW, OSELECT:
-               if n.HasBreak() {
-                       return false
-               }
-               def := false
-               for _, n1 := range n.List.Slice() {
-                       if !n1.Nbody.isterminating() {
-                               return false
-                       }
-                       if n1.List.Len() == 0 { // default
-                               def = true
-                       }
-               }
-
-               if n.Op != OSELECT && !def {
-                       return false
-               }
-               return true
-       }
-
-       return false
-}
-
-// checkreturn makes sure that fn terminates appropriately.
-func checkreturn(fn *Node) {
-       if fn.Type.NumResults() != 0 && fn.Nbody.Len() != 0 {
-               markbreaklist(fn.Nbody, nil)
-               if !fn.Nbody.isterminating() {
-                       yyerrorl(fn.Func.Endlineno, "missing return at end of function")
-               }
-       }
-}
-
-func deadcode(fn *Node) {
-       deadcodeslice(fn.Nbody)
-       deadcodefn(fn)
-}
-
-func deadcodefn(fn *Node) {
-       if fn.Nbody.Len() == 0 {
-               return
-       }
-
-       for _, n := range fn.Nbody.Slice() {
-               if n.Ninit.Len() > 0 {
-                       return
-               }
-               switch n.Op {
-               case OIF:
-                       if !Isconst(n.Left, CTBOOL) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
-                               return
-                       }
-               case OFOR:
-                       if !Isconst(n.Left, CTBOOL) || n.Left.BoolVal() {
-                               return
-                       }
-               default:
-                       return
-               }
-       }
-
-       fn.Nbody.Set([]*Node{nod(OEMPTY, nil, nil)})
-}
-
-func deadcodeslice(nn Nodes) {
-       var lastLabel = -1
-       for i, n := range nn.Slice() {
-               if n != nil && n.Op == OLABEL {
-                       lastLabel = i
-               }
-       }
-       for i, n := range nn.Slice() {
-               // Cut is set to true when all nodes after i'th position
-               // should be removed.
-               // In other words, it marks whole slice "tail" as dead.
-               cut := false
-               if n == nil {
-                       continue
-               }
-               if n.Op == OIF {
-                       n.Left = deadcodeexpr(n.Left)
-                       if Isconst(n.Left, CTBOOL) {
-                               var body Nodes
-                               if n.Left.BoolVal() {
-                                       n.Rlist = Nodes{}
-                                       body = n.Nbody
-                               } else {
-                                       n.Nbody = Nodes{}
-                                       body = n.Rlist
-                               }
-                               // If "then" or "else" branch ends with panic or return statement,
-                               // it is safe to remove all statements after this node.
-                               // isterminating is not used to avoid goto-related complications.
-                               // We must be careful not to deadcode-remove labels, as they
-                               // might be the target of a goto. See issue 28616.
-                               if body := body.Slice(); len(body) != 0 {
-                                       switch body[(len(body) - 1)].Op {
-                                       case ORETURN, ORETJMP, OPANIC:
-                                               if i > lastLabel {
-                                                       cut = true
-                                               }
-                                       }
-                               }
-                       }
-               }
-
-               deadcodeslice(n.Ninit)
-               deadcodeslice(n.Nbody)
-               deadcodeslice(n.List)
-               deadcodeslice(n.Rlist)
-               if cut {
-                       *nn.slice = nn.Slice()[:i+1]
-                       break
-               }
-       }
-}
-
-func deadcodeexpr(n *Node) *Node {
-       // Perform dead-code elimination on short-circuited boolean
-       // expressions involving constants with the intent of
-       // producing a constant 'if' condition.
-       switch n.Op {
-       case OANDAND:
-               n.Left = deadcodeexpr(n.Left)
-               n.Right = deadcodeexpr(n.Right)
-               if Isconst(n.Left, CTBOOL) {
-                       if n.Left.BoolVal() {
-                               return n.Right // true && x => x
-                       } else {
-                               return n.Left // false && x => false
-                       }
-               }
-       case OOROR:
-               n.Left = deadcodeexpr(n.Left)
-               n.Right = deadcodeexpr(n.Right)
-               if Isconst(n.Left, CTBOOL) {
-                       if n.Left.BoolVal() {
-                               return n.Left // true || x => true
-                       } else {
-                               return n.Right // false || x => x
-                       }
-               }
-       }
-       return n
-}
-
-// setTypeNode sets n to an OTYPE node representing t.
-func setTypeNode(n *Node, t *types.Type) {
-       n.Op = OTYPE
-       n.Type = t
-       n.Type.Nod = asTypesNode(n)
-}
-
-// getIotaValue returns the current value for "iota",
-// or -1 if not within a ConstSpec.
-func getIotaValue() int64 {
-       if i := len(typecheckdefstack); i > 0 {
-               if x := typecheckdefstack[i-1]; x.Op == OLITERAL {
-                       return x.Iota()
-               }
-       }
-
-       if Curfn != nil && Curfn.Iota() >= 0 {
-               return Curfn.Iota()
-       }
-
-       return -1
-}
-
-// curpkg returns the current package, based on Curfn.
-func curpkg() *types.Pkg {
-       fn := Curfn
-       if fn == nil {
-               // Initialization expressions for package-scope variables.
-               return localpkg
-       }
-
-       // TODO(mdempsky): Standardize on either ODCLFUNC or ONAME for
-       // Curfn, rather than mixing them.
-       if fn.Op == ODCLFUNC {
-               fn = fn.Func.Nname
-       }
-
-       return fnpkg(fn)
-}

diff --git a/src/cmd/compile/internal/gc/types.go b/src/cmd/compile/internal/gc/types.go
deleted file mode 100644 (file)
index 748f845..0000000
--- a/src/cmd/compile/internal/gc/types.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-)
-
-// convenience constants
-const (
-       Txxx = types.Txxx
-
-       TINT8    = types.TINT8
-       TUINT8   = types.TUINT8
-       TINT16   = types.TINT16
-       TUINT16  = types.TUINT16
-       TINT32   = types.TINT32
-       TUINT32  = types.TUINT32
-       TINT64   = types.TINT64
-       TUINT64  = types.TUINT64
-       TINT     = types.TINT
-       TUINT    = types.TUINT
-       TUINTPTR = types.TUINTPTR
-
-       TCOMPLEX64  = types.TCOMPLEX64
-       TCOMPLEX128 = types.TCOMPLEX128
-
-       TFLOAT32 = types.TFLOAT32
-       TFLOAT64 = types.TFLOAT64
-
-       TBOOL = types.TBOOL
-
-       TPTR       = types.TPTR
-       TFUNC      = types.TFUNC
-       TSLICE     = types.TSLICE
-       TARRAY     = types.TARRAY
-       TSTRUCT    = types.TSTRUCT
-       TCHAN      = types.TCHAN
-       TMAP       = types.TMAP
-       TINTER     = types.TINTER
-       TFORW      = types.TFORW
-       TANY       = types.TANY
-       TSTRING    = types.TSTRING
-       TUNSAFEPTR = types.TUNSAFEPTR
-
-       // pseudo-types for literals
-       TIDEAL = types.TIDEAL
-       TNIL   = types.TNIL
-       TBLANK = types.TBLANK
-
-       // pseudo-types for frame layout
-       TFUNCARGS = types.TFUNCARGS
-       TCHANARGS = types.TCHANARGS
-
-       NTYPE = types.NTYPE
-)

diff --git a/src/cmd/compile/internal/gc/types_acc.go b/src/cmd/compile/internal/gc/types_acc.go
deleted file mode 100644 (file)
index 7240f72..0000000
--- a/src/cmd/compile/internal/gc/types_acc.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements convertions between *types.Node and *Node.
-// TODO(gri) try to eliminate these soon
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "unsafe"
-)
-
-func asNode(n *types.Node) *Node      { return (*Node)(unsafe.Pointer(n)) }
-func asTypesNode(n *Node) *types.Node { return (*types.Node)(unsafe.Pointer(n)) }

diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
deleted file mode 100644 (file)
index ff8cabd..0000000
--- a/src/cmd/compile/internal/gc/universe.go
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TODO(gri) This file should probably become part of package types.
-
-package gc
-
-import "cmd/compile/internal/types"
-
-// builtinpkg is a fake package that declares the universe block.
-var builtinpkg *types.Pkg
-
-var basicTypes = [...]struct {
-       name  string
-       etype types.EType
-}{
-       {"int8", TINT8},
-       {"int16", TINT16},
-       {"int32", TINT32},
-       {"int64", TINT64},
-       {"uint8", TUINT8},
-       {"uint16", TUINT16},
-       {"uint32", TUINT32},
-       {"uint64", TUINT64},
-       {"float32", TFLOAT32},
-       {"float64", TFLOAT64},
-       {"complex64", TCOMPLEX64},
-       {"complex128", TCOMPLEX128},
-       {"bool", TBOOL},
-       {"string", TSTRING},
-}
-
-var typedefs = [...]struct {
-       name     string
-       etype    types.EType
-       sameas32 types.EType
-       sameas64 types.EType
-}{
-       {"int", TINT, TINT32, TINT64},
-       {"uint", TUINT, TUINT32, TUINT64},
-       {"uintptr", TUINTPTR, TUINT32, TUINT64},
-}
-
-var builtinFuncs = [...]struct {
-       name string
-       op   Op
-}{
-       {"append", OAPPEND},
-       {"cap", OCAP},
-       {"close", OCLOSE},
-       {"complex", OCOMPLEX},
-       {"copy", OCOPY},
-       {"delete", ODELETE},
-       {"imag", OIMAG},
-       {"len", OLEN},
-       {"make", OMAKE},
-       {"new", ONEW},
-       {"panic", OPANIC},
-       {"print", OPRINT},
-       {"println", OPRINTN},
-       {"real", OREAL},
-       {"recover", ORECOVER},
-}
-
-// isBuiltinFuncName reports whether name matches a builtin function
-// name.
-func isBuiltinFuncName(name string) bool {
-       for _, fn := range &builtinFuncs {
-               if fn.name == name {
-                       return true
-               }
-       }
-       return false
-}
-
-var unsafeFuncs = [...]struct {
-       name string
-       op   Op
-}{
-       {"Alignof", OALIGNOF},
-       {"Offsetof", OOFFSETOF},
-       {"Sizeof", OSIZEOF},
-}
-
-// initUniverse initializes the universe block.
-func initUniverse() {
-       lexinit()
-       typeinit()
-       lexinit1()
-}
-
-// lexinit initializes known symbols and the basic types.
-func lexinit() {
-       for _, s := range &basicTypes {
-               etype := s.etype
-               if int(etype) >= len(types.Types) {
-                       Fatalf("lexinit: %s bad etype", s.name)
-               }
-               s2 := builtinpkg.Lookup(s.name)
-               t := types.Types[etype]
-               if t == nil {
-                       t = types.New(etype)
-                       t.Sym = s2
-                       if etype != TANY && etype != TSTRING {
-                               dowidth(t)
-                       }
-                       types.Types[etype] = t
-               }
-               s2.Def = asTypesNode(typenod(t))
-               asNode(s2.Def).Name = new(Name)
-       }
-
-       for _, s := range &builtinFuncs {
-               s2 := builtinpkg.Lookup(s.name)
-               s2.Def = asTypesNode(newname(s2))
-               asNode(s2.Def).SetSubOp(s.op)
-       }
-
-       for _, s := range &unsafeFuncs {
-               s2 := unsafepkg.Lookup(s.name)
-               s2.Def = asTypesNode(newname(s2))
-               asNode(s2.Def).SetSubOp(s.op)
-       }
-
-       types.UntypedString = types.New(TSTRING)
-       types.UntypedBool = types.New(TBOOL)
-       types.Types[TANY] = types.New(TANY)
-
-       s := builtinpkg.Lookup("true")
-       s.Def = asTypesNode(nodbool(true))
-       asNode(s.Def).Sym = lookup("true")
-       asNode(s.Def).Name = new(Name)
-       asNode(s.Def).Type = types.UntypedBool
-
-       s = builtinpkg.Lookup("false")
-       s.Def = asTypesNode(nodbool(false))
-       asNode(s.Def).Sym = lookup("false")
-       asNode(s.Def).Name = new(Name)
-       asNode(s.Def).Type = types.UntypedBool
-
-       s = lookup("_")
-       s.Block = -100
-       s.Def = asTypesNode(newname(s))
-       types.Types[TBLANK] = types.New(TBLANK)
-       asNode(s.Def).Type = types.Types[TBLANK]
-       nblank = asNode(s.Def)
-
-       s = builtinpkg.Lookup("_")
-       s.Block = -100
-       s.Def = asTypesNode(newname(s))
-       types.Types[TBLANK] = types.New(TBLANK)
-       asNode(s.Def).Type = types.Types[TBLANK]
-
-       types.Types[TNIL] = types.New(TNIL)
-       s = builtinpkg.Lookup("nil")
-       var v Val
-       v.U = new(NilVal)
-       s.Def = asTypesNode(nodlit(v))
-       asNode(s.Def).Sym = s
-       asNode(s.Def).Name = new(Name)
-
-       s = builtinpkg.Lookup("iota")
-       s.Def = asTypesNode(nod(OIOTA, nil, nil))
-       asNode(s.Def).Sym = s
-       asNode(s.Def).Name = new(Name)
-}
-
-func typeinit() {
-       if Widthptr == 0 {
-               Fatalf("typeinit before betypeinit")
-       }
-
-       for et := types.EType(0); et < NTYPE; et++ {
-               simtype[et] = et
-       }
-
-       types.Types[TPTR] = types.New(TPTR)
-       dowidth(types.Types[TPTR])
-
-       t := types.New(TUNSAFEPTR)
-       types.Types[TUNSAFEPTR] = t
-       t.Sym = unsafepkg.Lookup("Pointer")
-       t.Sym.Def = asTypesNode(typenod(t))
-       asNode(t.Sym.Def).Name = new(Name)
-       dowidth(types.Types[TUNSAFEPTR])
-
-       for et := TINT8; et <= TUINT64; et++ {
-               isInt[et] = true
-       }
-       isInt[TINT] = true
-       isInt[TUINT] = true
-       isInt[TUINTPTR] = true
-
-       isFloat[TFLOAT32] = true
-       isFloat[TFLOAT64] = true
-
-       isComplex[TCOMPLEX64] = true
-       isComplex[TCOMPLEX128] = true
-
-       // initialize okfor
-       for et := types.EType(0); et < NTYPE; et++ {
-               if isInt[et] || et == TIDEAL {
-                       okforeq[et] = true
-                       okforcmp[et] = true
-                       okforarith[et] = true
-                       okforadd[et] = true
-                       okforand[et] = true
-                       okforconst[et] = true
-                       issimple[et] = true
-                       minintval[et] = new(Mpint)
-                       maxintval[et] = new(Mpint)
-               }
-
-               if isFloat[et] {
-                       okforeq[et] = true
-                       okforcmp[et] = true
-                       okforadd[et] = true
-                       okforarith[et] = true
-                       okforconst[et] = true
-                       issimple[et] = true
-                       minfltval[et] = newMpflt()
-                       maxfltval[et] = newMpflt()
-               }
-
-               if isComplex[et] {
-                       okforeq[et] = true
-                       okforadd[et] = true
-                       okforarith[et] = true
-                       okforconst[et] = true
-                       issimple[et] = true
-               }
-       }
-
-       issimple[TBOOL] = true
-
-       okforadd[TSTRING] = true
-
-       okforbool[TBOOL] = true
-
-       okforcap[TARRAY] = true
-       okforcap[TCHAN] = true
-       okforcap[TSLICE] = true
-
-       okforconst[TBOOL] = true
-       okforconst[TSTRING] = true
-
-       okforlen[TARRAY] = true
-       okforlen[TCHAN] = true
-       okforlen[TMAP] = true
-       okforlen[TSLICE] = true
-       okforlen[TSTRING] = true
-
-       okforeq[TPTR] = true
-       okforeq[TUNSAFEPTR] = true
-       okforeq[TINTER] = true
-       okforeq[TCHAN] = true
-       okforeq[TSTRING] = true
-       okforeq[TBOOL] = true
-       okforeq[TMAP] = true    // nil only; refined in typecheck
-       okforeq[TFUNC] = true   // nil only; refined in typecheck
-       okforeq[TSLICE] = true  // nil only; refined in typecheck
-       okforeq[TARRAY] = true  // only if element type is comparable; refined in typecheck
-       okforeq[TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
-
-       okforcmp[TSTRING] = true
-
-       var i int
-       for i = 0; i < len(okfor); i++ {
-               okfor[i] = okfornone[:]
-       }
-
-       // binary
-       okfor[OADD] = okforadd[:]
-       okfor[OAND] = okforand[:]
-       okfor[OANDAND] = okforbool[:]
-       okfor[OANDNOT] = okforand[:]
-       okfor[ODIV] = okforarith[:]
-       okfor[OEQ] = okforeq[:]
-       okfor[OGE] = okforcmp[:]
-       okfor[OGT] = okforcmp[:]
-       okfor[OLE] = okforcmp[:]
-       okfor[OLT] = okforcmp[:]
-       okfor[OMOD] = okforand[:]
-       okfor[OMUL] = okforarith[:]
-       okfor[ONE] = okforeq[:]
-       okfor[OOR] = okforand[:]
-       okfor[OOROR] = okforbool[:]
-       okfor[OSUB] = okforarith[:]
-       okfor[OXOR] = okforand[:]
-       okfor[OLSH] = okforand[:]
-       okfor[ORSH] = okforand[:]
-
-       // unary
-       okfor[OBITNOT] = okforand[:]
-       okfor[ONEG] = okforarith[:]
-       okfor[ONOT] = okforbool[:]
-       okfor[OPLUS] = okforarith[:]
-
-       // special
-       okfor[OCAP] = okforcap[:]
-       okfor[OLEN] = okforlen[:]
-
-       // comparison
-       iscmp[OLT] = true
-       iscmp[OGT] = true
-       iscmp[OGE] = true
-       iscmp[OLE] = true
-       iscmp[OEQ] = true
-       iscmp[ONE] = true
-
-       maxintval[TINT8].SetString("0x7f")
-       minintval[TINT8].SetString("-0x80")
-       maxintval[TINT16].SetString("0x7fff")
-       minintval[TINT16].SetString("-0x8000")
-       maxintval[TINT32].SetString("0x7fffffff")
-       minintval[TINT32].SetString("-0x80000000")
-       maxintval[TINT64].SetString("0x7fffffffffffffff")
-       minintval[TINT64].SetString("-0x8000000000000000")
-
-       maxintval[TUINT8].SetString("0xff")
-       maxintval[TUINT16].SetString("0xffff")
-       maxintval[TUINT32].SetString("0xffffffff")
-       maxintval[TUINT64].SetString("0xffffffffffffffff")
-
-       // f is valid float if min < f < max.  (min and max are not themselves valid.)
-       maxfltval[TFLOAT32].SetString("33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
-       minfltval[TFLOAT32].SetString("-33554431p103")
-       maxfltval[TFLOAT64].SetString("18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
-       minfltval[TFLOAT64].SetString("-18014398509481983p970")
-
-       maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
-       minfltval[TCOMPLEX64] = minfltval[TFLOAT32]
-       maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
-       minfltval[TCOMPLEX128] = minfltval[TFLOAT64]
-
-       types.Types[TINTER] = types.New(TINTER) // empty interface
-
-       // simple aliases
-       simtype[TMAP] = TPTR
-       simtype[TCHAN] = TPTR
-       simtype[TFUNC] = TPTR
-       simtype[TUNSAFEPTR] = TPTR
-
-       slicePtrOffset = 0
-       sliceLenOffset = Rnd(slicePtrOffset+int64(Widthptr), int64(Widthptr))
-       sliceCapOffset = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
-       sizeofSlice = Rnd(sliceCapOffset+int64(Widthptr), int64(Widthptr))
-
-       // string is same as slice wo the cap
-       sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
-
-       dowidth(types.Types[TSTRING])
-       dowidth(types.UntypedString)
-}
-
-func makeErrorInterface() *types.Type {
-       field := types.NewField()
-       field.Type = types.Types[TSTRING]
-       f := functypefield(fakeRecvField(), nil, []*types.Field{field})
-
-       field = types.NewField()
-       field.Sym = lookup("Error")
-       field.Type = f
-
-       t := types.New(TINTER)
-       t.SetInterface([]*types.Field{field})
-       return t
-}
-
-func lexinit1() {
-       // error type
-       s := builtinpkg.Lookup("error")
-       types.Errortype = makeErrorInterface()
-       types.Errortype.Sym = s
-       types.Errortype.Orig = makeErrorInterface()
-       s.Def = asTypesNode(typenod(types.Errortype))
-       dowidth(types.Errortype)
-
-       // We create separate byte and rune types for better error messages
-       // rather than just creating type alias *types.Sym's for the uint8 and
-       // int32 types. Hence, (bytetype|runtype).Sym.isAlias() is false.
-       // TODO(gri) Should we get rid of this special case (at the cost
-       // of less informative error messages involving bytes and runes)?
-       // (Alternatively, we could introduce an OTALIAS node representing
-       // type aliases, albeit at the cost of having to deal with it everywhere).
-
-       // byte alias
-       s = builtinpkg.Lookup("byte")
-       types.Bytetype = types.New(TUINT8)
-       types.Bytetype.Sym = s
-       s.Def = asTypesNode(typenod(types.Bytetype))
-       asNode(s.Def).Name = new(Name)
-       dowidth(types.Bytetype)
-
-       // rune alias
-       s = builtinpkg.Lookup("rune")
-       types.Runetype = types.New(TINT32)
-       types.Runetype.Sym = s
-       s.Def = asTypesNode(typenod(types.Runetype))
-       asNode(s.Def).Name = new(Name)
-       dowidth(types.Runetype)
-
-       // backend-dependent builtin types (e.g. int).
-       for _, s := range &typedefs {
-               s1 := builtinpkg.Lookup(s.name)
-
-               sameas := s.sameas32
-               if Widthptr == 8 {
-                       sameas = s.sameas64
-               }
-
-               simtype[s.etype] = sameas
-               minfltval[s.etype] = minfltval[sameas]
-               maxfltval[s.etype] = maxfltval[sameas]
-               minintval[s.etype] = minintval[sameas]
-               maxintval[s.etype] = maxintval[sameas]
-
-               t := types.New(s.etype)
-               t.Sym = s1
-               types.Types[s.etype] = t
-               s1.Def = asTypesNode(typenod(t))
-               asNode(s1.Def).Name = new(Name)
-               s1.Origpkg = builtinpkg
-
-               dowidth(t)
-       }
-}
-
-// finishUniverse makes the universe block visible within the current package.
-func finishUniverse() {
-       // Operationally, this is similar to a dot import of builtinpkg, except
-       // that we silently skip symbols that are already declared in the
-       // package block rather than emitting a redeclared symbol error.
-
-       for _, s := range builtinpkg.Syms {
-               if s.Def == nil {
-                       continue
-               }
-               s1 := lookup(s.Name)
-               if s1.Def != nil {
-                       continue
-               }
-
-               s1.Def = s.Def
-               s1.Block = s.Block
-       }
-
-       nodfp = newname(lookup(".fp"))
-       nodfp.Type = types.Types[TINT32]
-       nodfp.SetClass(PPARAM)
-       nodfp.Name.SetUsed(true)
-}

diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
deleted file mode 100644 (file)
index 2233961..0000000
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-// evalunsafe evaluates a package unsafe operation and returns the result.
-func evalunsafe(n *Node) int64 {
-       switch n.Op {
-       case OALIGNOF, OSIZEOF:
-               n.Left = typecheck(n.Left, ctxExpr)
-               n.Left = defaultlit(n.Left, nil)
-               tr := n.Left.Type
-               if tr == nil {
-                       return 0
-               }
-               dowidth(tr)
-               if n.Op == OALIGNOF {
-                       return int64(tr.Align)
-               }
-               return tr.Width
-
-       case OOFFSETOF:
-               // must be a selector.
-               if n.Left.Op != OXDOT {
-                       yyerror("invalid expression %v", n)
-                       return 0
-               }
-
-               // Remember base of selector to find it back after dot insertion.
-               // Since r->left may be mutated by typechecking, check it explicitly
-               // first to track it correctly.
-               n.Left.Left = typecheck(n.Left.Left, ctxExpr)
-               base := n.Left.Left
-
-               n.Left = typecheck(n.Left, ctxExpr)
-               if n.Left.Type == nil {
-                       return 0
-               }
-               switch n.Left.Op {
-               case ODOT, ODOTPTR:
-                       break
-               case OCALLPART:
-                       yyerror("invalid expression %v: argument is a method value", n)
-                       return 0
-               default:
-                       yyerror("invalid expression %v", n)
-                       return 0
-               }
-
-               // Sum offsets for dots until we reach base.
-               var v int64
-               for r := n.Left; r != base; r = r.Left {
-                       switch r.Op {
-                       case ODOTPTR:
-                               // For Offsetof(s.f), s may itself be a pointer,
-                               // but accessing f must not otherwise involve
-                               // indirection via embedded pointer types.
-                               if r.Left != base {
-                                       yyerror("invalid expression %v: selector implies indirection of embedded %v", n, r.Left)
-                                       return 0
-                               }
-                               fallthrough
-                       case ODOT:
-                               v += r.Xoffset
-                       default:
-                               Dump("unsafenmagic", n.Left)
-                               Fatalf("impossible %#v node after dot insertion", r.Op)
-                       }
-               }
-               return v
-       }
-
-       Fatalf("unexpected op %v", n.Op)
-       return 0
-}

diff --git a/src/cmd/compile/internal/gc/util.go b/src/cmd/compile/internal/gc/util.go
index 58be2f82530a90cb694a7820ade234304a065ea4..4baddbc029a8d2dc587650a1b99243bc20b9b619 100644 (file)
--- a/src/cmd/compile/internal/gc/util.go
+++ b/src/cmd/compile/internal/gc/util.go
@@ -8,59 +8,35 @@ import (
        "os"
        "runtime"
        "runtime/pprof"
-)
-
-// Line returns n's position as a string. If n has been inlined,
-// it uses the outermost position where n has been inlined.
-func (n *Node) Line() string {
-       return linestr(n.Pos)
-}
 
-var atExitFuncs []func()
-
-func atExit(f func()) {
-       atExitFuncs = append(atExitFuncs, f)
-}
-
-func Exit(code int) {
-       for i := len(atExitFuncs) - 1; i >= 0; i-- {
-               f := atExitFuncs[i]
-               atExitFuncs = atExitFuncs[:i]
-               f()
-       }
-       os.Exit(code)
-}
+       "cmd/compile/internal/base"
+)
 
 var (
-       blockprofile   string
-       cpuprofile     string
-       memprofile     string
        memprofilerate int64
-       traceprofile   string
        traceHandler   func(string)
-       mutexprofile   string
 )
 
 func startProfile() {
-       if cpuprofile != "" {
-               f, err := os.Create(cpuprofile)
+       if base.Flag.CPUProfile != "" {
+               f, err := os.Create(base.Flag.CPUProfile)
                if err != nil {
-                       Fatalf("%v", err)
+                       base.Fatalf("%v", err)
                }
                if err := pprof.StartCPUProfile(f); err != nil {
-                       Fatalf("%v", err)
+                       base.Fatalf("%v", err)
                }
-               atExit(pprof.StopCPUProfile)
+               base.AtExit(pprof.StopCPUProfile)
        }
-       if memprofile != "" {
+       if base.Flag.MemProfile != "" {
                if memprofilerate != 0 {
                        runtime.MemProfileRate = int(memprofilerate)
                }
-               f, err := os.Create(memprofile)
+               f, err := os.Create(base.Flag.MemProfile)
                if err != nil {
-                       Fatalf("%v", err)
+                       base.Fatalf("%v", err)
                }
-               atExit(func() {
+               base.AtExit(func() {
                        // Profile all outstanding allocations.
                        runtime.GC()
                        // compilebench parses the memory profile to extract memstats,
@@ -68,36 +44,36 @@ func startProfile() {
                        // See golang.org/issue/18641 and runtime/pprof/pprof.go:writeHeap.
                        const writeLegacyFormat = 1
                        if err := pprof.Lookup("heap").WriteTo(f, writeLegacyFormat); err != nil {
-                               Fatalf("%v", err)
+                               base.Fatalf("%v", err)
                        }
                })
        } else {
                // Not doing memory profiling; disable it entirely.
                runtime.MemProfileRate = 0
        }
-       if blockprofile != "" {
-               f, err := os.Create(blockprofile)
+       if base.Flag.BlockProfile != "" {
+               f, err := os.Create(base.Flag.BlockProfile)
                if err != nil {
-                       Fatalf("%v", err)
+                       base.Fatalf("%v", err)
                }
                runtime.SetBlockProfileRate(1)
-               atExit(func() {
+               base.AtExit(func() {
                        pprof.Lookup("block").WriteTo(f, 0)
                        f.Close()
                })
        }
-       if mutexprofile != "" {
-               f, err := os.Create(mutexprofile)
+       if base.Flag.MutexProfile != "" {
+               f, err := os.Create(base.Flag.MutexProfile)
                if err != nil {
-                       Fatalf("%v", err)
+                       base.Fatalf("%v", err)
                }
                startMutexProfiling()
-               atExit(func() {
+               base.AtExit(func() {
                        pprof.Lookup("mutex").WriteTo(f, 0)
                        f.Close()
                })
        }
-       if traceprofile != "" && traceHandler != nil {
-               traceHandler(traceprofile)
+       if base.Flag.TraceProfile != "" && traceHandler != nil {
+               traceHandler(base.Flag.TraceProfile)
        }
 }

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
deleted file mode 100644 (file)
index a7b6e7f..0000000
--- a/src/cmd/compile/internal/gc/walk.go
+++ /dev/null
@@ -1,4090 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc
-
-import (
-       "cmd/compile/internal/types"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/sys"
-       "encoding/binary"
-       "fmt"
-       "strings"
-)
-
-// The constant is known to runtime.
-const tmpstringbufsize = 32
-const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
-
-func walk(fn *Node) {
-       Curfn = fn
-
-       if Debug.W != 0 {
-               s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
-               dumplist(s, Curfn.Nbody)
-       }
-
-       lno := lineno
-
-       // Final typecheck for any unused variables.
-       for i, ln := range fn.Func.Dcl {
-               if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) {
-                       ln = typecheck(ln, ctxExpr|ctxAssign)
-                       fn.Func.Dcl[i] = ln
-               }
-       }
-
-       // Propagate the used flag for typeswitch variables up to the NONAME in its definition.
-       for _, ln := range fn.Func.Dcl {
-               if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) && ln.Name.Defn != nil && ln.Name.Defn.Op == OTYPESW && ln.Name.Used() {
-                       ln.Name.Defn.Left.Name.SetUsed(true)
-               }
-       }
-
-       for _, ln := range fn.Func.Dcl {
-               if ln.Op != ONAME || (ln.Class() != PAUTO && ln.Class() != PAUTOHEAP) || ln.Sym.Name[0] == '&' || ln.Name.Used() {
-                       continue
-               }
-               if defn := ln.Name.Defn; defn != nil && defn.Op == OTYPESW {
-                       if defn.Left.Name.Used() {
-                               continue
-                       }
-                       yyerrorl(defn.Left.Pos, "%v declared but not used", ln.Sym)
-                       defn.Left.Name.SetUsed(true) // suppress repeats
-               } else {
-                       yyerrorl(ln.Pos, "%v declared but not used", ln.Sym)
-               }
-       }
-
-       lineno = lno
-       if nerrors != 0 {
-               return
-       }
-       walkstmtlist(Curfn.Nbody.Slice())
-       if Debug.W != 0 {
-               s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
-               dumplist(s, Curfn.Nbody)
-       }
-
-       zeroResults()
-       heapmoves()
-       if Debug.W != 0 && Curfn.Func.Enter.Len() > 0 {
-               s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
-               dumplist(s, Curfn.Func.Enter)
-       }
-}
-
-func walkstmtlist(s []*Node) {
-       for i := range s {
-               s[i] = walkstmt(s[i])
-       }
-}
-
-func paramoutheap(fn *Node) bool {
-       for _, ln := range fn.Func.Dcl {
-               switch ln.Class() {
-               case PPARAMOUT:
-                       if ln.isParamStackCopy() || ln.Name.Addrtaken() {
-                               return true
-                       }
-
-               case PAUTO:
-                       // stop early - parameters are over
-                       return false
-               }
-       }
-
-       return false
-}
-
-// The result of walkstmt MUST be assigned back to n, e.g.
-//     n.Left = walkstmt(n.Left)
-func walkstmt(n *Node) *Node {
-       if n == nil {
-               return n
-       }
-
-       setlineno(n)
-
-       walkstmtlist(n.Ninit.Slice())
-
-       switch n.Op {
-       default:
-               if n.Op == ONAME {
-                       yyerror("%v is not a top level statement", n.Sym)
-               } else {
-                       yyerror("%v is not a top level statement", n.Op)
-               }
-               Dump("nottop", n)
-
-       case OAS,
-               OASOP,
-               OAS2,
-               OAS2DOTTYPE,
-               OAS2RECV,
-               OAS2FUNC,
-               OAS2MAPR,
-               OCLOSE,
-               OCOPY,
-               OCALLMETH,
-               OCALLINTER,
-               OCALL,
-               OCALLFUNC,
-               ODELETE,
-               OSEND,
-               OPRINT,
-               OPRINTN,
-               OPANIC,
-               OEMPTY,
-               ORECOVER,
-               OGETG:
-               if n.Typecheck() == 0 {
-                       Fatalf("missing typecheck: %+v", n)
-               }
-               wascopy := n.Op == OCOPY
-               init := n.Ninit
-               n.Ninit.Set(nil)
-               n = walkexpr(n, &init)
-               n = addinit(n, init.Slice())
-               if wascopy && n.Op == OCONVNOP {
-                       n.Op = OEMPTY // don't leave plain values as statements.
-               }
-
-       // special case for a receive where we throw away
-       // the value received.
-       case ORECV:
-               if n.Typecheck() == 0 {
-                       Fatalf("missing typecheck: %+v", n)
-               }
-               init := n.Ninit
-               n.Ninit.Set(nil)
-
-               n.Left = walkexpr(n.Left, &init)
-               n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, n.Left, nodnil())
-               n = walkexpr(n, &init)
-
-               n = addinit(n, init.Slice())
-
-       case OBREAK,
-               OCONTINUE,
-               OFALL,
-               OGOTO,
-               OLABEL,
-               ODCLCONST,
-               ODCLTYPE,
-               OCHECKNIL,
-               OVARDEF,
-               OVARKILL,
-               OVARLIVE:
-               break
-
-       case ODCL:
-               v := n.Left
-               if v.Class() == PAUTOHEAP {
-                       if compiling_runtime {
-                               yyerror("%v escapes to heap, not allowed in runtime", v)
-                       }
-                       if prealloc[v] == nil {
-                               prealloc[v] = callnew(v.Type)
-                       }
-                       nn := nod(OAS, v.Name.Param.Heapaddr, prealloc[v])
-                       nn.SetColas(true)
-                       nn = typecheck(nn, ctxStmt)
-                       return walkstmt(nn)
-               }
-
-       case OBLOCK:
-               walkstmtlist(n.List.Slice())
-
-       case OCASE:
-               yyerror("case statement out of place")
-
-       case ODEFER:
-               Curfn.Func.SetHasDefer(true)
-               Curfn.Func.numDefers++
-               if Curfn.Func.numDefers > maxOpenDefers {
-                       // Don't allow open-coded defers if there are more than
-                       // 8 defers in the function, since we use a single
-                       // byte to record active defers.
-                       Curfn.Func.SetOpenCodedDeferDisallowed(true)
-               }
-               if n.Esc != EscNever {
-                       // If n.Esc is not EscNever, then this defer occurs in a loop,
-                       // so open-coded defers cannot be used in this function.
-                       Curfn.Func.SetOpenCodedDeferDisallowed(true)
-               }
-               fallthrough
-       case OGO:
-               switch n.Left.Op {
-               case OPRINT, OPRINTN:
-                       n.Left = wrapCall(n.Left, &n.Ninit)
-
-               case ODELETE:
-                       if mapfast(n.Left.List.First().Type) == mapslow {
-                               n.Left = wrapCall(n.Left, &n.Ninit)
-                       } else {
-                               n.Left = walkexpr(n.Left, &n.Ninit)
-                       }
-
-               case OCOPY:
-                       n.Left = copyany(n.Left, &n.Ninit, true)
-
-               case OCALLFUNC, OCALLMETH, OCALLINTER:
-                       if n.Left.Nbody.Len() > 0 {
-                               n.Left = wrapCall(n.Left, &n.Ninit)
-                       } else {
-                               n.Left = walkexpr(n.Left, &n.Ninit)
-                       }
-
-               default:
-                       n.Left = walkexpr(n.Left, &n.Ninit)
-               }
-
-       case OFOR, OFORUNTIL:
-               if n.Left != nil {
-                       walkstmtlist(n.Left.Ninit.Slice())
-                       init := n.Left.Ninit
-                       n.Left.Ninit.Set(nil)
-                       n.Left = walkexpr(n.Left, &init)
-                       n.Left = addinit(n.Left, init.Slice())
-               }
-
-               n.Right = walkstmt(n.Right)
-               if n.Op == OFORUNTIL {
-                       walkstmtlist(n.List.Slice())
-               }
-               walkstmtlist(n.Nbody.Slice())
-
-       case OIF:
-               n.Left = walkexpr(n.Left, &n.Ninit)
-               walkstmtlist(n.Nbody.Slice())
-               walkstmtlist(n.Rlist.Slice())
-
-       case ORETURN:
-               Curfn.Func.numReturns++
-               if n.List.Len() == 0 {
-                       break
-               }
-               if (Curfn.Type.FuncType().Outnamed && n.List.Len() > 1) || paramoutheap(Curfn) {
-                       // assign to the function out parameters,
-                       // so that reorder3 can fix up conflicts
-                       var rl []*Node
-
-                       for _, ln := range Curfn.Func.Dcl {
-                               cl := ln.Class()
-                               if cl == PAUTO || cl == PAUTOHEAP {
-                                       break
-                               }
-                               if cl == PPARAMOUT {
-                                       if ln.isParamStackCopy() {
-                                               ln = walkexpr(typecheck(nod(ODEREF, ln.Name.Param.Heapaddr, nil), ctxExpr), nil)
-                                       }
-                                       rl = append(rl, ln)
-                               }
-                       }
-
-                       if got, want := n.List.Len(), len(rl); got != want {
-                               // order should have rewritten multi-value function calls
-                               // with explicit OAS2FUNC nodes.
-                               Fatalf("expected %v return arguments, have %v", want, got)
-                       }
-
-                       // move function calls out, to make reorder3's job easier.
-                       walkexprlistsafe(n.List.Slice(), &n.Ninit)
-
-                       ll := ascompatee(n.Op, rl, n.List.Slice(), &n.Ninit)
-                       n.List.Set(reorder3(ll))
-                       break
-               }
-               walkexprlist(n.List.Slice(), &n.Ninit)
-
-               // For each return parameter (lhs), assign the corresponding result (rhs).
-               lhs := Curfn.Type.Results()
-               rhs := n.List.Slice()
-               res := make([]*Node, lhs.NumFields())
-               for i, nl := range lhs.FieldSlice() {
-                       nname := asNode(nl.Nname)
-                       if nname.isParamHeapCopy() {
-                               nname = nname.Name.Param.Stackcopy
-                       }
-                       a := nod(OAS, nname, rhs[i])
-                       res[i] = convas(a, &n.Ninit)
-               }
-               n.List.Set(res)
-
-       case ORETJMP:
-               break
-
-       case OINLMARK:
-               break
-
-       case OSELECT:
-               walkselect(n)
-
-       case OSWITCH:
-               walkswitch(n)
-
-       case ORANGE:
-               n = walkrange(n)
-       }
-
-       if n.Op == ONAME {
-               Fatalf("walkstmt ended up with name: %+v", n)
-       }
-       return n
-}
-
-// walk the whole tree of the body of an
-// expression or simple statement.
-// the types expressions are calculated.
-// compile-time constants are evaluated.
-// complex side effects like statements are appended to init
-func walkexprlist(s []*Node, init *Nodes) {
-       for i := range s {
-               s[i] = walkexpr(s[i], init)
-       }
-}
-
-func walkexprlistsafe(s []*Node, init *Nodes) {
-       for i, n := range s {
-               s[i] = safeexpr(n, init)
-               s[i] = walkexpr(s[i], init)
-       }
-}
-
-func walkexprlistcheap(s []*Node, init *Nodes) {
-       for i, n := range s {
-               s[i] = cheapexpr(n, init)
-               s[i] = walkexpr(s[i], init)
-       }
-}
-
-// convFuncName builds the runtime function name for interface conversion.
-// It also reports whether the function expects the data by address.
-// Not all names are possible. For example, we never generate convE2E or convE2I.
-func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
-       tkind := to.Tie()
-       switch from.Tie() {
-       case 'I':
-               if tkind == 'I' {
-                       return "convI2I", false
-               }
-       case 'T':
-               switch {
-               case from.Size() == 2 && from.Align == 2:
-                       return "convT16", false
-               case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
-                       return "convT32", false
-               case from.Size() == 8 && from.Align == types.Types[TUINT64].Align && !from.HasPointers():
-                       return "convT64", false
-               }
-               if sc := from.SoleComponent(); sc != nil {
-                       switch {
-                       case sc.IsString():
-                               return "convTstring", false
-                       case sc.IsSlice():
-                               return "convTslice", false
-                       }
-               }
-
-               switch tkind {
-               case 'E':
-                       if !from.HasPointers() {
-                               return "convT2Enoptr", true
-                       }
-                       return "convT2E", true
-               case 'I':
-                       if !from.HasPointers() {
-                               return "convT2Inoptr", true
-                       }
-                       return "convT2I", true
-               }
-       }
-       Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
-       panic("unreachable")
-}
-
-// The result of walkexpr MUST be assigned back to n, e.g.
-//     n.Left = walkexpr(n.Left, init)
-func walkexpr(n *Node, init *Nodes) *Node {
-       if n == nil {
-               return n
-       }
-
-       // Eagerly checkwidth all expressions for the back end.
-       if n.Type != nil && !n.Type.WidthCalculated() {
-               switch n.Type.Etype {
-               case TBLANK, TNIL, TIDEAL:
-               default:
-                       checkwidth(n.Type)
-               }
-       }
-
-       if init == &n.Ninit {
-               // not okay to use n->ninit when walking n,
-               // because we might replace n with some other node
-               // and would lose the init list.
-               Fatalf("walkexpr init == &n->ninit")
-       }
-
-       if n.Ninit.Len() != 0 {
-               walkstmtlist(n.Ninit.Slice())
-               init.AppendNodes(&n.Ninit)
-       }
-
-       lno := setlineno(n)
-
-       if Debug.w > 1 {
-               Dump("before walk expr", n)
-       }
-
-       if n.Typecheck() != 1 {
-               Fatalf("missed typecheck: %+v", n)
-       }
-
-       if n.Type.IsUntyped() {
-               Fatalf("expression has untyped type: %+v", n)
-       }
-
-       if n.Op == ONAME && n.Class() == PAUTOHEAP {
-               nn := nod(ODEREF, n.Name.Param.Heapaddr, nil)
-               nn = typecheck(nn, ctxExpr)
-               nn = walkexpr(nn, init)
-               nn.Left.MarkNonNil()
-               return nn
-       }
-
-opswitch:
-       switch n.Op {
-       default:
-               Dump("walk", n)
-               Fatalf("walkexpr: switch 1 unknown op %+S", n)
-
-       case ONONAME, OEMPTY, OGETG, ONEWOBJ:
-
-       case OTYPE, ONAME, OLITERAL:
-               // TODO(mdempsky): Just return n; see discussion on CL 38655.
-               // Perhaps refactor to use Node.mayBeShared for these instead.
-               // If these return early, make sure to still call
-               // stringsym for constant strings.
-
-       case ONOT, ONEG, OPLUS, OBITNOT, OREAL, OIMAG, ODOTMETH, ODOTINTER,
-               ODEREF, OSPTR, OITAB, OIDATA, OADDR:
-               n.Left = walkexpr(n.Left, init)
-
-       case OEFACE, OAND, OANDNOT, OSUB, OMUL, OADD, OOR, OXOR, OLSH, ORSH:
-               n.Left = walkexpr(n.Left, init)
-               n.Right = walkexpr(n.Right, init)
-
-       case ODOT, ODOTPTR:
-               usefield(n)
-               n.Left = walkexpr(n.Left, init)
-
-       case ODOTTYPE, ODOTTYPE2:
-               n.Left = walkexpr(n.Left, init)
-               // Set up interface type addresses for back end.
-               n.Right = typename(n.Type)
-               if n.Op == ODOTTYPE {
-                       n.Right.Right = typename(n.Left.Type)
-               }
-               if !n.Type.IsInterface() && !n.Left.Type.IsEmptyInterface() {
-                       n.List.Set1(itabname(n.Type, n.Left.Type))
-               }
-
-       case OLEN, OCAP:
-               if isRuneCount(n) {
-                       // Replace len([]rune(string)) with runtime.countrunes(string).
-                       n = mkcall("countrunes", n.Type, init, conv(n.Left.Left, types.Types[TSTRING]))
-                       break
-               }
-
-               n.Left = walkexpr(n.Left, init)
-
-               // replace len(*[10]int) with 10.
-               // delayed until now to preserve side effects.
-               t := n.Left.Type
-
-               if t.IsPtr() {
-                       t = t.Elem()
-               }
-               if t.IsArray() {
-                       safeexpr(n.Left, init)
-                       setintconst(n, t.NumElem())
-                       n.SetTypecheck(1)
-               }
-
-       case OCOMPLEX:
-               // Use results from call expression as arguments for complex.
-               if n.Left == nil && n.Right == nil {
-                       n.Left = n.List.First()
-                       n.Right = n.List.Second()
-               }
-               n.Left = walkexpr(n.Left, init)
-               n.Right = walkexpr(n.Right, init)
-
-       case OEQ, ONE, OLT, OLE, OGT, OGE:
-               n = walkcompare(n, init)
-
-       case OANDAND, OOROR:
-               n.Left = walkexpr(n.Left, init)
-
-               // cannot put side effects from n.Right on init,
-               // because they cannot run before n.Left is checked.
-               // save elsewhere and store on the eventual n.Right.
-               var ll Nodes
-
-               n.Right = walkexpr(n.Right, &ll)
-               n.Right = addinit(n.Right, ll.Slice())
-
-       case OPRINT, OPRINTN:
-               n = walkprint(n, init)
-
-       case OPANIC:
-               n = mkcall("gopanic", nil, init, n.Left)
-
-       case ORECOVER:
-               n = mkcall("gorecover", n.Type, init, nod(OADDR, nodfp, nil))
-
-       case OCLOSUREVAR, OCFUNC:
-
-       case OCALLINTER, OCALLFUNC, OCALLMETH:
-               if n.Op == OCALLINTER {
-                       usemethod(n)
-                       markUsedIfaceMethod(n)
-               }
-
-               if n.Op == OCALLFUNC && n.Left.Op == OCLOSURE {
-                       // Transform direct call of a closure to call of a normal function.
-                       // transformclosure already did all preparation work.
-
-                       // Prepend captured variables to argument list.
-                       n.List.Prepend(n.Left.Func.Enter.Slice()...)
-
-                       n.Left.Func.Enter.Set(nil)
-
-                       // Replace OCLOSURE with ONAME/PFUNC.
-                       n.Left = n.Left.Func.Closure.Func.Nname
-
-                       // Update type of OCALLFUNC node.
-                       // Output arguments had not changed, but their offsets could.
-                       if n.Left.Type.NumResults() == 1 {
-                               n.Type = n.Left.Type.Results().Field(0).Type
-                       } else {
-                               n.Type = n.Left.Type.Results()
-                       }
-               }
-
-               walkCall(n, init)
-
-       case OAS, OASOP:
-               init.AppendNodes(&n.Ninit)
-
-               // Recognize m[k] = append(m[k], ...) so we can reuse
-               // the mapassign call.
-               mapAppend := n.Left.Op == OINDEXMAP && n.Right.Op == OAPPEND
-               if mapAppend && !samesafeexpr(n.Left, n.Right.List.First()) {
-                       Fatalf("not same expressions: %v != %v", n.Left, n.Right.List.First())
-               }
-
-               n.Left = walkexpr(n.Left, init)
-               n.Left = safeexpr(n.Left, init)
-
-               if mapAppend {
-                       n.Right.List.SetFirst(n.Left)
-               }
-
-               if n.Op == OASOP {
-                       // Rewrite x op= y into x = x op y.
-                       n.Right = nod(n.SubOp(), n.Left, n.Right)
-                       n.Right = typecheck(n.Right, ctxExpr)
-
-                       n.Op = OAS
-                       n.ResetAux()
-               }
-
-               if oaslit(n, init) {
-                       break
-               }
-
-               if n.Right == nil {
-                       // TODO(austin): Check all "implicit zeroing"
-                       break
-               }
-
-               if !instrumenting && isZero(n.Right) {
-                       break
-               }
-
-               switch n.Right.Op {
-               default:
-                       n.Right = walkexpr(n.Right, init)
-
-               case ORECV:
-                       // x = <-c; n.Left is x, n.Right.Left is c.
-                       // order.stmt made sure x is addressable.
-                       n.Right.Left = walkexpr(n.Right.Left, init)
-
-                       n1 := nod(OADDR, n.Left, nil)
-                       r := n.Right.Left // the channel
-                       n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, r, n1)
-                       n = walkexpr(n, init)
-                       break opswitch
-
-               case OAPPEND:
-                       // x = append(...)
-                       r := n.Right
-                       if r.Type.Elem().NotInHeap() {
-                               yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type.Elem())
-                       }
-                       switch {
-                       case isAppendOfMake(r):
-                               // x = append(y, make([]T, y)...)
-                               r = extendslice(r, init)
-                       case r.IsDDD():
-                               r = appendslice(r, init) // also works for append(slice, string).
-                       default:
-                               r = walkappend(r, init, n)
-                       }
-                       n.Right = r
-                       if r.Op == OAPPEND {
-                               // Left in place for back end.
-                               // Do not add a new write barrier.
-                               // Set up address of type for back end.
-                               r.Left = typename(r.Type.Elem())
-                               break opswitch
-                       }
-                       // Otherwise, lowered for race detector.
-                       // Treat as ordinary assignment.
-               }
-
-               if n.Left != nil && n.Right != nil {
-                       n = convas(n, init)
-               }
-
-       case OAS2:
-               init.AppendNodes(&n.Ninit)
-               walkexprlistsafe(n.List.Slice(), init)
-               walkexprlistsafe(n.Rlist.Slice(), init)
-               ll := ascompatee(OAS, n.List.Slice(), n.Rlist.Slice(), init)
-               ll = reorder3(ll)
-               n = liststmt(ll)
-
-       // a,b,... = fn()
-       case OAS2FUNC:
-               init.AppendNodes(&n.Ninit)
-
-               r := n.Right
-               walkexprlistsafe(n.List.Slice(), init)
-               r = walkexpr(r, init)
-
-               if isIntrinsicCall(r) {
-                       n.Right = r
-                       break
-               }
-               init.Append(r)
-
-               ll := ascompatet(n.List, r.Type)
-               n = liststmt(ll)
-
-       // x, y = <-c
-       // order.stmt made sure x is addressable or blank.
-       case OAS2RECV:
-               init.AppendNodes(&n.Ninit)
-
-               r := n.Right
-               walkexprlistsafe(n.List.Slice(), init)
-               r.Left = walkexpr(r.Left, init)
-               var n1 *Node
-               if n.List.First().isBlank() {
-                       n1 = nodnil()
-               } else {
-                       n1 = nod(OADDR, n.List.First(), nil)
-               }
-               fn := chanfn("chanrecv2", 2, r.Left.Type)
-               ok := n.List.Second()
-               call := mkcall1(fn, types.Types[TBOOL], init, r.Left, n1)
-               n = nod(OAS, ok, call)
-               n = typecheck(n, ctxStmt)
-
-       // a,b = m[i]
-       case OAS2MAPR:
-               init.AppendNodes(&n.Ninit)
-
-               r := n.Right
-               walkexprlistsafe(n.List.Slice(), init)
-               r.Left = walkexpr(r.Left, init)
-               r.Right = walkexpr(r.Right, init)
-               t := r.Left.Type
-
-               fast := mapfast(t)
-               var key *Node
-               if fast != mapslow {
-                       // fast versions take key by value
-                       key = r.Right
-               } else {
-                       // standard version takes key by reference
-                       // order.expr made sure key is addressable.
-                       key = nod(OADDR, r.Right, nil)
-               }
-
-               // from:
-               //   a,b = m[i]
-               // to:
-               //   var,b = mapaccess2*(t, m, i)
-               //   a = *var
-               a := n.List.First()
-
-               if w := t.Elem().Width; w <= zeroValSize {
-                       fn := mapfn(mapaccess2[fast], t)
-                       r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key)
-               } else {
-                       fn := mapfn("mapaccess2_fat", t)
-                       z := zeroaddr(w)
-                       r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key, z)
-               }
-
-               // mapaccess2* returns a typed bool, but due to spec changes,
-               // the boolean result of i.(T) is now untyped so we make it the
-               // same type as the variable on the lhs.
-               if ok := n.List.Second(); !ok.isBlank() && ok.Type.IsBoolean() {
-                       r.Type.Field(1).Type = ok.Type
-               }
-               n.Right = r
-               n.Op = OAS2FUNC
-
-               // don't generate a = *var if a is _
-               if !a.isBlank() {
-                       var_ := temp(types.NewPtr(t.Elem()))
-                       var_.SetTypecheck(1)
-                       var_.MarkNonNil() // mapaccess always returns a non-nil pointer
-                       n.List.SetFirst(var_)
-                       n = walkexpr(n, init)
-                       init.Append(n)
-                       n = nod(OAS, a, nod(ODEREF, var_, nil))
-               }
-
-               n = typecheck(n, ctxStmt)
-               n = walkexpr(n, init)
-
-       case ODELETE:
-               init.AppendNodes(&n.Ninit)
-               map_ := n.List.First()
-               key := n.List.Second()
-               map_ = walkexpr(map_, init)
-               key = walkexpr(key, init)
-
-               t := map_.Type
-               fast := mapfast(t)
-               if fast == mapslow {
-                       // order.stmt made sure key is addressable.
-                       key = nod(OADDR, key, nil)
-               }
-               n = mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
-
-       case OAS2DOTTYPE:
-               walkexprlistsafe(n.List.Slice(), init)
-               n.Right = walkexpr(n.Right, init)
-
-       case OCONVIFACE:
-               n.Left = walkexpr(n.Left, init)
-
-               fromType := n.Left.Type
-               toType := n.Type
-
-               if !fromType.IsInterface() && !Curfn.Func.Nname.isBlank() { // skip unnamed functions (func _())
-                       markTypeUsedInInterface(fromType, Curfn.Func.lsym)
-               }
-
-               // typeword generates the type word of the interface value.
-               typeword := func() *Node {
-                       if toType.IsEmptyInterface() {
-                               return typename(fromType)
-                       }
-                       return itabname(fromType, toType)
-               }
-
-               // Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
-               if isdirectiface(fromType) {
-                       l := nod(OEFACE, typeword(), n.Left)
-                       l.Type = toType
-                       l.SetTypecheck(n.Typecheck())
-                       n = l
-                       break
-               }
-
-               if staticuint64s == nil {
-                       staticuint64s = newname(Runtimepkg.Lookup("staticuint64s"))
-                       staticuint64s.SetClass(PEXTERN)
-                       // The actual type is [256]uint64, but we use [256*8]uint8 so we can address
-                       // individual bytes.
-                       staticuint64s.Type = types.NewArray(types.Types[TUINT8], 256*8)
-                       zerobase = newname(Runtimepkg.Lookup("zerobase"))
-                       zerobase.SetClass(PEXTERN)
-                       zerobase.Type = types.Types[TUINTPTR]
-               }
-
-               // Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
-               // by using an existing addressable value identical to n.Left
-               // or creating one on the stack.
-               var value *Node
-               switch {
-               case fromType.Size() == 0:
-                       // n.Left is zero-sized. Use zerobase.
-                       cheapexpr(n.Left, init) // Evaluate n.Left for side-effects. See issue 19246.
-                       value = zerobase
-               case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
-                       // n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
-                       // and staticuint64s[n.Left * 8 + 7] on big-endian.
-                       n.Left = cheapexpr(n.Left, init)
-                       // byteindex widens n.Left so that the multiplication doesn't overflow.
-                       index := nod(OLSH, byteindex(n.Left), nodintconst(3))
-                       if thearch.LinkArch.ByteOrder == binary.BigEndian {
-                               index = nod(OADD, index, nodintconst(7))
-                       }
-                       value = nod(OINDEX, staticuint64s, index)
-                       value.SetBounded(true)
-               case n.Left.Class() == PEXTERN && n.Left.Name != nil && n.Left.Name.Readonly():
-                       // n.Left is a readonly global; use it directly.
-                       value = n.Left
-               case !fromType.IsInterface() && n.Esc == EscNone && fromType.Width <= 1024:
-                       // n.Left does not escape. Use a stack temporary initialized to n.Left.
-                       value = temp(fromType)
-                       init.Append(typecheck(nod(OAS, value, n.Left), ctxStmt))
-               }
-
-               if value != nil {
-                       // Value is identical to n.Left.
-                       // Construct the interface directly: {type/itab, &value}.
-                       l := nod(OEFACE, typeword(), typecheck(nod(OADDR, value, nil), ctxExpr))
-                       l.Type = toType
-                       l.SetTypecheck(n.Typecheck())
-                       n = l
-                       break
-               }
-
-               // Implement interface to empty interface conversion.
-               // tmp = i.itab
-               // if tmp != nil {
-               //    tmp = tmp.type
-               // }
-               // e = iface{tmp, i.data}
-               if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
-                       // Evaluate the input interface.
-                       c := temp(fromType)
-                       init.Append(nod(OAS, c, n.Left))
-
-                       // Get the itab out of the interface.
-                       tmp := temp(types.NewPtr(types.Types[TUINT8]))
-                       init.Append(nod(OAS, tmp, typecheck(nod(OITAB, c, nil), ctxExpr)))
-
-                       // Get the type out of the itab.
-                       nif := nod(OIF, typecheck(nod(ONE, tmp, nodnil()), ctxExpr), nil)
-                       nif.Nbody.Set1(nod(OAS, tmp, itabType(tmp)))
-                       init.Append(nif)
-
-                       // Build the result.
-                       e := nod(OEFACE, tmp, ifaceData(n.Pos, c, types.NewPtr(types.Types[TUINT8])))
-                       e.Type = toType // assign type manually, typecheck doesn't understand OEFACE.
-                       e.SetTypecheck(1)
-                       n = e
-                       break
-               }
-
-               fnname, needsaddr := convFuncName(fromType, toType)
-
-               if !needsaddr && !fromType.IsInterface() {
-                       // Use a specialized conversion routine that only returns a data pointer.
-                       // ptr = convT2X(val)
-                       // e = iface{typ/tab, ptr}
-                       fn := syslook(fnname)
-                       dowidth(fromType)
-                       fn = substArgTypes(fn, fromType)
-                       dowidth(fn.Type)
-                       call := nod(OCALL, fn, nil)
-                       call.List.Set1(n.Left)
-                       call = typecheck(call, ctxExpr)
-                       call = walkexpr(call, init)
-                       call = safeexpr(call, init)
-                       e := nod(OEFACE, typeword(), call)
-                       e.Type = toType
-                       e.SetTypecheck(1)
-                       n = e
-                       break
-               }
-
-               var tab *Node
-               if fromType.IsInterface() {
-                       // convI2I
-                       tab = typename(toType)
-               } else {
-                       // convT2x
-                       tab = typeword()
-               }
-
-               v := n.Left
-               if needsaddr {
-                       // Types of large or unknown size are passed by reference.
-                       // Orderexpr arranged for n.Left to be a temporary for all
-                       // the conversions it could see. Comparison of an interface
-                       // with a non-interface, especially in a switch on interface value
-                       // with non-interface cases, is not visible to order.stmt, so we
-                       // have to fall back on allocating a temp here.
-                       if !islvalue(v) {
-                               v = copyexpr(v, v.Type, init)
-                       }
-                       v = nod(OADDR, v, nil)
-               }
-
-               dowidth(fromType)
-               fn := syslook(fnname)
-               fn = substArgTypes(fn, fromType, toType)
-               dowidth(fn.Type)
-               n = nod(OCALL, fn, nil)
-               n.List.Set2(tab, v)
-               n = typecheck(n, ctxExpr)
-               n = walkexpr(n, init)
-
-       case OCONV, OCONVNOP:
-               n.Left = walkexpr(n.Left, init)
-               if n.Op == OCONVNOP && checkPtr(Curfn, 1) {
-                       if n.Type.IsPtr() && n.Left.Type.IsUnsafePtr() { // unsafe.Pointer to *T
-                               n = walkCheckPtrAlignment(n, init, nil)
-                               break
-                       }
-                       if n.Type.IsUnsafePtr() && n.Left.Type.IsUintptr() { // uintptr to unsafe.Pointer
-                               n = walkCheckPtrArithmetic(n, init)
-                               break
-                       }
-               }
-               param, result := rtconvfn(n.Left.Type, n.Type)
-               if param == Txxx {
-                       break
-               }
-               fn := basicnames[param] + "to" + basicnames[result]
-               n = conv(mkcall(fn, types.Types[result], init, conv(n.Left, types.Types[param])), n.Type)
-
-       case ODIV, OMOD:
-               n.Left = walkexpr(n.Left, init)
-               n.Right = walkexpr(n.Right, init)
-
-               // rewrite complex div into function call.
-               et := n.Left.Type.Etype
-
-               if isComplex[et] && n.Op == ODIV {
-                       t := n.Type
-                       n = mkcall("complex128div", types.Types[TCOMPLEX128], init, conv(n.Left, types.Types[TCOMPLEX128]), conv(n.Right, types.Types[TCOMPLEX128]))
-                       n = conv(n, t)
-                       break
-               }
-
-               // Nothing to do for float divisions.
-               if isFloat[et] {
-                       break
-               }
-
-               // rewrite 64-bit div and mod on 32-bit architectures.
-               // TODO: Remove this code once we can introduce
-               // runtime calls late in SSA processing.
-               if Widthreg < 8 && (et == TINT64 || et == TUINT64) {
-                       if n.Right.Op == OLITERAL {
-                               // Leave div/mod by constant powers of 2 or small 16-bit constants.
-                               // The SSA backend will handle those.
-                               switch et {
-                               case TINT64:
-                                       c := n.Right.Int64Val()
-                                       if c < 0 {
-                                               c = -c
-                                       }
-                                       if c != 0 && c&(c-1) == 0 {
-                                               break opswitch
-                                       }
-                               case TUINT64:
-                                       c := uint64(n.Right.Int64Val())
-                                       if c < 1<<16 {
-                                               break opswitch
-                                       }
-                                       if c != 0 && c&(c-1) == 0 {
-                                               break opswitch
-                                       }
-                               }
-                       }
-                       var fn string
-                       if et == TINT64 {
-                               fn = "int64"
-                       } else {
-                               fn = "uint64"
-                       }
-                       if n.Op == ODIV {
-                               fn += "div"
-                       } else {
-                               fn += "mod"
-                       }
-                       n = mkcall(fn, n.Type, init, conv(n.Left, types.Types[et]), conv(n.Right, types.Types[et]))
-               }
-
-       case OINDEX:
-               n.Left = walkexpr(n.Left, init)
-
-               // save the original node for bounds checking elision.
-               // If it was a ODIV/OMOD walk might rewrite it.
-               r := n.Right
-
-               n.Right = walkexpr(n.Right, init)
-
-               // if range of type cannot exceed static array bound,
-               // disable bounds check.
-               if n.Bounded() {
-                       break
-               }
-               t := n.Left.Type
-               if t != nil && t.IsPtr() {
-                       t = t.Elem()
-               }
-               if t.IsArray() {
-                       n.SetBounded(bounded(r, t.NumElem()))
-                       if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, CTINT) {
-                               Warn("index bounds check elided")
-                       }
-                       if smallintconst(n.Right) && !n.Bounded() {
-                               yyerror("index out of bounds")
-                       }
-               } else if Isconst(n.Left, CTSTR) {
-                       n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-                       if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, CTINT) {
-                               Warn("index bounds check elided")
-                       }
-                       if smallintconst(n.Right) && !n.Bounded() {
-                               yyerror("index out of bounds")
-                       }
-               }
-
-               if Isconst(n.Right, CTINT) {
-                       if n.Right.Val().U.(*Mpint).CmpInt64(0) < 0 || n.Right.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
-                               yyerror("index out of bounds")
-                       }
-               }
-
-       case OINDEXMAP:
-               // Replace m[k] with *map{access1,assign}(maptype, m, &k)
-               n.Left = walkexpr(n.Left, init)
-               n.Right = walkexpr(n.Right, init)
-               map_ := n.Left
-               key := n.Right
-               t := map_.Type
-               if n.IndexMapLValue() {
-                       // This m[k] expression is on the left-hand side of an assignment.
-                       fast := mapfast(t)
-                       if fast == mapslow {
-                               // standard version takes key by reference.
-                               // order.expr made sure key is addressable.
-                               key = nod(OADDR, key, nil)
-                       }
-                       n = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
-               } else {
-                       // m[k] is not the target of an assignment.
-                       fast := mapfast(t)
-                       if fast == mapslow {
-                               // standard version takes key by reference.
-                               // order.expr made sure key is addressable.
-                               key = nod(OADDR, key, nil)
-                       }
-
-                       if w := t.Elem().Width; w <= zeroValSize {
-                               n = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, typename(t), map_, key)
-                       } else {
-                               z := zeroaddr(w)
-                               n = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, typename(t), map_, key, z)
-                       }
-               }
-               n.Type = types.NewPtr(t.Elem())
-               n.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
-               n = nod(ODEREF, n, nil)
-               n.Type = t.Elem()
-               n.SetTypecheck(1)
-
-       case ORECV:
-               Fatalf("walkexpr ORECV") // should see inside OAS only
-
-       case OSLICEHEADER:
-               n.Left = walkexpr(n.Left, init)
-               n.List.SetFirst(walkexpr(n.List.First(), init))
-               n.List.SetSecond(walkexpr(n.List.Second(), init))
-
-       case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
-               checkSlice := checkPtr(Curfn, 1) && n.Op == OSLICE3ARR && n.Left.Op == OCONVNOP && n.Left.Left.Type.IsUnsafePtr()
-               if checkSlice {
-                       n.Left.Left = walkexpr(n.Left.Left, init)
-               } else {
-                       n.Left = walkexpr(n.Left, init)
-               }
-               low, high, max := n.SliceBounds()
-               low = walkexpr(low, init)
-               if low != nil && isZero(low) {
-                       // Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
-                       low = nil
-               }
-               high = walkexpr(high, init)
-               max = walkexpr(max, init)
-               n.SetSliceBounds(low, high, max)
-               if checkSlice {
-                       n.Left = walkCheckPtrAlignment(n.Left, init, max)
-               }
-               if n.Op.IsSlice3() {
-                       if max != nil && max.Op == OCAP && samesafeexpr(n.Left, max.Left) {
-                               // Reduce x[i:j:cap(x)] to x[i:j].
-                               if n.Op == OSLICE3 {
-                                       n.Op = OSLICE
-                               } else {
-                                       n.Op = OSLICEARR
-                               }
-                               n = reduceSlice(n)
-                       }
-               } else {
-                       n = reduceSlice(n)
-               }
-
-       case ONEW:
-               if n.Type.Elem().NotInHeap() {
-                       yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type.Elem())
-               }
-               if n.Esc == EscNone {
-                       if n.Type.Elem().Width >= maxImplicitStackVarSize {
-                               Fatalf("large ONEW with EscNone: %v", n)
-                       }
-                       r := temp(n.Type.Elem())
-                       r = nod(OAS, r, nil) // zero temp
-                       r = typecheck(r, ctxStmt)
-                       init.Append(r)
-                       r = nod(OADDR, r.Left, nil)
-                       r = typecheck(r, ctxExpr)
-                       n = r
-               } else {
-                       n = callnew(n.Type.Elem())
-               }
-
-       case OADDSTR:
-               n = addstr(n, init)
-
-       case OAPPEND:
-               // order should make sure we only see OAS(node, OAPPEND), which we handle above.
-               Fatalf("append outside assignment")
-
-       case OCOPY:
-               n = copyany(n, init, instrumenting && !compiling_runtime)
-
-               // cannot use chanfn - closechan takes any, not chan any
-       case OCLOSE:
-               fn := syslook("closechan")
-
-               fn = substArgTypes(fn, n.Left.Type)
-               n = mkcall1(fn, nil, init, n.Left)
-
-       case OMAKECHAN:
-               // When size fits into int, use makechan instead of
-               // makechan64, which is faster and shorter on 32 bit platforms.
-               size := n.Left
-               fnname := "makechan64"
-               argtype := types.Types[TINT64]
-
-               // Type checking guarantees that TIDEAL size is positive and fits in an int.
-               // The case of size overflow when converting TUINT or TUINTPTR to TINT
-               // will be handled by the negative range checks in makechan during runtime.
-               if size.Type.IsKind(TIDEAL) || maxintval[size.Type.Etype].Cmp(maxintval[TUINT]) <= 0 {
-                       fnname = "makechan"
-                       argtype = types.Types[TINT]
-               }
-
-               n = mkcall1(chanfn(fnname, 1, n.Type), n.Type, init, typename(n.Type), conv(size, argtype))
-
-       case OMAKEMAP:
-               t := n.Type
-               hmapType := hmap(t)
-               hint := n.Left
-
-               // var h *hmap
-               var h *Node
-               if n.Esc == EscNone {
-                       // Allocate hmap on stack.
-
-                       // var hv hmap
-                       hv := temp(hmapType)
-                       zero := nod(OAS, hv, nil)
-                       zero = typecheck(zero, ctxStmt)
-                       init.Append(zero)
-                       // h = &hv
-                       h = nod(OADDR, hv, nil)
-
-                       // Allocate one bucket pointed to by hmap.buckets on stack if hint
-                       // is not larger than BUCKETSIZE. In case hint is larger than
-                       // BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
-                       // Maximum key and elem size is 128 bytes, larger objects
-                       // are stored with an indirection. So max bucket size is 2048+eps.
-                       if !Isconst(hint, CTINT) ||
-                               hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
-
-                               // In case hint is larger than BUCKETSIZE runtime.makemap
-                               // will allocate the buckets on the heap, see #20184
-                               //
-                               // if hint <= BUCKETSIZE {
-                               //     var bv bmap
-                               //     b = &bv
-                               //     h.buckets = b
-                               // }
-
-                               nif := nod(OIF, nod(OLE, hint, nodintconst(BUCKETSIZE)), nil)
-                               nif.SetLikely(true)
-
-                               // var bv bmap
-                               bv := temp(bmap(t))
-                               zero = nod(OAS, bv, nil)
-                               nif.Nbody.Append(zero)
-
-                               // b = &bv
-                               b := nod(OADDR, bv, nil)
-
-                               // h.buckets = b
-                               bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
-                               na := nod(OAS, nodSym(ODOT, h, bsym), b)
-                               nif.Nbody.Append(na)
-
-                               nif = typecheck(nif, ctxStmt)
-                               nif = walkstmt(nif)
-                               init.Append(nif)
-                       }
-               }
-
-               if Isconst(hint, CTINT) && hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
-                       // Handling make(map[any]any) and
-                       // make(map[any]any, hint) where hint <= BUCKETSIZE
-                       // special allows for faster map initialization and
-                       // improves binary size by using calls with fewer arguments.
-                       // For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
-                       // and no buckets will be allocated by makemap. Therefore,
-                       // no buckets need to be allocated in this code path.
-                       if n.Esc == EscNone {
-                               // Only need to initialize h.hash0 since
-                               // hmap h has been allocated on the stack already.
-                               // h.hash0 = fastrand()
-                               rand := mkcall("fastrand", types.Types[TUINT32], init)
-                               hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-                               a := nod(OAS, nodSym(ODOT, h, hashsym), rand)
-                               a = typecheck(a, ctxStmt)
-                               a = walkexpr(a, init)
-                               init.Append(a)
-                               n = convnop(h, t)
-                       } else {
-                               // Call runtime.makehmap to allocate an
-                               // hmap on the heap and initialize hmap's hash0 field.
-                               fn := syslook("makemap_small")
-                               fn = substArgTypes(fn, t.Key(), t.Elem())
-                               n = mkcall1(fn, n.Type, init)
-                       }
-               } else {
-                       if n.Esc != EscNone {
-                               h = nodnil()
-                       }
-                       // Map initialization with a variable or large hint is
-                       // more complicated. We therefore generate a call to
-                       // runtime.makemap to initialize hmap and allocate the
-                       // map buckets.
-
-                       // When hint fits into int, use makemap instead of
-                       // makemap64, which is faster and shorter on 32 bit platforms.
-                       fnname := "makemap64"
-                       argtype := types.Types[TINT64]
-
-                       // Type checking guarantees that TIDEAL hint is positive and fits in an int.
-                       // See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
-                       // The case of hint overflow when converting TUINT or TUINTPTR to TINT
-                       // will be handled by the negative range checks in makemap during runtime.
-                       if hint.Type.IsKind(TIDEAL) || maxintval[hint.Type.Etype].Cmp(maxintval[TUINT]) <= 0 {
-                               fnname = "makemap"
-                               argtype = types.Types[TINT]
-                       }
-
-                       fn := syslook(fnname)
-                       fn = substArgTypes(fn, hmapType, t.Key(), t.Elem())
-                       n = mkcall1(fn, n.Type, init, typename(n.Type), conv(hint, argtype), h)
-               }
-
-       case OMAKESLICE:
-               l := n.Left
-               r := n.Right
-               if r == nil {
-                       r = safeexpr(l, init)
-                       l = r
-               }
-               t := n.Type
-               if t.Elem().NotInHeap() {
-                       yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
-               }
-               if n.Esc == EscNone {
-                       if why := heapAllocReason(n); why != "" {
-                               Fatalf("%v has EscNone, but %v", n, why)
-                       }
-                       // var arr [r]T
-                       // n = arr[:l]
-                       i := indexconst(r)
-                       if i < 0 {
-                               Fatalf("walkexpr: invalid index %v", r)
-                       }
-
-                       // cap is constrained to [0,2^31) or [0,2^63) depending on whether
-                       // we're in 32-bit or 64-bit systems. So it's safe to do:
-                       //
-                       // if uint64(len) > cap {
-                       //     if len < 0 { panicmakeslicelen() }
-                       //     panicmakeslicecap()
-                       // }
-                       nif := nod(OIF, nod(OGT, conv(l, types.Types[TUINT64]), nodintconst(i)), nil)
-                       niflen := nod(OIF, nod(OLT, l, nodintconst(0)), nil)
-                       niflen.Nbody.Set1(mkcall("panicmakeslicelen", nil, init))
-                       nif.Nbody.Append(niflen, mkcall("panicmakeslicecap", nil, init))
-                       nif = typecheck(nif, ctxStmt)
-                       init.Append(nif)
-
-                       t = types.NewArray(t.Elem(), i) // [r]T
-                       var_ := temp(t)
-                       a := nod(OAS, var_, nil) // zero temp
-                       a = typecheck(a, ctxStmt)
-                       init.Append(a)
-                       r := nod(OSLICE, var_, nil) // arr[:l]
-                       r.SetSliceBounds(nil, l, nil)
-                       r = conv(r, n.Type) // in case n.Type is named.
-                       r = typecheck(r, ctxExpr)
-                       r = walkexpr(r, init)
-                       n = r
-               } else {
-                       // n escapes; set up a call to makeslice.
-                       // When len and cap can fit into int, use makeslice instead of
-                       // makeslice64, which is faster and shorter on 32 bit platforms.
-
-                       len, cap := l, r
-
-                       fnname := "makeslice64"
-                       argtype := types.Types[TINT64]
-
-                       // Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
-                       // The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
-                       // will be handled by the negative range checks in makeslice during runtime.
-                       if (len.Type.IsKind(TIDEAL) || maxintval[len.Type.Etype].Cmp(maxintval[TUINT]) <= 0) &&
-                               (cap.Type.IsKind(TIDEAL) || maxintval[cap.Type.Etype].Cmp(maxintval[TUINT]) <= 0) {
-                               fnname = "makeslice"
-                               argtype = types.Types[TINT]
-                       }
-
-                       m := nod(OSLICEHEADER, nil, nil)
-                       m.Type = t
-
-                       fn := syslook(fnname)
-                       m.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
-                       m.Left.MarkNonNil()
-                       m.List.Set2(conv(len, types.Types[TINT]), conv(cap, types.Types[TINT]))
-
-                       m = typecheck(m, ctxExpr)
-                       m = walkexpr(m, init)
-                       n = m
-               }
-
-       case OMAKESLICECOPY:
-               if n.Esc == EscNone {
-                       Fatalf("OMAKESLICECOPY with EscNone: %v", n)
-               }
-
-               t := n.Type
-               if t.Elem().NotInHeap() {
-                       yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
-               }
-
-               length := conv(n.Left, types.Types[TINT])
-               copylen := nod(OLEN, n.Right, nil)
-               copyptr := nod(OSPTR, n.Right, nil)
-
-               if !t.Elem().HasPointers() && n.Bounded() {
-                       // When len(to)==len(from) and elements have no pointers:
-                       // replace make+copy with runtime.mallocgc+runtime.memmove.
-
-                       // We do not check for overflow of len(to)*elem.Width here
-                       // since len(from) is an existing checked slice capacity
-                       // with same elem.Width for the from slice.
-                       size := nod(OMUL, conv(length, types.Types[TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[TUINTPTR]))
-
-                       // instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
-                       fn := syslook("mallocgc")
-                       sh := nod(OSLICEHEADER, nil, nil)
-                       sh.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, size, nodnil(), nodbool(false))
-                       sh.Left.MarkNonNil()
-                       sh.List.Set2(length, length)
-                       sh.Type = t
-
-                       s := temp(t)
-                       r := typecheck(nod(OAS, s, sh), ctxStmt)
-                       r = walkexpr(r, init)
-                       init.Append(r)
-
-                       // instantiate memmove(to *any, frm *any, size uintptr)
-                       fn = syslook("memmove")
-                       fn = substArgTypes(fn, t.Elem(), t.Elem())
-                       ncopy := mkcall1(fn, nil, init, nod(OSPTR, s, nil), copyptr, size)
-                       ncopy = typecheck(ncopy, ctxStmt)
-                       ncopy = walkexpr(ncopy, init)
-                       init.Append(ncopy)
-
-                       n = s
-               } else { // Replace make+copy with runtime.makeslicecopy.
-                       // instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
-                       fn := syslook("makeslicecopy")
-                       s := nod(OSLICEHEADER, nil, nil)
-                       s.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[TUNSAFEPTR]))
-                       s.Left.MarkNonNil()
-                       s.List.Set2(length, length)
-                       s.Type = t
-                       n = typecheck(s, ctxExpr)
-                       n = walkexpr(n, init)
-               }
-
-       case ORUNESTR:
-               a := nodnil()
-               if n.Esc == EscNone {
-                       t := types.NewArray(types.Types[TUINT8], 4)
-                       a = nod(OADDR, temp(t), nil)
-               }
-               // intstring(*[4]byte, rune)
-               n = mkcall("intstring", n.Type, init, a, conv(n.Left, types.Types[TINT64]))
-
-       case OBYTES2STR, ORUNES2STR:
-               a := nodnil()
-               if n.Esc == EscNone {
-                       // Create temporary buffer for string on stack.
-                       t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-                       a = nod(OADDR, temp(t), nil)
-               }
-               if n.Op == ORUNES2STR {
-                       // slicerunetostring(*[32]byte, []rune) string
-                       n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
-               } else {
-                       // slicebytetostring(*[32]byte, ptr *byte, n int) string
-                       n.Left = cheapexpr(n.Left, init)
-                       ptr, len := n.Left.backingArrayPtrLen()
-                       n = mkcall("slicebytetostring", n.Type, init, a, ptr, len)
-               }
-
-       case OBYTES2STRTMP:
-               n.Left = walkexpr(n.Left, init)
-               if !instrumenting {
-                       // Let the backend handle OBYTES2STRTMP directly
-                       // to avoid a function call to slicebytetostringtmp.
-                       break
-               }
-               // slicebytetostringtmp(ptr *byte, n int) string
-               n.Left = cheapexpr(n.Left, init)
-               ptr, len := n.Left.backingArrayPtrLen()
-               n = mkcall("slicebytetostringtmp", n.Type, init, ptr, len)
-
-       case OSTR2BYTES:
-               s := n.Left
-               if Isconst(s, CTSTR) {
-                       sc := s.StringVal()
-
-                       // Allocate a [n]byte of the right size.
-                       t := types.NewArray(types.Types[TUINT8], int64(len(sc)))
-                       var a *Node
-                       if n.Esc == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
-                               a = nod(OADDR, temp(t), nil)
-                       } else {
-                               a = callnew(t)
-                       }
-                       p := temp(t.PtrTo()) // *[n]byte
-                       init.Append(typecheck(nod(OAS, p, a), ctxStmt))
-
-                       // Copy from the static string data to the [n]byte.
-                       if len(sc) > 0 {
-                               as := nod(OAS,
-                                       nod(ODEREF, p, nil),
-                                       nod(ODEREF, convnop(nod(OSPTR, s, nil), t.PtrTo()), nil))
-                               as = typecheck(as, ctxStmt)
-                               as = walkstmt(as)
-                               init.Append(as)
-                       }
-
-                       // Slice the [n]byte to a []byte.
-                       n.Op = OSLICEARR
-                       n.Left = p
-                       n = walkexpr(n, init)
-                       break
-               }
-
-               a := nodnil()
-               if n.Esc == EscNone {
-                       // Create temporary buffer for slice on stack.
-                       t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-                       a = nod(OADDR, temp(t), nil)
-               }
-               // stringtoslicebyte(*32[byte], string) []byte
-               n = mkcall("stringtoslicebyte", n.Type, init, a, conv(s, types.Types[TSTRING]))
-
-       case OSTR2BYTESTMP:
-               // []byte(string) conversion that creates a slice
-               // referring to the actual string bytes.
-               // This conversion is handled later by the backend and
-               // is only for use by internal compiler optimizations
-               // that know that the slice won't be mutated.
-               // The only such case today is:
-               // for i, c := range []byte(string)
-               n.Left = walkexpr(n.Left, init)
-
-       case OSTR2RUNES:
-               a := nodnil()
-               if n.Esc == EscNone {
-                       // Create temporary buffer for slice on stack.
-                       t := types.NewArray(types.Types[TINT32], tmpstringbufsize)
-                       a = nod(OADDR, temp(t), nil)
-               }
-               // stringtoslicerune(*[32]rune, string) []rune
-               n = mkcall("stringtoslicerune", n.Type, init, a, conv(n.Left, types.Types[TSTRING]))
-
-       case OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT, OPTRLIT:
-               if isStaticCompositeLiteral(n) && !canSSAType(n.Type) {
-                       // n can be directly represented in the read-only data section.
-                       // Make direct reference to the static data. See issue 12841.
-                       vstat := readonlystaticname(n.Type)
-                       fixedlit(inInitFunction, initKindStatic, n, vstat, init)
-                       n = vstat
-                       n = typecheck(n, ctxExpr)
-                       break
-               }
-               var_ := temp(n.Type)
-               anylit(n, var_, init)
-               n = var_
-
-       case OSEND:
-               n1 := n.Right
-               n1 = assignconv(n1, n.Left.Type.Elem(), "chan send")
-               n1 = walkexpr(n1, init)
-               n1 = nod(OADDR, n1, nil)
-               n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, n.Left, n1)
-
-       case OCLOSURE:
-               n = walkclosure(n, init)
-
-       case OCALLPART:
-               n = walkpartialcall(n, init)
-       }
-
-       // Expressions that are constant at run time but not
-       // considered const by the language spec are not turned into
-       // constants until walk. For example, if n is y%1 == 0, the
-       // walk of y%1 may have replaced it by 0.
-       // Check whether n with its updated args is itself now a constant.
-       t := n.Type
-       evconst(n)
-       if n.Type != t {
-               Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
-       }
-       if n.Op == OLITERAL {
-               n = typecheck(n, ctxExpr)
-               // Emit string symbol now to avoid emitting
-               // any concurrently during the backend.
-               if s, ok := n.Val().U.(string); ok {
-                       _ = stringsym(n.Pos, s)
-               }
-       }
-
-       updateHasCall(n)
-
-       if Debug.w != 0 && n != nil {
-               Dump("after walk expr", n)
-       }
-
-       lineno = lno
-       return n
-}
-
-// markTypeUsedInInterface marks that type t is converted to an interface.
-// This information is used in the linker in dead method elimination.
-func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
-       tsym := typenamesym(t).Linksym()
-       // Emit a marker relocation. The linker will know the type is converted
-       // to an interface if "from" is reachable.
-       r := obj.Addrel(from)
-       r.Sym = tsym
-       r.Type = objabi.R_USEIFACE
-}
-
-// markUsedIfaceMethod marks that an interface method is used in the current
-// function. n is OCALLINTER node.
-func markUsedIfaceMethod(n *Node) {
-       ityp := n.Left.Left.Type
-       tsym := typenamesym(ityp).Linksym()
-       r := obj.Addrel(Curfn.Func.lsym)
-       r.Sym = tsym
-       // n.Left.Xoffset is the method index * Widthptr (the offset of code pointer
-       // in itab).
-       midx := n.Left.Xoffset / int64(Widthptr)
-       r.Add = ifaceMethodOffset(ityp, midx)
-       r.Type = objabi.R_USEIFACEMETHOD
-}
-
-// rtconvfn returns the parameter and result types that will be used by a
-// runtime function to convert from type src to type dst. The runtime function
-// name can be derived from the names of the returned types.
-//
-// If no such function is necessary, it returns (Txxx, Txxx).
-func rtconvfn(src, dst *types.Type) (param, result types.EType) {
-       if thearch.SoftFloat {
-               return Txxx, Txxx
-       }
-
-       switch thearch.LinkArch.Family {
-       case sys.ARM, sys.MIPS:
-               if src.IsFloat() {
-                       switch dst.Etype {
-                       case TINT64, TUINT64:
-                               return TFLOAT64, dst.Etype
-                       }
-               }
-               if dst.IsFloat() {
-                       switch src.Etype {
-                       case TINT64, TUINT64:
-                               return src.Etype, TFLOAT64
-                       }
-               }
-
-       case sys.I386:
-               if src.IsFloat() {
-                       switch dst.Etype {
-                       case TINT64, TUINT64:
-                               return TFLOAT64, dst.Etype
-                       case TUINT32, TUINT, TUINTPTR:
-                               return TFLOAT64, TUINT32
-                       }
-               }
-               if dst.IsFloat() {
-                       switch src.Etype {
-                       case TINT64, TUINT64:
-                               return src.Etype, TFLOAT64
-                       case TUINT32, TUINT, TUINTPTR:
-                               return TUINT32, TFLOAT64
-                       }
-               }
-       }
-       return Txxx, Txxx
-}
-
-// TODO(josharian): combine this with its caller and simplify
-func reduceSlice(n *Node) *Node {
-       low, high, max := n.SliceBounds()
-       if high != nil && high.Op == OLEN && samesafeexpr(n.Left, high.Left) {
-               // Reduce x[i:len(x)] to x[i:].
-               high = nil
-       }
-       n.SetSliceBounds(low, high, max)
-       if (n.Op == OSLICE || n.Op == OSLICESTR) && low == nil && high == nil {
-               // Reduce x[:] to x.
-               if Debug_slice > 0 {
-                       Warn("slice: omit slice operation")
-               }
-               return n.Left
-       }
-       return n
-}
-
-func ascompatee1(l *Node, r *Node, init *Nodes) *Node {
-       // convas will turn map assigns into function calls,
-       // making it impossible for reorder3 to work.
-       n := nod(OAS, l, r)
-
-       if l.Op == OINDEXMAP {
-               return n
-       }
-
-       return convas(n, init)
-}
-
-func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
-       // check assign expression list to
-       // an expression list. called in
-       //      expr-list = expr-list
-
-       // ensure order of evaluation for function calls
-       for i := range nl {
-               nl[i] = safeexpr(nl[i], init)
-       }
-       for i1 := range nr {
-               nr[i1] = safeexpr(nr[i1], init)
-       }
-
-       var nn []*Node
-       i := 0
-       for ; i < len(nl); i++ {
-               if i >= len(nr) {
-                       break
-               }
-               // Do not generate 'x = x' during return. See issue 4014.
-               if op == ORETURN && samesafeexpr(nl[i], nr[i]) {
-                       continue
-               }
-               nn = append(nn, ascompatee1(nl[i], nr[i], init))
-       }
-
-       // cannot happen: caller checked that lists had same length
-       if i < len(nl) || i < len(nr) {
-               var nln, nrn Nodes
-               nln.Set(nl)
-               nrn.Set(nr)
-               Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), Curfn.funcname())
-       }
-       return nn
-}
-
-// fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
-func fncall(l *Node, rt *types.Type) bool {
-       if l.HasCall() || l.Op == OINDEXMAP {
-               return true
-       }
-       if types.Identical(l.Type, rt) {
-               return false
-       }
-       // There might be a conversion required, which might involve a runtime call.
-       return true
-}
-
-// check assign type list to
-// an expression list. called in
-//     expr-list = func()
-func ascompatet(nl Nodes, nr *types.Type) []*Node {
-       if nl.Len() != nr.NumFields() {
-               Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
-       }
-
-       var nn, mm Nodes
-       for i, l := range nl.Slice() {
-               if l.isBlank() {
-                       continue
-               }
-               r := nr.Field(i)
-
-               // Any assignment to an lvalue that might cause a function call must be
-               // deferred until all the returned values have been read.
-               if fncall(l, r.Type) {
-                       tmp := temp(r.Type)
-                       tmp = typecheck(tmp, ctxExpr)
-                       a := nod(OAS, l, tmp)
-                       a = convas(a, &mm)
-                       mm.Append(a)
-                       l = tmp
-               }
-
-               res := nod(ORESULT, nil, nil)
-               res.Xoffset = Ctxt.FixedFrameSize() + r.Offset
-               res.Type = r.Type
-               res.SetTypecheck(1)
-
-               a := nod(OAS, l, res)
-               a = convas(a, &nn)
-               updateHasCall(a)
-               if a.HasCall() {
-                       Dump("ascompatet ucount", a)
-                       Fatalf("ascompatet: too many function calls evaluating parameters")
-               }
-
-               nn.Append(a)
-       }
-       return append(nn.Slice(), mm.Slice()...)
-}
-
-// package all the arguments that match a ... T parameter into a []T.
-func mkdotargslice(typ *types.Type, args []*Node) *Node {
-       var n *Node
-       if len(args) == 0 {
-               n = nodnil()
-               n.Type = typ
-       } else {
-               n = nod(OCOMPLIT, nil, typenod(typ))
-               n.List.Append(args...)
-               n.SetImplicit(true)
-       }
-
-       n = typecheck(n, ctxExpr)
-       if n.Type == nil {
-               Fatalf("mkdotargslice: typecheck failed")
-       }
-       return n
-}
-
-// fixVariadicCall rewrites calls to variadic functions to use an
-// explicit ... argument if one is not already present.
-func fixVariadicCall(call *Node) {
-       fntype := call.Left.Type
-       if !fntype.IsVariadic() || call.IsDDD() {
-               return
-       }
-
-       vi := fntype.NumParams() - 1
-       vt := fntype.Params().Field(vi).Type
-
-       args := call.List.Slice()
-       extra := args[vi:]
-       slice := mkdotargslice(vt, extra)
-       for i := range extra {
-               extra[i] = nil // allow GC
-       }
-
-       call.List.Set(append(args[:vi], slice))
-       call.SetIsDDD(true)
-}
-
-func walkCall(n *Node, init *Nodes) {
-       if n.Rlist.Len() != 0 {
-               return // already walked
-       }
-
-       params := n.Left.Type.Params()
-       args := n.List.Slice()
-
-       n.Left = walkexpr(n.Left, init)
-       walkexprlist(args, init)
-
-       // If this is a method call, add the receiver at the beginning of the args.
-       if n.Op == OCALLMETH {
-               withRecv := make([]*Node, len(args)+1)
-               withRecv[0] = n.Left.Left
-               n.Left.Left = nil
-               copy(withRecv[1:], args)
-               args = withRecv
-       }
-
-       // For any argument whose evaluation might require a function call,
-       // store that argument into a temporary variable,
-       // to prevent that calls from clobbering arguments already on the stack.
-       // When instrumenting, all arguments might require function calls.
-       var tempAssigns []*Node
-       for i, arg := range args {
-               updateHasCall(arg)
-               // Determine param type.
-               var t *types.Type
-               if n.Op == OCALLMETH {
-                       if i == 0 {
-                               t = n.Left.Type.Recv().Type
-                       } else {
-                               t = params.Field(i - 1).Type
-                       }
-               } else {
-                       t = params.Field(i).Type
-               }
-               if instrumenting || fncall(arg, t) {
-                       // make assignment of fncall to tempAt
-                       tmp := temp(t)
-                       a := nod(OAS, tmp, arg)
-                       a = convas(a, init)
-                       tempAssigns = append(tempAssigns, a)
-                       // replace arg with temp
-                       args[i] = tmp
-               }
-       }
-
-       n.List.Set(tempAssigns)
-       n.Rlist.Set(args)
-}
-
-// generate code for print
-func walkprint(nn *Node, init *Nodes) *Node {
-       // Hoist all the argument evaluation up before the lock.
-       walkexprlistcheap(nn.List.Slice(), init)
-
-       // For println, add " " between elements and "\n" at the end.
-       if nn.Op == OPRINTN {
-               s := nn.List.Slice()
-               t := make([]*Node, 0, len(s)*2)
-               for i, n := range s {
-                       if i != 0 {
-                               t = append(t, nodstr(" "))
-                       }
-                       t = append(t, n)
-               }
-               t = append(t, nodstr("\n"))
-               nn.List.Set(t)
-       }
-
-       // Collapse runs of constant strings.
-       s := nn.List.Slice()
-       t := make([]*Node, 0, len(s))
-       for i := 0; i < len(s); {
-               var strs []string
-               for i < len(s) && Isconst(s[i], CTSTR) {
-                       strs = append(strs, s[i].StringVal())
-                       i++
-               }
-               if len(strs) > 0 {
-                       t = append(t, nodstr(strings.Join(strs, "")))
-               }
-               if i < len(s) {
-                       t = append(t, s[i])
-                       i++
-               }
-       }
-       nn.List.Set(t)
-
-       calls := []*Node{mkcall("printlock", nil, init)}
-       for i, n := range nn.List.Slice() {
-               if n.Op == OLITERAL {
-                       switch n.Val().Ctype() {
-                       case CTRUNE:
-                               n = defaultlit(n, types.Runetype)
-
-                       case CTINT:
-                               n = defaultlit(n, types.Types[TINT64])
-
-                       case CTFLT:
-                               n = defaultlit(n, types.Types[TFLOAT64])
-                       }
-               }
-
-               if n.Op != OLITERAL && n.Type != nil && n.Type.Etype == TIDEAL {
-                       n = defaultlit(n, types.Types[TINT64])
-               }
-               n = defaultlit(n, nil)
-               nn.List.SetIndex(i, n)
-               if n.Type == nil || n.Type.Etype == TFORW {
-                       continue
-               }
-
-               var on *Node
-               switch n.Type.Etype {
-               case TINTER:
-                       if n.Type.IsEmptyInterface() {
-                               on = syslook("printeface")
-                       } else {
-                               on = syslook("printiface")
-                       }
-                       on = substArgTypes(on, n.Type) // any-1
-               case TPTR:
-                       if n.Type.Elem().NotInHeap() {
-                               on = syslook("printuintptr")
-                               n = nod(OCONV, n, nil)
-                               n.Type = types.Types[TUNSAFEPTR]
-                               n = nod(OCONV, n, nil)
-                               n.Type = types.Types[TUINTPTR]
-                               break
-                       }
-                       fallthrough
-               case TCHAN, TMAP, TFUNC, TUNSAFEPTR:
-                       on = syslook("printpointer")
-                       on = substArgTypes(on, n.Type) // any-1
-               case TSLICE:
-                       on = syslook("printslice")
-                       on = substArgTypes(on, n.Type) // any-1
-               case TUINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINTPTR:
-                       if isRuntimePkg(n.Type.Sym.Pkg) && n.Type.Sym.Name == "hex" {
-                               on = syslook("printhex")
-                       } else {
-                               on = syslook("printuint")
-                       }
-               case TINT, TINT8, TINT16, TINT32, TINT64:
-                       on = syslook("printint")
-               case TFLOAT32, TFLOAT64:
-                       on = syslook("printfloat")
-               case TCOMPLEX64, TCOMPLEX128:
-                       on = syslook("printcomplex")
-               case TBOOL:
-                       on = syslook("printbool")
-               case TSTRING:
-                       cs := ""
-                       if Isconst(n, CTSTR) {
-                               cs = n.StringVal()
-                       }
-                       switch cs {
-                       case " ":
-                               on = syslook("printsp")
-                       case "\n":
-                               on = syslook("printnl")
-                       default:
-                               on = syslook("printstring")
-                       }
-               default:
-                       badtype(OPRINT, n.Type, nil)
-                       continue
-               }
-
-               r := nod(OCALL, on, nil)
-               if params := on.Type.Params().FieldSlice(); len(params) > 0 {
-                       t := params[0].Type
-                       if !types.Identical(t, n.Type) {
-                               n = nod(OCONV, n, nil)
-                               n.Type = t
-                       }
-                       r.List.Append(n)
-               }
-               calls = append(calls, r)
-       }
-
-       calls = append(calls, mkcall("printunlock", nil, init))
-
-       typecheckslice(calls, ctxStmt)
-       walkexprlist(calls, init)
-
-       r := nod(OEMPTY, nil, nil)
-       r = typecheck(r, ctxStmt)
-       r = walkexpr(r, init)
-       r.Ninit.Set(calls)
-       return r
-}
-
-func callnew(t *types.Type) *Node {
-       dowidth(t)
-       n := nod(ONEWOBJ, typename(t), nil)
-       n.Type = types.NewPtr(t)
-       n.SetTypecheck(1)
-       n.MarkNonNil()
-       return n
-}
-
-// isReflectHeaderDataField reports whether l is an expression p.Data
-// where p has type reflect.SliceHeader or reflect.StringHeader.
-func isReflectHeaderDataField(l *Node) bool {
-       if l.Type != types.Types[TUINTPTR] {
-               return false
-       }
-
-       var tsym *types.Sym
-       switch l.Op {
-       case ODOT:
-               tsym = l.Left.Type.Sym
-       case ODOTPTR:
-               tsym = l.Left.Type.Elem().Sym
-       default:
-               return false
-       }
-
-       if tsym == nil || l.Sym.Name != "Data" || tsym.Pkg.Path != "reflect" {
-               return false
-       }
-       return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
-}
-
-func convas(n *Node, init *Nodes) *Node {
-       if n.Op != OAS {
-               Fatalf("convas: not OAS %v", n.Op)
-       }
-       defer updateHasCall(n)
-
-       n.SetTypecheck(1)
-
-       if n.Left == nil || n.Right == nil {
-               return n
-       }
-
-       lt := n.Left.Type
-       rt := n.Right.Type
-       if lt == nil || rt == nil {
-               return n
-       }
-
-       if n.Left.isBlank() {
-               n.Right = defaultlit(n.Right, nil)
-               return n
-       }
-
-       if !types.Identical(lt, rt) {
-               n.Right = assignconv(n.Right, lt, "assignment")
-               n.Right = walkexpr(n.Right, init)
-       }
-       dowidth(n.Right.Type)
-
-       return n
-}
-
-// from ascompat[ee]
-//     a,b = c,d
-// simultaneous assignment. there cannot
-// be later use of an earlier lvalue.
-//
-// function calls have been removed.
-func reorder3(all []*Node) []*Node {
-       // If a needed expression may be affected by an
-       // earlier assignment, make an early copy of that
-       // expression and use the copy instead.
-       var early []*Node
-
-       var mapinit Nodes
-       for i, n := range all {
-               l := n.Left
-
-               // Save subexpressions needed on left side.
-               // Drill through non-dereferences.
-               for {
-                       if l.Op == ODOT || l.Op == OPAREN {
-                               l = l.Left
-                               continue
-                       }
-
-                       if l.Op == OINDEX && l.Left.Type.IsArray() {
-                               l.Right = reorder3save(l.Right, all, i, &early)
-                               l = l.Left
-                               continue
-                       }
-
-                       break
-               }
-
-               switch l.Op {
-               default:
-                       Fatalf("reorder3 unexpected lvalue %#v", l.Op)
-
-               case ONAME:
-                       break
-
-               case OINDEX, OINDEXMAP:
-                       l.Left = reorder3save(l.Left, all, i, &early)
-                       l.Right = reorder3save(l.Right, all, i, &early)
-                       if l.Op == OINDEXMAP {
-                               all[i] = convas(all[i], &mapinit)
-                       }
-
-               case ODEREF, ODOTPTR:
-                       l.Left = reorder3save(l.Left, all, i, &early)
-               }
-
-               // Save expression on right side.
-               all[i].Right = reorder3save(all[i].Right, all, i, &early)
-       }
-
-       early = append(mapinit.Slice(), early...)
-       return append(early, all...)
-}
-
-// if the evaluation of *np would be affected by the
-// assignments in all up to but not including the ith assignment,
-// copy into a temporary during *early and
-// replace *np with that temp.
-// The result of reorder3save MUST be assigned back to n, e.g.
-//     n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n *Node, all []*Node, i int, early *[]*Node) *Node {
-       if !aliased(n, all[:i]) {
-               return n
-       }
-
-       q := temp(n.Type)
-       q = nod(OAS, q, n)
-       q = typecheck(q, ctxStmt)
-       *early = append(*early, q)
-       return q.Left
-}
-
-// what's the outer value that a write to n affects?
-// outer value means containing struct or array.
-func outervalue(n *Node) *Node {
-       for {
-               switch n.Op {
-               case OXDOT:
-                       Fatalf("OXDOT in walk")
-               case ODOT, OPAREN, OCONVNOP:
-                       n = n.Left
-                       continue
-               case OINDEX:
-                       if n.Left.Type != nil && n.Left.Type.IsArray() {
-                               n = n.Left
-                               continue
-                       }
-               }
-
-               return n
-       }
-}
-
-// Is it possible that the computation of r might be
-// affected by assignments in all?
-func aliased(r *Node, all []*Node) bool {
-       if r == nil {
-               return false
-       }
-
-       // Treat all fields of a struct as referring to the whole struct.
-       // We could do better but we would have to keep track of the fields.
-       for r.Op == ODOT {
-               r = r.Left
-       }
-
-       // Look for obvious aliasing: a variable being assigned
-       // during the all list and appearing in n.
-       // Also record whether there are any writes to addressable
-       // memory (either main memory or variables whose addresses
-       // have been taken).
-       memwrite := false
-       for _, as := range all {
-               // We can ignore assignments to blank.
-               if as.Left.isBlank() {
-                       continue
-               }
-
-               l := outervalue(as.Left)
-               if l.Op != ONAME {
-                       memwrite = true
-                       continue
-               }
-
-               switch l.Class() {
-               default:
-                       Fatalf("unexpected class: %v, %v", l, l.Class())
-
-               case PAUTOHEAP, PEXTERN:
-                       memwrite = true
-                       continue
-
-               case PAUTO, PPARAM, PPARAMOUT:
-                       if l.Name.Addrtaken() {
-                               memwrite = true
-                               continue
-                       }
-
-                       if vmatch2(l, r) {
-                               // Direct hit: l appears in r.
-                               return true
-                       }
-               }
-       }
-
-       // The variables being written do not appear in r.
-       // However, r might refer to computed addresses
-       // that are being written.
-
-       // If no computed addresses are affected by the writes, no aliasing.
-       if !memwrite {
-               return false
-       }
-
-       // If r does not refer to computed addresses
-       // (that is, if r only refers to variables whose addresses
-       // have not been taken), no aliasing.
-       if varexpr(r) {
-               return false
-       }
-
-       // Otherwise, both the writes and r refer to computed memory addresses.
-       // Assume that they might conflict.
-       return true
-}
-
-// does the evaluation of n only refer to variables
-// whose addresses have not been taken?
-// (and no other memory)
-func varexpr(n *Node) bool {
-       if n == nil {
-               return true
-       }
-
-       switch n.Op {
-       case OLITERAL:
-               return true
-
-       case ONAME:
-               switch n.Class() {
-               case PAUTO, PPARAM, PPARAMOUT:
-                       if !n.Name.Addrtaken() {
-                               return true
-                       }
-               }
-
-               return false
-
-       case OADD,
-               OSUB,
-               OOR,
-               OXOR,
-               OMUL,
-               ODIV,
-               OMOD,
-               OLSH,
-               ORSH,
-               OAND,
-               OANDNOT,
-               OPLUS,
-               ONEG,
-               OBITNOT,
-               OPAREN,
-               OANDAND,
-               OOROR,
-               OCONV,
-               OCONVNOP,
-               OCONVIFACE,
-               ODOTTYPE:
-               return varexpr(n.Left) && varexpr(n.Right)
-
-       case ODOT: // but not ODOTPTR
-               // Should have been handled in aliased.
-               Fatalf("varexpr unexpected ODOT")
-       }
-
-       // Be conservative.
-       return false
-}
-
-// is the name l mentioned in r?
-func vmatch2(l *Node, r *Node) bool {
-       if r == nil {
-               return false
-       }
-       switch r.Op {
-       // match each right given left
-       case ONAME:
-               return l == r
-
-       case OLITERAL:
-               return false
-       }
-
-       if vmatch2(l, r.Left) {
-               return true
-       }
-       if vmatch2(l, r.Right) {
-               return true
-       }
-       for _, n := range r.List.Slice() {
-               if vmatch2(l, n) {
-                       return true
-               }
-       }
-       return false
-}
-
-// is any name mentioned in l also mentioned in r?
-// called by sinit.go
-func vmatch1(l *Node, r *Node) bool {
-       // isolate all left sides
-       if l == nil || r == nil {
-               return false
-       }
-       switch l.Op {
-       case ONAME:
-               switch l.Class() {
-               case PPARAM, PAUTO:
-                       break
-
-               default:
-                       // assignment to non-stack variable must be
-                       // delayed if right has function calls.
-                       if r.HasCall() {
-                               return true
-                       }
-               }
-
-               return vmatch2(l, r)
-
-       case OLITERAL:
-               return false
-       }
-
-       if vmatch1(l.Left, r) {
-               return true
-       }
-       if vmatch1(l.Right, r) {
-               return true
-       }
-       for _, n := range l.List.Slice() {
-               if vmatch1(n, r) {
-                       return true
-               }
-       }
-       return false
-}
-
-// paramstoheap returns code to allocate memory for heap-escaped parameters
-// and to copy non-result parameters' values from the stack.
-func paramstoheap(params *types.Type) []*Node {
-       var nn []*Node
-       for _, t := range params.Fields().Slice() {
-               v := asNode(t.Nname)
-               if v != nil && v.Sym != nil && strings.HasPrefix(v.Sym.Name, "~r") { // unnamed result
-                       v = nil
-               }
-               if v == nil {
-                       continue
-               }
-
-               if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil {
-                       nn = append(nn, walkstmt(nod(ODCL, v, nil)))
-                       if stackcopy.Class() == PPARAM {
-                               nn = append(nn, walkstmt(typecheck(nod(OAS, v, stackcopy), ctxStmt)))
-                       }
-               }
-       }
-
-       return nn
-}
-
-// zeroResults zeros the return values at the start of the function.
-// We need to do this very early in the function.  Defer might stop a
-// panic and show the return values as they exist at the time of
-// panic.  For precise stacks, the garbage collector assumes results
-// are always live, so we need to zero them before any allocations,
-// even allocations to move params/results to the heap.
-// The generated code is added to Curfn's Enter list.
-func zeroResults() {
-       for _, f := range Curfn.Type.Results().Fields().Slice() {
-               v := asNode(f.Nname)
-               if v != nil && v.Name.Param.Heapaddr != nil {
-                       // The local which points to the return value is the
-                       // thing that needs zeroing. This is already handled
-                       // by a Needzero annotation in plive.go:livenessepilogue.
-                       continue
-               }
-               if v.isParamHeapCopy() {
-                       // TODO(josharian/khr): Investigate whether we can switch to "continue" here,
-                       // and document more in either case.
-                       // In the review of CL 114797, Keith wrote (roughly):
-                       // I don't think the zeroing below matters.
-                       // The stack return value will never be marked as live anywhere in the function.
-                       // It is not written to until deferreturn returns.
-                       v = v.Name.Param.Stackcopy
-               }
-               // Zero the stack location containing f.
-               Curfn.Func.Enter.Append(nodl(Curfn.Pos, OAS, v, nil))
-       }
-}
-
-// returnsfromheap returns code to copy values for heap-escaped parameters
-// back to the stack.
-func returnsfromheap(params *types.Type) []*Node {
-       var nn []*Node
-       for _, t := range params.Fields().Slice() {
-               v := asNode(t.Nname)
-               if v == nil {
-                       continue
-               }
-               if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil && stackcopy.Class() == PPARAMOUT {
-                       nn = append(nn, walkstmt(typecheck(nod(OAS, stackcopy, v), ctxStmt)))
-               }
-       }
-
-       return nn
-}
-
-// heapmoves generates code to handle migrating heap-escaped parameters
-// between the stack and the heap. The generated code is added to Curfn's
-// Enter and Exit lists.
-func heapmoves() {
-       lno := lineno
-       lineno = Curfn.Pos
-       nn := paramstoheap(Curfn.Type.Recvs())
-       nn = append(nn, paramstoheap(Curfn.Type.Params())...)
-       nn = append(nn, paramstoheap(Curfn.Type.Results())...)
-       Curfn.Func.Enter.Append(nn...)
-       lineno = Curfn.Func.Endlineno
-       Curfn.Func.Exit.Append(returnsfromheap(Curfn.Type.Results())...)
-       lineno = lno
-}
-
-func vmkcall(fn *Node, t *types.Type, init *Nodes, va []*Node) *Node {
-       if fn.Type == nil || fn.Type.Etype != TFUNC {
-               Fatalf("mkcall %v %v", fn, fn.Type)
-       }
-
-       n := fn.Type.NumParams()
-       if n != len(va) {
-               Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
-       }
-
-       r := nod(OCALL, fn, nil)
-       r.List.Set(va)
-       if fn.Type.NumResults() > 0 {
-               r = typecheck(r, ctxExpr|ctxMultiOK)
-       } else {
-               r = typecheck(r, ctxStmt)
-       }
-       r = walkexpr(r, init)
-       r.Type = t
-       return r
-}
-
-func mkcall(name string, t *types.Type, init *Nodes, args ...*Node) *Node {
-       return vmkcall(syslook(name), t, init, args)
-}
-
-func mkcall1(fn *Node, t *types.Type, init *Nodes, args ...*Node) *Node {
-       return vmkcall(fn, t, init, args)
-}
-
-func conv(n *Node, t *types.Type) *Node {
-       if types.Identical(n.Type, t) {
-               return n
-       }
-       n = nod(OCONV, n, nil)
-       n.Type = t
-       n = typecheck(n, ctxExpr)
-       return n
-}
-
-// convnop converts node n to type t using the OCONVNOP op
-// and typechecks the result with ctxExpr.
-func convnop(n *Node, t *types.Type) *Node {
-       if types.Identical(n.Type, t) {
-               return n
-       }
-       n = nod(OCONVNOP, n, nil)
-       n.Type = t
-       n = typecheck(n, ctxExpr)
-       return n
-}
-
-// byteindex converts n, which is byte-sized, to an int used to index into an array.
-// We cannot use conv, because we allow converting bool to int here,
-// which is forbidden in user code.
-func byteindex(n *Node) *Node {
-       // We cannot convert from bool to int directly.
-       // While converting from int8 to int is possible, it would yield
-       // the wrong result for negative values.
-       // Reinterpreting the value as an unsigned byte solves both cases.
-       if !types.Identical(n.Type, types.Types[TUINT8]) {
-               n = nod(OCONV, n, nil)
-               n.Type = types.Types[TUINT8]
-               n.SetTypecheck(1)
-       }
-       n = nod(OCONV, n, nil)
-       n.Type = types.Types[TINT]
-       n.SetTypecheck(1)
-       return n
-}
-
-func chanfn(name string, n int, t *types.Type) *Node {
-       if !t.IsChan() {
-               Fatalf("chanfn %v", t)
-       }
-       fn := syslook(name)
-       switch n {
-       default:
-               Fatalf("chanfn %d", n)
-       case 1:
-               fn = substArgTypes(fn, t.Elem())
-       case 2:
-               fn = substArgTypes(fn, t.Elem(), t.Elem())
-       }
-       return fn
-}
-
-func mapfn(name string, t *types.Type) *Node {
-       if !t.IsMap() {
-               Fatalf("mapfn %v", t)
-       }
-       fn := syslook(name)
-       fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
-       return fn
-}
-
-func mapfndel(name string, t *types.Type) *Node {
-       if !t.IsMap() {
-               Fatalf("mapfn %v", t)
-       }
-       fn := syslook(name)
-       fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key())
-       return fn
-}
-
-const (
-       mapslow = iota
-       mapfast32
-       mapfast32ptr
-       mapfast64
-       mapfast64ptr
-       mapfaststr
-       nmapfast
-)
-
-type mapnames [nmapfast]string
-
-func mkmapnames(base string, ptr string) mapnames {
-       return mapnames{base, base + "_fast32", base + "_fast32" + ptr, base + "_fast64", base + "_fast64" + ptr, base + "_faststr"}
-}
-
-var mapaccess1 = mkmapnames("mapaccess1", "")
-var mapaccess2 = mkmapnames("mapaccess2", "")
-var mapassign = mkmapnames("mapassign", "ptr")
-var mapdelete = mkmapnames("mapdelete", "")
-
-func mapfast(t *types.Type) int {
-       // Check runtime/map.go:maxElemSize before changing.
-       if t.Elem().Width > 128 {
-               return mapslow
-       }
-       switch algtype(t.Key()) {
-       case AMEM32:
-               if !t.Key().HasPointers() {
-                       return mapfast32
-               }
-               if Widthptr == 4 {
-                       return mapfast32ptr
-               }
-               Fatalf("small pointer %v", t.Key())
-       case AMEM64:
-               if !t.Key().HasPointers() {
-                       return mapfast64
-               }
-               if Widthptr == 8 {
-                       return mapfast64ptr
-               }
-               // Two-word object, at least one of which is a pointer.
-               // Use the slow path.
-       case ASTRING:
-               return mapfaststr
-       }
-       return mapslow
-}
-
-func writebarrierfn(name string, l *types.Type, r *types.Type) *Node {
-       fn := syslook(name)
-       fn = substArgTypes(fn, l, r)
-       return fn
-}
-
-func addstr(n *Node, init *Nodes) *Node {
-       // order.expr rewrote OADDSTR to have a list of strings.
-       c := n.List.Len()
-
-       if c < 2 {
-               Fatalf("addstr count %d too small", c)
-       }
-
-       buf := nodnil()
-       if n.Esc == EscNone {
-               sz := int64(0)
-               for _, n1 := range n.List.Slice() {
-                       if n1.Op == OLITERAL {
-                               sz += int64(len(n1.StringVal()))
-                       }
-               }
-
-               // Don't allocate the buffer if the result won't fit.
-               if sz < tmpstringbufsize {
-                       // Create temporary buffer for result string on stack.
-                       t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-                       buf = nod(OADDR, temp(t), nil)
-               }
-       }
-
-       // build list of string arguments
-       args := []*Node{buf}
-       for _, n2 := range n.List.Slice() {
-               args = append(args, conv(n2, types.Types[TSTRING]))
-       }
-
-       var fn string
-       if c <= 5 {
-               // small numbers of strings use direct runtime helpers.
-               // note: order.expr knows this cutoff too.
-               fn = fmt.Sprintf("concatstring%d", c)
-       } else {
-               // large numbers of strings are passed to the runtime as a slice.
-               fn = "concatstrings"
-
-               t := types.NewSlice(types.Types[TSTRING])
-               slice := nod(OCOMPLIT, nil, typenod(t))
-               if prealloc[n] != nil {
-                       prealloc[slice] = prealloc[n]
-               }
-               slice.List.Set(args[1:]) // skip buf arg
-               args = []*Node{buf, slice}
-               slice.Esc = EscNone
-       }
-
-       cat := syslook(fn)
-       r := nod(OCALL, cat, nil)
-       r.List.Set(args)
-       r = typecheck(r, ctxExpr)
-       r = walkexpr(r, init)
-       r.Type = n.Type
-
-       return r
-}
-
-func walkAppendArgs(n *Node, init *Nodes) {
-       walkexprlistsafe(n.List.Slice(), init)
-
-       // walkexprlistsafe will leave OINDEX (s[n]) alone if both s
-       // and n are name or literal, but those may index the slice we're
-       // modifying here. Fix explicitly.
-       ls := n.List.Slice()
-       for i1, n1 := range ls {
-               ls[i1] = cheapexpr(n1, init)
-       }
-}
-
-// expand append(l1, l2...) to
-//   init {
-//     s := l1
-//     n := len(s) + len(l2)
-//     // Compare as uint so growslice can panic on overflow.
-//     if uint(n) > uint(cap(s)) {
-//       s = growslice(s, n)
-//     }
-//     s = s[:n]
-//     memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-//   }
-//   s
-//
-// l2 is allowed to be a string.
-func appendslice(n *Node, init *Nodes) *Node {
-       walkAppendArgs(n, init)
-
-       l1 := n.List.First()
-       l2 := n.List.Second()
-       l2 = cheapexpr(l2, init)
-       n.List.SetSecond(l2)
-
-       var nodes Nodes
-
-       // var s []T
-       s := temp(l1.Type)
-       nodes.Append(nod(OAS, s, l1)) // s = l1
-
-       elemtype := s.Type.Elem()
-
-       // n := len(s) + len(l2)
-       nn := temp(types.Types[TINT])
-       nodes.Append(nod(OAS, nn, nod(OADD, nod(OLEN, s, nil), nod(OLEN, l2, nil))))
-
-       // if uint(n) > uint(cap(s))
-       nif := nod(OIF, nil, nil)
-       nuint := conv(nn, types.Types[TUINT])
-       scapuint := conv(nod(OCAP, s, nil), types.Types[TUINT])
-       nif.Left = nod(OGT, nuint, scapuint)
-
-       // instantiate growslice(typ *type, []any, int) []any
-       fn := syslook("growslice")
-       fn = substArgTypes(fn, elemtype, elemtype)
-
-       // s = growslice(T, s, n)
-       nif.Nbody.Set1(nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
-       nodes.Append(nif)
-
-       // s = s[:n]
-       nt := nod(OSLICE, s, nil)
-       nt.SetSliceBounds(nil, nn, nil)
-       nt.SetBounded(true)
-       nodes.Append(nod(OAS, s, nt))
-
-       var ncopy *Node
-       if elemtype.HasPointers() {
-               // copy(s[len(l1):], l2)
-               nptr1 := nod(OSLICE, s, nil)
-               nptr1.Type = s.Type
-               nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
-               nptr1 = cheapexpr(nptr1, &nodes)
-
-               nptr2 := l2
-
-               Curfn.Func.setWBPos(n.Pos)
-
-               // instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
-               fn := syslook("typedslicecopy")
-               fn = substArgTypes(fn, l1.Type.Elem(), l2.Type.Elem())
-               ptr1, len1 := nptr1.backingArrayPtrLen()
-               ptr2, len2 := nptr2.backingArrayPtrLen()
-               ncopy = mkcall1(fn, types.Types[TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
-       } else if instrumenting && !compiling_runtime {
-               // rely on runtime to instrument:
-               //  copy(s[len(l1):], l2)
-               // l2 can be a slice or string.
-               nptr1 := nod(OSLICE, s, nil)
-               nptr1.Type = s.Type
-               nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
-               nptr1 = cheapexpr(nptr1, &nodes)
-               nptr2 := l2
-
-               ptr1, len1 := nptr1.backingArrayPtrLen()
-               ptr2, len2 := nptr2.backingArrayPtrLen()
-
-               fn := syslook("slicecopy")
-               fn = substArgTypes(fn, ptr1.Type.Elem(), ptr2.Type.Elem())
-               ncopy = mkcall1(fn, types.Types[TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
-       } else {
-               // memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-               nptr1 := nod(OINDEX, s, nod(OLEN, l1, nil))
-               nptr1.SetBounded(true)
-               nptr1 = nod(OADDR, nptr1, nil)
-
-               nptr2 := nod(OSPTR, l2, nil)
-
-               nwid := cheapexpr(conv(nod(OLEN, l2, nil), types.Types[TUINTPTR]), &nodes)
-               nwid = nod(OMUL, nwid, nodintconst(elemtype.Width))
-
-               // instantiate func memmove(to *any, frm *any, length uintptr)
-               fn := syslook("memmove")
-               fn = substArgTypes(fn, elemtype, elemtype)
-               ncopy = mkcall1(fn, nil, &nodes, nptr1, nptr2, nwid)
-       }
-       ln := append(nodes.Slice(), ncopy)
-
-       typecheckslice(ln, ctxStmt)
-       walkstmtlist(ln)
-       init.Append(ln...)
-       return s
-}
-
-// isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
-// isAppendOfMake assumes n has already been typechecked.
-func isAppendOfMake(n *Node) bool {
-       if Debug.N != 0 || instrumenting {
-               return false
-       }
-
-       if n.Typecheck() == 0 {
-               Fatalf("missing typecheck: %+v", n)
-       }
-
-       if n.Op != OAPPEND || !n.IsDDD() || n.List.Len() != 2 {
-               return false
-       }
-
-       second := n.List.Second()
-       if second.Op != OMAKESLICE || second.Right != nil {
-               return false
-       }
-
-       // y must be either an integer constant or the largest possible positive value
-       // of variable y needs to fit into an uint.
-
-       // typecheck made sure that constant arguments to make are not negative and fit into an int.
-
-       // The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
-       y := second.Left
-       if !Isconst(y, CTINT) && maxintval[y.Type.Etype].Cmp(maxintval[TUINT]) > 0 {
-               return false
-       }
-
-       return true
-}
-
-// extendslice rewrites append(l1, make([]T, l2)...) to
-//   init {
-//     if l2 >= 0 { // Empty if block here for more meaningful node.SetLikely(true)
-//     } else {
-//       panicmakeslicelen()
-//     }
-//     s := l1
-//     n := len(s) + l2
-//     // Compare n and s as uint so growslice can panic on overflow of len(s) + l2.
-//     // cap is a positive int and n can become negative when len(s) + l2
-//     // overflows int. Interpreting n when negative as uint makes it larger
-//     // than cap(s). growslice will check the int n arg and panic if n is
-//     // negative. This prevents the overflow from being undetected.
-//     if uint(n) > uint(cap(s)) {
-//       s = growslice(T, s, n)
-//     }
-//     s = s[:n]
-//     lptr := &l1[0]
-//     sptr := &s[0]
-//     if lptr == sptr || !T.HasPointers() {
-//       // growslice did not clear the whole underlying array (or did not get called)
-//       hp := &s[len(l1)]
-//       hn := l2 * sizeof(T)
-//       memclr(hp, hn)
-//     }
-//   }
-//   s
-func extendslice(n *Node, init *Nodes) *Node {
-       // isAppendOfMake made sure all possible positive values of l2 fit into an uint.
-       // The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
-       // check of l2 < 0 at runtime which is generated below.
-       l2 := conv(n.List.Second().Left, types.Types[TINT])
-       l2 = typecheck(l2, ctxExpr)
-       n.List.SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
-
-       walkAppendArgs(n, init)
-
-       l1 := n.List.First()
-       l2 = n.List.Second() // re-read l2, as it may have been updated by walkAppendArgs
-
-       var nodes []*Node
-
-       // if l2 >= 0 (likely happens), do nothing
-       nifneg := nod(OIF, nod(OGE, l2, nodintconst(0)), nil)
-       nifneg.SetLikely(true)
-
-       // else panicmakeslicelen()
-       nifneg.Rlist.Set1(mkcall("panicmakeslicelen", nil, init))
-       nodes = append(nodes, nifneg)
-
-       // s := l1
-       s := temp(l1.Type)
-       nodes = append(nodes, nod(OAS, s, l1))
-
-       elemtype := s.Type.Elem()
-
-       // n := len(s) + l2
-       nn := temp(types.Types[TINT])
-       nodes = append(nodes, nod(OAS, nn, nod(OADD, nod(OLEN, s, nil), l2)))
-
-       // if uint(n) > uint(cap(s))
-       nuint := conv(nn, types.Types[TUINT])
-       capuint := conv(nod(OCAP, s, nil), types.Types[TUINT])
-       nif := nod(OIF, nod(OGT, nuint, capuint), nil)
-
-       // instantiate growslice(typ *type, old []any, newcap int) []any
-       fn := syslook("growslice")
-       fn = substArgTypes(fn, elemtype, elemtype)
-
-       // s = growslice(T, s, n)
-       nif.Nbody.Set1(nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
-       nodes = append(nodes, nif)
-
-       // s = s[:n]
-       nt := nod(OSLICE, s, nil)
-       nt.SetSliceBounds(nil, nn, nil)
-       nt.SetBounded(true)
-       nodes = append(nodes, nod(OAS, s, nt))
-
-       // lptr := &l1[0]
-       l1ptr := temp(l1.Type.Elem().PtrTo())
-       tmp := nod(OSPTR, l1, nil)
-       nodes = append(nodes, nod(OAS, l1ptr, tmp))
-
-       // sptr := &s[0]
-       sptr := temp(elemtype.PtrTo())
-       tmp = nod(OSPTR, s, nil)
-       nodes = append(nodes, nod(OAS, sptr, tmp))
-
-       // hp := &s[len(l1)]
-       hp := nod(OINDEX, s, nod(OLEN, l1, nil))
-       hp.SetBounded(true)
-       hp = nod(OADDR, hp, nil)
-       hp = convnop(hp, types.Types[TUNSAFEPTR])
-
-       // hn := l2 * sizeof(elem(s))
-       hn := nod(OMUL, l2, nodintconst(elemtype.Width))
-       hn = conv(hn, types.Types[TUINTPTR])
-
-       clrname := "memclrNoHeapPointers"
-       hasPointers := elemtype.HasPointers()
-       if hasPointers {
-               clrname = "memclrHasPointers"
-               Curfn.Func.setWBPos(n.Pos)
-       }
-
-       var clr Nodes
-       clrfn := mkcall(clrname, nil, &clr, hp, hn)
-       clr.Append(clrfn)
-
-       if hasPointers {
-               // if l1ptr == sptr
-               nifclr := nod(OIF, nod(OEQ, l1ptr, sptr), nil)
-               nifclr.Nbody = clr
-               nodes = append(nodes, nifclr)
-       } else {
-               nodes = append(nodes, clr.Slice()...)
-       }
-
-       typecheckslice(nodes, ctxStmt)
-       walkstmtlist(nodes)
-       init.Append(nodes...)
-       return s
-}
-
-// Rewrite append(src, x, y, z) so that any side effects in
-// x, y, z (including runtime panics) are evaluated in
-// initialization statements before the append.
-// For normal code generation, stop there and leave the
-// rest to cgen_append.
-//
-// For race detector, expand append(src, a [, b]* ) to
-//
-//   init {
-//     s := src
-//     const argc = len(args) - 1
-//     if cap(s) - len(s) < argc {
-//         s = growslice(s, len(s)+argc)
-//     }
-//     n := len(s)
-//     s = s[:n+argc]
-//     s[n] = a
-//     s[n+1] = b
-//     ...
-//   }
-//   s
-func walkappend(n *Node, init *Nodes, dst *Node) *Node {
-       if !samesafeexpr(dst, n.List.First()) {
-               n.List.SetFirst(safeexpr(n.List.First(), init))
-               n.List.SetFirst(walkexpr(n.List.First(), init))
-       }
-       walkexprlistsafe(n.List.Slice()[1:], init)
-
-       nsrc := n.List.First()
-
-       // walkexprlistsafe will leave OINDEX (s[n]) alone if both s
-       // and n are name or literal, but those may index the slice we're
-       // modifying here. Fix explicitly.
-       // Using cheapexpr also makes sure that the evaluation
-       // of all arguments (and especially any panics) happen
-       // before we begin to modify the slice in a visible way.
-       ls := n.List.Slice()[1:]
-       for i, n := range ls {
-               n = cheapexpr(n, init)
-               if !types.Identical(n.Type, nsrc.Type.Elem()) {
-                       n = assignconv(n, nsrc.Type.Elem(), "append")
-                       n = walkexpr(n, init)
-               }
-               ls[i] = n
-       }
-
-       argc := n.List.Len() - 1
-       if argc < 1 {
-               return nsrc
-       }
-
-       // General case, with no function calls left as arguments.
-       // Leave for gen, except that instrumentation requires old form.
-       if !instrumenting || compiling_runtime {
-               return n
-       }
-
-       var l []*Node
-
-       ns := temp(nsrc.Type)
-       l = append(l, nod(OAS, ns, nsrc)) // s = src
-
-       na := nodintconst(int64(argc)) // const argc
-       nx := nod(OIF, nil, nil)       // if cap(s) - len(s) < argc
-       nx.Left = nod(OLT, nod(OSUB, nod(OCAP, ns, nil), nod(OLEN, ns, nil)), na)
-
-       fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
-       fn = substArgTypes(fn, ns.Type.Elem(), ns.Type.Elem())
-
-       nx.Nbody.Set1(nod(OAS, ns,
-               mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type.Elem()), ns,
-                       nod(OADD, nod(OLEN, ns, nil), na))))
-
-       l = append(l, nx)
-
-       nn := temp(types.Types[TINT])
-       l = append(l, nod(OAS, nn, nod(OLEN, ns, nil))) // n = len(s)
-
-       nx = nod(OSLICE, ns, nil) // ...s[:n+argc]
-       nx.SetSliceBounds(nil, nod(OADD, nn, na), nil)
-       nx.SetBounded(true)
-       l = append(l, nod(OAS, ns, nx)) // s = s[:n+argc]
-
-       ls = n.List.Slice()[1:]
-       for i, n := range ls {
-               nx = nod(OINDEX, ns, nn) // s[n] ...
-               nx.SetBounded(true)
-               l = append(l, nod(OAS, nx, n)) // s[n] = arg
-               if i+1 < len(ls) {
-                       l = append(l, nod(OAS, nn, nod(OADD, nn, nodintconst(1)))) // n = n + 1
-               }
-       }
-
-       typecheckslice(l, ctxStmt)
-       walkstmtlist(l)
-       init.Append(l...)
-       return ns
-}
-
-// Lower copy(a, b) to a memmove call or a runtime call.
-//
-// init {
-//   n := len(a)
-//   if n > len(b) { n = len(b) }
-//   if a.ptr != b.ptr { memmove(a.ptr, b.ptr, n*sizeof(elem(a))) }
-// }
-// n;
-//
-// Also works if b is a string.
-//
-func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
-       if n.Left.Type.Elem().HasPointers() {
-               Curfn.Func.setWBPos(n.Pos)
-               fn := writebarrierfn("typedslicecopy", n.Left.Type.Elem(), n.Right.Type.Elem())
-               n.Left = cheapexpr(n.Left, init)
-               ptrL, lenL := n.Left.backingArrayPtrLen()
-               n.Right = cheapexpr(n.Right, init)
-               ptrR, lenR := n.Right.backingArrayPtrLen()
-               return mkcall1(fn, n.Type, init, typename(n.Left.Type.Elem()), ptrL, lenL, ptrR, lenR)
-       }
-
-       if runtimecall {
-               // rely on runtime to instrument:
-               //  copy(n.Left, n.Right)
-               // n.Right can be a slice or string.
-
-               n.Left = cheapexpr(n.Left, init)
-               ptrL, lenL := n.Left.backingArrayPtrLen()
-               n.Right = cheapexpr(n.Right, init)
-               ptrR, lenR := n.Right.backingArrayPtrLen()
-
-               fn := syslook("slicecopy")
-               fn = substArgTypes(fn, ptrL.Type.Elem(), ptrR.Type.Elem())
-
-               return mkcall1(fn, n.Type, init, ptrL, lenL, ptrR, lenR, nodintconst(n.Left.Type.Elem().Width))
-       }
-
-       n.Left = walkexpr(n.Left, init)
-       n.Right = walkexpr(n.Right, init)
-       nl := temp(n.Left.Type)
-       nr := temp(n.Right.Type)
-       var l []*Node
-       l = append(l, nod(OAS, nl, n.Left))
-       l = append(l, nod(OAS, nr, n.Right))
-
-       nfrm := nod(OSPTR, nr, nil)
-       nto := nod(OSPTR, nl, nil)
-
-       nlen := temp(types.Types[TINT])
-
-       // n = len(to)
-       l = append(l, nod(OAS, nlen, nod(OLEN, nl, nil)))
-
-       // if n > len(frm) { n = len(frm) }
-       nif := nod(OIF, nil, nil)
-
-       nif.Left = nod(OGT, nlen, nod(OLEN, nr, nil))
-       nif.Nbody.Append(nod(OAS, nlen, nod(OLEN, nr, nil)))
-       l = append(l, nif)
-
-       // if to.ptr != frm.ptr { memmove( ... ) }
-       ne := nod(OIF, nod(ONE, nto, nfrm), nil)
-       ne.SetLikely(true)
-       l = append(l, ne)
-
-       fn := syslook("memmove")
-       fn = substArgTypes(fn, nl.Type.Elem(), nl.Type.Elem())
-       nwid := temp(types.Types[TUINTPTR])
-       setwid := nod(OAS, nwid, conv(nlen, types.Types[TUINTPTR]))
-       ne.Nbody.Append(setwid)
-       nwid = nod(OMUL, nwid, nodintconst(nl.Type.Elem().Width))
-       call := mkcall1(fn, nil, init, nto, nfrm, nwid)
-       ne.Nbody.Append(call)
-
-       typecheckslice(l, ctxStmt)
-       walkstmtlist(l)
-       init.Append(l...)
-       return nlen
-}
-
-func eqfor(t *types.Type) (n *Node, needsize bool) {
-       // Should only arrive here with large memory or
-       // a struct/array containing a non-memory field/element.
-       // Small memory is handled inline, and single non-memory
-       // is handled by walkcompare.
-       switch a, _ := algtype1(t); a {
-       case AMEM:
-               n := syslook("memequal")
-               n = substArgTypes(n, t, t)
-               return n, true
-       case ASPECIAL:
-               sym := typesymprefix(".eq", t)
-               n := newname(sym)
-               setNodeNameFunc(n)
-               n.Type = functype(nil, []*Node{
-                       anonfield(types.NewPtr(t)),
-                       anonfield(types.NewPtr(t)),
-               }, []*Node{
-                       anonfield(types.Types[TBOOL]),
-               })
-               return n, false
-       }
-       Fatalf("eqfor %v", t)
-       return nil, false
-}
-
-// The result of walkcompare MUST be assigned back to n, e.g.
-//     n.Left = walkcompare(n.Left, init)
-func walkcompare(n *Node, init *Nodes) *Node {
-       if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != OLITERAL && n.Right.Op != OLITERAL {
-               return walkcompareInterface(n, init)
-       }
-
-       if n.Left.Type.IsString() && n.Right.Type.IsString() {
-               return walkcompareString(n, init)
-       }
-
-       n.Left = walkexpr(n.Left, init)
-       n.Right = walkexpr(n.Right, init)
-
-       // Given mixed interface/concrete comparison,
-       // rewrite into types-equal && data-equal.
-       // This is efficient, avoids allocations, and avoids runtime calls.
-       if n.Left.Type.IsInterface() != n.Right.Type.IsInterface() {
-               // Preserve side-effects in case of short-circuiting; see #32187.
-               l := cheapexpr(n.Left, init)
-               r := cheapexpr(n.Right, init)
-               // Swap so that l is the interface value and r is the concrete value.
-               if n.Right.Type.IsInterface() {
-                       l, r = r, l
-               }
-
-               // Handle both == and !=.
-               eq := n.Op
-               andor := OOROR
-               if eq == OEQ {
-                       andor = OANDAND
-               }
-               // Check for types equal.
-               // For empty interface, this is:
-               //   l.tab == type(r)
-               // For non-empty interface, this is:
-               //   l.tab != nil && l.tab._type == type(r)
-               var eqtype *Node
-               tab := nod(OITAB, l, nil)
-               rtyp := typename(r.Type)
-               if l.Type.IsEmptyInterface() {
-                       tab.Type = types.NewPtr(types.Types[TUINT8])
-                       tab.SetTypecheck(1)
-                       eqtype = nod(eq, tab, rtyp)
-               } else {
-                       nonnil := nod(brcom(eq), nodnil(), tab)
-                       match := nod(eq, itabType(tab), rtyp)
-                       eqtype = nod(andor, nonnil, match)
-               }
-               // Check for data equal.
-               eqdata := nod(eq, ifaceData(n.Pos, l, r.Type), r)
-               // Put it all together.
-               expr := nod(andor, eqtype, eqdata)
-               n = finishcompare(n, expr, init)
-               return n
-       }
-
-       // Must be comparison of array or struct.
-       // Otherwise back end handles it.
-       // While we're here, decide whether to
-       // inline or call an eq alg.
-       t := n.Left.Type
-       var inline bool
-
-       maxcmpsize := int64(4)
-       unalignedLoad := canMergeLoads()
-       if unalignedLoad {
-               // Keep this low enough to generate less code than a function call.
-               maxcmpsize = 2 * int64(thearch.LinkArch.RegSize)
-       }
-
-       switch t.Etype {
-       default:
-               if Debug_libfuzzer != 0 && t.IsInteger() {
-                       n.Left = cheapexpr(n.Left, init)
-                       n.Right = cheapexpr(n.Right, init)
-
-                       // If exactly one comparison operand is
-                       // constant, invoke the constcmp functions
-                       // instead, and arrange for the constant
-                       // operand to be the first argument.
-                       l, r := n.Left, n.Right
-                       if r.Op == OLITERAL {
-                               l, r = r, l
-                       }
-                       constcmp := l.Op == OLITERAL && r.Op != OLITERAL
-
-                       var fn string
-                       var paramType *types.Type
-                       switch t.Size() {
-                       case 1:
-                               fn = "libfuzzerTraceCmp1"
-                               if constcmp {
-                                       fn = "libfuzzerTraceConstCmp1"
-                               }
-                               paramType = types.Types[TUINT8]
-                       case 2:
-                               fn = "libfuzzerTraceCmp2"
-                               if constcmp {
-                                       fn = "libfuzzerTraceConstCmp2"
-                               }
-                               paramType = types.Types[TUINT16]
-                       case 4:
-                               fn = "libfuzzerTraceCmp4"
-                               if constcmp {
-                                       fn = "libfuzzerTraceConstCmp4"
-                               }
-                               paramType = types.Types[TUINT32]
-                       case 8:
-                               fn = "libfuzzerTraceCmp8"
-                               if constcmp {
-                                       fn = "libfuzzerTraceConstCmp8"
-                               }
-                               paramType = types.Types[TUINT64]
-                       default:
-                               Fatalf("unexpected integer size %d for %v", t.Size(), t)
-                       }
-                       init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
-               }
-               return n
-       case TARRAY:
-               // We can compare several elements at once with 2/4/8 byte integer compares
-               inline = t.NumElem() <= 1 || (issimple[t.Elem().Etype] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
-       case TSTRUCT:
-               inline = t.NumComponents(types.IgnoreBlankFields) <= 4
-       }
-
-       cmpl := n.Left
-       for cmpl != nil && cmpl.Op == OCONVNOP {
-               cmpl = cmpl.Left
-       }
-       cmpr := n.Right
-       for cmpr != nil && cmpr.Op == OCONVNOP {
-               cmpr = cmpr.Left
-       }
-
-       // Chose not to inline. Call equality function directly.
-       if !inline {
-               // eq algs take pointers; cmpl and cmpr must be addressable
-               if !islvalue(cmpl) || !islvalue(cmpr) {
-                       Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
-               }
-
-               fn, needsize := eqfor(t)
-               call := nod(OCALL, fn, nil)
-               call.List.Append(nod(OADDR, cmpl, nil))
-               call.List.Append(nod(OADDR, cmpr, nil))
-               if needsize {
-                       call.List.Append(nodintconst(t.Width))
-               }
-               res := call
-               if n.Op != OEQ {
-                       res = nod(ONOT, res, nil)
-               }
-               n = finishcompare(n, res, init)
-               return n
-       }
-
-       // inline: build boolean expression comparing element by element
-       andor := OANDAND
-       if n.Op == ONE {
-               andor = OOROR
-       }
-       var expr *Node
-       compare := func(el, er *Node) {
-               a := nod(n.Op, el, er)
-               if expr == nil {
-                       expr = a
-               } else {
-                       expr = nod(andor, expr, a)
-               }
-       }
-       cmpl = safeexpr(cmpl, init)
-       cmpr = safeexpr(cmpr, init)
-       if t.IsStruct() {
-               for _, f := range t.Fields().Slice() {
-                       sym := f.Sym
-                       if sym.IsBlank() {
-                               continue
-                       }
-                       compare(
-                               nodSym(OXDOT, cmpl, sym),
-                               nodSym(OXDOT, cmpr, sym),
-                       )
-               }
-       } else {
-               step := int64(1)
-               remains := t.NumElem() * t.Elem().Width
-               combine64bit := unalignedLoad && Widthreg == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
-               combine32bit := unalignedLoad && t.Elem().Width <= 2 && t.Elem().IsInteger()
-               combine16bit := unalignedLoad && t.Elem().Width == 1 && t.Elem().IsInteger()
-               for i := int64(0); remains > 0; {
-                       var convType *types.Type
-                       switch {
-                       case remains >= 8 && combine64bit:
-                               convType = types.Types[TINT64]
-                               step = 8 / t.Elem().Width
-                       case remains >= 4 && combine32bit:
-                               convType = types.Types[TUINT32]
-                               step = 4 / t.Elem().Width
-                       case remains >= 2 && combine16bit:
-                               convType = types.Types[TUINT16]
-                               step = 2 / t.Elem().Width
-                       default:
-                               step = 1
-                       }
-                       if step == 1 {
-                               compare(
-                                       nod(OINDEX, cmpl, nodintconst(i)),
-                                       nod(OINDEX, cmpr, nodintconst(i)),
-                               )
-                               i++
-                               remains -= t.Elem().Width
-                       } else {
-                               elemType := t.Elem().ToUnsigned()
-                               cmplw := nod(OINDEX, cmpl, nodintconst(i))
-                               cmplw = conv(cmplw, elemType) // convert to unsigned
-                               cmplw = conv(cmplw, convType) // widen
-                               cmprw := nod(OINDEX, cmpr, nodintconst(i))
-                               cmprw = conv(cmprw, elemType)
-                               cmprw = conv(cmprw, convType)
-                               // For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
-                               // ssa will generate a single large load.
-                               for offset := int64(1); offset < step; offset++ {
-                                       lb := nod(OINDEX, cmpl, nodintconst(i+offset))
-                                       lb = conv(lb, elemType)
-                                       lb = conv(lb, convType)
-                                       lb = nod(OLSH, lb, nodintconst(8*t.Elem().Width*offset))
-                                       cmplw = nod(OOR, cmplw, lb)
-                                       rb := nod(OINDEX, cmpr, nodintconst(i+offset))
-                                       rb = conv(rb, elemType)
-                                       rb = conv(rb, convType)
-                                       rb = nod(OLSH, rb, nodintconst(8*t.Elem().Width*offset))
-                                       cmprw = nod(OOR, cmprw, rb)
-                               }
-                               compare(cmplw, cmprw)
-                               i += step
-                               remains -= step * t.Elem().Width
-                       }
-               }
-       }
-       if expr == nil {
-               expr = nodbool(n.Op == OEQ)
-               // We still need to use cmpl and cmpr, in case they contain
-               // an expression which might panic. See issue 23837.
-               t := temp(cmpl.Type)
-               a1 := nod(OAS, t, cmpl)
-               a1 = typecheck(a1, ctxStmt)
-               a2 := nod(OAS, t, cmpr)
-               a2 = typecheck(a2, ctxStmt)
-               init.Append(a1, a2)
-       }
-       n = finishcompare(n, expr, init)
-       return n
-}
-
-func tracecmpArg(n *Node, t *types.Type, init *Nodes) *Node {
-       // Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
-       if n.Op == OLITERAL && n.Type.IsSigned() && n.Int64Val() < 0 {
-               n = copyexpr(n, n.Type, init)
-       }
-
-       return conv(n, t)
-}
-
-func walkcompareInterface(n *Node, init *Nodes) *Node {
-       n.Right = cheapexpr(n.Right, init)
-       n.Left = cheapexpr(n.Left, init)
-       eqtab, eqdata := eqinterface(n.Left, n.Right)
-       var cmp *Node
-       if n.Op == OEQ {
-               cmp = nod(OANDAND, eqtab, eqdata)
-       } else {
-               eqtab.Op = ONE
-               cmp = nod(OOROR, eqtab, nod(ONOT, eqdata, nil))
-       }
-       return finishcompare(n, cmp, init)
-}
-
-func walkcompareString(n *Node, init *Nodes) *Node {
-       // Rewrite comparisons to short constant strings as length+byte-wise comparisons.
-       var cs, ncs *Node // const string, non-const string
-       switch {
-       case Isconst(n.Left, CTSTR) && Isconst(n.Right, CTSTR):
-               // ignore; will be constant evaluated
-       case Isconst(n.Left, CTSTR):
-               cs = n.Left
-               ncs = n.Right
-       case Isconst(n.Right, CTSTR):
-               cs = n.Right
-               ncs = n.Left
-       }
-       if cs != nil {
-               cmp := n.Op
-               // Our comparison below assumes that the non-constant string
-               // is on the left hand side, so rewrite "" cmp x to x cmp "".
-               // See issue 24817.
-               if Isconst(n.Left, CTSTR) {
-                       cmp = brrev(cmp)
-               }
-
-               // maxRewriteLen was chosen empirically.
-               // It is the value that minimizes cmd/go file size
-               // across most architectures.
-               // See the commit description for CL 26758 for details.
-               maxRewriteLen := 6
-               // Some architectures can load unaligned byte sequence as 1 word.
-               // So we can cover longer strings with the same amount of code.
-               canCombineLoads := canMergeLoads()
-               combine64bit := false
-               if canCombineLoads {
-                       // Keep this low enough to generate less code than a function call.
-                       maxRewriteLen = 2 * thearch.LinkArch.RegSize
-                       combine64bit = thearch.LinkArch.RegSize >= 8
-               }
-
-               var and Op
-               switch cmp {
-               case OEQ:
-                       and = OANDAND
-               case ONE:
-                       and = OOROR
-               default:
-                       // Don't do byte-wise comparisons for <, <=, etc.
-                       // They're fairly complicated.
-                       // Length-only checks are ok, though.
-                       maxRewriteLen = 0
-               }
-               if s := cs.StringVal(); len(s) <= maxRewriteLen {
-                       if len(s) > 0 {
-                               ncs = safeexpr(ncs, init)
-                       }
-                       r := nod(cmp, nod(OLEN, ncs, nil), nodintconst(int64(len(s))))
-                       remains := len(s)
-                       for i := 0; remains > 0; {
-                               if remains == 1 || !canCombineLoads {
-                                       cb := nodintconst(int64(s[i]))
-                                       ncb := nod(OINDEX, ncs, nodintconst(int64(i)))
-                                       r = nod(and, r, nod(cmp, ncb, cb))
-                                       remains--
-                                       i++
-                                       continue
-                               }
-                               var step int
-                               var convType *types.Type
-                               switch {
-                               case remains >= 8 && combine64bit:
-                                       convType = types.Types[TINT64]
-                                       step = 8
-                               case remains >= 4:
-                                       convType = types.Types[TUINT32]
-                                       step = 4
-                               case remains >= 2:
-                                       convType = types.Types[TUINT16]
-                                       step = 2
-                               }
-                               ncsubstr := nod(OINDEX, ncs, nodintconst(int64(i)))
-                               ncsubstr = conv(ncsubstr, convType)
-                               csubstr := int64(s[i])
-                               // Calculate large constant from bytes as sequence of shifts and ors.
-                               // Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
-                               // ssa will combine this into a single large load.
-                               for offset := 1; offset < step; offset++ {
-                                       b := nod(OINDEX, ncs, nodintconst(int64(i+offset)))
-                                       b = conv(b, convType)
-                                       b = nod(OLSH, b, nodintconst(int64(8*offset)))
-                                       ncsubstr = nod(OOR, ncsubstr, b)
-                                       csubstr |= int64(s[i+offset]) << uint8(8*offset)
-                               }
-                               csubstrPart := nodintconst(csubstr)
-                               // Compare "step" bytes as once
-                               r = nod(and, r, nod(cmp, csubstrPart, ncsubstr))
-                               remains -= step
-                               i += step
-                       }
-                       return finishcompare(n, r, init)
-               }
-       }
-
-       var r *Node
-       if n.Op == OEQ || n.Op == ONE {
-               // prepare for rewrite below
-               n.Left = cheapexpr(n.Left, init)
-               n.Right = cheapexpr(n.Right, init)
-               eqlen, eqmem := eqstring(n.Left, n.Right)
-               // quick check of len before full compare for == or !=.
-               // memequal then tests equality up to length len.
-               if n.Op == OEQ {
-                       // len(left) == len(right) && memequal(left, right, len)
-                       r = nod(OANDAND, eqlen, eqmem)
-               } else {
-                       // len(left) != len(right) || !memequal(left, right, len)
-                       eqlen.Op = ONE
-                       r = nod(OOROR, eqlen, nod(ONOT, eqmem, nil))
-               }
-       } else {
-               // sys_cmpstring(s1, s2) :: 0
-               r = mkcall("cmpstring", types.Types[TINT], init, conv(n.Left, types.Types[TSTRING]), conv(n.Right, types.Types[TSTRING]))
-               r = nod(n.Op, r, nodintconst(0))
-       }
-
-       return finishcompare(n, r, init)
-}
-
-// The result of finishcompare MUST be assigned back to n, e.g.
-//     n.Left = finishcompare(n.Left, x, r, init)
-func finishcompare(n, r *Node, init *Nodes) *Node {
-       r = typecheck(r, ctxExpr)
-       r = conv(r, n.Type)
-       r = walkexpr(r, init)
-       return r
-}
-
-// return 1 if integer n must be in range [0, max), 0 otherwise
-func bounded(n *Node, max int64) bool {
-       if n.Type == nil || !n.Type.IsInteger() {
-               return false
-       }
-
-       sign := n.Type.IsSigned()
-       bits := int32(8 * n.Type.Width)
-
-       if smallintconst(n) {
-               v := n.Int64Val()
-               return 0 <= v && v < max
-       }
-
-       switch n.Op {
-       case OAND, OANDNOT:
-               v := int64(-1)
-               switch {
-               case smallintconst(n.Left):
-                       v = n.Left.Int64Val()
-               case smallintconst(n.Right):
-                       v = n.Right.Int64Val()
-                       if n.Op == OANDNOT {
-                               v = ^v
-                               if !sign {
-                                       v &= 1<<uint(bits) - 1
-                               }
-                       }
-               }
-               if 0 <= v && v < max {
-                       return true
-               }
-
-       case OMOD:
-               if !sign && smallintconst(n.Right) {
-                       v := n.Right.Int64Val()
-                       if 0 <= v && v <= max {
-                               return true
-                       }
-               }
-
-       case ODIV:
-               if !sign && smallintconst(n.Right) {
-                       v := n.Right.Int64Val()
-                       for bits > 0 && v >= 2 {
-                               bits--
-                               v >>= 1
-                       }
-               }
-
-       case ORSH:
-               if !sign && smallintconst(n.Right) {
-                       v := n.Right.Int64Val()
-                       if v > int64(bits) {
-                               return true
-                       }
-                       bits -= int32(v)
-               }
-       }
-
-       if !sign && bits <= 62 && 1<<uint(bits) <= max {
-               return true
-       }
-
-       return false
-}
-
-// usemethod checks interface method calls for uses of reflect.Type.Method.
-func usemethod(n *Node) {
-       t := n.Left.Type
-
-       // Looking for either of:
-       //      Method(int) reflect.Method
-       //      MethodByName(string) (reflect.Method, bool)
-       //
-       // TODO(crawshaw): improve precision of match by working out
-       //                 how to check the method name.
-       if n := t.NumParams(); n != 1 {
-               return
-       }
-       if n := t.NumResults(); n != 1 && n != 2 {
-               return
-       }
-       p0 := t.Params().Field(0)
-       res0 := t.Results().Field(0)
-       var res1 *types.Field
-       if t.NumResults() == 2 {
-               res1 = t.Results().Field(1)
-       }
-
-       if res1 == nil {
-               if p0.Type.Etype != TINT {
-                       return
-               }
-       } else {
-               if !p0.Type.IsString() {
-                       return
-               }
-               if !res1.Type.IsBoolean() {
-                       return
-               }
-       }
-
-       // Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
-       //       (including global variables such as numImports - was issue #19028).
-       // Also need to check for reflect package itself (see Issue #38515).
-       if s := res0.Type.Sym; s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
-               Curfn.Func.SetReflectMethod(true)
-               // The LSym is initialized at this point. We need to set the attribute on the LSym.
-               Curfn.Func.lsym.Set(obj.AttrReflectMethod, true)
-       }
-}
-
-func usefield(n *Node) {
-       if objabi.Fieldtrack_enabled == 0 {
-               return
-       }
-
-       switch n.Op {
-       default:
-               Fatalf("usefield %v", n.Op)
-
-       case ODOT, ODOTPTR:
-               break
-       }
-       if n.Sym == nil {
-               // No field name.  This DOTPTR was built by the compiler for access
-               // to runtime data structures.  Ignore.
-               return
-       }
-
-       t := n.Left.Type
-       if t.IsPtr() {
-               t = t.Elem()
-       }
-       field := n.Opt().(*types.Field)
-       if field == nil {
-               Fatalf("usefield %v %v without paramfld", n.Left.Type, n.Sym)
-       }
-       if field.Sym != n.Sym || field.Offset != n.Xoffset {
-               Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym, n.Xoffset)
-       }
-       if !strings.Contains(field.Note, "go:\"track\"") {
-               return
-       }
-
-       outer := n.Left.Type
-       if outer.IsPtr() {
-               outer = outer.Elem()
-       }
-       if outer.Sym == nil {
-               yyerror("tracked field must be in named struct type")
-       }
-       if !types.IsExported(field.Sym.Name) {
-               yyerror("tracked field must be exported (upper case)")
-       }
-
-       sym := tracksym(outer, field)
-       if Curfn.Func.FieldTrack == nil {
-               Curfn.Func.FieldTrack = make(map[*types.Sym]struct{})
-       }
-       Curfn.Func.FieldTrack[sym] = struct{}{}
-}
-
-func candiscardlist(l Nodes) bool {
-       for _, n := range l.Slice() {
-               if !candiscard(n) {
-                       return false
-               }
-       }
-       return true
-}
-
-func candiscard(n *Node) bool {
-       if n == nil {
-               return true
-       }
-
-       switch n.Op {
-       default:
-               return false
-
-               // Discardable as long as the subpieces are.
-       case ONAME,
-               ONONAME,
-               OTYPE,
-               OPACK,
-               OLITERAL,
-               OADD,
-               OSUB,
-               OOR,
-               OXOR,
-               OADDSTR,
-               OADDR,
-               OANDAND,
-               OBYTES2STR,
-               ORUNES2STR,
-               OSTR2BYTES,
-               OSTR2RUNES,
-               OCAP,
-               OCOMPLIT,
-               OMAPLIT,
-               OSTRUCTLIT,
-               OARRAYLIT,
-               OSLICELIT,
-               OPTRLIT,
-               OCONV,
-               OCONVIFACE,
-               OCONVNOP,
-               ODOT,
-               OEQ,
-               ONE,
-               OLT,
-               OLE,
-               OGT,
-               OGE,
-               OKEY,
-               OSTRUCTKEY,
-               OLEN,
-               OMUL,
-               OLSH,
-               ORSH,
-               OAND,
-               OANDNOT,
-               ONEW,
-               ONOT,
-               OBITNOT,
-               OPLUS,
-               ONEG,
-               OOROR,
-               OPAREN,
-               ORUNESTR,
-               OREAL,
-               OIMAG,
-               OCOMPLEX:
-               break
-
-               // Discardable as long as we know it's not division by zero.
-       case ODIV, OMOD:
-               if Isconst(n.Right, CTINT) && n.Right.Val().U.(*Mpint).CmpInt64(0) != 0 {
-                       break
-               }
-               if Isconst(n.Right, CTFLT) && n.Right.Val().U.(*Mpflt).CmpFloat64(0) != 0 {
-                       break
-               }
-               return false
-
-               // Discardable as long as we know it won't fail because of a bad size.
-       case OMAKECHAN, OMAKEMAP:
-               if Isconst(n.Left, CTINT) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
-                       break
-               }
-               return false
-
-               // Difficult to tell what sizes are okay.
-       case OMAKESLICE:
-               return false
-
-       case OMAKESLICECOPY:
-               return false
-       }
-
-       if !candiscard(n.Left) || !candiscard(n.Right) || !candiscardlist(n.Ninit) || !candiscardlist(n.Nbody) || !candiscardlist(n.List) || !candiscardlist(n.Rlist) {
-               return false
-       }
-
-       return true
-}
-
-// Rewrite
-//     go builtin(x, y, z)
-// into
-//     go func(a1, a2, a3) {
-//             builtin(a1, a2, a3)
-//     }(x, y, z)
-// for print, println, and delete.
-//
-// Rewrite
-//     go f(x, y, uintptr(unsafe.Pointer(z)))
-// into
-//     go func(a1, a2, a3) {
-//             builtin(a1, a2, uintptr(a3))
-//     }(x, y, unsafe.Pointer(z))
-// for function contains unsafe-uintptr arguments.
-
-var wrapCall_prgen int
-
-// The result of wrapCall MUST be assigned back to n, e.g.
-//     n.Left = wrapCall(n.Left, init)
-func wrapCall(n *Node, init *Nodes) *Node {
-       if n.Ninit.Len() != 0 {
-               walkstmtlist(n.Ninit.Slice())
-               init.AppendNodes(&n.Ninit)
-       }
-
-       isBuiltinCall := n.Op != OCALLFUNC && n.Op != OCALLMETH && n.Op != OCALLINTER
-
-       // Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
-       if !isBuiltinCall && n.IsDDD() {
-               last := n.List.Len() - 1
-               if va := n.List.Index(last); va.Op == OSLICELIT {
-                       n.List.Set(append(n.List.Slice()[:last], va.List.Slice()...))
-                       n.SetIsDDD(false)
-               }
-       }
-
-       // origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-       origArgs := make([]*Node, n.List.Len())
-       t := nod(OTFUNC, nil, nil)
-       for i, arg := range n.List.Slice() {
-               s := lookupN("a", i)
-               if !isBuiltinCall && arg.Op == OCONVNOP && arg.Type.IsUintptr() && arg.Left.Type.IsUnsafePtr() {
-                       origArgs[i] = arg
-                       arg = arg.Left
-                       n.List.SetIndex(i, arg)
-               }
-               t.List.Append(symfield(s, arg.Type))
-       }
-
-       wrapCall_prgen++
-       sym := lookupN("wrap·", wrapCall_prgen)
-       fn := dclfunc(sym, t)
-
-       args := paramNnames(t.Type)
-       for i, origArg := range origArgs {
-               if origArg == nil {
-                       continue
-               }
-               arg := nod(origArg.Op, args[i], nil)
-               arg.Type = origArg.Type
-               args[i] = arg
-       }
-       call := nod(n.Op, nil, nil)
-       if !isBuiltinCall {
-               call.Op = OCALL
-               call.Left = n.Left
-               call.SetIsDDD(n.IsDDD())
-       }
-       call.List.Set(args)
-       fn.Nbody.Set1(call)
-
-       funcbody()
-
-       fn = typecheck(fn, ctxStmt)
-       typecheckslice(fn.Nbody.Slice(), ctxStmt)
-       xtop = append(xtop, fn)
-
-       call = nod(OCALL, nil, nil)
-       call.Left = fn.Func.Nname
-       call.List.Set(n.List.Slice())
-       call = typecheck(call, ctxStmt)
-       call = walkexpr(call, init)
-       return call
-}
-
-// substArgTypes substitutes the given list of types for
-// successive occurrences of the "any" placeholder in the
-// type syntax expression n.Type.
-// The result of substArgTypes MUST be assigned back to old, e.g.
-//     n.Left = substArgTypes(n.Left, t1, t2)
-func substArgTypes(old *Node, types_ ...*types.Type) *Node {
-       n := old.copy()
-
-       for _, t := range types_ {
-               dowidth(t)
-       }
-       n.Type = types.SubstAny(n.Type, &types_)
-       if len(types_) > 0 {
-               Fatalf("substArgTypes: too many argument types")
-       }
-       return n
-}
-
-// canMergeLoads reports whether the backend optimization passes for
-// the current architecture can combine adjacent loads into a single
-// larger, possibly unaligned, load. Note that currently the
-// optimizations must be able to handle little endian byte order.
-func canMergeLoads() bool {
-       switch thearch.LinkArch.Family {
-       case sys.ARM64, sys.AMD64, sys.I386, sys.S390X:
-               return true
-       case sys.PPC64:
-               // Load combining only supported on ppc64le.
-               return thearch.LinkArch.ByteOrder == binary.LittleEndian
-       }
-       return false
-}
-
-// isRuneCount reports whether n is of the form len([]rune(string)).
-// These are optimized into a call to runtime.countrunes.
-func isRuneCount(n *Node) bool {
-       return Debug.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
-}
-
-func walkCheckPtrAlignment(n *Node, init *Nodes, count *Node) *Node {
-       if !n.Type.IsPtr() {
-               Fatalf("expected pointer type: %v", n.Type)
-       }
-       elem := n.Type.Elem()
-       if count != nil {
-               if !elem.IsArray() {
-                       Fatalf("expected array type: %v", elem)
-               }
-               elem = elem.Elem()
-       }
-
-       size := elem.Size()
-       if elem.Alignment() == 1 && (size == 0 || size == 1 && count == nil) {
-               return n
-       }
-
-       if count == nil {
-               count = nodintconst(1)
-       }
-
-       n.Left = cheapexpr(n.Left, init)
-       init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left, types.Types[TUNSAFEPTR]), typename(elem), conv(count, types.Types[TUINTPTR])))
-       return n
-}
-
-var walkCheckPtrArithmeticMarker byte
-
-func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
-       // Calling cheapexpr(n, init) below leads to a recursive call
-       // to walkexpr, which leads us back here again. Use n.Opt to
-       // prevent infinite loops.
-       if opt := n.Opt(); opt == &walkCheckPtrArithmeticMarker {
-               return n
-       } else if opt != nil {
-               // We use n.Opt() here because today it's not used for OCONVNOP. If that changes,
-               // there's no guarantee that temporarily replacing it is safe, so just hard fail here.
-               Fatalf("unexpected Opt: %v", opt)
-       }
-       n.SetOpt(&walkCheckPtrArithmeticMarker)
-       defer n.SetOpt(nil)
-
-       // TODO(mdempsky): Make stricter. We only need to exempt
-       // reflect.Value.Pointer and reflect.Value.UnsafeAddr.
-       switch n.Left.Op {
-       case OCALLFUNC, OCALLMETH, OCALLINTER:
-               return n
-       }
-
-       if n.Left.Op == ODOTPTR && isReflectHeaderDataField(n.Left) {
-               return n
-       }
-
-       // Find original unsafe.Pointer operands involved in this
-       // arithmetic expression.
-       //
-       // "It is valid both to add and to subtract offsets from a
-       // pointer in this way. It is also valid to use &^ to round
-       // pointers, usually for alignment."
-       var originals []*Node
-       var walk func(n *Node)
-       walk = func(n *Node) {
-               switch n.Op {
-               case OADD:
-                       walk(n.Left)
-                       walk(n.Right)
-               case OSUB, OANDNOT:
-                       walk(n.Left)
-               case OCONVNOP:
-                       if n.Left.Type.IsUnsafePtr() {
-                               n.Left = cheapexpr(n.Left, init)
-                               originals = append(originals, convnop(n.Left, types.Types[TUNSAFEPTR]))
-                       }
-               }
-       }
-       walk(n.Left)
-
-       n = cheapexpr(n, init)
-
-       slice := mkdotargslice(types.NewSlice(types.Types[TUNSAFEPTR]), originals)
-       slice.Esc = EscNone
-
-       init.Append(mkcall("checkptrArithmetic", nil, init, convnop(n, types.Types[TUNSAFEPTR]), slice))
-       // TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
-       // the backing store for multiple calls to checkptrArithmetic.
-
-       return n
-}
-
-// checkPtr reports whether pointer checking should be enabled for
-// function fn at a given level. See debugHelpFooter for defined
-// levels.
-func checkPtr(fn *Node, level int) bool {
-       return Debug_checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
-}

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
new file mode 100644 (file)
index 0000000..9f9bb87
--- /dev/null
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -0,0 +1,1420 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+// The inlining facility makes 2 passes: first caninl determines which
+// functions are suitable for inlining, and for those that are it
+// saves a copy of the body. Then InlineCalls walks each function body to
+// expand calls to inlinable functions.
+//
+// The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
+// making 1 the default and -l disable. Additional levels (beyond -l) may be buggy and
+// are not supported.
+//      0: disabled
+//      1: 80-nodes leaf functions, oneliners, panic, lazy typechecking (default)
+//      2: (unassigned)
+//      3: (unassigned)
+//      4: allow non-leaf functions
+//
+// At some point this may get another default and become switch-offable with -N.
+//
+// The -d typcheckinl flag enables early typechecking of all imported bodies,
+// which is useful to flush out bugs.
+//
+// The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
+// which calls get inlined or not, more is for debugging, and may go away at any point.
+
+package inline
+
+import (
+       "fmt"
+       "go/constant"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/logopt"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+// Inlining budget parameters, gathered in one place
+const (
+       inlineMaxBudget       = 80
+       inlineExtraAppendCost = 0
+       // default is to inline if there's at most one call. -l=4 overrides this by using 1 instead.
+       inlineExtraCallCost  = 57              // 57 was benchmarked to provided most benefit with no bad surprises; see https://github.com/golang/go/issues/19348#issuecomment-439370742
+       inlineExtraPanicCost = 1               // do not penalize inlining panics.
+       inlineExtraThrowCost = inlineMaxBudget // with current (2018-05/1.11) code, inlining runtime.throw does not help.
+
+       inlineBigFunctionNodes   = 5000 // Functions with this many nodes are considered "big".
+       inlineBigFunctionMaxCost = 20   // Max cost of inlinee when inlining into a "big" function.
+)
+
+func InlinePackage() {
+       // Find functions that can be inlined and clone them before walk expands them.
+       ir.VisitFuncsBottomUp(typecheck.Target.Decls, func(list []*ir.Func, recursive bool) {
+               numfns := numNonClosures(list)
+               for _, n := range list {
+                       if !recursive || numfns > 1 {
+                               // We allow inlining if there is no
+                               // recursion, or the recursion cycle is
+                               // across more than one function.
+                               CanInline(n)
+                       } else {
+                               if base.Flag.LowerM > 1 {
+                                       fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
+                               }
+                       }
+                       InlineCalls(n)
+               }
+       })
+}
+
+// CanInline determines whether fn is inlineable.
+// If so, CanInline saves fn->nbody in fn->inl and substitutes it with a copy.
+// fn and ->nbody will already have been typechecked.
+func CanInline(fn *ir.Func) {
+       if fn.Nname == nil {
+               base.Fatalf("CanInline no nname %+v", fn)
+       }
+
+       var reason string // reason, if any, that the function was not inlined
+       if base.Flag.LowerM > 1 || logopt.Enabled() {
+               defer func() {
+                       if reason != "" {
+                               if base.Flag.LowerM > 1 {
+                                       fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Nname, reason)
+                               }
+                               if logopt.Enabled() {
+                                       logopt.LogOpt(fn.Pos(), "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
+                               }
+                       }
+               }()
+       }
+
+       // If marked "go:noinline", don't inline
+       if fn.Pragma&ir.Noinline != 0 {
+               reason = "marked go:noinline"
+               return
+       }
+
+       // If marked "go:norace" and -race compilation, don't inline.
+       if base.Flag.Race && fn.Pragma&ir.Norace != 0 {
+               reason = "marked go:norace with -race compilation"
+               return
+       }
+
+       // If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
+       if base.Debug.Checkptr != 0 && fn.Pragma&ir.NoCheckPtr != 0 {
+               reason = "marked go:nocheckptr"
+               return
+       }
+
+       // If marked "go:cgo_unsafe_args", don't inline, since the
+       // function makes assumptions about its argument frame layout.
+       if fn.Pragma&ir.CgoUnsafeArgs != 0 {
+               reason = "marked go:cgo_unsafe_args"
+               return
+       }
+
+       // If marked as "go:uintptrescapes", don't inline, since the
+       // escape information is lost during inlining.
+       if fn.Pragma&ir.UintptrEscapes != 0 {
+               reason = "marked as having an escaping uintptr argument"
+               return
+       }
+
+       // The nowritebarrierrec checker currently works at function
+       // granularity, so inlining yeswritebarrierrec functions can
+       // confuse it (#22342). As a workaround, disallow inlining
+       // them for now.
+       if fn.Pragma&ir.Yeswritebarrierrec != 0 {
+               reason = "marked go:yeswritebarrierrec"
+               return
+       }
+
+       // If fn has no body (is defined outside of Go), cannot inline it.
+       if len(fn.Body) == 0 {
+               reason = "no function body"
+               return
+       }
+
+       if fn.Typecheck() == 0 {
+               base.Fatalf("CanInline on non-typechecked function %v", fn)
+       }
+
+       n := fn.Nname
+       if n.Func.InlinabilityChecked() {
+               return
+       }
+       defer n.Func.SetInlinabilityChecked(true)
+
+       cc := int32(inlineExtraCallCost)
+       if base.Flag.LowerL == 4 {
+               cc = 1 // this appears to yield better performance than 0.
+       }
+
+       // At this point in the game the function we're looking at may
+       // have "stale" autos, vars that still appear in the Dcl list, but
+       // which no longer have any uses in the function body (due to
+       // elimination by deadcode). We'd like to exclude these dead vars
+       // when creating the "Inline.Dcl" field below; to accomplish this,
+       // the hairyVisitor below builds up a map of used/referenced
+       // locals, and we use this map to produce a pruned Inline.Dcl
+       // list. See issue 25249 for more context.
+
+       visitor := hairyVisitor{
+               budget:        inlineMaxBudget,
+               extraCallCost: cc,
+       }
+       if visitor.tooHairy(fn) {
+               reason = visitor.reason
+               return
+       }
+
+       n.Func.Inl = &ir.Inline{
+               Cost: inlineMaxBudget - visitor.budget,
+               Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
+               Body: inlcopylist(fn.Body),
+       }
+
+       if base.Flag.LowerM > 1 {
+               fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.Nodes(n.Func.Inl.Body))
+       } else if base.Flag.LowerM != 0 {
+               fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
+       }
+       if logopt.Enabled() {
+               logopt.LogOpt(fn.Pos(), "canInlineFunction", "inline", ir.FuncName(fn), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
+       }
+}
+
+// Inline_Flood marks n's inline body for export and recursively ensures
+// all called functions are marked too.
+func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
+       if n == nil {
+               return
+       }
+       if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
+               base.Fatalf("Inline_Flood: unexpected %v, %v, %v", n, n.Op(), n.Class)
+       }
+       fn := n.Func
+       if fn == nil {
+               base.Fatalf("Inline_Flood: missing Func on %v", n)
+       }
+       if fn.Inl == nil {
+               return
+       }
+
+       if fn.ExportInline() {
+               return
+       }
+       fn.SetExportInline(true)
+
+       typecheck.ImportedBody(fn)
+
+       var doFlood func(n ir.Node)
+       doFlood = func(n ir.Node) {
+               switch n.Op() {
+               case ir.OMETHEXPR, ir.ODOTMETH:
+                       Inline_Flood(ir.MethodExprName(n), exportsym)
+
+               case ir.ONAME:
+                       n := n.(*ir.Name)
+                       switch n.Class {
+                       case ir.PFUNC:
+                               Inline_Flood(n, exportsym)
+                               exportsym(n)
+                       case ir.PEXTERN:
+                               exportsym(n)
+                       }
+
+               case ir.OCALLPART:
+                       // Okay, because we don't yet inline indirect
+                       // calls to method values.
+               case ir.OCLOSURE:
+                       // VisitList doesn't visit closure bodies, so force a
+                       // recursive call to VisitList on the body of the closure.
+                       ir.VisitList(n.(*ir.ClosureExpr).Func.Body, doFlood)
+               }
+       }
+
+       // Recursively identify all referenced functions for
+       // reexport. We want to include even non-called functions,
+       // because after inlining they might be callable.
+       ir.VisitList(ir.Nodes(fn.Inl.Body), doFlood)
+}
+
+// hairyVisitor visits a function body to determine its inlining
+// hairiness and whether or not it can be inlined.
+type hairyVisitor struct {
+       budget        int32
+       reason        string
+       extraCallCost int32
+       usedLocals    ir.NameSet
+       do            func(ir.Node) bool
+}
+
+func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
+       v.do = v.doNode // cache closure
+       if ir.DoChildren(fn, v.do) {
+               return true
+       }
+       if v.budget < 0 {
+               v.reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-v.budget, inlineMaxBudget)
+               return true
+       }
+       return false
+}
+
+func (v *hairyVisitor) doNode(n ir.Node) bool {
+       if n == nil {
+               return false
+       }
+       switch n.Op() {
+       // Call is okay if inlinable and we have the budget for the body.
+       case ir.OCALLFUNC:
+               n := n.(*ir.CallExpr)
+               // Functions that call runtime.getcaller{pc,sp} can not be inlined
+               // because getcaller{pc,sp} expect a pointer to the caller's first argument.
+               //
+               // runtime.throw is a "cheap call" like panic in normal code.
+               if n.X.Op() == ir.ONAME {
+                       name := n.X.(*ir.Name)
+                       if name.Class == ir.PFUNC && types.IsRuntimePkg(name.Sym().Pkg) {
+                               fn := name.Sym().Name
+                               if fn == "getcallerpc" || fn == "getcallersp" {
+                                       v.reason = "call to " + fn
+                                       return true
+                               }
+                               if fn == "throw" {
+                                       v.budget -= inlineExtraThrowCost
+                                       break
+                               }
+                       }
+               }
+
+               if ir.IsIntrinsicCall(n) {
+                       // Treat like any other node.
+                       break
+               }
+
+               if fn := inlCallee(n.X); fn != nil && fn.Inl != nil {
+                       v.budget -= fn.Inl.Cost
+                       break
+               }
+
+               // Call cost for non-leaf inlining.
+               v.budget -= v.extraCallCost
+
+       // Call is okay if inlinable and we have the budget for the body.
+       case ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
+               t := n.X.Type()
+               if t == nil {
+                       base.Fatalf("no function type for [%p] %+v\n", n.X, n.X)
+               }
+               fn := ir.MethodExprName(n.X).Func
+               if types.IsRuntimePkg(fn.Sym().Pkg) && fn.Sym().Name == "heapBits.nextArena" {
+                       // Special case: explicitly allow
+                       // mid-stack inlining of
+                       // runtime.heapBits.next even though
+                       // it calls slow-path
+                       // runtime.heapBits.nextArena.
+                       break
+               }
+               if fn.Inl != nil {
+                       v.budget -= fn.Inl.Cost
+                       break
+               }
+               // Call cost for non-leaf inlining.
+               v.budget -= v.extraCallCost
+
+       // Things that are too hairy, irrespective of the budget
+       case ir.OCALL, ir.OCALLINTER:
+               // Call cost for non-leaf inlining.
+               v.budget -= v.extraCallCost
+
+       case ir.OPANIC:
+               n := n.(*ir.UnaryExpr)
+               if n.X.Op() == ir.OCONVIFACE && n.X.(*ir.ConvExpr).Implicit() {
+                       // Hack to keep reflect.flag.mustBe inlinable for TestIntendedInlining.
+                       // Before CL 284412, these conversions were introduced later in the
+                       // compiler, so they didn't count against inlining budget.
+                       v.budget++
+               }
+               v.budget -= inlineExtraPanicCost
+
+       case ir.ORECOVER:
+               // recover matches the argument frame pointer to find
+               // the right panic value, so it needs an argument frame.
+               v.reason = "call to recover"
+               return true
+
+       case ir.OCLOSURE:
+               // TODO(danscales) - fix some bugs when budget is lowered below 15
+               // Maybe make budget proportional to number of closure variables, e.g.:
+               //v.budget -= int32(len(n.(*ir.ClosureExpr).Func.ClosureVars) * 3)
+               v.budget -= 15
+               // Scan body of closure (which DoChildren doesn't automatically
+               // do) to check for disallowed ops in the body and include the
+               // body in the budget.
+               if doList(n.(*ir.ClosureExpr).Func.Body, v.do) {
+                       return true
+               }
+
+       case ir.ORANGE,
+               ir.OSELECT,
+               ir.OGO,
+               ir.ODEFER,
+               ir.ODCLTYPE, // can't print yet
+               ir.OTAILCALL:
+               v.reason = "unhandled op " + n.Op().String()
+               return true
+
+       case ir.OAPPEND:
+               v.budget -= inlineExtraAppendCost
+
+       case ir.ODCLCONST, ir.OFALL:
+               // These nodes don't produce code; omit from inlining budget.
+               return false
+
+       case ir.OFOR, ir.OFORUNTIL:
+               n := n.(*ir.ForStmt)
+               if n.Label != nil {
+                       v.reason = "labeled control"
+                       return true
+               }
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+               if n.Label != nil {
+                       v.reason = "labeled control"
+                       return true
+               }
+       // case ir.ORANGE, ir.OSELECT in "unhandled" above
+
+       case ir.OBREAK, ir.OCONTINUE:
+               n := n.(*ir.BranchStmt)
+               if n.Label != nil {
+                       // Should have short-circuited due to labeled control error above.
+                       base.Fatalf("unexpected labeled break/continue: %v", n)
+               }
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               if ir.IsConst(n.Cond, constant.Bool) {
+                       // This if and the condition cost nothing.
+                       // TODO(rsc): It seems strange that we visit the dead branch.
+                       return doList(n.Init(), v.do) ||
+                               doList(n.Body, v.do) ||
+                               doList(n.Else, v.do)
+               }
+
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Class == ir.PAUTO {
+                       v.usedLocals.Add(n)
+               }
+
+       case ir.OBLOCK:
+               // The only OBLOCK we should see at this point is an empty one.
+               // In any event, let the visitList(n.List()) below take care of the statements,
+               // and don't charge for the OBLOCK itself. The ++ undoes the -- below.
+               v.budget++
+
+       case ir.OCALLPART, ir.OSLICELIT:
+               v.budget-- // Hack for toolstash -cmp.
+
+       case ir.OMETHEXPR:
+               v.budget++ // Hack for toolstash -cmp.
+       }
+
+       v.budget--
+
+       // When debugging, don't stop early, to get full cost of inlining this function
+       if v.budget < 0 && base.Flag.LowerM < 2 && !logopt.Enabled() {
+               v.reason = "too expensive"
+               return true
+       }
+
+       return ir.DoChildren(n, v.do)
+}
+
+func isBigFunc(fn *ir.Func) bool {
+       budget := inlineBigFunctionNodes
+       return ir.Any(fn, func(n ir.Node) bool {
+               budget--
+               return budget <= 0
+       })
+}
+
+// inlcopylist (together with inlcopy) recursively copies a list of nodes, except
+// that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
+// the body and dcls of an inlineable function.
+func inlcopylist(ll []ir.Node) []ir.Node {
+       s := make([]ir.Node, len(ll))
+       for i, n := range ll {
+               s[i] = inlcopy(n)
+       }
+       return s
+}
+
+// inlcopy is like DeepCopy(), but does extra work to copy closures.
+func inlcopy(n ir.Node) ir.Node {
+       var edit func(ir.Node) ir.Node
+       edit = func(x ir.Node) ir.Node {
+               switch x.Op() {
+               case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.ONIL:
+                       return x
+               }
+               m := ir.Copy(x)
+               ir.EditChildren(m, edit)
+               if x.Op() == ir.OCLOSURE {
+                       x := x.(*ir.ClosureExpr)
+                       // Need to save/duplicate x.Func.Nname,
+                       // x.Func.Nname.Ntype, x.Func.Dcl, x.Func.ClosureVars, and
+                       // x.Func.Body for iexport and local inlining.
+                       oldfn := x.Func
+                       newfn := ir.NewFunc(oldfn.Pos())
+                       if oldfn.ClosureCalled() {
+                               newfn.SetClosureCalled(true)
+                       }
+                       m.(*ir.ClosureExpr).Func = newfn
+                       newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), oldfn.Nname.Sym())
+                       // XXX OK to share fn.Type() ??
+                       newfn.Nname.SetType(oldfn.Nname.Type())
+                       newfn.Nname.Ntype = inlcopy(oldfn.Nname.Ntype).(ir.Ntype)
+                       newfn.Body = inlcopylist(oldfn.Body)
+                       // Make shallow copy of the Dcl and ClosureVar slices
+                       newfn.Dcl = append([]*ir.Name(nil), oldfn.Dcl...)
+                       newfn.ClosureVars = append([]*ir.Name(nil), oldfn.ClosureVars...)
+               }
+               return m
+       }
+       return edit(n)
+}
+
+// Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
+// calls made to inlineable functions. This is the external entry point.
+func InlineCalls(fn *ir.Func) {
+       savefn := ir.CurFunc
+       ir.CurFunc = fn
+       maxCost := int32(inlineMaxBudget)
+       if isBigFunc(fn) {
+               maxCost = inlineBigFunctionMaxCost
+       }
+       // Map to keep track of functions that have been inlined at a particular
+       // call site, in order to stop inlining when we reach the beginning of a
+       // recursion cycle again. We don't inline immediately recursive functions,
+       // but allow inlining if there is a recursion cycle of many functions.
+       // Most likely, the inlining will stop before we even hit the beginning of
+       // the cycle again, but the map catches the unusual case.
+       inlMap := make(map[*ir.Func]bool)
+       var edit func(ir.Node) ir.Node
+       edit = func(n ir.Node) ir.Node {
+               return inlnode(n, maxCost, inlMap, edit)
+       }
+       ir.EditChildren(fn, edit)
+       ir.CurFunc = savefn
+}
+
+// Turn an OINLCALL into a statement.
+func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
+       n := ir.NewBlockStmt(inlcall.Pos(), nil)
+       n.List = inlcall.Init()
+       n.List.Append(inlcall.Body.Take()...)
+       return n
+}
+
+// Turn an OINLCALL into a single valued expression.
+// The result of inlconv2expr MUST be assigned back to n, e.g.
+//     n.Left = inlconv2expr(n.Left)
+func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
+       r := n.ReturnVars[0]
+       return ir.InitExpr(append(n.Init(), n.Body...), r)
+}
+
+// Turn the rlist (with the return values) of the OINLCALL in
+// n into an expression list lumping the ninit and body
+// containing the inlined statements on the first list element so
+// order will be preserved. Used in return, oas2func and call
+// statements.
+func inlconv2list(n *ir.InlinedCallExpr) []ir.Node {
+       if n.Op() != ir.OINLCALL || len(n.ReturnVars) == 0 {
+               base.Fatalf("inlconv2list %+v\n", n)
+       }
+
+       s := n.ReturnVars
+       s[0] = ir.InitExpr(append(n.Init(), n.Body...), s[0])
+       return s
+}
+
+// inlnode recurses over the tree to find inlineable calls, which will
+// be turned into OINLCALLs by mkinlcall. When the recursion comes
+// back up will examine left, right, list, rlist, ninit, ntest, nincr,
+// nbody and nelse and use one of the 4 inlconv/glue functions above
+// to turn the OINLCALL into an expression, a statement, or patch it
+// in to this nodes list or rlist as appropriate.
+// NOTE it makes no sense to pass the glue functions down the
+// recursion to the level where the OINLCALL gets created because they
+// have to edit /this/ n, so you'd have to push that one down as well,
+// but then you may as well do it here.  so this is cleaner and
+// shorter and less complicated.
+// The result of inlnode MUST be assigned back to n, e.g.
+//     n.Left = inlnode(n.Left)
+func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
+       if n == nil {
+               return n
+       }
+
+       switch n.Op() {
+       case ir.ODEFER, ir.OGO:
+               n := n.(*ir.GoDeferStmt)
+               switch call := n.Call; call.Op() {
+               case ir.OCALLFUNC, ir.OCALLMETH:
+                       call := call.(*ir.CallExpr)
+                       call.NoInline = true
+               }
+
+       // TODO do them here (or earlier),
+       // so escape analysis can avoid more heapmoves.
+       case ir.OCLOSURE:
+               return n
+       case ir.OCALLMETH:
+               // Prevent inlining some reflect.Value methods when using checkptr,
+               // even when package reflect was compiled without it (#35073).
+               n := n.(*ir.CallExpr)
+               if s := ir.MethodExprName(n.X).Sym(); base.Debug.Checkptr != 0 && types.IsReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+                       return n
+               }
+       }
+
+       lno := ir.SetPos(n)
+
+       ir.EditChildren(n, edit)
+
+       if as := n; as.Op() == ir.OAS2FUNC {
+               as := as.(*ir.AssignListStmt)
+               if as.Rhs[0].Op() == ir.OINLCALL {
+                       as.Rhs = inlconv2list(as.Rhs[0].(*ir.InlinedCallExpr))
+                       as.SetOp(ir.OAS2)
+                       as.SetTypecheck(0)
+                       n = typecheck.Stmt(as)
+               }
+       }
+
+       // with all the branches out of the way, it is now time to
+       // transmogrify this node itself unless inhibited by the
+       // switch at the top of this function.
+       switch n.Op() {
+       case ir.OCALLFUNC, ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
+               if n.NoInline {
+                       return n
+               }
+       }
+
+       var call *ir.CallExpr
+       switch n.Op() {
+       case ir.OCALLFUNC:
+               call = n.(*ir.CallExpr)
+               if base.Flag.LowerM > 3 {
+                       fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.X)
+               }
+               if ir.IsIntrinsicCall(call) {
+                       break
+               }
+               if fn := inlCallee(call.X); fn != nil && fn.Inl != nil {
+                       n = mkinlcall(call, fn, maxCost, inlMap, edit)
+               }
+
+       case ir.OCALLMETH:
+               call = n.(*ir.CallExpr)
+               if base.Flag.LowerM > 3 {
+                       fmt.Printf("%v:call to meth %v\n", ir.Line(n), call.X.(*ir.SelectorExpr).Sel)
+               }
+
+               // typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
+               if call.X.Type() == nil {
+                       base.Fatalf("no function type for [%p] %+v\n", call.X, call.X)
+               }
+
+               n = mkinlcall(call, ir.MethodExprName(call.X).Func, maxCost, inlMap, edit)
+       }
+
+       base.Pos = lno
+
+       if n.Op() == ir.OINLCALL {
+               ic := n.(*ir.InlinedCallExpr)
+               switch call.Use {
+               default:
+                       ir.Dump("call", call)
+                       base.Fatalf("call missing use")
+               case ir.CallUseExpr:
+                       n = inlconv2expr(ic)
+               case ir.CallUseStmt:
+                       n = inlconv2stmt(ic)
+               case ir.CallUseList:
+                       // leave for caller to convert
+               }
+       }
+
+       return n
+}
+
+// inlCallee takes a function-typed expression and returns the underlying function ONAME
+// that it refers to if statically known. Otherwise, it returns nil.
+func inlCallee(fn ir.Node) *ir.Func {
+       fn = ir.StaticValue(fn)
+       switch fn.Op() {
+       case ir.OMETHEXPR:
+               fn := fn.(*ir.SelectorExpr)
+               n := ir.MethodExprName(fn)
+               // Check that receiver type matches fn.X.
+               // TODO(mdempsky): Handle implicit dereference
+               // of pointer receiver argument?
+               if n == nil || !types.Identical(n.Type().Recv().Type, fn.X.Type()) {
+                       return nil
+               }
+               return n.Func
+       case ir.ONAME:
+               fn := fn.(*ir.Name)
+               if fn.Class == ir.PFUNC {
+                       return fn.Func
+               }
+       case ir.OCLOSURE:
+               fn := fn.(*ir.ClosureExpr)
+               c := fn.Func
+               CanInline(c)
+               return c
+       }
+       return nil
+}
+
+func inlParam(t *types.Field, as ir.InitNode, inlvars map[*ir.Name]*ir.Name) ir.Node {
+       if t.Nname == nil {
+               return ir.BlankNode
+       }
+       n := t.Nname.(*ir.Name)
+       if ir.IsBlank(n) {
+               return ir.BlankNode
+       }
+       inlvar := inlvars[n]
+       if inlvar == nil {
+               base.Fatalf("missing inlvar for %v", n)
+       }
+       as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar))
+       inlvar.Name().Defn = as
+       return inlvar
+}
+
+var inlgen int
+
+// SSADumpInline gives the SSA back end a chance to dump the function
+// when producing output for debugging the compiler itself.
+var SSADumpInline = func(*ir.Func) {}
+
+// If n is a call node (OCALLFUNC or OCALLMETH), and fn is an ONAME node for a
+// function with an inlinable body, return an OINLCALL node that can replace n.
+// The returned node's Ninit has the parameter assignments, the Nbody is the
+// inlined function body, and (List, Rlist) contain the (input, output)
+// parameters.
+// The result of mkinlcall MUST be assigned back to n, e.g.
+//     n.Left = mkinlcall(n.Left, fn, isddd)
+func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
+       if fn.Inl == nil {
+               if logopt.Enabled() {
+                       logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
+                               fmt.Sprintf("%s cannot be inlined", ir.PkgFuncName(fn)))
+               }
+               return n
+       }
+       if fn.Inl.Cost > maxCost {
+               // The inlined function body is too big. Typically we use this check to restrict
+               // inlining into very big functions.  See issue 26546 and 17566.
+               if logopt.Enabled() {
+                       logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
+                               fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Inl.Cost, ir.PkgFuncName(fn), maxCost))
+               }
+               return n
+       }
+
+       if fn == ir.CurFunc {
+               // Can't recursively inline a function into itself.
+               if logopt.Enabled() {
+                       logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(ir.CurFunc)))
+               }
+               return n
+       }
+
+       if base.Flag.Cfg.Instrumenting && types.IsRuntimePkg(fn.Sym().Pkg) {
+               // Runtime package must not be instrumented.
+               // Instrument skips runtime package. However, some runtime code can be
+               // inlined into other packages and instrumented there. To avoid this,
+               // we disable inlining of runtime functions when instrumenting.
+               // The example that we observed is inlining of LockOSThread,
+               // which lead to false race reports on m contents.
+               return n
+       }
+
+       if inlMap[fn] {
+               if base.Flag.LowerM > 1 {
+                       fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", ir.Line(n), fn, ir.FuncName(ir.CurFunc))
+               }
+               return n
+       }
+       inlMap[fn] = true
+       defer func() {
+               inlMap[fn] = false
+       }()
+       if base.Debug.TypecheckInl == 0 {
+               typecheck.ImportedBody(fn)
+       }
+
+       // We have a function node, and it has an inlineable body.
+       if base.Flag.LowerM > 1 {
+               fmt.Printf("%v: inlining call to %v %v { %v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.Nodes(fn.Inl.Body))
+       } else if base.Flag.LowerM != 0 {
+               fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
+       }
+       if base.Flag.LowerM > 2 {
+               fmt.Printf("%v: Before inlining: %+v\n", ir.Line(n), n)
+       }
+
+       SSADumpInline(fn)
+
+       ninit := n.Init()
+
+       // For normal function calls, the function callee expression
+       // may contain side effects (e.g., added by addinit during
+       // inlconv2expr or inlconv2list). Make sure to preserve these,
+       // if necessary (#42703).
+       if n.Op() == ir.OCALLFUNC {
+               callee := n.X
+               for callee.Op() == ir.OCONVNOP {
+                       conv := callee.(*ir.ConvExpr)
+                       ninit.Append(ir.TakeInit(conv)...)
+                       callee = conv.X
+               }
+               if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
+                       base.Fatalf("unexpected callee expression: %v", callee)
+               }
+       }
+
+       // Make temp names to use instead of the originals.
+       inlvars := make(map[*ir.Name]*ir.Name)
+
+       // record formals/locals for later post-processing
+       var inlfvars []*ir.Name
+
+       for _, ln := range fn.Inl.Dcl {
+               if ln.Op() != ir.ONAME {
+                       continue
+               }
+               if ln.Class == ir.PPARAMOUT { // return values handled below.
+                       continue
+               }
+               inlf := typecheck.Expr(inlvar(ln)).(*ir.Name)
+               inlvars[ln] = inlf
+               if base.Flag.GenDwarfInl > 0 {
+                       if ln.Class == ir.PPARAM {
+                               inlf.Name().SetInlFormal(true)
+                       } else {
+                               inlf.Name().SetInlLocal(true)
+                       }
+                       inlf.SetPos(ln.Pos())
+                       inlfvars = append(inlfvars, inlf)
+               }
+       }
+
+       nreturns := 0
+       ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
+               if n != nil && n.Op() == ir.ORETURN {
+                       nreturns++
+               }
+       })
+
+       // We can delay declaring+initializing result parameters if:
+       // (1) there's only one "return" statement in the inlined
+       // function, and (2) the result parameters aren't named.
+       delayretvars := nreturns == 1
+
+       // temporaries for return values.
+       var retvars []ir.Node
+       for i, t := range fn.Type().Results().Fields().Slice() {
+               var m *ir.Name
+               if nn := t.Nname; nn != nil && !ir.IsBlank(nn.(*ir.Name)) && !strings.HasPrefix(nn.Sym().Name, "~r") {
+                       n := nn.(*ir.Name)
+                       m = inlvar(n)
+                       m = typecheck.Expr(m).(*ir.Name)
+                       inlvars[n] = m
+                       delayretvars = false // found a named result parameter
+               } else {
+                       // anonymous return values, synthesize names for use in assignment that replaces return
+                       m = retvar(t, i)
+               }
+
+               if base.Flag.GenDwarfInl > 0 {
+                       // Don't update the src.Pos on a return variable if it
+                       // was manufactured by the inliner (e.g. "~R2"); such vars
+                       // were not part of the original callee.
+                       if !strings.HasPrefix(m.Sym().Name, "~R") {
+                               m.Name().SetInlFormal(true)
+                               m.SetPos(t.Pos)
+                               inlfvars = append(inlfvars, m)
+                       }
+               }
+
+               retvars = append(retvars, m)
+       }
+
+       // Assign arguments to the parameters' temp names.
+       as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+       as.Def = true
+       if n.Op() == ir.OCALLMETH {
+               sel := n.X.(*ir.SelectorExpr)
+               if sel.X == nil {
+                       base.Fatalf("method call without receiver: %+v", n)
+               }
+               as.Rhs.Append(sel.X)
+       }
+       as.Rhs.Append(n.Args...)
+
+       // For non-dotted calls to variadic functions, we assign the
+       // variadic parameter's temp name separately.
+       var vas *ir.AssignStmt
+
+       if recv := fn.Type().Recv(); recv != nil {
+               as.Lhs.Append(inlParam(recv, as, inlvars))
+       }
+       for _, param := range fn.Type().Params().Fields().Slice() {
+               // For ordinary parameters or variadic parameters in
+               // dotted calls, just add the variable to the
+               // assignment list, and we're done.
+               if !param.IsDDD() || n.IsDDD {
+                       as.Lhs.Append(inlParam(param, as, inlvars))
+                       continue
+               }
+
+               // Otherwise, we need to collect the remaining values
+               // to pass as a slice.
+
+               x := len(as.Lhs)
+               for len(as.Lhs) < len(as.Rhs) {
+                       as.Lhs.Append(argvar(param.Type, len(as.Lhs)))
+               }
+               varargs := as.Lhs[x:]
+
+               vas = ir.NewAssignStmt(base.Pos, nil, nil)
+               vas.X = inlParam(param, vas, inlvars)
+               if len(varargs) == 0 {
+                       vas.Y = typecheck.NodNil()
+                       vas.Y.SetType(param.Type)
+               } else {
+                       lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type), nil)
+                       lit.List = varargs
+                       vas.Y = lit
+               }
+       }
+
+       if len(as.Rhs) != 0 {
+               ninit.Append(typecheck.Stmt(as))
+       }
+
+       if vas != nil {
+               ninit.Append(typecheck.Stmt(vas))
+       }
+
+       if !delayretvars {
+               // Zero the return parameters.
+               for _, n := range retvars {
+                       ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
+                       ras := ir.NewAssignStmt(base.Pos, n, nil)
+                       ninit.Append(typecheck.Stmt(ras))
+               }
+       }
+
+       retlabel := typecheck.AutoLabel(".i")
+
+       inlgen++
+
+       parent := -1
+       if b := base.Ctxt.PosTable.Pos(n.Pos()).Base(); b != nil {
+               parent = b.InliningIndex()
+       }
+
+       sym := fn.Linksym()
+       newIndex := base.Ctxt.InlTree.Add(parent, n.Pos(), sym)
+
+       // Add an inline mark just before the inlined body.
+       // This mark is inline in the code so that it's a reasonable spot
+       // to put a breakpoint. Not sure if that's really necessary or not
+       // (in which case it could go at the end of the function instead).
+       // Note issue 28603.
+       inlMark := ir.NewInlineMarkStmt(base.Pos, types.BADWIDTH)
+       inlMark.SetPos(n.Pos().WithIsStmt())
+       inlMark.Index = int64(newIndex)
+       ninit.Append(inlMark)
+
+       if base.Flag.GenDwarfInl > 0 {
+               if !sym.WasInlined() {
+                       base.Ctxt.DwFixups.SetPrecursorFunc(sym, fn)
+                       sym.Set(obj.AttrWasInlined, true)
+               }
+       }
+
+       subst := inlsubst{
+               retlabel:     retlabel,
+               retvars:      retvars,
+               delayretvars: delayretvars,
+               inlvars:      inlvars,
+               bases:        make(map[*src.PosBase]*src.PosBase),
+               newInlIndex:  newIndex,
+               fn:           fn,
+       }
+       subst.edit = subst.node
+
+       body := subst.list(ir.Nodes(fn.Inl.Body))
+
+       lab := ir.NewLabelStmt(base.Pos, retlabel)
+       body = append(body, lab)
+
+       typecheck.Stmts(body)
+
+       if base.Flag.GenDwarfInl > 0 {
+               for _, v := range inlfvars {
+                       v.SetPos(subst.updatedPos(v.Pos()))
+               }
+       }
+
+       //dumplist("ninit post", ninit);
+
+       call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
+       *call.PtrInit() = ninit
+       call.Body = body
+       call.ReturnVars = retvars
+       call.SetType(n.Type())
+       call.SetTypecheck(1)
+
+       // transitive inlining
+       // might be nice to do this before exporting the body,
+       // but can't emit the body with inlining expanded.
+       // instead we emit the things that the body needs
+       // and each use must redo the inlining.
+       // luckily these are small.
+       ir.EditChildren(call, edit)
+
+       if base.Flag.LowerM > 2 {
+               fmt.Printf("%v: After inlining %+v\n\n", ir.Line(call), call)
+       }
+
+       return call
+}
+
+// Every time we expand a function we generate a new set of tmpnames,
+// PAUTO's in the calling functions, and link them off of the
+// PPARAM's, PAUTOS and PPARAMOUTs of the called function.
+func inlvar(var_ *ir.Name) *ir.Name {
+       if base.Flag.LowerM > 3 {
+               fmt.Printf("inlvar %+v\n", var_)
+       }
+
+       n := typecheck.NewName(var_.Sym())
+       n.SetType(var_.Type())
+       n.Class = ir.PAUTO
+       n.SetUsed(true)
+       n.Curfn = ir.CurFunc // the calling function, not the called one
+       n.SetAddrtaken(var_.Addrtaken())
+
+       ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
+       return n
+}
+
+// Synthesize a variable to store the inlined function's results in.
+func retvar(t *types.Field, i int) *ir.Name {
+       n := typecheck.NewName(typecheck.LookupNum("~R", i))
+       n.SetType(t.Type)
+       n.Class = ir.PAUTO
+       n.SetUsed(true)
+       n.Curfn = ir.CurFunc // the calling function, not the called one
+       ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
+       return n
+}
+
+// Synthesize a variable to store the inlined function's arguments
+// when they come from a multiple return call.
+func argvar(t *types.Type, i int) ir.Node {
+       n := typecheck.NewName(typecheck.LookupNum("~arg", i))
+       n.SetType(t.Elem())
+       n.Class = ir.PAUTO
+       n.SetUsed(true)
+       n.Curfn = ir.CurFunc // the calling function, not the called one
+       ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
+       return n
+}
+
+// The inlsubst type implements the actual inlining of a single
+// function call.
+type inlsubst struct {
+       // Target of the goto substituted in place of a return.
+       retlabel *types.Sym
+
+       // Temporary result variables.
+       retvars []ir.Node
+
+       // Whether result variables should be initialized at the
+       // "return" statement.
+       delayretvars bool
+
+       inlvars map[*ir.Name]*ir.Name
+
+       // bases maps from original PosBase to PosBase with an extra
+       // inlined call frame.
+       bases map[*src.PosBase]*src.PosBase
+
+       // newInlIndex is the index of the inlined call frame to
+       // insert for inlined nodes.
+       newInlIndex int
+
+       edit func(ir.Node) ir.Node // cached copy of subst.node method value closure
+
+       // If non-nil, we are inside a closure inside the inlined function, and
+       // newclofn is the Func of the new inlined closure.
+       newclofn *ir.Func
+
+       fn *ir.Func // For debug -- the func that is being inlined
+}
+
+// list inlines a list of nodes.
+func (subst *inlsubst) list(ll ir.Nodes) []ir.Node {
+       s := make([]ir.Node, 0, len(ll))
+       for _, n := range ll {
+               s = append(s, subst.node(n))
+       }
+       return s
+}
+
+// fields returns a list of the fields of a struct type representing receiver,
+// params, or results, after duplicating the field nodes and substituting the
+// Nname nodes inside the field nodes.
+func (subst *inlsubst) fields(oldt *types.Type) []*types.Field {
+       oldfields := oldt.FieldSlice()
+       newfields := make([]*types.Field, len(oldfields))
+       for i := range oldfields {
+               newfields[i] = oldfields[i].Copy()
+               if oldfields[i].Nname != nil {
+                       newfields[i].Nname = subst.node(oldfields[i].Nname.(*ir.Name))
+               }
+       }
+       return newfields
+}
+
+// clovar creates a new ONAME node for a local variable or param of a closure
+// inside a function being inlined.
+func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
+       // TODO(danscales): want to get rid of this shallow copy, with code like the
+       // following, but it is hard to copy all the necessary flags in a maintainable way.
+       // m := ir.NewNameAt(n.Pos(), n.Sym())
+       // m.Class = n.Class
+       // m.SetType(n.Type())
+       // m.SetTypecheck(1)
+       //if n.IsClosureVar() {
+       //      m.SetIsClosureVar(true)
+       //}
+       m := &ir.Name{}
+       *m = *n
+       m.Curfn = subst.newclofn
+       if n.Defn != nil && n.Defn.Op() == ir.ONAME {
+               if !n.IsClosureVar() {
+                       base.FatalfAt(n.Pos(), "want closure variable, got: %+v", n)
+               }
+               if n.Sym().Pkg != types.LocalPkg {
+                       // If the closure came from inlining a function from
+                       // another package, must change package of captured
+                       // variable to localpkg, so that the fields of the closure
+                       // struct are local package and can be accessed even if
+                       // name is not exported. If you disable this code, you can
+                       // reproduce the problem by running 'go test
+                       // go/internal/srcimporter'. TODO(mdempsky) - maybe change
+                       // how we create closure structs?
+                       m.SetSym(types.LocalPkg.Lookup(n.Sym().Name))
+               }
+               // Make sure any inlvar which is the Defn
+               // of an ONAME closure var is rewritten
+               // during inlining. Don't substitute
+               // if Defn node is outside inlined function.
+               if subst.inlvars[n.Defn.(*ir.Name)] != nil {
+                       m.Defn = subst.node(n.Defn)
+               }
+       }
+       if n.Outer != nil {
+               // Either the outer variable is defined in function being inlined,
+               // and we will replace it with the substituted variable, or it is
+               // defined outside the function being inlined, and we should just
+               // skip the outer variable (the closure variable of the function
+               // being inlined).
+               s := subst.node(n.Outer).(*ir.Name)
+               if s == n.Outer {
+                       s = n.Outer.Outer
+               }
+               m.Outer = s
+       }
+       return m
+}
+
+// closure does the necessary substitions for a ClosureExpr n and returns the new
+// closure node.
+func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node {
+       m := ir.Copy(n)
+       m.SetPos(subst.updatedPos(m.Pos()))
+       ir.EditChildren(m, subst.edit)
+
+       //fmt.Printf("Inlining func %v with closure into %v\n", subst.fn, ir.FuncName(ir.CurFunc))
+
+       // The following is similar to funcLit
+       oldfn := n.Func
+       newfn := ir.NewFunc(oldfn.Pos())
+       // These three lines are not strictly necessary, but just to be clear
+       // that new function needs to redo typechecking and inlinability.
+       newfn.SetTypecheck(0)
+       newfn.SetInlinabilityChecked(false)
+       newfn.Inl = nil
+       newfn.SetIsHiddenClosure(true)
+       newfn.Nname = ir.NewNameAt(n.Pos(), ir.BlankNode.Sym())
+       newfn.Nname.Func = newfn
+       newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+       newfn.Nname.Defn = newfn
+
+       m.(*ir.ClosureExpr).Func = newfn
+       newfn.OClosure = m.(*ir.ClosureExpr)
+
+       if subst.newclofn != nil {
+               //fmt.Printf("Inlining a closure with a nested closure\n")
+       }
+       prevxfunc := subst.newclofn
+
+       // Mark that we are now substituting within a closure (within the
+       // inlined function), and create new nodes for all the local
+       // vars/params inside this closure.
+       subst.newclofn = newfn
+       newfn.Dcl = nil
+       newfn.ClosureVars = nil
+       for _, oldv := range oldfn.Dcl {
+               newv := subst.clovar(oldv)
+               subst.inlvars[oldv] = newv
+               newfn.Dcl = append(newfn.Dcl, newv)
+       }
+       for _, oldv := range oldfn.ClosureVars {
+               newv := subst.clovar(oldv)
+               subst.inlvars[oldv] = newv
+               newfn.ClosureVars = append(newfn.ClosureVars, newv)
+       }
+
+       // Need to replace ONAME nodes in
+       // newfn.Type().FuncType().Receiver/Params/Results.FieldSlice().Nname
+       oldt := oldfn.Type()
+       newrecvs := subst.fields(oldt.Recvs())
+       var newrecv *types.Field
+       if len(newrecvs) > 0 {
+               newrecv = newrecvs[0]
+       }
+       newt := types.NewSignature(oldt.Pkg(), newrecv,
+               subst.fields(oldt.Params()), subst.fields(oldt.Results()))
+
+       newfn.Nname.SetType(newt)
+       newfn.Body = subst.list(oldfn.Body)
+
+       // Remove the nodes for the current closure from subst.inlvars
+       for _, oldv := range oldfn.Dcl {
+               delete(subst.inlvars, oldv)
+       }
+       for _, oldv := range oldfn.ClosureVars {
+               delete(subst.inlvars, oldv)
+       }
+       // Go back to previous closure func
+       subst.newclofn = prevxfunc
+
+       // Actually create the named function for the closure, now that
+       // the closure is inlined in a specific function.
+       m.SetTypecheck(0)
+       if oldfn.ClosureCalled() {
+               typecheck.Callee(m)
+       } else {
+               typecheck.Expr(m)
+       }
+       return m
+}
+
+// node recursively copies a node from the saved pristine body of the
+// inlined function, substituting references to input/output
+// parameters with ones to the tmpnames, and substituting returns with
+// assignments to the output.
+func (subst *inlsubst) node(n ir.Node) ir.Node {
+       if n == nil {
+               return nil
+       }
+
+       switch n.Op() {
+       case ir.ONAME:
+               n := n.(*ir.Name)
+
+               // Handle captured variables when inlining closures.
+               if n.IsClosureVar() && subst.newclofn == nil {
+                       o := n.Outer
+
+                       // Deal with case where sequence of closures are inlined.
+                       // TODO(danscales) - write test case to see if we need to
+                       // go up multiple levels.
+                       if o.Curfn != ir.CurFunc {
+                               o = o.Outer
+                       }
+
+                       // make sure the outer param matches the inlining location
+                       if o == nil || o.Curfn != ir.CurFunc {
+                               base.Fatalf("%v: unresolvable capture %v\n", ir.Line(n), n)
+                       }
+
+                       if base.Flag.LowerM > 2 {
+                               fmt.Printf("substituting captured name %+v  ->  %+v\n", n, o)
+                       }
+                       return o
+               }
+
+               if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
+                       if base.Flag.LowerM > 2 {
+                               fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
+                       }
+                       return inlvar
+               }
+
+               if base.Flag.LowerM > 2 {
+                       fmt.Printf("not substituting name %+v\n", n)
+               }
+               return n
+
+       case ir.OMETHEXPR:
+               n := n.(*ir.SelectorExpr)
+               return n
+
+       case ir.OLITERAL, ir.ONIL, ir.OTYPE:
+               // If n is a named constant or type, we can continue
+               // using it in the inline copy. Otherwise, make a copy
+               // so we can update the line number.
+               if n.Sym() != nil {
+                       return n
+               }
+
+       case ir.ORETURN:
+               if subst.newclofn != nil {
+                       // Don't do special substitutions if inside a closure
+                       break
+               }
+               // Since we don't handle bodies with closures,
+               // this return is guaranteed to belong to the current inlined function.
+               n := n.(*ir.ReturnStmt)
+               init := subst.list(n.Init())
+               if len(subst.retvars) != 0 && len(n.Results) != 0 {
+                       as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+
+                       // Make a shallow copy of retvars.
+                       // Otherwise OINLCALL.Rlist will be the same list,
+                       // and later walk and typecheck may clobber it.
+                       for _, n := range subst.retvars {
+                               as.Lhs.Append(n)
+                       }
+                       as.Rhs = subst.list(n.Results)
+
+                       if subst.delayretvars {
+                               for _, n := range as.Lhs {
+                                       as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
+                                       n.Name().Defn = as
+                               }
+                       }
+
+                       init = append(init, typecheck.Stmt(as))
+               }
+               init = append(init, ir.NewBranchStmt(base.Pos, ir.OGOTO, subst.retlabel))
+               typecheck.Stmts(init)
+               return ir.NewBlockStmt(base.Pos, init)
+
+       case ir.OGOTO:
+               n := n.(*ir.BranchStmt)
+               m := ir.Copy(n).(*ir.BranchStmt)
+               m.SetPos(subst.updatedPos(m.Pos()))
+               *m.PtrInit() = nil
+               p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
+               m.Label = typecheck.Lookup(p)
+               return m
+
+       case ir.OLABEL:
+               if subst.newclofn != nil {
+                       // Don't do special substitutions if inside a closure
+                       break
+               }
+               n := n.(*ir.LabelStmt)
+               m := ir.Copy(n).(*ir.LabelStmt)
+               m.SetPos(subst.updatedPos(m.Pos()))
+               *m.PtrInit() = nil
+               p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
+               m.Label = typecheck.Lookup(p)
+               return m
+
+       case ir.OCLOSURE:
+               return subst.closure(n.(*ir.ClosureExpr))
+
+       }
+
+       m := ir.Copy(n)
+       m.SetPos(subst.updatedPos(m.Pos()))
+       ir.EditChildren(m, subst.edit)
+       return m
+}
+
+func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
+       pos := base.Ctxt.PosTable.Pos(xpos)
+       oldbase := pos.Base() // can be nil
+       newbase := subst.bases[oldbase]
+       if newbase == nil {
+               newbase = src.NewInliningBase(oldbase, subst.newInlIndex)
+               subst.bases[oldbase] = newbase
+       }
+       pos.SetBase(newbase)
+       return base.Ctxt.PosTable.XPos(pos)
+}
+
+func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
+       s := make([]*ir.Name, 0, len(ll))
+       for _, n := range ll {
+               if n.Class == ir.PAUTO {
+                       if !vis.usedLocals.Has(n) {
+                               continue
+                       }
+               }
+               s = append(s, n)
+       }
+       return s
+}
+
+// numNonClosures returns the number of functions in list which are not closures.
+func numNonClosures(list []*ir.Func) int {
+       count := 0
+       for _, fn := range list {
+               if fn.OClosure == nil {
+                       count++
+               }
+       }
+       return count
+}
+
+func doList(list []ir.Node, do func(ir.Node) bool) bool {
+       for _, x := range list {
+               if x != nil {
+                       if do(x) {
+                               return true
+                       }
+               }
+       }
+       return false
+}

diff --git a/src/cmd/compile/internal/gc/bitset.go b/src/cmd/compile/internal/ir/bitset.go
similarity index 79%
rename from src/cmd/compile/internal/gc/bitset.go
rename to src/cmd/compile/internal/ir/bitset.go
index ed5eea0a11be9a559b2b237ba9c0c8db88706804..0c7bd542f60bbcdf31949dd53a4fe88d6fd21e42 100644 (file)
--- a/src/cmd/compile/internal/gc/bitset.go
+++ b/src/cmd/compile/internal/ir/bitset.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 type bitset8 uint8
 
@@ -14,6 +14,18 @@ func (f *bitset8) set(mask uint8, b bool) {
        }
 }
 
+func (f bitset8) get2(shift uint8) uint8 {
+       return uint8(f>>shift) & 3
+}
+
+// set2 sets two bits in f using the bottom two bits of b.
+func (f *bitset8) set2(shift uint8, b uint8) {
+       // Clear old bits.
+       *(*uint8)(f) &^= 3 << shift
+       // Set new bits.
+       *(*uint8)(f) |= uint8(b&3) << shift
+}
+
 type bitset16 uint16
 
 func (f *bitset16) set(mask uint16, b bool) {

diff --git a/src/cmd/compile/internal/ir/cfg.go b/src/cmd/compile/internal/ir/cfg.go
new file mode 100644 (file)
index 0000000..d986ac3
--- /dev/null
+++ b/src/cmd/compile/internal/ir/cfg.go
@@ -0,0 +1,26 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+var (
+       // maximum size variable which we will allocate on the stack.
+       // This limit is for explicit variable declarations like "var x T" or "x := ...".
+       // Note: the flag smallframes can update this value.
+       MaxStackVarSize = int64(10 * 1024 * 1024)
+
+       // maximum size of implicit variables that we will allocate on the stack.
+       //   p := new(T)          allocating T on the stack
+       //   p := &T{}            allocating T on the stack
+       //   s := make([]T, n)    allocating [n]T on the stack
+       //   s := []byte("...")   allocating [n]byte on the stack
+       // Note: the flag smallframes can update this value.
+       MaxImplicitStackVarSize = int64(64 * 1024)
+
+       // MaxSmallArraySize is the maximum size of an array which is considered small.
+       // Small arrays will be initialized directly with a sequence of constant stores.
+       // Large arrays will be initialized by copying from a static temp.
+       // 256 bytes was chosen to minimize generated code + statictmp size.
+       MaxSmallArraySize = int64(256)
+)

diff --git a/src/cmd/compile/internal/gc/class_string.go b/src/cmd/compile/internal/ir/class_string.go
similarity index 89%
rename from src/cmd/compile/internal/gc/class_string.go
rename to src/cmd/compile/internal/ir/class_string.go
index a4084a7535209505093583c7b2745520c68772fd..13b9bd4812cce0e644924d3afae08c452cb1a3f9 100644 (file)
--- a/src/cmd/compile/internal/gc/class_string.go
+++ b/src/cmd/compile/internal/ir/class_string.go
@@ -1,6 +1,6 @@
-// Code generated by "stringer -type=Class"; DO NOT EDIT.
+// Code generated by "stringer -type=Class name.go"; DO NOT EDIT.
 
-package gc
+package ir
 
 import "strconv"
 

diff --git a/src/cmd/compile/internal/ir/const.go b/src/cmd/compile/internal/ir/const.go
new file mode 100644 (file)
index 0000000..eaa4d5b
--- /dev/null
+++ b/src/cmd/compile/internal/ir/const.go
@@ -0,0 +1,99 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "go/constant"
+       "math"
+       "math/big"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+)
+
+func NewBool(b bool) Node {
+       return NewLiteral(constant.MakeBool(b))
+}
+
+func NewInt(v int64) Node {
+       return NewLiteral(constant.MakeInt64(v))
+}
+
+func NewString(s string) Node {
+       return NewLiteral(constant.MakeString(s))
+}
+
+const (
+       // Maximum size in bits for big.Ints before signalling
+       // overflow and also mantissa precision for big.Floats.
+       ConstPrec = 512
+)
+
+func BigFloat(v constant.Value) *big.Float {
+       f := new(big.Float)
+       f.SetPrec(ConstPrec)
+       switch u := constant.Val(v).(type) {
+       case int64:
+               f.SetInt64(u)
+       case *big.Int:
+               f.SetInt(u)
+       case *big.Float:
+               f.Set(u)
+       case *big.Rat:
+               f.SetRat(u)
+       default:
+               base.Fatalf("unexpected: %v", u)
+       }
+       return f
+}
+
+// ConstOverflow reports whether constant value v is too large
+// to represent with type t.
+func ConstOverflow(v constant.Value, t *types.Type) bool {
+       switch {
+       case t.IsInteger():
+               bits := uint(8 * t.Size())
+               if t.IsUnsigned() {
+                       x, ok := constant.Uint64Val(v)
+                       return !ok || x>>bits != 0
+               }
+               x, ok := constant.Int64Val(v)
+               if x < 0 {
+                       x = ^x
+               }
+               return !ok || x>>(bits-1) != 0
+       case t.IsFloat():
+               switch t.Size() {
+               case 4:
+                       f, _ := constant.Float32Val(v)
+                       return math.IsInf(float64(f), 0)
+               case 8:
+                       f, _ := constant.Float64Val(v)
+                       return math.IsInf(f, 0)
+               }
+       case t.IsComplex():
+               ft := types.FloatForComplex(t)
+               return ConstOverflow(constant.Real(v), ft) || ConstOverflow(constant.Imag(v), ft)
+       }
+       base.Fatalf("ConstOverflow: %v, %v", v, t)
+       panic("unreachable")
+}
+
+// IsConstNode reports whether n is a Go language constant (as opposed to a
+// compile-time constant).
+//
+// Expressions derived from nil, like string([]byte(nil)), while they
+// may be known at compile time, are not Go language constants.
+func IsConstNode(n Node) bool {
+       return n.Op() == OLITERAL
+}
+
+func IsSmallIntConst(n Node) bool {
+       if n.Op() == OLITERAL {
+               v, ok := constant.Int64Val(n.Val())
+               return ok && int64(int32(v)) == v
+       }
+       return false
+}

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
new file mode 100644 (file)
index 0000000..7da9b24
--- /dev/null
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -0,0 +1,102 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/internal/src"
+)
+
+// A Node may implement the Orig and SetOrig method to
+// maintain a pointer to the "unrewritten" form of a Node.
+// If a Node does not implement OrigNode, it is its own Orig.
+//
+// Note that both SepCopy and Copy have definitions compatible
+// with a Node that does not implement OrigNode: such a Node
+// is its own Orig, and in that case, that's what both want to return
+// anyway (SepCopy unconditionally, and Copy only when the input
+// is its own Orig as well, but if the output does not implement
+// OrigNode, then neither does the input, making the condition true).
+type OrigNode interface {
+       Node
+       Orig() Node
+       SetOrig(Node)
+}
+
+// origNode may be embedded into a Node to make it implement OrigNode.
+type origNode struct {
+       orig Node `mknode:"-"`
+}
+
+func (n *origNode) Orig() Node     { return n.orig }
+func (n *origNode) SetOrig(o Node) { n.orig = o }
+
+// Orig returns the “original” node for n.
+// If n implements OrigNode, Orig returns n.Orig().
+// Otherwise Orig returns n itself.
+func Orig(n Node) Node {
+       if n, ok := n.(OrigNode); ok {
+               o := n.Orig()
+               if o == nil {
+                       Dump("Orig nil", n)
+                       base.Fatalf("Orig returned nil")
+               }
+               return o
+       }
+       return n
+}
+
+// SepCopy returns a separate shallow copy of n,
+// breaking any Orig link to any other nodes.
+func SepCopy(n Node) Node {
+       n = n.copy()
+       if n, ok := n.(OrigNode); ok {
+               n.SetOrig(n)
+       }
+       return n
+}
+
+// Copy returns a shallow copy of n.
+// If Orig(n) == n, then Orig(Copy(n)) == the copy.
+// Otherwise the Orig link is preserved as well.
+//
+// The specific semantics surrounding Orig are subtle but right for most uses.
+// See issues #26855 and #27765 for pitfalls.
+func Copy(n Node) Node {
+       c := n.copy()
+       if n, ok := n.(OrigNode); ok && n.Orig() == n {
+               c.(OrigNode).SetOrig(c)
+       }
+       return c
+}
+
+// DeepCopy returns a “deep” copy of n, with its entire structure copied
+// (except for shared nodes like ONAME, ONONAME, OLITERAL, and OTYPE).
+// If pos.IsKnown(), it sets the source position of newly allocated Nodes to pos.
+func DeepCopy(pos src.XPos, n Node) Node {
+       var edit func(Node) Node
+       edit = func(x Node) Node {
+               switch x.Op() {
+               case OPACK, ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
+                       return x
+               }
+               x = Copy(x)
+               if pos.IsKnown() {
+                       x.SetPos(pos)
+               }
+               EditChildren(x, edit)
+               return x
+       }
+       return edit(n)
+}
+
+// DeepCopyList returns a list of deep copies (using DeepCopy) of the nodes in list.
+func DeepCopyList(pos src.XPos, list []Node) []Node {
+       var out []Node
+       for _, n := range list {
+               out = append(out, DeepCopy(pos, n))
+       }
+       return out
+}

diff --git a/src/cmd/compile/internal/gc/dump.go b/src/cmd/compile/internal/ir/dump.go
similarity index 91%
rename from src/cmd/compile/internal/gc/dump.go
rename to src/cmd/compile/internal/ir/dump.go
index 29eb1c1e48b6cf9f7b165c2ce6331b74352ace4e..fc995cee6202f0107a0c98e400000080ea58ace9 100644 (file)
--- a/src/cmd/compile/internal/gc/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -6,21 +6,23 @@
 // for debugging purposes. The code is customized for Node graphs
 // and may be used for an alternative view of the node structure.
 
-package gc
+package ir
 
 import (
-       "cmd/compile/internal/types"
-       "cmd/internal/src"
        "fmt"
        "io"
        "os"
        "reflect"
        "regexp"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
 )
 
 // dump is like fdump but prints to stderr.
-func dump(root interface{}, filter string, depth int) {
-       fdump(os.Stderr, root, filter, depth)
+func DumpAny(root interface{}, filter string, depth int) {
+       FDumpAny(os.Stderr, root, filter, depth)
 }
 
 // fdump prints the structure of a rooted data structure
@@ -40,7 +42,7 @@ func dump(root interface{}, filter string, depth int) {
 // rather than their type; struct fields with zero values or
 // non-matching field names are omitted, and "…" means recursion
 // depth has been reached or struct fields have been omitted.
-func fdump(w io.Writer, root interface{}, filter string, depth int) {
+func FDumpAny(w io.Writer, root interface{}, filter string, depth int) {
        if root == nil {
                fmt.Fprintln(w, "nil")
                return
@@ -138,19 +140,9 @@ func (p *dumper) dump(x reflect.Value, depth int) {
                return
        }
 
-       // special cases
-       switch v := x.Interface().(type) {
-       case Nodes:
-               // unpack Nodes since reflect cannot look inside
-               // due to the unexported field in its struct
-               x = reflect.ValueOf(v.Slice())
-
-       case src.XPos:
-               p.printf("%s", linestr(v))
+       if pos, ok := x.Interface().(src.XPos); ok {
+               p.printf("%s", base.FmtPos(pos))
                return
-
-       case *types.Node:
-               x = reflect.ValueOf(asNode(v))
        }
 
        switch x.Kind() {
@@ -203,7 +195,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
                isNode := false
                if n, ok := x.Interface().(Node); ok {
                        isNode = true
-                       p.printf("%s %s {", n.Op.String(), p.addr(x))
+                       p.printf("%s %s {", n.Op().String(), p.addr(x))
                } else {
                        p.printf("%s {", typ)
                }
@@ -230,7 +222,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
                                        omitted = true
                                        continue // exclude zero-valued fields
                                }
-                               if n, ok := x.Interface().(Nodes); ok && n.Len() == 0 {
+                               if n, ok := x.Interface().(Nodes); ok && len(n) == 0 {
                                        omitted = true
                                        continue // exclude empty Nodes slices
                                }

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
new file mode 100644 (file)
index 0000000..b32ed71
--- /dev/null
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -0,0 +1,1057 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "bytes"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+       "fmt"
+       "go/constant"
+       "go/token"
+)
+
+// An Expr is a Node that can appear as an expression.
+type Expr interface {
+       Node
+       isExpr()
+}
+
+// A miniExpr is a miniNode with extra fields common to expressions.
+// TODO(rsc): Once we are sure about the contents, compact the bools
+// into a bit field and leave extra bits available for implementations
+// embedding miniExpr. Right now there are ~60 unused bits sitting here.
+type miniExpr struct {
+       miniNode
+       typ   *types.Type
+       init  Nodes // TODO(rsc): Don't require every Node to have an init
+       flags bitset8
+}
+
+const (
+       miniExprNonNil = 1 << iota
+       miniExprTransient
+       miniExprBounded
+       miniExprImplicit // for use by implementations; not supported by every Expr
+       miniExprCheckPtr
+)
+
+func (*miniExpr) isExpr() {}
+
+func (n *miniExpr) Type() *types.Type     { return n.typ }
+func (n *miniExpr) SetType(x *types.Type) { n.typ = x }
+func (n *miniExpr) NonNil() bool          { return n.flags&miniExprNonNil != 0 }
+func (n *miniExpr) MarkNonNil()           { n.flags |= miniExprNonNil }
+func (n *miniExpr) Transient() bool       { return n.flags&miniExprTransient != 0 }
+func (n *miniExpr) SetTransient(b bool)   { n.flags.set(miniExprTransient, b) }
+func (n *miniExpr) Bounded() bool         { return n.flags&miniExprBounded != 0 }
+func (n *miniExpr) SetBounded(b bool)     { n.flags.set(miniExprBounded, b) }
+func (n *miniExpr) Init() Nodes           { return n.init }
+func (n *miniExpr) PtrInit() *Nodes       { return &n.init }
+func (n *miniExpr) SetInit(x Nodes)       { n.init = x }
+
+// An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
+type AddStringExpr struct {
+       miniExpr
+       List     Nodes
+       Prealloc *Name
+}
+
+func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
+       n := &AddStringExpr{}
+       n.pos = pos
+       n.op = OADDSTR
+       n.List = list
+       return n
+}
+
+// An AddrExpr is an address-of expression &X.
+// It may end up being a normal address-of or an allocation of a composite literal.
+type AddrExpr struct {
+       miniExpr
+       X        Node
+       Prealloc *Name // preallocated storage if any
+}
+
+func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
+       n := &AddrExpr{X: x}
+       n.op = OADDR
+       n.pos = pos
+       return n
+}
+
+func (n *AddrExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *AddrExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+
+func (n *AddrExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OADDR, OPTRLIT:
+               n.op = op
+       }
+}
+
+// A BasicLit is a literal of basic type.
+type BasicLit struct {
+       miniExpr
+       val constant.Value
+}
+
+func NewBasicLit(pos src.XPos, val constant.Value) Node {
+       n := &BasicLit{val: val}
+       n.op = OLITERAL
+       n.pos = pos
+       if k := val.Kind(); k != constant.Unknown {
+               n.SetType(idealType(k))
+       }
+       return n
+}
+
+func (n *BasicLit) Val() constant.Value       { return n.val }
+func (n *BasicLit) SetVal(val constant.Value) { n.val = val }
+
+// A BinaryExpr is a binary expression X Op Y,
+// or Op(X, Y) for builtin functions that do not become calls.
+type BinaryExpr struct {
+       miniExpr
+       X Node
+       Y Node
+}
+
+func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
+       n := &BinaryExpr{X: x, Y: y}
+       n.pos = pos
+       n.SetOp(op)
+       return n
+}
+
+func (n *BinaryExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OADD, OADDSTR, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
+               OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
+               OCOPY, OCOMPLEX,
+               OEFACE:
+               n.op = op
+       }
+}
+
+// A CallUse records how the result of the call is used:
+type CallUse byte
+
+const (
+       _ CallUse = iota
+
+       CallUseExpr // single expression result is used
+       CallUseList // list of results are used
+       CallUseStmt // results not used - call is a statement
+)
+
+// A CallExpr is a function call X(Args).
+type CallExpr struct {
+       miniExpr
+       origNode
+       X         Node
+       Args      Nodes
+       KeepAlive []*Name // vars to be kept alive until call returns
+       IsDDD     bool
+       Use       CallUse
+       NoInline  bool
+}
+
+func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
+       n := &CallExpr{X: fun}
+       n.pos = pos
+       n.orig = n
+       n.SetOp(op)
+       n.Args = args
+       return n
+}
+
+func (*CallExpr) isStmt() {}
+
+func (n *CallExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
+               OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
+               n.op = op
+       }
+}
+
+// A ClosureExpr is a function literal expression.
+type ClosureExpr struct {
+       miniExpr
+       Func     *Func `mknode:"-"`
+       Prealloc *Name
+}
+
+func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
+       n := &ClosureExpr{Func: fn}
+       n.op = OCLOSURE
+       n.pos = pos
+       return n
+}
+
+// A CompLitExpr is a composite literal Type{Vals}.
+// Before type-checking, the type is Ntype.
+type CompLitExpr struct {
+       miniExpr
+       origNode
+       Ntype    Ntype
+       List     Nodes // initialized values
+       Prealloc *Name
+       Len      int64 // backing array length for OSLICELIT
+}
+
+func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
+       n := &CompLitExpr{Ntype: typ}
+       n.pos = pos
+       n.SetOp(op)
+       n.List = list
+       n.orig = n
+       return n
+}
+
+func (n *CompLitExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *CompLitExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+
+func (n *CompLitExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
+               n.op = op
+       }
+}
+
+type ConstExpr struct {
+       miniExpr
+       origNode
+       val constant.Value
+}
+
+func NewConstExpr(val constant.Value, orig Node) Node {
+       n := &ConstExpr{val: val}
+       n.op = OLITERAL
+       n.pos = orig.Pos()
+       n.orig = orig
+       n.SetType(orig.Type())
+       n.SetTypecheck(orig.Typecheck())
+       n.SetDiag(orig.Diag())
+       return n
+}
+
+func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
+func (n *ConstExpr) Val() constant.Value { return n.val }
+
+// A ConvExpr is a conversion Type(X).
+// It may end up being a value or a type.
+type ConvExpr struct {
+       miniExpr
+       X Node
+}
+
+func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
+       n := &ConvExpr{X: x}
+       n.pos = pos
+       n.typ = typ
+       n.SetOp(op)
+       return n
+}
+
+func (n *ConvExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *ConvExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+func (n *ConvExpr) CheckPtr() bool     { return n.flags&miniExprCheckPtr != 0 }
+func (n *ConvExpr) SetCheckPtr(b bool) { n.flags.set(miniExprCheckPtr, b) }
+
+func (n *ConvExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, OBYTES2STRTMP, ORUNES2STR, OSTR2BYTES, OSTR2BYTESTMP, OSTR2RUNES, ORUNESTR:
+               n.op = op
+       }
+}
+
+// An IndexExpr is an index expression X[Y].
+type IndexExpr struct {
+       miniExpr
+       X        Node
+       Index    Node
+       Assigned bool
+}
+
+func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
+       n := &IndexExpr{X: x, Index: index}
+       n.pos = pos
+       n.op = OINDEX
+       return n
+}
+
+func (n *IndexExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OINDEX, OINDEXMAP:
+               n.op = op
+       }
+}
+
+// A KeyExpr is a Key: Value composite literal key.
+type KeyExpr struct {
+       miniExpr
+       Key   Node
+       Value Node
+}
+
+func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
+       n := &KeyExpr{Key: key, Value: value}
+       n.pos = pos
+       n.op = OKEY
+       return n
+}
+
+// A StructKeyExpr is an Field: Value composite literal key.
+type StructKeyExpr struct {
+       miniExpr
+       Field  *types.Sym
+       Value  Node
+       Offset int64
+}
+
+func NewStructKeyExpr(pos src.XPos, field *types.Sym, value Node) *StructKeyExpr {
+       n := &StructKeyExpr{Field: field, Value: value}
+       n.pos = pos
+       n.op = OSTRUCTKEY
+       n.Offset = types.BADWIDTH
+       return n
+}
+
+func (n *StructKeyExpr) Sym() *types.Sym { return n.Field }
+
+// An InlinedCallExpr is an inlined function call.
+type InlinedCallExpr struct {
+       miniExpr
+       Body       Nodes
+       ReturnVars Nodes
+}
+
+func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
+       n := &InlinedCallExpr{}
+       n.pos = pos
+       n.op = OINLCALL
+       n.Body = body
+       n.ReturnVars = retvars
+       return n
+}
+
+// A LogicalExpr is a expression X Op Y where Op is && or ||.
+// It is separate from BinaryExpr to make room for statements
+// that must be executed before Y but after X.
+type LogicalExpr struct {
+       miniExpr
+       X Node
+       Y Node
+}
+
+func NewLogicalExpr(pos src.XPos, op Op, x, y Node) *LogicalExpr {
+       n := &LogicalExpr{X: x, Y: y}
+       n.pos = pos
+       n.SetOp(op)
+       return n
+}
+
+func (n *LogicalExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OANDAND, OOROR:
+               n.op = op
+       }
+}
+
+// A MakeExpr is a make expression: make(Type[, Len[, Cap]]).
+// Op is OMAKECHAN, OMAKEMAP, OMAKESLICE, or OMAKESLICECOPY,
+// but *not* OMAKE (that's a pre-typechecking CallExpr).
+type MakeExpr struct {
+       miniExpr
+       Len Node
+       Cap Node
+}
+
+func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
+       n := &MakeExpr{Len: len, Cap: cap}
+       n.pos = pos
+       n.SetOp(op)
+       return n
+}
+
+func (n *MakeExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
+               n.op = op
+       }
+}
+
+// A NilExpr represents the predefined untyped constant nil.
+// (It may be copied and assigned a type, though.)
+type NilExpr struct {
+       miniExpr
+       Sym_ *types.Sym // TODO: Remove
+}
+
+func NewNilExpr(pos src.XPos) *NilExpr {
+       n := &NilExpr{}
+       n.pos = pos
+       n.op = ONIL
+       return n
+}
+
+func (n *NilExpr) Sym() *types.Sym     { return n.Sym_ }
+func (n *NilExpr) SetSym(x *types.Sym) { n.Sym_ = x }
+
+// A ParenExpr is a parenthesized expression (X).
+// It may end up being a value or a type.
+type ParenExpr struct {
+       miniExpr
+       X Node
+}
+
+func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
+       n := &ParenExpr{X: x}
+       n.op = OPAREN
+       n.pos = pos
+       return n
+}
+
+func (n *ParenExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *ParenExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+
+func (*ParenExpr) CanBeNtype() {}
+
+// SetOTYPE changes n to be an OTYPE node returning t,
+// like all the type nodes in type.go.
+func (n *ParenExpr) SetOTYPE(t *types.Type) {
+       n.op = OTYPE
+       n.typ = t
+       t.SetNod(n)
+}
+
+// A ResultExpr represents a direct access to a result slot on the stack frame.
+type ResultExpr struct {
+       miniExpr
+       Offset int64
+}
+
+func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
+       n := &ResultExpr{Offset: offset}
+       n.pos = pos
+       n.op = ORESULT
+       n.typ = typ
+       return n
+}
+
+// A LinksymOffsetExpr refers to an offset within a global variable.
+// It is like a SelectorExpr but without the field name.
+type LinksymOffsetExpr struct {
+       miniExpr
+       Linksym *obj.LSym
+       Offset_ int64
+}
+
+func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types.Type) *LinksymOffsetExpr {
+       n := &LinksymOffsetExpr{Linksym: lsym, Offset_: offset}
+       n.typ = typ
+       n.op = OLINKSYMOFFSET
+       return n
+}
+
+// NewLinksymExpr is NewLinksymOffsetExpr, but with offset fixed at 0.
+func NewLinksymExpr(pos src.XPos, lsym *obj.LSym, typ *types.Type) *LinksymOffsetExpr {
+       return NewLinksymOffsetExpr(pos, lsym, 0, typ)
+}
+
+// NewNameOffsetExpr is NewLinksymOffsetExpr, but taking a *Name
+// representing a global variable instead of an *obj.LSym directly.
+func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *LinksymOffsetExpr {
+       if name == nil || IsBlank(name) || !(name.Op() == ONAME && name.Class == PEXTERN) {
+               base.FatalfAt(pos, "cannot take offset of nil, blank name or non-global variable: %v", name)
+       }
+       return NewLinksymOffsetExpr(pos, name.Linksym(), offset, typ)
+}
+
+// A SelectorExpr is a selector expression X.Sel.
+type SelectorExpr struct {
+       miniExpr
+       X         Node
+       Sel       *types.Sym
+       Selection *types.Field
+       Prealloc  *Name // preallocated storage for OCALLPART, if any
+}
+
+func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr {
+       n := &SelectorExpr{X: x, Sel: sel}
+       n.pos = pos
+       n.SetOp(op)
+       return n
+}
+
+func (n *SelectorExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OXDOT, ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OCALLPART, OMETHEXPR:
+               n.op = op
+       }
+}
+
+func (n *SelectorExpr) Sym() *types.Sym    { return n.Sel }
+func (n *SelectorExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *SelectorExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+func (n *SelectorExpr) Offset() int64      { return n.Selection.Offset }
+
+func (n *SelectorExpr) FuncName() *Name {
+       if n.Op() != OMETHEXPR {
+               panic(n.no("FuncName"))
+       }
+       fn := NewNameAt(n.Selection.Pos, MethodSym(n.X.Type(), n.Sel))
+       fn.Class = PFUNC
+       fn.SetType(n.Type())
+       return fn
+}
+
+// Before type-checking, bytes.Buffer is a SelectorExpr.
+// After type-checking it becomes a Name.
+func (*SelectorExpr) CanBeNtype() {}
+
+// A SliceExpr is a slice expression X[Low:High] or X[Low:High:Max].
+type SliceExpr struct {
+       miniExpr
+       X    Node
+       Low  Node
+       High Node
+       Max  Node
+}
+
+func NewSliceExpr(pos src.XPos, op Op, x, low, high, max Node) *SliceExpr {
+       n := &SliceExpr{X: x, Low: low, High: high, Max: max}
+       n.pos = pos
+       n.op = op
+       return n
+}
+
+func (n *SliceExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
+               n.op = op
+       }
+}
+
+// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
+// o must be a slicing op.
+func (o Op) IsSlice3() bool {
+       switch o {
+       case OSLICE, OSLICEARR, OSLICESTR:
+               return false
+       case OSLICE3, OSLICE3ARR:
+               return true
+       }
+       base.Fatalf("IsSlice3 op %v", o)
+       return false
+}
+
+// A SliceHeader expression constructs a slice header from its parts.
+type SliceHeaderExpr struct {
+       miniExpr
+       Ptr Node
+       Len Node
+       Cap Node
+}
+
+func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr {
+       n := &SliceHeaderExpr{Ptr: ptr, Len: len, Cap: cap}
+       n.pos = pos
+       n.op = OSLICEHEADER
+       n.typ = typ
+       return n
+}
+
+// A StarExpr is a dereference expression *X.
+// It may end up being a value or a type.
+type StarExpr struct {
+       miniExpr
+       X Node
+}
+
+func NewStarExpr(pos src.XPos, x Node) *StarExpr {
+       n := &StarExpr{X: x}
+       n.op = ODEREF
+       n.pos = pos
+       return n
+}
+
+func (n *StarExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *StarExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+
+func (*StarExpr) CanBeNtype() {}
+
+// SetOTYPE changes n to be an OTYPE node returning t,
+// like all the type nodes in type.go.
+func (n *StarExpr) SetOTYPE(t *types.Type) {
+       n.op = OTYPE
+       n.X = nil
+       n.typ = t
+       t.SetNod(n)
+}
+
+// A TypeAssertionExpr is a selector expression X.(Type).
+// Before type-checking, the type is Ntype.
+type TypeAssertExpr struct {
+       miniExpr
+       X     Node
+       Ntype Ntype
+
+       // Runtime type information provided by walkDotType for
+       // assertions from non-empty interface to concrete type.
+       Itab *AddrExpr `mknode:"-"` // *runtime.itab for Type implementing X's type
+}
+
+func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
+       n := &TypeAssertExpr{X: x, Ntype: typ}
+       n.pos = pos
+       n.op = ODOTTYPE
+       return n
+}
+
+func (n *TypeAssertExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case ODOTTYPE, ODOTTYPE2:
+               n.op = op
+       }
+}
+
+// A UnaryExpr is a unary expression Op X,
+// or Op(X) for a builtin function that does not end up being a call.
+type UnaryExpr struct {
+       miniExpr
+       X Node
+}
+
+func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
+       n := &UnaryExpr{X: x}
+       n.pos = pos
+       n.SetOp(op)
+       return n
+}
+
+func (n *UnaryExpr) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
+               OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW,
+               OOFFSETOF, OPANIC, OREAL, OSIZEOF,
+               OCHECKNIL, OCFUNC, OIDATA, OITAB, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
+               n.op = op
+       }
+}
+
+func IsZero(n Node) bool {
+       switch n.Op() {
+       case ONIL:
+               return true
+
+       case OLITERAL:
+               switch u := n.Val(); u.Kind() {
+               case constant.String:
+                       return constant.StringVal(u) == ""
+               case constant.Bool:
+                       return !constant.BoolVal(u)
+               default:
+                       return constant.Sign(u) == 0
+               }
+
+       case OARRAYLIT:
+               n := n.(*CompLitExpr)
+               for _, n1 := range n.List {
+                       if n1.Op() == OKEY {
+                               n1 = n1.(*KeyExpr).Value
+                       }
+                       if !IsZero(n1) {
+                               return false
+                       }
+               }
+               return true
+
+       case OSTRUCTLIT:
+               n := n.(*CompLitExpr)
+               for _, n1 := range n.List {
+                       n1 := n1.(*StructKeyExpr)
+                       if !IsZero(n1.Value) {
+                               return false
+                       }
+               }
+               return true
+       }
+
+       return false
+}
+
+// lvalue etc
+func IsAddressable(n Node) bool {
+       switch n.Op() {
+       case OINDEX:
+               n := n.(*IndexExpr)
+               if n.X.Type() != nil && n.X.Type().IsArray() {
+                       return IsAddressable(n.X)
+               }
+               if n.X.Type() != nil && n.X.Type().IsString() {
+                       return false
+               }
+               fallthrough
+       case ODEREF, ODOTPTR:
+               return true
+
+       case ODOT:
+               n := n.(*SelectorExpr)
+               return IsAddressable(n.X)
+
+       case ONAME:
+               n := n.(*Name)
+               if n.Class == PFUNC {
+                       return false
+               }
+               return true
+
+       case OLINKSYMOFFSET:
+               return true
+       }
+
+       return false
+}
+
+func StaticValue(n Node) Node {
+       for {
+               if n.Op() == OCONVNOP {
+                       n = n.(*ConvExpr).X
+                       continue
+               }
+
+               n1 := staticValue1(n)
+               if n1 == nil {
+                       return n
+               }
+               n = n1
+       }
+}
+
+// staticValue1 implements a simple SSA-like optimization. If n is a local variable
+// that is initialized and never reassigned, staticValue1 returns the initializer
+// expression. Otherwise, it returns nil.
+func staticValue1(nn Node) Node {
+       if nn.Op() != ONAME {
+               return nil
+       }
+       n := nn.(*Name)
+       if n.Class != PAUTO {
+               return nil
+       }
+
+       defn := n.Defn
+       if defn == nil {
+               return nil
+       }
+
+       var rhs Node
+FindRHS:
+       switch defn.Op() {
+       case OAS:
+               defn := defn.(*AssignStmt)
+               rhs = defn.Y
+       case OAS2:
+               defn := defn.(*AssignListStmt)
+               for i, lhs := range defn.Lhs {
+                       if lhs == n {
+                               rhs = defn.Rhs[i]
+                               break FindRHS
+                       }
+               }
+               base.Fatalf("%v missing from LHS of %v", n, defn)
+       default:
+               return nil
+       }
+       if rhs == nil {
+               base.Fatalf("RHS is nil: %v", defn)
+       }
+
+       if reassigned(n) {
+               return nil
+       }
+
+       return rhs
+}
+
+// reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
+// indicating whether the name has any assignments other than its declaration.
+// The second return value is the first such assignment encountered in the walk, if any. It is mostly
+// useful for -m output documenting the reason for inhibited optimizations.
+// NB: global variables are always considered to be re-assigned.
+// TODO: handle initial declaration not including an assignment and followed by a single assignment?
+func reassigned(name *Name) bool {
+       if name.Op() != ONAME {
+               base.Fatalf("reassigned %v", name)
+       }
+       // no way to reliably check for no-reassignment of globals, assume it can be
+       if name.Curfn == nil {
+               return true
+       }
+
+       // TODO(mdempsky): This is inefficient and becoming increasingly
+       // unwieldy. Figure out a way to generalize escape analysis's
+       // reassignment detection for use by inlining and devirtualization.
+
+       // isName reports whether n is a reference to name.
+       isName := func(x Node) bool {
+               n, ok := x.(*Name)
+               return ok && n.Canonical() == name
+       }
+
+       var do func(n Node) bool
+       do = func(n Node) bool {
+               switch n.Op() {
+               case OAS:
+                       n := n.(*AssignStmt)
+                       if isName(n.X) && n != name.Defn {
+                               return true
+                       }
+               case OAS2, OAS2FUNC, OAS2MAPR, OAS2DOTTYPE, OAS2RECV, OSELRECV2:
+                       n := n.(*AssignListStmt)
+                       for _, p := range n.Lhs {
+                               if isName(p) && n != name.Defn {
+                                       return true
+                               }
+                       }
+               case OADDR:
+                       n := n.(*AddrExpr)
+                       if isName(OuterValue(n.X)) {
+                               return true
+                       }
+               case OCLOSURE:
+                       n := n.(*ClosureExpr)
+                       if Any(n.Func, do) {
+                               return true
+                       }
+               }
+               return false
+       }
+       return Any(name.Curfn, do)
+}
+
+// IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.
+var IsIntrinsicCall = func(*CallExpr) bool { return false }
+
+// SameSafeExpr checks whether it is safe to reuse one of l and r
+// instead of computing both. SameSafeExpr assumes that l and r are
+// used in the same statement or expression. In order for it to be
+// safe to reuse l or r, they must:
+// * be the same expression
+// * not have side-effects (no function calls, no channel ops);
+//   however, panics are ok
+// * not cause inappropriate aliasing; e.g. two string to []byte
+//   conversions, must result in two distinct slices
+//
+// The handling of OINDEXMAP is subtle. OINDEXMAP can occur both
+// as an lvalue (map assignment) and an rvalue (map access). This is
+// currently OK, since the only place SameSafeExpr gets used on an
+// lvalue expression is for OSLICE and OAPPEND optimizations, and it
+// is correct in those settings.
+func SameSafeExpr(l Node, r Node) bool {
+       if l.Op() != r.Op() || !types.Identical(l.Type(), r.Type()) {
+               return false
+       }
+
+       switch l.Op() {
+       case ONAME:
+               return l == r
+
+       case ODOT, ODOTPTR:
+               l := l.(*SelectorExpr)
+               r := r.(*SelectorExpr)
+               return l.Sel != nil && r.Sel != nil && l.Sel == r.Sel && SameSafeExpr(l.X, r.X)
+
+       case ODEREF:
+               l := l.(*StarExpr)
+               r := r.(*StarExpr)
+               return SameSafeExpr(l.X, r.X)
+
+       case ONOT, OBITNOT, OPLUS, ONEG:
+               l := l.(*UnaryExpr)
+               r := r.(*UnaryExpr)
+               return SameSafeExpr(l.X, r.X)
+
+       case OCONVNOP:
+               l := l.(*ConvExpr)
+               r := r.(*ConvExpr)
+               return SameSafeExpr(l.X, r.X)
+
+       case OCONV:
+               l := l.(*ConvExpr)
+               r := r.(*ConvExpr)
+               // Some conversions can't be reused, such as []byte(str).
+               // Allow only numeric-ish types. This is a bit conservative.
+               return types.IsSimple[l.Type().Kind()] && SameSafeExpr(l.X, r.X)
+
+       case OINDEX, OINDEXMAP:
+               l := l.(*IndexExpr)
+               r := r.(*IndexExpr)
+               return SameSafeExpr(l.X, r.X) && SameSafeExpr(l.Index, r.Index)
+
+       case OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
+               l := l.(*BinaryExpr)
+               r := r.(*BinaryExpr)
+               return SameSafeExpr(l.X, r.X) && SameSafeExpr(l.Y, r.Y)
+
+       case OLITERAL:
+               return constant.Compare(l.Val(), token.EQL, r.Val())
+
+       case ONIL:
+               return true
+       }
+
+       return false
+}
+
+// ShouldCheckPtr reports whether pointer checking should be enabled for
+// function fn at a given level. See debugHelpFooter for defined
+// levels.
+func ShouldCheckPtr(fn *Func, level int) bool {
+       return base.Debug.Checkptr >= level && fn.Pragma&NoCheckPtr == 0
+}
+
+// IsReflectHeaderDataField reports whether l is an expression p.Data
+// where p has type reflect.SliceHeader or reflect.StringHeader.
+func IsReflectHeaderDataField(l Node) bool {
+       if l.Type() != types.Types[types.TUINTPTR] {
+               return false
+       }
+
+       var tsym *types.Sym
+       switch l.Op() {
+       case ODOT:
+               l := l.(*SelectorExpr)
+               tsym = l.X.Type().Sym()
+       case ODOTPTR:
+               l := l.(*SelectorExpr)
+               tsym = l.X.Type().Elem().Sym()
+       default:
+               return false
+       }
+
+       if tsym == nil || l.Sym().Name != "Data" || tsym.Pkg.Path != "reflect" {
+               return false
+       }
+       return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
+}
+
+func ParamNames(ft *types.Type) []Node {
+       args := make([]Node, ft.NumParams())
+       for i, f := range ft.Params().FieldSlice() {
+               args[i] = AsNode(f.Nname)
+       }
+       return args
+}
+
+// MethodSym returns the method symbol representing a method name
+// associated with a specific receiver type.
+//
+// Method symbols can be used to distinguish the same method appearing
+// in different method sets. For example, T.M and (*T).M have distinct
+// method symbols.
+//
+// The returned symbol will be marked as a function.
+func MethodSym(recv *types.Type, msym *types.Sym) *types.Sym {
+       sym := MethodSymSuffix(recv, msym, "")
+       sym.SetFunc(true)
+       return sym
+}
+
+// MethodSymSuffix is like methodsym, but allows attaching a
+// distinguisher suffix. To avoid collisions, the suffix must not
+// start with a letter, number, or period.
+func MethodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym {
+       if msym.IsBlank() {
+               base.Fatalf("blank method name")
+       }
+
+       rsym := recv.Sym()
+       if recv.IsPtr() {
+               if rsym != nil {
+                       base.Fatalf("declared pointer receiver type: %v", recv)
+               }
+               rsym = recv.Elem().Sym()
+       }
+
+       // Find the package the receiver type appeared in. For
+       // anonymous receiver types (i.e., anonymous structs with
+       // embedded fields), use the "go" pseudo-package instead.
+       rpkg := Pkgs.Go
+       if rsym != nil {
+               rpkg = rsym.Pkg
+       }
+
+       var b bytes.Buffer
+       if recv.IsPtr() {
+               // The parentheses aren't really necessary, but
+               // they're pretty traditional at this point.
+               fmt.Fprintf(&b, "(%-S)", recv)
+       } else {
+               fmt.Fprintf(&b, "%-S", recv)
+       }
+
+       // A particular receiver type may have multiple non-exported
+       // methods with the same name. To disambiguate them, include a
+       // package qualifier for names that came from a different
+       // package than the receiver type.
+       if !types.IsExported(msym.Name) && msym.Pkg != rpkg {
+               b.WriteString(".")
+               b.WriteString(msym.Pkg.Prefix)
+       }
+
+       b.WriteString(".")
+       b.WriteString(msym.Name)
+       b.WriteString(suffix)
+
+       return rpkg.LookupBytes(b.Bytes())
+}
+
+// MethodName returns the ONAME representing the method
+// referenced by expression n, which must be a method selector,
+// method expression, or method value.
+func MethodExprName(n Node) *Name {
+       name, _ := MethodExprFunc(n).Nname.(*Name)
+       return name
+}
+
+// MethodFunc is like MethodName, but returns the types.Field instead.
+func MethodExprFunc(n Node) *types.Field {
+       switch n.Op() {
+       case ODOTMETH, OMETHEXPR, OCALLPART:
+               return n.(*SelectorExpr).Selection
+       }
+       base.Fatalf("unexpected node: %v (%v)", n, n.Op())
+       panic("unreachable")
+}

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
new file mode 100644 (file)
index 0000000..1a05079
--- /dev/null
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -0,0 +1,1331 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "bytes"
+       "fmt"
+       "go/constant"
+       "io"
+       "math"
+       "os"
+       "path/filepath"
+       "reflect"
+       "strings"
+
+       "unicode/utf8"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// Op
+
+var OpNames = []string{
+       OADDR:     "&",
+       OADD:      "+",
+       OADDSTR:   "+",
+       OALIGNOF:  "unsafe.Alignof",
+       OANDAND:   "&&",
+       OANDNOT:   "&^",
+       OAND:      "&",
+       OAPPEND:   "append",
+       OAS:       "=",
+       OAS2:      "=",
+       OBREAK:    "break",
+       OCALL:     "function call", // not actual syntax
+       OCAP:      "cap",
+       OCASE:     "case",
+       OCLOSE:    "close",
+       OCOMPLEX:  "complex",
+       OBITNOT:   "^",
+       OCONTINUE: "continue",
+       OCOPY:     "copy",
+       ODELETE:   "delete",
+       ODEFER:    "defer",
+       ODIV:      "/",
+       OEQ:       "==",
+       OFALL:     "fallthrough",
+       OFOR:      "for",
+       OFORUNTIL: "foruntil", // not actual syntax; used to avoid off-end pointer live on backedge.892
+       OGE:       ">=",
+       OGOTO:     "goto",
+       OGT:       ">",
+       OIF:       "if",
+       OIMAG:     "imag",
+       OINLMARK:  "inlmark",
+       ODEREF:    "*",
+       OLEN:      "len",
+       OLE:       "<=",
+       OLSH:      "<<",
+       OLT:       "<",
+       OMAKE:     "make",
+       ONEG:      "-",
+       OMOD:      "%",
+       OMUL:      "*",
+       ONEW:      "new",
+       ONE:       "!=",
+       ONOT:      "!",
+       OOFFSETOF: "unsafe.Offsetof",
+       OOROR:     "||",
+       OOR:       "|",
+       OPANIC:    "panic",
+       OPLUS:     "+",
+       OPRINTN:   "println",
+       OPRINT:    "print",
+       ORANGE:    "range",
+       OREAL:     "real",
+       ORECV:     "<-",
+       ORECOVER:  "recover",
+       ORETURN:   "return",
+       ORSH:      ">>",
+       OSELECT:   "select",
+       OSEND:     "<-",
+       OSIZEOF:   "unsafe.Sizeof",
+       OSUB:      "-",
+       OSWITCH:   "switch",
+       OXOR:      "^",
+}
+
+// GoString returns the Go syntax for the Op, or else its name.
+func (o Op) GoString() string {
+       if int(o) < len(OpNames) && OpNames[o] != "" {
+               return OpNames[o]
+       }
+       return o.String()
+}
+
+// Format implements formatting for an Op.
+// The valid formats are:
+//
+//     %v      Go syntax ("+", "<-", "print")
+//     %+v     Debug syntax ("ADD", "RECV", "PRINT")
+//
+func (o Op) Format(s fmt.State, verb rune) {
+       switch verb {
+       default:
+               fmt.Fprintf(s, "%%!%c(Op=%d)", verb, int(o))
+       case 'v':
+               if s.Flag('+') {
+                       // %+v is OMUL instead of "*"
+                       io.WriteString(s, o.String())
+                       return
+               }
+               io.WriteString(s, o.GoString())
+       }
+}
+
+// Node
+
+// FmtNode implements formatting for a Node n.
+// Every Node implementation must define a Format method that calls FmtNode.
+// The valid formats are:
+//
+//     %v      Go syntax
+//     %L      Go syntax followed by " (type T)" if type is known.
+//     %+v     Debug syntax, as in Dump.
+//
+func fmtNode(n Node, s fmt.State, verb rune) {
+       // %+v prints Dump.
+       // Otherwise we print Go syntax.
+       if s.Flag('+') && verb == 'v' {
+               dumpNode(s, n, 1)
+               return
+       }
+
+       if verb != 'v' && verb != 'S' && verb != 'L' {
+               fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
+               return
+       }
+
+       if n == nil {
+               fmt.Fprint(s, "<nil>")
+               return
+       }
+
+       t := n.Type()
+       if verb == 'L' && t != nil {
+               if t.Kind() == types.TNIL {
+                       fmt.Fprint(s, "nil")
+               } else if n.Op() == ONAME && n.Name().AutoTemp() {
+                       fmt.Fprintf(s, "%v value", t)
+               } else {
+                       fmt.Fprintf(s, "%v (type %v)", n, t)
+               }
+               return
+       }
+
+       // TODO inlining produces expressions with ninits. we can't print these yet.
+
+       if OpPrec[n.Op()] < 0 {
+               stmtFmt(n, s)
+               return
+       }
+
+       exprFmt(n, s, 0)
+}
+
+var OpPrec = []int{
+       OALIGNOF:       8,
+       OAPPEND:        8,
+       OBYTES2STR:     8,
+       OARRAYLIT:      8,
+       OSLICELIT:      8,
+       ORUNES2STR:     8,
+       OCALLFUNC:      8,
+       OCALLINTER:     8,
+       OCALLMETH:      8,
+       OCALL:          8,
+       OCAP:           8,
+       OCLOSE:         8,
+       OCOMPLIT:       8,
+       OCONVIFACE:     8,
+       OCONVNOP:       8,
+       OCONV:          8,
+       OCOPY:          8,
+       ODELETE:        8,
+       OGETG:          8,
+       OLEN:           8,
+       OLITERAL:       8,
+       OMAKESLICE:     8,
+       OMAKESLICECOPY: 8,
+       OMAKE:          8,
+       OMAPLIT:        8,
+       ONAME:          8,
+       ONEW:           8,
+       ONIL:           8,
+       ONONAME:        8,
+       OOFFSETOF:      8,
+       OPACK:          8,
+       OPANIC:         8,
+       OPAREN:         8,
+       OPRINTN:        8,
+       OPRINT:         8,
+       ORUNESTR:       8,
+       OSIZEOF:        8,
+       OSTR2BYTES:     8,
+       OSTR2RUNES:     8,
+       OSTRUCTLIT:     8,
+       OTARRAY:        8,
+       OTSLICE:        8,
+       OTCHAN:         8,
+       OTFUNC:         8,
+       OTINTER:        8,
+       OTMAP:          8,
+       OTSTRUCT:       8,
+       OTYPE:          8,
+       OINDEXMAP:      8,
+       OINDEX:         8,
+       OSLICE:         8,
+       OSLICESTR:      8,
+       OSLICEARR:      8,
+       OSLICE3:        8,
+       OSLICE3ARR:     8,
+       OSLICEHEADER:   8,
+       ODOTINTER:      8,
+       ODOTMETH:       8,
+       ODOTPTR:        8,
+       ODOTTYPE2:      8,
+       ODOTTYPE:       8,
+       ODOT:           8,
+       OXDOT:          8,
+       OCALLPART:      8,
+       OMETHEXPR:      8,
+       OPLUS:          7,
+       ONOT:           7,
+       OBITNOT:        7,
+       ONEG:           7,
+       OADDR:          7,
+       ODEREF:         7,
+       ORECV:          7,
+       OMUL:           6,
+       ODIV:           6,
+       OMOD:           6,
+       OLSH:           6,
+       ORSH:           6,
+       OAND:           6,
+       OANDNOT:        6,
+       OADD:           5,
+       OSUB:           5,
+       OOR:            5,
+       OXOR:           5,
+       OEQ:            4,
+       OLT:            4,
+       OLE:            4,
+       OGE:            4,
+       OGT:            4,
+       ONE:            4,
+       OSEND:          3,
+       OANDAND:        2,
+       OOROR:          1,
+
+       // Statements handled by stmtfmt
+       OAS:         -1,
+       OAS2:        -1,
+       OAS2DOTTYPE: -1,
+       OAS2FUNC:    -1,
+       OAS2MAPR:    -1,
+       OAS2RECV:    -1,
+       OASOP:       -1,
+       OBLOCK:      -1,
+       OBREAK:      -1,
+       OCASE:       -1,
+       OCONTINUE:   -1,
+       ODCL:        -1,
+       ODEFER:      -1,
+       OFALL:       -1,
+       OFOR:        -1,
+       OFORUNTIL:   -1,
+       OGOTO:       -1,
+       OIF:         -1,
+       OLABEL:      -1,
+       OGO:         -1,
+       ORANGE:      -1,
+       ORETURN:     -1,
+       OSELECT:     -1,
+       OSWITCH:     -1,
+
+       OEND: 0,
+}
+
+// StmtWithInit reports whether op is a statement with an explicit init list.
+func StmtWithInit(op Op) bool {
+       switch op {
+       case OIF, OFOR, OFORUNTIL, OSWITCH:
+               return true
+       }
+       return false
+}
+
+func stmtFmt(n Node, s fmt.State) {
+       // NOTE(rsc): This code used to support the text-based
+       // which was more aggressive about printing full Go syntax
+       // (for example, an actual loop instead of "for loop").
+       // The code is preserved for now in case we want to expand
+       // any of those shortenings later. Or maybe we will delete
+       // the code. But for now, keep it.
+       const exportFormat = false
+
+       // some statements allow for an init, but at most one,
+       // but we may have an arbitrary number added, eg by typecheck
+       // and inlining. If it doesn't fit the syntax, emit an enclosing
+       // block starting with the init statements.
+
+       // if we can just say "for" n->ninit; ... then do so
+       simpleinit := len(n.Init()) == 1 && len(n.Init()[0].Init()) == 0 && StmtWithInit(n.Op())
+
+       // otherwise, print the inits as separate statements
+       complexinit := len(n.Init()) != 0 && !simpleinit && exportFormat
+
+       // but if it was for if/for/switch, put in an extra surrounding block to limit the scope
+       extrablock := complexinit && StmtWithInit(n.Op())
+
+       if extrablock {
+               fmt.Fprint(s, "{")
+       }
+
+       if complexinit {
+               fmt.Fprintf(s, " %v; ", n.Init())
+       }
+
+       switch n.Op() {
+       case ODCL:
+               n := n.(*Decl)
+               fmt.Fprintf(s, "var %v %v", n.X.Sym(), n.X.Type())
+
+       // Don't export "v = <N>" initializing statements, hope they're always
+       // preceded by the DCL which will be re-parsed and typechecked to reproduce
+       // the "v = <N>" again.
+       case OAS:
+               n := n.(*AssignStmt)
+               if n.Def && !complexinit {
+                       fmt.Fprintf(s, "%v := %v", n.X, n.Y)
+               } else {
+                       fmt.Fprintf(s, "%v = %v", n.X, n.Y)
+               }
+
+       case OASOP:
+               n := n.(*AssignOpStmt)
+               if n.IncDec {
+                       if n.AsOp == OADD {
+                               fmt.Fprintf(s, "%v++", n.X)
+                       } else {
+                               fmt.Fprintf(s, "%v--", n.X)
+                       }
+                       break
+               }
+
+               fmt.Fprintf(s, "%v %v= %v", n.X, n.AsOp, n.Y)
+
+       case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+               n := n.(*AssignListStmt)
+               if n.Def && !complexinit {
+                       fmt.Fprintf(s, "%.v := %.v", n.Lhs, n.Rhs)
+               } else {
+                       fmt.Fprintf(s, "%.v = %.v", n.Lhs, n.Rhs)
+               }
+
+       case OBLOCK:
+               n := n.(*BlockStmt)
+               if len(n.List) != 0 {
+                       fmt.Fprintf(s, "%v", n.List)
+               }
+
+       case ORETURN:
+               n := n.(*ReturnStmt)
+               fmt.Fprintf(s, "return %.v", n.Results)
+
+       case OTAILCALL:
+               n := n.(*TailCallStmt)
+               fmt.Fprintf(s, "tailcall %v", n.Target)
+
+       case OINLMARK:
+               n := n.(*InlineMarkStmt)
+               fmt.Fprintf(s, "inlmark %d", n.Index)
+
+       case OGO:
+               n := n.(*GoDeferStmt)
+               fmt.Fprintf(s, "go %v", n.Call)
+
+       case ODEFER:
+               n := n.(*GoDeferStmt)
+               fmt.Fprintf(s, "defer %v", n.Call)
+
+       case OIF:
+               n := n.(*IfStmt)
+               if simpleinit {
+                       fmt.Fprintf(s, "if %v; %v { %v }", n.Init()[0], n.Cond, n.Body)
+               } else {
+                       fmt.Fprintf(s, "if %v { %v }", n.Cond, n.Body)
+               }
+               if len(n.Else) != 0 {
+                       fmt.Fprintf(s, " else { %v }", n.Else)
+               }
+
+       case OFOR, OFORUNTIL:
+               n := n.(*ForStmt)
+               opname := "for"
+               if n.Op() == OFORUNTIL {
+                       opname = "foruntil"
+               }
+               if !exportFormat { // TODO maybe only if FmtShort, same below
+                       fmt.Fprintf(s, "%s loop", opname)
+                       break
+               }
+
+               fmt.Fprint(s, opname)
+               if simpleinit {
+                       fmt.Fprintf(s, " %v;", n.Init()[0])
+               } else if n.Post != nil {
+                       fmt.Fprint(s, " ;")
+               }
+
+               if n.Cond != nil {
+                       fmt.Fprintf(s, " %v", n.Cond)
+               }
+
+               if n.Post != nil {
+                       fmt.Fprintf(s, "; %v", n.Post)
+               } else if simpleinit {
+                       fmt.Fprint(s, ";")
+               }
+
+               if n.Op() == OFORUNTIL && len(n.Late) != 0 {
+                       fmt.Fprintf(s, "; %v", n.Late)
+               }
+
+               fmt.Fprintf(s, " { %v }", n.Body)
+
+       case ORANGE:
+               n := n.(*RangeStmt)
+               if !exportFormat {
+                       fmt.Fprint(s, "for loop")
+                       break
+               }
+
+               fmt.Fprint(s, "for")
+               if n.Key != nil {
+                       fmt.Fprintf(s, " %v", n.Key)
+                       if n.Value != nil {
+                               fmt.Fprintf(s, ", %v", n.Value)
+                       }
+                       fmt.Fprint(s, " =")
+               }
+               fmt.Fprintf(s, " range %v { %v }", n.X, n.Body)
+
+       case OSELECT:
+               n := n.(*SelectStmt)
+               if !exportFormat {
+                       fmt.Fprintf(s, "%v statement", n.Op())
+                       break
+               }
+               fmt.Fprintf(s, "select { %v }", n.Cases)
+
+       case OSWITCH:
+               n := n.(*SwitchStmt)
+               if !exportFormat {
+                       fmt.Fprintf(s, "%v statement", n.Op())
+                       break
+               }
+               fmt.Fprintf(s, "switch")
+               if simpleinit {
+                       fmt.Fprintf(s, " %v;", n.Init()[0])
+               }
+               if n.Tag != nil {
+                       fmt.Fprintf(s, " %v ", n.Tag)
+               }
+               fmt.Fprintf(s, " { %v }", n.Cases)
+
+       case OCASE:
+               n := n.(*CaseClause)
+               if len(n.List) != 0 {
+                       fmt.Fprintf(s, "case %.v", n.List)
+               } else {
+                       fmt.Fprint(s, "default")
+               }
+               fmt.Fprintf(s, ": %v", n.Body)
+
+       case OBREAK, OCONTINUE, OGOTO, OFALL:
+               n := n.(*BranchStmt)
+               if n.Label != nil {
+                       fmt.Fprintf(s, "%v %v", n.Op(), n.Label)
+               } else {
+                       fmt.Fprintf(s, "%v", n.Op())
+               }
+
+       case OLABEL:
+               n := n.(*LabelStmt)
+               fmt.Fprintf(s, "%v: ", n.Label)
+       }
+
+       if extrablock {
+               fmt.Fprint(s, "}")
+       }
+}
+
+func exprFmt(n Node, s fmt.State, prec int) {
+       // NOTE(rsc): This code used to support the text-based
+       // which was more aggressive about printing full Go syntax
+       // (for example, an actual loop instead of "for loop").
+       // The code is preserved for now in case we want to expand
+       // any of those shortenings later. Or maybe we will delete
+       // the code. But for now, keep it.
+       const exportFormat = false
+
+       for {
+               if n == nil {
+                       fmt.Fprint(s, "<nil>")
+                       return
+               }
+
+               // We always want the original, if any.
+               if o := Orig(n); o != n {
+                       n = o
+                       continue
+               }
+
+               // Skip implicit operations introduced during typechecking.
+               switch nn := n; nn.Op() {
+               case OADDR:
+                       nn := nn.(*AddrExpr)
+                       if nn.Implicit() {
+                               n = nn.X
+                               continue
+                       }
+               case ODEREF:
+                       nn := nn.(*StarExpr)
+                       if nn.Implicit() {
+                               n = nn.X
+                               continue
+                       }
+               case OCONV, OCONVNOP, OCONVIFACE:
+                       nn := nn.(*ConvExpr)
+                       if nn.Implicit() {
+                               n = nn.X
+                               continue
+                       }
+               }
+
+               break
+       }
+
+       nprec := OpPrec[n.Op()]
+       if n.Op() == OTYPE && n.Type().IsPtr() {
+               nprec = OpPrec[ODEREF]
+       }
+
+       if prec > nprec {
+               fmt.Fprintf(s, "(%v)", n)
+               return
+       }
+
+       switch n.Op() {
+       case OPAREN:
+               n := n.(*ParenExpr)
+               fmt.Fprintf(s, "(%v)", n.X)
+
+       case ONIL:
+               fmt.Fprint(s, "nil")
+
+       case OLITERAL: // this is a bit of a mess
+               if !exportFormat && n.Sym() != nil {
+                       fmt.Fprint(s, n.Sym())
+                       return
+               }
+
+               needUnparen := false
+               if n.Type() != nil && !n.Type().IsUntyped() {
+                       // Need parens when type begins with what might
+                       // be misinterpreted as a unary operator: * or <-.
+                       if n.Type().IsPtr() || (n.Type().IsChan() && n.Type().ChanDir() == types.Crecv) {
+                               fmt.Fprintf(s, "(%v)(", n.Type())
+                       } else {
+                               fmt.Fprintf(s, "%v(", n.Type())
+                       }
+                       needUnparen = true
+               }
+
+               if n.Type() == types.UntypedRune {
+                       switch x, ok := constant.Uint64Val(n.Val()); {
+                       case !ok:
+                               fallthrough
+                       default:
+                               fmt.Fprintf(s, "('\\x00' + %v)", n.Val())
+
+                       case x < utf8.RuneSelf:
+                               fmt.Fprintf(s, "%q", x)
+
+                       case x < 1<<16:
+                               fmt.Fprintf(s, "'\\u%04x'", x)
+
+                       case x <= utf8.MaxRune:
+                               fmt.Fprintf(s, "'\\U%08x'", x)
+                       }
+               } else {
+                       fmt.Fprint(s, types.FmtConst(n.Val(), s.Flag('#')))
+               }
+
+               if needUnparen {
+                       fmt.Fprintf(s, ")")
+               }
+
+       case ODCLFUNC:
+               n := n.(*Func)
+               if sym := n.Sym(); sym != nil {
+                       fmt.Fprint(s, sym)
+                       return
+               }
+               fmt.Fprintf(s, "<unnamed Func>")
+
+       case ONAME:
+               n := n.(*Name)
+               // Special case: name used as local variable in export.
+               // _ becomes ~b%d internally; print as _ for export
+               if !exportFormat && n.Sym() != nil && n.Sym().Name[0] == '~' && n.Sym().Name[1] == 'b' {
+                       fmt.Fprint(s, "_")
+                       return
+               }
+               fallthrough
+       case OPACK, ONONAME:
+               fmt.Fprint(s, n.Sym())
+
+       case OLINKSYMOFFSET:
+               n := n.(*LinksymOffsetExpr)
+               fmt.Fprintf(s, "(%v)(%s@%d)", n.Type(), n.Linksym.Name, n.Offset_)
+
+       case OTYPE:
+               if n.Type() == nil && n.Sym() != nil {
+                       fmt.Fprint(s, n.Sym())
+                       return
+               }
+               fmt.Fprintf(s, "%v", n.Type())
+
+       case OTSLICE:
+               n := n.(*SliceType)
+               if n.DDD {
+                       fmt.Fprintf(s, "...%v", n.Elem)
+               } else {
+                       fmt.Fprintf(s, "[]%v", n.Elem) // happens before typecheck
+               }
+
+       case OTARRAY:
+               n := n.(*ArrayType)
+               if n.Len == nil {
+                       fmt.Fprintf(s, "[...]%v", n.Elem)
+               } else {
+                       fmt.Fprintf(s, "[%v]%v", n.Len, n.Elem)
+               }
+
+       case OTMAP:
+               n := n.(*MapType)
+               fmt.Fprintf(s, "map[%v]%v", n.Key, n.Elem)
+
+       case OTCHAN:
+               n := n.(*ChanType)
+               switch n.Dir {
+               case types.Crecv:
+                       fmt.Fprintf(s, "<-chan %v", n.Elem)
+
+               case types.Csend:
+                       fmt.Fprintf(s, "chan<- %v", n.Elem)
+
+               default:
+                       if n.Elem != nil && n.Elem.Op() == OTCHAN && n.Elem.(*ChanType).Dir == types.Crecv {
+                               fmt.Fprintf(s, "chan (%v)", n.Elem)
+                       } else {
+                               fmt.Fprintf(s, "chan %v", n.Elem)
+                       }
+               }
+
+       case OTSTRUCT:
+               fmt.Fprint(s, "<struct>")
+
+       case OTINTER:
+               fmt.Fprint(s, "<inter>")
+
+       case OTFUNC:
+               fmt.Fprint(s, "<func>")
+
+       case OCLOSURE:
+               n := n.(*ClosureExpr)
+               if !exportFormat {
+                       fmt.Fprint(s, "func literal")
+                       return
+               }
+               fmt.Fprintf(s, "%v { %v }", n.Type(), n.Func.Body)
+
+       case OCOMPLIT:
+               n := n.(*CompLitExpr)
+               if !exportFormat {
+                       if n.Implicit() {
+                               fmt.Fprintf(s, "... argument")
+                               return
+                       }
+                       if n.Ntype != nil {
+                               fmt.Fprintf(s, "%v{%s}", n.Ntype, ellipsisIf(len(n.List) != 0))
+                               return
+                       }
+
+                       fmt.Fprint(s, "composite literal")
+                       return
+               }
+               fmt.Fprintf(s, "(%v{ %.v })", n.Ntype, n.List)
+
+       case OPTRLIT:
+               n := n.(*AddrExpr)
+               fmt.Fprintf(s, "&%v", n.X)
+
+       case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
+               n := n.(*CompLitExpr)
+               if !exportFormat {
+                       fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(len(n.List) != 0))
+                       return
+               }
+               fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List)
+
+       case OKEY:
+               n := n.(*KeyExpr)
+               if n.Key != nil && n.Value != nil {
+                       fmt.Fprintf(s, "%v:%v", n.Key, n.Value)
+                       return
+               }
+
+               if n.Key == nil && n.Value != nil {
+                       fmt.Fprintf(s, ":%v", n.Value)
+                       return
+               }
+               if n.Key != nil && n.Value == nil {
+                       fmt.Fprintf(s, "%v:", n.Key)
+                       return
+               }
+               fmt.Fprint(s, ":")
+
+       case OSTRUCTKEY:
+               n := n.(*StructKeyExpr)
+               fmt.Fprintf(s, "%v:%v", n.Field, n.Value)
+
+       case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH, OCALLPART, OMETHEXPR:
+               n := n.(*SelectorExpr)
+               exprFmt(n.X, s, nprec)
+               if n.Sel == nil {
+                       fmt.Fprint(s, ".<nil>")
+                       return
+               }
+               fmt.Fprintf(s, ".%s", n.Sel.Name)
+
+       case ODOTTYPE, ODOTTYPE2:
+               n := n.(*TypeAssertExpr)
+               exprFmt(n.X, s, nprec)
+               if n.Ntype != nil {
+                       fmt.Fprintf(s, ".(%v)", n.Ntype)
+                       return
+               }
+               fmt.Fprintf(s, ".(%v)", n.Type())
+
+       case OINDEX, OINDEXMAP:
+               n := n.(*IndexExpr)
+               exprFmt(n.X, s, nprec)
+               fmt.Fprintf(s, "[%v]", n.Index)
+
+       case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
+               n := n.(*SliceExpr)
+               exprFmt(n.X, s, nprec)
+               fmt.Fprint(s, "[")
+               if n.Low != nil {
+                       fmt.Fprint(s, n.Low)
+               }
+               fmt.Fprint(s, ":")
+               if n.High != nil {
+                       fmt.Fprint(s, n.High)
+               }
+               if n.Op().IsSlice3() {
+                       fmt.Fprint(s, ":")
+                       if n.Max != nil {
+                               fmt.Fprint(s, n.Max)
+                       }
+               }
+               fmt.Fprint(s, "]")
+
+       case OSLICEHEADER:
+               n := n.(*SliceHeaderExpr)
+               fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.Len, n.Cap)
+
+       case OCOMPLEX, OCOPY:
+               n := n.(*BinaryExpr)
+               fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.X, n.Y)
+
+       case OCONV,
+               OCONVIFACE,
+               OCONVNOP,
+               OBYTES2STR,
+               ORUNES2STR,
+               OSTR2BYTES,
+               OSTR2RUNES,
+               ORUNESTR:
+               n := n.(*ConvExpr)
+               if n.Type() == nil || n.Type().Sym() == nil {
+                       fmt.Fprintf(s, "(%v)", n.Type())
+               } else {
+                       fmt.Fprintf(s, "%v", n.Type())
+               }
+               fmt.Fprintf(s, "(%v)", n.X)
+
+       case OREAL,
+               OIMAG,
+               OCAP,
+               OCLOSE,
+               OLEN,
+               ONEW,
+               OPANIC,
+               OALIGNOF,
+               OOFFSETOF,
+               OSIZEOF:
+               n := n.(*UnaryExpr)
+               fmt.Fprintf(s, "%v(%v)", n.Op(), n.X)
+
+       case OAPPEND,
+               ODELETE,
+               OMAKE,
+               ORECOVER,
+               OPRINT,
+               OPRINTN:
+               n := n.(*CallExpr)
+               if n.IsDDD {
+                       fmt.Fprintf(s, "%v(%.v...)", n.Op(), n.Args)
+                       return
+               }
+               fmt.Fprintf(s, "%v(%.v)", n.Op(), n.Args)
+
+       case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
+               n := n.(*CallExpr)
+               exprFmt(n.X, s, nprec)
+               if n.IsDDD {
+                       fmt.Fprintf(s, "(%.v...)", n.Args)
+                       return
+               }
+               fmt.Fprintf(s, "(%.v)", n.Args)
+
+       case OMAKEMAP, OMAKECHAN, OMAKESLICE:
+               n := n.(*MakeExpr)
+               if n.Cap != nil {
+                       fmt.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Len, n.Cap)
+                       return
+               }
+               if n.Len != nil && (n.Op() == OMAKESLICE || !n.Len.Type().IsUntyped()) {
+                       fmt.Fprintf(s, "make(%v, %v)", n.Type(), n.Len)
+                       return
+               }
+               fmt.Fprintf(s, "make(%v)", n.Type())
+
+       case OMAKESLICECOPY:
+               n := n.(*MakeExpr)
+               fmt.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Len, n.Cap)
+
+       case OPLUS, ONEG, OBITNOT, ONOT, ORECV:
+               // Unary
+               n := n.(*UnaryExpr)
+               fmt.Fprintf(s, "%v", n.Op())
+               if n.X != nil && n.X.Op() == n.Op() {
+                       fmt.Fprint(s, " ")
+               }
+               exprFmt(n.X, s, nprec+1)
+
+       case OADDR:
+               n := n.(*AddrExpr)
+               fmt.Fprintf(s, "%v", n.Op())
+               if n.X != nil && n.X.Op() == n.Op() {
+                       fmt.Fprint(s, " ")
+               }
+               exprFmt(n.X, s, nprec+1)
+
+       case ODEREF:
+               n := n.(*StarExpr)
+               fmt.Fprintf(s, "%v", n.Op())
+               exprFmt(n.X, s, nprec+1)
+
+               // Binary
+       case OADD,
+               OAND,
+               OANDNOT,
+               ODIV,
+               OEQ,
+               OGE,
+               OGT,
+               OLE,
+               OLT,
+               OLSH,
+               OMOD,
+               OMUL,
+               ONE,
+               OOR,
+               ORSH,
+               OSUB,
+               OXOR:
+               n := n.(*BinaryExpr)
+               exprFmt(n.X, s, nprec)
+               fmt.Fprintf(s, " %v ", n.Op())
+               exprFmt(n.Y, s, nprec+1)
+
+       case OANDAND,
+               OOROR:
+               n := n.(*LogicalExpr)
+               exprFmt(n.X, s, nprec)
+               fmt.Fprintf(s, " %v ", n.Op())
+               exprFmt(n.Y, s, nprec+1)
+
+       case OSEND:
+               n := n.(*SendStmt)
+               exprFmt(n.Chan, s, nprec)
+               fmt.Fprintf(s, " <- ")
+               exprFmt(n.Value, s, nprec+1)
+
+       case OADDSTR:
+               n := n.(*AddStringExpr)
+               for i, n1 := range n.List {
+                       if i != 0 {
+                               fmt.Fprint(s, " + ")
+                       }
+                       exprFmt(n1, s, nprec)
+               }
+       default:
+               fmt.Fprintf(s, "<node %v>", n.Op())
+       }
+}
+
+func ellipsisIf(b bool) string {
+       if b {
+               return "..."
+       }
+       return ""
+}
+
+// Nodes
+
+// Format implements formatting for a Nodes.
+// The valid formats are:
+//
+//     %v      Go syntax, semicolon-separated
+//     %.v     Go syntax, comma-separated
+//     %+v     Debug syntax, as in DumpList.
+//
+func (l Nodes) Format(s fmt.State, verb rune) {
+       if s.Flag('+') && verb == 'v' {
+               // %+v is DumpList output
+               dumpNodes(s, l, 1)
+               return
+       }
+
+       if verb != 'v' {
+               fmt.Fprintf(s, "%%!%c(Nodes)", verb)
+               return
+       }
+
+       sep := "; "
+       if _, ok := s.Precision(); ok { // %.v is expr list
+               sep = ", "
+       }
+
+       for i, n := range l {
+               fmt.Fprint(s, n)
+               if i+1 < len(l) {
+                       fmt.Fprint(s, sep)
+               }
+       }
+}
+
+// Dump
+
+// Dump prints the message s followed by a debug dump of n.
+func Dump(s string, n Node) {
+       fmt.Printf("%s [%p]%+v\n", s, n, n)
+}
+
+// DumpList prints the message s followed by a debug dump of each node in the list.
+func DumpList(s string, list Nodes) {
+       var buf bytes.Buffer
+       FDumpList(&buf, s, list)
+       os.Stdout.Write(buf.Bytes())
+}
+
+// FDumpList prints to w the message s followed by a debug dump of each node in the list.
+func FDumpList(w io.Writer, s string, list Nodes) {
+       io.WriteString(w, s)
+       dumpNodes(w, list, 1)
+       io.WriteString(w, "\n")
+}
+
+// indent prints indentation to w.
+func indent(w io.Writer, depth int) {
+       fmt.Fprint(w, "\n")
+       for i := 0; i < depth; i++ {
+               fmt.Fprint(w, ".   ")
+       }
+}
+
+// EscFmt is set by the escape analysis code to add escape analysis details to the node print.
+var EscFmt func(n Node) string
+
+// dumpNodeHeader prints the debug-format node header line to w.
+func dumpNodeHeader(w io.Writer, n Node) {
+       // Useful to see which nodes in an AST printout are actually identical
+       if base.Debug.DumpPtrs != 0 {
+               fmt.Fprintf(w, " p(%p)", n)
+       }
+
+       if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
+               // Useful to see where Defn is set and what node it points to
+               fmt.Fprintf(w, " defn(%p)", n.Name().Defn)
+       }
+
+       if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Curfn != nil {
+               // Useful to see where Defn is set and what node it points to
+               fmt.Fprintf(w, " curfn(%p)", n.Name().Curfn)
+       }
+       if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Outer != nil {
+               // Useful to see where Defn is set and what node it points to
+               fmt.Fprintf(w, " outer(%p)", n.Name().Outer)
+       }
+
+       if EscFmt != nil {
+               if esc := EscFmt(n); esc != "" {
+                       fmt.Fprintf(w, " %s", esc)
+               }
+       }
+
+       if n.Typecheck() != 0 {
+               fmt.Fprintf(w, " tc(%d)", n.Typecheck())
+       }
+
+       // Print Node-specific fields of basic type in header line.
+       v := reflect.ValueOf(n).Elem()
+       t := v.Type()
+       nf := t.NumField()
+       for i := 0; i < nf; i++ {
+               tf := t.Field(i)
+               if tf.PkgPath != "" {
+                       // skip unexported field - Interface will fail
+                       continue
+               }
+               k := tf.Type.Kind()
+               if reflect.Bool <= k && k <= reflect.Complex128 {
+                       name := strings.TrimSuffix(tf.Name, "_")
+                       vf := v.Field(i)
+                       vfi := vf.Interface()
+                       if name == "Offset" && vfi == types.BADWIDTH || name != "Offset" && isZero(vf) {
+                               continue
+                       }
+                       if vfi == true {
+                               fmt.Fprintf(w, " %s", name)
+                       } else {
+                               fmt.Fprintf(w, " %s:%+v", name, vf.Interface())
+                       }
+               }
+       }
+
+       // Print Node-specific booleans by looking for methods.
+       // Different v, t from above - want *Struct not Struct, for methods.
+       v = reflect.ValueOf(n)
+       t = v.Type()
+       nm := t.NumMethod()
+       for i := 0; i < nm; i++ {
+               tm := t.Method(i)
+               if tm.PkgPath != "" {
+                       // skip unexported method - call will fail
+                       continue
+               }
+               m := v.Method(i)
+               mt := m.Type()
+               if mt.NumIn() == 0 && mt.NumOut() == 1 && mt.Out(0).Kind() == reflect.Bool {
+                       // TODO(rsc): Remove the func/defer/recover wrapping,
+                       // which is guarding against panics in miniExpr,
+                       // once we get down to the simpler state in which
+                       // nodes have no getter methods that aren't allowed to be called.
+                       func() {
+                               defer func() { recover() }()
+                               if m.Call(nil)[0].Bool() {
+                                       name := strings.TrimSuffix(tm.Name, "_")
+                                       fmt.Fprintf(w, " %s", name)
+                               }
+                       }()
+               }
+       }
+
+       if n.Op() == OCLOSURE {
+               n := n.(*ClosureExpr)
+               if fn := n.Func; fn != nil && fn.Nname.Sym() != nil {
+                       fmt.Fprintf(w, " fnName(%+v)", fn.Nname.Sym())
+               }
+       }
+
+       if n.Type() != nil {
+               if n.Op() == OTYPE {
+                       fmt.Fprintf(w, " type")
+               }
+               fmt.Fprintf(w, " %+v", n.Type())
+       }
+
+       if n.Pos().IsKnown() {
+               pfx := ""
+               switch n.Pos().IsStmt() {
+               case src.PosNotStmt:
+                       pfx = "_" // "-" would be confusing
+               case src.PosIsStmt:
+                       pfx = "+"
+               }
+               pos := base.Ctxt.PosTable.Pos(n.Pos())
+               file := filepath.Base(pos.Filename())
+               fmt.Fprintf(w, " # %s%s:%d", pfx, file, pos.Line())
+       }
+}
+
+func dumpNode(w io.Writer, n Node, depth int) {
+       indent(w, depth)
+       if depth > 40 {
+               fmt.Fprint(w, "...")
+               return
+       }
+
+       if n == nil {
+               fmt.Fprint(w, "NilIrNode")
+               return
+       }
+
+       if len(n.Init()) != 0 {
+               fmt.Fprintf(w, "%+v-init", n.Op())
+               dumpNodes(w, n.Init(), depth+1)
+               indent(w, depth)
+       }
+
+       switch n.Op() {
+       default:
+               fmt.Fprintf(w, "%+v", n.Op())
+               dumpNodeHeader(w, n)
+
+       case OLITERAL:
+               fmt.Fprintf(w, "%+v-%v", n.Op(), n.Val())
+               dumpNodeHeader(w, n)
+               return
+
+       case ONAME, ONONAME:
+               if n.Sym() != nil {
+                       fmt.Fprintf(w, "%+v-%+v", n.Op(), n.Sym())
+               } else {
+                       fmt.Fprintf(w, "%+v", n.Op())
+               }
+               dumpNodeHeader(w, n)
+               if n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-ntype", n.Op())
+                       dumpNode(w, n.Name().Ntype, depth+1)
+               }
+               return
+
+       case OASOP:
+               n := n.(*AssignOpStmt)
+               fmt.Fprintf(w, "%+v-%+v", n.Op(), n.AsOp)
+               dumpNodeHeader(w, n)
+
+       case OTYPE:
+               fmt.Fprintf(w, "%+v %+v", n.Op(), n.Sym())
+               dumpNodeHeader(w, n)
+               if n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-ntype", n.Op())
+                       dumpNode(w, n.Name().Ntype, depth+1)
+               }
+               return
+
+       case OCLOSURE:
+               fmt.Fprintf(w, "%+v", n.Op())
+               dumpNodeHeader(w, n)
+
+       case ODCLFUNC:
+               // Func has many fields we don't want to print.
+               // Bypass reflection and just print what we want.
+               n := n.(*Func)
+               fmt.Fprintf(w, "%+v", n.Op())
+               dumpNodeHeader(w, n)
+               fn := n
+               if len(fn.Dcl) > 0 {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-Dcl", n.Op())
+                       for _, dcl := range n.Dcl {
+                               dumpNode(w, dcl, depth+1)
+                       }
+               }
+               if len(fn.ClosureVars) > 0 {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-ClosureVars", n.Op())
+                       for _, cv := range fn.ClosureVars {
+                               dumpNode(w, cv, depth+1)
+                       }
+               }
+               if len(fn.Enter) > 0 {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-Enter", n.Op())
+                       dumpNodes(w, fn.Enter, depth+1)
+               }
+               if len(fn.Body) > 0 {
+                       indent(w, depth)
+                       fmt.Fprintf(w, "%+v-body", n.Op())
+                       dumpNodes(w, fn.Body, depth+1)
+               }
+               return
+       }
+
+       if n.Sym() != nil {
+               fmt.Fprintf(w, " %+v", n.Sym())
+       }
+       if n.Type() != nil {
+               fmt.Fprintf(w, " %+v", n.Type())
+       }
+
+       v := reflect.ValueOf(n).Elem()
+       t := reflect.TypeOf(n).Elem()
+       nf := t.NumField()
+       for i := 0; i < nf; i++ {
+               tf := t.Field(i)
+               vf := v.Field(i)
+               if tf.PkgPath != "" {
+                       // skip unexported field - Interface will fail
+                       continue
+               }
+               switch tf.Type.Kind() {
+               case reflect.Interface, reflect.Ptr, reflect.Slice:
+                       if vf.IsNil() {
+                               continue
+                       }
+               }
+               name := strings.TrimSuffix(tf.Name, "_")
+               // Do not bother with field name header lines for the
+               // most common positional arguments: unary, binary expr,
+               // index expr, send stmt, go and defer call expression.
+               switch name {
+               case "X", "Y", "Index", "Chan", "Value", "Call":
+                       name = ""
+               }
+               switch val := vf.Interface().(type) {
+               case Node:
+                       if name != "" {
+                               indent(w, depth)
+                               fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+                       }
+                       dumpNode(w, val, depth+1)
+               case Nodes:
+                       if len(val) == 0 {
+                               continue
+                       }
+                       if name != "" {
+                               indent(w, depth)
+                               fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+                       }
+                       dumpNodes(w, val, depth+1)
+               default:
+                       if vf.Kind() == reflect.Slice && vf.Type().Elem().Implements(nodeType) {
+                               if vf.Len() == 0 {
+                                       continue
+                               }
+                               if name != "" {
+                                       indent(w, depth)
+                                       fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+                               }
+                               for i, n := 0, vf.Len(); i < n; i++ {
+                                       dumpNode(w, vf.Index(i).Interface().(Node), depth+1)
+                               }
+                       }
+               }
+       }
+}
+
+var nodeType = reflect.TypeOf((*Node)(nil)).Elem()
+
+func dumpNodes(w io.Writer, list Nodes, depth int) {
+       if len(list) == 0 {
+               fmt.Fprintf(w, " <nil>")
+               return
+       }
+
+       for _, n := range list {
+               dumpNode(w, n, depth)
+       }
+}
+
+// reflect.IsZero is not available in Go 1.4 (added in Go 1.13), so we use this copy instead.
+func isZero(v reflect.Value) bool {
+       switch v.Kind() {
+       case reflect.Bool:
+               return !v.Bool()
+       case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+               return v.Int() == 0
+       case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+               return v.Uint() == 0
+       case reflect.Float32, reflect.Float64:
+               return math.Float64bits(v.Float()) == 0
+       case reflect.Complex64, reflect.Complex128:
+               c := v.Complex()
+               return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
+       case reflect.Array:
+               for i := 0; i < v.Len(); i++ {
+                       if !isZero(v.Index(i)) {
+                               return false
+                       }
+               }
+               return true
+       case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+               return v.IsNil()
+       case reflect.String:
+               return v.Len() == 0
+       case reflect.Struct:
+               for i := 0; i < v.NumField(); i++ {
+                       if !isZero(v.Field(i)) {
+                               return false
+                       }
+               }
+               return true
+       default:
+               return false
+       }
+}

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
new file mode 100644 (file)
index 0000000..0a9db92
--- /dev/null
+++ b/src/cmd/compile/internal/ir/func.go
@@ -0,0 +1,284 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+// A Func corresponds to a single function in a Go program
+// (and vice versa: each function is denoted by exactly one *Func).
+//
+// There are multiple nodes that represent a Func in the IR.
+//
+// The ONAME node (Func.Nname) is used for plain references to it.
+// The ODCLFUNC node (the Func itself) is used for its declaration code.
+// The OCLOSURE node (Func.OClosure) is used for a reference to a
+// function literal.
+//
+// An imported function will have an ONAME node which points to a Func
+// with an empty body.
+// A declared function or method has an ODCLFUNC (the Func itself) and an ONAME.
+// A function literal is represented directly by an OCLOSURE, but it also
+// has an ODCLFUNC (and a matching ONAME) representing the compiled
+// underlying form of the closure, which accesses the captured variables
+// using a special data structure passed in a register.
+//
+// A method declaration is represented like functions, except f.Sym
+// will be the qualified method name (e.g., "T.m") and
+// f.Func.Shortname is the bare method name (e.g., "m").
+//
+// A method expression (T.M) is represented as an OMETHEXPR node,
+// in which n.Left and n.Right point to the type and method, respectively.
+// Each distinct mention of a method expression in the source code
+// constructs a fresh node.
+//
+// A method value (t.M) is represented by ODOTMETH/ODOTINTER
+// when it is called directly and by OCALLPART otherwise.
+// These are like method expressions, except that for ODOTMETH/ODOTINTER,
+// the method name is stored in Sym instead of Right.
+// Each OCALLPART ends up being implemented as a new
+// function, a bit like a closure, with its own ODCLFUNC.
+// The OCALLPART uses n.Func to record the linkage to
+// the generated ODCLFUNC, but there is no
+// pointer from the Func back to the OCALLPART.
+type Func struct {
+       miniNode
+       Body Nodes
+       Iota int64
+
+       Nname    *Name        // ONAME node
+       OClosure *ClosureExpr // OCLOSURE node
+
+       Shortname *types.Sym
+
+       // Extra entry code for the function. For example, allocate and initialize
+       // memory for escaping parameters.
+       Enter Nodes
+       Exit  Nodes
+
+       // ONAME nodes for all params/locals for this func/closure, does NOT
+       // include closurevars until transforming closures during walk.
+       // Names must be listed PPARAMs, PPARAMOUTs, then PAUTOs,
+       // with PPARAMs and PPARAMOUTs in order corresponding to the function signature.
+       // However, as anonymous or blank PPARAMs are not actually declared,
+       // they are omitted from Dcl.
+       // Anonymous and blank PPARAMOUTs are declared as ~rNN and ~bNN Names, respectively.
+       Dcl []*Name
+
+       // ClosureVars lists the free variables that are used within a
+       // function literal, but formally declared in an enclosing
+       // function. The variables in this slice are the closure function's
+       // own copy of the variables, which are used within its function
+       // body. They will also each have IsClosureVar set, and will have
+       // Byval set if they're captured by value.
+       ClosureVars []*Name
+
+       // Enclosed functions that need to be compiled.
+       // Populated during walk.
+       Closures []*Func
+
+       // Parents records the parent scope of each scope within a
+       // function. The root scope (0) has no parent, so the i'th
+       // scope's parent is stored at Parents[i-1].
+       Parents []ScopeID
+
+       // Marks records scope boundary changes.
+       Marks []Mark
+
+       FieldTrack map[*obj.LSym]struct{}
+       DebugInfo  interface{}
+       LSym       *obj.LSym
+
+       Inl *Inline
+
+       // Closgen tracks how many closures have been generated within
+       // this function. Used by closurename for creating unique
+       // function names.
+       Closgen int32
+
+       Label int32 // largest auto-generated label in this function
+
+       Endlineno src.XPos
+       WBPos     src.XPos // position of first write barrier; see SetWBPos
+
+       Pragma PragmaFlag // go:xxx function annotations
+
+       flags      bitset16
+       NumDefers  int32 // number of defer calls in the function
+       NumReturns int32 // number of explicit returns in the function
+
+       // nwbrCalls records the LSyms of functions called by this
+       // function for go:nowritebarrierrec analysis. Only filled in
+       // if nowritebarrierrecCheck != nil.
+       NWBRCalls *[]SymAndPos
+}
+
+func NewFunc(pos src.XPos) *Func {
+       f := new(Func)
+       f.pos = pos
+       f.op = ODCLFUNC
+       f.Iota = -1
+       return f
+}
+
+func (f *Func) isStmt() {}
+
+func (n *Func) copy() Node                         { panic(n.no("copy")) }
+func (n *Func) doChildren(do func(Node) bool) bool { return doNodes(n.Body, do) }
+func (n *Func) editChildren(edit func(Node) Node)  { editNodes(n.Body, edit) }
+
+func (f *Func) Type() *types.Type                { return f.Nname.Type() }
+func (f *Func) Sym() *types.Sym                  { return f.Nname.Sym() }
+func (f *Func) Linksym() *obj.LSym               { return f.Nname.Linksym() }
+func (f *Func) LinksymABI(abi obj.ABI) *obj.LSym { return f.Nname.LinksymABI(abi) }
+
+// An Inline holds fields used for function bodies that can be inlined.
+type Inline struct {
+       Cost int32 // heuristic cost of inlining this function
+
+       // Copies of Func.Dcl and Nbody for use during inlining.
+       Dcl  []*Name
+       Body []Node
+}
+
+// A Mark represents a scope boundary.
+type Mark struct {
+       // Pos is the position of the token that marks the scope
+       // change.
+       Pos src.XPos
+
+       // Scope identifies the innermost scope to the right of Pos.
+       Scope ScopeID
+}
+
+// A ScopeID represents a lexical scope within a function.
+type ScopeID int32
+
+const (
+       funcDupok         = 1 << iota // duplicate definitions ok
+       funcWrapper                   // is method wrapper
+       funcNeedctxt                  // function uses context register (has closure variables)
+       funcReflectMethod             // function calls reflect.Type.Method or MethodByName
+       // true if closure inside a function; false if a simple function or a
+       // closure in a global variable initialization
+       funcIsHiddenClosure
+       funcHasDefer                 // contains a defer statement
+       funcNilCheckDisabled         // disable nil checks when compiling this function
+       funcInlinabilityChecked      // inliner has already determined whether the function is inlinable
+       funcExportInline             // include inline body in export data
+       funcInstrumentBody           // add race/msan instrumentation during SSA construction
+       funcOpenCodedDeferDisallowed // can't do open-coded defers
+       funcClosureCalled            // closure is only immediately called
+)
+
+type SymAndPos struct {
+       Sym *obj.LSym // LSym of callee
+       Pos src.XPos  // line of call
+}
+
+func (f *Func) Dupok() bool                    { return f.flags&funcDupok != 0 }
+func (f *Func) Wrapper() bool                  { return f.flags&funcWrapper != 0 }
+func (f *Func) Needctxt() bool                 { return f.flags&funcNeedctxt != 0 }
+func (f *Func) ReflectMethod() bool            { return f.flags&funcReflectMethod != 0 }
+func (f *Func) IsHiddenClosure() bool          { return f.flags&funcIsHiddenClosure != 0 }
+func (f *Func) HasDefer() bool                 { return f.flags&funcHasDefer != 0 }
+func (f *Func) NilCheckDisabled() bool         { return f.flags&funcNilCheckDisabled != 0 }
+func (f *Func) InlinabilityChecked() bool      { return f.flags&funcInlinabilityChecked != 0 }
+func (f *Func) ExportInline() bool             { return f.flags&funcExportInline != 0 }
+func (f *Func) InstrumentBody() bool           { return f.flags&funcInstrumentBody != 0 }
+func (f *Func) OpenCodedDeferDisallowed() bool { return f.flags&funcOpenCodedDeferDisallowed != 0 }
+func (f *Func) ClosureCalled() bool            { return f.flags&funcClosureCalled != 0 }
+
+func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
+func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
+func (f *Func) SetNeedctxt(b bool)                 { f.flags.set(funcNeedctxt, b) }
+func (f *Func) SetReflectMethod(b bool)            { f.flags.set(funcReflectMethod, b) }
+func (f *Func) SetIsHiddenClosure(b bool)          { f.flags.set(funcIsHiddenClosure, b) }
+func (f *Func) SetHasDefer(b bool)                 { f.flags.set(funcHasDefer, b) }
+func (f *Func) SetNilCheckDisabled(b bool)         { f.flags.set(funcNilCheckDisabled, b) }
+func (f *Func) SetInlinabilityChecked(b bool)      { f.flags.set(funcInlinabilityChecked, b) }
+func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInline, b) }
+func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
+func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
+func (f *Func) SetClosureCalled(b bool)            { f.flags.set(funcClosureCalled, b) }
+
+func (f *Func) SetWBPos(pos src.XPos) {
+       if base.Debug.WB != 0 {
+               base.WarnfAt(pos, "write barrier")
+       }
+       if !f.WBPos.IsKnown() {
+               f.WBPos = pos
+       }
+}
+
+// funcname returns the name (without the package) of the function n.
+func FuncName(f *Func) string {
+       if f == nil || f.Nname == nil {
+               return "<nil>"
+       }
+       return f.Sym().Name
+}
+
+// pkgFuncName returns the name of the function referenced by n, with package prepended.
+// This differs from the compiler's internal convention where local functions lack a package
+// because the ultimate consumer of this is a human looking at an IDE; package is only empty
+// if the compilation package is actually the empty string.
+func PkgFuncName(f *Func) string {
+       if f == nil || f.Nname == nil {
+               return "<nil>"
+       }
+       s := f.Sym()
+       pkg := s.Pkg
+
+       p := base.Ctxt.Pkgpath
+       if pkg != nil && pkg.Path != "" {
+               p = pkg.Path
+       }
+       if p == "" {
+               return s.Name
+       }
+       return p + "." + s.Name
+}
+
+var CurFunc *Func
+
+func FuncSymName(s *types.Sym) string {
+       return s.Name + "·f"
+}
+
+// MarkFunc marks a node as a function.
+func MarkFunc(n *Name) {
+       if n.Op() != ONAME || n.Class != Pxxx {
+               base.Fatalf("expected ONAME/Pxxx node, got %v", n)
+       }
+
+       n.Class = PFUNC
+       n.Sym().SetFunc(true)
+}
+
+// ClosureDebugRuntimeCheck applies boilerplate checks for debug flags
+// and compiling runtime
+func ClosureDebugRuntimeCheck(clo *ClosureExpr) {
+       if base.Debug.Closure > 0 {
+               if clo.Esc() == EscHeap {
+                       base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func.ClosureVars)
+               } else {
+                       base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func.ClosureVars)
+               }
+       }
+       if base.Flag.CompilingRuntime && clo.Esc() == EscHeap {
+               base.ErrorfAt(clo.Pos(), "heap-allocated closure, not allowed in runtime")
+       }
+}
+
+// IsTrivialClosure reports whether closure clo has an
+// empty list of captured vars.
+func IsTrivialClosure(clo *ClosureExpr) bool {
+       return len(clo.Func.ClosureVars) == 0
+}

diff --git a/src/syscall/syscall_windows_386.go b/src/cmd/compile/internal/ir/ir.go
similarity index 90%
rename from src/syscall/syscall_windows_386.go
rename to src/cmd/compile/internal/ir/ir.go
index e82b540b4b64da1ef68d4cde3eb4beb73762befc..82224ca2ed8350660cb412acb7e483e27e073ff3 100644 (file)
--- a/src/syscall/syscall_windows_386.go
+++ b/src/cmd/compile/internal/ir/ir.go
@@ -2,4 +2,4 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package syscall
+package ir

diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
new file mode 100644 (file)
index 0000000..a7ff4ac
--- /dev/null
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -0,0 +1,92 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run -mod=mod mknode.go
+
+package ir
+
+import (
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+       "fmt"
+       "go/constant"
+)
+
+// A miniNode is a minimal node implementation,
+// meant to be embedded as the first field in a larger node implementation,
+// at a cost of 8 bytes.
+//
+// A miniNode is NOT a valid Node by itself: the embedding struct
+// must at the least provide:
+//
+//     func (n *MyNode) String() string { return fmt.Sprint(n) }
+//     func (n *MyNode) rawCopy() Node { c := *n; return &c }
+//     func (n *MyNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+//
+// The embedding struct should also fill in n.op in its constructor,
+// for more useful panic messages when invalid methods are called,
+// instead of implementing Op itself.
+//
+type miniNode struct {
+       pos  src.XPos // uint32
+       op   Op       // uint8
+       bits bitset8
+       esc  uint16
+}
+
+// posOr returns pos if known, or else n.pos.
+// For use in DeepCopy.
+func (n *miniNode) posOr(pos src.XPos) src.XPos {
+       if pos.IsKnown() {
+               return pos
+       }
+       return n.pos
+}
+
+// op can be read, but not written.
+// An embedding implementation can provide a SetOp if desired.
+// (The panicking SetOp is with the other panics below.)
+func (n *miniNode) Op() Op            { return n.op }
+func (n *miniNode) Pos() src.XPos     { return n.pos }
+func (n *miniNode) SetPos(x src.XPos) { n.pos = x }
+func (n *miniNode) Esc() uint16       { return n.esc }
+func (n *miniNode) SetEsc(x uint16)   { n.esc = x }
+
+const (
+       miniWalkdefShift   = 0 // TODO(mdempsky): Move to Name.flags.
+       miniTypecheckShift = 2
+       miniDiag           = 1 << 4
+       miniWalked         = 1 << 5 // to prevent/catch re-walking
+)
+
+func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
+func (n *miniNode) SetTypecheck(x uint8) {
+       if x > 3 {
+               panic(fmt.Sprintf("cannot SetTypecheck %d", x))
+       }
+       n.bits.set2(miniTypecheckShift, x)
+}
+
+func (n *miniNode) Diag() bool     { return n.bits&miniDiag != 0 }
+func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
+
+func (n *miniNode) Walked() bool     { return n.bits&miniWalked != 0 }
+func (n *miniNode) SetWalked(x bool) { n.bits.set(miniWalked, x) }
+
+// Empty, immutable graph structure.
+
+func (n *miniNode) Init() Nodes { return Nodes{} }
+
+// Additional functionality unavailable.
+
+func (n *miniNode) no(name string) string { return "cannot " + name + " on " + n.op.String() }
+
+func (n *miniNode) Type() *types.Type       { return nil }
+func (n *miniNode) SetType(*types.Type)     { panic(n.no("SetType")) }
+func (n *miniNode) Name() *Name             { return nil }
+func (n *miniNode) Sym() *types.Sym         { return nil }
+func (n *miniNode) Val() constant.Value     { panic(n.no("Val")) }
+func (n *miniNode) SetVal(v constant.Value) { panic(n.no("SetVal")) }
+func (n *miniNode) NonNil() bool            { return false }
+func (n *miniNode) MarkNonNil()             { panic(n.no("MarkNonNil")) }

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
new file mode 100644 (file)
index 0000000..326f491
--- /dev/null
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -0,0 +1,228 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+       "bytes"
+       "fmt"
+       "go/format"
+       "go/types"
+       "io/ioutil"
+       "log"
+       "reflect"
+       "sort"
+       "strings"
+
+       "golang.org/x/tools/go/packages"
+)
+
+var irPkg *types.Package
+var buf bytes.Buffer
+
+func main() {
+       cfg := &packages.Config{
+               Mode: packages.NeedSyntax | packages.NeedTypes,
+       }
+       pkgs, err := packages.Load(cfg, "cmd/compile/internal/ir")
+       if err != nil {
+               log.Fatal(err)
+       }
+       irPkg = pkgs[0].Types
+
+       fmt.Fprintln(&buf, "// Code generated by mknode.go. DO NOT EDIT.")
+       fmt.Fprintln(&buf)
+       fmt.Fprintln(&buf, "package ir")
+       fmt.Fprintln(&buf)
+       fmt.Fprintln(&buf, `import "fmt"`)
+
+       scope := irPkg.Scope()
+       for _, name := range scope.Names() {
+               if strings.HasPrefix(name, "mini") {
+                       continue
+               }
+
+               obj, ok := scope.Lookup(name).(*types.TypeName)
+               if !ok {
+                       continue
+               }
+               typ := obj.Type().(*types.Named)
+               if !implementsNode(types.NewPointer(typ)) {
+                       continue
+               }
+
+               fmt.Fprintf(&buf, "\n")
+               fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }\n", name)
+
+               switch name {
+               case "Name", "Func":
+                       // Too specialized to automate.
+                       continue
+               }
+
+               forNodeFields(typ,
+                       "func (n *%[1]s) copy() Node { c := *n\n",
+                       "",
+                       "c.%[1]s = copy%[2]s(c.%[1]s)",
+                       "return &c }\n")
+
+               forNodeFields(typ,
+                       "func (n *%[1]s) doChildren(do func(Node) bool) bool {\n",
+                       "if n.%[1]s != nil && do(n.%[1]s) { return true }",
+                       "if do%[2]s(n.%[1]s, do) { return true }",
+                       "return false }\n")
+
+               forNodeFields(typ,
+                       "func (n *%[1]s) editChildren(edit func(Node) Node) {\n",
+                       "if n.%[1]s != nil { n.%[1]s = edit(n.%[1]s).(%[2]s) }",
+                       "edit%[2]s(n.%[1]s, edit)",
+                       "}\n")
+       }
+
+       makeHelpers()
+
+       out, err := format.Source(buf.Bytes())
+       if err != nil {
+               // write out mangled source so we can see the bug.
+               out = buf.Bytes()
+       }
+
+       err = ioutil.WriteFile("node_gen.go", out, 0666)
+       if err != nil {
+               log.Fatal(err)
+       }
+}
+
+// needHelper maps needed slice helpers from their base name to their
+// respective slice-element type.
+var needHelper = map[string]string{}
+
+func makeHelpers() {
+       var names []string
+       for name := range needHelper {
+               names = append(names, name)
+       }
+       sort.Strings(names)
+
+       for _, name := range names {
+               fmt.Fprintf(&buf, sliceHelperTmpl, name, needHelper[name])
+       }
+}
+
+const sliceHelperTmpl = `
+func copy%[1]s(list []%[2]s) []%[2]s {
+       if list == nil {
+               return nil
+       }
+       c := make([]%[2]s, len(list))
+       copy(c, list)
+       return c
+}
+func do%[1]s(list []%[2]s, do func(Node) bool) bool {
+       for _, x := range list {
+               if x != nil && do(x) {
+                       return true
+               }
+       }
+       return false
+}
+func edit%[1]s(list []%[2]s, edit func(Node) Node) {
+       for i, x := range list {
+               if x != nil {
+                       list[i] = edit(x).(%[2]s)
+               }
+       }
+}
+`
+
+func forNodeFields(named *types.Named, prologue, singleTmpl, sliceTmpl, epilogue string) {
+       fmt.Fprintf(&buf, prologue, named.Obj().Name())
+
+       anyField(named.Underlying().(*types.Struct), func(f *types.Var) bool {
+               if f.Embedded() {
+                       return false
+               }
+               name, typ := f.Name(), f.Type()
+
+               slice, _ := typ.Underlying().(*types.Slice)
+               if slice != nil {
+                       typ = slice.Elem()
+               }
+
+               tmpl, what := singleTmpl, types.TypeString(typ, types.RelativeTo(irPkg))
+               if implementsNode(typ) {
+                       if slice != nil {
+                               helper := strings.TrimPrefix(what, "*") + "s"
+                               needHelper[helper] = what
+                               tmpl, what = sliceTmpl, helper
+                       }
+               } else if what == "*Field" {
+                       // Special case for *Field.
+                       tmpl = sliceTmpl
+                       if slice != nil {
+                               what = "Fields"
+                       } else {
+                               what = "Field"
+                       }
+               } else {
+                       return false
+               }
+
+               if tmpl == "" {
+                       return false
+               }
+
+               // Allow template to not use all arguments without
+               // upsetting fmt.Printf.
+               s := fmt.Sprintf(tmpl+"\x00 %[1]s %[2]s", name, what)
+               fmt.Fprintln(&buf, s[:strings.LastIndex(s, "\x00")])
+               return false
+       })
+
+       fmt.Fprintf(&buf, epilogue)
+}
+
+func implementsNode(typ types.Type) bool {
+       if _, ok := typ.Underlying().(*types.Interface); ok {
+               // TODO(mdempsky): Check the interface implements Node.
+               // Worst case, node_gen.go will fail to compile if we're wrong.
+               return true
+       }
+
+       if ptr, ok := typ.(*types.Pointer); ok {
+               if str, ok := ptr.Elem().Underlying().(*types.Struct); ok {
+                       return anyField(str, func(f *types.Var) bool {
+                               return f.Embedded() && f.Name() == "miniNode"
+                       })
+               }
+       }
+
+       return false
+}
+
+func anyField(typ *types.Struct, pred func(f *types.Var) bool) bool {
+       for i, n := 0, typ.NumFields(); i < n; i++ {
+               if value, ok := reflect.StructTag(typ.Tag(i)).Lookup("mknode"); ok {
+                       if value != "-" {
+                               panic(fmt.Sprintf("unexpected tag value: %q", value))
+                       }
+                       continue
+               }
+
+               f := typ.Field(i)
+               if pred(f) {
+                       return true
+               }
+               if f.Embedded() {
+                       if typ, ok := f.Type().Underlying().(*types.Struct); ok {
+                               if anyField(typ, pred) {
+                                       return true
+                               }
+                       }
+               }
+       }
+       return false
+}

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
new file mode 100644 (file)
index 0000000..fa06396
--- /dev/null
+++ b/src/cmd/compile/internal/ir/name.go
@@ -0,0 +1,512 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+       "fmt"
+
+       "go/constant"
+)
+
+// An Ident is an identifier, possibly qualified.
+type Ident struct {
+       miniExpr
+       sym *types.Sym
+}
+
+func NewIdent(pos src.XPos, sym *types.Sym) *Ident {
+       n := new(Ident)
+       n.op = ONONAME
+       n.pos = pos
+       n.sym = sym
+       return n
+}
+
+func (n *Ident) Sym() *types.Sym { return n.sym }
+
+func (*Ident) CanBeNtype() {}
+
+// Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
+type Name struct {
+       miniExpr
+       BuiltinOp Op         // uint8
+       Class     Class      // uint8
+       pragma    PragmaFlag // int16
+       flags     bitset16
+       sym       *types.Sym
+       Func      *Func
+       Offset_   int64
+       val       constant.Value
+       Opt       interface{} // for use by escape analysis
+       Embed     *[]Embed    // list of embedded files, for ONAME var
+
+       PkgName *PkgName // real package for import . names
+       // For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
+       // For a closure var, the ONAME node of the outer captured variable
+       Defn Node
+
+       // The function, method, or closure in which local variable or param is declared.
+       Curfn *Func
+
+       Ntype    Ntype
+       Heapaddr *Name // temp holding heap address of param
+
+       // ONAME closure linkage
+       // Consider:
+       //
+       //      func f() {
+       //              x := 1 // x1
+       //              func() {
+       //                      use(x) // x2
+       //                      func() {
+       //                              use(x) // x3
+       //                              --- parser is here ---
+       //                      }()
+       //              }()
+       //      }
+       //
+       // There is an original declaration of x and then a chain of mentions of x
+       // leading into the current function. Each time x is mentioned in a new closure,
+       // we create a variable representing x for use in that specific closure,
+       // since the way you get to x is different in each closure.
+       //
+       // Let's number the specific variables as shown in the code:
+       // x1 is the original x, x2 is when mentioned in the closure,
+       // and x3 is when mentioned in the closure in the closure.
+       //
+       // We keep these linked (assume N > 1):
+       //
+       //   - x1.Defn = original declaration statement for x (like most variables)
+       //   - x1.Innermost = current innermost closure x (in this case x3), or nil for none
+       //   - x1.IsClosureVar() = false
+       //
+       //   - xN.Defn = x1, N > 1
+       //   - xN.IsClosureVar() = true, N > 1
+       //   - x2.Outer = nil
+       //   - xN.Outer = x(N-1), N > 2
+       //
+       //
+       // When we look up x in the symbol table, we always get x1.
+       // Then we can use x1.Innermost (if not nil) to get the x
+       // for the innermost known closure function,
+       // but the first reference in a closure will find either no x1.Innermost
+       // or an x1.Innermost with .Funcdepth < Funcdepth.
+       // In that case, a new xN must be created, linked in with:
+       //
+       //     xN.Defn = x1
+       //     xN.Outer = x1.Innermost
+       //     x1.Innermost = xN
+       //
+       // When we finish the function, we'll process its closure variables
+       // and find xN and pop it off the list using:
+       //
+       //     x1 := xN.Defn
+       //     x1.Innermost = xN.Outer
+       //
+       // We leave x1.Innermost set so that we can still get to the original
+       // variable quickly. Not shown here, but once we're
+       // done parsing a function and no longer need xN.Outer for the
+       // lexical x reference links as described above, funcLit
+       // recomputes xN.Outer as the semantic x reference link tree,
+       // even filling in x in intermediate closures that might not
+       // have mentioned it along the way to inner closures that did.
+       // See funcLit for details.
+       //
+       // During the eventual compilation, then, for closure variables we have:
+       //
+       //     xN.Defn = original variable
+       //     xN.Outer = variable captured in next outward scope
+       //                to make closure where xN appears
+       //
+       // Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
+       // and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
+       Innermost *Name
+       Outer     *Name
+}
+
+func (n *Name) isExpr() {}
+
+func (n *Name) copy() Node                         { panic(n.no("copy")) }
+func (n *Name) doChildren(do func(Node) bool) bool { return false }
+func (n *Name) editChildren(edit func(Node) Node)  {}
+
+// TypeDefn returns the type definition for a named OTYPE.
+// That is, given "type T Defn", it returns Defn.
+// It is used by package types.
+func (n *Name) TypeDefn() *types.Type {
+       return n.Ntype.Type()
+}
+
+// RecordFrameOffset records the frame offset for the name.
+// It is used by package types when laying out function arguments.
+func (n *Name) RecordFrameOffset(offset int64) {
+       n.SetFrameOffset(offset)
+}
+
+// NewNameAt returns a new ONAME Node associated with symbol s at position pos.
+// The caller is responsible for setting Curfn.
+func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
+       if sym == nil {
+               base.Fatalf("NewNameAt nil")
+       }
+       return newNameAt(pos, ONAME, sym)
+}
+
+// NewIota returns a new OIOTA Node.
+func NewIota(pos src.XPos, sym *types.Sym) *Name {
+       if sym == nil {
+               base.Fatalf("NewIota nil")
+       }
+       return newNameAt(pos, OIOTA, sym)
+}
+
+// NewDeclNameAt returns a new Name associated with symbol s at position pos.
+// The caller is responsible for setting Curfn.
+func NewDeclNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
+       if sym == nil {
+               base.Fatalf("NewDeclNameAt nil")
+       }
+       switch op {
+       case ONAME, OTYPE, OLITERAL:
+               // ok
+       default:
+               base.Fatalf("NewDeclNameAt op %v", op)
+       }
+       return newNameAt(pos, op, sym)
+}
+
+// NewConstAt returns a new OLITERAL Node associated with symbol s at position pos.
+func NewConstAt(pos src.XPos, sym *types.Sym, typ *types.Type, val constant.Value) *Name {
+       if sym == nil {
+               base.Fatalf("NewConstAt nil")
+       }
+       n := newNameAt(pos, OLITERAL, sym)
+       n.SetType(typ)
+       n.SetVal(val)
+       return n
+}
+
+// newNameAt is like NewNameAt but allows sym == nil.
+func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
+       n := new(Name)
+       n.op = op
+       n.pos = pos
+       n.sym = sym
+       return n
+}
+
+func (n *Name) Name() *Name         { return n }
+func (n *Name) Sym() *types.Sym     { return n.sym }
+func (n *Name) SetSym(x *types.Sym) { n.sym = x }
+func (n *Name) SubOp() Op           { return n.BuiltinOp }
+func (n *Name) SetSubOp(x Op)       { n.BuiltinOp = x }
+func (n *Name) SetFunc(x *Func)     { n.Func = x }
+func (n *Name) Offset() int64       { panic("Name.Offset") }
+func (n *Name) SetOffset(x int64) {
+       if x != 0 {
+               panic("Name.SetOffset")
+       }
+}
+func (n *Name) FrameOffset() int64     { return n.Offset_ }
+func (n *Name) SetFrameOffset(x int64) { n.Offset_ = x }
+func (n *Name) Iota() int64            { return n.Offset_ }
+func (n *Name) SetIota(x int64)        { n.Offset_ = x }
+func (n *Name) Walkdef() uint8         { return n.bits.get2(miniWalkdefShift) }
+func (n *Name) SetWalkdef(x uint8) {
+       if x > 3 {
+               panic(fmt.Sprintf("cannot SetWalkdef %d", x))
+       }
+       n.bits.set2(miniWalkdefShift, x)
+}
+
+func (n *Name) Linksym() *obj.LSym               { return n.sym.Linksym() }
+func (n *Name) LinksymABI(abi obj.ABI) *obj.LSym { return n.sym.LinksymABI(abi) }
+
+func (*Name) CanBeNtype()    {}
+func (*Name) CanBeAnSSASym() {}
+func (*Name) CanBeAnSSAAux() {}
+
+// Pragma returns the PragmaFlag for p, which must be for an OTYPE.
+func (n *Name) Pragma() PragmaFlag { return n.pragma }
+
+// SetPragma sets the PragmaFlag for p, which must be for an OTYPE.
+func (n *Name) SetPragma(flag PragmaFlag) { n.pragma = flag }
+
+// Alias reports whether p, which must be for an OTYPE, is a type alias.
+func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
+
+// SetAlias sets whether p, which must be for an OTYPE, is a type alias.
+func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
+
+const (
+       nameReadonly              = 1 << iota
+       nameByval                 // is the variable captured by value or by reference
+       nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
+       nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
+       nameUsed                  // for variable declared and not used error
+       nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
+       nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
+       nameAddrtaken             // address taken, even if not moved to heap
+       nameInlFormal             // PAUTO created by inliner, derived from callee formal
+       nameInlLocal              // PAUTO created by inliner, derived from callee local
+       nameOpenDeferSlot         // if temporary var storing info for open-coded defers
+       nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+       nameAlias                 // is type name an alias
+)
+
+func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
+func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
+func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
+func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
+func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
+func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
+func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
+func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
+func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
+func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
+func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
+
+func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
+func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
+func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
+func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
+func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
+func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
+func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
+func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
+func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
+func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
+
+// OnStack reports whether variable n may reside on the stack.
+func (n *Name) OnStack() bool {
+       if n.Op() == ONAME {
+               switch n.Class {
+               case PPARAM, PPARAMOUT, PAUTO:
+                       return n.Esc() != EscHeap
+               case PEXTERN, PAUTOHEAP:
+                       return false
+               }
+       }
+       // Note: fmt.go:dumpNodeHeader calls all "func() bool"-typed
+       // methods, but it can only recover from panics, not Fatalf.
+       panic(fmt.Sprintf("%v: not a variable: %v", base.FmtPos(n.Pos()), n))
+}
+
+// MarkReadonly indicates that n is an ONAME with readonly contents.
+func (n *Name) MarkReadonly() {
+       if n.Op() != ONAME {
+               base.Fatalf("Node.MarkReadonly %v", n.Op())
+       }
+       n.setReadonly(true)
+       // Mark the linksym as readonly immediately
+       // so that the SSA backend can use this information.
+       // It will be overridden later during dumpglobls.
+       n.Linksym().Type = objabi.SRODATA
+}
+
+// Val returns the constant.Value for the node.
+func (n *Name) Val() constant.Value {
+       if n.val == nil {
+               return constant.MakeUnknown()
+       }
+       return n.val
+}
+
+// SetVal sets the constant.Value for the node.
+func (n *Name) SetVal(v constant.Value) {
+       if n.op != OLITERAL {
+               panic(n.no("SetVal"))
+       }
+       AssertValidTypeForConst(n.Type(), v)
+       n.val = v
+}
+
+// Canonical returns the logical declaration that n represents. If n
+// is a closure variable, then Canonical returns the original Name as
+// it appears in the function that immediately contains the
+// declaration. Otherwise, Canonical simply returns n itself.
+func (n *Name) Canonical() *Name {
+       if n.IsClosureVar() && n.Defn != nil {
+               n = n.Defn.(*Name)
+       }
+       return n
+}
+
+func (n *Name) SetByval(b bool) {
+       if n.Canonical() != n {
+               base.Fatalf("SetByval called on non-canonical variable: %v", n)
+       }
+       n.flags.set(nameByval, b)
+}
+
+func (n *Name) Byval() bool {
+       // We require byval to be set on the canonical variable, but we
+       // allow it to be accessed from any instance.
+       return n.Canonical().flags&nameByval != 0
+}
+
+// CaptureName returns a Name suitable for referring to n from within function
+// fn or from the package block if fn is nil. If n is a free variable declared
+// within a function that encloses fn, then CaptureName returns a closure
+// variable that refers to n and adds it to fn.ClosureVars. Otherwise, it simply
+// returns n.
+func CaptureName(pos src.XPos, fn *Func, n *Name) *Name {
+       if n.IsClosureVar() {
+               base.FatalfAt(pos, "misuse of CaptureName on closure variable: %v", n)
+       }
+       if n.Op() != ONAME || n.Curfn == nil || n.Curfn == fn {
+               return n // okay to use directly
+       }
+       if fn == nil {
+               base.FatalfAt(pos, "package-block reference to %v, declared in %v", n, n.Curfn)
+       }
+
+       c := n.Innermost
+       if c != nil && c.Curfn == fn {
+               return c
+       }
+
+       // Do not have a closure var for the active closure yet; make one.
+       c = NewNameAt(pos, n.Sym())
+       c.Curfn = fn
+       c.Class = PAUTOHEAP
+       c.SetIsClosureVar(true)
+       c.Defn = n
+
+       // Link into list of active closure variables.
+       // Popped from list in FinishCaptureNames.
+       c.Outer = n.Innermost
+       n.Innermost = c
+       fn.ClosureVars = append(fn.ClosureVars, c)
+
+       return c
+}
+
+// FinishCaptureNames handles any work leftover from calling CaptureName
+// earlier. outerfn should be the function that immediately encloses fn.
+func FinishCaptureNames(pos src.XPos, outerfn, fn *Func) {
+       // closure-specific variables are hanging off the
+       // ordinary ones; see CaptureName above.
+       // unhook them.
+       // make the list of pointers for the closure call.
+       for _, cv := range fn.ClosureVars {
+               // Unlink from n; see comment in syntax.go type Param for these fields.
+               n := cv.Defn.(*Name)
+               n.Innermost = cv.Outer
+
+               // If the closure usage of n is not dense, we need to make it
+               // dense by recapturing n within the enclosing function.
+               //
+               // That is, suppose we just finished parsing the innermost
+               // closure f4 in this code:
+               //
+               //      func f() {
+               //              n := 1
+               //              func() { // f2
+               //                      use(n)
+               //                      func() { // f3
+               //                              func() { // f4
+               //                                      use(n)
+               //                              }()
+               //                      }()
+               //              }()
+               //      }
+               //
+               // At this point cv.Outer is f2's n; there is no n for f3. To
+               // construct the closure f4 from within f3, we need to use f3's
+               // n and in this case we need to create f3's n with CaptureName.
+               //
+               // We'll decide later in walk whether to use v directly or &v.
+               cv.Outer = CaptureName(pos, outerfn, n)
+       }
+}
+
+// SameSource reports whether two nodes refer to the same source
+// element.
+//
+// It exists to help incrementally migrate the compiler towards
+// allowing the introduction of IdentExpr (#42990). Once we have
+// IdentExpr, it will no longer be safe to directly compare Node
+// values to tell if they refer to the same Name. Instead, code will
+// need to explicitly get references to the underlying Name object(s),
+// and compare those instead.
+//
+// It will still be safe to compare Nodes directly for checking if two
+// nodes are syntactically the same. The SameSource function exists to
+// indicate code that intentionally compares Nodes for syntactic
+// equality as opposed to code that has yet to be updated in
+// preparation for IdentExpr.
+func SameSource(n1, n2 Node) bool {
+       return n1 == n2
+}
+
+// Uses reports whether expression x is a (direct) use of the given
+// variable.
+func Uses(x Node, v *Name) bool {
+       if v == nil || v.Op() != ONAME {
+               base.Fatalf("RefersTo bad Name: %v", v)
+       }
+       return x.Op() == ONAME && x.Name() == v
+}
+
+// DeclaredBy reports whether expression x refers (directly) to a
+// variable that was declared by the given statement.
+func DeclaredBy(x, stmt Node) bool {
+       if stmt == nil {
+               base.Fatalf("DeclaredBy nil")
+       }
+       return x.Op() == ONAME && SameSource(x.Name().Defn, stmt)
+}
+
+// The Class of a variable/function describes the "storage class"
+// of a variable or function. During parsing, storage classes are
+// called declaration contexts.
+type Class uint8
+
+//go:generate stringer -type=Class name.go
+const (
+       Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
+       PEXTERN                // global variables
+       PAUTO                  // local variables
+       PAUTOHEAP              // local variables or parameters moved to heap
+       PPARAM                 // input arguments
+       PPARAMOUT              // output results
+       PFUNC                  // global functions
+
+       // Careful: Class is stored in three bits in Node.flags.
+       _ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
+)
+
+type Embed struct {
+       Pos      src.XPos
+       Patterns []string
+}
+
+// A Pack is an identifier referring to an imported package.
+type PkgName struct {
+       miniNode
+       sym  *types.Sym
+       Pkg  *types.Pkg
+       Used bool
+}
+
+func (p *PkgName) Sym() *types.Sym { return p.sym }
+
+func (*PkgName) CanBeNtype() {}
+
+func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
+       p := &PkgName{sym: sym, Pkg: pkg}
+       p.op = OPACK
+       p.pos = pos
+       return p
+}
+
+var RegFP *Name

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
new file mode 100644 (file)
index 0000000..ffa7daf
--- /dev/null
+++ b/src/cmd/compile/internal/ir/node.go
@@ -0,0 +1,591 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// “Abstract” syntax representation.
+
+package ir
+
+import (
+       "fmt"
+       "go/constant"
+       "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// A Node is the abstract interface to an IR node.
+type Node interface {
+       // Formatting
+       Format(s fmt.State, verb rune)
+
+       // Source position.
+       Pos() src.XPos
+       SetPos(x src.XPos)
+
+       // For making copies. For Copy and SepCopy.
+       copy() Node
+
+       doChildren(func(Node) bool) bool
+       editChildren(func(Node) Node)
+
+       // Abstract graph structure, for generic traversals.
+       Op() Op
+       Init() Nodes
+
+       // Fields specific to certain Ops only.
+       Type() *types.Type
+       SetType(t *types.Type)
+       Name() *Name
+       Sym() *types.Sym
+       Val() constant.Value
+       SetVal(v constant.Value)
+
+       // Storage for analysis passes.
+       Esc() uint16
+       SetEsc(x uint16)
+       Diag() bool
+       SetDiag(x bool)
+       Typecheck() uint8
+       SetTypecheck(x uint8)
+       NonNil() bool
+       MarkNonNil()
+}
+
+// Line returns n's position as a string. If n has been inlined,
+// it uses the outermost position where n has been inlined.
+func Line(n Node) string {
+       return base.FmtPos(n.Pos())
+}
+
+func IsSynthetic(n Node) bool {
+       name := n.Sym().Name
+       return name[0] == '.' || name[0] == '~'
+}
+
+// IsAutoTmp indicates if n was created by the compiler as a temporary,
+// based on the setting of the .AutoTemp flag in n's Name.
+func IsAutoTmp(n Node) bool {
+       if n == nil || n.Op() != ONAME {
+               return false
+       }
+       return n.Name().AutoTemp()
+}
+
+// mayBeShared reports whether n may occur in multiple places in the AST.
+// Extra care must be taken when mutating such a node.
+func MayBeShared(n Node) bool {
+       switch n.Op() {
+       case ONAME, OLITERAL, ONIL, OTYPE:
+               return true
+       }
+       return false
+}
+
+type InitNode interface {
+       Node
+       PtrInit() *Nodes
+       SetInit(x Nodes)
+}
+
+func TakeInit(n Node) Nodes {
+       init := n.Init()
+       if len(init) != 0 {
+               n.(InitNode).SetInit(nil)
+       }
+       return init
+}
+
+//go:generate stringer -type=Op -trimprefix=O node.go
+
+type Op uint8
+
+// Node ops.
+const (
+       OXXX Op = iota
+
+       // names
+       ONAME // var or func name
+       // Unnamed arg or return value: f(int, string) (int, error) { etc }
+       // Also used for a qualified package identifier that hasn't been resolved yet.
+       ONONAME
+       OTYPE    // type name
+       OPACK    // import
+       OLITERAL // literal
+       ONIL     // nil
+
+       // expressions
+       OADD          // Left + Right
+       OSUB          // Left - Right
+       OOR           // Left | Right
+       OXOR          // Left ^ Right
+       OADDSTR       // +{List} (string addition, list elements are strings)
+       OADDR         // &Left
+       OANDAND       // Left && Right
+       OAPPEND       // append(List); after walk, Left may contain elem type descriptor
+       OBYTES2STR    // Type(Left) (Type is string, Left is a []byte)
+       OBYTES2STRTMP // Type(Left) (Type is string, Left is a []byte, ephemeral)
+       ORUNES2STR    // Type(Left) (Type is string, Left is a []rune)
+       OSTR2BYTES    // Type(Left) (Type is []byte, Left is a string)
+       OSTR2BYTESTMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
+       OSTR2RUNES    // Type(Left) (Type is []rune, Left is a string)
+       // Left = Right or (if Colas=true) Left := Right
+       // If Colas, then Ninit includes a DCL node for Left.
+       OAS
+       // List = Rlist (x, y, z = a, b, c) or (if Colas=true) List := Rlist
+       // If Colas, then Ninit includes DCL nodes for List
+       OAS2
+       OAS2DOTTYPE // List = Right (x, ok = I.(int))
+       OAS2FUNC    // List = Right (x, y = f())
+       OAS2MAPR    // List = Right (x, ok = m["foo"])
+       OAS2RECV    // List = Right (x, ok = <-c)
+       OASOP       // Left Etype= Right (x += y)
+       OCALL       // Left(List) (function call, method call or type conversion)
+
+       // OCALLFUNC, OCALLMETH, and OCALLINTER have the same structure.
+       // Prior to walk, they are: Left(List), where List is all regular arguments.
+       // After walk, List is a series of assignments to temporaries,
+       // and Rlist is an updated set of arguments.
+       // Nbody is all OVARLIVE nodes that are attached to OCALLxxx.
+       // TODO(josharian/khr): Use Ninit instead of List for the assignments to temporaries. See CL 114797.
+       OCALLFUNC  // Left(List/Rlist) (function call f(args))
+       OCALLMETH  // Left(List/Rlist) (direct method call x.Method(args))
+       OCALLINTER // Left(List/Rlist) (interface method call x.Method(args))
+       OCALLPART  // Left.Right (method expression x.Method, not called)
+       OCAP       // cap(Left)
+       OCLOSE     // close(Left)
+       OCLOSURE   // func Type { Func.Closure.Nbody } (func literal)
+       OCOMPLIT   // Right{List} (composite literal, not yet lowered to specific form)
+       OMAPLIT    // Type{List} (composite literal, Type is map)
+       OSTRUCTLIT // Type{List} (composite literal, Type is struct)
+       OARRAYLIT  // Type{List} (composite literal, Type is array)
+       OSLICELIT  // Type{List} (composite literal, Type is slice) Right.Int64() = slice length.
+       OPTRLIT    // &Left (left is composite literal)
+       OCONV      // Type(Left) (type conversion)
+       OCONVIFACE // Type(Left) (type conversion, to interface)
+       OCONVNOP   // Type(Left) (type conversion, no effect)
+       OCOPY      // copy(Left, Right)
+       ODCL       // var Left (declares Left of type Left.Type)
+
+       // Used during parsing but don't last.
+       ODCLFUNC  // func f() or func (r) f()
+       ODCLCONST // const pi = 3.14
+       ODCLTYPE  // type Int int or type Int = int
+
+       ODELETE        // delete(List)
+       ODOT           // Left.Sym (Left is of struct type)
+       ODOTPTR        // Left.Sym (Left is of pointer to struct type)
+       ODOTMETH       // Left.Sym (Left is non-interface, Right is method name)
+       ODOTINTER      // Left.Sym (Left is interface, Right is method name)
+       OXDOT          // Left.Sym (before rewrite to one of the preceding)
+       ODOTTYPE       // Left.Right or Left.Type (.Right during parsing, .Type once resolved); after walk, .Right contains address of interface type descriptor and .Right.Right contains address of concrete type descriptor
+       ODOTTYPE2      // Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor
+       OEQ            // Left == Right
+       ONE            // Left != Right
+       OLT            // Left < Right
+       OLE            // Left <= Right
+       OGE            // Left >= Right
+       OGT            // Left > Right
+       ODEREF         // *Left
+       OINDEX         // Left[Right] (index of array or slice)
+       OINDEXMAP      // Left[Right] (index of map)
+       OKEY           // Left:Right (key:value in struct/array/map literal)
+       OSTRUCTKEY     // Sym:Left (key:value in struct literal, after type checking)
+       OLEN           // len(Left)
+       OMAKE          // make(List) (before type checking converts to one of the following)
+       OMAKECHAN      // make(Type, Left) (type is chan)
+       OMAKEMAP       // make(Type, Left) (type is map)
+       OMAKESLICE     // make(Type, Left, Right) (type is slice)
+       OMAKESLICECOPY // makeslicecopy(Type, Left, Right) (type is slice; Left is length and Right is the copied from slice)
+       // OMAKESLICECOPY is created by the order pass and corresponds to:
+       //  s = make(Type, Left); copy(s, Right)
+       //
+       // Bounded can be set on the node when Left == len(Right) is known at compile time.
+       //
+       // This node is created so the walk pass can optimize this pattern which would
+       // otherwise be hard to detect after the order pass.
+       OMUL         // Left * Right
+       ODIV         // Left / Right
+       OMOD         // Left % Right
+       OLSH         // Left << Right
+       ORSH         // Left >> Right
+       OAND         // Left & Right
+       OANDNOT      // Left &^ Right
+       ONEW         // new(Left); corresponds to calls to new in source code
+       ONOT         // !Left
+       OBITNOT      // ^Left
+       OPLUS        // +Left
+       ONEG         // -Left
+       OOROR        // Left || Right
+       OPANIC       // panic(Left)
+       OPRINT       // print(List)
+       OPRINTN      // println(List)
+       OPAREN       // (Left)
+       OSEND        // Left <- Right
+       OSLICE       // Left[List[0] : List[1]] (Left is untypechecked or slice)
+       OSLICEARR    // Left[List[0] : List[1]] (Left is pointer to array)
+       OSLICESTR    // Left[List[0] : List[1]] (Left is string)
+       OSLICE3      // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
+       OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is pointer to array)
+       OSLICEHEADER // sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity)
+       ORECOVER     // recover()
+       ORECV        // <-Left
+       ORUNESTR     // Type(Left) (Type is string, Left is rune)
+       OSELRECV2    // like OAS2: List = Rlist where len(List)=2, len(Rlist)=1, Rlist[0].Op = ORECV (appears as .Left of OCASE)
+       OIOTA        // iota
+       OREAL        // real(Left)
+       OIMAG        // imag(Left)
+       OCOMPLEX     // complex(Left, Right) or complex(List[0]) where List[0] is a 2-result function call
+       OALIGNOF     // unsafe.Alignof(Left)
+       OOFFSETOF    // unsafe.Offsetof(Left)
+       OSIZEOF      // unsafe.Sizeof(Left)
+       OMETHEXPR    // method expression
+       OSTMTEXPR    // statement expression (Init; Left)
+
+       // statements
+       OBLOCK // { List } (block of code)
+       OBREAK // break [Sym]
+       // OCASE:  case List: Nbody (List==nil means default)
+       //   For OTYPESW, List is a OTYPE node for the specified type (or OLITERAL
+       //   for nil), and, if a type-switch variable is specified, Rlist is an
+       //   ONAME for the version of the type-switch variable with the specified
+       //   type.
+       OCASE
+       OCONTINUE // continue [Sym]
+       ODEFER    // defer Left (Left must be call)
+       OFALL     // fallthrough
+       OFOR      // for Ninit; Left; Right { Nbody }
+       // OFORUNTIL is like OFOR, but the test (Left) is applied after the body:
+       //      Ninit
+       //      top: { Nbody }   // Execute the body at least once
+       //      cont: Right
+       //      if Left {        // And then test the loop condition
+       //              List     // Before looping to top, execute List
+       //              goto top
+       //      }
+       // OFORUNTIL is created by walk. There's no way to write this in Go code.
+       OFORUNTIL
+       OGOTO   // goto Sym
+       OIF     // if Ninit; Left { Nbody } else { Rlist }
+       OLABEL  // Sym:
+       OGO     // go Left (Left must be call)
+       ORANGE  // for List = range Right { Nbody }
+       ORETURN // return List
+       OSELECT // select { List } (List is list of OCASE)
+       OSWITCH // switch Ninit; Left { List } (List is a list of OCASE)
+       // OTYPESW:  Left := Right.(type) (appears as .Left of OSWITCH)
+       //   Left is nil if there is no type-switch variable
+       OTYPESW
+
+       // types
+       OTCHAN   // chan int
+       OTMAP    // map[string]int
+       OTSTRUCT // struct{}
+       OTINTER  // interface{}
+       // OTFUNC: func() - Left is receiver field, List is list of param fields, Rlist is
+       // list of result fields.
+       OTFUNC
+       OTARRAY // [8]int or [...]int
+       OTSLICE // []int
+
+       // misc
+       // intermediate representation of an inlined call.  Uses Init (assignments
+       // for the captured variables, parameters, retvars, & INLMARK op),
+       // Body (body of the inlined function), and ReturnVars (list of
+       // return values)
+       OINLCALL       // intermediary representation of an inlined call.
+       OEFACE         // itable and data words of an empty-interface value.
+       OITAB          // itable word of an interface value.
+       OIDATA         // data word of an interface value in Left
+       OSPTR          // base pointer of a slice or string.
+       OCFUNC         // reference to c function pointer (not go func value)
+       OCHECKNIL      // emit code to ensure pointer/interface not nil
+       OVARDEF        // variable is about to be fully initialized
+       OVARKILL       // variable is dead
+       OVARLIVE       // variable is alive
+       ORESULT        // result of a function call; Xoffset is stack offset
+       OINLMARK       // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
+       OLINKSYMOFFSET // offset within a name
+
+       // arch-specific opcodes
+       OTAILCALL // tail call to another function
+       OGETG     // runtime.getg() (read g pointer)
+
+       OEND
+)
+
+// Nodes is a pointer to a slice of *Node.
+// For fields that are not used in most nodes, this is used instead of
+// a slice to save space.
+type Nodes []Node
+
+// Append appends entries to Nodes.
+func (n *Nodes) Append(a ...Node) {
+       if len(a) == 0 {
+               return
+       }
+       *n = append(*n, a...)
+}
+
+// Prepend prepends entries to Nodes.
+// If a slice is passed in, this will take ownership of it.
+func (n *Nodes) Prepend(a ...Node) {
+       if len(a) == 0 {
+               return
+       }
+       *n = append(a, *n...)
+}
+
+// Take clears n, returning its former contents.
+func (n *Nodes) Take() []Node {
+       ret := *n
+       *n = nil
+       return ret
+}
+
+// Copy returns a copy of the content of the slice.
+func (n Nodes) Copy() Nodes {
+       if n == nil {
+               return nil
+       }
+       c := make(Nodes, len(n))
+       copy(c, n)
+       return c
+}
+
+// NameQueue is a FIFO queue of *Name. The zero value of NameQueue is
+// a ready-to-use empty queue.
+type NameQueue struct {
+       ring       []*Name
+       head, tail int
+}
+
+// Empty reports whether q contains no Names.
+func (q *NameQueue) Empty() bool {
+       return q.head == q.tail
+}
+
+// PushRight appends n to the right of the queue.
+func (q *NameQueue) PushRight(n *Name) {
+       if len(q.ring) == 0 {
+               q.ring = make([]*Name, 16)
+       } else if q.head+len(q.ring) == q.tail {
+               // Grow the ring.
+               nring := make([]*Name, len(q.ring)*2)
+               // Copy the old elements.
+               part := q.ring[q.head%len(q.ring):]
+               if q.tail-q.head <= len(part) {
+                       part = part[:q.tail-q.head]
+                       copy(nring, part)
+               } else {
+                       pos := copy(nring, part)
+                       copy(nring[pos:], q.ring[:q.tail%len(q.ring)])
+               }
+               q.ring, q.head, q.tail = nring, 0, q.tail-q.head
+       }
+
+       q.ring[q.tail%len(q.ring)] = n
+       q.tail++
+}
+
+// PopLeft pops a Name from the left of the queue. It panics if q is
+// empty.
+func (q *NameQueue) PopLeft() *Name {
+       if q.Empty() {
+               panic("dequeue empty")
+       }
+       n := q.ring[q.head%len(q.ring)]
+       q.head++
+       return n
+}
+
+// NameSet is a set of Names.
+type NameSet map[*Name]struct{}
+
+// Has reports whether s contains n.
+func (s NameSet) Has(n *Name) bool {
+       _, isPresent := s[n]
+       return isPresent
+}
+
+// Add adds n to s.
+func (s *NameSet) Add(n *Name) {
+       if *s == nil {
+               *s = make(map[*Name]struct{})
+       }
+       (*s)[n] = struct{}{}
+}
+
+// Sorted returns s sorted according to less.
+func (s NameSet) Sorted(less func(*Name, *Name) bool) []*Name {
+       var res []*Name
+       for n := range s {
+               res = append(res, n)
+       }
+       sort.Slice(res, func(i, j int) bool { return less(res[i], res[j]) })
+       return res
+}
+
+type PragmaFlag int16
+
+const (
+       // Func pragmas.
+       Nointerface    PragmaFlag = 1 << iota
+       Noescape                  // func parameters don't escape
+       Norace                    // func must not have race detector annotations
+       Nosplit                   // func should not execute on separate stack
+       Noinline                  // func should not be inlined
+       NoCheckPtr                // func should not be instrumented by checkptr
+       CgoUnsafeArgs             // treat a pointer to one arg as a pointer to them all
+       UintptrEscapes            // pointers converted to uintptr escape
+
+       // Runtime-only func pragmas.
+       // See ../../../../runtime/README.md for detailed descriptions.
+       Systemstack        // func must run on system stack
+       Nowritebarrier     // emit compiler error instead of write barrier
+       Nowritebarrierrec  // error on write barrier in this or recursive callees
+       Yeswritebarrierrec // cancels Nowritebarrierrec in this function and callees
+
+       // Runtime and cgo type pragmas
+       NotInHeap // values of this type must not be heap allocated
+
+       // Go command pragmas
+       GoBuildPragma
+
+       RegisterParams // TODO remove after register abi is working
+
+)
+
+func AsNode(n types.Object) Node {
+       if n == nil {
+               return nil
+       }
+       return n.(Node)
+}
+
+var BlankNode Node
+
+func IsConst(n Node, ct constant.Kind) bool {
+       return ConstType(n) == ct
+}
+
+// isNil reports whether n represents the universal untyped zero value "nil".
+func IsNil(n Node) bool {
+       // Check n.Orig because constant propagation may produce typed nil constants,
+       // which don't exist in the Go spec.
+       return n != nil && Orig(n).Op() == ONIL
+}
+
+func IsBlank(n Node) bool {
+       if n == nil {
+               return false
+       }
+       return n.Sym().IsBlank()
+}
+
+// IsMethod reports whether n is a method.
+// n must be a function or a method.
+func IsMethod(n Node) bool {
+       return n.Type().Recv() != nil
+}
+
+func HasNamedResults(fn *Func) bool {
+       typ := fn.Type()
+       return typ.NumResults() > 0 && types.OrigSym(typ.Results().Field(0).Sym) != nil
+}
+
+// HasUniquePos reports whether n has a unique position that can be
+// used for reporting error messages.
+//
+// It's primarily used to distinguish references to named objects,
+// whose Pos will point back to their declaration position rather than
+// their usage position.
+func HasUniquePos(n Node) bool {
+       switch n.Op() {
+       case ONAME, OPACK:
+               return false
+       case OLITERAL, ONIL, OTYPE:
+               if n.Sym() != nil {
+                       return false
+               }
+       }
+
+       if !n.Pos().IsKnown() {
+               if base.Flag.K != 0 {
+                       base.Warn("setlineno: unknown position (line 0)")
+               }
+               return false
+       }
+
+       return true
+}
+
+func SetPos(n Node) src.XPos {
+       lno := base.Pos
+       if n != nil && HasUniquePos(n) {
+               base.Pos = n.Pos()
+       }
+       return lno
+}
+
+// The result of InitExpr MUST be assigned back to n, e.g.
+//     n.Left = InitExpr(init, n.Left)
+func InitExpr(init []Node, expr Node) Node {
+       if len(init) == 0 {
+               return expr
+       }
+
+       n, ok := expr.(InitNode)
+       if !ok || MayBeShared(n) {
+               // Introduce OCONVNOP to hold init list.
+               n = NewConvExpr(base.Pos, OCONVNOP, nil, expr)
+               n.SetType(expr.Type())
+               n.SetTypecheck(1)
+       }
+
+       n.PtrInit().Prepend(init...)
+       return n
+}
+
+// what's the outer value that a write to n affects?
+// outer value means containing struct or array.
+func OuterValue(n Node) Node {
+       for {
+               switch nn := n; nn.Op() {
+               case OXDOT:
+                       base.Fatalf("OXDOT in walk")
+               case ODOT:
+                       nn := nn.(*SelectorExpr)
+                       n = nn.X
+                       continue
+               case OPAREN:
+                       nn := nn.(*ParenExpr)
+                       n = nn.X
+                       continue
+               case OCONVNOP:
+                       nn := nn.(*ConvExpr)
+                       n = nn.X
+                       continue
+               case OINDEX:
+                       nn := nn.(*IndexExpr)
+                       if nn.X.Type() == nil {
+                               base.Fatalf("OuterValue needs type for %v", nn.X)
+                       }
+                       if nn.X.Type().IsArray() {
+                               n = nn.X
+                               continue
+                       }
+               }
+
+               return n
+       }
+}
+
+const (
+       EscUnknown = iota
+       EscNone    // Does not escape to heap, result, or parameters.
+       EscHeap    // Reachable from the heap
+       EscNever   // By construction will not escape.
+)

diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
new file mode 100644 (file)
index 0000000..fe43686
--- /dev/null
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -0,0 +1,1425 @@
+// Code generated by mknode.go. DO NOT EDIT.
+
+package ir
+
+import "fmt"
+
+func (n *AddStringExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *AddStringExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.List = copyNodes(c.List)
+       return &c
+}
+func (n *AddStringExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doNodes(n.List, do) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *AddStringExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editNodes(n.List, edit)
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *AddrExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *AddrExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *AddrExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *AddrExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *ArrayType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ArrayType) copy() Node {
+       c := *n
+       return &c
+}
+func (n *ArrayType) doChildren(do func(Node) bool) bool {
+       if n.Len != nil && do(n.Len) {
+               return true
+       }
+       if n.Elem != nil && do(n.Elem) {
+               return true
+       }
+       return false
+}
+func (n *ArrayType) editChildren(edit func(Node) Node) {
+       if n.Len != nil {
+               n.Len = edit(n.Len).(Node)
+       }
+       if n.Elem != nil {
+               n.Elem = edit(n.Elem).(Ntype)
+       }
+}
+
+func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *AssignListStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Lhs = copyNodes(c.Lhs)
+       c.Rhs = copyNodes(c.Rhs)
+       return &c
+}
+func (n *AssignListStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doNodes(n.Lhs, do) {
+               return true
+       }
+       if doNodes(n.Rhs, do) {
+               return true
+       }
+       return false
+}
+func (n *AssignListStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editNodes(n.Lhs, edit)
+       editNodes(n.Rhs, edit)
+}
+
+func (n *AssignOpStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *AssignOpStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *AssignOpStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Y != nil && do(n.Y) {
+               return true
+       }
+       return false
+}
+func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Y != nil {
+               n.Y = edit(n.Y).(Node)
+       }
+}
+
+func (n *AssignStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *AssignStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *AssignStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Y != nil && do(n.Y) {
+               return true
+       }
+       return false
+}
+func (n *AssignStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Y != nil {
+               n.Y = edit(n.Y).(Node)
+       }
+}
+
+func (n *BasicLit) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *BasicLit) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *BasicLit) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *BasicLit) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *BinaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *BinaryExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *BinaryExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Y != nil && do(n.Y) {
+               return true
+       }
+       return false
+}
+func (n *BinaryExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Y != nil {
+               n.Y = edit(n.Y).(Node)
+       }
+}
+
+func (n *BlockStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *BlockStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.List = copyNodes(c.List)
+       return &c
+}
+func (n *BlockStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doNodes(n.List, do) {
+               return true
+       }
+       return false
+}
+func (n *BlockStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editNodes(n.List, edit)
+}
+
+func (n *BranchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *BranchStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *BranchStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *BranchStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *CallExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Args = copyNodes(c.Args)
+       c.KeepAlive = copyNames(c.KeepAlive)
+       return &c
+}
+func (n *CallExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if doNodes(n.Args, do) {
+               return true
+       }
+       if doNames(n.KeepAlive, do) {
+               return true
+       }
+       return false
+}
+func (n *CallExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       editNodes(n.Args, edit)
+       editNames(n.KeepAlive, edit)
+}
+
+func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *CaseClause) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.List = copyNodes(c.List)
+       c.Body = copyNodes(c.Body)
+       return &c
+}
+func (n *CaseClause) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Var != nil && do(n.Var) {
+               return true
+       }
+       if doNodes(n.List, do) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       return false
+}
+func (n *CaseClause) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Var != nil {
+               n.Var = edit(n.Var).(*Name)
+       }
+       editNodes(n.List, edit)
+       editNodes(n.Body, edit)
+}
+
+func (n *ChanType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ChanType) copy() Node {
+       c := *n
+       return &c
+}
+func (n *ChanType) doChildren(do func(Node) bool) bool {
+       if n.Elem != nil && do(n.Elem) {
+               return true
+       }
+       return false
+}
+func (n *ChanType) editChildren(edit func(Node) Node) {
+       if n.Elem != nil {
+               n.Elem = edit(n.Elem).(Ntype)
+       }
+}
+
+func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ClosureExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *ClosureExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *ClosureExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *CommClause) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Body = copyNodes(c.Body)
+       return &c
+}
+func (n *CommClause) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Comm != nil && do(n.Comm) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       return false
+}
+func (n *CommClause) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Comm != nil {
+               n.Comm = edit(n.Comm).(Node)
+       }
+       editNodes(n.Body, edit)
+}
+
+func (n *CompLitExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *CompLitExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.List = copyNodes(c.List)
+       return &c
+}
+func (n *CompLitExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Ntype != nil && do(n.Ntype) {
+               return true
+       }
+       if doNodes(n.List, do) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *CompLitExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Ntype != nil {
+               n.Ntype = edit(n.Ntype).(Ntype)
+       }
+       editNodes(n.List, edit)
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *ConstExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ConstExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *ConstExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *ConstExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *ConvExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ConvExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *ConvExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *ConvExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+}
+
+func (n *Decl) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *Decl) copy() Node {
+       c := *n
+       return &c
+}
+func (n *Decl) doChildren(do func(Node) bool) bool {
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *Decl) editChildren(edit func(Node) Node) {
+       if n.X != nil {
+               n.X = edit(n.X).(*Name)
+       }
+}
+
+func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ForStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Late = copyNodes(c.Late)
+       c.Body = copyNodes(c.Body)
+       return &c
+}
+func (n *ForStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Cond != nil && do(n.Cond) {
+               return true
+       }
+       if doNodes(n.Late, do) {
+               return true
+       }
+       if n.Post != nil && do(n.Post) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       return false
+}
+func (n *ForStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Cond != nil {
+               n.Cond = edit(n.Cond).(Node)
+       }
+       editNodes(n.Late, edit)
+       if n.Post != nil {
+               n.Post = edit(n.Post).(Node)
+       }
+       editNodes(n.Body, edit)
+}
+
+func (n *Func) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+
+func (n *FuncType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *FuncType) copy() Node {
+       c := *n
+       c.Recv = copyField(c.Recv)
+       c.Params = copyFields(c.Params)
+       c.Results = copyFields(c.Results)
+       return &c
+}
+func (n *FuncType) doChildren(do func(Node) bool) bool {
+       if doField(n.Recv, do) {
+               return true
+       }
+       if doFields(n.Params, do) {
+               return true
+       }
+       if doFields(n.Results, do) {
+               return true
+       }
+       return false
+}
+func (n *FuncType) editChildren(edit func(Node) Node) {
+       editField(n.Recv, edit)
+       editFields(n.Params, edit)
+       editFields(n.Results, edit)
+}
+
+func (n *GoDeferStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *GoDeferStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *GoDeferStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Call != nil && do(n.Call) {
+               return true
+       }
+       return false
+}
+func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Call != nil {
+               n.Call = edit(n.Call).(Node)
+       }
+}
+
+func (n *Ident) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *Ident) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *Ident) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *Ident) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *IfStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *IfStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Body = copyNodes(c.Body)
+       c.Else = copyNodes(c.Else)
+       return &c
+}
+func (n *IfStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Cond != nil && do(n.Cond) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       if doNodes(n.Else, do) {
+               return true
+       }
+       return false
+}
+func (n *IfStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Cond != nil {
+               n.Cond = edit(n.Cond).(Node)
+       }
+       editNodes(n.Body, edit)
+       editNodes(n.Else, edit)
+}
+
+func (n *IndexExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *IndexExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *IndexExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Index != nil && do(n.Index) {
+               return true
+       }
+       return false
+}
+func (n *IndexExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Index != nil {
+               n.Index = edit(n.Index).(Node)
+       }
+}
+
+func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *InlineMarkStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *InlineMarkStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *InlinedCallExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Body = copyNodes(c.Body)
+       c.ReturnVars = copyNodes(c.ReturnVars)
+       return &c
+}
+func (n *InlinedCallExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       if doNodes(n.ReturnVars, do) {
+               return true
+       }
+       return false
+}
+func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editNodes(n.Body, edit)
+       editNodes(n.ReturnVars, edit)
+}
+
+func (n *InterfaceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *InterfaceType) copy() Node {
+       c := *n
+       c.Methods = copyFields(c.Methods)
+       return &c
+}
+func (n *InterfaceType) doChildren(do func(Node) bool) bool {
+       if doFields(n.Methods, do) {
+               return true
+       }
+       return false
+}
+func (n *InterfaceType) editChildren(edit func(Node) Node) {
+       editFields(n.Methods, edit)
+}
+
+func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *KeyExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *KeyExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Key != nil && do(n.Key) {
+               return true
+       }
+       if n.Value != nil && do(n.Value) {
+               return true
+       }
+       return false
+}
+func (n *KeyExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Key != nil {
+               n.Key = edit(n.Key).(Node)
+       }
+       if n.Value != nil {
+               n.Value = edit(n.Value).(Node)
+       }
+}
+
+func (n *LabelStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *LabelStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *LabelStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *LabelStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *LinksymOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *LinksymOffsetExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *LinksymOffsetExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *LogicalExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *LogicalExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Y != nil && do(n.Y) {
+               return true
+       }
+       return false
+}
+func (n *LogicalExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Y != nil {
+               n.Y = edit(n.Y).(Node)
+       }
+}
+
+func (n *MakeExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *MakeExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *MakeExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Len != nil && do(n.Len) {
+               return true
+       }
+       if n.Cap != nil && do(n.Cap) {
+               return true
+       }
+       return false
+}
+func (n *MakeExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Len != nil {
+               n.Len = edit(n.Len).(Node)
+       }
+       if n.Cap != nil {
+               n.Cap = edit(n.Cap).(Node)
+       }
+}
+
+func (n *MapType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *MapType) copy() Node {
+       c := *n
+       return &c
+}
+func (n *MapType) doChildren(do func(Node) bool) bool {
+       if n.Key != nil && do(n.Key) {
+               return true
+       }
+       if n.Elem != nil && do(n.Elem) {
+               return true
+       }
+       return false
+}
+func (n *MapType) editChildren(edit func(Node) Node) {
+       if n.Key != nil {
+               n.Key = edit(n.Key).(Ntype)
+       }
+       if n.Elem != nil {
+               n.Elem = edit(n.Elem).(Ntype)
+       }
+}
+
+func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+
+func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *NilExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *NilExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *NilExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *ParenExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ParenExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *ParenExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *ParenExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+}
+
+func (n *PkgName) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *PkgName) copy() Node {
+       c := *n
+       return &c
+}
+func (n *PkgName) doChildren(do func(Node) bool) bool {
+       return false
+}
+func (n *PkgName) editChildren(edit func(Node) Node) {
+}
+
+func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *RangeStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Body = copyNodes(c.Body)
+       return &c
+}
+func (n *RangeStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Key != nil && do(n.Key) {
+               return true
+       }
+       if n.Value != nil && do(n.Value) {
+               return true
+       }
+       if doNodes(n.Body, do) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *RangeStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Key != nil {
+               n.Key = edit(n.Key).(Node)
+       }
+       if n.Value != nil {
+               n.Value = edit(n.Value).(Node)
+       }
+       editNodes(n.Body, edit)
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ResultExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *ResultExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       return false
+}
+func (n *ResultExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+}
+
+func (n *ReturnStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ReturnStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Results = copyNodes(c.Results)
+       return &c
+}
+func (n *ReturnStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doNodes(n.Results, do) {
+               return true
+       }
+       return false
+}
+func (n *ReturnStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editNodes(n.Results, edit)
+}
+
+func (n *SelectStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SelectStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Cases = copyCommClauses(c.Cases)
+       c.Compiled = copyNodes(c.Compiled)
+       return &c
+}
+func (n *SelectStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if doCommClauses(n.Cases, do) {
+               return true
+       }
+       if doNodes(n.Compiled, do) {
+               return true
+       }
+       return false
+}
+func (n *SelectStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       editCommClauses(n.Cases, edit)
+       editNodes(n.Compiled, edit)
+}
+
+func (n *SelectorExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SelectorExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *SelectorExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Prealloc != nil && do(n.Prealloc) {
+               return true
+       }
+       return false
+}
+func (n *SelectorExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Prealloc != nil {
+               n.Prealloc = edit(n.Prealloc).(*Name)
+       }
+}
+
+func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SendStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *SendStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Chan != nil && do(n.Chan) {
+               return true
+       }
+       if n.Value != nil && do(n.Value) {
+               return true
+       }
+       return false
+}
+func (n *SendStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Chan != nil {
+               n.Chan = edit(n.Chan).(Node)
+       }
+       if n.Value != nil {
+               n.Value = edit(n.Value).(Node)
+       }
+}
+
+func (n *SliceExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SliceExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *SliceExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Low != nil && do(n.Low) {
+               return true
+       }
+       if n.High != nil && do(n.High) {
+               return true
+       }
+       if n.Max != nil && do(n.Max) {
+               return true
+       }
+       return false
+}
+func (n *SliceExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Low != nil {
+               n.Low = edit(n.Low).(Node)
+       }
+       if n.High != nil {
+               n.High = edit(n.High).(Node)
+       }
+       if n.Max != nil {
+               n.Max = edit(n.Max).(Node)
+       }
+}
+
+func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SliceHeaderExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *SliceHeaderExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Ptr != nil && do(n.Ptr) {
+               return true
+       }
+       if n.Len != nil && do(n.Len) {
+               return true
+       }
+       if n.Cap != nil && do(n.Cap) {
+               return true
+       }
+       return false
+}
+func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Ptr != nil {
+               n.Ptr = edit(n.Ptr).(Node)
+       }
+       if n.Len != nil {
+               n.Len = edit(n.Len).(Node)
+       }
+       if n.Cap != nil {
+               n.Cap = edit(n.Cap).(Node)
+       }
+}
+
+func (n *SliceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SliceType) copy() Node {
+       c := *n
+       return &c
+}
+func (n *SliceType) doChildren(do func(Node) bool) bool {
+       if n.Elem != nil && do(n.Elem) {
+               return true
+       }
+       return false
+}
+func (n *SliceType) editChildren(edit func(Node) Node) {
+       if n.Elem != nil {
+               n.Elem = edit(n.Elem).(Ntype)
+       }
+}
+
+func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *StarExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *StarExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *StarExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+}
+
+func (n *StructKeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *StructKeyExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *StructKeyExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Value != nil && do(n.Value) {
+               return true
+       }
+       return false
+}
+func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Value != nil {
+               n.Value = edit(n.Value).(Node)
+       }
+}
+
+func (n *StructType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *StructType) copy() Node {
+       c := *n
+       c.Fields = copyFields(c.Fields)
+       return &c
+}
+func (n *StructType) doChildren(do func(Node) bool) bool {
+       if doFields(n.Fields, do) {
+               return true
+       }
+       return false
+}
+func (n *StructType) editChildren(edit func(Node) Node) {
+       editFields(n.Fields, edit)
+}
+
+func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *SwitchStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       c.Cases = copyCaseClauses(c.Cases)
+       c.Compiled = copyNodes(c.Compiled)
+       return &c
+}
+func (n *SwitchStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Tag != nil && do(n.Tag) {
+               return true
+       }
+       if doCaseClauses(n.Cases, do) {
+               return true
+       }
+       if doNodes(n.Compiled, do) {
+               return true
+       }
+       return false
+}
+func (n *SwitchStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Tag != nil {
+               n.Tag = edit(n.Tag).(Node)
+       }
+       editCaseClauses(n.Cases, edit)
+       editNodes(n.Compiled, edit)
+}
+
+func (n *TailCallStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *TailCallStmt) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *TailCallStmt) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.Target != nil && do(n.Target) {
+               return true
+       }
+       return false
+}
+func (n *TailCallStmt) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.Target != nil {
+               n.Target = edit(n.Target).(*Name)
+       }
+}
+
+func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *TypeAssertExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *TypeAssertExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       if n.Ntype != nil && do(n.Ntype) {
+               return true
+       }
+       return false
+}
+func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+       if n.Ntype != nil {
+               n.Ntype = edit(n.Ntype).(Ntype)
+       }
+}
+
+func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *TypeSwitchGuard) copy() Node {
+       c := *n
+       return &c
+}
+func (n *TypeSwitchGuard) doChildren(do func(Node) bool) bool {
+       if n.Tag != nil && do(n.Tag) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
+       if n.Tag != nil {
+               n.Tag = edit(n.Tag).(*Ident)
+       }
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+}
+
+func (n *UnaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *UnaryExpr) copy() Node {
+       c := *n
+       c.init = copyNodes(c.init)
+       return &c
+}
+func (n *UnaryExpr) doChildren(do func(Node) bool) bool {
+       if doNodes(n.init, do) {
+               return true
+       }
+       if n.X != nil && do(n.X) {
+               return true
+       }
+       return false
+}
+func (n *UnaryExpr) editChildren(edit func(Node) Node) {
+       editNodes(n.init, edit)
+       if n.X != nil {
+               n.X = edit(n.X).(Node)
+       }
+}
+
+func (n *typeNode) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *typeNode) copy() Node {
+       c := *n
+       return &c
+}
+func (n *typeNode) doChildren(do func(Node) bool) bool {
+       return false
+}
+func (n *typeNode) editChildren(edit func(Node) Node) {
+}
+
+func copyCaseClauses(list []*CaseClause) []*CaseClause {
+       if list == nil {
+               return nil
+       }
+       c := make([]*CaseClause, len(list))
+       copy(c, list)
+       return c
+}
+func doCaseClauses(list []*CaseClause, do func(Node) bool) bool {
+       for _, x := range list {
+               if x != nil && do(x) {
+                       return true
+               }
+       }
+       return false
+}
+func editCaseClauses(list []*CaseClause, edit func(Node) Node) {
+       for i, x := range list {
+               if x != nil {
+                       list[i] = edit(x).(*CaseClause)
+               }
+       }
+}
+
+func copyCommClauses(list []*CommClause) []*CommClause {
+       if list == nil {
+               return nil
+       }
+       c := make([]*CommClause, len(list))
+       copy(c, list)
+       return c
+}
+func doCommClauses(list []*CommClause, do func(Node) bool) bool {
+       for _, x := range list {
+               if x != nil && do(x) {
+                       return true
+               }
+       }
+       return false
+}
+func editCommClauses(list []*CommClause, edit func(Node) Node) {
+       for i, x := range list {
+               if x != nil {
+                       list[i] = edit(x).(*CommClause)
+               }
+       }
+}
+
+func copyNames(list []*Name) []*Name {
+       if list == nil {
+               return nil
+       }
+       c := make([]*Name, len(list))
+       copy(c, list)
+       return c
+}
+func doNames(list []*Name, do func(Node) bool) bool {
+       for _, x := range list {
+               if x != nil && do(x) {
+                       return true
+               }
+       }
+       return false
+}
+func editNames(list []*Name, edit func(Node) Node) {
+       for i, x := range list {
+               if x != nil {
+                       list[i] = edit(x).(*Name)
+               }
+       }
+}
+
+func copyNodes(list []Node) []Node {
+       if list == nil {
+               return nil
+       }
+       c := make([]Node, len(list))
+       copy(c, list)
+       return c
+}
+func doNodes(list []Node, do func(Node) bool) bool {
+       for _, x := range list {
+               if x != nil && do(x) {
+                       return true
+               }
+       }
+       return false
+}
+func editNodes(list []Node, edit func(Node) Node) {
+       for i, x := range list {
+               if x != nil {
+                       list[i] = edit(x).(Node)
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
new file mode 100644 (file)
index 0000000..15c60ba
--- /dev/null
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -0,0 +1,174 @@
+// Code generated by "stringer -type=Op -trimprefix=O node.go"; DO NOT EDIT.
+
+package ir
+
+import "strconv"
+
+func _() {
+       // An "invalid array index" compiler error signifies that the constant values have changed.
+       // Re-run the stringer command to generate them again.
+       var x [1]struct{}
+       _ = x[OXXX-0]
+       _ = x[ONAME-1]
+       _ = x[ONONAME-2]
+       _ = x[OTYPE-3]
+       _ = x[OPACK-4]
+       _ = x[OLITERAL-5]
+       _ = x[ONIL-6]
+       _ = x[OADD-7]
+       _ = x[OSUB-8]
+       _ = x[OOR-9]
+       _ = x[OXOR-10]
+       _ = x[OADDSTR-11]
+       _ = x[OADDR-12]
+       _ = x[OANDAND-13]
+       _ = x[OAPPEND-14]
+       _ = x[OBYTES2STR-15]
+       _ = x[OBYTES2STRTMP-16]
+       _ = x[ORUNES2STR-17]
+       _ = x[OSTR2BYTES-18]
+       _ = x[OSTR2BYTESTMP-19]
+       _ = x[OSTR2RUNES-20]
+       _ = x[OAS-21]
+       _ = x[OAS2-22]
+       _ = x[OAS2DOTTYPE-23]
+       _ = x[OAS2FUNC-24]
+       _ = x[OAS2MAPR-25]
+       _ = x[OAS2RECV-26]
+       _ = x[OASOP-27]
+       _ = x[OCALL-28]
+       _ = x[OCALLFUNC-29]
+       _ = x[OCALLMETH-30]
+       _ = x[OCALLINTER-31]
+       _ = x[OCALLPART-32]
+       _ = x[OCAP-33]
+       _ = x[OCLOSE-34]
+       _ = x[OCLOSURE-35]
+       _ = x[OCOMPLIT-36]
+       _ = x[OMAPLIT-37]
+       _ = x[OSTRUCTLIT-38]
+       _ = x[OARRAYLIT-39]
+       _ = x[OSLICELIT-40]
+       _ = x[OPTRLIT-41]
+       _ = x[OCONV-42]
+       _ = x[OCONVIFACE-43]
+       _ = x[OCONVNOP-44]
+       _ = x[OCOPY-45]
+       _ = x[ODCL-46]
+       _ = x[ODCLFUNC-47]
+       _ = x[ODCLCONST-48]
+       _ = x[ODCLTYPE-49]
+       _ = x[ODELETE-50]
+       _ = x[ODOT-51]
+       _ = x[ODOTPTR-52]
+       _ = x[ODOTMETH-53]
+       _ = x[ODOTINTER-54]
+       _ = x[OXDOT-55]
+       _ = x[ODOTTYPE-56]
+       _ = x[ODOTTYPE2-57]
+       _ = x[OEQ-58]
+       _ = x[ONE-59]
+       _ = x[OLT-60]
+       _ = x[OLE-61]
+       _ = x[OGE-62]
+       _ = x[OGT-63]
+       _ = x[ODEREF-64]
+       _ = x[OINDEX-65]
+       _ = x[OINDEXMAP-66]
+       _ = x[OKEY-67]
+       _ = x[OSTRUCTKEY-68]
+       _ = x[OLEN-69]
+       _ = x[OMAKE-70]
+       _ = x[OMAKECHAN-71]
+       _ = x[OMAKEMAP-72]
+       _ = x[OMAKESLICE-73]
+       _ = x[OMAKESLICECOPY-74]
+       _ = x[OMUL-75]
+       _ = x[ODIV-76]
+       _ = x[OMOD-77]
+       _ = x[OLSH-78]
+       _ = x[ORSH-79]
+       _ = x[OAND-80]
+       _ = x[OANDNOT-81]
+       _ = x[ONEW-82]
+       _ = x[ONOT-83]
+       _ = x[OBITNOT-84]
+       _ = x[OPLUS-85]
+       _ = x[ONEG-86]
+       _ = x[OOROR-87]
+       _ = x[OPANIC-88]
+       _ = x[OPRINT-89]
+       _ = x[OPRINTN-90]
+       _ = x[OPAREN-91]
+       _ = x[OSEND-92]
+       _ = x[OSLICE-93]
+       _ = x[OSLICEARR-94]
+       _ = x[OSLICESTR-95]
+       _ = x[OSLICE3-96]
+       _ = x[OSLICE3ARR-97]
+       _ = x[OSLICEHEADER-98]
+       _ = x[ORECOVER-99]
+       _ = x[ORECV-100]
+       _ = x[ORUNESTR-101]
+       _ = x[OSELRECV2-102]
+       _ = x[OIOTA-103]
+       _ = x[OREAL-104]
+       _ = x[OIMAG-105]
+       _ = x[OCOMPLEX-106]
+       _ = x[OALIGNOF-107]
+       _ = x[OOFFSETOF-108]
+       _ = x[OSIZEOF-109]
+       _ = x[OMETHEXPR-110]
+       _ = x[OSTMTEXPR-111]
+       _ = x[OBLOCK-112]
+       _ = x[OBREAK-113]
+       _ = x[OCASE-114]
+       _ = x[OCONTINUE-115]
+       _ = x[ODEFER-116]
+       _ = x[OFALL-117]
+       _ = x[OFOR-118]
+       _ = x[OFORUNTIL-119]
+       _ = x[OGOTO-120]
+       _ = x[OIF-121]
+       _ = x[OLABEL-122]
+       _ = x[OGO-123]
+       _ = x[ORANGE-124]
+       _ = x[ORETURN-125]
+       _ = x[OSELECT-126]
+       _ = x[OSWITCH-127]
+       _ = x[OTYPESW-128]
+       _ = x[OTCHAN-129]
+       _ = x[OTMAP-130]
+       _ = x[OTSTRUCT-131]
+       _ = x[OTINTER-132]
+       _ = x[OTFUNC-133]
+       _ = x[OTARRAY-134]
+       _ = x[OTSLICE-135]
+       _ = x[OINLCALL-136]
+       _ = x[OEFACE-137]
+       _ = x[OITAB-138]
+       _ = x[OIDATA-139]
+       _ = x[OSPTR-140]
+       _ = x[OCFUNC-141]
+       _ = x[OCHECKNIL-142]
+       _ = x[OVARDEF-143]
+       _ = x[OVARKILL-144]
+       _ = x[OVARLIVE-145]
+       _ = x[ORESULT-146]
+       _ = x[OINLMARK-147]
+       _ = x[OLINKSYMOFFSET-148]
+       _ = x[OTAILCALL-149]
+       _ = x[OGETG-150]
+       _ = x[OEND-151]
+}
+
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 852, 860, 864, 867}
+
+func (i Op) String() string {
+       if i >= Op(len(_Op_index)-1) {
+               return "Op(" + strconv.FormatInt(int64(i), 10) + ")"
+       }
+       return _Op_name[_Op_index[i]:_Op_index[i+1]]
+}

diff --git a/src/cmd/compile/internal/ir/package.go b/src/cmd/compile/internal/ir/package.go
new file mode 100644 (file)
index 0000000..3896e2b
--- /dev/null
+++ b/src/cmd/compile/internal/ir/package.go
@@ -0,0 +1,35 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import "cmd/compile/internal/types"
+
+// A Package holds information about the package being compiled.
+type Package struct {
+       // Imports, listed in source order.
+       // See golang.org/issue/31636.
+       Imports []*types.Pkg
+
+       // Init functions, listed in source order.
+       Inits []*Func
+
+       // Top-level declarations.
+       Decls []Node
+
+       // Extern (package global) declarations.
+       Externs []Node
+
+       // Assembly function declarations.
+       Asms []*Name
+
+       // Cgo directives.
+       CgoPragmas [][]string
+
+       // Variables with //go:embed lines.
+       Embeds []*Name
+
+       // Exported (or re-exported) symbols.
+       Exports []*Name
+}

diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/ir/scc.go
similarity index 74%
rename from src/cmd/compile/internal/gc/scc.go
rename to src/cmd/compile/internal/ir/scc.go
index 5c7935aa87674dd1348d23fbdb838d2112daf665..83c6074170b31370e0e6c6e71f35e56533204d2b 100644 (file)
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/ir/scc.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 // Strongly connected components.
 //
@@ -30,13 +30,13 @@ package gc
 // when analyzing a set of mutually recursive functions.
 
 type bottomUpVisitor struct {
-       analyze  func([]*Node, bool)
+       analyze  func([]*Func, bool)
        visitgen uint32
-       nodeID   map[*Node]uint32
-       stack    []*Node
+       nodeID   map[*Func]uint32
+       stack    []*Func
 }
 
-// visitBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
+// VisitFuncsBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
 // It calls analyze with successive groups of functions, working from
 // the bottom of the call graph upward. Each time analyze is called with
 // a list of functions, every function on that list only calls other functions
@@ -49,18 +49,21 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list []*Node, analyze func(list []*Node, recursive bool)) {
+func VisitFuncsBottomUp(list []Node, analyze func(list []*Func, recursive bool)) {
        var v bottomUpVisitor
        v.analyze = analyze
-       v.nodeID = make(map[*Node]uint32)
+       v.nodeID = make(map[*Func]uint32)
        for _, n := range list {
-               if n.Op == ODCLFUNC && !n.Func.IsHiddenClosure() {
-                       v.visit(n)
+               if n.Op() == ODCLFUNC {
+                       n := n.(*Func)
+                       if !n.IsHiddenClosure() {
+                               v.visit(n)
+                       }
                }
        }
 }
 
-func (v *bottomUpVisitor) visit(n *Node) uint32 {
+func (v *bottomUpVisitor) visit(n *Func) uint32 {
        if id := v.nodeID[n]; id > 0 {
                // already visited
                return id
@@ -73,42 +76,31 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
        min := v.visitgen
        v.stack = append(v.stack, n)
 
-       inspectList(n.Nbody, func(n *Node) bool {
-               switch n.Op {
-               case ONAME:
-                       if n.Class() == PFUNC {
-                               if n.isMethodExpression() {
-                                       n = asNode(n.Type.Nname())
-                               }
-                               if n != nil && n.Name.Defn != nil {
-                                       if m := v.visit(n.Name.Defn); m < min {
-                                               min = m
-                                       }
-                               }
+       do := func(defn Node) {
+               if defn != nil {
+                       if m := v.visit(defn.(*Func)); m < min {
+                               min = m
                        }
-               case ODOTMETH:
-                       fn := asNode(n.Type.Nname())
-                       if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
-                               if m := v.visit(fn.Name.Defn); m < min {
-                                       min = m
-                               }
+               }
+       }
+
+       Visit(n, func(n Node) {
+               switch n.Op() {
+               case ONAME:
+                       if n := n.(*Name); n.Class == PFUNC {
+                               do(n.Defn)
                        }
-               case OCALLPART:
-                       fn := asNode(callpartMethod(n).Type.Nname())
-                       if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
-                               if m := v.visit(fn.Name.Defn); m < min {
-                                       min = m
-                               }
+               case ODOTMETH, OCALLPART, OMETHEXPR:
+                       if fn := MethodExprName(n); fn != nil {
+                               do(fn.Defn)
                        }
                case OCLOSURE:
-                       if m := v.visit(n.Func.Closure); m < min {
-                               min = m
-                       }
+                       n := n.(*ClosureExpr)
+                       do(n.Func)
                }
-               return true
        })
 
-       if (min == id || min == id+1) && !n.Func.IsHiddenClosure() {
+       if (min == id || min == id+1) && !n.IsHiddenClosure() {
                // This node is the root of a strongly connected component.
 
                // The original min passed to visitcodelist was v.nodeID[n]+1.

diff --git a/src/cmd/compile/internal/gc/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
similarity index 88%
rename from src/cmd/compile/internal/gc/sizeof_test.go
rename to src/cmd/compile/internal/ir/sizeof_test.go
index ce4a216c2e2daa1090910c62eb2dd7b4cda4e2d5..d8c1518b90f347658a11ce323694c1477e8bc77d 100644 (file)
--- a/src/cmd/compile/internal/gc/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 import (
        "reflect"
@@ -20,10 +20,8 @@ func TestSizeof(t *testing.T) {
                _32bit uintptr     // size on 32bit platforms
                _64bit uintptr     // size on 64bit platforms
        }{
-               {Func{}, 124, 224},
-               {Name{}, 32, 56},
-               {Param{}, 24, 48},
-               {Node{}, 76, 128},
+               {Func{}, 188, 328},
+               {Name{}, 112, 200},
        }
 
        for _, tt := range tests {

diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
new file mode 100644 (file)
index 0000000..c304867
--- /dev/null
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -0,0 +1,414 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
+type Decl struct {
+       miniNode
+       X *Name // the thing being declared
+}
+
+func NewDecl(pos src.XPos, op Op, x *Name) *Decl {
+       n := &Decl{X: x}
+       n.pos = pos
+       switch op {
+       default:
+               panic("invalid Decl op " + op.String())
+       case ODCL, ODCLCONST, ODCLTYPE:
+               n.op = op
+       }
+       return n
+}
+
+func (*Decl) isStmt() {}
+
+// A Stmt is a Node that can appear as a statement.
+// This includes statement-like expressions such as f().
+//
+// (It's possible it should include <-c, but that would require
+// splitting ORECV out of UnaryExpr, which hasn't yet been
+// necessary. Maybe instead we will introduce ExprStmt at
+// some point.)
+type Stmt interface {
+       Node
+       isStmt()
+}
+
+// A miniStmt is a miniNode with extra fields common to statements.
+type miniStmt struct {
+       miniNode
+       init Nodes
+}
+
+func (*miniStmt) isStmt() {}
+
+func (n *miniStmt) Init() Nodes     { return n.init }
+func (n *miniStmt) SetInit(x Nodes) { n.init = x }
+func (n *miniStmt) PtrInit() *Nodes { return &n.init }
+
+// An AssignListStmt is an assignment statement with
+// more than one item on at least one side: Lhs = Rhs.
+// If Def is true, the assignment is a :=.
+type AssignListStmt struct {
+       miniStmt
+       Lhs Nodes
+       Def bool
+       Rhs Nodes
+}
+
+func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
+       n := &AssignListStmt{}
+       n.pos = pos
+       n.SetOp(op)
+       n.Lhs = lhs
+       n.Rhs = rhs
+       return n
+}
+
+func (n *AssignListStmt) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
+               n.op = op
+       }
+}
+
+// An AssignStmt is a simple assignment statement: X = Y.
+// If Def is true, the assignment is a :=.
+type AssignStmt struct {
+       miniStmt
+       X   Node
+       Def bool
+       Y   Node
+}
+
+func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
+       n := &AssignStmt{X: x, Y: y}
+       n.pos = pos
+       n.op = OAS
+       return n
+}
+
+func (n *AssignStmt) SetOp(op Op) {
+       switch op {
+       default:
+               panic(n.no("SetOp " + op.String()))
+       case OAS:
+               n.op = op
+       }
+}
+
+// An AssignOpStmt is an AsOp= assignment statement: X AsOp= Y.
+type AssignOpStmt struct {
+       miniStmt
+       X      Node
+       AsOp   Op // OADD etc
+       Y      Node
+       IncDec bool // actually ++ or --
+}
+
+func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {
+       n := &AssignOpStmt{AsOp: asOp, X: x, Y: y}
+       n.pos = pos
+       n.op = OASOP
+       return n
+}
+
+// A BlockStmt is a block: { List }.
+type BlockStmt struct {
+       miniStmt
+       List Nodes
+}
+
+func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
+       n := &BlockStmt{}
+       n.pos = pos
+       if !pos.IsKnown() {
+               n.pos = base.Pos
+               if len(list) > 0 {
+                       n.pos = list[0].Pos()
+               }
+       }
+       n.op = OBLOCK
+       n.List = list
+       return n
+}
+
+// A BranchStmt is a break, continue, fallthrough, or goto statement.
+type BranchStmt struct {
+       miniStmt
+       Label *types.Sym // label if present
+}
+
+func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
+       switch op {
+       case OBREAK, OCONTINUE, OFALL, OGOTO:
+               // ok
+       default:
+               panic("NewBranch " + op.String())
+       }
+       n := &BranchStmt{Label: label}
+       n.pos = pos
+       n.op = op
+       return n
+}
+
+func (n *BranchStmt) Sym() *types.Sym { return n.Label }
+
+// A CaseClause is a case statement in a switch or select: case List: Body.
+type CaseClause struct {
+       miniStmt
+       Var  *Name // declared variable for this case in type switch
+       List Nodes // list of expressions for switch, early select
+       Body Nodes
+}
+
+func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause {
+       n := &CaseClause{List: list, Body: body}
+       n.pos = pos
+       n.op = OCASE
+       return n
+}
+
+type CommClause struct {
+       miniStmt
+       Comm Node // communication case
+       Body Nodes
+}
+
+func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause {
+       n := &CommClause{Comm: comm, Body: body}
+       n.pos = pos
+       n.op = OCASE
+       return n
+}
+
+// A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
+// Op can be OFOR or OFORUNTIL (!Cond).
+type ForStmt struct {
+       miniStmt
+       Label    *types.Sym
+       Cond     Node
+       Late     Nodes
+       Post     Node
+       Body     Nodes
+       HasBreak bool
+}
+
+func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node) *ForStmt {
+       n := &ForStmt{Cond: cond, Post: post}
+       n.pos = pos
+       n.op = OFOR
+       if init != nil {
+               n.init = []Node{init}
+       }
+       n.Body = body
+       return n
+}
+
+func (n *ForStmt) SetOp(op Op) {
+       if op != OFOR && op != OFORUNTIL {
+               panic(n.no("SetOp " + op.String()))
+       }
+       n.op = op
+}
+
+// A GoDeferStmt is a go or defer statement: go Call / defer Call.
+//
+// The two opcodes use a signle syntax because the implementations
+// are very similar: both are concerned with saving Call and running it
+// in a different context (a separate goroutine or a later time).
+type GoDeferStmt struct {
+       miniStmt
+       Call Node
+}
+
+func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt {
+       n := &GoDeferStmt{Call: call}
+       n.pos = pos
+       switch op {
+       case ODEFER, OGO:
+               n.op = op
+       default:
+               panic("NewGoDeferStmt " + op.String())
+       }
+       return n
+}
+
+// A IfStmt is a return statement: if Init; Cond { Then } else { Else }.
+type IfStmt struct {
+       miniStmt
+       Cond   Node
+       Body   Nodes
+       Else   Nodes
+       Likely bool // code layout hint
+}
+
+func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
+       n := &IfStmt{Cond: cond}
+       n.pos = pos
+       n.op = OIF
+       n.Body = body
+       n.Else = els
+       return n
+}
+
+// An InlineMarkStmt is a marker placed just before an inlined body.
+type InlineMarkStmt struct {
+       miniStmt
+       Index int64
+}
+
+func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
+       n := &InlineMarkStmt{Index: index}
+       n.pos = pos
+       n.op = OINLMARK
+       return n
+}
+
+func (n *InlineMarkStmt) Offset() int64     { return n.Index }
+func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
+
+// A LabelStmt is a label statement (just the label, not including the statement it labels).
+type LabelStmt struct {
+       miniStmt
+       Label *types.Sym // "Label:"
+}
+
+func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
+       n := &LabelStmt{Label: label}
+       n.pos = pos
+       n.op = OLABEL
+       return n
+}
+
+func (n *LabelStmt) Sym() *types.Sym { return n.Label }
+
+// A RangeStmt is a range loop: for Key, Value = range X { Body }
+type RangeStmt struct {
+       miniStmt
+       Label    *types.Sym
+       Def      bool
+       X        Node
+       Key      Node
+       Value    Node
+       Body     Nodes
+       HasBreak bool
+       Prealloc *Name
+}
+
+func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node) *RangeStmt {
+       n := &RangeStmt{X: x, Key: key, Value: value}
+       n.pos = pos
+       n.op = ORANGE
+       n.Body = body
+       return n
+}
+
+// A ReturnStmt is a return statement.
+type ReturnStmt struct {
+       miniStmt
+       origNode       // for typecheckargs rewrite
+       Results  Nodes // return list
+}
+
+func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
+       n := &ReturnStmt{}
+       n.pos = pos
+       n.op = ORETURN
+       n.orig = n
+       n.Results = results
+       return n
+}
+
+// A SelectStmt is a block: { Cases }.
+type SelectStmt struct {
+       miniStmt
+       Label    *types.Sym
+       Cases    []*CommClause
+       HasBreak bool
+
+       // TODO(rsc): Instead of recording here, replace with a block?
+       Compiled Nodes // compiled form, after walkSwitch
+}
+
+func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt {
+       n := &SelectStmt{Cases: cases}
+       n.pos = pos
+       n.op = OSELECT
+       return n
+}
+
+// A SendStmt is a send statement: X <- Y.
+type SendStmt struct {
+       miniStmt
+       Chan  Node
+       Value Node
+}
+
+func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
+       n := &SendStmt{Chan: ch, Value: value}
+       n.pos = pos
+       n.op = OSEND
+       return n
+}
+
+// A SwitchStmt is a switch statement: switch Init; Expr { Cases }.
+type SwitchStmt struct {
+       miniStmt
+       Tag      Node
+       Cases    []*CaseClause
+       Label    *types.Sym
+       HasBreak bool
+
+       // TODO(rsc): Instead of recording here, replace with a block?
+       Compiled Nodes // compiled form, after walkSwitch
+}
+
+func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
+       n := &SwitchStmt{Tag: tag, Cases: cases}
+       n.pos = pos
+       n.op = OSWITCH
+       return n
+}
+
+// A TailCallStmt is a tail call statement, which is used for back-end
+// code generation to jump directly to another function entirely.
+type TailCallStmt struct {
+       miniStmt
+       Target *Name
+}
+
+func NewTailCallStmt(pos src.XPos, target *Name) *TailCallStmt {
+       if target.Op() != ONAME || target.Class != PFUNC {
+               base.FatalfAt(pos, "tail call to non-func %v", target)
+       }
+       n := &TailCallStmt{Target: target}
+       n.pos = pos
+       n.op = OTAILCALL
+       return n
+}
+
+// A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
+type TypeSwitchGuard struct {
+       miniNode
+       Tag  *Ident
+       X    Node
+       Used bool
+}
+
+func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard {
+       n := &TypeSwitchGuard{Tag: tag, X: x}
+       n.pos = pos
+       n.op = OTYPESW
+       return n
+}

diff --git a/src/cmd/compile/internal/ir/symtab.go b/src/cmd/compile/internal/ir/symtab.go
new file mode 100644 (file)
index 0000000..61727fb
--- /dev/null
+++ b/src/cmd/compile/internal/ir/symtab.go
@@ -0,0 +1,72 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+// Syms holds known symbols.
+var Syms struct {
+       AssertE2I       *obj.LSym
+       AssertE2I2      *obj.LSym
+       AssertI2I       *obj.LSym
+       AssertI2I2      *obj.LSym
+       Deferproc       *obj.LSym
+       DeferprocStack  *obj.LSym
+       Deferreturn     *obj.LSym
+       Duffcopy        *obj.LSym
+       Duffzero        *obj.LSym
+       GCWriteBarrier  *obj.LSym
+       Goschedguarded  *obj.LSym
+       Growslice       *obj.LSym
+       Msanread        *obj.LSym
+       Msanwrite       *obj.LSym
+       Msanmove        *obj.LSym
+       Newobject       *obj.LSym
+       Newproc         *obj.LSym
+       Panicdivide     *obj.LSym
+       Panicshift      *obj.LSym
+       PanicdottypeE   *obj.LSym
+       PanicdottypeI   *obj.LSym
+       Panicnildottype *obj.LSym
+       Panicoverflow   *obj.LSym
+       Raceread        *obj.LSym
+       Racereadrange   *obj.LSym
+       Racewrite       *obj.LSym
+       Racewriterange  *obj.LSym
+       // Wasm
+       SigPanic        *obj.LSym
+       Staticuint64s   *obj.LSym
+       Typedmemclr     *obj.LSym
+       Typedmemmove    *obj.LSym
+       Udiv            *obj.LSym
+       WriteBarrier    *obj.LSym
+       Zerobase        *obj.LSym
+       ARM64HasATOMICS *obj.LSym
+       ARMHasVFPv4     *obj.LSym
+       X86HasFMA       *obj.LSym
+       X86HasPOPCNT    *obj.LSym
+       X86HasSSE41     *obj.LSym
+       // Wasm
+       WasmDiv *obj.LSym
+       // Wasm
+       WasmMove *obj.LSym
+       // Wasm
+       WasmZero *obj.LSym
+       // Wasm
+       WasmTruncS *obj.LSym
+       // Wasm
+       WasmTruncU *obj.LSym
+}
+
+// Pkgs holds known packages.
+var Pkgs struct {
+       Go      *types.Pkg
+       Itab    *types.Pkg
+       Runtime *types.Pkg
+       Unsafe  *types.Pkg
+}

diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
new file mode 100644 (file)
index 0000000..a903ea8
--- /dev/null
+++ b/src/cmd/compile/internal/ir/type.go
@@ -0,0 +1,310 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+       "fmt"
+)
+
+// Nodes that represent the syntax of a type before type-checking.
+// After type-checking, they serve only as shells around a *types.Type.
+// Calling TypeNode converts a *types.Type to a Node shell.
+
+// An Ntype is a Node that syntactically looks like a type.
+// It can be the raw syntax for a type before typechecking,
+// or it can be an OTYPE with Type() set to a *types.Type.
+// Note that syntax doesn't guarantee it's a type: an expression
+// like *fmt is an Ntype (we don't know whether names are types yet),
+// but at least 1+1 is not an Ntype.
+type Ntype interface {
+       Node
+       CanBeNtype()
+}
+
+// A miniType is a minimal type syntax Node implementation,
+// to be embedded as the first field in a larger node implementation.
+type miniType struct {
+       miniNode
+       typ *types.Type
+}
+
+func (*miniType) CanBeNtype() {}
+
+func (n *miniType) Type() *types.Type { return n.typ }
+
+// setOTYPE changes n to be an OTYPE node returning t.
+// Rewriting the node in place this way should not be strictly
+// necessary (we should be able to update the uses with
+// proper OTYPE nodes), but it's mostly harmless and easy
+// to keep doing for now.
+//
+// setOTYPE also records t.Nod = self if t.Nod is not already set.
+// (Some types are shared by multiple OTYPE nodes, so only
+// the first such node is used as t.Nod.)
+func (n *miniType) setOTYPE(t *types.Type, self Ntype) {
+       if n.typ != nil {
+               panic(n.op.String() + " SetType: type already set")
+       }
+       n.op = OTYPE
+       n.typ = t
+       t.SetNod(self)
+}
+
+func (n *miniType) Sym() *types.Sym { return nil }   // for Format OTYPE
+func (n *miniType) Implicit() bool  { return false } // for Format OTYPE
+
+// A ChanType represents a chan Elem syntax with the direction Dir.
+type ChanType struct {
+       miniType
+       Elem Ntype
+       Dir  types.ChanDir
+}
+
+func NewChanType(pos src.XPos, elem Ntype, dir types.ChanDir) *ChanType {
+       n := &ChanType{Elem: elem, Dir: dir}
+       n.op = OTCHAN
+       n.pos = pos
+       return n
+}
+
+func (n *ChanType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Elem = nil
+}
+
+// A MapType represents a map[Key]Value type syntax.
+type MapType struct {
+       miniType
+       Key  Ntype
+       Elem Ntype
+}
+
+func NewMapType(pos src.XPos, key, elem Ntype) *MapType {
+       n := &MapType{Key: key, Elem: elem}
+       n.op = OTMAP
+       n.pos = pos
+       return n
+}
+
+func (n *MapType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Key = nil
+       n.Elem = nil
+}
+
+// A StructType represents a struct { ... } type syntax.
+type StructType struct {
+       miniType
+       Fields []*Field
+}
+
+func NewStructType(pos src.XPos, fields []*Field) *StructType {
+       n := &StructType{Fields: fields}
+       n.op = OTSTRUCT
+       n.pos = pos
+       return n
+}
+
+func (n *StructType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Fields = nil
+}
+
+// An InterfaceType represents a struct { ... } type syntax.
+type InterfaceType struct {
+       miniType
+       Methods []*Field
+}
+
+func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
+       n := &InterfaceType{Methods: methods}
+       n.op = OTINTER
+       n.pos = pos
+       return n
+}
+
+func (n *InterfaceType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Methods = nil
+}
+
+// A FuncType represents a func(Args) Results type syntax.
+type FuncType struct {
+       miniType
+       Recv    *Field
+       Params  []*Field
+       Results []*Field
+}
+
+func NewFuncType(pos src.XPos, rcvr *Field, args, results []*Field) *FuncType {
+       n := &FuncType{Recv: rcvr, Params: args, Results: results}
+       n.op = OTFUNC
+       n.pos = pos
+       return n
+}
+
+func (n *FuncType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Recv = nil
+       n.Params = nil
+       n.Results = nil
+}
+
+// A Field is a declared struct field, interface method, or function argument.
+// It is not a Node.
+type Field struct {
+       Pos      src.XPos
+       Sym      *types.Sym
+       Ntype    Ntype
+       Type     *types.Type
+       Embedded bool
+       IsDDD    bool
+       Note     string
+       Decl     *Name
+}
+
+func NewField(pos src.XPos, sym *types.Sym, ntyp Ntype, typ *types.Type) *Field {
+       return &Field{Pos: pos, Sym: sym, Ntype: ntyp, Type: typ}
+}
+
+func (f *Field) String() string {
+       var typ string
+       if f.Type != nil {
+               typ = fmt.Sprint(f.Type)
+       } else {
+               typ = fmt.Sprint(f.Ntype)
+       }
+       if f.Sym != nil {
+               return fmt.Sprintf("%v %v", f.Sym, typ)
+       }
+       return typ
+}
+
+// TODO(mdempsky): Make Field a Node again so these can be generated?
+// Fields are Nodes in go/ast and cmd/compile/internal/syntax.
+
+func copyField(f *Field) *Field {
+       if f == nil {
+               return nil
+       }
+       c := *f
+       return &c
+}
+func doField(f *Field, do func(Node) bool) bool {
+       if f == nil {
+               return false
+       }
+       if f.Decl != nil && do(f.Decl) {
+               return true
+       }
+       if f.Ntype != nil && do(f.Ntype) {
+               return true
+       }
+       return false
+}
+func editField(f *Field, edit func(Node) Node) {
+       if f == nil {
+               return
+       }
+       if f.Decl != nil {
+               f.Decl = edit(f.Decl).(*Name)
+       }
+       if f.Ntype != nil {
+               f.Ntype = edit(f.Ntype).(Ntype)
+       }
+}
+
+func copyFields(list []*Field) []*Field {
+       out := make([]*Field, len(list))
+       for i, f := range list {
+               out[i] = copyField(f)
+       }
+       return out
+}
+func doFields(list []*Field, do func(Node) bool) bool {
+       for _, x := range list {
+               if doField(x, do) {
+                       return true
+               }
+       }
+       return false
+}
+func editFields(list []*Field, edit func(Node) Node) {
+       for _, f := range list {
+               editField(f, edit)
+       }
+}
+
+// A SliceType represents a []Elem type syntax.
+// If DDD is true, it's the ...Elem at the end of a function list.
+type SliceType struct {
+       miniType
+       Elem Ntype
+       DDD  bool
+}
+
+func NewSliceType(pos src.XPos, elem Ntype) *SliceType {
+       n := &SliceType{Elem: elem}
+       n.op = OTSLICE
+       n.pos = pos
+       return n
+}
+
+func (n *SliceType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Elem = nil
+}
+
+// An ArrayType represents a [Len]Elem type syntax.
+// If Len is nil, the type is a [...]Elem in an array literal.
+type ArrayType struct {
+       miniType
+       Len  Node
+       Elem Ntype
+}
+
+func NewArrayType(pos src.XPos, len Node, elem Ntype) *ArrayType {
+       n := &ArrayType{Len: len, Elem: elem}
+       n.op = OTARRAY
+       n.pos = pos
+       return n
+}
+
+func (n *ArrayType) SetOTYPE(t *types.Type) {
+       n.setOTYPE(t, n)
+       n.Len = nil
+       n.Elem = nil
+}
+
+// A typeNode is a Node wrapper for type t.
+type typeNode struct {
+       miniNode
+       typ *types.Type
+}
+
+func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
+       n := &typeNode{typ: typ}
+       n.pos = pos
+       n.op = OTYPE
+       return n
+}
+
+func (n *typeNode) Type() *types.Type { return n.typ }
+func (n *typeNode) Sym() *types.Sym   { return n.typ.Sym() }
+func (n *typeNode) CanBeNtype()       {}
+
+// TypeNode returns the Node representing the type t.
+func TypeNode(t *types.Type) Ntype {
+       if n := t.Obj(); n != nil {
+               if n.Type() != t {
+                       base.Fatalf("type skew: %v has type %v, but expected %v", n, n.Type(), t)
+               }
+               return n.(Ntype)
+       }
+       return newTypeNode(src.NoXPos, t)
+}

diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
new file mode 100644 (file)
index 0000000..ff45f31
--- /dev/null
+++ b/src/cmd/compile/internal/ir/val.go
@@ -0,0 +1,171 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ir
+
+import (
+       "go/constant"
+       "math"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/types"
+)
+
+func ConstType(n Node) constant.Kind {
+       if n == nil || n.Op() != OLITERAL {
+               return constant.Unknown
+       }
+       return n.Val().Kind()
+}
+
+// ValueInterface returns the constant value stored in n as an interface{}.
+// It returns int64s for ints and runes, float64s for floats,
+// and complex128s for complex values.
+func ConstValue(n Node) interface{} {
+       switch v := n.Val(); v.Kind() {
+       default:
+               base.Fatalf("unexpected constant: %v", v)
+               panic("unreachable")
+       case constant.Bool:
+               return constant.BoolVal(v)
+       case constant.String:
+               return constant.StringVal(v)
+       case constant.Int:
+               return IntVal(n.Type(), v)
+       case constant.Float:
+               return Float64Val(v)
+       case constant.Complex:
+               return complex(Float64Val(constant.Real(v)), Float64Val(constant.Imag(v)))
+       }
+}
+
+// int64Val returns v converted to int64.
+// Note: if t is uint64, very large values will be converted to negative int64.
+func IntVal(t *types.Type, v constant.Value) int64 {
+       if t.IsUnsigned() {
+               if x, ok := constant.Uint64Val(v); ok {
+                       return int64(x)
+               }
+       } else {
+               if x, ok := constant.Int64Val(v); ok {
+                       return x
+               }
+       }
+       base.Fatalf("%v out of range for %v", v, t)
+       panic("unreachable")
+}
+
+func Float64Val(v constant.Value) float64 {
+       if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
+               return x + 0 // avoid -0 (should not be needed, but be conservative)
+       }
+       base.Fatalf("bad float64 value: %v", v)
+       panic("unreachable")
+}
+
+func AssertValidTypeForConst(t *types.Type, v constant.Value) {
+       if !ValidTypeForConst(t, v) {
+               base.Fatalf("%v does not represent %v", t, v)
+       }
+}
+
+func ValidTypeForConst(t *types.Type, v constant.Value) bool {
+       switch v.Kind() {
+       case constant.Unknown:
+               return OKForConst[t.Kind()]
+       case constant.Bool:
+               return t.IsBoolean()
+       case constant.String:
+               return t.IsString()
+       case constant.Int:
+               return t.IsInteger()
+       case constant.Float:
+               return t.IsFloat()
+       case constant.Complex:
+               return t.IsComplex()
+       }
+
+       base.Fatalf("unexpected constant kind: %v", v)
+       panic("unreachable")
+}
+
+// nodlit returns a new untyped constant with value v.
+func NewLiteral(v constant.Value) Node {
+       return NewBasicLit(base.Pos, v)
+}
+
+func idealType(ct constant.Kind) *types.Type {
+       switch ct {
+       case constant.String:
+               return types.UntypedString
+       case constant.Bool:
+               return types.UntypedBool
+       case constant.Int:
+               return types.UntypedInt
+       case constant.Float:
+               return types.UntypedFloat
+       case constant.Complex:
+               return types.UntypedComplex
+       }
+       base.Fatalf("unexpected Ctype: %v", ct)
+       return nil
+}
+
+var OKForConst [types.NTYPE]bool
+
+// CanInt64 reports whether it is safe to call Int64Val() on n.
+func CanInt64(n Node) bool {
+       if !IsConst(n, constant.Int) {
+               return false
+       }
+
+       // if the value inside n cannot be represented as an int64, the
+       // return value of Int64 is undefined
+       _, ok := constant.Int64Val(n.Val())
+       return ok
+}
+
+// Int64Val returns n as an int64.
+// n must be an integer or rune constant.
+func Int64Val(n Node) int64 {
+       if !IsConst(n, constant.Int) {
+               base.Fatalf("Int64Val(%v)", n)
+       }
+       x, ok := constant.Int64Val(n.Val())
+       if !ok {
+               base.Fatalf("Int64Val(%v)", n)
+       }
+       return x
+}
+
+// Uint64Val returns n as an uint64.
+// n must be an integer or rune constant.
+func Uint64Val(n Node) uint64 {
+       if !IsConst(n, constant.Int) {
+               base.Fatalf("Uint64Val(%v)", n)
+       }
+       x, ok := constant.Uint64Val(n.Val())
+       if !ok {
+               base.Fatalf("Uint64Val(%v)", n)
+       }
+       return x
+}
+
+// BoolVal returns n as a bool.
+// n must be a boolean constant.
+func BoolVal(n Node) bool {
+       if !IsConst(n, constant.Bool) {
+               base.Fatalf("BoolVal(%v)", n)
+       }
+       return constant.BoolVal(n.Val())
+}
+
+// StringVal returns the value of a literal string Node as a string.
+// n must be a string constant.
+func StringVal(n Node) string {
+       if !IsConst(n, constant.String) {
+               base.Fatalf("StringVal(%v)", n)
+       }
+       return constant.StringVal(n.Val())
+}

diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
new file mode 100644 (file)
index 0000000..c1b3d4e
--- /dev/null
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -0,0 +1,186 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// IR visitors for walking the IR tree.
+//
+// The lowest level helpers are DoChildren and EditChildren, which
+// nodes help implement and provide control over whether and when
+// recursion happens during the walk of the IR.
+//
+// Although these are both useful directly, two simpler patterns
+// are fairly common and also provided: Visit and Any.
+
+package ir
+
+// DoChildren calls do(x) on each of n's non-nil child nodes x.
+// If any call returns true, DoChildren stops and returns true.
+// Otherwise, DoChildren returns false.
+//
+// Note that DoChildren(n, do) only calls do(x) for n's immediate children.
+// If x's children should be processed, then do(x) must call DoChildren(x, do).
+//
+// DoChildren allows constructing general traversals of the IR graph
+// that can stop early if needed. The most general usage is:
+//
+//     var do func(ir.Node) bool
+//     do = func(x ir.Node) bool {
+//             ... processing BEFORE visting children ...
+//             if ... should visit children ... {
+//                     ir.DoChildren(x, do)
+//                     ... processing AFTER visting children ...
+//             }
+//             if ... should stop parent DoChildren call from visiting siblings ... {
+//                     return true
+//             }
+//             return false
+//     }
+//     do(root)
+//
+// Since DoChildren does not return true itself, if the do function
+// never wants to stop the traversal, it can assume that DoChildren
+// itself will always return false, simplifying to:
+//
+//     var do func(ir.Node) bool
+//     do = func(x ir.Node) bool {
+//             ... processing BEFORE visting children ...
+//             if ... should visit children ... {
+//                     ir.DoChildren(x, do)
+//             }
+//             ... processing AFTER visting children ...
+//             return false
+//     }
+//     do(root)
+//
+// The Visit function illustrates a further simplification of the pattern,
+// only processing before visiting children and never stopping:
+//
+//     func Visit(n ir.Node, visit func(ir.Node)) {
+//             if n == nil {
+//                     return
+//             }
+//             var do func(ir.Node) bool
+//             do = func(x ir.Node) bool {
+//                     visit(x)
+//                     return ir.DoChildren(x, do)
+//             }
+//             do(n)
+//     }
+//
+// The Any function illustrates a different simplification of the pattern,
+// visiting each node and then its children, recursively, until finding
+// a node x for which cond(x) returns true, at which point the entire
+// traversal stops and returns true.
+//
+//     func Any(n ir.Node, cond(ir.Node) bool) bool {
+//             if n == nil {
+//                     return false
+//             }
+//             var do func(ir.Node) bool
+//             do = func(x ir.Node) bool {
+//                     return cond(x) || ir.DoChildren(x, do)
+//             }
+//             return do(n)
+//     }
+//
+// Visit and Any are presented above as examples of how to use
+// DoChildren effectively, but of course, usage that fits within the
+// simplifications captured by Visit or Any will be best served
+// by directly calling the ones provided by this package.
+func DoChildren(n Node, do func(Node) bool) bool {
+       if n == nil {
+               return false
+       }
+       return n.doChildren(do)
+}
+
+// Visit visits each non-nil node x in the IR tree rooted at n
+// in a depth-first preorder traversal, calling visit on each node visited.
+func Visit(n Node, visit func(Node)) {
+       if n == nil {
+               return
+       }
+       var do func(Node) bool
+       do = func(x Node) bool {
+               visit(x)
+               return DoChildren(x, do)
+       }
+       do(n)
+}
+
+// VisitList calls Visit(x, visit) for each node x in the list.
+func VisitList(list Nodes, visit func(Node)) {
+       for _, x := range list {
+               Visit(x, visit)
+       }
+}
+
+// Any looks for a non-nil node x in the IR tree rooted at n
+// for which cond(x) returns true.
+// Any considers nodes in a depth-first, preorder traversal.
+// When Any finds a node x such that cond(x) is true,
+// Any ends the traversal and returns true immediately.
+// Otherwise Any returns false after completing the entire traversal.
+func Any(n Node, cond func(Node) bool) bool {
+       if n == nil {
+               return false
+       }
+       var do func(Node) bool
+       do = func(x Node) bool {
+               return cond(x) || DoChildren(x, do)
+       }
+       return do(n)
+}
+
+// AnyList calls Any(x, cond) for each node x in the list, in order.
+// If any call returns true, AnyList stops and returns true.
+// Otherwise, AnyList returns false after calling Any(x, cond)
+// for every x in the list.
+func AnyList(list Nodes, cond func(Node) bool) bool {
+       for _, x := range list {
+               if Any(x, cond) {
+                       return true
+               }
+       }
+       return false
+}
+
+// EditChildren edits the child nodes of n, replacing each child x with edit(x).
+//
+// Note that EditChildren(n, edit) only calls edit(x) for n's immediate children.
+// If x's children should be processed, then edit(x) must call EditChildren(x, edit).
+//
+// EditChildren allows constructing general editing passes of the IR graph.
+// The most general usage is:
+//
+//     var edit func(ir.Node) ir.Node
+//     edit = func(x ir.Node) ir.Node {
+//             ... processing BEFORE editing children ...
+//             if ... should edit children ... {
+//                     EditChildren(x, edit)
+//                     ... processing AFTER editing children ...
+//             }
+//             ... return x ...
+//     }
+//     n = edit(n)
+//
+// EditChildren edits the node in place. To edit a copy, call Copy first.
+// As an example, a simple deep copy implementation would be:
+//
+//     func deepCopy(n ir.Node) ir.Node {
+//             var edit func(ir.Node) ir.Node
+//             edit = func(x ir.Node) ir.Node {
+//                     x = ir.Copy(x)
+//                     ir.EditChildren(x, edit)
+//                     return x
+//             }
+//             return edit(n)
+//     }
+//
+// Of course, in this case it is better to call ir.DeepCopy than to build one anew.
+func EditChildren(n Node, edit func(Node) Node) {
+       if n == nil {
+               return
+       }
+       n.editChildren(edit)
+}

diff --git a/src/cmd/compile/internal/liveness/bvset.go b/src/cmd/compile/internal/liveness/bvset.go
new file mode 100644 (file)
index 0000000..3431f54
--- /dev/null
+++ b/src/cmd/compile/internal/liveness/bvset.go
@@ -0,0 +1,97 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package liveness
+
+import "cmd/compile/internal/bitvec"
+
+// FNV-1 hash function constants.
+const (
+       h0 = 2166136261
+       hp = 16777619
+)
+
+// bvecSet is a set of bvecs, in initial insertion order.
+type bvecSet struct {
+       index []int           // hash -> uniq index. -1 indicates empty slot.
+       uniq  []bitvec.BitVec // unique bvecs, in insertion order
+}
+
+func (m *bvecSet) grow() {
+       // Allocate new index.
+       n := len(m.index) * 2
+       if n == 0 {
+               n = 32
+       }
+       newIndex := make([]int, n)
+       for i := range newIndex {
+               newIndex[i] = -1
+       }
+
+       // Rehash into newIndex.
+       for i, bv := range m.uniq {
+               h := hashbitmap(h0, bv) % uint32(len(newIndex))
+               for {
+                       j := newIndex[h]
+                       if j < 0 {
+                               newIndex[h] = i
+                               break
+                       }
+                       h++
+                       if h == uint32(len(newIndex)) {
+                               h = 0
+                       }
+               }
+       }
+       m.index = newIndex
+}
+
+// add adds bv to the set and returns its index in m.extractUnique.
+// The caller must not modify bv after this.
+func (m *bvecSet) add(bv bitvec.BitVec) int {
+       if len(m.uniq)*4 >= len(m.index) {
+               m.grow()
+       }
+
+       index := m.index
+       h := hashbitmap(h0, bv) % uint32(len(index))
+       for {
+               j := index[h]
+               if j < 0 {
+                       // New bvec.
+                       index[h] = len(m.uniq)
+                       m.uniq = append(m.uniq, bv)
+                       return len(m.uniq) - 1
+               }
+               jlive := m.uniq[j]
+               if bv.Eq(jlive) {
+                       // Existing bvec.
+                       return j
+               }
+
+               h++
+               if h == uint32(len(index)) {
+                       h = 0
+               }
+       }
+}
+
+// extractUnique returns this slice of unique bit vectors in m, as
+// indexed by the result of bvecSet.add.
+func (m *bvecSet) extractUnique() []bitvec.BitVec {
+       return m.uniq
+}
+
+func hashbitmap(h uint32, bv bitvec.BitVec) uint32 {
+       n := int((bv.N + 31) / 32)
+       for i := 0; i < n; i++ {
+               w := bv.B[i]
+               h = (h * hp) ^ (w & 0xff)
+               h = (h * hp) ^ ((w >> 8) & 0xff)
+               h = (h * hp) ^ ((w >> 16) & 0xff)
+               h = (h * hp) ^ ((w >> 24) & 0xff)
+       }
+
+       return h
+}

diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/liveness/plive.go
similarity index 71%
rename from src/cmd/compile/internal/gc/plive.go
rename to src/cmd/compile/internal/liveness/plive.go
index a48173e0d65bfec00ce5bfdc78ae8de5a26ba775..53ae797fce18f1fe7007ebdf9336f010bdfd5574 100644 (file)
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -12,16 +12,24 @@
 //
 // Each level includes the earlier output as well.
 
-package gc
+package liveness
 
 import (
+       "crypto/md5"
+       "fmt"
+       "sort"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/bitvec"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/reflectdata"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/typebits"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/objabi"
-       "crypto/md5"
-       "fmt"
-       "strings"
 )
 
 // OpVarDef is an annotation for the liveness analysis, marking a place
@@ -79,117 +87,87 @@ import (
 // so the compiler can allocate two temps to the same location. Here it's now
 // useless, since the implementation of stack objects.
 
-// BlockEffects summarizes the liveness effects on an SSA block.
-type BlockEffects struct {
+// blockEffects summarizes the liveness effects on an SSA block.
+type blockEffects struct {
        // Computed during Liveness.prologue using only the content of
        // individual blocks:
        //
        //      uevar: upward exposed variables (used before set in block)
        //      varkill: killed variables (set in block)
-       uevar   bvec
-       varkill bvec
+       uevar   bitvec.BitVec
+       varkill bitvec.BitVec
 
        // Computed during Liveness.solve using control flow information:
        //
        //      livein: variables live at block entry
        //      liveout: variables live at block exit
-       livein  bvec
-       liveout bvec
+       livein  bitvec.BitVec
+       liveout bitvec.BitVec
 }
 
 // A collection of global state used by liveness analysis.
-type Liveness struct {
-       fn         *Node
+type liveness struct {
+       fn         *ir.Func
        f          *ssa.Func
-       vars       []*Node
-       idx        map[*Node]int32
+       vars       []*ir.Name
+       idx        map[*ir.Name]int32
        stkptrsize int64
 
-       be []BlockEffects
+       be []blockEffects
 
        // allUnsafe indicates that all points in this function are
        // unsafe-points.
        allUnsafe bool
        // unsafePoints bit i is set if Value ID i is an unsafe-point
        // (preemption is not allowed). Only valid if !allUnsafe.
-       unsafePoints bvec
+       unsafePoints bitvec.BitVec
 
        // An array with a bit vector for each safe point in the
        // current Block during Liveness.epilogue. Indexed in Value
        // order for that block. Additionally, for the entry block
        // livevars[0] is the entry bitmap. Liveness.compact moves
        // these to stackMaps.
-       livevars []bvec
+       livevars []bitvec.BitVec
 
        // livenessMap maps from safe points (i.e., CALLs) to their
        // liveness map indexes.
-       livenessMap LivenessMap
+       livenessMap Map
        stackMapSet bvecSet
-       stackMaps   []bvec
+       stackMaps   []bitvec.BitVec
 
        cache progeffectscache
 }
 
-// LivenessMap maps from *ssa.Value to LivenessIndex.
-type LivenessMap struct {
-       vals map[ssa.ID]LivenessIndex
-       // The set of live, pointer-containing variables at the deferreturn
+// Map maps from *ssa.Value to LivenessIndex.
+type Map struct {
+       Vals map[ssa.ID]objw.LivenessIndex
+       // The set of live, pointer-containing variables at the DeferReturn
        // call (only set when open-coded defers are used).
-       deferreturn LivenessIndex
+       DeferReturn objw.LivenessIndex
 }
 
-func (m *LivenessMap) reset() {
-       if m.vals == nil {
-               m.vals = make(map[ssa.ID]LivenessIndex)
+func (m *Map) reset() {
+       if m.Vals == nil {
+               m.Vals = make(map[ssa.ID]objw.LivenessIndex)
        } else {
-               for k := range m.vals {
-                       delete(m.vals, k)
+               for k := range m.Vals {
+                       delete(m.Vals, k)
                }
        }
-       m.deferreturn = LivenessDontCare
+       m.DeferReturn = objw.LivenessDontCare
 }
 
-func (m *LivenessMap) set(v *ssa.Value, i LivenessIndex) {
-       m.vals[v.ID] = i
+func (m *Map) set(v *ssa.Value, i objw.LivenessIndex) {
+       m.Vals[v.ID] = i
 }
 
-func (m LivenessMap) Get(v *ssa.Value) LivenessIndex {
+func (m Map) Get(v *ssa.Value) objw.LivenessIndex {
        // If v isn't in the map, then it's a "don't care" and not an
        // unsafe-point.
-       if idx, ok := m.vals[v.ID]; ok {
+       if idx, ok := m.Vals[v.ID]; ok {
                return idx
        }
-       return LivenessIndex{StackMapDontCare, false}
-}
-
-// LivenessIndex stores the liveness map information for a Value.
-type LivenessIndex struct {
-       stackMapIndex int
-
-       // isUnsafePoint indicates that this is an unsafe-point.
-       //
-       // Note that it's possible for a call Value to have a stack
-       // map while also being an unsafe-point. This means it cannot
-       // be preempted at this instruction, but that a preemption or
-       // stack growth may happen in the called function.
-       isUnsafePoint bool
-}
-
-// LivenessDontCare indicates that the liveness information doesn't
-// matter. Currently it is used in deferreturn liveness when we don't
-// actually need it. It should never be emitted to the PCDATA stream.
-var LivenessDontCare = LivenessIndex{StackMapDontCare, true}
-
-// StackMapDontCare indicates that the stack map index at a Value
-// doesn't matter.
-//
-// This is a sentinel value that should never be emitted to the PCDATA
-// stream. We use -1000 because that's obviously never a valid stack
-// index (but -1 is).
-const StackMapDontCare = -1000
-
-func (idx LivenessIndex) StackMapValid() bool {
-       return idx.stackMapIndex != StackMapDontCare
+       return objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: false}
 }
 
 type progeffectscache struct {
@@ -198,42 +176,42 @@ type progeffectscache struct {
        initialized bool
 }
 
-// livenessShouldTrack reports whether the liveness analysis
+// shouldTrack reports whether the liveness analysis
 // should track the variable n.
 // We don't care about variables that have no pointers,
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func livenessShouldTrack(n *Node) bool {
-       return n.Op == ONAME && (n.Class() == PAUTO || n.Class() == PPARAM || n.Class() == PPARAMOUT) && n.Type.HasPointers()
+func shouldTrack(n *ir.Name) bool {
+       return (n.Class == ir.PAUTO && n.Esc() != ir.EscHeap || n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
-func getvariables(fn *Node) ([]*Node, map[*Node]int32) {
-       var vars []*Node
-       for _, n := range fn.Func.Dcl {
-               if livenessShouldTrack(n) {
+func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
+       var vars []*ir.Name
+       for _, n := range fn.Dcl {
+               if shouldTrack(n) {
                        vars = append(vars, n)
                }
        }
-       idx := make(map[*Node]int32, len(vars))
+       idx := make(map[*ir.Name]int32, len(vars))
        for i, n := range vars {
                idx[n] = int32(i)
        }
        return vars, idx
 }
 
-func (lv *Liveness) initcache() {
+func (lv *liveness) initcache() {
        if lv.cache.initialized {
-               Fatalf("liveness cache initialized twice")
+               base.Fatalf("liveness cache initialized twice")
                return
        }
        lv.cache.initialized = true
 
        for i, node := range lv.vars {
-               switch node.Class() {
-               case PPARAM:
+               switch node.Class {
+               case ir.PPARAM:
                        // A return instruction with a p.to is a tail return, which brings
                        // the stack pointer back up (if it ever went down) and then jumps
                        // to a new function entirely. That form of instruction must read
@@ -242,7 +220,7 @@ func (lv *Liveness) initcache() {
                        // function runs.
                        lv.cache.tailuevar = append(lv.cache.tailuevar, int32(i))
 
-               case PPARAMOUT:
+               case ir.PPARAMOUT:
                        // All results are live at every return point.
                        // Note that this point is after escaping return values
                        // are copied back to the stack using their PAUTOHEAP references.
@@ -268,19 +246,18 @@ const (
 // valueEffects returns the index of a variable in lv.vars and the
 // liveness effects v has on that variable.
 // If v does not affect any tracked variables, it returns -1, 0.
-func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
-       n, e := affectedNode(v)
-       if e == 0 || n == nil || n.Op != ONAME { // cheapest checks first
+func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
+       n, e := affectedVar(v)
+       if e == 0 || n == nil { // cheapest checks first
                return -1, 0
        }
-
        // AllocFrame has dropped unused variables from
        // lv.fn.Func.Dcl, but they might still be referenced by
        // OpVarFoo pseudo-ops. Ignore them to prevent "lost track of
        // variable" ICEs (issue 19632).
        switch v.Op {
        case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-               if !n.Name.Used() {
+               if !n.Used() {
                        return -1, 0
                }
        }
@@ -295,7 +272,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
        if e&(ssa.SymRead|ssa.SymAddr) != 0 {
                effect |= uevar
        }
-       if e&ssa.SymWrite != 0 && (!isfat(n.Type) || v.Op == ssa.OpVarDef) {
+       if e&ssa.SymWrite != 0 && (!isfat(n.Type()) || v.Op == ssa.OpVarDef) {
                effect |= varkill
        }
 
@@ -309,23 +286,23 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
        return -1, 0
 }
 
-// affectedNode returns the *Node affected by v
-func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
+// affectedVar returns the *ir.Name node affected by v
+func affectedVar(v *ssa.Value) (*ir.Name, ssa.SymEffect) {
        // Special cases.
        switch v.Op {
        case ssa.OpLoadReg:
-               n, _ := AutoVar(v.Args[0])
+               n, _ := ssa.AutoVar(v.Args[0])
                return n, ssa.SymRead
        case ssa.OpStoreReg:
-               n, _ := AutoVar(v)
+               n, _ := ssa.AutoVar(v)
                return n, ssa.SymWrite
 
        case ssa.OpVarLive:
-               return v.Aux.(*Node), ssa.SymRead
+               return v.Aux.(*ir.Name), ssa.SymRead
        case ssa.OpVarDef, ssa.OpVarKill:
-               return v.Aux.(*Node), ssa.SymWrite
+               return v.Aux.(*ir.Name), ssa.SymWrite
        case ssa.OpKeepAlive:
-               n, _ := AutoVar(v.Args[0])
+               n, _ := ssa.AutoVar(v.Args[0])
                return n, ssa.SymRead
        }
 
@@ -338,24 +315,24 @@ func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
        case nil, *obj.LSym:
                // ok, but no node
                return nil, e
-       case *Node:
+       case *ir.Name:
                return a, e
        default:
-               Fatalf("weird aux: %s", v.LongString())
+               base.Fatalf("weird aux: %s", v.LongString())
                return nil, e
        }
 }
 
 type livenessFuncCache struct {
-       be          []BlockEffects
-       livenessMap LivenessMap
+       be          []blockEffects
+       livenessMap Map
 }
 
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn *Node, f *ssa.Func, vars []*Node, idx map[*Node]int32, stkptrsize int64) *Liveness {
-       lv := &Liveness{
+func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int32, stkptrsize int64) *liveness {
+       lv := &liveness{
                fn:         fn,
                f:          f,
                vars:       vars,
@@ -373,23 +350,23 @@ func newliveness(fn *Node, f *ssa.Func, vars []*Node, idx map[*Node]int32, stkpt
                if cap(lc.be) >= f.NumBlocks() {
                        lv.be = lc.be[:f.NumBlocks()]
                }
-               lv.livenessMap = LivenessMap{vals: lc.livenessMap.vals, deferreturn: LivenessDontCare}
-               lc.livenessMap.vals = nil
+               lv.livenessMap = Map{Vals: lc.livenessMap.Vals, DeferReturn: objw.LivenessDontCare}
+               lc.livenessMap.Vals = nil
        }
        if lv.be == nil {
-               lv.be = make([]BlockEffects, f.NumBlocks())
+               lv.be = make([]blockEffects, f.NumBlocks())
        }
 
        nblocks := int32(len(f.Blocks))
        nvars := int32(len(vars))
-       bulk := bvbulkalloc(nvars, nblocks*7)
+       bulk := bitvec.NewBulk(nvars, nblocks*7)
        for _, b := range f.Blocks {
                be := lv.blockEffects(b)
 
-               be.uevar = bulk.next()
-               be.varkill = bulk.next()
-               be.livein = bulk.next()
-               be.liveout = bulk.next()
+               be.uevar = bulk.Next()
+               be.varkill = bulk.Next()
+               be.livein = bulk.Next()
+               be.liveout = bulk.Next()
        }
        lv.livenessMap.reset()
 
@@ -397,109 +374,33 @@ func newliveness(fn *Node, f *ssa.Func, vars []*Node, idx map[*Node]int32, stkpt
        return lv
 }
 
-func (lv *Liveness) blockEffects(b *ssa.Block) *BlockEffects {
+func (lv *liveness) blockEffects(b *ssa.Block) *blockEffects {
        return &lv.be[b.ID]
 }
 
-// NOTE: The bitmap for a specific type t could be cached in t after
-// the first run and then simply copied into bv at the correct offset
-// on future calls with the same type t.
-func onebitwalktype1(t *types.Type, off int64, bv bvec) {
-       if t.Align > 0 && off&int64(t.Align-1) != 0 {
-               Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
-       }
-       if !t.HasPointers() {
-               // Note: this case ensures that pointers to go:notinheap types
-               // are not considered pointers by garbage collection and stack copying.
-               return
-       }
-
-       switch t.Etype {
-       case TPTR, TUNSAFEPTR, TFUNC, TCHAN, TMAP:
-               if off&int64(Widthptr-1) != 0 {
-                       Fatalf("onebitwalktype1: invalid alignment, %v", t)
-               }
-               bv.Set(int32(off / int64(Widthptr))) // pointer
-
-       case TSTRING:
-               // struct { byte *str; intgo len; }
-               if off&int64(Widthptr-1) != 0 {
-                       Fatalf("onebitwalktype1: invalid alignment, %v", t)
-               }
-               bv.Set(int32(off / int64(Widthptr))) //pointer in first slot
-
-       case TINTER:
-               // struct { Itab *tab;  void *data; }
-               // or, when isnilinter(t)==true:
-               // struct { Type *type; void *data; }
-               if off&int64(Widthptr-1) != 0 {
-                       Fatalf("onebitwalktype1: invalid alignment, %v", t)
-               }
-               // The first word of an interface is a pointer, but we don't
-               // treat it as such.
-               // 1. If it is a non-empty interface, the pointer points to an itab
-               //    which is always in persistentalloc space.
-               // 2. If it is an empty interface, the pointer points to a _type.
-               //   a. If it is a compile-time-allocated type, it points into
-               //      the read-only data section.
-               //   b. If it is a reflect-allocated type, it points into the Go heap.
-               //      Reflect is responsible for keeping a reference to
-               //      the underlying type so it won't be GCd.
-               // If we ever have a moving GC, we need to change this for 2b (as
-               // well as scan itabs to update their itab._type fields).
-               bv.Set(int32(off/int64(Widthptr) + 1)) // pointer in second slot
-
-       case TSLICE:
-               // struct { byte *array; uintgo len; uintgo cap; }
-               if off&int64(Widthptr-1) != 0 {
-                       Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
-               }
-               bv.Set(int32(off / int64(Widthptr))) // pointer in first slot (BitsPointer)
-
-       case TARRAY:
-               elt := t.Elem()
-               if elt.Width == 0 {
-                       // Short-circuit for #20739.
-                       break
-               }
-               for i := int64(0); i < t.NumElem(); i++ {
-                       onebitwalktype1(elt, off, bv)
-                       off += elt.Width
-               }
-
-       case TSTRUCT:
-               for _, f := range t.Fields().Slice() {
-                       onebitwalktype1(f.Type, off+f.Offset, bv)
-               }
-
-       default:
-               Fatalf("onebitwalktype1: unexpected type, %v", t)
-       }
-}
-
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bvec, vars []*Node, args, locals bvec) {
+func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, locals bitvec.BitVec) {
        for i := int32(0); ; i++ {
                i = liveout.Next(i)
                if i < 0 {
                        break
                }
                node := vars[i]
-               switch node.Class() {
-               case PAUTO:
-                       onebitwalktype1(node.Type, node.Xoffset+lv.stkptrsize, locals)
+               switch node.Class {
+               case ir.PAUTO:
+                       typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
-               case PPARAM, PPARAMOUT:
-                       onebitwalktype1(node.Type, node.Xoffset, args)
+               case ir.PPARAM, ir.PPARAMOUT:
+                       typebits.Set(node.Type(), node.FrameOffset(), args)
                }
        }
 }
 
-// allUnsafe indicates that all points in this function are
+// IsUnsafe indicates that all points in this function are
 // unsafe-points.
-func allUnsafe(f *ssa.Func) bool {
+func IsUnsafe(f *ssa.Func) bool {
        // The runtime assumes the only safe-points are function
        // prologues (because that's how it used to be). We could and
        // should improve that, but for now keep consider all points
@@ -509,18 +410,18 @@ func allUnsafe(f *ssa.Func) bool {
        // go:nosplit functions are similar. Since safe points used to
        // be coupled with stack checks, go:nosplit often actually
        // means "no safe points in this function".
-       return compiling_runtime || f.NoSplit
+       return base.Flag.CompilingRuntime || f.NoSplit
 }
 
 // markUnsafePoints finds unsafe points and computes lv.unsafePoints.
-func (lv *Liveness) markUnsafePoints() {
-       if allUnsafe(lv.f) {
+func (lv *liveness) markUnsafePoints() {
+       if IsUnsafe(lv.f) {
                // No complex analysis necessary.
                lv.allUnsafe = true
                return
        }
 
-       lv.unsafePoints = bvalloc(int32(lv.f.NumValues()))
+       lv.unsafePoints = bitvec.New(int32(lv.f.NumValues()))
 
        // Mark architecture-specific unsafe points.
        for _, b := range lv.f.Blocks {
@@ -564,7 +465,7 @@ func (lv *Liveness) markUnsafePoints() {
                var load *ssa.Value
                v := wbBlock.Controls[0]
                for {
-                       if sym, ok := v.Aux.(*obj.LSym); ok && sym == writeBarrier {
+                       if sym, ok := v.Aux.(*obj.LSym); ok && sym == ir.Syms.WriteBarrier {
                                load = v
                                break
                        }
@@ -631,11 +532,11 @@ func (lv *Liveness) markUnsafePoints() {
        // nice to only flood as far as the unsafe.Pointer -> uintptr
        // conversion, but it's hard to know which argument of an Add
        // or Sub to follow.
-       var flooded bvec
+       var flooded bitvec.BitVec
        var flood func(b *ssa.Block, vi int)
        flood = func(b *ssa.Block, vi int) {
-               if flooded.n == 0 {
-                       flooded = bvalloc(int32(lv.f.NumBlocks()))
+               if flooded.N == 0 {
+                       flooded = bitvec.New(int32(lv.f.NumBlocks()))
                }
                if flooded.Get(int32(b.ID)) {
                        return
@@ -676,14 +577,14 @@ func (lv *Liveness) markUnsafePoints() {
 // This does not necessarily mean the instruction is a safe-point. In
 // particular, call Values can have a stack map in case the callee
 // grows the stack, but not themselves be a safe-point.
-func (lv *Liveness) hasStackMap(v *ssa.Value) bool {
+func (lv *liveness) hasStackMap(v *ssa.Value) bool {
        if !v.Op.IsCall() {
                return false
        }
        // typedmemclr and typedmemmove are write barriers and
        // deeply non-preemptible. They are unsafe points and
        // hence should not have liveness maps.
-       if sym, ok := v.Aux.(*ssa.AuxCall); ok && (sym.Fn == typedmemclr || sym.Fn == typedmemmove) {
+       if sym, ok := v.Aux.(*ssa.AuxCall); ok && (sym.Fn == ir.Syms.Typedmemclr || sym.Fn == ir.Syms.Typedmemmove) {
                return false
        }
        return true
@@ -692,7 +593,7 @@ func (lv *Liveness) hasStackMap(v *ssa.Value) bool {
 // Initializes the sets for solving the live variables. Visits all the
 // instructions in each basic block to summarizes the information at each basic
 // block
-func (lv *Liveness) prologue() {
+func (lv *liveness) prologue() {
        lv.initcache()
 
        for _, b := range lv.f.Blocks {
@@ -714,12 +615,12 @@ func (lv *Liveness) prologue() {
 }
 
 // Solve the liveness dataflow equations.
-func (lv *Liveness) solve() {
+func (lv *liveness) solve() {
        // These temporary bitvectors exist to avoid successive allocations and
        // frees within the loop.
        nvars := int32(len(lv.vars))
-       newlivein := bvalloc(nvars)
-       newliveout := bvalloc(nvars)
+       newlivein := bitvec.New(nvars)
+       newliveout := bitvec.New(nvars)
 
        // Walk blocks in postorder ordering. This improves convergence.
        po := lv.f.Postorder()
@@ -774,10 +675,10 @@ func (lv *Liveness) solve() {
 
 // Visits all instructions in a basic block and computes a bit vector of live
 // variables at each safe point locations.
-func (lv *Liveness) epilogue() {
+func (lv *liveness) epilogue() {
        nvars := int32(len(lv.vars))
-       liveout := bvalloc(nvars)
-       livedefer := bvalloc(nvars) // always-live variables
+       liveout := bitvec.New(nvars)
+       livedefer := bitvec.New(nvars) // always-live variables
 
        // If there is a defer (that could recover), then all output
        // parameters are live all the time.  In addition, any locals
@@ -786,14 +687,14 @@ func (lv *Liveness) epilogue() {
        // pointers to copy values back to the stack).
        // TODO: if the output parameter is heap-allocated, then we
        // don't need to keep the stack copy live?
-       if lv.fn.Func.HasDefer() {
+       if lv.fn.HasDefer() {
                for i, n := range lv.vars {
-                       if n.Class() == PPARAMOUT {
-                               if n.Name.IsOutputParamHeapAddr() {
+                       if n.Class == ir.PPARAMOUT {
+                               if n.IsOutputParamHeapAddr() {
                                        // Just to be paranoid.  Heap addresses are PAUTOs.
-                                       Fatalf("variable %v both output param and heap output param", n)
+                                       base.Fatalf("variable %v both output param and heap output param", n)
                                }
-                               if n.Name.Param.Heapaddr != nil {
+                               if n.Heapaddr != nil {
                                        // If this variable moved to the heap, then
                                        // its stack copy is not live.
                                        continue
@@ -801,22 +702,22 @@ func (lv *Liveness) epilogue() {
                                // Note: zeroing is handled by zeroResults in walk.go.
                                livedefer.Set(int32(i))
                        }
-                       if n.Name.IsOutputParamHeapAddr() {
+                       if n.IsOutputParamHeapAddr() {
                                // This variable will be overwritten early in the function
                                // prologue (from the result of a mallocgc) but we need to
                                // zero it in case that malloc causes a stack scan.
-                               n.Name.SetNeedzero(true)
+                               n.SetNeedzero(true)
                                livedefer.Set(int32(i))
                        }
-                       if n.Name.OpenDeferSlot() {
+                       if n.OpenDeferSlot() {
                                // Open-coded defer args slots must be live
                                // everywhere in a function, since a panic can
                                // occur (almost) anywhere. Because it is live
                                // everywhere, it must be zeroed on entry.
                                livedefer.Set(int32(i))
                                // It was already marked as Needzero when created.
-                               if !n.Name.Needzero() {
-                                       Fatalf("all pointer-containing defer arg slots should have Needzero set")
+                               if !n.Needzero() {
+                                       base.Fatalf("all pointer-containing defer arg slots should have Needzero set")
                                }
                        }
                }
@@ -831,7 +732,7 @@ func (lv *Liveness) epilogue() {
 
        {
                // Reserve an entry for function entry.
-               live := bvalloc(nvars)
+               live := bitvec.New(nvars)
                lv.livevars = append(lv.livevars, live)
        }
 
@@ -845,7 +746,7 @@ func (lv *Liveness) epilogue() {
                                continue
                        }
 
-                       live := bvalloc(nvars)
+                       live := bitvec.New(nvars)
                        lv.livevars = append(lv.livevars, live)
                }
 
@@ -878,7 +779,7 @@ func (lv *Liveness) epilogue() {
 
                if b == lv.f.Entry {
                        if index != 0 {
-                               Fatalf("bad index for entry point: %v", index)
+                               base.Fatalf("bad index for entry point: %v", index)
                        }
 
                        // Check to make sure only input variables are live.
@@ -886,10 +787,10 @@ func (lv *Liveness) epilogue() {
                                if !liveout.Get(int32(i)) {
                                        continue
                                }
-                               if n.Class() == PPARAM {
+                               if n.Class == ir.PPARAM {
                                        continue // ok
                                }
-                               Fatalf("bad live variable at entry of %v: %L", lv.fn.Func.Nname, n)
+                               base.FatalfAt(n.Pos(), "bad live variable at entry of %v: %L", lv.fn.Nname, n)
                        }
 
                        // Record live variables.
@@ -902,25 +803,25 @@ func (lv *Liveness) epilogue() {
        }
 
        // If we have an open-coded deferreturn call, make a liveness map for it.
-       if lv.fn.Func.OpenCodedDeferDisallowed() {
-               lv.livenessMap.deferreturn = LivenessDontCare
+       if lv.fn.OpenCodedDeferDisallowed() {
+               lv.livenessMap.DeferReturn = objw.LivenessDontCare
        } else {
-               lv.livenessMap.deferreturn = LivenessIndex{
-                       stackMapIndex: lv.stackMapSet.add(livedefer),
-                       isUnsafePoint: false,
+               lv.livenessMap.DeferReturn = objw.LivenessIndex{
+                       StackMapIndex: lv.stackMapSet.add(livedefer),
+                       IsUnsafePoint: false,
                }
        }
 
        // Done compacting. Throw out the stack map set.
-       lv.stackMaps = lv.stackMapSet.extractUniqe()
+       lv.stackMaps = lv.stackMapSet.extractUnique()
        lv.stackMapSet = bvecSet{}
 
        // Useful sanity check: on entry to the function,
        // the only things that can possibly be live are the
        // input parameters.
        for j, n := range lv.vars {
-               if n.Class() != PPARAM && lv.stackMaps[0].Get(int32(j)) {
-                       lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Func.Nname, n)
+               if n.Class != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
+                       lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Nname, n)
                }
        }
 }
@@ -941,7 +842,7 @@ func (lv *Liveness) epilogue() {
 // is actually a net loss: we save about 50k of argument bitmaps but the new
 // PCDATA tables cost about 100k. So for now we keep using a single index for
 // both bitmap lists.
-func (lv *Liveness) compact(b *ssa.Block) {
+func (lv *liveness) compact(b *ssa.Block) {
        pos := 0
        if b == lv.f.Entry {
                // Handle entry stack map.
@@ -951,9 +852,9 @@ func (lv *Liveness) compact(b *ssa.Block) {
        for _, v := range b.Values {
                hasStackMap := lv.hasStackMap(v)
                isUnsafePoint := lv.allUnsafe || lv.unsafePoints.Get(int32(v.ID))
-               idx := LivenessIndex{StackMapDontCare, isUnsafePoint}
+               idx := objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: isUnsafePoint}
                if hasStackMap {
-                       idx.stackMapIndex = lv.stackMapSet.add(lv.livevars[pos])
+                       idx.StackMapIndex = lv.stackMapSet.add(lv.livevars[pos])
                        pos++
                }
                if hasStackMap || isUnsafePoint {
@@ -965,8 +866,8 @@ func (lv *Liveness) compact(b *ssa.Block) {
        lv.livevars = lv.livevars[:0]
 }
 
-func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
-       if debuglive == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
+func (lv *liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
+       if base.Flag.Live == 0 || ir.FuncName(lv.fn) == "init" || strings.HasPrefix(ir.FuncName(lv.fn), ".") {
                return
        }
        if !(v == nil || v.Op.IsCall()) {
@@ -978,14 +879,14 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
                return
        }
 
-       pos := lv.fn.Func.Nname.Pos
+       pos := lv.fn.Nname.Pos()
        if v != nil {
                pos = v.Pos
        }
 
        s := "live at "
        if v == nil {
-               s += fmt.Sprintf("entry to %s:", lv.fn.funcname())
+               s += fmt.Sprintf("entry to %s:", ir.FuncName(lv.fn))
        } else if sym, ok := v.Aux.(*ssa.AuxCall); ok && sym.Fn != nil {
                fn := sym.Fn.Name
                if pos := strings.Index(fn, "."); pos >= 0 {
@@ -1002,10 +903,10 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
                }
        }
 
-       Warnl(pos, s)
+       base.WarnfAt(pos, s)
 }
 
-func (lv *Liveness) printbvec(printed bool, name string, live bvec) bool {
+func (lv *liveness) printbvec(printed bool, name string, live bitvec.BitVec) bool {
        if live.IsEmpty() {
                return printed
        }
@@ -1022,14 +923,14 @@ func (lv *Liveness) printbvec(printed bool, name string, live bvec) bool {
                if !live.Get(int32(i)) {
                        continue
                }
-               fmt.Printf("%s%s", comma, n.Sym.Name)
+               fmt.Printf("%s%s", comma, n.Sym().Name)
                comma = ","
        }
        return true
 }
 
 // printeffect is like printbvec, but for valueEffects.
-func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bool {
+func (lv *liveness) printeffect(printed bool, name string, pos int32, x bool) bool {
        if !x {
                return printed
        }
@@ -1040,7 +941,7 @@ func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bo
        }
        fmt.Printf("%s=", name)
        if x {
-               fmt.Printf("%s", lv.vars[pos].Sym.Name)
+               fmt.Printf("%s", lv.vars[pos].Sym().Name)
        }
 
        return true
@@ -1049,8 +950,8 @@ func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bo
 // Prints the computed liveness information and inputs, for debugging.
 // This format synthesizes the information used during the multiple passes
 // into a single presentation.
-func (lv *Liveness) printDebug() {
-       fmt.Printf("liveness: %s\n", lv.fn.funcname())
+func (lv *liveness) printDebug() {
+       fmt.Printf("liveness: %s\n", ir.FuncName(lv.fn))
 
        for i, b := range lv.f.Blocks {
                if i > 0 {
@@ -1088,7 +989,7 @@ func (lv *Liveness) printDebug() {
 
                if b == lv.f.Entry {
                        live := lv.stackMaps[0]
-                       fmt.Printf("(%s) function entry\n", linestr(lv.fn.Func.Nname.Pos))
+                       fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Nname.Pos()))
                        fmt.Printf("\tlive=")
                        printed = false
                        for j, n := range lv.vars {
@@ -1105,7 +1006,7 @@ func (lv *Liveness) printDebug() {
                }
 
                for _, v := range b.Values {
-                       fmt.Printf("(%s) %v\n", linestr(v.Pos), v.LongString())
+                       fmt.Printf("(%s) %v\n", base.FmtPos(v.Pos), v.LongString())
 
                        pcdata := lv.livenessMap.Get(v)
 
@@ -1121,7 +1022,7 @@ func (lv *Liveness) printDebug() {
                                fmt.Printf("\tlive=")
                                printed = false
                                if pcdata.StackMapValid() {
-                                       live := lv.stackMaps[pcdata.stackMapIndex]
+                                       live := lv.stackMaps[pcdata.StackMapIndex]
                                        for j, n := range lv.vars {
                                                if !live.Get(int32(j)) {
                                                        continue
@@ -1136,7 +1037,7 @@ func (lv *Liveness) printDebug() {
                                fmt.Printf("\n")
                        }
 
-                       if pcdata.isUnsafePoint {
+                       if pcdata.IsUnsafePoint {
                                fmt.Printf("\tunsafe-point\n")
                        }
                }
@@ -1158,15 +1059,15 @@ func (lv *Liveness) printDebug() {
 // first word dumped is the total number of bitmaps. The second word is the
 // length of the bitmaps. All bitmaps are assumed to be of equal length. The
 // remaining bytes are the raw bitmaps.
-func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
+func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
        // Size args bitmaps to be just large enough to hold the largest pointer.
        // First, find the largest Xoffset node we care about.
-       // (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
-       var maxArgNode *Node
+       // (Nodes without pointers aren't in lv.vars; see ShouldTrack.)
+       var maxArgNode *ir.Name
        for _, n := range lv.vars {
-               switch n.Class() {
-               case PPARAM, PPARAMOUT:
-                       if maxArgNode == nil || n.Xoffset > maxArgNode.Xoffset {
+               switch n.Class {
+               case ir.PPARAM, ir.PPARAMOUT:
+                       if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
                                maxArgNode = n
                        }
                }
@@ -1174,7 +1075,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
        // Next, find the offset of the largest pointer in the largest node.
        var maxArgs int64
        if maxArgNode != nil {
-               maxArgs = maxArgNode.Xoffset + typeptrdata(maxArgNode.Type)
+               maxArgs = maxArgNode.FrameOffset() + types.PtrDataSize(maxArgNode.Type())
        }
 
        // Size locals bitmaps to be stkptrsize sized.
@@ -1189,13 +1090,13 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
        // Temporary symbols for encoding bitmaps.
        var argsSymTmp, liveSymTmp obj.LSym
 
-       args := bvalloc(int32(maxArgs / int64(Widthptr)))
-       aoff := duint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
-       aoff = duint32(&argsSymTmp, aoff, uint32(args.n))          // number of bits in each bitmap
+       args := bitvec.New(int32(maxArgs / int64(types.PtrSize)))
+       aoff := objw.Uint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
+       aoff = objw.Uint32(&argsSymTmp, aoff, uint32(args.N))          // number of bits in each bitmap
 
-       locals := bvalloc(int32(maxLocals / int64(Widthptr)))
-       loff := duint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
-       loff = duint32(&liveSymTmp, loff, uint32(locals.n))        // number of bits in each bitmap
+       locals := bitvec.New(int32(maxLocals / int64(types.PtrSize)))
+       loff := objw.Uint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
+       loff = objw.Uint32(&liveSymTmp, loff, uint32(locals.N))        // number of bits in each bitmap
 
        for _, live := range lv.stackMaps {
                args.Clear()
@@ -1203,8 +1104,8 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 
                lv.pointerMap(live, lv.vars, args, locals)
 
-               aoff = dbvec(&argsSymTmp, aoff, args)
-               loff = dbvec(&liveSymTmp, loff, locals)
+               aoff = objw.BitVec(&argsSymTmp, aoff, args)
+               loff = objw.BitVec(&liveSymTmp, loff, locals)
        }
 
        // Give these LSyms content-addressable names,
@@ -1214,7 +1115,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
        // These symbols will be added to Ctxt.Data by addGCLocals
        // after parallel compilation is done.
        makeSym := func(tmpSym *obj.LSym) *obj.LSym {
-               return Ctxt.LookupInit(fmt.Sprintf("gclocals·%x", md5.Sum(tmpSym.P)), func(lsym *obj.LSym) {
+               return base.Ctxt.LookupInit(fmt.Sprintf("gclocals·%x", md5.Sum(tmpSym.P)), func(lsym *obj.LSym) {
                        lsym.P = tmpSym.P
                        lsym.Set(obj.AttrContentAddressable, true)
                })
@@ -1222,30 +1123,30 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
        return makeSym(&argsSymTmp), makeSym(&liveSymTmp)
 }
 
-// Entry pointer for liveness analysis. Solves for the liveness of
+// Entry pointer for Compute analysis. Solves for the Compute of
 // pointer variables in the function and emits a runtime data
 // structure read by the garbage collector.
 // Returns a map from GC safe points to their corresponding stack map index.
-func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
+func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Map {
        // Construct the global liveness state.
-       vars, idx := getvariables(e.curfn)
-       lv := newliveness(e.curfn, f, vars, idx, e.stkptrsize)
+       vars, idx := getvariables(curfn)
+       lv := newliveness(curfn, f, vars, idx, stkptrsize)
 
        // Run the dataflow framework.
        lv.prologue()
        lv.solve()
        lv.epilogue()
-       if debuglive > 0 {
+       if base.Flag.Live > 0 {
                lv.showlive(nil, lv.stackMaps[0])
                for _, b := range f.Blocks {
                        for _, val := range b.Values {
                                if idx := lv.livenessMap.Get(val); idx.StackMapValid() {
-                                       lv.showlive(val, lv.stackMaps[idx.stackMapIndex])
+                                       lv.showlive(val, lv.stackMaps[idx.StackMapIndex])
                                }
                        }
                }
        }
-       if debuglive >= 2 {
+       if base.Flag.Live >= 2 {
                lv.printDebug()
        }
 
@@ -1254,35 +1155,80 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
                cache := f.Cache.Liveness.(*livenessFuncCache)
                if cap(lv.be) < 2000 { // Threshold from ssa.Cache slices.
                        for i := range lv.be {
-                               lv.be[i] = BlockEffects{}
+                               lv.be[i] = blockEffects{}
                        }
                        cache.be = lv.be
                }
-               if len(lv.livenessMap.vals) < 2000 {
+               if len(lv.livenessMap.Vals) < 2000 {
                        cache.livenessMap = lv.livenessMap
                }
        }
 
        // Emit the live pointer map data structures
-       ls := e.curfn.Func.lsym
+       ls := curfn.LSym
        fninfo := ls.Func()
        fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
        p := pp.Prog(obj.AFUNCDATA)
-       Addrconst(&p.From, objabi.FUNCDATA_ArgsPointerMaps)
+       p.From.SetConst(objabi.FUNCDATA_ArgsPointerMaps)
        p.To.Type = obj.TYPE_MEM
        p.To.Name = obj.NAME_EXTERN
        p.To.Sym = fninfo.GCArgs
 
        p = pp.Prog(obj.AFUNCDATA)
-       Addrconst(&p.From, objabi.FUNCDATA_LocalsPointerMaps)
+       p.From.SetConst(objabi.FUNCDATA_LocalsPointerMaps)
        p.To.Type = obj.TYPE_MEM
        p.To.Name = obj.NAME_EXTERN
        p.To.Sym = fninfo.GCLocals
 
+       if x := lv.emitStackObjects(); x != nil {
+               p := pp.Prog(obj.AFUNCDATA)
+               p.From.SetConst(objabi.FUNCDATA_StackObjects)
+               p.To.Type = obj.TYPE_MEM
+               p.To.Name = obj.NAME_EXTERN
+               p.To.Sym = x
+       }
+
        return lv.livenessMap
 }
 
+func (lv *liveness) emitStackObjects() *obj.LSym {
+       var vars []*ir.Name
+       for _, n := range lv.fn.Dcl {
+               if shouldTrack(n) && n.Addrtaken() && n.Esc() != ir.EscHeap {
+                       vars = append(vars, n)
+               }
+       }
+       if len(vars) == 0 {
+               return nil
+       }
+
+       // Sort variables from lowest to highest address.
+       sort.Slice(vars, func(i, j int) bool { return vars[i].FrameOffset() < vars[j].FrameOffset() })
+
+       // Populate the stack object data.
+       // Format must match runtime/stack.go:stackObjectRecord.
+       x := base.Ctxt.Lookup(lv.fn.LSym.Name + ".stkobj")
+       lv.fn.LSym.Func().StackObjects = x
+       off := 0
+       off = objw.Uintptr(x, off, uint64(len(vars)))
+       for _, v := range vars {
+               // Note: arguments and return values have non-negative Xoffset,
+               // in which case the offset is relative to argp.
+               // Locals have a negative Xoffset, in which case the offset is relative to varp.
+               off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
+               off = objw.SymPtr(x, off, reflectdata.TypeLinksym(v.Type()), 0)
+       }
+
+       if base.Flag.Live != 0 {
+               for _, v := range vars {
+                       base.WarnfAt(v.Pos(), "stack object %v %v", v, v.Type())
+               }
+       }
+
+       return x
+}
+
 // isfat reports whether a variable of type t needs multiple assignments to initialize.
 // For example:
 //
@@ -1298,17 +1244,17 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 // to fully initialize t.
 func isfat(t *types.Type) bool {
        if t != nil {
-               switch t.Etype {
-               case TSLICE, TSTRING,
-                       TINTER: // maybe remove later
+               switch t.Kind() {
+               case types.TSLICE, types.TSTRING,
+                       types.TINTER: // maybe remove later
                        return true
-               case TARRAY:
+               case types.TARRAY:
                        // Array of 1 element, check if element is fat
                        if t.NumElem() == 1 {
                                return isfat(t.Elem())
                        }
                        return true
-               case TSTRUCT:
+               case types.TSTRUCT:
                        // Struct with 1 field, check if field is fat
                        if t.NumFields() == 1 {
                                return isfat(t.Field(0).Type)
@@ -1319,3 +1265,34 @@ func isfat(t *types.Type) bool {
 
        return false
 }
+
+func WriteFuncMap(fn *ir.Func) {
+       if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
+               return
+       }
+       types.CalcSize(fn.Type())
+       lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
+       nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
+       bv := bitvec.New(int32(nptr) * 2)
+       nbitmap := 1
+       if fn.Type().NumResults() > 0 {
+               nbitmap = 2
+       }
+       off := objw.Uint32(lsym, 0, uint32(nbitmap))
+       off = objw.Uint32(lsym, off, uint32(bv.N))
+
+       if ir.IsMethod(fn) {
+               typebits.Set(fn.Type().Recvs(), 0, bv)
+       }
+       if fn.Type().NumParams() > 0 {
+               typebits.Set(fn.Type().Params(), 0, bv)
+       }
+       off = objw.BitVec(lsym, off, bv)
+
+       if fn.Type().NumResults() > 0 {
+               typebits.Set(fn.Type().Results(), 0, bv)
+               off = objw.BitVec(lsym, off, bv)
+       }
+
+       objw.Global(lsym, int32(off), obj.RODATA|obj.LOCAL)
+}

diff --git a/src/cmd/compile/internal/logopt/logopt_test.go b/src/cmd/compile/internal/logopt/logopt_test.go
index e121c1abd228638c7d7cacd46e06b1110ecadc24..71976174b03517def512290e47d86a4980a02963 100644 (file)
--- a/src/cmd/compile/internal/logopt/logopt_test.go
+++ b/src/cmd/compile/internal/logopt/logopt_test.go
@@ -132,7 +132,7 @@ func TestLogOpt(t *testing.T) {
        // Check at both 1 and 8-byte alignments.
        t.Run("Copy", func(t *testing.T) {
                const copyCode = `package x
-func s128a1(x *[128]int8) [128]int8 { 
+func s128a1(x *[128]int8) [128]int8 {
        return *x
 }
 func s127a1(x *[127]int8) [127]int8 {
@@ -219,7 +219,7 @@ func s15a8(x *[15]int64) [15]int64 {
                        `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":4,"character":11},"end":{"line":4,"character":11}}},"message":"inlineLoc"},`+
                        `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from \u0026y.b (address-of)"},`+
                        `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":4,"character":9},"end":{"line":4,"character":9}}},"message":"inlineLoc"},`+
-                       `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from ~R0 = \u003cN\u003e (assign-pair)"},`+
+                       `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from ~R0 = \u0026y.b (assign-pair)"},`+
                        `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":3},"end":{"line":9,"character":3}}},"message":"escflow:    flow: ~r2 = ~R0:"},`+
                        `{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":3},"end":{"line":9,"character":3}}},"message":"escflow:      from return (*int)(~R0) (return)"}]}`)
        })

diff --git a/src/cmd/compile/internal/mips/galign.go b/src/cmd/compile/internal/mips/galign.go
index be40c16dde0b7baeca74f251714c6ef9636c9adf..599163550bb2942ee4d64aa570edecfe4efef5d1 100644 (file)
--- a/src/cmd/compile/internal/mips/galign.go
+++ b/src/cmd/compile/internal/mips/galign.go
@@ -5,13 +5,13 @@
 package mips
 
 import (
-       "cmd/compile/internal/gc"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/mips"
        "cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &mips.Linkmips
        if objabi.GOARCH == "mipsle" {
                arch.LinkArch = &mips.Linkmipsle
@@ -22,7 +22,7 @@ func Init(arch *gc.Arch) {
        arch.ZeroRange = zerorange
        arch.Ginsnop = ginsnop
        arch.Ginsnopdefer = ginsnop
-       arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+       arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
        arch.SSAGenValue = ssaGenValue
        arch.SSAGenBlock = ssaGenBlock
 }

diff --git a/src/cmd/compile/internal/mips/ggen.go b/src/cmd/compile/internal/mips/ggen.go
index 5e867721c3fcf6b08cd5140ceb43eb8013f6f700..1a5125207dd0ea3b2fd10f582f1f81ba5e80f813 100644 (file)
--- a/src/cmd/compile/internal/mips/ggen.go
+++ b/src/cmd/compile/internal/mips/ggen.go
@@ -5,20 +5,22 @@
 package mips
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/mips"
 )
 
 // TODO(mips): implement DUFFZERO
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 
        if cnt == 0 {
                return p
        }
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, gc.Ctxt.FixedFrameSize()+off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.FixedFrameSize()+off+i)
                }
        } else {
                //fmt.Printf("zerorange frame:%v, lo: %v, hi:%v \n", frame ,lo, hi)
@@ -28,22 +30,22 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
                //      MOVW    R0, (Widthptr)r1
                //      ADD     $Widthptr, r1
                //      BNE             r1, r2, loop
-               p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
+               p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
                p.Reg = mips.REGSP
-               p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
+               p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
                p.Reg = mips.REGRT1
-               p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(gc.Widthptr))
+               p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
                p1 := p
-               p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, mips.REGRT1, 0)
-               p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
+               p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
+               p = pp.Append(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
                p.Reg = mips.REGRT2
-               gc.Patch(p, p1)
+               p.To.SetTarget(p1)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        p := pp.Prog(mips.ANOR)
        p.From.Type = obj.TYPE_REG
        p.From.Reg = mips.REG_R0

diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 9d11c6bf53ae78652fa7fadf2eedff4943dcc385..f1cdbd3241a6519406cfc154fd1b6d8f4cd74e2b 100644 (file)
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -7,9 +7,11 @@ package mips
 import (
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/mips"
@@ -75,7 +77,7 @@ func storeByType(t *types.Type, r int16) obj.As {
        panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpCopy, ssa.OpMIPSMOVWreg:
                t := v.Type
@@ -121,7 +123,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                r := v.Reg()
                p := s.Prog(loadByType(v.Type, r))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = r
                if isHILO(r) {
@@ -151,7 +153,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type, r))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = r
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpMIPSADD,
                ssa.OpMIPSSUB,
                ssa.OpMIPSAND,
@@ -286,10 +288,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        v.Fatalf("aux is of unknown type %T", v.Aux)
                case *obj.LSym:
                        wantreg = "SB"
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        wantreg = "SP"
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                case nil:
                        // No sym, just MOVW $off(SP), R
                        wantreg = "SP"
@@ -310,7 +312,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpMIPSMOVBstore,
@@ -323,7 +325,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpMIPSMOVBstorezero,
                ssa.OpMIPSMOVHstorezero,
                ssa.OpMIPSMOVWstorezero:
@@ -332,7 +334,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = mips.REGZERO
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpMIPSMOVBreg,
                ssa.OpMIPSMOVBUreg,
                ssa.OpMIPSMOVHreg,
@@ -425,7 +427,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p4.From.Reg = v.Args[1].Reg()
                p4.Reg = mips.REG_R1
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p2)
+               p4.To.SetTarget(p2)
        case ssa.OpMIPSLoweredMove:
                // SUBU $4, R1
                // MOVW 4(R1), Rtmp
@@ -478,7 +480,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p6.From.Reg = v.Args[2].Reg()
                p6.Reg = mips.REG_R1
                p6.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p6, p2)
+               p6.To.SetTarget(p2)
        case ssa.OpMIPSCALLstatic, ssa.OpMIPSCALLclosure, ssa.OpMIPSCALLinter:
                s.Call(v)
        case ssa.OpMIPSLoweredWB:
@@ -490,13 +492,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(8) // space used in callee args area by assembly stubs
        case ssa.OpMIPSLoweredPanicExtendA, ssa.OpMIPSLoweredPanicExtendB, ssa.OpMIPSLoweredPanicExtendC:
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
                s.UseArgs(12) // space used in callee args area by assembly stubs
        case ssa.OpMIPSLoweredAtomicLoad8,
                ssa.OpMIPSLoweredAtomicLoad32:
@@ -575,7 +577,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
                s.Prog(mips.ASYNC)
        case ssa.OpMIPSLoweredAtomicAdd:
@@ -611,7 +613,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
                s.Prog(mips.ASYNC)
 
@@ -655,7 +657,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
                s.Prog(mips.ASYNC)
 
@@ -699,7 +701,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
                s.Prog(mips.ASYNC)
 
@@ -748,26 +750,26 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p5.From.Type = obj.TYPE_REG
                p5.From.Reg = v.Reg0()
                p5.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p5, p1)
+               p5.To.SetTarget(p1)
 
                s.Prog(mips.ASYNC)
 
                p6 := s.Prog(obj.ANOP)
-               gc.Patch(p2, p6)
+               p2.To.SetTarget(p6)
 
        case ssa.OpMIPSLoweredNilCheck:
                // Issue a load which will fault if arg is nil.
                p := s.Prog(mips.AMOVB)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = mips.REGTMP
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpMIPSFPFlagTrue,
                ssa.OpMIPSFPFlagFalse:
@@ -791,12 +793,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
        case ssa.OpMIPSLoweredGetClosurePtr:
                // Closure pointer is R22 (mips.REGCTXT).
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpMIPSLoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(mips.AMOVW)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -824,13 +826,13 @@ var blockJump = map[ssa.BlockKind]struct {
        ssa.BlockMIPSFPF: {mips.ABFPF, mips.ABFPT},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockDefer:
                // defer returns in R1:
@@ -841,11 +843,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.From.Reg = mips.REGZERO
                p.Reg = mips.REG_R1
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:

diff --git a/src/cmd/compile/internal/mips64/galign.go b/src/cmd/compile/internal/mips64/galign.go
index 90c381a50b6df3445d7a795fbfab472879b64722..fc0a34228c8f40bb70dd753aea0756777ed2f864 100644 (file)
--- a/src/cmd/compile/internal/mips64/galign.go
+++ b/src/cmd/compile/internal/mips64/galign.go
@@ -5,13 +5,13 @@
 package mips64
 
 import (
-       "cmd/compile/internal/gc"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/mips"
        "cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &mips.Linkmips64
        if objabi.GOARCH == "mips64le" {
                arch.LinkArch = &mips.Linkmips64le
@@ -23,7 +23,7 @@ func Init(arch *gc.Arch) {
        arch.Ginsnop = ginsnop
        arch.Ginsnopdefer = ginsnop
 
-       arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+       arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
        arch.SSAGenValue = ssaGenValue
        arch.SSAGenBlock = ssaGenBlock
 }

diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index 04e7a66e417b95c8a5bcd957fb11566f71e9ba45..37bb871958bf4e827dc6d829c4f4853951b93351 100644 (file)
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -5,26 +5,28 @@
 package mips64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/mips"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, 8+off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, 8+off+i)
                }
-       } else if cnt <= int64(128*gc.Widthptr) {
-               p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
+       } else if cnt <= int64(128*types.PtrSize) {
+               p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
                p.Reg = mips.REGSP
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
-               p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
+               p.To.Sym = ir.Syms.Duffzero
+               p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
        } else {
                //      ADDV    $(8+frame+lo-8), SP, r1
                //      ADDV    $cnt, r1, r2
@@ -32,22 +34,22 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
                //      MOVV    R0, (Widthptr)r1
                //      ADDV    $Widthptr, r1
                //      BNE             r1, r2, loop
-               p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
+               p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
                p.Reg = mips.REGSP
-               p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
+               p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
                p.Reg = mips.REGRT1
-               p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(gc.Widthptr))
+               p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
                p1 := p
-               p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, mips.REGRT1, 0)
-               p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
+               p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
+               p = pp.Append(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
                p.Reg = mips.REGRT2
-               gc.Patch(p, p1)
+               p.To.SetTarget(p1)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        p := pp.Prog(mips.ANOR)
        p.From.Type = obj.TYPE_REG
        p.From.Reg = mips.REG_R0

diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 2727c4d8a8340b6481f972a277f98844c9067623..14cf7af143703e482bbc742e7a87d079ef908405 100644 (file)
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -7,9 +7,11 @@ package mips64
 import (
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/mips"
@@ -83,7 +85,7 @@ func storeByType(t *types.Type, r int16) obj.As {
        panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpCopy, ssa.OpMIPS64MOVVreg:
                if v.Type.IsMemory() {
@@ -124,7 +126,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                r := v.Reg()
                p := s.Prog(loadByType(v.Type, r))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = r
                if isHILO(r) {
@@ -154,7 +156,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type, r))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = r
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpMIPS64ADDV,
                ssa.OpMIPS64SUBV,
                ssa.OpMIPS64AND,
@@ -260,10 +262,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        v.Fatalf("aux is of unknown type %T", v.Aux)
                case *obj.LSym:
                        wantreg = "SB"
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        wantreg = "SP"
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                case nil:
                        // No sym, just MOVV $off(SP), R
                        wantreg = "SP"
@@ -286,7 +288,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpMIPS64MOVBstore,
@@ -300,7 +302,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpMIPS64MOVBstorezero,
                ssa.OpMIPS64MOVHstorezero,
                ssa.OpMIPS64MOVWstorezero,
@@ -310,7 +312,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = mips.REGZERO
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpMIPS64MOVBreg,
                ssa.OpMIPS64MOVBUreg,
                ssa.OpMIPS64MOVHreg,
@@ -381,7 +383,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p = s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpMIPS64LoweredZero:
                // SUBV $8, R1
@@ -426,12 +428,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p4.From.Reg = v.Args[1].Reg()
                p4.Reg = mips.REG_R1
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p2)
+               p4.To.SetTarget(p2)
        case ssa.OpMIPS64DUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                p.To.Offset = v.AuxInt
        case ssa.OpMIPS64LoweredMove:
                // SUBV $8, R1
@@ -488,7 +490,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p6.From.Reg = v.Args[2].Reg()
                p6.Reg = mips.REG_R1
                p6.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p6, p2)
+               p6.To.SetTarget(p2)
        case ssa.OpMIPS64CALLstatic, ssa.OpMIPS64CALLclosure, ssa.OpMIPS64CALLinter:
                s.Call(v)
        case ssa.OpMIPS64LoweredWB:
@@ -500,7 +502,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(16) // space used in callee args area by assembly stubs
        case ssa.OpMIPS64LoweredAtomicLoad8, ssa.OpMIPS64LoweredAtomicLoad32, ssa.OpMIPS64LoweredAtomicLoad64:
                as := mips.AMOVV
@@ -577,7 +579,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
                s.Prog(mips.ASYNC)
        case ssa.OpMIPS64LoweredAtomicAdd32, ssa.OpMIPS64LoweredAtomicAdd64:
                // SYNC
@@ -614,7 +616,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
                s.Prog(mips.ASYNC)
                p4 := s.Prog(mips.AADDVU)
                p4.From.Type = obj.TYPE_REG
@@ -657,7 +659,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = mips.REGTMP
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
                s.Prog(mips.ASYNC)
                p4 := s.Prog(mips.AADDVU)
                p4.From.Type = obj.TYPE_CONST
@@ -710,22 +712,22 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p5.From.Type = obj.TYPE_REG
                p5.From.Reg = v.Reg0()
                p5.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p5, p1)
+               p5.To.SetTarget(p1)
                p6 := s.Prog(mips.ASYNC)
-               gc.Patch(p2, p6)
+               p2.To.SetTarget(p6)
        case ssa.OpMIPS64LoweredNilCheck:
                // Issue a load which will fault if arg is nil.
                p := s.Prog(mips.AMOVB)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = mips.REGTMP
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpMIPS64FPFlagTrue,
                ssa.OpMIPS64FPFlagFalse:
@@ -749,15 +751,15 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.To.Type = obj.TYPE_REG
                p3.To.Reg = v.Reg()
                p4 := s.Prog(obj.ANOP) // not a machine instruction, for branch to land
-               gc.Patch(p2, p4)
+               p2.To.SetTarget(p4)
        case ssa.OpMIPS64LoweredGetClosurePtr:
                // Closure pointer is R22 (mips.REGCTXT).
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpMIPS64LoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(mips.AMOVV)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -785,13 +787,13 @@ var blockJump = map[ssa.BlockKind]struct {
        ssa.BlockMIPS64FPF: {mips.ABFPF, mips.ABFPT},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockDefer:
                // defer returns in R1:
@@ -802,11 +804,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.From.Reg = mips.REGZERO
                p.Reg = mips.REG_R1
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:

diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
new file mode 100644 (file)
index 0000000..747c30e
--- /dev/null
+++ b/src/cmd/compile/internal/noder/import.go
@@ -0,0 +1,480 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package noder
+
+import (
+       "errors"
+       "fmt"
+       "os"
+       pathpkg "path"
+       "runtime"
+       "sort"
+       "strconv"
+       "strings"
+       "unicode"
+       "unicode/utf8"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/syntax"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/archive"
+       "cmd/internal/bio"
+       "cmd/internal/goobj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+func isDriveLetter(b byte) bool {
+       return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
+}
+
+// is this path a local name? begins with ./ or ../ or /
+func islocalname(name string) bool {
+       return strings.HasPrefix(name, "/") ||
+               runtime.GOOS == "windows" && len(name) >= 3 && isDriveLetter(name[0]) && name[1] == ':' && name[2] == '/' ||
+               strings.HasPrefix(name, "./") || name == "." ||
+               strings.HasPrefix(name, "../") || name == ".."
+}
+
+func openPackage(path string) (*os.File, error) {
+       if islocalname(path) {
+               if base.Flag.NoLocalImports {
+                       return nil, errors.New("local imports disallowed")
+               }
+
+               if base.Flag.Cfg.PackageFile != nil {
+                       return os.Open(base.Flag.Cfg.PackageFile[path])
+               }
+
+               // try .a before .o.  important for building libraries:
+               // if there is an array.o in the array.a library,
+               // want to find all of array.a, not just array.o.
+               if file, err := os.Open(fmt.Sprintf("%s.a", path)); err == nil {
+                       return file, nil
+               }
+               if file, err := os.Open(fmt.Sprintf("%s.o", path)); err == nil {
+                       return file, nil
+               }
+               return nil, errors.New("file not found")
+       }
+
+       // local imports should be canonicalized already.
+       // don't want to see "encoding/../encoding/base64"
+       // as different from "encoding/base64".
+       if q := pathpkg.Clean(path); q != path {
+               return nil, fmt.Errorf("non-canonical import path %q (should be %q)", path, q)
+       }
+
+       if base.Flag.Cfg.PackageFile != nil {
+               return os.Open(base.Flag.Cfg.PackageFile[path])
+       }
+
+       for _, dir := range base.Flag.Cfg.ImportDirs {
+               if file, err := os.Open(fmt.Sprintf("%s/%s.a", dir, path)); err == nil {
+                       return file, nil
+               }
+               if file, err := os.Open(fmt.Sprintf("%s/%s.o", dir, path)); err == nil {
+                       return file, nil
+               }
+       }
+
+       if objabi.GOROOT != "" {
+               suffix := ""
+               if base.Flag.InstallSuffix != "" {
+                       suffix = "_" + base.Flag.InstallSuffix
+               } else if base.Flag.Race {
+                       suffix = "_race"
+               } else if base.Flag.MSan {
+                       suffix = "_msan"
+               }
+
+               if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+                       return file, nil
+               }
+               if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+                       return file, nil
+               }
+       }
+       return nil, errors.New("file not found")
+}
+
+// myheight tracks the local package's height based on packages
+// imported so far.
+var myheight int
+
+// resolveImportPath resolves an import path as it appears in a Go
+// source file to the package's full path.
+func resolveImportPath(path string) (string, error) {
+       // The package name main is no longer reserved,
+       // but we reserve the import path "main" to identify
+       // the main package, just as we reserve the import
+       // path "math" to identify the standard math package.
+       if path == "main" {
+               return "", errors.New("cannot import \"main\"")
+       }
+
+       if base.Ctxt.Pkgpath != "" && path == base.Ctxt.Pkgpath {
+               return "", fmt.Errorf("import %q while compiling that package (import cycle)", path)
+       }
+
+       if mapped, ok := base.Flag.Cfg.ImportMap[path]; ok {
+               path = mapped
+       }
+
+       if islocalname(path) {
+               if path[0] == '/' {
+                       return "", errors.New("import path cannot be absolute path")
+               }
+
+               prefix := base.Flag.D
+               if prefix == "" {
+                       // Questionable, but when -D isn't specified, historically we
+                       // resolve local import paths relative to the directory the
+                       // compiler's current directory, not the respective source
+                       // file's directory.
+                       prefix = base.Ctxt.Pathname
+               }
+               path = pathpkg.Join(prefix, path)
+
+               if err := checkImportPath(path, true); err != nil {
+                       return "", err
+               }
+       }
+
+       return path, nil
+}
+
+// TODO(mdempsky): Return an error instead.
+func importfile(decl *syntax.ImportDecl) *types.Pkg {
+       if decl.Path.Kind != syntax.StringLit {
+               base.Errorf("import path must be a string")
+               return nil
+       }
+
+       path, err := strconv.Unquote(decl.Path.Value)
+       if err != nil {
+               base.Errorf("import path must be a string")
+               return nil
+       }
+
+       if err := checkImportPath(path, false); err != nil {
+               base.Errorf("%s", err.Error())
+               return nil
+       }
+
+       path, err = resolveImportPath(path)
+       if err != nil {
+               base.Errorf("%s", err)
+               return nil
+       }
+
+       importpkg := types.NewPkg(path, "")
+       if importpkg.Direct {
+               return importpkg // already fully loaded
+       }
+       importpkg.Direct = true
+       typecheck.Target.Imports = append(typecheck.Target.Imports, importpkg)
+
+       if path == "unsafe" {
+               return importpkg // initialized with universe
+       }
+
+       f, err := openPackage(path)
+       if err != nil {
+               base.Errorf("could not import %q: %v", path, err)
+               base.ErrorExit()
+       }
+       imp := bio.NewReader(f)
+       defer imp.Close()
+       file := f.Name()
+
+       // check object header
+       p, err := imp.ReadString('\n')
+       if err != nil {
+               base.Errorf("import %s: reading input: %v", file, err)
+               base.ErrorExit()
+       }
+
+       if p == "!<arch>\n" { // package archive
+               // package export block should be first
+               sz := archive.ReadHeader(imp.Reader, "__.PKGDEF")
+               if sz <= 0 {
+                       base.Errorf("import %s: not a package file", file)
+                       base.ErrorExit()
+               }
+               p, err = imp.ReadString('\n')
+               if err != nil {
+                       base.Errorf("import %s: reading input: %v", file, err)
+                       base.ErrorExit()
+               }
+       }
+
+       if !strings.HasPrefix(p, "go object ") {
+               base.Errorf("import %s: not a go object file: %s", file, p)
+               base.ErrorExit()
+       }
+       q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
+       if p[10:] != q {
+               base.Errorf("import %s: object is [%s] expected [%s]", file, p[10:], q)
+               base.ErrorExit()
+       }
+
+       // process header lines
+       for {
+               p, err = imp.ReadString('\n')
+               if err != nil {
+                       base.Errorf("import %s: reading input: %v", file, err)
+                       base.ErrorExit()
+               }
+               if p == "\n" {
+                       break // header ends with blank line
+               }
+       }
+
+       // Expect $$B\n to signal binary import format.
+
+       // look for $$
+       var c byte
+       for {
+               c, err = imp.ReadByte()
+               if err != nil {
+                       break
+               }
+               if c == '$' {
+                       c, err = imp.ReadByte()
+                       if c == '$' || err != nil {
+                               break
+                       }
+               }
+       }
+
+       // get character after $$
+       if err == nil {
+               c, _ = imp.ReadByte()
+       }
+
+       var fingerprint goobj.FingerprintType
+       switch c {
+       case '\n':
+               base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path)
+               return nil
+
+       case 'B':
+               if base.Debug.Export != 0 {
+                       fmt.Printf("importing %s (%s)\n", path, file)
+               }
+               imp.ReadByte() // skip \n after $$B
+
+               c, err = imp.ReadByte()
+               if err != nil {
+                       base.Errorf("import %s: reading input: %v", file, err)
+                       base.ErrorExit()
+               }
+
+               // Indexed format is distinguished by an 'i' byte,
+               // whereas previous export formats started with 'c', 'd', or 'v'.
+               if c != 'i' {
+                       base.Errorf("import %s: unexpected package format byte: %v", file, c)
+                       base.ErrorExit()
+               }
+               fingerprint = typecheck.ReadImports(importpkg, imp)
+
+       default:
+               base.Errorf("no import in %q", path)
+               base.ErrorExit()
+       }
+
+       // assume files move (get installed) so don't record the full path
+       if base.Flag.Cfg.PackageFile != nil {
+               // If using a packageFile map, assume path_ can be recorded directly.
+               base.Ctxt.AddImport(path, fingerprint)
+       } else {
+               // For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
+               base.Ctxt.AddImport(file[len(file)-len(path)-len(".a"):], fingerprint)
+       }
+
+       if importpkg.Height >= myheight {
+               myheight = importpkg.Height + 1
+       }
+
+       return importpkg
+}
+
+// The linker uses the magic symbol prefixes "go." and "type."
+// Avoid potential confusion between import paths and symbols
+// by rejecting these reserved imports for now. Also, people
+// "can do weird things in GOPATH and we'd prefer they didn't
+// do _that_ weird thing" (per rsc). See also #4257.
+var reservedimports = []string{
+       "go",
+       "type",
+}
+
+func checkImportPath(path string, allowSpace bool) error {
+       if path == "" {
+               return errors.New("import path is empty")
+       }
+
+       if strings.Contains(path, "\x00") {
+               return errors.New("import path contains NUL")
+       }
+
+       for _, ri := range reservedimports {
+               if path == ri {
+                       return fmt.Errorf("import path %q is reserved and cannot be used", path)
+               }
+       }
+
+       for _, r := range path {
+               switch {
+               case r == utf8.RuneError:
+                       return fmt.Errorf("import path contains invalid UTF-8 sequence: %q", path)
+               case r < 0x20 || r == 0x7f:
+                       return fmt.Errorf("import path contains control character: %q", path)
+               case r == '\\':
+                       return fmt.Errorf("import path contains backslash; use slash: %q", path)
+               case !allowSpace && unicode.IsSpace(r):
+                       return fmt.Errorf("import path contains space character: %q", path)
+               case strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r):
+                       return fmt.Errorf("import path contains invalid character '%c': %q", r, path)
+               }
+       }
+
+       return nil
+}
+
+func pkgnotused(lineno src.XPos, path string, name string) {
+       // If the package was imported with a name other than the final
+       // import path element, show it explicitly in the error message.
+       // Note that this handles both renamed imports and imports of
+       // packages containing unconventional package declarations.
+       // Note that this uses / always, even on Windows, because Go import
+       // paths always use forward slashes.
+       elem := path
+       if i := strings.LastIndex(elem, "/"); i >= 0 {
+               elem = elem[i+1:]
+       }
+       if name == "" || elem == name {
+               base.ErrorfAt(lineno, "imported and not used: %q", path)
+       } else {
+               base.ErrorfAt(lineno, "imported and not used: %q as %s", path, name)
+       }
+}
+
+func mkpackage(pkgname string) {
+       if types.LocalPkg.Name == "" {
+               if pkgname == "_" {
+                       base.Errorf("invalid package name _")
+               }
+               types.LocalPkg.Name = pkgname
+       } else {
+               if pkgname != types.LocalPkg.Name {
+                       base.Errorf("package %s; expected %s", pkgname, types.LocalPkg.Name)
+               }
+       }
+}
+
+func clearImports() {
+       type importedPkg struct {
+               pos  src.XPos
+               path string
+               name string
+       }
+       var unused []importedPkg
+
+       for _, s := range types.LocalPkg.Syms {
+               n := ir.AsNode(s.Def)
+               if n == nil {
+                       continue
+               }
+               if n.Op() == ir.OPACK {
+                       // throw away top-level package name left over
+                       // from previous file.
+                       // leave s->block set to cause redeclaration
+                       // errors if a conflicting top-level name is
+                       // introduced by a different file.
+                       p := n.(*ir.PkgName)
+                       if !p.Used && base.SyntaxErrors() == 0 {
+                               unused = append(unused, importedPkg{p.Pos(), p.Pkg.Path, s.Name})
+                       }
+                       s.Def = nil
+                       continue
+               }
+               if types.IsDotAlias(s) {
+                       // throw away top-level name left over
+                       // from previous import . "x"
+                       // We'll report errors after type checking in CheckDotImports.
+                       s.Def = nil
+                       continue
+               }
+       }
+
+       sort.Slice(unused, func(i, j int) bool { return unused[i].pos.Before(unused[j].pos) })
+       for _, pkg := range unused {
+               pkgnotused(pkg.pos, pkg.path, pkg.name)
+       }
+}
+
+// CheckDotImports reports errors for any unused dot imports.
+func CheckDotImports() {
+       for _, pack := range dotImports {
+               if !pack.Used {
+                       base.ErrorfAt(pack.Pos(), "imported and not used: %q", pack.Pkg.Path)
+               }
+       }
+
+       // No longer needed; release memory.
+       dotImports = nil
+       typecheck.DotImportRefs = nil
+}
+
+// dotImports tracks all PkgNames that have been dot-imported.
+var dotImports []*ir.PkgName
+
+// find all the exported symbols in package referenced by PkgName,
+// and make them available in the current package
+func importDot(pack *ir.PkgName) {
+       if typecheck.DotImportRefs == nil {
+               typecheck.DotImportRefs = make(map[*ir.Ident]*ir.PkgName)
+       }
+
+       opkg := pack.Pkg
+       for _, s := range opkg.Syms {
+               if s.Def == nil {
+                       if _, ok := typecheck.DeclImporter[s]; !ok {
+                               continue
+                       }
+               }
+               if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
+                       continue
+               }
+               s1 := typecheck.Lookup(s.Name)
+               if s1.Def != nil {
+                       pkgerror := fmt.Sprintf("during import %q", opkg.Path)
+                       typecheck.Redeclared(base.Pos, s1, pkgerror)
+                       continue
+               }
+
+               id := ir.NewIdent(src.NoXPos, s)
+               typecheck.DotImportRefs[id] = pack
+               s1.Def = id
+               s1.Block = 1
+       }
+
+       dotImports = append(dotImports, pack)
+}
+
+// importName is like oldname,
+// but it reports an error if sym is from another package and not exported.
+func importName(sym *types.Sym) ir.Node {
+       n := oldname(sym)
+       if !types.IsExported(sym.Name) && sym.Pkg != types.LocalPkg {
+               n.SetDiag(true)
+               base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
+       }
+       return n
+}

diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/noder/lex.go
similarity index 67%
rename from src/cmd/compile/internal/gc/lex.go
rename to src/cmd/compile/internal/noder/lex.go
index 7cce371408ae81f2e476da906e5197a454a0193f..cdca9e55f336c790ac586cf15eaf05f3894ce4a7 100644 (file)
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -2,23 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package noder
 
 import (
-       "cmd/compile/internal/syntax"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
        "fmt"
        "strings"
-)
-
-// lineno is the source position at the start of the most recently lexed token.
-// TODO(gri) rename and eventually remove
-var lineno src.XPos
 
-func makePos(base *src.PosBase, line, col uint) src.XPos {
-       return Ctxt.PosTable.XPos(src.MakePos(base, line, col))
-}
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/syntax"
+       "cmd/internal/objabi"
+)
 
 func isSpace(c rune) bool {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r'
@@ -28,78 +21,52 @@ func isQuoted(s string) bool {
        return len(s) >= 2 && s[0] == '"' && s[len(s)-1] == '"'
 }
 
-type PragmaFlag int16
-
-const (
-       // Func pragmas.
-       Nointerface    PragmaFlag = 1 << iota
-       Noescape                  // func parameters don't escape
-       Norace                    // func must not have race detector annotations
-       Nosplit                   // func should not execute on separate stack
-       Noinline                  // func should not be inlined
-       NoCheckPtr                // func should not be instrumented by checkptr
-       CgoUnsafeArgs             // treat a pointer to one arg as a pointer to them all
-       UintptrEscapes            // pointers converted to uintptr escape
-
-       // Runtime-only func pragmas.
-       // See ../../../../runtime/README.md for detailed descriptions.
-       Systemstack        // func must run on system stack
-       Nowritebarrier     // emit compiler error instead of write barrier
-       Nowritebarrierrec  // error on write barrier in this or recursive callees
-       Yeswritebarrierrec // cancels Nowritebarrierrec in this function and callees
-
-       // Runtime and cgo type pragmas
-       NotInHeap // values of this type must not be heap allocated
-
-       // Go command pragmas
-       GoBuildPragma
-)
-
 const (
-       FuncPragmas = Nointerface |
-               Noescape |
-               Norace |
-               Nosplit |
-               Noinline |
-               NoCheckPtr |
-               CgoUnsafeArgs |
-               UintptrEscapes |
-               Systemstack |
-               Nowritebarrier |
-               Nowritebarrierrec |
-               Yeswritebarrierrec
-
-       TypePragmas = NotInHeap
+       funcPragmas = ir.Nointerface |
+               ir.Noescape |
+               ir.Norace |
+               ir.Nosplit |
+               ir.Noinline |
+               ir.NoCheckPtr |
+               ir.RegisterParams | // TODO remove after register abi is working
+               ir.CgoUnsafeArgs |
+               ir.UintptrEscapes |
+               ir.Systemstack |
+               ir.Nowritebarrier |
+               ir.Nowritebarrierrec |
+               ir.Yeswritebarrierrec
+
+       typePragmas = ir.NotInHeap
 )
 
-func pragmaFlag(verb string) PragmaFlag {
+func pragmaFlag(verb string) ir.PragmaFlag {
        switch verb {
        case "go:build":
-               return GoBuildPragma
+               return ir.GoBuildPragma
        case "go:nointerface":
                if objabi.Fieldtrack_enabled != 0 {
-                       return Nointerface
+                       return ir.Nointerface
                }
        case "go:noescape":
-               return Noescape
+               return ir.Noescape
        case "go:norace":
-               return Norace
+               return ir.Norace
        case "go:nosplit":
-               return Nosplit | NoCheckPtr // implies NoCheckPtr (see #34972)
+               return ir.Nosplit | ir.NoCheckPtr // implies NoCheckPtr (see #34972)
        case "go:noinline":
-               return Noinline
+               return ir.Noinline
        case "go:nocheckptr":
-               return NoCheckPtr
+               return ir.NoCheckPtr
        case "go:systemstack":
-               return Systemstack
+               return ir.Systemstack
        case "go:nowritebarrier":
-               return Nowritebarrier
+               return ir.Nowritebarrier
        case "go:nowritebarrierrec":
-               return Nowritebarrierrec | Nowritebarrier // implies Nowritebarrier
+               return ir.Nowritebarrierrec | ir.Nowritebarrier // implies Nowritebarrier
        case "go:yeswritebarrierrec":
-               return Yeswritebarrierrec
+               return ir.Yeswritebarrierrec
        case "go:cgo_unsafe_args":
-               return CgoUnsafeArgs | NoCheckPtr // implies NoCheckPtr (see #34968)
+               return ir.CgoUnsafeArgs | ir.NoCheckPtr // implies NoCheckPtr (see #34968)
        case "go:uintptrescapes":
                // For the next function declared in the file
                // any uintptr arguments may be pointer values
@@ -112,9 +79,11 @@ func pragmaFlag(verb string) PragmaFlag {
                // call. The conversion to uintptr must appear
                // in the argument list.
                // Used in syscall/dll_windows.go.
-               return UintptrEscapes
+               return ir.UintptrEscapes
+       case "go:registerparams": // TODO remove after register abi is working
+               return ir.RegisterParams
        case "go:notinheap":
-               return NotInHeap
+               return ir.NotInHeap
        }
        return 0
 }

diff --git a/src/cmd/compile/internal/gc/lex_test.go b/src/cmd/compile/internal/noder/lex_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/lex_test.go
rename to src/cmd/compile/internal/noder/lex_test.go
index b2081a1732bbb49382645b492351e7cdccba9cb0..85a3f06759ad7b477b111db6b0c4ad1ab71b615d 100644 (file)
--- a/src/cmd/compile/internal/gc/lex_test.go
+++ b/src/cmd/compile/internal/noder/lex_test.go
@@ -2,13 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package noder
 
 import (
-       "cmd/compile/internal/syntax"
        "reflect"
        "runtime"
        "testing"
+
+       "cmd/compile/internal/syntax"
 )
 
 func eq(a, b []string) bool {

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
new file mode 100644 (file)
index 0000000..5b5b09c
--- /dev/null
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -0,0 +1,1858 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package noder
+
+import (
+       "fmt"
+       "go/constant"
+       "go/token"
+       "os"
+       "path/filepath"
+       "runtime"
+       "strconv"
+       "strings"
+       "unicode"
+       "unicode/utf8"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/dwarfgen"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/syntax"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+func LoadPackage(filenames []string) {
+       base.Timer.Start("fe", "parse")
+
+       mode := syntax.CheckBranches
+
+       // Limit the number of simultaneously open files.
+       sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
+
+       noders := make([]*noder, len(filenames))
+       for i, filename := range filenames {
+               p := noder{
+                       err:         make(chan syntax.Error),
+                       trackScopes: base.Flag.Dwarf,
+               }
+               noders[i] = &p
+
+               filename := filename
+               go func() {
+                       sem <- struct{}{}
+                       defer func() { <-sem }()
+                       defer close(p.err)
+                       fbase := syntax.NewFileBase(filename)
+
+                       f, err := os.Open(filename)
+                       if err != nil {
+                               p.error(syntax.Error{Msg: err.Error()})
+                               return
+                       }
+                       defer f.Close()
+
+                       p.file, _ = syntax.Parse(fbase, f, p.error, p.pragma, mode) // errors are tracked via p.error
+               }()
+       }
+
+       var lines uint
+       for _, p := range noders {
+               for e := range p.err {
+                       p.errorAt(e.Pos, "%s", e.Msg)
+               }
+               lines += p.file.Lines
+       }
+       base.Timer.AddEvent(int64(lines), "lines")
+
+       for _, p := range noders {
+               p.node()
+               p.file = nil // release memory
+       }
+
+       if base.SyntaxErrors() != 0 {
+               base.ErrorExit()
+       }
+       types.CheckDclstack()
+
+       for _, p := range noders {
+               p.processPragmas()
+       }
+
+       // Typecheck.
+       types.LocalPkg.Height = myheight
+       typecheck.DeclareUniverse()
+       typecheck.TypecheckAllowed = true
+
+       // Process top-level declarations in phases.
+
+       // Phase 1: const, type, and names and types of funcs.
+       //   This will gather all the information about types
+       //   and methods but doesn't depend on any of it.
+       //
+       //   We also defer type alias declarations until phase 2
+       //   to avoid cycles like #18640.
+       //   TODO(gri) Remove this again once we have a fix for #25838.
+
+       // Don't use range--typecheck can add closures to Target.Decls.
+       base.Timer.Start("fe", "typecheck", "top1")
+       for i := 0; i < len(typecheck.Target.Decls); i++ {
+               n := typecheck.Target.Decls[i]
+               if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Alias()) {
+                       typecheck.Target.Decls[i] = typecheck.Stmt(n)
+               }
+       }
+
+       // Phase 2: Variable assignments.
+       //   To check interface assignments, depends on phase 1.
+
+       // Don't use range--typecheck can add closures to Target.Decls.
+       base.Timer.Start("fe", "typecheck", "top2")
+       for i := 0; i < len(typecheck.Target.Decls); i++ {
+               n := typecheck.Target.Decls[i]
+               if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Alias() {
+                       typecheck.Target.Decls[i] = typecheck.Stmt(n)
+               }
+       }
+
+       // Phase 3: Type check function bodies.
+       // Don't use range--typecheck can add closures to Target.Decls.
+       base.Timer.Start("fe", "typecheck", "func")
+       var fcount int64
+       for i := 0; i < len(typecheck.Target.Decls); i++ {
+               n := typecheck.Target.Decls[i]
+               if n.Op() == ir.ODCLFUNC {
+                       if base.Flag.W > 1 {
+                               s := fmt.Sprintf("\nbefore typecheck %v", n)
+                               ir.Dump(s, n)
+                       }
+                       typecheck.FuncBody(n.(*ir.Func))
+                       if base.Flag.W > 1 {
+                               s := fmt.Sprintf("\nafter typecheck %v", n)
+                               ir.Dump(s, n)
+                       }
+                       fcount++
+               }
+       }
+
+       // Phase 4: Check external declarations.
+       // TODO(mdempsky): This should be handled when type checking their
+       // corresponding ODCL nodes.
+       base.Timer.Start("fe", "typecheck", "externdcls")
+       for i, n := range typecheck.Target.Externs {
+               if n.Op() == ir.ONAME {
+                       typecheck.Target.Externs[i] = typecheck.Expr(typecheck.Target.Externs[i])
+               }
+       }
+
+       // Phase 5: With all user code type-checked, it's now safe to verify map keys.
+       // With all user code typechecked, it's now safe to verify unused dot imports.
+       typecheck.CheckMapKeys()
+       CheckDotImports()
+       base.ExitIfErrors()
+}
+
+func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
+       base.ErrorfAt(p.makeXPos(pos), format, args...)
+}
+
+// TODO(gri) Can we eliminate fileh in favor of absFilename?
+func fileh(name string) string {
+       return objabi.AbsFile("", name, base.Flag.TrimPath)
+}
+
+func absFilename(name string) string {
+       return objabi.AbsFile(base.Ctxt.Pathname, name, base.Flag.TrimPath)
+}
+
+// noder transforms package syntax's AST into a Node tree.
+type noder struct {
+       posMap
+
+       file           *syntax.File
+       linknames      []linkname
+       pragcgobuf     [][]string
+       err            chan syntax.Error
+       importedUnsafe bool
+       importedEmbed  bool
+       trackScopes    bool
+
+       funcState *funcState
+}
+
+// funcState tracks all per-function state to make handling nested
+// functions easier.
+type funcState struct {
+       // scopeVars is a stack tracking the number of variables declared in
+       // the current function at the moment each open scope was opened.
+       scopeVars []int
+       marker    dwarfgen.ScopeMarker
+
+       lastCloseScopePos syntax.Pos
+}
+
+func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
+       outerFuncState := p.funcState
+       p.funcState = new(funcState)
+       typecheck.StartFuncBody(fn)
+
+       if block != nil {
+               body := p.stmts(block.List)
+               if body == nil {
+                       body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
+               }
+               fn.Body = body
+
+               base.Pos = p.makeXPos(block.Rbrace)
+               fn.Endlineno = base.Pos
+       }
+
+       typecheck.FinishFuncBody()
+       p.funcState.marker.WriteTo(fn)
+       p.funcState = outerFuncState
+}
+
+func (p *noder) openScope(pos syntax.Pos) {
+       fs := p.funcState
+       types.Markdcl()
+
+       if p.trackScopes {
+               fs.scopeVars = append(fs.scopeVars, len(ir.CurFunc.Dcl))
+               fs.marker.Push(p.makeXPos(pos))
+       }
+}
+
+func (p *noder) closeScope(pos syntax.Pos) {
+       fs := p.funcState
+       fs.lastCloseScopePos = pos
+       types.Popdcl()
+
+       if p.trackScopes {
+               scopeVars := fs.scopeVars[len(fs.scopeVars)-1]
+               fs.scopeVars = fs.scopeVars[:len(fs.scopeVars)-1]
+               if scopeVars == len(ir.CurFunc.Dcl) {
+                       // no variables were declared in this scope, so we can retract it.
+                       fs.marker.Unpush()
+               } else {
+                       fs.marker.Pop(p.makeXPos(pos))
+               }
+       }
+}
+
+// closeAnotherScope is like closeScope, but it reuses the same mark
+// position as the last closeScope call. This is useful for "for" and
+// "if" statements, as their implicit blocks always end at the same
+// position as an explicit block.
+func (p *noder) closeAnotherScope() {
+       p.closeScope(p.funcState.lastCloseScopePos)
+}
+
+// linkname records a //go:linkname directive.
+type linkname struct {
+       pos    syntax.Pos
+       local  string
+       remote string
+}
+
+func (p *noder) node() {
+       p.importedUnsafe = false
+       p.importedEmbed = false
+
+       p.setlineno(p.file.PkgName)
+       mkpackage(p.file.PkgName.Value)
+
+       if pragma, ok := p.file.Pragma.(*pragmas); ok {
+               pragma.Flag &^= ir.GoBuildPragma
+               p.checkUnused(pragma)
+       }
+
+       typecheck.Target.Decls = append(typecheck.Target.Decls, p.decls(p.file.DeclList)...)
+
+       base.Pos = src.NoXPos
+       clearImports()
+}
+
+func (p *noder) processPragmas() {
+       for _, l := range p.linknames {
+               if !p.importedUnsafe {
+                       p.errorAt(l.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
+                       continue
+               }
+               n := ir.AsNode(typecheck.Lookup(l.local).Def)
+               if n == nil || n.Op() != ir.ONAME {
+                       // TODO(mdempsky): Change to p.errorAt before Go 1.17 release.
+                       // base.WarnfAt(p.makeXPos(l.pos), "//go:linkname must refer to declared function or variable (will be an error in Go 1.17)")
+                       continue
+               }
+               if n.Sym().Linkname != "" {
+                       p.errorAt(l.pos, "duplicate //go:linkname for %s", l.local)
+                       continue
+               }
+               n.Sym().Linkname = l.remote
+       }
+       typecheck.Target.CgoPragmas = append(typecheck.Target.CgoPragmas, p.pragcgobuf...)
+}
+
+func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
+       var cs constState
+
+       for _, decl := range decls {
+               p.setlineno(decl)
+               switch decl := decl.(type) {
+               case *syntax.ImportDecl:
+                       p.importDecl(decl)
+
+               case *syntax.VarDecl:
+                       l = append(l, p.varDecl(decl)...)
+
+               case *syntax.ConstDecl:
+                       l = append(l, p.constDecl(decl, &cs)...)
+
+               case *syntax.TypeDecl:
+                       l = append(l, p.typeDecl(decl))
+
+               case *syntax.FuncDecl:
+                       l = append(l, p.funcDecl(decl))
+
+               default:
+                       panic("unhandled Decl")
+               }
+       }
+
+       return
+}
+
+func (p *noder) importDecl(imp *syntax.ImportDecl) {
+       if imp.Path == nil || imp.Path.Bad {
+               return // avoid follow-on errors if there was a syntax error
+       }
+
+       if pragma, ok := imp.Pragma.(*pragmas); ok {
+               p.checkUnused(pragma)
+       }
+
+       ipkg := importfile(imp)
+       if ipkg == nil {
+               if base.Errors() == 0 {
+                       base.Fatalf("phase error in import")
+               }
+               return
+       }
+
+       if ipkg == ir.Pkgs.Unsafe {
+               p.importedUnsafe = true
+       }
+       if ipkg.Path == "embed" {
+               p.importedEmbed = true
+       }
+
+       var my *types.Sym
+       if imp.LocalPkgName != nil {
+               my = p.name(imp.LocalPkgName)
+       } else {
+               my = typecheck.Lookup(ipkg.Name)
+       }
+
+       pack := ir.NewPkgName(p.pos(imp), my, ipkg)
+
+       switch my.Name {
+       case ".":
+               importDot(pack)
+               return
+       case "init":
+               base.ErrorfAt(pack.Pos(), "cannot import package as init - init must be a func")
+               return
+       case "_":
+               return
+       }
+       if my.Def != nil {
+               typecheck.Redeclared(pack.Pos(), my, "as imported package name")
+       }
+       my.Def = pack
+       my.Lastlineno = pack.Pos()
+       my.Block = 1 // at top level
+}
+
+func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
+       names := p.declNames(ir.ONAME, decl.NameList)
+       typ := p.typeExprOrNil(decl.Type)
+       exprs := p.exprList(decl.Values)
+
+       if pragma, ok := decl.Pragma.(*pragmas); ok {
+               varEmbed(p.makeXPos, names[0], decl, pragma, p.importedEmbed)
+               p.checkUnused(pragma)
+       }
+
+       var init []ir.Node
+       p.setlineno(decl)
+
+       if len(names) > 1 && len(exprs) == 1 {
+               as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, exprs)
+               for _, v := range names {
+                       as2.Lhs.Append(v)
+                       typecheck.Declare(v, typecheck.DeclContext)
+                       v.Ntype = typ
+                       v.Defn = as2
+                       if ir.CurFunc != nil {
+                               init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+                       }
+               }
+
+               return append(init, as2)
+       }
+
+       for i, v := range names {
+               var e ir.Node
+               if i < len(exprs) {
+                       e = exprs[i]
+               }
+
+               typecheck.Declare(v, typecheck.DeclContext)
+               v.Ntype = typ
+
+               if ir.CurFunc != nil {
+                       init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+               }
+               as := ir.NewAssignStmt(base.Pos, v, e)
+               init = append(init, as)
+               if e != nil || ir.CurFunc == nil {
+                       v.Defn = as
+               }
+       }
+
+       if len(exprs) != 0 && len(names) != len(exprs) {
+               base.Errorf("assignment mismatch: %d variables but %d values", len(names), len(exprs))
+       }
+
+       return init
+}
+
+// constState tracks state between constant specifiers within a
+// declaration group. This state is kept separate from noder so nested
+// constant declarations are handled correctly (e.g., issue 15550).
+type constState struct {
+       group  *syntax.Group
+       typ    ir.Ntype
+       values []ir.Node
+       iota   int64
+}
+
+func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
+       if decl.Group == nil || decl.Group != cs.group {
+               *cs = constState{
+                       group: decl.Group,
+               }
+       }
+
+       if pragma, ok := decl.Pragma.(*pragmas); ok {
+               p.checkUnused(pragma)
+       }
+
+       names := p.declNames(ir.OLITERAL, decl.NameList)
+       typ := p.typeExprOrNil(decl.Type)
+
+       var values []ir.Node
+       if decl.Values != nil {
+               values = p.exprList(decl.Values)
+               cs.typ, cs.values = typ, values
+       } else {
+               if typ != nil {
+                       base.Errorf("const declaration cannot have type without expression")
+               }
+               typ, values = cs.typ, cs.values
+       }
+
+       nn := make([]ir.Node, 0, len(names))
+       for i, n := range names {
+               if i >= len(values) {
+                       base.Errorf("missing value in const declaration")
+                       break
+               }
+               v := values[i]
+               if decl.Values == nil {
+                       v = ir.DeepCopy(n.Pos(), v)
+               }
+               typecheck.Declare(n, typecheck.DeclContext)
+
+               n.Ntype = typ
+               n.Defn = v
+               n.SetIota(cs.iota)
+
+               nn = append(nn, ir.NewDecl(p.pos(decl), ir.ODCLCONST, n))
+       }
+
+       if len(values) > len(names) {
+               base.Errorf("extra expression in const declaration")
+       }
+
+       cs.iota++
+
+       return nn
+}
+
+func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
+       n := p.declName(ir.OTYPE, decl.Name)
+       typecheck.Declare(n, typecheck.DeclContext)
+
+       // decl.Type may be nil but in that case we got a syntax error during parsing
+       typ := p.typeExprOrNil(decl.Type)
+
+       n.Ntype = typ
+       n.SetAlias(decl.Alias)
+       if pragma, ok := decl.Pragma.(*pragmas); ok {
+               if !decl.Alias {
+                       n.SetPragma(pragma.Flag & typePragmas)
+                       pragma.Flag &^= typePragmas
+               }
+               p.checkUnused(pragma)
+       }
+
+       nod := ir.NewDecl(p.pos(decl), ir.ODCLTYPE, n)
+       if n.Alias() && !types.AllowsGoVersion(types.LocalPkg, 1, 9) {
+               base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
+       }
+       return nod
+}
+
+func (p *noder) declNames(op ir.Op, names []*syntax.Name) []*ir.Name {
+       nodes := make([]*ir.Name, 0, len(names))
+       for _, name := range names {
+               nodes = append(nodes, p.declName(op, name))
+       }
+       return nodes
+}
+
+func (p *noder) declName(op ir.Op, name *syntax.Name) *ir.Name {
+       return ir.NewDeclNameAt(p.pos(name), op, p.name(name))
+}
+
+func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
+       name := p.name(fun.Name)
+       t := p.signature(fun.Recv, fun.Type)
+       f := ir.NewFunc(p.pos(fun))
+
+       if fun.Recv == nil {
+               if name.Name == "init" {
+                       name = renameinit()
+                       if len(t.Params) > 0 || len(t.Results) > 0 {
+                               base.ErrorfAt(f.Pos(), "func init must have no arguments and no return values")
+                       }
+                       typecheck.Target.Inits = append(typecheck.Target.Inits, f)
+               }
+
+               if types.LocalPkg.Name == "main" && name.Name == "main" {
+                       if len(t.Params) > 0 || len(t.Results) > 0 {
+                               base.ErrorfAt(f.Pos(), "func main must have no arguments and no return values")
+                       }
+               }
+       } else {
+               f.Shortname = name
+               name = ir.BlankNode.Sym() // filled in by tcFunc
+       }
+
+       f.Nname = ir.NewNameAt(p.pos(fun.Name), name)
+       f.Nname.Func = f
+       f.Nname.Defn = f
+       f.Nname.Ntype = t
+
+       if pragma, ok := fun.Pragma.(*pragmas); ok {
+               f.Pragma = pragma.Flag & funcPragmas
+               if pragma.Flag&ir.Systemstack != 0 && pragma.Flag&ir.Nosplit != 0 {
+                       base.ErrorfAt(f.Pos(), "go:nosplit and go:systemstack cannot be combined")
+               }
+               pragma.Flag &^= funcPragmas
+               p.checkUnused(pragma)
+       }
+
+       if fun.Recv == nil {
+               typecheck.Declare(f.Nname, ir.PFUNC)
+       }
+
+       p.funcBody(f, fun.Body)
+
+       if fun.Body != nil {
+               if f.Pragma&ir.Noescape != 0 {
+                       base.ErrorfAt(f.Pos(), "can only use //go:noescape with external func implementations")
+               }
+       } else {
+               if base.Flag.Complete || strings.HasPrefix(ir.FuncName(f), "init.") {
+                       // Linknamed functions are allowed to have no body. Hopefully
+                       // the linkname target has a body. See issue 23311.
+                       isLinknamed := false
+                       for _, n := range p.linknames {
+                               if ir.FuncName(f) == n.local {
+                                       isLinknamed = true
+                                       break
+                               }
+                       }
+                       if !isLinknamed {
+                               base.ErrorfAt(f.Pos(), "missing function body")
+                       }
+               }
+       }
+
+       return f
+}
+
+func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.FuncType {
+       var rcvr *ir.Field
+       if recv != nil {
+               rcvr = p.param(recv, false, false)
+       }
+       return ir.NewFuncType(p.pos(typ), rcvr,
+               p.params(typ.ParamList, true),
+               p.params(typ.ResultList, false))
+}
+
+func (p *noder) params(params []*syntax.Field, dddOk bool) []*ir.Field {
+       nodes := make([]*ir.Field, 0, len(params))
+       for i, param := range params {
+               p.setlineno(param)
+               nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
+       }
+       return nodes
+}
+
+func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Field {
+       var name *types.Sym
+       if param.Name != nil {
+               name = p.name(param.Name)
+       }
+
+       typ := p.typeExpr(param.Type)
+       n := ir.NewField(p.pos(param), name, typ, nil)
+
+       // rewrite ...T parameter
+       if typ, ok := typ.(*ir.SliceType); ok && typ.DDD {
+               if !dddOk {
+                       // We mark these as syntax errors to get automatic elimination
+                       // of multiple such errors per line (see ErrorfAt in subr.go).
+                       base.Errorf("syntax error: cannot use ... in receiver or result parameter list")
+               } else if !final {
+                       if param.Name == nil {
+                               base.Errorf("syntax error: cannot use ... with non-final parameter")
+                       } else {
+                               p.errorAt(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
+                       }
+               }
+               typ.DDD = false
+               n.IsDDD = true
+       }
+
+       return n
+}
+
+func (p *noder) exprList(expr syntax.Expr) []ir.Node {
+       switch expr := expr.(type) {
+       case nil:
+               return nil
+       case *syntax.ListExpr:
+               return p.exprs(expr.ElemList)
+       default:
+               return []ir.Node{p.expr(expr)}
+       }
+}
+
+func (p *noder) exprs(exprs []syntax.Expr) []ir.Node {
+       nodes := make([]ir.Node, 0, len(exprs))
+       for _, expr := range exprs {
+               nodes = append(nodes, p.expr(expr))
+       }
+       return nodes
+}
+
+func (p *noder) expr(expr syntax.Expr) ir.Node {
+       p.setlineno(expr)
+       switch expr := expr.(type) {
+       case nil, *syntax.BadExpr:
+               return nil
+       case *syntax.Name:
+               return p.mkname(expr)
+       case *syntax.BasicLit:
+               n := ir.NewBasicLit(p.pos(expr), p.basicLit(expr))
+               if expr.Kind == syntax.RuneLit {
+                       n.SetType(types.UntypedRune)
+               }
+               n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
+               return n
+       case *syntax.CompositeLit:
+               n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, p.typeExpr(expr.Type), nil)
+               l := p.exprs(expr.ElemList)
+               for i, e := range l {
+                       l[i] = p.wrapname(expr.ElemList[i], e)
+               }
+               n.List = l
+               base.Pos = p.makeXPos(expr.Rbrace)
+               return n
+       case *syntax.KeyValueExpr:
+               // use position of expr.Key rather than of expr (which has position of ':')
+               return ir.NewKeyExpr(p.pos(expr.Key), p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
+       case *syntax.FuncLit:
+               return p.funcLit(expr)
+       case *syntax.ParenExpr:
+               return ir.NewParenExpr(p.pos(expr), p.expr(expr.X))
+       case *syntax.SelectorExpr:
+               // parser.new_dotname
+               obj := p.expr(expr.X)
+               if obj.Op() == ir.OPACK {
+                       pack := obj.(*ir.PkgName)
+                       pack.Used = true
+                       return importName(pack.Pkg.Lookup(expr.Sel.Value))
+               }
+               n := ir.NewSelectorExpr(base.Pos, ir.OXDOT, obj, p.name(expr.Sel))
+               n.SetPos(p.pos(expr)) // lineno may have been changed by p.expr(expr.X)
+               return n
+       case *syntax.IndexExpr:
+               return ir.NewIndexExpr(p.pos(expr), p.expr(expr.X), p.expr(expr.Index))
+       case *syntax.SliceExpr:
+               op := ir.OSLICE
+               if expr.Full {
+                       op = ir.OSLICE3
+               }
+               x := p.expr(expr.X)
+               var index [3]ir.Node
+               for i, n := range &expr.Index {
+                       if n != nil {
+                               index[i] = p.expr(n)
+                       }
+               }
+               return ir.NewSliceExpr(p.pos(expr), op, x, index[0], index[1], index[2])
+       case *syntax.AssertExpr:
+               return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type))
+       case *syntax.Operation:
+               if expr.Op == syntax.Add && expr.Y != nil {
+                       return p.sum(expr)
+               }
+               x := p.expr(expr.X)
+               if expr.Y == nil {
+                       pos, op := p.pos(expr), p.unOp(expr.Op)
+                       switch op {
+                       case ir.OADDR:
+                               return typecheck.NodAddrAt(pos, x)
+                       case ir.ODEREF:
+                               return ir.NewStarExpr(pos, x)
+                       }
+                       return ir.NewUnaryExpr(pos, op, x)
+               }
+
+               pos, op, y := p.pos(expr), p.binOp(expr.Op), p.expr(expr.Y)
+               switch op {
+               case ir.OANDAND, ir.OOROR:
+                       return ir.NewLogicalExpr(pos, op, x, y)
+               }
+               return ir.NewBinaryExpr(pos, op, x, y)
+       case *syntax.CallExpr:
+               n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), p.exprs(expr.ArgList))
+               n.IsDDD = expr.HasDots
+               return n
+
+       case *syntax.ArrayType:
+               var len ir.Node
+               if expr.Len != nil {
+                       len = p.expr(expr.Len)
+               }
+               return ir.NewArrayType(p.pos(expr), len, p.typeExpr(expr.Elem))
+       case *syntax.SliceType:
+               return ir.NewSliceType(p.pos(expr), p.typeExpr(expr.Elem))
+       case *syntax.DotsType:
+               t := ir.NewSliceType(p.pos(expr), p.typeExpr(expr.Elem))
+               t.DDD = true
+               return t
+       case *syntax.StructType:
+               return p.structType(expr)
+       case *syntax.InterfaceType:
+               return p.interfaceType(expr)
+       case *syntax.FuncType:
+               return p.signature(nil, expr)
+       case *syntax.MapType:
+               return ir.NewMapType(p.pos(expr),
+                       p.typeExpr(expr.Key), p.typeExpr(expr.Value))
+       case *syntax.ChanType:
+               return ir.NewChanType(p.pos(expr),
+                       p.typeExpr(expr.Elem), p.chanDir(expr.Dir))
+
+       case *syntax.TypeSwitchGuard:
+               var tag *ir.Ident
+               if expr.Lhs != nil {
+                       tag = ir.NewIdent(p.pos(expr.Lhs), p.name(expr.Lhs))
+                       if ir.IsBlank(tag) {
+                               base.Errorf("invalid variable name %v in type switch", tag)
+                       }
+               }
+               return ir.NewTypeSwitchGuard(p.pos(expr), tag, p.expr(expr.X))
+       }
+       panic("unhandled Expr")
+}
+
+// sum efficiently handles very large summation expressions (such as
+// in issue #16394). In particular, it avoids left recursion and
+// collapses string literals.
+func (p *noder) sum(x syntax.Expr) ir.Node {
+       // While we need to handle long sums with asymptotic
+       // efficiency, the vast majority of sums are very small: ~95%
+       // have only 2 or 3 operands, and ~99% of string literals are
+       // never concatenated.
+
+       adds := make([]*syntax.Operation, 0, 2)
+       for {
+               add, ok := x.(*syntax.Operation)
+               if !ok || add.Op != syntax.Add || add.Y == nil {
+                       break
+               }
+               adds = append(adds, add)
+               x = add.X
+       }
+
+       // nstr is the current rightmost string literal in the
+       // summation (if any), and chunks holds its accumulated
+       // substrings.
+       //
+       // Consider the expression x + "a" + "b" + "c" + y. When we
+       // reach the string literal "a", we assign nstr to point to
+       // its corresponding Node and initialize chunks to {"a"}.
+       // Visiting the subsequent string literals "b" and "c", we
+       // simply append their values to chunks. Finally, when we
+       // reach the non-constant operand y, we'll join chunks to form
+       // "abc" and reassign the "a" string literal's value.
+       //
+       // N.B., we need to be careful about named string constants
+       // (indicated by Sym != nil) because 1) we can't modify their
+       // value, as doing so would affect other uses of the string
+       // constant, and 2) they may have types, which we need to
+       // handle correctly. For now, we avoid these problems by
+       // treating named string constants the same as non-constant
+       // operands.
+       var nstr ir.Node
+       chunks := make([]string, 0, 1)
+
+       n := p.expr(x)
+       if ir.IsConst(n, constant.String) && n.Sym() == nil {
+               nstr = n
+               chunks = append(chunks, ir.StringVal(nstr))
+       }
+
+       for i := len(adds) - 1; i >= 0; i-- {
+               add := adds[i]
+
+               r := p.expr(add.Y)
+               if ir.IsConst(r, constant.String) && r.Sym() == nil {
+                       if nstr != nil {
+                               // Collapse r into nstr instead of adding to n.
+                               chunks = append(chunks, ir.StringVal(r))
+                               continue
+                       }
+
+                       nstr = r
+                       chunks = append(chunks, ir.StringVal(nstr))
+               } else {
+                       if len(chunks) > 1 {
+                               nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
+                       }
+                       nstr = nil
+                       chunks = chunks[:0]
+               }
+               n = ir.NewBinaryExpr(p.pos(add), ir.OADD, n, r)
+       }
+       if len(chunks) > 1 {
+               nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
+       }
+
+       return n
+}
+
+func (p *noder) typeExpr(typ syntax.Expr) ir.Ntype {
+       // TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
+       n := p.expr(typ)
+       if n == nil {
+               return nil
+       }
+       if _, ok := n.(ir.Ntype); !ok {
+               ir.Dump("NOT NTYPE", n)
+       }
+       return n.(ir.Ntype)
+}
+
+func (p *noder) typeExprOrNil(typ syntax.Expr) ir.Ntype {
+       if typ != nil {
+               return p.typeExpr(typ)
+       }
+       return nil
+}
+
+func (p *noder) chanDir(dir syntax.ChanDir) types.ChanDir {
+       switch dir {
+       case 0:
+               return types.Cboth
+       case syntax.SendOnly:
+               return types.Csend
+       case syntax.RecvOnly:
+               return types.Crecv
+       }
+       panic("unhandled ChanDir")
+}
+
+func (p *noder) structType(expr *syntax.StructType) ir.Node {
+       l := make([]*ir.Field, 0, len(expr.FieldList))
+       for i, field := range expr.FieldList {
+               p.setlineno(field)
+               var n *ir.Field
+               if field.Name == nil {
+                       n = p.embedded(field.Type)
+               } else {
+                       n = ir.NewField(p.pos(field), p.name(field.Name), p.typeExpr(field.Type), nil)
+               }
+               if i < len(expr.TagList) && expr.TagList[i] != nil {
+                       n.Note = constant.StringVal(p.basicLit(expr.TagList[i]))
+               }
+               l = append(l, n)
+       }
+
+       p.setlineno(expr)
+       return ir.NewStructType(p.pos(expr), l)
+}
+
+func (p *noder) interfaceType(expr *syntax.InterfaceType) ir.Node {
+       l := make([]*ir.Field, 0, len(expr.MethodList))
+       for _, method := range expr.MethodList {
+               p.setlineno(method)
+               var n *ir.Field
+               if method.Name == nil {
+                       n = ir.NewField(p.pos(method), nil, importName(p.packname(method.Type)).(ir.Ntype), nil)
+               } else {
+                       mname := p.name(method.Name)
+                       if mname.IsBlank() {
+                               base.Errorf("methods must have a unique non-blank name")
+                               continue
+                       }
+                       sig := p.typeExpr(method.Type).(*ir.FuncType)
+                       sig.Recv = fakeRecv()
+                       n = ir.NewField(p.pos(method), mname, sig, nil)
+               }
+               l = append(l, n)
+       }
+
+       return ir.NewInterfaceType(p.pos(expr), l)
+}
+
+func (p *noder) packname(expr syntax.Expr) *types.Sym {
+       switch expr := expr.(type) {
+       case *syntax.Name:
+               name := p.name(expr)
+               if n := oldname(name); n.Name() != nil && n.Name().PkgName != nil {
+                       n.Name().PkgName.Used = true
+               }
+               return name
+       case *syntax.SelectorExpr:
+               name := p.name(expr.X.(*syntax.Name))
+               def := ir.AsNode(name.Def)
+               if def == nil {
+                       base.Errorf("undefined: %v", name)
+                       return name
+               }
+               var pkg *types.Pkg
+               if def.Op() != ir.OPACK {
+                       base.Errorf("%v is not a package", name)
+                       pkg = types.LocalPkg
+               } else {
+                       def := def.(*ir.PkgName)
+                       def.Used = true
+                       pkg = def.Pkg
+               }
+               return pkg.Lookup(expr.Sel.Value)
+       }
+       panic(fmt.Sprintf("unexpected packname: %#v", expr))
+}
+
+func (p *noder) embedded(typ syntax.Expr) *ir.Field {
+       op, isStar := typ.(*syntax.Operation)
+       if isStar {
+               if op.Op != syntax.Mul || op.Y != nil {
+                       panic("unexpected Operation")
+               }
+               typ = op.X
+       }
+
+       sym := p.packname(typ)
+       n := ir.NewField(p.pos(typ), typecheck.Lookup(sym.Name), importName(sym).(ir.Ntype), nil)
+       n.Embedded = true
+
+       if isStar {
+               n.Ntype = ir.NewStarExpr(p.pos(op), n.Ntype)
+       }
+       return n
+}
+
+func (p *noder) stmts(stmts []syntax.Stmt) []ir.Node {
+       return p.stmtsFall(stmts, false)
+}
+
+func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
+       var nodes []ir.Node
+       for i, stmt := range stmts {
+               s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
+               if s == nil {
+               } else if s.Op() == ir.OBLOCK && len(s.(*ir.BlockStmt).List) > 0 {
+                       // Inline non-empty block.
+                       // Empty blocks must be preserved for CheckReturn.
+                       nodes = append(nodes, s.(*ir.BlockStmt).List...)
+               } else {
+                       nodes = append(nodes, s)
+               }
+       }
+       return nodes
+}
+
+func (p *noder) stmt(stmt syntax.Stmt) ir.Node {
+       return p.stmtFall(stmt, false)
+}
+
+func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
+       p.setlineno(stmt)
+       switch stmt := stmt.(type) {
+       case nil, *syntax.EmptyStmt:
+               return nil
+       case *syntax.LabeledStmt:
+               return p.labeledStmt(stmt, fallOK)
+       case *syntax.BlockStmt:
+               l := p.blockStmt(stmt)
+               if len(l) == 0 {
+                       // TODO(mdempsky): Line number?
+                       return ir.NewBlockStmt(base.Pos, nil)
+               }
+               return ir.NewBlockStmt(src.NoXPos, l)
+       case *syntax.ExprStmt:
+               return p.wrapname(stmt, p.expr(stmt.X))
+       case *syntax.SendStmt:
+               return ir.NewSendStmt(p.pos(stmt), p.expr(stmt.Chan), p.expr(stmt.Value))
+       case *syntax.DeclStmt:
+               return ir.NewBlockStmt(src.NoXPos, p.decls(stmt.DeclList))
+       case *syntax.AssignStmt:
+               if stmt.Rhs == syntax.ImplicitOne {
+                       one := constant.MakeInt64(1)
+                       pos := p.pos(stmt)
+                       n := ir.NewAssignOpStmt(pos, p.binOp(stmt.Op), p.expr(stmt.Lhs), ir.NewBasicLit(pos, one))
+                       n.IncDec = true
+                       return n
+               }
+
+               if stmt.Op != 0 && stmt.Op != syntax.Def {
+                       n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
+                       return n
+               }
+
+               rhs := p.exprList(stmt.Rhs)
+               if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
+                       n := ir.NewAssignListStmt(p.pos(stmt), ir.OAS2, nil, nil)
+                       n.Def = stmt.Op == syntax.Def
+                       n.Lhs = p.assignList(stmt.Lhs, n, n.Def)
+                       n.Rhs = rhs
+                       return n
+               }
+
+               n := ir.NewAssignStmt(p.pos(stmt), nil, nil)
+               n.Def = stmt.Op == syntax.Def
+               n.X = p.assignList(stmt.Lhs, n, n.Def)[0]
+               n.Y = rhs[0]
+               return n
+
+       case *syntax.BranchStmt:
+               var op ir.Op
+               switch stmt.Tok {
+               case syntax.Break:
+                       op = ir.OBREAK
+               case syntax.Continue:
+                       op = ir.OCONTINUE
+               case syntax.Fallthrough:
+                       if !fallOK {
+                               base.Errorf("fallthrough statement out of place")
+                       }
+                       op = ir.OFALL
+               case syntax.Goto:
+                       op = ir.OGOTO
+               default:
+                       panic("unhandled BranchStmt")
+               }
+               var sym *types.Sym
+               if stmt.Label != nil {
+                       sym = p.name(stmt.Label)
+               }
+               return ir.NewBranchStmt(p.pos(stmt), op, sym)
+       case *syntax.CallStmt:
+               var op ir.Op
+               switch stmt.Tok {
+               case syntax.Defer:
+                       op = ir.ODEFER
+               case syntax.Go:
+                       op = ir.OGO
+               default:
+                       panic("unhandled CallStmt")
+               }
+               return ir.NewGoDeferStmt(p.pos(stmt), op, p.expr(stmt.Call))
+       case *syntax.ReturnStmt:
+               n := ir.NewReturnStmt(p.pos(stmt), p.exprList(stmt.Results))
+               if len(n.Results) == 0 && ir.CurFunc != nil {
+                       for _, ln := range ir.CurFunc.Dcl {
+                               if ln.Class == ir.PPARAM {
+                                       continue
+                               }
+                               if ln.Class != ir.PPARAMOUT {
+                                       break
+                               }
+                               if ln.Sym().Def != ln {
+                                       base.Errorf("%s is shadowed during return", ln.Sym().Name)
+                               }
+                       }
+               }
+               return n
+       case *syntax.IfStmt:
+               return p.ifStmt(stmt)
+       case *syntax.ForStmt:
+               return p.forStmt(stmt)
+       case *syntax.SwitchStmt:
+               return p.switchStmt(stmt)
+       case *syntax.SelectStmt:
+               return p.selectStmt(stmt)
+       }
+       panic("unhandled Stmt")
+}
+
+func (p *noder) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.Node {
+       if !colas {
+               return p.exprList(expr)
+       }
+
+       var exprs []syntax.Expr
+       if list, ok := expr.(*syntax.ListExpr); ok {
+               exprs = list.ElemList
+       } else {
+               exprs = []syntax.Expr{expr}
+       }
+
+       res := make([]ir.Node, len(exprs))
+       seen := make(map[*types.Sym]bool, len(exprs))
+
+       newOrErr := false
+       for i, expr := range exprs {
+               p.setlineno(expr)
+               res[i] = ir.BlankNode
+
+               name, ok := expr.(*syntax.Name)
+               if !ok {
+                       p.errorAt(expr.Pos(), "non-name %v on left side of :=", p.expr(expr))
+                       newOrErr = true
+                       continue
+               }
+
+               sym := p.name(name)
+               if sym.IsBlank() {
+                       continue
+               }
+
+               if seen[sym] {
+                       p.errorAt(expr.Pos(), "%v repeated on left side of :=", sym)
+                       newOrErr = true
+                       continue
+               }
+               seen[sym] = true
+
+               if sym.Block == types.Block {
+                       res[i] = oldname(sym)
+                       continue
+               }
+
+               newOrErr = true
+               n := typecheck.NewName(sym)
+               typecheck.Declare(n, typecheck.DeclContext)
+               n.Defn = defn
+               defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+               res[i] = n
+       }
+
+       if !newOrErr {
+               base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
+       }
+       return res
+}
+
+func (p *noder) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
+       p.openScope(stmt.Pos())
+       nodes := p.stmts(stmt.List)
+       p.closeScope(stmt.Rbrace)
+       return nodes
+}
+
+func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
+       p.openScope(stmt.Pos())
+       init := p.stmt(stmt.Init)
+       n := ir.NewIfStmt(p.pos(stmt), p.expr(stmt.Cond), p.blockStmt(stmt.Then), nil)
+       if init != nil {
+               *n.PtrInit() = []ir.Node{init}
+       }
+       if stmt.Else != nil {
+               e := p.stmt(stmt.Else)
+               if e.Op() == ir.OBLOCK {
+                       e := e.(*ir.BlockStmt)
+                       n.Else = e.List
+               } else {
+                       n.Else = []ir.Node{e}
+               }
+       }
+       p.closeAnotherScope()
+       return n
+}
+
+func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
+       p.openScope(stmt.Pos())
+       if r, ok := stmt.Init.(*syntax.RangeClause); ok {
+               if stmt.Cond != nil || stmt.Post != nil {
+                       panic("unexpected RangeClause")
+               }
+
+               n := ir.NewRangeStmt(p.pos(r), nil, nil, p.expr(r.X), nil)
+               if r.Lhs != nil {
+                       n.Def = r.Def
+                       lhs := p.assignList(r.Lhs, n, n.Def)
+                       n.Key = lhs[0]
+                       if len(lhs) > 1 {
+                               n.Value = lhs[1]
+                       }
+               }
+               n.Body = p.blockStmt(stmt.Body)
+               p.closeAnotherScope()
+               return n
+       }
+
+       n := ir.NewForStmt(p.pos(stmt), p.stmt(stmt.Init), p.expr(stmt.Cond), p.stmt(stmt.Post), p.blockStmt(stmt.Body))
+       p.closeAnotherScope()
+       return n
+}
+
+func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
+       p.openScope(stmt.Pos())
+
+       init := p.stmt(stmt.Init)
+       n := ir.NewSwitchStmt(p.pos(stmt), p.expr(stmt.Tag), nil)
+       if init != nil {
+               *n.PtrInit() = []ir.Node{init}
+       }
+
+       var tswitch *ir.TypeSwitchGuard
+       if l := n.Tag; l != nil && l.Op() == ir.OTYPESW {
+               tswitch = l.(*ir.TypeSwitchGuard)
+       }
+       n.Cases = p.caseClauses(stmt.Body, tswitch, stmt.Rbrace)
+
+       p.closeScope(stmt.Rbrace)
+       return n
+}
+
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []*ir.CaseClause {
+       nodes := make([]*ir.CaseClause, 0, len(clauses))
+       for i, clause := range clauses {
+               p.setlineno(clause)
+               if i > 0 {
+                       p.closeScope(clause.Pos())
+               }
+               p.openScope(clause.Pos())
+
+               n := ir.NewCaseStmt(p.pos(clause), p.exprList(clause.Cases), nil)
+               if tswitch != nil && tswitch.Tag != nil {
+                       nn := typecheck.NewName(tswitch.Tag.Sym())
+                       typecheck.Declare(nn, typecheck.DeclContext)
+                       n.Var = nn
+                       // keep track of the instances for reporting unused
+                       nn.Defn = tswitch
+               }
+
+               // Trim trailing empty statements. We omit them from
+               // the Node AST anyway, and it's easier to identify
+               // out-of-place fallthrough statements without them.
+               body := clause.Body
+               for len(body) > 0 {
+                       if _, ok := body[len(body)-1].(*syntax.EmptyStmt); !ok {
+                               break
+                       }
+                       body = body[:len(body)-1]
+               }
+
+               n.Body = p.stmtsFall(body, true)
+               if l := len(n.Body); l > 0 && n.Body[l-1].Op() == ir.OFALL {
+                       if tswitch != nil {
+                               base.Errorf("cannot fallthrough in type switch")
+                       }
+                       if i+1 == len(clauses) {
+                               base.Errorf("cannot fallthrough final case in switch")
+                       }
+               }
+
+               nodes = append(nodes, n)
+       }
+       if len(clauses) > 0 {
+               p.closeScope(rbrace)
+       }
+       return nodes
+}
+
+func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
+       return ir.NewSelectStmt(p.pos(stmt), p.commClauses(stmt.Body, stmt.Rbrace))
+}
+
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CommClause {
+       nodes := make([]*ir.CommClause, len(clauses))
+       for i, clause := range clauses {
+               p.setlineno(clause)
+               if i > 0 {
+                       p.closeScope(clause.Pos())
+               }
+               p.openScope(clause.Pos())
+
+               nodes[i] = ir.NewCommStmt(p.pos(clause), p.stmt(clause.Comm), p.stmts(clause.Body))
+       }
+       if len(clauses) > 0 {
+               p.closeScope(rbrace)
+       }
+       return nodes
+}
+
+func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
+       sym := p.name(label.Label)
+       lhs := ir.NewLabelStmt(p.pos(label), sym)
+
+       var ls ir.Node
+       if label.Stmt != nil { // TODO(mdempsky): Should always be present.
+               ls = p.stmtFall(label.Stmt, fallOK)
+               // Attach label directly to control statement too.
+               if ls != nil {
+                       switch ls.Op() {
+                       case ir.OFOR:
+                               ls := ls.(*ir.ForStmt)
+                               ls.Label = sym
+                       case ir.ORANGE:
+                               ls := ls.(*ir.RangeStmt)
+                               ls.Label = sym
+                       case ir.OSWITCH:
+                               ls := ls.(*ir.SwitchStmt)
+                               ls.Label = sym
+                       case ir.OSELECT:
+                               ls := ls.(*ir.SelectStmt)
+                               ls.Label = sym
+                       }
+               }
+       }
+
+       l := []ir.Node{lhs}
+       if ls != nil {
+               if ls.Op() == ir.OBLOCK {
+                       ls := ls.(*ir.BlockStmt)
+                       l = append(l, ls.List...)
+               } else {
+                       l = append(l, ls)
+               }
+       }
+       return ir.NewBlockStmt(src.NoXPos, l)
+}
+
+var unOps = [...]ir.Op{
+       syntax.Recv: ir.ORECV,
+       syntax.Mul:  ir.ODEREF,
+       syntax.And:  ir.OADDR,
+
+       syntax.Not: ir.ONOT,
+       syntax.Xor: ir.OBITNOT,
+       syntax.Add: ir.OPLUS,
+       syntax.Sub: ir.ONEG,
+}
+
+func (p *noder) unOp(op syntax.Operator) ir.Op {
+       if uint64(op) >= uint64(len(unOps)) || unOps[op] == 0 {
+               panic("invalid Operator")
+       }
+       return unOps[op]
+}
+
+var binOps = [...]ir.Op{
+       syntax.OrOr:   ir.OOROR,
+       syntax.AndAnd: ir.OANDAND,
+
+       syntax.Eql: ir.OEQ,
+       syntax.Neq: ir.ONE,
+       syntax.Lss: ir.OLT,
+       syntax.Leq: ir.OLE,
+       syntax.Gtr: ir.OGT,
+       syntax.Geq: ir.OGE,
+
+       syntax.Add: ir.OADD,
+       syntax.Sub: ir.OSUB,
+       syntax.Or:  ir.OOR,
+       syntax.Xor: ir.OXOR,
+
+       syntax.Mul:    ir.OMUL,
+       syntax.Div:    ir.ODIV,
+       syntax.Rem:    ir.OMOD,
+       syntax.And:    ir.OAND,
+       syntax.AndNot: ir.OANDNOT,
+       syntax.Shl:    ir.OLSH,
+       syntax.Shr:    ir.ORSH,
+}
+
+func (p *noder) binOp(op syntax.Operator) ir.Op {
+       if uint64(op) >= uint64(len(binOps)) || binOps[op] == 0 {
+               panic("invalid Operator")
+       }
+       return binOps[op]
+}
+
+// checkLangCompat reports an error if the representation of a numeric
+// literal is not compatible with the current language version.
+func checkLangCompat(lit *syntax.BasicLit) {
+       s := lit.Value
+       if len(s) <= 2 || types.AllowsGoVersion(types.LocalPkg, 1, 13) {
+               return
+       }
+       // len(s) > 2
+       if strings.Contains(s, "_") {
+               base.ErrorfVers("go1.13", "underscores in numeric literals")
+               return
+       }
+       if s[0] != '0' {
+               return
+       }
+       radix := s[1]
+       if radix == 'b' || radix == 'B' {
+               base.ErrorfVers("go1.13", "binary literals")
+               return
+       }
+       if radix == 'o' || radix == 'O' {
+               base.ErrorfVers("go1.13", "0o/0O-style octal literals")
+               return
+       }
+       if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') {
+               base.ErrorfVers("go1.13", "hexadecimal floating-point literals")
+       }
+}
+
+func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
+       // We don't use the errors of the conversion routines to determine
+       // if a literal string is valid because the conversion routines may
+       // accept a wider syntax than the language permits. Rely on lit.Bad
+       // instead.
+       if lit.Bad {
+               return constant.MakeUnknown()
+       }
+
+       switch lit.Kind {
+       case syntax.IntLit, syntax.FloatLit, syntax.ImagLit:
+               checkLangCompat(lit)
+       }
+
+       v := constant.MakeFromLiteral(lit.Value, tokenForLitKind[lit.Kind], 0)
+       if v.Kind() == constant.Unknown {
+               // TODO(mdempsky): Better error message?
+               p.errorAt(lit.Pos(), "malformed constant: %s", lit.Value)
+       }
+
+       return v
+}
+
+var tokenForLitKind = [...]token.Token{
+       syntax.IntLit:    token.INT,
+       syntax.RuneLit:   token.CHAR,
+       syntax.FloatLit:  token.FLOAT,
+       syntax.ImagLit:   token.IMAG,
+       syntax.StringLit: token.STRING,
+}
+
+func (p *noder) name(name *syntax.Name) *types.Sym {
+       return typecheck.Lookup(name.Value)
+}
+
+func (p *noder) mkname(name *syntax.Name) ir.Node {
+       // TODO(mdempsky): Set line number?
+       return mkname(p.name(name))
+}
+
+func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
+       // These nodes do not carry line numbers.
+       // Introduce a wrapper node to give them the correct line.
+       switch x.Op() {
+       case ir.OTYPE, ir.OLITERAL:
+               if x.Sym() == nil {
+                       break
+               }
+               fallthrough
+       case ir.ONAME, ir.ONONAME, ir.OPACK:
+               p := ir.NewParenExpr(p.pos(n), x)
+               p.SetImplicit(true)
+               return p
+       }
+       return x
+}
+
+func (p *noder) setlineno(n syntax.Node) {
+       if n != nil {
+               base.Pos = p.pos(n)
+       }
+}
+
+// error is called concurrently if files are parsed concurrently.
+func (p *noder) error(err error) {
+       p.err <- err.(syntax.Error)
+}
+
+// pragmas that are allowed in the std lib, but don't have
+// a syntax.Pragma value (see lex.go) associated with them.
+var allowedStdPragmas = map[string]bool{
+       "go:cgo_export_static":  true,
+       "go:cgo_export_dynamic": true,
+       "go:cgo_import_static":  true,
+       "go:cgo_import_dynamic": true,
+       "go:cgo_ldflag":         true,
+       "go:cgo_dynamic_linker": true,
+       "go:embed":              true,
+       "go:generate":           true,
+}
+
+// *pragmas is the value stored in a syntax.pragmas during parsing.
+type pragmas struct {
+       Flag   ir.PragmaFlag // collected bits
+       Pos    []pragmaPos   // position of each individual flag
+       Embeds []pragmaEmbed
+}
+
+type pragmaPos struct {
+       Flag ir.PragmaFlag
+       Pos  syntax.Pos
+}
+
+type pragmaEmbed struct {
+       Pos      syntax.Pos
+       Patterns []string
+}
+
+func (p *noder) checkUnused(pragma *pragmas) {
+       for _, pos := range pragma.Pos {
+               if pos.Flag&pragma.Flag != 0 {
+                       p.errorAt(pos.Pos, "misplaced compiler directive")
+               }
+       }
+       if len(pragma.Embeds) > 0 {
+               for _, e := range pragma.Embeds {
+                       p.errorAt(e.Pos, "misplaced go:embed directive")
+               }
+       }
+}
+
+func (p *noder) checkUnusedDuringParse(pragma *pragmas) {
+       for _, pos := range pragma.Pos {
+               if pos.Flag&pragma.Flag != 0 {
+                       p.error(syntax.Error{Pos: pos.Pos, Msg: "misplaced compiler directive"})
+               }
+       }
+       if len(pragma.Embeds) > 0 {
+               for _, e := range pragma.Embeds {
+                       p.error(syntax.Error{Pos: e.Pos, Msg: "misplaced go:embed directive"})
+               }
+       }
+}
+
+// pragma is called concurrently if files are parsed concurrently.
+func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.Pragma) syntax.Pragma {
+       pragma, _ := old.(*pragmas)
+       if pragma == nil {
+               pragma = new(pragmas)
+       }
+
+       if text == "" {
+               // unused pragma; only called with old != nil.
+               p.checkUnusedDuringParse(pragma)
+               return nil
+       }
+
+       if strings.HasPrefix(text, "line ") {
+               // line directives are handled by syntax package
+               panic("unreachable")
+       }
+
+       if !blankLine {
+               // directive must be on line by itself
+               p.error(syntax.Error{Pos: pos, Msg: "misplaced compiler directive"})
+               return pragma
+       }
+
+       switch {
+       case strings.HasPrefix(text, "go:linkname "):
+               f := strings.Fields(text)
+               if !(2 <= len(f) && len(f) <= 3) {
+                       p.error(syntax.Error{Pos: pos, Msg: "usage: //go:linkname localname [linkname]"})
+                       break
+               }
+               // The second argument is optional. If omitted, we use
+               // the default object symbol name for this and
+               // linkname only serves to mark this symbol as
+               // something that may be referenced via the object
+               // symbol name from another package.
+               var target string
+               if len(f) == 3 {
+                       target = f[2]
+               } else if base.Ctxt.Pkgpath != "" {
+                       // Use the default object symbol name if the
+                       // user didn't provide one.
+                       target = objabi.PathToPrefix(base.Ctxt.Pkgpath) + "." + f[1]
+               } else {
+                       p.error(syntax.Error{Pos: pos, Msg: "//go:linkname requires linkname argument or -p compiler flag"})
+                       break
+               }
+               p.linknames = append(p.linknames, linkname{pos, f[1], target})
+
+       case text == "go:embed", strings.HasPrefix(text, "go:embed "):
+               args, err := parseGoEmbed(text[len("go:embed"):])
+               if err != nil {
+                       p.error(syntax.Error{Pos: pos, Msg: err.Error()})
+               }
+               if len(args) == 0 {
+                       p.error(syntax.Error{Pos: pos, Msg: "usage: //go:embed pattern..."})
+                       break
+               }
+               pragma.Embeds = append(pragma.Embeds, pragmaEmbed{pos, args})
+
+       case strings.HasPrefix(text, "go:cgo_import_dynamic "):
+               // This is permitted for general use because Solaris
+               // code relies on it in golang.org/x/sys/unix and others.
+               fields := pragmaFields(text)
+               if len(fields) >= 4 {
+                       lib := strings.Trim(fields[3], `"`)
+                       if lib != "" && !safeArg(lib) && !isCgoGeneratedFile(pos) {
+                               p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("invalid library name %q in cgo_import_dynamic directive", lib)})
+                       }
+                       p.pragcgo(pos, text)
+                       pragma.Flag |= pragmaFlag("go:cgo_import_dynamic")
+                       break
+               }
+               fallthrough
+       case strings.HasPrefix(text, "go:cgo_"):
+               // For security, we disallow //go:cgo_* directives other
+               // than cgo_import_dynamic outside cgo-generated files.
+               // Exception: they are allowed in the standard library, for runtime and syscall.
+               if !isCgoGeneratedFile(pos) && !base.Flag.Std {
+                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in cgo-generated code", text)})
+               }
+               p.pragcgo(pos, text)
+               fallthrough // because of //go:cgo_unsafe_args
+       default:
+               verb := text
+               if i := strings.Index(text, " "); i >= 0 {
+                       verb = verb[:i]
+               }
+               flag := pragmaFlag(verb)
+               const runtimePragmas = ir.Systemstack | ir.Nowritebarrier | ir.Nowritebarrierrec | ir.Yeswritebarrierrec
+               if !base.Flag.CompilingRuntime && flag&runtimePragmas != 0 {
+                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in runtime", verb)})
+               }
+               if flag == 0 && !allowedStdPragmas[verb] && base.Flag.Std {
+                       p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s is not allowed in the standard library", verb)})
+               }
+               pragma.Flag |= flag
+               pragma.Pos = append(pragma.Pos, pragmaPos{flag, pos})
+       }
+
+       return pragma
+}
+
+// isCgoGeneratedFile reports whether pos is in a file
+// generated by cgo, which is to say a file with name
+// beginning with "_cgo_". Such files are allowed to
+// contain cgo directives, and for security reasons
+// (primarily misuse of linker flags), other files are not.
+// See golang.org/issue/23672.
+func isCgoGeneratedFile(pos syntax.Pos) bool {
+       return strings.HasPrefix(filepath.Base(filepath.Clean(fileh(pos.Base().Filename()))), "_cgo_")
+}
+
+// safeArg reports whether arg is a "safe" command-line argument,
+// meaning that when it appears in a command-line, it probably
+// doesn't have some special meaning other than its own name.
+// This is copied from SafeArg in cmd/go/internal/load/pkg.go.
+func safeArg(name string) bool {
+       if name == "" {
+               return false
+       }
+       c := name[0]
+       return '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '.' || c == '_' || c == '/' || c >= utf8.RuneSelf
+}
+
+func mkname(sym *types.Sym) ir.Node {
+       n := oldname(sym)
+       if n.Name() != nil && n.Name().PkgName != nil {
+               n.Name().PkgName.Used = true
+       }
+       return n
+}
+
+// parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
+// It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
+// go/build/read.go also processes these strings and contains similar logic.
+func parseGoEmbed(args string) ([]string, error) {
+       var list []string
+       for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
+               var path string
+       Switch:
+               switch args[0] {
+               default:
+                       i := len(args)
+                       for j, c := range args {
+                               if unicode.IsSpace(c) {
+                                       i = j
+                                       break
+                               }
+                       }
+                       path = args[:i]
+                       args = args[i:]
+
+               case '`':
+                       i := strings.Index(args[1:], "`")
+                       if i < 0 {
+                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+                       }
+                       path = args[1 : 1+i]
+                       args = args[1+i+1:]
+
+               case '"':
+                       i := 1
+                       for ; i < len(args); i++ {
+                               if args[i] == '\\' {
+                                       i++
+                                       continue
+                               }
+                               if args[i] == '"' {
+                                       q, err := strconv.Unquote(args[:i+1])
+                                       if err != nil {
+                                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
+                                       }
+                                       path = q
+                                       args = args[i+1:]
+                                       break Switch
+                               }
+                       }
+                       if i >= len(args) {
+                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+                       }
+               }
+
+               if args != "" {
+                       r, _ := utf8.DecodeRuneInString(args)
+                       if !unicode.IsSpace(r) {
+                               return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+                       }
+               }
+               list = append(list, path)
+       }
+       return list, nil
+}
+
+func fakeRecv() *ir.Field {
+       return ir.NewField(base.Pos, nil, nil, types.FakeRecvType())
+}
+
+func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
+       xtype := p.typeExpr(expr.Type)
+
+       fn := ir.NewFunc(p.pos(expr))
+       fn.SetIsHiddenClosure(ir.CurFunc != nil)
+
+       fn.Nname = ir.NewNameAt(p.pos(expr), ir.BlankNode.Sym()) // filled in by tcClosure
+       fn.Nname.Func = fn
+       fn.Nname.Ntype = xtype
+       fn.Nname.Defn = fn
+
+       clo := ir.NewClosureExpr(p.pos(expr), fn)
+       fn.OClosure = clo
+
+       p.funcBody(fn, expr.Body)
+
+       ir.FinishCaptureNames(base.Pos, ir.CurFunc, fn)
+
+       return clo
+}
+
+// A function named init is a special case.
+// It is called by the initialization before main is run.
+// To make it unique within a package and also uncallable,
+// the name, normally "pkg.init", is altered to "pkg.init.0".
+var renameinitgen int
+
+func renameinit() *types.Sym {
+       s := typecheck.LookupNum("init.", renameinitgen)
+       renameinitgen++
+       return s
+}
+
+// oldname returns the Node that declares symbol s in the current scope.
+// If no such Node currently exists, an ONONAME Node is returned instead.
+// Automatically creates a new closure variable if the referenced symbol was
+// declared in a different (containing) function.
+func oldname(s *types.Sym) ir.Node {
+       if s.Pkg != types.LocalPkg {
+               return ir.NewIdent(base.Pos, s)
+       }
+
+       n := ir.AsNode(s.Def)
+       if n == nil {
+               // Maybe a top-level declaration will come along later to
+               // define s. resolve will check s.Def again once all input
+               // source has been processed.
+               return ir.NewIdent(base.Pos, s)
+       }
+
+       if n, ok := n.(*ir.Name); ok {
+               // TODO(rsc): If there is an outer variable x and we
+               // are parsing x := 5 inside the closure, until we get to
+               // the := it looks like a reference to the outer x so we'll
+               // make x a closure variable unnecessarily.
+               return ir.CaptureName(base.Pos, ir.CurFunc, n)
+       }
+
+       return n
+}
+
+func varEmbed(makeXPos func(syntax.Pos) src.XPos, name *ir.Name, decl *syntax.VarDecl, pragma *pragmas, haveEmbed bool) {
+       if pragma.Embeds == nil {
+               return
+       }
+
+       pragmaEmbeds := pragma.Embeds
+       pragma.Embeds = nil
+       pos := makeXPos(pragmaEmbeds[0].Pos)
+
+       if !haveEmbed {
+               base.ErrorfAt(pos, "go:embed only allowed in Go files that import \"embed\"")
+               return
+       }
+       if len(decl.NameList) > 1 {
+               base.ErrorfAt(pos, "go:embed cannot apply to multiple vars")
+               return
+       }
+       if decl.Values != nil {
+               base.ErrorfAt(pos, "go:embed cannot apply to var with initializer")
+               return
+       }
+       if decl.Type == nil {
+               // Should not happen, since Values == nil now.
+               base.ErrorfAt(pos, "go:embed cannot apply to var without type")
+               return
+       }
+       if typecheck.DeclContext != ir.PEXTERN {
+               base.ErrorfAt(pos, "go:embed cannot apply to var inside func")
+               return
+       }
+
+       var embeds []ir.Embed
+       for _, e := range pragmaEmbeds {
+               embeds = append(embeds, ir.Embed{Pos: makeXPos(e.Pos), Patterns: e.Patterns})
+       }
+       typecheck.Target.Embeds = append(typecheck.Target.Embeds, name)
+       name.Embed = &embeds
+}

diff --git a/src/cmd/compile/internal/noder/posmap.go b/src/cmd/compile/internal/noder/posmap.go
new file mode 100644 (file)
index 0000000..a6d3e2d
--- /dev/null
+++ b/src/cmd/compile/internal/noder/posmap.go
@@ -0,0 +1,83 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package noder
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/syntax"
+       "cmd/internal/src"
+)
+
+// A posMap handles mapping from syntax.Pos to src.XPos.
+type posMap struct {
+       bases map[*syntax.PosBase]*src.PosBase
+       cache struct {
+               last *syntax.PosBase
+               base *src.PosBase
+       }
+}
+
+type poser interface{ Pos() syntax.Pos }
+type ender interface{ End() syntax.Pos }
+
+func (m *posMap) pos(p poser) src.XPos { return m.makeXPos(p.Pos()) }
+func (m *posMap) end(p ender) src.XPos { return m.makeXPos(p.End()) }
+
+func (m *posMap) makeXPos(pos syntax.Pos) src.XPos {
+       if !pos.IsKnown() {
+               // TODO(mdempsky): Investigate restoring base.Fatalf.
+               return src.NoXPos
+       }
+
+       posBase := m.makeSrcPosBase(pos.Base())
+       return base.Ctxt.PosTable.XPos(src.MakePos(posBase, pos.Line(), pos.Col()))
+}
+
+// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
+func (m *posMap) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
+       // fast path: most likely PosBase hasn't changed
+       if m.cache.last == b0 {
+               return m.cache.base
+       }
+
+       b1, ok := m.bases[b0]
+       if !ok {
+               fn := b0.Filename()
+               if b0.IsFileBase() {
+                       b1 = src.NewFileBase(fn, absFilename(fn))
+               } else {
+                       // line directive base
+                       p0 := b0.Pos()
+                       p0b := p0.Base()
+                       if p0b == b0 {
+                               panic("infinite recursion in makeSrcPosBase")
+                       }
+                       p1 := src.MakePos(m.makeSrcPosBase(p0b), p0.Line(), p0.Col())
+                       b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
+               }
+               if m.bases == nil {
+                       m.bases = make(map[*syntax.PosBase]*src.PosBase)
+               }
+               m.bases[b0] = b1
+       }
+
+       // update cache
+       m.cache.last = b0
+       m.cache.base = b1
+
+       return b1
+}
+
+func (m *posMap) join(other *posMap) {
+       if m.bases == nil {
+               m.bases = make(map[*syntax.PosBase]*src.PosBase)
+       }
+       for k, v := range other.bases {
+               if m.bases[k] != nil {
+                       base.Fatalf("duplicate posmap bases")
+               }
+               m.bases[k] = v
+       }
+}

diff --git a/src/cmd/compile/internal/objw/objw.go b/src/cmd/compile/internal/objw/objw.go
new file mode 100644 (file)
index 0000000..dfbcf51
--- /dev/null
+++ b/src/cmd/compile/internal/objw/objw.go
@@ -0,0 +1,72 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objw
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/bitvec"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+func Uint8(s *obj.LSym, off int, v uint8) int {
+       return UintN(s, off, uint64(v), 1)
+}
+
+func Uint16(s *obj.LSym, off int, v uint16) int {
+       return UintN(s, off, uint64(v), 2)
+}
+
+func Uint32(s *obj.LSym, off int, v uint32) int {
+       return UintN(s, off, uint64(v), 4)
+}
+
+func Uintptr(s *obj.LSym, off int, v uint64) int {
+       return UintN(s, off, v, types.PtrSize)
+}
+
+func UintN(s *obj.LSym, off int, v uint64, wid int) int {
+       if off&(wid-1) != 0 {
+               base.Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
+       }
+       s.WriteInt(base.Ctxt, int64(off), wid, int64(v))
+       return off + wid
+}
+
+func SymPtr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
+       off = int(types.Rnd(int64(off), int64(types.PtrSize)))
+       s.WriteAddr(base.Ctxt, int64(off), types.PtrSize, x, int64(xoff))
+       off += types.PtrSize
+       return off
+}
+
+func SymPtrOff(s *obj.LSym, off int, x *obj.LSym) int {
+       s.WriteOff(base.Ctxt, int64(off), x, 0)
+       off += 4
+       return off
+}
+
+func SymPtrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
+       s.WriteWeakOff(base.Ctxt, int64(off), x, 0)
+       off += 4
+       return off
+}
+
+func Global(s *obj.LSym, width int32, flags int16) {
+       if flags&obj.LOCAL != 0 {
+               s.Set(obj.AttrLocal, true)
+               flags &^= obj.LOCAL
+       }
+       base.Ctxt.Globl(s, int64(width), int(flags))
+}
+
+func BitVec(s *obj.LSym, off int, bv bitvec.BitVec) int {
+       // Runtime reads the bitmaps as byte arrays. Oblige.
+       for j := 0; int32(j) < bv.N; j += 8 {
+               word := bv.B[j/32]
+               off = Uint8(s, off, uint8(word>>(uint(j)%32)))
+       }
+       return off
+}

diff --git a/src/cmd/compile/internal/objw/prog.go b/src/cmd/compile/internal/objw/prog.go
new file mode 100644 (file)
index 0000000..b5ac4dd
--- /dev/null
+++ b/src/cmd/compile/internal/objw/prog.go
@@ -0,0 +1,226 @@
+// Derived from Inferno utils/6c/txt.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/txt.c
+//
+//     Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//     Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//     Portions Copyright © 1997-1999 Vita Nuova Limited
+//     Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//     Portions Copyright © 2004,2006 Bruce Ellis
+//     Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//     Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//     Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// 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 objw
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839
+
+// NewProgs returns a new Progs for fn.
+// worker indicates which of the backend workers will use the Progs.
+func NewProgs(fn *ir.Func, worker int) *Progs {
+       pp := new(Progs)
+       if base.Ctxt.CanReuseProgs() {
+               sz := len(sharedProgArray) / base.Flag.LowerC
+               pp.Cache = sharedProgArray[sz*worker : sz*(worker+1)]
+       }
+       pp.CurFunc = fn
+
+       // prime the pump
+       pp.Next = pp.NewProg()
+       pp.Clear(pp.Next)
+
+       pp.Pos = fn.Pos()
+       pp.SetText(fn)
+       // PCDATA tables implicitly start with index -1.
+       pp.PrevLive = LivenessIndex{-1, false}
+       pp.NextLive = pp.PrevLive
+       return pp
+}
+
+// Progs accumulates Progs for a function and converts them into machine code.
+type Progs struct {
+       Text       *obj.Prog  // ATEXT Prog for this function
+       Next       *obj.Prog  // next Prog
+       PC         int64      // virtual PC; count of Progs
+       Pos        src.XPos   // position to use for new Progs
+       CurFunc    *ir.Func   // fn these Progs are for
+       Cache      []obj.Prog // local progcache
+       CacheIndex int        // first free element of progcache
+
+       NextLive LivenessIndex // liveness index for the next Prog
+       PrevLive LivenessIndex // last emitted liveness index
+}
+
+// LivenessIndex stores the liveness map information for a Value.
+type LivenessIndex struct {
+       StackMapIndex int
+
+       // IsUnsafePoint indicates that this is an unsafe-point.
+       //
+       // Note that it's possible for a call Value to have a stack
+       // map while also being an unsafe-point. This means it cannot
+       // be preempted at this instruction, but that a preemption or
+       // stack growth may happen in the called function.
+       IsUnsafePoint bool
+}
+
+// StackMapDontCare indicates that the stack map index at a Value
+// doesn't matter.
+//
+// This is a sentinel value that should never be emitted to the PCDATA
+// stream. We use -1000 because that's obviously never a valid stack
+// index (but -1 is).
+const StackMapDontCare = -1000
+
+// LivenessDontCare indicates that the liveness information doesn't
+// matter. Currently it is used in deferreturn liveness when we don't
+// actually need it. It should never be emitted to the PCDATA stream.
+var LivenessDontCare = LivenessIndex{StackMapDontCare, true}
+
+func (idx LivenessIndex) StackMapValid() bool {
+       return idx.StackMapIndex != StackMapDontCare
+}
+
+func (pp *Progs) NewProg() *obj.Prog {
+       var p *obj.Prog
+       if pp.CacheIndex < len(pp.Cache) {
+               p = &pp.Cache[pp.CacheIndex]
+               pp.CacheIndex++
+       } else {
+               p = new(obj.Prog)
+       }
+       p.Ctxt = base.Ctxt
+       return p
+}
+
+// Flush converts from pp to machine code.
+func (pp *Progs) Flush() {
+       plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.CurFunc}
+       obj.Flushplist(base.Ctxt, plist, pp.NewProg, base.Ctxt.Pkgpath)
+}
+
+// Free clears pp and any associated resources.
+func (pp *Progs) Free() {
+       if base.Ctxt.CanReuseProgs() {
+               // Clear progs to enable GC and avoid abuse.
+               s := pp.Cache[:pp.CacheIndex]
+               for i := range s {
+                       s[i] = obj.Prog{}
+               }
+       }
+       // Clear pp to avoid abuse.
+       *pp = Progs{}
+}
+
+// Prog adds a Prog with instruction As to pp.
+func (pp *Progs) Prog(as obj.As) *obj.Prog {
+       if pp.NextLive.StackMapValid() && pp.NextLive.StackMapIndex != pp.PrevLive.StackMapIndex {
+               // Emit stack map index change.
+               idx := pp.NextLive.StackMapIndex
+               pp.PrevLive.StackMapIndex = idx
+               p := pp.Prog(obj.APCDATA)
+               p.From.SetConst(objabi.PCDATA_StackMapIndex)
+               p.To.SetConst(int64(idx))
+       }
+       if pp.NextLive.IsUnsafePoint != pp.PrevLive.IsUnsafePoint {
+               // Emit unsafe-point marker.
+               pp.PrevLive.IsUnsafePoint = pp.NextLive.IsUnsafePoint
+               p := pp.Prog(obj.APCDATA)
+               p.From.SetConst(objabi.PCDATA_UnsafePoint)
+               if pp.NextLive.IsUnsafePoint {
+                       p.To.SetConst(objabi.PCDATA_UnsafePointUnsafe)
+               } else {
+                       p.To.SetConst(objabi.PCDATA_UnsafePointSafe)
+               }
+       }
+
+       p := pp.Next
+       pp.Next = pp.NewProg()
+       pp.Clear(pp.Next)
+       p.Link = pp.Next
+
+       if !pp.Pos.IsKnown() && base.Flag.K != 0 {
+               base.Warn("prog: unknown position (line 0)")
+       }
+
+       p.As = as
+       p.Pos = pp.Pos
+       if pp.Pos.IsStmt() == src.PosIsStmt {
+               // Clear IsStmt for later Progs at this pos provided that as can be marked as a stmt
+               if LosesStmtMark(as) {
+                       return p
+               }
+               pp.Pos = pp.Pos.WithNotStmt()
+       }
+       return p
+}
+
+func (pp *Progs) Clear(p *obj.Prog) {
+       obj.Nopout(p)
+       p.As = obj.AEND
+       p.Pc = pp.PC
+       pp.PC++
+}
+
+func (pp *Progs) Append(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16, foffset int64, ttype obj.AddrType, treg int16, toffset int64) *obj.Prog {
+       q := pp.NewProg()
+       pp.Clear(q)
+       q.As = as
+       q.Pos = p.Pos
+       q.From.Type = ftype
+       q.From.Reg = freg
+       q.From.Offset = foffset
+       q.To.Type = ttype
+       q.To.Reg = treg
+       q.To.Offset = toffset
+       q.Link = p.Link
+       p.Link = q
+       return q
+}
+
+func (pp *Progs) SetText(fn *ir.Func) {
+       if pp.Text != nil {
+               base.Fatalf("Progs.SetText called twice")
+       }
+       ptxt := pp.Prog(obj.ATEXT)
+       pp.Text = ptxt
+
+       fn.LSym.Func().Text = ptxt
+       ptxt.From.Type = obj.TYPE_MEM
+       ptxt.From.Name = obj.NAME_EXTERN
+       ptxt.From.Sym = fn.LSym
+}
+
+// LosesStmtMark reports whether a prog with op as loses its statement mark on the way to DWARF.
+// The attributes from some opcodes are lost in translation.
+// TODO: this is an artifact of how funcpctab combines information for instructions at a single PC.
+// Should try to fix it there.
+func LosesStmtMark(as obj.As) bool {
+       // is_stmt does not work for these; it DOES for ANOP even though that generates no code.
+       return as == obj.APCDATA || as == obj.AFUNCDATA
+}

diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
new file mode 100644 (file)
index 0000000..7cad262
--- /dev/null
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -0,0 +1,109 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkginit
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/deadcode"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+// Task makes and returns an initialization record for the package.
+// See runtime/proc.go:initTask for its layout.
+// The 3 tasks for initialization are:
+//   1) Initialize all of the packages the current package depends on.
+//   2) Initialize all the variables that have initializers.
+//   3) Run any init functions.
+func Task() *ir.Name {
+       nf := initOrder(typecheck.Target.Decls)
+
+       var deps []*obj.LSym // initTask records for packages the current package depends on
+       var fns []*obj.LSym  // functions to call for package initialization
+
+       // Find imported packages with init tasks.
+       for _, pkg := range typecheck.Target.Imports {
+               n := typecheck.Resolve(ir.NewIdent(base.Pos, pkg.Lookup(".inittask")))
+               if n.Op() == ir.ONONAME {
+                       continue
+               }
+               if n.Op() != ir.ONAME || n.(*ir.Name).Class != ir.PEXTERN {
+                       base.Fatalf("bad inittask: %v", n)
+               }
+               deps = append(deps, n.(*ir.Name).Linksym())
+       }
+
+       // Make a function that contains all the initialization statements.
+       if len(nf) > 0 {
+               base.Pos = nf[0].Pos() // prolog/epilog gets line number of first init stmt
+               initializers := typecheck.Lookup("init")
+               fn := typecheck.DeclFunc(initializers, ir.NewFuncType(base.Pos, nil, nil, nil))
+               for _, dcl := range typecheck.InitTodoFunc.Dcl {
+                       dcl.Curfn = fn
+               }
+               fn.Dcl = append(fn.Dcl, typecheck.InitTodoFunc.Dcl...)
+               typecheck.InitTodoFunc.Dcl = nil
+
+               fn.Body = nf
+               typecheck.FinishFuncBody()
+
+               typecheck.Func(fn)
+               ir.CurFunc = fn
+               typecheck.Stmts(nf)
+               ir.CurFunc = nil
+               typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+               fns = append(fns, fn.Linksym())
+       }
+       if typecheck.InitTodoFunc.Dcl != nil {
+               // We only generate temps using InitTodoFunc if there
+               // are package-scope initialization statements, so
+               // something's weird if we get here.
+               base.Fatalf("InitTodoFunc still has declarations")
+       }
+       typecheck.InitTodoFunc = nil
+
+       // Record user init functions.
+       for _, fn := range typecheck.Target.Inits {
+               // Must happen after initOrder; see #43444.
+               deadcode.Func(fn)
+
+               // Skip init functions with empty bodies.
+               if len(fn.Body) == 1 {
+                       if stmt := fn.Body[0]; stmt.Op() == ir.OBLOCK && len(stmt.(*ir.BlockStmt).List) == 0 {
+                               continue
+                       }
+               }
+               fns = append(fns, fn.Nname.Linksym())
+       }
+
+       if len(deps) == 0 && len(fns) == 0 && types.LocalPkg.Name != "main" && types.LocalPkg.Name != "runtime" {
+               return nil // nothing to initialize
+       }
+
+       // Make an .inittask structure.
+       sym := typecheck.Lookup(".inittask")
+       task := typecheck.NewName(sym)
+       task.SetType(types.Types[types.TUINT8]) // fake type
+       task.Class = ir.PEXTERN
+       sym.Def = task
+       lsym := task.Linksym()
+       ot := 0
+       ot = objw.Uintptr(lsym, ot, 0) // state: not initialized yet
+       ot = objw.Uintptr(lsym, ot, uint64(len(deps)))
+       ot = objw.Uintptr(lsym, ot, uint64(len(fns)))
+       for _, d := range deps {
+               ot = objw.SymPtr(lsym, ot, d, 0)
+       }
+       for _, f := range fns {
+               ot = objw.SymPtr(lsym, ot, f, 0)
+       }
+       // An initTask has pointers, but none into the Go heap.
+       // It's not quite read only, the state field must be modifiable.
+       objw.Global(lsym, int32(ot), obj.NOPTR)
+       return task
+}

diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/pkginit/initorder.go
similarity index 61%
rename from src/cmd/compile/internal/gc/initorder.go
rename to src/cmd/compile/internal/pkginit/initorder.go
index 41f1349bbe64ff2ad8e5b13c033e9a390b7835f8..97d69629fbae9e5167ec68abe39c9264a8c979cc 100644 (file)
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/pkginit/initorder.go
@@ -2,12 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package pkginit
 
 import (
        "bytes"
        "container/heap"
        "fmt"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/staticinit"
 )
 
 // Package initialization
@@ -60,56 +64,57 @@ const (
 type InitOrder struct {
        // blocking maps initialization assignments to the assignments
        // that depend on it.
-       blocking map[*Node][]*Node
+       blocking map[ir.Node][]ir.Node
 
        // ready is the queue of Pending initialization assignments
        // that are ready for initialization.
        ready declOrder
+
+       order map[ir.Node]int
 }
 
 // initOrder computes initialization order for a list l of
 // package-level declarations (in declaration order) and outputs the
 // corresponding list of statements to include in the init() function
 // body.
-func initOrder(l []*Node) []*Node {
-       s := InitSchedule{
-               initplans: make(map[*Node]*InitPlan),
-               inittemps: make(map[*Node]*Node),
+func initOrder(l []ir.Node) []ir.Node {
+       s := staticinit.Schedule{
+               Plans: make(map[ir.Node]*staticinit.Plan),
+               Temps: make(map[ir.Node]*ir.Name),
        }
        o := InitOrder{
-               blocking: make(map[*Node][]*Node),
+               blocking: make(map[ir.Node][]ir.Node),
+               order:    make(map[ir.Node]int),
        }
 
        // Process all package-level assignment in declaration order.
        for _, n := range l {
-               switch n.Op {
-               case OAS, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+               switch n.Op() {
+               case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
                        o.processAssign(n)
-                       o.flushReady(s.staticInit)
-               case ODCLCONST, ODCLFUNC, ODCLTYPE:
+                       o.flushReady(s.StaticInit)
+               case ir.ODCLCONST, ir.ODCLFUNC, ir.ODCLTYPE:
                        // nop
                default:
-                       Fatalf("unexpected package-level statement: %v", n)
+                       base.Fatalf("unexpected package-level statement: %v", n)
                }
        }
 
        // Check that all assignments are now Done; if not, there must
        // have been a dependency cycle.
        for _, n := range l {
-               switch n.Op {
-               case OAS, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-                       if n.Initorder() != InitDone {
+               switch n.Op() {
+               case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+                       if o.order[n] != orderDone {
                                // If there have already been errors
                                // printed, those errors may have
                                // confused us and there might not be
                                // a loop. Let the user fix those
                                // first.
-                               if nerrors > 0 {
-                                       errorexit()
-                               }
+                               base.ExitIfErrors()
 
-                               findInitLoopAndExit(firstLHS(n), new([]*Node))
-                               Fatalf("initialization unfinished, but failed to identify loop")
+                               o.findInitLoopAndExit(firstLHS(n), new([]*ir.Name), new(ir.NameSet))
+                               base.Fatalf("initialization unfinished, but failed to identify loop")
                        }
                }
        }
@@ -117,58 +122,56 @@ func initOrder(l []*Node) []*Node {
        // Invariant consistency check. If this is non-zero, then we
        // should have found a cycle above.
        if len(o.blocking) != 0 {
-               Fatalf("expected empty map: %v", o.blocking)
+               base.Fatalf("expected empty map: %v", o.blocking)
        }
 
-       return s.out
+       return s.Out
 }
 
-func (o *InitOrder) processAssign(n *Node) {
-       if n.Initorder() != InitNotStarted || n.Xoffset != BADWIDTH {
-               Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+func (o *InitOrder) processAssign(n ir.Node) {
+       if _, ok := o.order[n]; ok {
+               base.Fatalf("unexpected state: %v, %v", n, o.order[n])
        }
-
-       n.SetInitorder(InitPending)
-       n.Xoffset = 0
+       o.order[n] = 0
 
        // Compute number of variable dependencies and build the
        // inverse dependency ("blocking") graph.
        for dep := range collectDeps(n, true) {
-               defn := dep.Name.Defn
+               defn := dep.Defn
                // Skip dependencies on functions (PFUNC) and
                // variables already initialized (InitDone).
-               if dep.Class() != PEXTERN || defn.Initorder() == InitDone {
+               if dep.Class != ir.PEXTERN || o.order[defn] == orderDone {
                        continue
                }
-               n.Xoffset++
+               o.order[n]++
                o.blocking[defn] = append(o.blocking[defn], n)
        }
 
-       if n.Xoffset == 0 {
+       if o.order[n] == 0 {
                heap.Push(&o.ready, n)
        }
 }
 
+const orderDone = -1000
+
 // flushReady repeatedly applies initialize to the earliest (in
 // declaration order) assignment ready for initialization and updates
 // the inverse dependency ("blocking") graph.
-func (o *InitOrder) flushReady(initialize func(*Node)) {
+func (o *InitOrder) flushReady(initialize func(ir.Node)) {
        for o.ready.Len() != 0 {
-               n := heap.Pop(&o.ready).(*Node)
-               if n.Initorder() != InitPending || n.Xoffset != 0 {
-                       Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+               n := heap.Pop(&o.ready).(ir.Node)
+               if order, ok := o.order[n]; !ok || order != 0 {
+                       base.Fatalf("unexpected state: %v, %v, %v", n, ok, order)
                }
 
                initialize(n)
-               n.SetInitorder(InitDone)
-               n.Xoffset = BADWIDTH
+               o.order[n] = orderDone
 
                blocked := o.blocking[n]
                delete(o.blocking, n)
 
                for _, m := range blocked {
-                       m.Xoffset--
-                       if m.Xoffset == 0 {
+                       if o.order[m]--; o.order[m] == 0 {
                                heap.Push(&o.ready, m)
                        }
                }
@@ -181,10 +184,7 @@ func (o *InitOrder) flushReady(initialize func(*Node)) {
 // path points to a slice used for tracking the sequence of
 // variables/functions visited. Using a pointer to a slice allows the
 // slice capacity to grow and limit reallocations.
-func findInitLoopAndExit(n *Node, path *[]*Node) {
-       // We implement a simple DFS loop-finding algorithm. This
-       // could be faster, but initialization cycles are rare.
-
+func (o *InitOrder) findInitLoopAndExit(n *ir.Name, path *[]*ir.Name, ok *ir.NameSet) {
        for i, x := range *path {
                if x == n {
                        reportInitLoopAndExit((*path)[i:])
@@ -194,31 +194,38 @@ func findInitLoopAndExit(n *Node, path *[]*Node) {
 
        // There might be multiple loops involving n; by sorting
        // references, we deterministically pick the one reported.
-       refers := collectDeps(n.Name.Defn, false).Sorted(func(ni, nj *Node) bool {
-               return ni.Pos.Before(nj.Pos)
+       refers := collectDeps(n.Defn, false).Sorted(func(ni, nj *ir.Name) bool {
+               return ni.Pos().Before(nj.Pos())
        })
 
        *path = append(*path, n)
        for _, ref := range refers {
                // Short-circuit variables that were initialized.
-               if ref.Class() == PEXTERN && ref.Name.Defn.Initorder() == InitDone {
+               if ref.Class == ir.PEXTERN && o.order[ref.Defn] == orderDone || ok.Has(ref) {
                        continue
                }
 
-               findInitLoopAndExit(ref, path)
+               o.findInitLoopAndExit(ref, path, ok)
        }
+
+       // n is not involved in a cycle.
+       // Record that fact to avoid checking it again when reached another way,
+       // or else this traversal will take exponential time traversing all paths
+       // through the part of the package's call graph implicated in the cycle.
+       ok.Add(n)
+
        *path = (*path)[:len(*path)-1]
 }
 
 // reportInitLoopAndExit reports and initialization loop as an error
 // and exits. However, if l is not actually an initialization loop, it
 // simply returns instead.
-func reportInitLoopAndExit(l []*Node) {
+func reportInitLoopAndExit(l []*ir.Name) {
        // Rotate loop so that the earliest variable declaration is at
        // the start.
        i := -1
        for j, n := range l {
-               if n.Class() == PEXTERN && (i == -1 || n.Pos.Before(l[i].Pos)) {
+               if n.Class == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
                        i = j
                }
        }
@@ -236,69 +243,75 @@ func reportInitLoopAndExit(l []*Node) {
        var msg bytes.Buffer
        fmt.Fprintf(&msg, "initialization loop:\n")
        for _, n := range l {
-               fmt.Fprintf(&msg, "\t%v: %v refers to\n", n.Line(), n)
+               fmt.Fprintf(&msg, "\t%v: %v refers to\n", ir.Line(n), n)
        }
-       fmt.Fprintf(&msg, "\t%v: %v", l[0].Line(), l[0])
+       fmt.Fprintf(&msg, "\t%v: %v", ir.Line(l[0]), l[0])
 
-       yyerrorl(l[0].Pos, msg.String())
-       errorexit()
+       base.ErrorfAt(l[0].Pos(), msg.String())
+       base.ErrorExit()
 }
 
 // collectDeps returns all of the package-level functions and
 // variables that declaration n depends on. If transitive is true,
 // then it also includes the transitive dependencies of any depended
 // upon functions (but not variables).
-func collectDeps(n *Node, transitive bool) NodeSet {
+func collectDeps(n ir.Node, transitive bool) ir.NameSet {
        d := initDeps{transitive: transitive}
-       switch n.Op {
-       case OAS:
-               d.inspect(n.Right)
-       case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-               d.inspect(n.Right)
-       case ODCLFUNC:
-               d.inspectList(n.Nbody)
+       switch n.Op() {
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               d.inspect(n.Y)
+       case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+               n := n.(*ir.AssignListStmt)
+               d.inspect(n.Rhs[0])
+       case ir.ODCLFUNC:
+               n := n.(*ir.Func)
+               d.inspectList(n.Body)
        default:
-               Fatalf("unexpected Op: %v", n.Op)
+               base.Fatalf("unexpected Op: %v", n.Op())
        }
        return d.seen
 }
 
 type initDeps struct {
        transitive bool
-       seen       NodeSet
+       seen       ir.NameSet
+       cvisit     func(ir.Node)
 }
 
-func (d *initDeps) inspect(n *Node)     { inspect(n, d.visit) }
-func (d *initDeps) inspectList(l Nodes) { inspectList(l, d.visit) }
+func (d *initDeps) cachedVisit() func(ir.Node) {
+       if d.cvisit == nil {
+               d.cvisit = d.visit // cache closure
+       }
+       return d.cvisit
+}
+
+func (d *initDeps) inspect(n ir.Node)      { ir.Visit(n, d.cachedVisit()) }
+func (d *initDeps) inspectList(l ir.Nodes) { ir.VisitList(l, d.cachedVisit()) }
 
 // visit calls foundDep on any package-level functions or variables
 // referenced by n, if any.
-func (d *initDeps) visit(n *Node) bool {
-       switch n.Op {
-       case ONAME:
-               if n.isMethodExpression() {
-                       d.foundDep(asNode(n.Type.FuncType().Nname))
-                       return false
-               }
-
-               switch n.Class() {
-               case PEXTERN, PFUNC:
+func (d *initDeps) visit(n ir.Node) {
+       switch n.Op() {
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               switch n.Class {
+               case ir.PEXTERN, ir.PFUNC:
                        d.foundDep(n)
                }
 
-       case OCLOSURE:
-               d.inspectList(n.Func.Closure.Nbody)
+       case ir.OCLOSURE:
+               n := n.(*ir.ClosureExpr)
+               d.inspectList(n.Func.Body)
 
-       case ODOTMETH, OCALLPART:
-               d.foundDep(asNode(n.Type.FuncType().Nname))
+       case ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
+               d.foundDep(ir.MethodExprName(n))
        }
-
-       return true
 }
 
 // foundDep records that we've found a dependency on n by adding it to
 // seen.
-func (d *initDeps) foundDep(n *Node) {
+func (d *initDeps) foundDep(n *ir.Name) {
        // Can happen with method expressions involving interface
        // types; e.g., fixedbugs/issue4495.go.
        if n == nil {
@@ -307,7 +320,7 @@ func (d *initDeps) foundDep(n *Node) {
 
        // Names without definitions aren't interesting as far as
        // initialization ordering goes.
-       if n.Name.Defn == nil {
+       if n.Defn == nil {
                return
        }
 
@@ -315,8 +328,8 @@ func (d *initDeps) foundDep(n *Node) {
                return
        }
        d.seen.Add(n)
-       if d.transitive && n.Class() == PFUNC {
-               d.inspectList(n.Name.Defn.Nbody)
+       if d.transitive && n.Class == ir.PFUNC {
+               d.inspectList(n.Defn.(*ir.Func).Body)
        }
 }
 
@@ -327,13 +340,15 @@ func (d *initDeps) foundDep(n *Node) {
 // an OAS node's Pos may not be unique. For example, given the
 // declaration "var a, b = f(), g()", "a" must be ordered before "b",
 // but both OAS nodes use the "=" token's position as their Pos.
-type declOrder []*Node
+type declOrder []ir.Node
 
-func (s declOrder) Len() int           { return len(s) }
-func (s declOrder) Less(i, j int) bool { return firstLHS(s[i]).Pos.Before(firstLHS(s[j]).Pos) }
-func (s declOrder) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s declOrder) Len() int { return len(s) }
+func (s declOrder) Less(i, j int) bool {
+       return firstLHS(s[i]).Pos().Before(firstLHS(s[j]).Pos())
+}
+func (s declOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 
-func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(*Node)) }
+func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(ir.Node)) }
 func (s *declOrder) Pop() interface{} {
        n := (*s)[len(*s)-1]
        *s = (*s)[:len(*s)-1]
@@ -342,14 +357,16 @@ func (s *declOrder) Pop() interface{} {
 
 // firstLHS returns the first expression on the left-hand side of
 // assignment n.
-func firstLHS(n *Node) *Node {
-       switch n.Op {
-       case OAS:
-               return n.Left
-       case OAS2DOTTYPE, OAS2FUNC, OAS2RECV, OAS2MAPR:
-               return n.List.First()
+func firstLHS(n ir.Node) *ir.Name {
+       switch n.Op() {
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               return n.X.Name()
+       case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
+               n := n.(*ir.AssignListStmt)
+               return n.Lhs[0].Name()
        }
 
-       Fatalf("unexpected Op: %v", n.Op)
+       base.Fatalf("unexpected Op: %v", n.Op())
        return nil
 }

diff --git a/src/cmd/compile/internal/ppc64/galign.go b/src/cmd/compile/internal/ppc64/galign.go
index c8ef567dc3fd0ca94e8c70442913273fba34b2ac..c72d1aa8348c40f27df9e45fa0b0b6fa0a55b133 100644 (file)
--- a/src/cmd/compile/internal/ppc64/galign.go
+++ b/src/cmd/compile/internal/ppc64/galign.go
@@ -5,12 +5,12 @@
 package ppc64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/ppc64"
        "cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &ppc64.Linkppc64
        if objabi.GOARCH == "ppc64le" {
                arch.LinkArch = &ppc64.Linkppc64le

diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index a5a772b49179e4b5b934a4842cb88d2d1243af6e..c76962cfb811334d577ffc49b427533f0a8517b8 100644 (file)
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -5,44 +5,47 @@
 package ppc64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/ppc64"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, gc.Ctxt.FixedFrameSize()+off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, base.Ctxt.FixedFrameSize()+off+i)
                }
-       } else if cnt <= int64(128*gc.Widthptr) {
-               p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
+       } else if cnt <= int64(128*types.PtrSize) {
+               p = pp.Append(p, ppc64.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
                p.Reg = ppc64.REGSP
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
-               p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+               p.To.Sym = ir.Syms.Duffzero
+               p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
        } else {
-               p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
-               p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
+               p = pp.Append(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
+               p = pp.Append(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
                p.Reg = ppc64.REGSP
-               p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
-               p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+               p = pp.Append(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
+               p = pp.Append(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
                p.Reg = ppc64.REGRT1
-               p = pp.Appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(gc.Widthptr))
+               p = pp.Append(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(types.PtrSize))
                p1 := p
-               p = pp.Appendpp(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
-               p = pp.Appendpp(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-               gc.Patch(p, p1)
+               p = pp.Append(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+               p = pp.Append(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+               p.To.SetTarget(p1)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        p := pp.Prog(ppc64.AOR)
        p.From.Type = obj.TYPE_REG
        p.From.Reg = ppc64.REG_R0
@@ -51,7 +54,7 @@ func ginsnop(pp *gc.Progs) *obj.Prog {
        return p
 }
 
-func ginsnopdefer(pp *gc.Progs) *obj.Prog {
+func ginsnopdefer(pp *objw.Progs) *obj.Prog {
        // On PPC64 two nops are required in the defer case.
        //
        // (see gc/cgen.go, gc/plive.go -- copy of comment below)
@@ -66,7 +69,7 @@ func ginsnopdefer(pp *gc.Progs) *obj.Prog {
        // on ppc64 in both shared and non-shared modes.
 
        ginsnop(pp)
-       if gc.Ctxt.Flag_shared {
+       if base.Ctxt.Flag_shared {
                p := pp.Prog(ppc64.AMOVD)
                p.From.Type = obj.TYPE_MEM
                p.From.Offset = 24

diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 3e20c44a4c72b61d9514ec4b977c43d7c6784544..c85e110ed35848e6d218330d708ed8a3dc431711 100644 (file)
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -5,9 +5,11 @@
 package ppc64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/ppc64"
@@ -17,7 +19,7 @@ import (
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
        //      flive := b.FlagsLiveAtEnd
        //      if b.Control != nil && b.Control.Type.IsFlags() {
        //              flive = true
@@ -99,7 +101,7 @@ func storeByType(t *types.Type) obj.As {
        panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpCopy:
                t := v.Type
@@ -208,7 +210,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // BNE retry
                p3 := s.Prog(ppc64.ABNE)
                p3.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
        case ssa.OpPPC64LoweredAtomicAdd32,
                ssa.OpPPC64LoweredAtomicAdd64:
@@ -252,7 +254,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // BNE retry
                p4 := s.Prog(ppc64.ABNE)
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p)
+               p4.To.SetTarget(p)
 
                // Ensure a 32 bit result
                if v.Op == ssa.OpPPC64LoweredAtomicAdd32 {
@@ -298,7 +300,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // BNE retry
                p2 := s.Prog(ppc64.ABNE)
                p2.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p2, p)
+               p2.To.SetTarget(p)
                // ISYNC
                pisync := s.Prog(ppc64.AISYNC)
                pisync.To.Type = obj.TYPE_NONE
@@ -346,7 +348,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // ISYNC
                pisync := s.Prog(ppc64.AISYNC)
                pisync.To.Type = obj.TYPE_NONE
-               gc.Patch(p2, pisync)
+               p2.To.SetTarget(pisync)
 
        case ssa.OpPPC64LoweredAtomicStore8,
                ssa.OpPPC64LoweredAtomicStore32,
@@ -437,7 +439,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // BNE retry
                p4 := s.Prog(ppc64.ABNE)
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p)
+               p4.To.SetTarget(p)
                // LWSYNC - Assuming shared data not write-through-required nor
                // caching-inhibited. See Appendix B.2.1.1 in the ISA 2.07b.
                // If the operation is a CAS-Release, then synchronization is not necessary.
@@ -460,20 +462,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p7.From.Offset = 0
                p7.To.Type = obj.TYPE_REG
                p7.To.Reg = out
-               gc.Patch(p2, p7)
+               p2.To.SetTarget(p7)
                // done (label)
                p8 := s.Prog(obj.ANOP)
-               gc.Patch(p6, p8)
+               p6.To.SetTarget(p8)
 
        case ssa.OpPPC64LoweredGetClosurePtr:
                // Closure pointer is R11 (already)
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
 
        case ssa.OpPPC64LoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(ppc64.AMOVD)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -489,7 +491,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.OpLoadReg:
                loadOp := loadByType(v.Type)
                p := s.Prog(loadOp)
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
 
@@ -498,7 +500,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeOp)
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
 
        case ssa.OpPPC64DIVD:
                // For now,
@@ -537,10 +539,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Reg = r
                p.From.Type = obj.TYPE_REG
                p.From.Reg = r0
-               gc.Patch(pbahead, p)
+               pbahead.To.SetTarget(p)
 
                p = s.Prog(obj.ANOP)
-               gc.Patch(pbover, p)
+               pbover.To.SetTarget(p)
 
        case ssa.OpPPC64DIVW:
                // word-width version of above
@@ -572,10 +574,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Reg = r
                p.From.Type = obj.TYPE_REG
                p.From.Reg = r0
-               gc.Patch(pbahead, p)
+               pbahead.To.SetTarget(p)
 
                p = s.Prog(obj.ANOP)
-               gc.Patch(pbover, p)
+               pbover.To.SetTarget(p)
 
        case ssa.OpPPC64CLRLSLWI:
                r := v.Reg()
@@ -750,13 +752,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                                p.To.Reg = v.Reg()
                        }
 
-               case *obj.LSym, *gc.Node:
+               case *obj.LSym, ir.Node:
                        p := s.Prog(ppc64.AMOVD)
                        p.From.Type = obj.TYPE_ADDR
                        p.From.Reg = v.Args[0].Reg()
                        p.To.Type = obj.TYPE_REG
                        p.To.Reg = v.Reg()
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
 
                }
 
@@ -817,7 +819,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p := s.Prog(ppc64.AMOVD)
                        p.From.Type = obj.TYPE_ADDR
                        p.From.Reg = v.Args[0].Reg()
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                        p.To.Type = obj.TYPE_REG
                        p.To.Reg = v.Reg()
                        // Load go.string using 0 offset
@@ -835,7 +837,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
 
@@ -869,7 +871,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = ppc64.REGZERO
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
 
        case ssa.OpPPC64MOVDstore, ssa.OpPPC64MOVWstore, ssa.OpPPC64MOVHstore, ssa.OpPPC64MOVBstore, ssa.OpPPC64FMOVDstore, ssa.OpPPC64FMOVSstore:
                p := s.Prog(v.Op.Asm())
@@ -877,7 +879,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
 
        case ssa.OpPPC64MOVDstoreidx, ssa.OpPPC64MOVWstoreidx, ssa.OpPPC64MOVHstoreidx, ssa.OpPPC64MOVBstoreidx,
                ssa.OpPPC64FMOVDstoreidx, ssa.OpPPC64FMOVSstoreidx, ssa.OpPPC64MOVDBRstoreidx, ssa.OpPPC64MOVWBRstoreidx,
@@ -1026,7 +1028,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.From.Offset = ppc64.BO_BCTR
                        p.Reg = ppc64.REG_R0
                        p.To.Type = obj.TYPE_BRANCH
-                       gc.Patch(p, top)
+                       p.To.SetTarget(top)
                }
                // When ctr == 1 the loop was not generated but
                // there are at least 64 bytes to clear, so add
@@ -1226,7 +1228,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.From.Offset = ppc64.BO_BCTR
                        p.Reg = ppc64.REG_R0
                        p.To.Type = obj.TYPE_BRANCH
-                       gc.Patch(p, top)
+                       p.To.SetTarget(top)
                }
 
                // when ctr == 1 the loop was not generated but
@@ -1405,7 +1407,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.From.Offset = ppc64.BO_BCTR
                        p.Reg = ppc64.REG_R0
                        p.To.Type = obj.TYPE_BRANCH
-                       gc.Patch(p, top)
+                       p.To.SetTarget(top)
 
                        // srcReg and dstReg were incremented in the loop, so
                        // later instructions start with offset 0.
@@ -1652,7 +1654,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.From.Offset = ppc64.BO_BCTR
                        p.Reg = ppc64.REG_R0
                        p.To.Type = obj.TYPE_BRANCH
-                       gc.Patch(p, top)
+                       p.To.SetTarget(top)
 
                        // srcReg and dstReg were incremented in the loop, so
                        // later instructions start with offset 0.
@@ -1784,7 +1786,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // Insert a hint this is not a subroutine return.
                pp.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: 1})
 
-               if gc.Ctxt.Flag_shared {
+               if base.Ctxt.Flag_shared {
                        // When compiling Go into PIC, the function we just
                        // called via pointer might have been implemented in
                        // a separate module and so overwritten the TOC
@@ -1807,7 +1809,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(16) // space used in callee args area by assembly stubs
 
        case ssa.OpPPC64LoweredNilCheck:
@@ -1838,22 +1840,22 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
                        // NOP (so the BNE has somewhere to land)
                        nop := s.Prog(obj.ANOP)
-                       gc.Patch(p2, nop)
+                       p2.To.SetTarget(nop)
 
                } else {
                        // Issue a load which will fault if arg is nil.
                        p := s.Prog(ppc64.AMOVBZ)
                        p.From.Type = obj.TYPE_MEM
                        p.From.Reg = v.Args[0].Reg()
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                        p.To.Type = obj.TYPE_REG
                        p.To.Reg = ppc64.REGTMP
                }
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
 
        // These should be resolved by rules and not make it here.
@@ -1891,7 +1893,7 @@ var blockJump = [...]struct {
        ssa.BlockPPC64FGT: {ppc64.ABGT, ppc64.ABLE, false, false},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockDefer:
                // defer returns in R3:
@@ -1905,18 +1907,18 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 
                p = s.Prog(ppc64.ABNE)
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
 
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:

diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
new file mode 100644 (file)
index 0000000..fcd824f
--- /dev/null
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -0,0 +1,788 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reflectdata
+
+import (
+       "fmt"
+       "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+// isRegularMemory reports whether t can be compared/hashed as regular memory.
+func isRegularMemory(t *types.Type) bool {
+       a, _ := types.AlgType(t)
+       return a == types.AMEM
+}
+
+// eqCanPanic reports whether == on type t could panic (has an interface somewhere).
+// t must be comparable.
+func eqCanPanic(t *types.Type) bool {
+       switch t.Kind() {
+       default:
+               return false
+       case types.TINTER:
+               return true
+       case types.TARRAY:
+               return eqCanPanic(t.Elem())
+       case types.TSTRUCT:
+               for _, f := range t.FieldSlice() {
+                       if !f.Sym.IsBlank() && eqCanPanic(f.Type) {
+                               return true
+                       }
+               }
+               return false
+       }
+}
+
+// AlgType returns the fixed-width AMEMxx variants instead of the general
+// AMEM kind when possible.
+func AlgType(t *types.Type) types.AlgKind {
+       a, _ := types.AlgType(t)
+       if a == types.AMEM {
+               switch t.Width {
+               case 0:
+                       return types.AMEM0
+               case 1:
+                       return types.AMEM8
+               case 2:
+                       return types.AMEM16
+               case 4:
+                       return types.AMEM32
+               case 8:
+                       return types.AMEM64
+               case 16:
+                       return types.AMEM128
+               }
+       }
+
+       return a
+}
+
+// genhash returns a symbol which is the closure used to compute
+// the hash of a value of type t.
+// Note: the generated function must match runtime.typehash exactly.
+func genhash(t *types.Type) *obj.LSym {
+       switch AlgType(t) {
+       default:
+               // genhash is only called for types that have equality
+               base.Fatalf("genhash %v", t)
+       case types.AMEM0:
+               return sysClosure("memhash0")
+       case types.AMEM8:
+               return sysClosure("memhash8")
+       case types.AMEM16:
+               return sysClosure("memhash16")
+       case types.AMEM32:
+               return sysClosure("memhash32")
+       case types.AMEM64:
+               return sysClosure("memhash64")
+       case types.AMEM128:
+               return sysClosure("memhash128")
+       case types.ASTRING:
+               return sysClosure("strhash")
+       case types.AINTER:
+               return sysClosure("interhash")
+       case types.ANILINTER:
+               return sysClosure("nilinterhash")
+       case types.AFLOAT32:
+               return sysClosure("f32hash")
+       case types.AFLOAT64:
+               return sysClosure("f64hash")
+       case types.ACPLX64:
+               return sysClosure("c64hash")
+       case types.ACPLX128:
+               return sysClosure("c128hash")
+       case types.AMEM:
+               // For other sizes of plain memory, we build a closure
+               // that calls memhash_varlen. The size of the memory is
+               // encoded in the first slot of the closure.
+               closure := TypeLinksymLookup(fmt.Sprintf(".hashfunc%d", t.Width))
+               if len(closure.P) > 0 { // already generated
+                       return closure
+               }
+               if memhashvarlen == nil {
+                       memhashvarlen = typecheck.LookupRuntimeFunc("memhash_varlen")
+               }
+               ot := 0
+               ot = objw.SymPtr(closure, ot, memhashvarlen, 0)
+               ot = objw.Uintptr(closure, ot, uint64(t.Width)) // size encoded in closure
+               objw.Global(closure, int32(ot), obj.DUPOK|obj.RODATA)
+               return closure
+       case types.ASPECIAL:
+               break
+       }
+
+       closure := TypeLinksymPrefix(".hashfunc", t)
+       if len(closure.P) > 0 { // already generated
+               return closure
+       }
+
+       // Generate hash functions for subtypes.
+       // There are cases where we might not use these hashes,
+       // but in that case they will get dead-code eliminated.
+       // (And the closure generated by genhash will also get
+       // dead-code eliminated, as we call the subtype hashers
+       // directly.)
+       switch t.Kind() {
+       case types.TARRAY:
+               genhash(t.Elem())
+       case types.TSTRUCT:
+               for _, f := range t.FieldSlice() {
+                       genhash(f.Type)
+               }
+       }
+
+       sym := TypeSymPrefix(".hash", t)
+       if base.Flag.LowerR != 0 {
+               fmt.Printf("genhash %v %v %v\n", closure, sym, t)
+       }
+
+       base.Pos = base.AutogeneratedPos // less confusing than end of input
+       typecheck.DeclContext = ir.PEXTERN
+
+       // func sym(p *T, h uintptr) uintptr
+       args := []*ir.Field{
+               ir.NewField(base.Pos, typecheck.Lookup("p"), nil, types.NewPtr(t)),
+               ir.NewField(base.Pos, typecheck.Lookup("h"), nil, types.Types[types.TUINTPTR]),
+       }
+       results := []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR])}
+       tfn := ir.NewFuncType(base.Pos, nil, args, results)
+
+       fn := typecheck.DeclFunc(sym, tfn)
+       np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
+       nh := ir.AsNode(tfn.Type().Params().Field(1).Nname)
+
+       switch t.Kind() {
+       case types.TARRAY:
+               // An array of pure memory would be handled by the
+               // standard algorithm, so the element type must not be
+               // pure memory.
+               hashel := hashfor(t.Elem())
+
+               // for i := 0; i < nelem; i++
+               ni := typecheck.Temp(types.Types[types.TINT])
+               init := ir.NewAssignStmt(base.Pos, ni, ir.NewInt(0))
+               cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, ir.NewInt(t.NumElem()))
+               post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, ir.NewInt(1)))
+               loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
+               loop.PtrInit().Append(init)
+
+               // h = hashel(&p[i], h)
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+
+               nx := ir.NewIndexExpr(base.Pos, np, ni)
+               nx.SetBounded(true)
+               na := typecheck.NodAddr(nx)
+               call.Args.Append(na)
+               call.Args.Append(nh)
+               loop.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
+
+               fn.Body.Append(loop)
+
+       case types.TSTRUCT:
+               // Walk the struct using memhash for runs of AMEM
+               // and calling specific hash functions for the others.
+               for i, fields := 0, t.FieldSlice(); i < len(fields); {
+                       f := fields[i]
+
+                       // Skip blank fields.
+                       if f.Sym.IsBlank() {
+                               i++
+                               continue
+                       }
+
+                       // Hash non-memory fields with appropriate hash function.
+                       if !isRegularMemory(f.Type) {
+                               hashel := hashfor(f.Type)
+                               call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+                               nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+                               na := typecheck.NodAddr(nx)
+                               call.Args.Append(na)
+                               call.Args.Append(nh)
+                               fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
+                               i++
+                               continue
+                       }
+
+                       // Otherwise, hash a maximal length run of raw memory.
+                       size, next := memrun(t, i)
+
+                       // h = hashel(&p.first, size, h)
+                       hashel := hashmem(f.Type)
+                       call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+                       nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+                       na := typecheck.NodAddr(nx)
+                       call.Args.Append(na)
+                       call.Args.Append(nh)
+                       call.Args.Append(ir.NewInt(size))
+                       fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
+
+                       i = next
+               }
+       }
+
+       r := ir.NewReturnStmt(base.Pos, nil)
+       r.Results.Append(nh)
+       fn.Body.Append(r)
+
+       if base.Flag.LowerR != 0 {
+               ir.DumpList("genhash body", fn.Body)
+       }
+
+       typecheck.FinishFuncBody()
+
+       fn.SetDupok(true)
+       typecheck.Func(fn)
+
+       ir.CurFunc = fn
+       typecheck.Stmts(fn.Body)
+       ir.CurFunc = nil
+
+       if base.Debug.DclStack != 0 {
+               types.CheckDclstack()
+       }
+
+       fn.SetNilCheckDisabled(true)
+       typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+       // Build closure. It doesn't close over any variables, so
+       // it contains just the function pointer.
+       objw.SymPtr(closure, 0, fn.Linksym(), 0)
+       objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+
+       return closure
+}
+
+func hashfor(t *types.Type) ir.Node {
+       var sym *types.Sym
+
+       switch a, _ := types.AlgType(t); a {
+       case types.AMEM:
+               base.Fatalf("hashfor with AMEM type")
+       case types.AINTER:
+               sym = ir.Pkgs.Runtime.Lookup("interhash")
+       case types.ANILINTER:
+               sym = ir.Pkgs.Runtime.Lookup("nilinterhash")
+       case types.ASTRING:
+               sym = ir.Pkgs.Runtime.Lookup("strhash")
+       case types.AFLOAT32:
+               sym = ir.Pkgs.Runtime.Lookup("f32hash")
+       case types.AFLOAT64:
+               sym = ir.Pkgs.Runtime.Lookup("f64hash")
+       case types.ACPLX64:
+               sym = ir.Pkgs.Runtime.Lookup("c64hash")
+       case types.ACPLX128:
+               sym = ir.Pkgs.Runtime.Lookup("c128hash")
+       default:
+               // Note: the caller of hashfor ensured that this symbol
+               // exists and has a body by calling genhash for t.
+               sym = TypeSymPrefix(".hash", t)
+       }
+
+       n := typecheck.NewName(sym)
+       ir.MarkFunc(n)
+       n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+               types.NewField(base.Pos, nil, types.NewPtr(t)),
+               types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+       }, []*types.Field{
+               types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+       }))
+       return n
+}
+
+// sysClosure returns a closure which will call the
+// given runtime function (with no closed-over variables).
+func sysClosure(name string) *obj.LSym {
+       s := typecheck.LookupRuntimeVar(name + "·f")
+       if len(s.P) == 0 {
+               f := typecheck.LookupRuntimeFunc(name)
+               objw.SymPtr(s, 0, f, 0)
+               objw.Global(s, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+       }
+       return s
+}
+
+// geneq returns a symbol which is the closure used to compute
+// equality for two objects of type t.
+func geneq(t *types.Type) *obj.LSym {
+       switch AlgType(t) {
+       case types.ANOEQ:
+               // The runtime will panic if it tries to compare
+               // a type with a nil equality function.
+               return nil
+       case types.AMEM0:
+               return sysClosure("memequal0")
+       case types.AMEM8:
+               return sysClosure("memequal8")
+       case types.AMEM16:
+               return sysClosure("memequal16")
+       case types.AMEM32:
+               return sysClosure("memequal32")
+       case types.AMEM64:
+               return sysClosure("memequal64")
+       case types.AMEM128:
+               return sysClosure("memequal128")
+       case types.ASTRING:
+               return sysClosure("strequal")
+       case types.AINTER:
+               return sysClosure("interequal")
+       case types.ANILINTER:
+               return sysClosure("nilinterequal")
+       case types.AFLOAT32:
+               return sysClosure("f32equal")
+       case types.AFLOAT64:
+               return sysClosure("f64equal")
+       case types.ACPLX64:
+               return sysClosure("c64equal")
+       case types.ACPLX128:
+               return sysClosure("c128equal")
+       case types.AMEM:
+               // make equality closure. The size of the type
+               // is encoded in the closure.
+               closure := TypeLinksymLookup(fmt.Sprintf(".eqfunc%d", t.Width))
+               if len(closure.P) != 0 {
+                       return closure
+               }
+               if memequalvarlen == nil {
+                       memequalvarlen = typecheck.LookupRuntimeVar("memequal_varlen") // asm func
+               }
+               ot := 0
+               ot = objw.SymPtr(closure, ot, memequalvarlen, 0)
+               ot = objw.Uintptr(closure, ot, uint64(t.Width))
+               objw.Global(closure, int32(ot), obj.DUPOK|obj.RODATA)
+               return closure
+       case types.ASPECIAL:
+               break
+       }
+
+       closure := TypeLinksymPrefix(".eqfunc", t)
+       if len(closure.P) > 0 { // already generated
+               return closure
+       }
+       sym := TypeSymPrefix(".eq", t)
+       if base.Flag.LowerR != 0 {
+               fmt.Printf("geneq %v\n", t)
+       }
+
+       // Autogenerate code for equality of structs and arrays.
+
+       base.Pos = base.AutogeneratedPos // less confusing than end of input
+       typecheck.DeclContext = ir.PEXTERN
+
+       // func sym(p, q *T) bool
+       tfn := ir.NewFuncType(base.Pos, nil,
+               []*ir.Field{ir.NewField(base.Pos, typecheck.Lookup("p"), nil, types.NewPtr(t)), ir.NewField(base.Pos, typecheck.Lookup("q"), nil, types.NewPtr(t))},
+               []*ir.Field{ir.NewField(base.Pos, typecheck.Lookup("r"), nil, types.Types[types.TBOOL])})
+
+       fn := typecheck.DeclFunc(sym, tfn)
+       np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
+       nq := ir.AsNode(tfn.Type().Params().Field(1).Nname)
+       nr := ir.AsNode(tfn.Type().Results().Field(0).Nname)
+
+       // Label to jump to if an equality test fails.
+       neq := typecheck.AutoLabel(".neq")
+
+       // We reach here only for types that have equality but
+       // cannot be handled by the standard algorithms,
+       // so t must be either an array or a struct.
+       switch t.Kind() {
+       default:
+               base.Fatalf("geneq %v", t)
+
+       case types.TARRAY:
+               nelem := t.NumElem()
+
+               // checkAll generates code to check the equality of all array elements.
+               // If unroll is greater than nelem, checkAll generates:
+               //
+               // if eq(p[0], q[0]) && eq(p[1], q[1]) && ... {
+               // } else {
+               //   return
+               // }
+               //
+               // And so on.
+               //
+               // Otherwise it generates:
+               //
+               // for i := 0; i < nelem; i++ {
+               //   if eq(p[i], q[i]) {
+               //   } else {
+               //     goto neq
+               //   }
+               // }
+               //
+               // TODO(josharian): consider doing some loop unrolling
+               // for larger nelem as well, processing a few elements at a time in a loop.
+               checkAll := func(unroll int64, last bool, eq func(pi, qi ir.Node) ir.Node) {
+                       // checkIdx generates a node to check for equality at index i.
+                       checkIdx := func(i ir.Node) ir.Node {
+                               // pi := p[i]
+                               pi := ir.NewIndexExpr(base.Pos, np, i)
+                               pi.SetBounded(true)
+                               pi.SetType(t.Elem())
+                               // qi := q[i]
+                               qi := ir.NewIndexExpr(base.Pos, nq, i)
+                               qi.SetBounded(true)
+                               qi.SetType(t.Elem())
+                               return eq(pi, qi)
+                       }
+
+                       if nelem <= unroll {
+                               if last {
+                                       // Do last comparison in a different manner.
+                                       nelem--
+                               }
+                               // Generate a series of checks.
+                               for i := int64(0); i < nelem; i++ {
+                                       // if check {} else { goto neq }
+                                       nif := ir.NewIfStmt(base.Pos, checkIdx(ir.NewInt(i)), nil, nil)
+                                       nif.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+                                       fn.Body.Append(nif)
+                               }
+                               if last {
+                                       fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(ir.NewInt(nelem))))
+                               }
+                       } else {
+                               // Generate a for loop.
+                               // for i := 0; i < nelem; i++
+                               i := typecheck.Temp(types.Types[types.TINT])
+                               init := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
+                               cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(nelem))
+                               post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
+                               loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
+                               loop.PtrInit().Append(init)
+                               // if eq(pi, qi) {} else { goto neq }
+                               nif := ir.NewIfStmt(base.Pos, checkIdx(i), nil, nil)
+                               nif.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+                               loop.Body.Append(nif)
+                               fn.Body.Append(loop)
+                               if last {
+                                       fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(true)))
+                               }
+                       }
+               }
+
+               switch t.Elem().Kind() {
+               case types.TSTRING:
+                       // Do two loops. First, check that all the lengths match (cheap).
+                       // Second, check that all the contents match (expensive).
+                       // TODO: when the array size is small, unroll the length match checks.
+                       checkAll(3, false, func(pi, qi ir.Node) ir.Node {
+                               // Compare lengths.
+                               eqlen, _ := EqString(pi, qi)
+                               return eqlen
+                       })
+                       checkAll(1, true, func(pi, qi ir.Node) ir.Node {
+                               // Compare contents.
+                               _, eqmem := EqString(pi, qi)
+                               return eqmem
+                       })
+               case types.TFLOAT32, types.TFLOAT64:
+                       checkAll(2, true, func(pi, qi ir.Node) ir.Node {
+                               // p[i] == q[i]
+                               return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
+                       })
+               // TODO: pick apart structs, do them piecemeal too
+               default:
+                       checkAll(1, true, func(pi, qi ir.Node) ir.Node {
+                               // p[i] == q[i]
+                               return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
+                       })
+               }
+
+       case types.TSTRUCT:
+               // Build a list of conditions to satisfy.
+               // The conditions are a list-of-lists. Conditions are reorderable
+               // within each inner list. The outer lists must be evaluated in order.
+               var conds [][]ir.Node
+               conds = append(conds, []ir.Node{})
+               and := func(n ir.Node) {
+                       i := len(conds) - 1
+                       conds[i] = append(conds[i], n)
+               }
+
+               // Walk the struct using memequal for runs of AMEM
+               // and calling specific equality tests for the others.
+               for i, fields := 0, t.FieldSlice(); i < len(fields); {
+                       f := fields[i]
+
+                       // Skip blank-named fields.
+                       if f.Sym.IsBlank() {
+                               i++
+                               continue
+                       }
+
+                       // Compare non-memory fields with field equality.
+                       if !isRegularMemory(f.Type) {
+                               if eqCanPanic(f.Type) {
+                                       // Enforce ordering by starting a new set of reorderable conditions.
+                                       conds = append(conds, []ir.Node{})
+                               }
+                               p := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym)
+                               q := ir.NewSelectorExpr(base.Pos, ir.OXDOT, nq, f.Sym)
+                               switch {
+                               case f.Type.IsString():
+                                       eqlen, eqmem := EqString(p, q)
+                                       and(eqlen)
+                                       and(eqmem)
+                               default:
+                                       and(ir.NewBinaryExpr(base.Pos, ir.OEQ, p, q))
+                               }
+                               if eqCanPanic(f.Type) {
+                                       // Also enforce ordering after something that can panic.
+                                       conds = append(conds, []ir.Node{})
+                               }
+                               i++
+                               continue
+                       }
+
+                       // Find maximal length run of memory-only fields.
+                       size, next := memrun(t, i)
+
+                       // TODO(rsc): All the calls to newname are wrong for
+                       // cross-package unexported fields.
+                       if s := fields[i:next]; len(s) <= 2 {
+                               // Two or fewer fields: use plain field equality.
+                               for _, f := range s {
+                                       and(eqfield(np, nq, f.Sym))
+                               }
+                       } else {
+                               // More than two fields: use memequal.
+                               and(eqmem(np, nq, f.Sym, size))
+                       }
+                       i = next
+               }
+
+               // Sort conditions to put runtime calls last.
+               // Preserve the rest of the ordering.
+               var flatConds []ir.Node
+               for _, c := range conds {
+                       isCall := func(n ir.Node) bool {
+                               return n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC
+                       }
+                       sort.SliceStable(c, func(i, j int) bool {
+                               return !isCall(c[i]) && isCall(c[j])
+                       })
+                       flatConds = append(flatConds, c...)
+               }
+
+               if len(flatConds) == 0 {
+                       fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(true)))
+               } else {
+                       for _, c := range flatConds[:len(flatConds)-1] {
+                               // if cond {} else { goto neq }
+                               n := ir.NewIfStmt(base.Pos, c, nil, nil)
+                               n.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+                               fn.Body.Append(n)
+                       }
+                       fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, flatConds[len(flatConds)-1]))
+               }
+       }
+
+       // ret:
+       //   return
+       ret := typecheck.AutoLabel(".ret")
+       fn.Body.Append(ir.NewLabelStmt(base.Pos, ret))
+       fn.Body.Append(ir.NewReturnStmt(base.Pos, nil))
+
+       // neq:
+       //   r = false
+       //   return (or goto ret)
+       fn.Body.Append(ir.NewLabelStmt(base.Pos, neq))
+       fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(false)))
+       if eqCanPanic(t) || anyCall(fn) {
+               // Epilogue is large, so share it with the equal case.
+               fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
+       } else {
+               // Epilogue is small, so don't bother sharing.
+               fn.Body.Append(ir.NewReturnStmt(base.Pos, nil))
+       }
+       // TODO(khr): the epilogue size detection condition above isn't perfect.
+       // We should really do a generic CL that shares epilogues across
+       // the board. See #24936.
+
+       if base.Flag.LowerR != 0 {
+               ir.DumpList("geneq body", fn.Body)
+       }
+
+       typecheck.FinishFuncBody()
+
+       fn.SetDupok(true)
+       typecheck.Func(fn)
+
+       ir.CurFunc = fn
+       typecheck.Stmts(fn.Body)
+       ir.CurFunc = nil
+
+       if base.Debug.DclStack != 0 {
+               types.CheckDclstack()
+       }
+
+       // Disable checknils while compiling this code.
+       // We are comparing a struct or an array,
+       // neither of which can be nil, and our comparisons
+       // are shallow.
+       fn.SetNilCheckDisabled(true)
+       typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+       // Generate a closure which points at the function we just generated.
+       objw.SymPtr(closure, 0, fn.Linksym(), 0)
+       objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+       return closure
+}
+
+func anyCall(fn *ir.Func) bool {
+       return ir.Any(fn, func(n ir.Node) bool {
+               // TODO(rsc): No methods?
+               op := n.Op()
+               return op == ir.OCALL || op == ir.OCALLFUNC
+       })
+}
+
+// eqfield returns the node
+//     p.field == q.field
+func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
+       nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)
+       ny := ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)
+       ne := ir.NewBinaryExpr(base.Pos, ir.OEQ, nx, ny)
+       return ne
+}
+
+// EqString returns the nodes
+//   len(s) == len(t)
+// and
+//   memequal(s.ptr, t.ptr, len(s))
+// which can be used to construct string equality comparison.
+// eqlen must be evaluated before eqmem, and shortcircuiting is required.
+func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
+       s = typecheck.Conv(s, types.Types[types.TSTRING])
+       t = typecheck.Conv(t, types.Types[types.TSTRING])
+       sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+       tptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, t)
+       slen := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, s), types.Types[types.TUINTPTR])
+       tlen := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, t), types.Types[types.TUINTPTR])
+
+       fn := typecheck.LookupRuntime("memequal")
+       fn = typecheck.SubstArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
+       typecheck.Call(call)
+
+       cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
+       cmp = typecheck.Expr(cmp).(*ir.BinaryExpr)
+       cmp.SetType(types.Types[types.TBOOL])
+       return cmp, call
+}
+
+// EqInterface returns the nodes
+//   s.tab == t.tab (or s.typ == t.typ, as appropriate)
+// and
+//   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
+// which can be used to construct interface equality comparison.
+// eqtab must be evaluated before eqdata, and shortcircuiting is required.
+func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
+       if !types.Identical(s.Type(), t.Type()) {
+               base.Fatalf("EqInterface %v %v", s.Type(), t.Type())
+       }
+       // func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
+       // func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
+       var fn ir.Node
+       if s.Type().IsEmptyInterface() {
+               fn = typecheck.LookupRuntime("efaceeq")
+       } else {
+               fn = typecheck.LookupRuntime("ifaceeq")
+       }
+
+       stab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s)
+       ttab := ir.NewUnaryExpr(base.Pos, ir.OITAB, t)
+       sdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, s)
+       tdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, t)
+       sdata.SetType(types.Types[types.TUNSAFEPTR])
+       tdata.SetType(types.Types[types.TUNSAFEPTR])
+       sdata.SetTypecheck(1)
+       tdata.SetTypecheck(1)
+
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
+       typecheck.Call(call)
+
+       cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
+       cmp = typecheck.Expr(cmp).(*ir.BinaryExpr)
+       cmp.SetType(types.Types[types.TBOOL])
+       return cmp, call
+}
+
+// eqmem returns the node
+//     memequal(&p.field, &q.field [, size])
+func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
+       nx := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)))
+       ny := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)))
+
+       fn, needsize := eqmemfunc(size, nx.Type().Elem())
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+       call.Args.Append(nx)
+       call.Args.Append(ny)
+       if needsize {
+               call.Args.Append(ir.NewInt(size))
+       }
+
+       return call
+}
+
+func eqmemfunc(size int64, t *types.Type) (fn *ir.Name, needsize bool) {
+       switch size {
+       default:
+               fn = typecheck.LookupRuntime("memequal")
+               needsize = true
+       case 1, 2, 4, 8, 16:
+               buf := fmt.Sprintf("memequal%d", int(size)*8)
+               fn = typecheck.LookupRuntime(buf)
+       }
+
+       fn = typecheck.SubstArgTypes(fn, t, t)
+       return fn, needsize
+}
+
+// memrun finds runs of struct fields for which memory-only algs are appropriate.
+// t is the parent struct type, and start is the field index at which to start the run.
+// size is the length in bytes of the memory included in the run.
+// next is the index just after the end of the memory run.
+func memrun(t *types.Type, start int) (size int64, next int) {
+       next = start
+       for {
+               next++
+               if next == t.NumFields() {
+                       break
+               }
+               // Stop run after a padded field.
+               if types.IsPaddedField(t, next-1) {
+                       break
+               }
+               // Also, stop before a blank or non-memory field.
+               if f := t.Field(next); f.Sym.IsBlank() || !isRegularMemory(f.Type) {
+                       break
+               }
+       }
+       return t.Field(next-1).End() - t.Field(start).Offset, next
+}
+
+func hashmem(t *types.Type) ir.Node {
+       sym := ir.Pkgs.Runtime.Lookup("memhash")
+
+       n := typecheck.NewName(sym)
+       ir.MarkFunc(n)
+       n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+               types.NewField(base.Pos, nil, types.NewPtr(t)),
+               types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+               types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+       }, []*types.Field{
+               types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+       }))
+       return n
+}

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
similarity index 54%
rename from src/cmd/compile/internal/gc/reflect.go
rename to src/cmd/compile/internal/reflectdata/reflect.go
index 9401eba7a5021af1ecdd7dea5555363dcfa17d53..3ff14c87f4fc7b0603435b511771cc9cf1dcfbdc 100644 (file)
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -2,19 +2,28 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package reflectdata
 
 import (
-       "cmd/compile/internal/types"
-       "cmd/internal/gcprog"
-       "cmd/internal/obj"
-       "cmd/internal/objabi"
-       "cmd/internal/src"
        "fmt"
        "os"
        "sort"
        "strings"
        "sync"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/bitvec"
+       "cmd/compile/internal/escape"
+       "cmd/compile/internal/inline"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/typebits"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/gcprog"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
 )
 
 type itabEntry struct {
@@ -23,7 +32,7 @@ type itabEntry struct {
 
        // symbols of each method in
        // the itab, sorted by byte offset;
-       // filled in by peekitabs
+       // filled in by CompileITabs
        entries []*obj.LSym
 }
 
@@ -32,6 +41,10 @@ type ptabEntry struct {
        t *types.Type
 }
 
+func CountTabs() (numPTabs, numITabs int) {
+       return len(ptabs), len(itabs)
+}
+
 // runtime interface and reflection data structures
 var (
        signatmu    sync.Mutex // protects signatset and signatslice
@@ -39,13 +52,13 @@ var (
        signatslice []*types.Type
 
        itabs []itabEntry
-       ptabs []ptabEntry
+       ptabs []*ir.Name
 )
 
-type Sig struct {
+type typeSig struct {
        name  *types.Sym
-       isym  *types.Sym
-       tsym  *types.Sym
+       isym  *obj.LSym
+       tsym  *obj.LSym
        type_ *types.Type
        mtype *types.Type
 }
@@ -61,35 +74,32 @@ const (
        MAXELEMSIZE = 128
 )
 
-func structfieldSize() int { return 3 * Widthptr }       // Sizeof(runtime.structfield{})
-func imethodSize() int     { return 4 + 4 }              // Sizeof(runtime.imethod{})
-func commonSize() int      { return 4*Widthptr + 8 + 8 } // Sizeof(runtime._type{})
+func structfieldSize() int { return 3 * types.PtrSize }       // Sizeof(runtime.structfield{})
+func imethodSize() int     { return 4 + 4 }                   // Sizeof(runtime.imethod{})
+func commonSize() int      { return 4*types.PtrSize + 8 + 8 } // Sizeof(runtime._type{})
 
 func uncommonSize(t *types.Type) int { // Sizeof(runtime.uncommontype{})
-       if t.Sym == nil && len(methods(t)) == 0 {
+       if t.Sym() == nil && len(methods(t)) == 0 {
                return 0
        }
        return 4 + 2 + 2 + 4 + 4
 }
 
 func makefield(name string, t *types.Type) *types.Field {
-       f := types.NewField()
-       f.Type = t
-       f.Sym = (*types.Pkg)(nil).Lookup(name)
-       return f
+       sym := (*types.Pkg)(nil).Lookup(name)
+       return types.NewField(src.NoXPos, sym, t)
 }
 
-// bmap makes the map bucket type given the type of the map.
-func bmap(t *types.Type) *types.Type {
+// MapBucketType makes the map bucket type given the type of the map.
+func MapBucketType(t *types.Type) *types.Type {
        if t.MapType().Bucket != nil {
                return t.MapType().Bucket
        }
 
-       bucket := types.New(TSTRUCT)
        keytype := t.Key()
        elemtype := t.Elem()
-       dowidth(keytype)
-       dowidth(elemtype)
+       types.CalcSize(keytype)
+       types.CalcSize(elemtype)
        if keytype.Width > MAXKEYSIZE {
                keytype = types.NewPtr(keytype)
        }
@@ -100,7 +110,7 @@ func bmap(t *types.Type) *types.Type {
        field := make([]*types.Field, 0, 5)
 
        // The first field is: uint8 topbits[BUCKETSIZE].
-       arr := types.NewArray(types.Types[TUINT8], BUCKETSIZE)
+       arr := types.NewArray(types.Types[types.TUINT8], BUCKETSIZE)
        field = append(field, makefield("topbits", arr))
 
        arr = types.NewArray(keytype, BUCKETSIZE)
@@ -119,66 +129,66 @@ func bmap(t *types.Type) *types.Type {
        // Arrange for the bucket to have no pointers by changing
        // the type of the overflow field to uintptr in this case.
        // See comment on hmap.overflow in runtime/map.go.
-       otyp := types.NewPtr(bucket)
+       otyp := types.Types[types.TUNSAFEPTR]
        if !elemtype.HasPointers() && !keytype.HasPointers() {
-               otyp = types.Types[TUINTPTR]
+               otyp = types.Types[types.TUINTPTR]
        }
        overflow := makefield("overflow", otyp)
        field = append(field, overflow)
 
        // link up fields
+       bucket := types.NewStruct(types.NoPkg, field[:])
        bucket.SetNoalg(true)
-       bucket.SetFields(field[:])
-       dowidth(bucket)
+       types.CalcSize(bucket)
 
        // Check invariants that map code depends on.
-       if !IsComparable(t.Key()) {
-               Fatalf("unsupported map key type for %v", t)
+       if !types.IsComparable(t.Key()) {
+               base.Fatalf("unsupported map key type for %v", t)
        }
        if BUCKETSIZE < 8 {
-               Fatalf("bucket size too small for proper alignment")
+               base.Fatalf("bucket size too small for proper alignment")
        }
        if keytype.Align > BUCKETSIZE {
-               Fatalf("key align too big for %v", t)
+               base.Fatalf("key align too big for %v", t)
        }
        if elemtype.Align > BUCKETSIZE {
-               Fatalf("elem align too big for %v", t)
+               base.Fatalf("elem align too big for %v", t)
        }
        if keytype.Width > MAXKEYSIZE {
-               Fatalf("key size to large for %v", t)
+               base.Fatalf("key size to large for %v", t)
        }
        if elemtype.Width > MAXELEMSIZE {
-               Fatalf("elem size to large for %v", t)
+               base.Fatalf("elem size to large for %v", t)
        }
        if t.Key().Width > MAXKEYSIZE && !keytype.IsPtr() {
-               Fatalf("key indirect incorrect for %v", t)
+               base.Fatalf("key indirect incorrect for %v", t)
        }
        if t.Elem().Width > MAXELEMSIZE && !elemtype.IsPtr() {
-               Fatalf("elem indirect incorrect for %v", t)
+               base.Fatalf("elem indirect incorrect for %v", t)
        }
        if keytype.Width%int64(keytype.Align) != 0 {
-               Fatalf("key size not a multiple of key align for %v", t)
+               base.Fatalf("key size not a multiple of key align for %v", t)
        }
        if elemtype.Width%int64(elemtype.Align) != 0 {
-               Fatalf("elem size not a multiple of elem align for %v", t)
+               base.Fatalf("elem size not a multiple of elem align for %v", t)
        }
        if bucket.Align%keytype.Align != 0 {
-               Fatalf("bucket align not multiple of key align %v", t)
+               base.Fatalf("bucket align not multiple of key align %v", t)
        }
        if bucket.Align%elemtype.Align != 0 {
-               Fatalf("bucket align not multiple of elem align %v", t)
+               base.Fatalf("bucket align not multiple of elem align %v", t)
        }
        if keys.Offset%int64(keytype.Align) != 0 {
-               Fatalf("bad alignment of keys in bmap for %v", t)
+               base.Fatalf("bad alignment of keys in bmap for %v", t)
        }
        if elems.Offset%int64(elemtype.Align) != 0 {
-               Fatalf("bad alignment of elems in bmap for %v", t)
+               base.Fatalf("bad alignment of elems in bmap for %v", t)
        }
 
        // Double-check that overflow field is final memory in struct,
        // with no padding at end.
-       if overflow.Offset != bucket.Width-int64(Widthptr) {
-               Fatalf("bad offset of overflow in bmap for %v", t)
+       if overflow.Offset != bucket.Width-int64(types.PtrSize) {
+               base.Fatalf("bad offset of overflow in bmap for %v", t)
        }
 
        t.MapType().Bucket = bucket
@@ -187,14 +197,14 @@ func bmap(t *types.Type) *types.Type {
        return bucket
 }
 
-// hmap builds a type representing a Hmap structure for the given map type.
+// MapType builds a type representing a Hmap structure for the given map type.
 // Make sure this stays in sync with runtime/map.go.
-func hmap(t *types.Type) *types.Type {
+func MapType(t *types.Type) *types.Type {
        if t.MapType().Hmap != nil {
                return t.MapType().Hmap
        }
 
-       bmap := bmap(t)
+       bmap := MapBucketType(t)
 
        // build a struct:
        // type hmap struct {
@@ -210,26 +220,25 @@ func hmap(t *types.Type) *types.Type {
        // }
        // must match runtime/map.go:hmap.
        fields := []*types.Field{
-               makefield("count", types.Types[TINT]),
-               makefield("flags", types.Types[TUINT8]),
-               makefield("B", types.Types[TUINT8]),
-               makefield("noverflow", types.Types[TUINT16]),
-               makefield("hash0", types.Types[TUINT32]), // Used in walk.go for OMAKEMAP.
-               makefield("buckets", types.NewPtr(bmap)), // Used in walk.go for OMAKEMAP.
+               makefield("count", types.Types[types.TINT]),
+               makefield("flags", types.Types[types.TUINT8]),
+               makefield("B", types.Types[types.TUINT8]),
+               makefield("noverflow", types.Types[types.TUINT16]),
+               makefield("hash0", types.Types[types.TUINT32]), // Used in walk.go for OMAKEMAP.
+               makefield("buckets", types.NewPtr(bmap)),       // Used in walk.go for OMAKEMAP.
                makefield("oldbuckets", types.NewPtr(bmap)),
-               makefield("nevacuate", types.Types[TUINTPTR]),
-               makefield("extra", types.Types[TUNSAFEPTR]),
+               makefield("nevacuate", types.Types[types.TUINTPTR]),
+               makefield("extra", types.Types[types.TUNSAFEPTR]),
        }
 
-       hmap := types.New(TSTRUCT)
+       hmap := types.NewStruct(types.NoPkg, fields)
        hmap.SetNoalg(true)
-       hmap.SetFields(fields)
-       dowidth(hmap)
+       types.CalcSize(hmap)
 
        // The size of hmap should be 48 bytes on 64 bit
        // and 28 bytes on 32 bit platforms.
-       if size := int64(8 + 5*Widthptr); hmap.Width != size {
-               Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
+       if size := int64(8 + 5*types.PtrSize); hmap.Width != size {
+               base.Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
        }
 
        t.MapType().Hmap = hmap
@@ -237,15 +246,15 @@ func hmap(t *types.Type) *types.Type {
        return hmap
 }
 
-// hiter builds a type representing an Hiter structure for the given map type.
+// MapIterType builds a type representing an Hiter structure for the given map type.
 // Make sure this stays in sync with runtime/map.go.
-func hiter(t *types.Type) *types.Type {
+func MapIterType(t *types.Type) *types.Type {
        if t.MapType().Hiter != nil {
                return t.MapType().Hiter
        }
 
-       hmap := hmap(t)
-       bmap := bmap(t)
+       hmap := MapType(t)
+       bmap := MapBucketType(t)
 
        // build a struct:
        // type hiter struct {
@@ -269,210 +278,110 @@ func hiter(t *types.Type) *types.Type {
        fields := []*types.Field{
                makefield("key", types.NewPtr(t.Key())),   // Used in range.go for TMAP.
                makefield("elem", types.NewPtr(t.Elem())), // Used in range.go for TMAP.
-               makefield("t", types.Types[TUNSAFEPTR]),
+               makefield("t", types.Types[types.TUNSAFEPTR]),
                makefield("h", types.NewPtr(hmap)),
                makefield("buckets", types.NewPtr(bmap)),
                makefield("bptr", types.NewPtr(bmap)),
-               makefield("overflow", types.Types[TUNSAFEPTR]),
-               makefield("oldoverflow", types.Types[TUNSAFEPTR]),
-               makefield("startBucket", types.Types[TUINTPTR]),
-               makefield("offset", types.Types[TUINT8]),
-               makefield("wrapped", types.Types[TBOOL]),
-               makefield("B", types.Types[TUINT8]),
-               makefield("i", types.Types[TUINT8]),
-               makefield("bucket", types.Types[TUINTPTR]),
-               makefield("checkBucket", types.Types[TUINTPTR]),
+               makefield("overflow", types.Types[types.TUNSAFEPTR]),
+               makefield("oldoverflow", types.Types[types.TUNSAFEPTR]),
+               makefield("startBucket", types.Types[types.TUINTPTR]),
+               makefield("offset", types.Types[types.TUINT8]),
+               makefield("wrapped", types.Types[types.TBOOL]),
+               makefield("B", types.Types[types.TUINT8]),
+               makefield("i", types.Types[types.TUINT8]),
+               makefield("bucket", types.Types[types.TUINTPTR]),
+               makefield("checkBucket", types.Types[types.TUINTPTR]),
        }
 
        // build iterator struct holding the above fields
-       hiter := types.New(TSTRUCT)
+       hiter := types.NewStruct(types.NoPkg, fields)
        hiter.SetNoalg(true)
-       hiter.SetFields(fields)
-       dowidth(hiter)
-       if hiter.Width != int64(12*Widthptr) {
-               Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*Widthptr)
+       types.CalcSize(hiter)
+       if hiter.Width != int64(12*types.PtrSize) {
+               base.Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*types.PtrSize)
        }
        t.MapType().Hiter = hiter
        hiter.StructType().Map = t
        return hiter
 }
 
-// deferstruct makes a runtime._defer structure, with additional space for
-// stksize bytes of args.
-func deferstruct(stksize int64) *types.Type {
-       makefield := func(name string, typ *types.Type) *types.Field {
-               f := types.NewField()
-               f.Type = typ
-               // Unlike the global makefield function, this one needs to set Pkg
-               // because these types might be compared (in SSA CSE sorting).
-               // TODO: unify this makefield and the global one above.
-               f.Sym = &types.Sym{Name: name, Pkg: localpkg}
-               return f
-       }
-       argtype := types.NewArray(types.Types[TUINT8], stksize)
-       argtype.Width = stksize
-       argtype.Align = 1
-       // These fields must match the ones in runtime/runtime2.go:_defer and
-       // cmd/compile/internal/gc/ssa.go:(*state).call.
-       fields := []*types.Field{
-               makefield("siz", types.Types[TUINT32]),
-               makefield("started", types.Types[TBOOL]),
-               makefield("heap", types.Types[TBOOL]),
-               makefield("openDefer", types.Types[TBOOL]),
-               makefield("sp", types.Types[TUINTPTR]),
-               makefield("pc", types.Types[TUINTPTR]),
-               // Note: the types here don't really matter. Defer structures
-               // are always scanned explicitly during stack copying and GC,
-               // so we make them uintptr type even though they are real pointers.
-               makefield("fn", types.Types[TUINTPTR]),
-               makefield("_panic", types.Types[TUINTPTR]),
-               makefield("link", types.Types[TUINTPTR]),
-               makefield("framepc", types.Types[TUINTPTR]),
-               makefield("varp", types.Types[TUINTPTR]),
-               makefield("fd", types.Types[TUINTPTR]),
-               makefield("args", argtype),
-       }
-
-       // build struct holding the above fields
-       s := types.New(TSTRUCT)
-       s.SetNoalg(true)
-       s.SetFields(fields)
-       s.Width = widstruct(s, s, 0, 1)
-       s.Align = uint8(Widthptr)
-       return s
-}
-
-// f is method type, with receiver.
-// return function type, receiver as first argument (or not).
-func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
-       inLen := f.Params().Fields().Len()
-       if receiver != nil {
-               inLen++
-       }
-       in := make([]*Node, 0, inLen)
-
-       if receiver != nil {
-               d := anonfield(receiver)
-               in = append(in, d)
-       }
-
-       for _, t := range f.Params().Fields().Slice() {
-               d := anonfield(t.Type)
-               d.SetIsDDD(t.IsDDD())
-               in = append(in, d)
-       }
-
-       outLen := f.Results().Fields().Len()
-       out := make([]*Node, 0, outLen)
-       for _, t := range f.Results().Fields().Slice() {
-               d := anonfield(t.Type)
-               out = append(out, d)
-       }
-
-       t := functype(nil, in, out)
-       if f.Nname() != nil {
-               // Link to name of original method function.
-               t.SetNname(f.Nname())
-       }
-
-       return t
-}
-
 // methods returns the methods of the non-interface type t, sorted by name.
 // Generates stub functions as needed.
-func methods(t *types.Type) []*Sig {
+func methods(t *types.Type) []*typeSig {
        // method type
-       mt := methtype(t)
+       mt := types.ReceiverBaseType(t)
 
        if mt == nil {
                return nil
        }
-       expandmeth(mt)
+       typecheck.CalcMethods(mt)
 
        // type stored in interface word
        it := t
 
-       if !isdirectiface(it) {
+       if !types.IsDirectIface(it) {
                it = types.NewPtr(t)
        }
 
        // make list of methods for t,
        // generating code if necessary.
-       var ms []*Sig
+       var ms []*typeSig
        for _, f := range mt.AllMethods().Slice() {
+               if f.Sym == nil {
+                       base.Fatalf("method with no sym on %v", mt)
+               }
                if !f.IsMethod() {
-                       Fatalf("non-method on %v method %v %v\n", mt, f.Sym, f)
+                       base.Fatalf("non-method on %v method %v %v", mt, f.Sym, f)
                }
                if f.Type.Recv() == nil {
-                       Fatalf("receiver with no type on %v method %v %v\n", mt, f.Sym, f)
+                       base.Fatalf("receiver with no type on %v method %v %v", mt, f.Sym, f)
                }
                if f.Nointerface() {
                        continue
                }
 
-               method := f.Sym
-               if method == nil {
-                       break
-               }
-
                // get receiver type for this particular method.
                // if pointer receiver but non-pointer t and
                // this is not an embedded pointer inside a struct,
                // method does not apply.
-               if !isMethodApplicable(t, f) {
+               if !types.IsMethodApplicable(t, f) {
                        continue
                }
 
-               sig := &Sig{
-                       name:  method,
-                       isym:  methodSym(it, method),
-                       tsym:  methodSym(t, method),
-                       type_: methodfunc(f.Type, t),
-                       mtype: methodfunc(f.Type, nil),
+               sig := &typeSig{
+                       name:  f.Sym,
+                       isym:  methodWrapper(it, f),
+                       tsym:  methodWrapper(t, f),
+                       type_: typecheck.NewMethodType(f.Type, t),
+                       mtype: typecheck.NewMethodType(f.Type, nil),
                }
                ms = append(ms, sig)
-
-               this := f.Type.Recv().Type
-
-               if !sig.isym.Siggen() {
-                       sig.isym.SetSiggen(true)
-                       if !types.Identical(this, it) {
-                               genwrapper(it, f, sig.isym)
-                       }
-               }
-
-               if !sig.tsym.Siggen() {
-                       sig.tsym.SetSiggen(true)
-                       if !types.Identical(this, t) {
-                               genwrapper(t, f, sig.tsym)
-                       }
-               }
        }
 
        return ms
 }
 
 // imethods returns the methods of the interface type t, sorted by name.
-func imethods(t *types.Type) []*Sig {
-       var methods []*Sig
+func imethods(t *types.Type) []*typeSig {
+       var methods []*typeSig
        for _, f := range t.Fields().Slice() {
-               if f.Type.Etype != TFUNC || f.Sym == nil {
+               if f.Type.Kind() != types.TFUNC || f.Sym == nil {
                        continue
                }
                if f.Sym.IsBlank() {
-                       Fatalf("unexpected blank symbol in interface method set")
+                       base.Fatalf("unexpected blank symbol in interface method set")
                }
                if n := len(methods); n > 0 {
                        last := methods[n-1]
                        if !last.name.Less(f.Sym) {
-                               Fatalf("sigcmp vs sortinter %v %v", last.name, f.Sym)
+                               base.Fatalf("sigcmp vs sortinter %v %v", last.name, f.Sym)
                        }
                }
 
-               sig := &Sig{
+               sig := &typeSig{
                        name:  f.Sym,
                        mtype: f.Type,
-                       type_: methodfunc(f.Type, nil),
+                       type_: typecheck.NewMethodType(f.Type, nil),
                }
                methods = append(methods, sig)
 
@@ -480,11 +389,7 @@ func imethods(t *types.Type) []*Sig {
                // IfaceType.Method is not in the reflect data.
                // Generate the method body, so that compiled
                // code can refer to it.
-               isym := methodSym(t, f.Sym)
-               if !isym.Siggen() {
-                       isym.SetSiggen(true)
-                       genwrapper(t, f, isym)
-               }
+               methodWrapper(t, f)
        }
 
        return methods
@@ -496,79 +401,79 @@ func dimportpath(p *types.Pkg) {
        }
 
        // If we are compiling the runtime package, there are two runtime packages around
-       // -- localpkg and Runtimepkg. We don't want to produce import path symbols for
+       // -- localpkg and Pkgs.Runtime. We don't want to produce import path symbols for
        // both of them, so just produce one for localpkg.
-       if myimportpath == "runtime" && p == Runtimepkg {
+       if base.Ctxt.Pkgpath == "runtime" && p == ir.Pkgs.Runtime {
                return
        }
 
        str := p.Path
-       if p == localpkg {
+       if p == types.LocalPkg {
                // Note: myimportpath != "", or else dgopkgpath won't call dimportpath.
-               str = myimportpath
+               str = base.Ctxt.Pkgpath
        }
 
-       s := Ctxt.Lookup("type..importpath." + p.Prefix + ".")
+       s := base.Ctxt.Lookup("type..importpath." + p.Prefix + ".")
        ot := dnameData(s, 0, str, "", nil, false)
-       ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
+       objw.Global(s, int32(ot), obj.DUPOK|obj.RODATA)
        s.Set(obj.AttrContentAddressable, true)
        p.Pathsym = s
 }
 
 func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
        if pkg == nil {
-               return duintptr(s, ot, 0)
+               return objw.Uintptr(s, ot, 0)
        }
 
-       if pkg == localpkg && myimportpath == "" {
+       if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
                // If we don't know the full import path of the package being compiled
                // (i.e. -p was not passed on the compiler command line), emit a reference to
                // type..importpath.""., which the linker will rewrite using the correct import path.
                // Every package that imports this one directly defines the symbol.
                // See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
-               ns := Ctxt.Lookup(`type..importpath."".`)
-               return dsymptr(s, ot, ns, 0)
+               ns := base.Ctxt.Lookup(`type..importpath."".`)
+               return objw.SymPtr(s, ot, ns, 0)
        }
 
        dimportpath(pkg)
-       return dsymptr(s, ot, pkg.Pathsym, 0)
+       return objw.SymPtr(s, ot, pkg.Pathsym, 0)
 }
 
 // dgopkgpathOff writes an offset relocation in s at offset ot to the pkg path symbol.
 func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
        if pkg == nil {
-               return duint32(s, ot, 0)
+               return objw.Uint32(s, ot, 0)
        }
-       if pkg == localpkg && myimportpath == "" {
+       if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
                // If we don't know the full import path of the package being compiled
                // (i.e. -p was not passed on the compiler command line), emit a reference to
                // type..importpath.""., which the linker will rewrite using the correct import path.
                // Every package that imports this one directly defines the symbol.
                // See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
-               ns := Ctxt.Lookup(`type..importpath."".`)
-               return dsymptrOff(s, ot, ns)
+               ns := base.Ctxt.Lookup(`type..importpath."".`)
+               return objw.SymPtrOff(s, ot, ns)
        }
 
        dimportpath(pkg)
-       return dsymptrOff(s, ot, pkg.Pathsym)
+       return objw.SymPtrOff(s, ot, pkg.Pathsym)
 }
 
 // dnameField dumps a reflect.name for a struct field.
 func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
        if !types.IsExported(ft.Sym.Name) && ft.Sym.Pkg != spkg {
-               Fatalf("package mismatch for %v", ft.Sym)
+               base.Fatalf("package mismatch for %v", ft.Sym)
        }
        nsym := dname(ft.Sym.Name, ft.Note, nil, types.IsExported(ft.Sym.Name))
-       return dsymptr(lsym, ot, nsym, 0)
+       return objw.SymPtr(lsym, ot, nsym, 0)
 }
 
 // dnameData writes the contents of a reflect.name into s at offset ot.
 func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported bool) int {
        if len(name) > 1<<16-1 {
-               Fatalf("name too long: %s", name)
+               base.Fatalf("name too long: %s", name)
        }
        if len(tag) > 1<<16-1 {
-               Fatalf("tag too long: %s", tag)
+               base.Fatalf("tag too long: %s", tag)
        }
 
        // Encode name and tag. See reflect/type.go for details.
@@ -596,7 +501,7 @@ func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported b
                copy(tb[2:], tag)
        }
 
-       ot = int(s.WriteBytes(Ctxt, int64(ot), b))
+       ot = int(s.WriteBytes(base.Ctxt, int64(ot), b))
 
        if pkg != nil {
                ot = dgopkgpathOff(s, ot, pkg)
@@ -633,12 +538,12 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
                sname = fmt.Sprintf(`%s"".%d`, sname, dnameCount)
                dnameCount++
        }
-       s := Ctxt.Lookup(sname)
+       s := base.Ctxt.Lookup(sname)
        if len(s.P) > 0 {
                return s
        }
        ot := dnameData(s, 0, name, tag, pkg, exported)
-       ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
+       objw.Global(s, int32(ot), obj.DUPOK|obj.RODATA)
        s.Set(obj.AttrContentAddressable, true)
        return s
 }
@@ -648,16 +553,16 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
 // backing array of the []method field is written (by dextratypeData).
 func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
        m := methods(t)
-       if t.Sym == nil && len(m) == 0 {
+       if t.Sym() == nil && len(m) == 0 {
                return ot
        }
-       noff := int(Rnd(int64(ot), int64(Widthptr)))
+       noff := int(types.Rnd(int64(ot), int64(types.PtrSize)))
        if noff != ot {
-               Fatalf("unexpected alignment in dextratype for %v", t)
+               base.Fatalf("unexpected alignment in dextratype for %v", t)
        }
 
        for _, a := range m {
-               dtypesym(a.type_)
+               writeType(a.type_)
        }
 
        ot = dgopkgpathOff(lsym, ot, typePkg(t))
@@ -665,31 +570,31 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
        dataAdd += uncommonSize(t)
        mcount := len(m)
        if mcount != int(uint16(mcount)) {
-               Fatalf("too many methods on %v: %d", t, mcount)
+               base.Fatalf("too many methods on %v: %d", t, mcount)
        }
        xcount := sort.Search(mcount, func(i int) bool { return !types.IsExported(m[i].name.Name) })
        if dataAdd != int(uint32(dataAdd)) {
-               Fatalf("methods are too far away on %v: %d", t, dataAdd)
+               base.Fatalf("methods are too far away on %v: %d", t, dataAdd)
        }
 
-       ot = duint16(lsym, ot, uint16(mcount))
-       ot = duint16(lsym, ot, uint16(xcount))
-       ot = duint32(lsym, ot, uint32(dataAdd))
-       ot = duint32(lsym, ot, 0)
+       ot = objw.Uint16(lsym, ot, uint16(mcount))
+       ot = objw.Uint16(lsym, ot, uint16(xcount))
+       ot = objw.Uint32(lsym, ot, uint32(dataAdd))
+       ot = objw.Uint32(lsym, ot, 0)
        return ot
 }
 
 func typePkg(t *types.Type) *types.Pkg {
-       tsym := t.Sym
+       tsym := t.Sym()
        if tsym == nil {
-               switch t.Etype {
-               case TARRAY, TSLICE, TPTR, TCHAN:
+               switch t.Kind() {
+               case types.TARRAY, types.TSLICE, types.TPTR, types.TCHAN:
                        if t.Elem() != nil {
-                               tsym = t.Elem().Sym
+                               tsym = t.Elem().Sym()
                        }
                }
        }
-       if tsym != nil && t != types.Types[t.Etype] && t != types.Errortype {
+       if tsym != nil && t != types.Types[t.Kind()] && t != types.ErrorType {
                return tsym.Pkg
        }
        return nil
@@ -707,16 +612,16 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
                }
                nsym := dname(a.name.Name, "", pkg, exported)
 
-               ot = dsymptrOff(lsym, ot, nsym)
-               ot = dmethodptrOff(lsym, ot, dtypesym(a.mtype))
-               ot = dmethodptrOff(lsym, ot, a.isym.Linksym())
-               ot = dmethodptrOff(lsym, ot, a.tsym.Linksym())
+               ot = objw.SymPtrOff(lsym, ot, nsym)
+               ot = dmethodptrOff(lsym, ot, writeType(a.mtype))
+               ot = dmethodptrOff(lsym, ot, a.isym)
+               ot = dmethodptrOff(lsym, ot, a.tsym)
        }
        return ot
 }
 
 func dmethodptrOff(s *obj.LSym, ot int, x *obj.LSym) int {
-       duint32(s, ot, 0)
+       objw.Uint32(s, ot, 0)
        r := obj.Addrel(s)
        r.Off = int32(ot)
        r.Siz = 4
@@ -726,81 +631,32 @@ func dmethodptrOff(s *obj.LSym, ot int, x *obj.LSym) int {
 }
 
 var kinds = []int{
-       TINT:        objabi.KindInt,
-       TUINT:       objabi.KindUint,
-       TINT8:       objabi.KindInt8,
-       TUINT8:      objabi.KindUint8,
-       TINT16:      objabi.KindInt16,
-       TUINT16:     objabi.KindUint16,
-       TINT32:      objabi.KindInt32,
-       TUINT32:     objabi.KindUint32,
-       TINT64:      objabi.KindInt64,
-       TUINT64:     objabi.KindUint64,
-       TUINTPTR:    objabi.KindUintptr,
-       TFLOAT32:    objabi.KindFloat32,
-       TFLOAT64:    objabi.KindFloat64,
-       TBOOL:       objabi.KindBool,
-       TSTRING:     objabi.KindString,
-       TPTR:        objabi.KindPtr,
-       TSTRUCT:     objabi.KindStruct,
-       TINTER:      objabi.KindInterface,
-       TCHAN:       objabi.KindChan,
-       TMAP:        objabi.KindMap,
-       TARRAY:      objabi.KindArray,
-       TSLICE:      objabi.KindSlice,
-       TFUNC:       objabi.KindFunc,
-       TCOMPLEX64:  objabi.KindComplex64,
-       TCOMPLEX128: objabi.KindComplex128,
-       TUNSAFEPTR:  objabi.KindUnsafePointer,
-}
-
-// typeptrdata returns the length in bytes of the prefix of t
-// containing pointer data. Anything after this offset is scalar data.
-func typeptrdata(t *types.Type) int64 {
-       if !t.HasPointers() {
-               return 0
-       }
-
-       switch t.Etype {
-       case TPTR,
-               TUNSAFEPTR,
-               TFUNC,
-               TCHAN,
-               TMAP:
-               return int64(Widthptr)
-
-       case TSTRING:
-               // struct { byte *str; intgo len; }
-               return int64(Widthptr)
-
-       case TINTER:
-               // struct { Itab *tab;  void *data; } or
-               // struct { Type *type; void *data; }
-               // Note: see comment in plive.go:onebitwalktype1.
-               return 2 * int64(Widthptr)
-
-       case TSLICE:
-               // struct { byte *array; uintgo len; uintgo cap; }
-               return int64(Widthptr)
-
-       case TARRAY:
-               // haspointers already eliminated t.NumElem() == 0.
-               return (t.NumElem()-1)*t.Elem().Width + typeptrdata(t.Elem())
-
-       case TSTRUCT:
-               // Find the last field that has pointers.
-               var lastPtrField *types.Field
-               for _, t1 := range t.Fields().Slice() {
-                       if t1.Type.HasPointers() {
-                               lastPtrField = t1
-                       }
-               }
-               return lastPtrField.Offset + typeptrdata(lastPtrField.Type)
-
-       default:
-               Fatalf("typeptrdata: unexpected type, %v", t)
-               return 0
-       }
+       types.TINT:        objabi.KindInt,
+       types.TUINT:       objabi.KindUint,
+       types.TINT8:       objabi.KindInt8,
+       types.TUINT8:      objabi.KindUint8,
+       types.TINT16:      objabi.KindInt16,
+       types.TUINT16:     objabi.KindUint16,
+       types.TINT32:      objabi.KindInt32,
+       types.TUINT32:     objabi.KindUint32,
+       types.TINT64:      objabi.KindInt64,
+       types.TUINT64:     objabi.KindUint64,
+       types.TUINTPTR:    objabi.KindUintptr,
+       types.TFLOAT32:    objabi.KindFloat32,
+       types.TFLOAT64:    objabi.KindFloat64,
+       types.TBOOL:       objabi.KindBool,
+       types.TSTRING:     objabi.KindString,
+       types.TPTR:        objabi.KindPtr,
+       types.TSTRUCT:     objabi.KindStruct,
+       types.TINTER:      objabi.KindInterface,
+       types.TCHAN:       objabi.KindChan,
+       types.TMAP:        objabi.KindMap,
+       types.TARRAY:      objabi.KindArray,
+       types.TSLICE:      objabi.KindSlice,
+       types.TFUNC:       objabi.KindFunc,
+       types.TCOMPLEX64:  objabi.KindComplex64,
+       types.TCOMPLEX128: objabi.KindComplex128,
+       types.TUNSAFEPTR:  objabi.KindUnsafePointer,
 }
 
 // tflag is documented in reflect/type.go.
@@ -824,17 +680,17 @@ var (
 
 // dcommontype dumps the contents of a reflect.rtype (runtime._type).
 func dcommontype(lsym *obj.LSym, t *types.Type) int {
-       dowidth(t)
+       types.CalcSize(t)
        eqfunc := geneq(t)
 
        sptrWeak := true
        var sptr *obj.LSym
        if !t.IsPtr() || t.IsPtrElem() {
                tptr := types.NewPtr(t)
-               if t.Sym != nil || methods(tptr) != nil {
+               if t.Sym() != nil || methods(tptr) != nil {
                        sptrWeak = false
                }
-               sptr = dtypesym(tptr)
+               sptr = writeType(tptr)
        }
 
        gcsym, useGCProg, ptrdata := dgcsym(t)
@@ -855,18 +711,18 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
        //              ptrToThis     typeOff
        //      }
        ot := 0
-       ot = duintptr(lsym, ot, uint64(t.Width))
-       ot = duintptr(lsym, ot, uint64(ptrdata))
-       ot = duint32(lsym, ot, typehash(t))
+       ot = objw.Uintptr(lsym, ot, uint64(t.Width))
+       ot = objw.Uintptr(lsym, ot, uint64(ptrdata))
+       ot = objw.Uint32(lsym, ot, types.TypeHash(t))
 
        var tflag uint8
        if uncommonSize(t) != 0 {
                tflag |= tflagUncommon
        }
-       if t.Sym != nil && t.Sym.Name != "" {
+       if t.Sym() != nil && t.Sym().Name != "" {
                tflag |= tflagNamed
        }
-       if IsRegularMemory(t) {
+       if isRegularMemory(t) {
                tflag |= tflagRegularMemory
        }
 
@@ -880,16 +736,16 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
        if !strings.HasPrefix(p, "*") {
                p = "*" + p
                tflag |= tflagExtraStar
-               if t.Sym != nil {
-                       exported = types.IsExported(t.Sym.Name)
+               if t.Sym() != nil {
+                       exported = types.IsExported(t.Sym().Name)
                }
        } else {
-               if t.Elem() != nil && t.Elem().Sym != nil {
-                       exported = types.IsExported(t.Elem().Sym.Name)
+               if t.Elem() != nil && t.Elem().Sym() != nil {
+                       exported = types.IsExported(t.Elem().Sym().Name)
                }
        }
 
-       ot = duint8(lsym, ot, tflag)
+       ot = objw.Uint8(lsym, ot, tflag)
 
        // runtime (and common sense) expects alignment to be a power of two.
        i := int(t.Align)
@@ -898,88 +754,54 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
                i = 1
        }
        if i&(i-1) != 0 {
-               Fatalf("invalid alignment %d for %v", t.Align, t)
+               base.Fatalf("invalid alignment %d for %v", t.Align, t)
        }
-       ot = duint8(lsym, ot, t.Align) // align
-       ot = duint8(lsym, ot, t.Align) // fieldAlign
+       ot = objw.Uint8(lsym, ot, t.Align) // align
+       ot = objw.Uint8(lsym, ot, t.Align) // fieldAlign
 
-       i = kinds[t.Etype]
-       if isdirectiface(t) {
+       i = kinds[t.Kind()]
+       if types.IsDirectIface(t) {
                i |= objabi.KindDirectIface
        }
        if useGCProg {
                i |= objabi.KindGCProg
        }
-       ot = duint8(lsym, ot, uint8(i)) // kind
+       ot = objw.Uint8(lsym, ot, uint8(i)) // kind
        if eqfunc != nil {
-               ot = dsymptr(lsym, ot, eqfunc, 0) // equality function
+               ot = objw.SymPtr(lsym, ot, eqfunc, 0) // equality function
        } else {
-               ot = duintptr(lsym, ot, 0) // type we can't do == with
+               ot = objw.Uintptr(lsym, ot, 0) // type we can't do == with
        }
-       ot = dsymptr(lsym, ot, gcsym, 0) // gcdata
+       ot = objw.SymPtr(lsym, ot, gcsym, 0) // gcdata
 
        nsym := dname(p, "", nil, exported)
-       ot = dsymptrOff(lsym, ot, nsym) // str
+       ot = objw.SymPtrOff(lsym, ot, nsym) // str
        // ptrToThis
        if sptr == nil {
-               ot = duint32(lsym, ot, 0)
+               ot = objw.Uint32(lsym, ot, 0)
        } else if sptrWeak {
-               ot = dsymptrWeakOff(lsym, ot, sptr)
+               ot = objw.SymPtrWeakOff(lsym, ot, sptr)
        } else {
-               ot = dsymptrOff(lsym, ot, sptr)
+               ot = objw.SymPtrOff(lsym, ot, sptr)
        }
 
        return ot
 }
 
-// typeHasNoAlg reports whether t does not have any associated hash/eq
-// algorithms because t, or some component of t, is marked Noalg.
-func typeHasNoAlg(t *types.Type) bool {
-       a, bad := algtype1(t)
-       return a == ANOEQ && bad.Noalg()
-}
-
-func typesymname(t *types.Type) string {
-       name := t.ShortString()
-       // Use a separate symbol name for Noalg types for #17752.
-       if typeHasNoAlg(t) {
-               name = "noalg." + name
-       }
-       return name
-}
-
-// Fake package for runtime type info (headers)
-// Don't access directly, use typeLookup below.
-var (
-       typepkgmu sync.Mutex // protects typepkg lookups
-       typepkg   = types.NewPkg("type", "type")
-)
-
-func typeLookup(name string) *types.Sym {
-       typepkgmu.Lock()
-       s := typepkg.Lookup(name)
-       typepkgmu.Unlock()
-       return s
-}
-
-func typesym(t *types.Type) *types.Sym {
-       return typeLookup(typesymname(t))
-}
-
-// tracksym returns the symbol for tracking use of field/method f, assumed
+// TrackSym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
-func tracksym(t *types.Type, f *types.Field) *types.Sym {
-       return trackpkg.Lookup(t.ShortString() + "." + f.Sym.Name)
+func TrackSym(t *types.Type, f *types.Field) *obj.LSym {
+       return base.PkgLinksym("go.track", t.ShortString()+"."+f.Sym.Name, obj.ABI0)
 }
 
-func typesymprefix(prefix string, t *types.Type) *types.Sym {
+func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
        p := prefix + "." + t.ShortString()
-       s := typeLookup(p)
+       s := types.TypeSymLookup(p)
 
        // This function is for looking up type-related generated functions
        // (e.g. eq and hash). Make sure they are indeed generated.
        signatmu.Lock()
-       addsignat(t)
+       NeedRuntimeType(t)
        signatmu.Unlock()
 
        //print("algsym: %s -> %+S\n", p, s);
@@ -987,116 +809,68 @@ func typesymprefix(prefix string, t *types.Type) *types.Sym {
        return s
 }
 
-func typenamesym(t *types.Type) *types.Sym {
+func TypeSym(t *types.Type) *types.Sym {
        if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
-               Fatalf("typenamesym %v", t)
+               base.Fatalf("TypeSym %v", t)
+       }
+       if t.Kind() == types.TFUNC && t.Recv() != nil {
+               base.Fatalf("misuse of method type: %v", t)
        }
-       s := typesym(t)
+       s := types.TypeSym(t)
        signatmu.Lock()
-       addsignat(t)
+       NeedRuntimeType(t)
        signatmu.Unlock()
        return s
 }
 
-func typename(t *types.Type) *Node {
-       s := typenamesym(t)
-       if s.Def == nil {
-               n := newnamel(src.NoXPos, s)
-               n.Type = types.Types[TUINT8]
-               n.SetClass(PEXTERN)
-               n.SetTypecheck(1)
-               s.Def = asTypesNode(n)
-       }
-
-       n := nod(OADDR, asNode(s.Def), nil)
-       n.Type = types.NewPtr(asNode(s.Def).Type)
-       n.SetTypecheck(1)
-       return n
+func TypeLinksymPrefix(prefix string, t *types.Type) *obj.LSym {
+       return TypeSymPrefix(prefix, t).Linksym()
 }
 
-func itabname(t, itype *types.Type) *Node {
-       if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
-               Fatalf("itabname(%v, %v)", t, itype)
-       }
-       s := itabpkg.Lookup(t.ShortString() + "," + itype.ShortString())
-       if s.Def == nil {
-               n := newname(s)
-               n.Type = types.Types[TUINT8]
-               n.SetClass(PEXTERN)
-               n.SetTypecheck(1)
-               s.Def = asTypesNode(n)
-               itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
-       }
-
-       n := nod(OADDR, asNode(s.Def), nil)
-       n.Type = types.NewPtr(asNode(s.Def).Type)
-       n.SetTypecheck(1)
-       return n
+func TypeLinksymLookup(name string) *obj.LSym {
+       return types.TypeSymLookup(name).Linksym()
 }
 
-// isreflexive reports whether t has a reflexive equality operator.
-// That is, if x==x for all x of type t.
-func isreflexive(t *types.Type) bool {
-       switch t.Etype {
-       case TBOOL,
-               TINT,
-               TUINT,
-               TINT8,
-               TUINT8,
-               TINT16,
-               TUINT16,
-               TINT32,
-               TUINT32,
-               TINT64,
-               TUINT64,
-               TUINTPTR,
-               TPTR,
-               TUNSAFEPTR,
-               TSTRING,
-               TCHAN:
-               return true
-
-       case TFLOAT32,
-               TFLOAT64,
-               TCOMPLEX64,
-               TCOMPLEX128,
-               TINTER:
-               return false
-
-       case TARRAY:
-               return isreflexive(t.Elem())
+func TypeLinksym(t *types.Type) *obj.LSym {
+       return TypeSym(t).Linksym()
+}
 
-       case TSTRUCT:
-               for _, t1 := range t.Fields().Slice() {
-                       if !isreflexive(t1.Type) {
-                               return false
-                       }
-               }
-               return true
+func TypePtr(t *types.Type) *ir.AddrExpr {
+       n := ir.NewLinksymExpr(base.Pos, TypeLinksym(t), types.Types[types.TUINT8])
+       return typecheck.Expr(typecheck.NodAddr(n)).(*ir.AddrExpr)
+}
 
-       default:
-               Fatalf("bad type for map key: %v", t)
-               return false
+func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
+       if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
+               base.Fatalf("ITabAddr(%v, %v)", t, itype)
+       }
+       s, existed := ir.Pkgs.Itab.LookupOK(t.ShortString() + "," + itype.ShortString())
+       if !existed {
+               itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
        }
+
+       lsym := s.Linksym()
+       n := ir.NewLinksymExpr(base.Pos, lsym, types.Types[types.TUINT8])
+       return typecheck.Expr(typecheck.NodAddr(n)).(*ir.AddrExpr)
 }
 
 // needkeyupdate reports whether map updates with t as a key
 // need the key to be updated.
 func needkeyupdate(t *types.Type) bool {
-       switch t.Etype {
-       case TBOOL, TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32,
-               TINT64, TUINT64, TUINTPTR, TPTR, TUNSAFEPTR, TCHAN:
+       switch t.Kind() {
+       case types.TBOOL, types.TINT, types.TUINT, types.TINT8, types.TUINT8, types.TINT16, types.TUINT16, types.TINT32, types.TUINT32,
+               types.TINT64, types.TUINT64, types.TUINTPTR, types.TPTR, types.TUNSAFEPTR, types.TCHAN:
                return false
 
-       case TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, // floats and complex can be +0/-0
-               TINTER,
-               TSTRING: // strings might have smaller backing stores
+       case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128, // floats and complex can be +0/-0
+               types.TINTER,
+               types.TSTRING: // strings might have smaller backing stores
                return true
 
-       case TARRAY:
+       case types.TARRAY:
                return needkeyupdate(t.Elem())
 
-       case TSTRUCT:
+       case types.TSTRUCT:
                for _, t1 := range t.Fields().Slice() {
                        if needkeyupdate(t1.Type) {
                                return true
@@ -1105,21 +879,21 @@ func needkeyupdate(t *types.Type) bool {
                return false
 
        default:
-               Fatalf("bad type for map key: %v", t)
+               base.Fatalf("bad type for map key: %v", t)
                return true
        }
 }
 
 // hashMightPanic reports whether the hash of a map key of type t might panic.
 func hashMightPanic(t *types.Type) bool {
-       switch t.Etype {
-       case TINTER:
+       switch t.Kind() {
+       case types.TINTER:
                return true
 
-       case TARRAY:
+       case types.TARRAY:
                return hashMightPanic(t.Elem())
 
-       case TSTRUCT:
+       case types.TSTRUCT:
                for _, t1 := range t.Fields().Slice() {
                        if hashMightPanic(t1.Type) {
                                return true
@@ -1136,19 +910,19 @@ func hashMightPanic(t *types.Type) bool {
 // They've been separate internally to make error messages
 // better, but we have to merge them in the reflect tables.
 func formalType(t *types.Type) *types.Type {
-       if t == types.Bytetype || t == types.Runetype {
-               return types.Types[t.Etype]
+       if t == types.ByteType || t == types.RuneType {
+               return types.Types[t.Kind()]
        }
        return t
 }
 
-func dtypesym(t *types.Type) *obj.LSym {
+func writeType(t *types.Type) *obj.LSym {
        t = formalType(t)
        if t.IsUntyped() {
-               Fatalf("dtypesym %v", t)
+               base.Fatalf("writeType %v", t)
        }
 
-       s := typesym(t)
+       s := types.TypeSym(t)
        lsym := s.Linksym()
        if s.Siggen() {
                return lsym
@@ -1160,77 +934,73 @@ func dtypesym(t *types.Type) *obj.LSym {
        // emit the type structures for int, float, etc.
        tbase := t
 
-       if t.IsPtr() && t.Sym == nil && t.Elem().Sym != nil {
+       if t.IsPtr() && t.Sym() == nil && t.Elem().Sym() != nil {
                tbase = t.Elem()
        }
        dupok := 0
-       if tbase.Sym == nil {
+       if tbase.Sym() == nil {
                dupok = obj.DUPOK
        }
 
-       if myimportpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
+       if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Kind()] && tbase != types.ByteType && tbase != types.RuneType && tbase != types.ErrorType) { // int, float, etc
                // named types from other files are defined only by those files
-               if tbase.Sym != nil && tbase.Sym.Pkg != localpkg {
-                       if i, ok := typeSymIdx[tbase]; ok {
-                               lsym.Pkg = tbase.Sym.Pkg.Prefix
-                               if t != tbase {
-                                       lsym.SymIdx = int32(i[1])
-                               } else {
-                                       lsym.SymIdx = int32(i[0])
-                               }
+               if tbase.Sym() != nil && tbase.Sym().Pkg != types.LocalPkg {
+                       if i := typecheck.BaseTypeIndex(t); i >= 0 {
+                               lsym.Pkg = tbase.Sym().Pkg.Prefix
+                               lsym.SymIdx = int32(i)
                                lsym.Set(obj.AttrIndexed, true)
                        }
                        return lsym
                }
                // TODO(mdempsky): Investigate whether this can happen.
-               if tbase.Etype == TFORW {
+               if tbase.Kind() == types.TFORW {
                        return lsym
                }
        }
 
        ot := 0
-       switch t.Etype {
+       switch t.Kind() {
        default:
                ot = dcommontype(lsym, t)
                ot = dextratype(lsym, ot, t, 0)
 
-       case TARRAY:
+       case types.TARRAY:
                // ../../../../runtime/type.go:/arrayType
-               s1 := dtypesym(t.Elem())
+               s1 := writeType(t.Elem())
                t2 := types.NewSlice(t.Elem())
-               s2 := dtypesym(t2)
+               s2 := writeType(t2)
                ot = dcommontype(lsym, t)
-               ot = dsymptr(lsym, ot, s1, 0)
-               ot = dsymptr(lsym, ot, s2, 0)
-               ot = duintptr(lsym, ot, uint64(t.NumElem()))
+               ot = objw.SymPtr(lsym, ot, s1, 0)
+               ot = objw.SymPtr(lsym, ot, s2, 0)
+               ot = objw.Uintptr(lsym, ot, uint64(t.NumElem()))
                ot = dextratype(lsym, ot, t, 0)
 
-       case TSLICE:
+       case types.TSLICE:
                // ../../../../runtime/type.go:/sliceType
-               s1 := dtypesym(t.Elem())
+               s1 := writeType(t.Elem())
                ot = dcommontype(lsym, t)
-               ot = dsymptr(lsym, ot, s1, 0)
+               ot = objw.SymPtr(lsym, ot, s1, 0)
                ot = dextratype(lsym, ot, t, 0)
 
-       case TCHAN:
+       case types.TCHAN:
                // ../../../../runtime/type.go:/chanType
-               s1 := dtypesym(t.Elem())
+               s1 := writeType(t.Elem())
                ot = dcommontype(lsym, t)
-               ot = dsymptr(lsym, ot, s1, 0)
-               ot = duintptr(lsym, ot, uint64(t.ChanDir()))
+               ot = objw.SymPtr(lsym, ot, s1, 0)
+               ot = objw.Uintptr(lsym, ot, uint64(t.ChanDir()))
                ot = dextratype(lsym, ot, t, 0)
 
-       case TFUNC:
+       case types.TFUNC:
                for _, t1 := range t.Recvs().Fields().Slice() {
-                       dtypesym(t1.Type)
+                       writeType(t1.Type)
                }
                isddd := false
                for _, t1 := range t.Params().Fields().Slice() {
                        isddd = t1.IsDDD()
-                       dtypesym(t1.Type)
+                       writeType(t1.Type)
                }
                for _, t1 := range t.Results().Fields().Slice() {
-                       dtypesym(t1.Type)
+                       writeType(t1.Type)
                }
 
                ot = dcommontype(lsym, t)
@@ -1239,45 +1009,45 @@ func dtypesym(t *types.Type) *obj.LSym {
                if isddd {
                        outCount |= 1 << 15
                }
-               ot = duint16(lsym, ot, uint16(inCount))
-               ot = duint16(lsym, ot, uint16(outCount))
-               if Widthptr == 8 {
+               ot = objw.Uint16(lsym, ot, uint16(inCount))
+               ot = objw.Uint16(lsym, ot, uint16(outCount))
+               if types.PtrSize == 8 {
                        ot += 4 // align for *rtype
                }
 
-               dataAdd := (inCount + t.NumResults()) * Widthptr
+               dataAdd := (inCount + t.NumResults()) * types.PtrSize
                ot = dextratype(lsym, ot, t, dataAdd)
 
                // Array of rtype pointers follows funcType.
                for _, t1 := range t.Recvs().Fields().Slice() {
-                       ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+                       ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
                }
                for _, t1 := range t.Params().Fields().Slice() {
-                       ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+                       ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
                }
                for _, t1 := range t.Results().Fields().Slice() {
-                       ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+                       ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
                }
 
-       case TINTER:
+       case types.TINTER:
                m := imethods(t)
                n := len(m)
                for _, a := range m {
-                       dtypesym(a.type_)
+                       writeType(a.type_)
                }
 
                // ../../../../runtime/type.go:/interfaceType
                ot = dcommontype(lsym, t)
 
                var tpkg *types.Pkg
-               if t.Sym != nil && t != types.Types[t.Etype] && t != types.Errortype {
-                       tpkg = t.Sym.Pkg
+               if t.Sym() != nil && t != types.Types[t.Kind()] && t != types.ErrorType {
+                       tpkg = t.Sym().Pkg
                }
                ot = dgopkgpath(lsym, ot, tpkg)
 
-               ot = dsymptr(lsym, ot, lsym, ot+3*Widthptr+uncommonSize(t))
-               ot = duintptr(lsym, ot, uint64(n))
-               ot = duintptr(lsym, ot, uint64(n))
+               ot = objw.SymPtr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
+               ot = objw.Uintptr(lsym, ot, uint64(n))
+               ot = objw.Uintptr(lsym, ot, uint64(n))
                dataAdd := imethodSize() * n
                ot = dextratype(lsym, ot, t, dataAdd)
 
@@ -1290,40 +1060,40 @@ func dtypesym(t *types.Type) *obj.LSym {
                        }
                        nsym := dname(a.name.Name, "", pkg, exported)
 
-                       ot = dsymptrOff(lsym, ot, nsym)
-                       ot = dsymptrOff(lsym, ot, dtypesym(a.type_))
+                       ot = objw.SymPtrOff(lsym, ot, nsym)
+                       ot = objw.SymPtrOff(lsym, ot, writeType(a.type_))
                }
 
        // ../../../../runtime/type.go:/mapType
-       case TMAP:
-               s1 := dtypesym(t.Key())
-               s2 := dtypesym(t.Elem())
-               s3 := dtypesym(bmap(t))
+       case types.TMAP:
+               s1 := writeType(t.Key())
+               s2 := writeType(t.Elem())
+               s3 := writeType(MapBucketType(t))
                hasher := genhash(t.Key())
 
                ot = dcommontype(lsym, t)
-               ot = dsymptr(lsym, ot, s1, 0)
-               ot = dsymptr(lsym, ot, s2, 0)
-               ot = dsymptr(lsym, ot, s3, 0)
-               ot = dsymptr(lsym, ot, hasher, 0)
+               ot = objw.SymPtr(lsym, ot, s1, 0)
+               ot = objw.SymPtr(lsym, ot, s2, 0)
+               ot = objw.SymPtr(lsym, ot, s3, 0)
+               ot = objw.SymPtr(lsym, ot, hasher, 0)
                var flags uint32
                // Note: flags must match maptype accessors in ../../../../runtime/type.go
                // and maptype builder in ../../../../reflect/type.go:MapOf.
                if t.Key().Width > MAXKEYSIZE {
-                       ot = duint8(lsym, ot, uint8(Widthptr))
+                       ot = objw.Uint8(lsym, ot, uint8(types.PtrSize))
                        flags |= 1 // indirect key
                } else {
-                       ot = duint8(lsym, ot, uint8(t.Key().Width))
+                       ot = objw.Uint8(lsym, ot, uint8(t.Key().Width))
                }
 
                if t.Elem().Width > MAXELEMSIZE {
-                       ot = duint8(lsym, ot, uint8(Widthptr))
+                       ot = objw.Uint8(lsym, ot, uint8(types.PtrSize))
                        flags |= 2 // indirect value
                } else {
-                       ot = duint8(lsym, ot, uint8(t.Elem().Width))
+                       ot = objw.Uint8(lsym, ot, uint8(t.Elem().Width))
                }
-               ot = duint16(lsym, ot, uint16(bmap(t).Width))
-               if isreflexive(t.Key()) {
+               ot = objw.Uint16(lsym, ot, uint16(MapBucketType(t).Width))
+               if types.IsReflexive(t.Key()) {
                        flags |= 4 // reflexive key
                }
                if needkeyupdate(t.Key()) {
@@ -1332,11 +1102,11 @@ func dtypesym(t *types.Type) *obj.LSym {
                if hashMightPanic(t.Key()) {
                        flags |= 16 // hash might panic
                }
-               ot = duint32(lsym, ot, flags)
+               ot = objw.Uint32(lsym, ot, flags)
                ot = dextratype(lsym, ot, t, 0)
 
-       case TPTR:
-               if t.Elem().Etype == TANY {
+       case types.TPTR:
+               if t.Elem().Kind() == types.TANY {
                        // ../../../../runtime/type.go:/UnsafePointerType
                        ot = dcommontype(lsym, t)
                        ot = dextratype(lsym, ot, t, 0)
@@ -1345,18 +1115,18 @@ func dtypesym(t *types.Type) *obj.LSym {
                }
 
                // ../../../../runtime/type.go:/ptrType
-               s1 := dtypesym(t.Elem())
+               s1 := writeType(t.Elem())
 
                ot = dcommontype(lsym, t)
-               ot = dsymptr(lsym, ot, s1, 0)
+               ot = objw.SymPtr(lsym, ot, s1, 0)
                ot = dextratype(lsym, ot, t, 0)
 
        // ../../../../runtime/type.go:/structType
        // for security, only the exported fields.
-       case TSTRUCT:
+       case types.TSTRUCT:
                fields := t.Fields().Slice()
                for _, t1 := range fields {
-                       dtypesym(t1.Type)
+                       writeType(t1.Type)
                }
 
                // All non-exported struct field names within a struct
@@ -1374,9 +1144,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 
                ot = dcommontype(lsym, t)
                ot = dgopkgpath(lsym, ot, spkg)
-               ot = dsymptr(lsym, ot, lsym, ot+3*Widthptr+uncommonSize(t))
-               ot = duintptr(lsym, ot, uint64(len(fields)))
-               ot = duintptr(lsym, ot, uint64(len(fields)))
+               ot = objw.SymPtr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
+               ot = objw.Uintptr(lsym, ot, uint64(len(fields)))
+               ot = objw.Uintptr(lsym, ot, uint64(len(fields)))
 
                dataAdd := len(fields) * structfieldSize()
                ot = dextratype(lsym, ot, t, dataAdd)
@@ -1384,40 +1154,40 @@ func dtypesym(t *types.Type) *obj.LSym {
                for _, f := range fields {
                        // ../../../../runtime/type.go:/structField
                        ot = dnameField(lsym, ot, spkg, f)
-                       ot = dsymptr(lsym, ot, dtypesym(f.Type), 0)
+                       ot = objw.SymPtr(lsym, ot, writeType(f.Type), 0)
                        offsetAnon := uint64(f.Offset) << 1
                        if offsetAnon>>1 != uint64(f.Offset) {
-                               Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
+                               base.Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
                        }
                        if f.Embedded != 0 {
                                offsetAnon |= 1
                        }
-                       ot = duintptr(lsym, ot, offsetAnon)
+                       ot = objw.Uintptr(lsym, ot, offsetAnon)
                }
        }
 
        ot = dextratypeData(lsym, ot, t)
-       ggloblsym(lsym, int32(ot), int16(dupok|obj.RODATA))
+       objw.Global(lsym, int32(ot), int16(dupok|obj.RODATA))
 
        // The linker will leave a table of all the typelinks for
        // types in the binary, so the runtime can find them.
        //
        // When buildmode=shared, all types are in typelinks so the
        // runtime can deduplicate type pointers.
-       keep := Ctxt.Flag_dynlink
-       if !keep && t.Sym == nil {
+       keep := base.Ctxt.Flag_dynlink
+       if !keep && t.Sym() == nil {
                // For an unnamed type, we only need the link if the type can
                // be created at run time by reflect.PtrTo and similar
                // functions. If the type exists in the program, those
                // functions must return the existing type structure rather
                // than creating a new one.
-               switch t.Etype {
-               case TPTR, TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRUCT:
+               switch t.Kind() {
+               case types.TPTR, types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRUCT:
                        keep = true
                }
        }
        // Do not put Noalg types in typelinks.  See issue #22605.
-       if typeHasNoAlg(t) {
+       if types.TypeHasNoAlg(t) {
                keep = false
        }
        lsym.Set(obj.AttrMakeTypelink, keep)
@@ -1425,9 +1195,9 @@ func dtypesym(t *types.Type) *obj.LSym {
        return lsym
 }
 
-// ifaceMethodOffset returns the offset of the i-th method in the interface
+// InterfaceMethodOffset returns the offset of the i-th method in the interface
 // type descriptor, ityp.
-func ifaceMethodOffset(ityp *types.Type, i int64) int64 {
+func InterfaceMethodOffset(ityp *types.Type, i int64) int64 {
        // interface type descriptor layout is struct {
        //   _type        // commonSize
        //   pkgpath      // 1 word
@@ -1436,12 +1206,12 @@ func ifaceMethodOffset(ityp *types.Type, i int64) int64 {
        //   [...]imethod
        // }
        // The size of imethod is 8.
-       return int64(commonSize()+4*Widthptr+uncommonSize(ityp)) + i*8
+       return int64(commonSize()+4*types.PtrSize+uncommonSize(ityp)) + i*8
 }
 
 // for each itabEntry, gather the methods on
 // the concrete type that implement the interface
-func peekitabs() {
+func CompileITabs() {
        for i := range itabs {
                tab := &itabs[i]
                methods := genfun(tab.t, tab.itype)
@@ -1472,7 +1242,7 @@ func genfun(t, it *types.Type) []*obj.LSym {
        // so we can find the intersect in a single pass
        for _, m := range methods {
                if m.name == sigs[0].name {
-                       out = append(out, m.isym.Linksym())
+                       out = append(out, m.isym)
                        sigs = sigs[1:]
                        if len(sigs) == 0 {
                                break
@@ -1481,17 +1251,17 @@ func genfun(t, it *types.Type) []*obj.LSym {
        }
 
        if len(sigs) != 0 {
-               Fatalf("incomplete itab")
+               base.Fatalf("incomplete itab")
        }
 
        return out
 }
 
-// itabsym uses the information gathered in
-// peekitabs to de-virtualize interface methods.
+// ITabSym uses the information gathered in
+// CompileITabs to de-virtualize interface methods.
 // Since this is called by the SSA backend, it shouldn't
 // generate additional Nodes, Syms, etc.
-func itabsym(it *obj.LSym, offset int64) *obj.LSym {
+func ITabSym(it *obj.LSym, offset int64) *obj.LSym {
        var syms []*obj.LSym
        if it == nil {
                return nil
@@ -1509,54 +1279,45 @@ func itabsym(it *obj.LSym, offset int64) *obj.LSym {
        }
 
        // keep this arithmetic in sync with *itab layout
-       methodnum := int((offset - 2*int64(Widthptr) - 8) / int64(Widthptr))
+       methodnum := int((offset - 2*int64(types.PtrSize) - 8) / int64(types.PtrSize))
        if methodnum >= len(syms) {
                return nil
        }
        return syms[methodnum]
 }
 
-// addsignat ensures that a runtime type descriptor is emitted for t.
-func addsignat(t *types.Type) {
+// NeedRuntimeType ensures that a runtime type descriptor is emitted for t.
+func NeedRuntimeType(t *types.Type) {
        if _, ok := signatset[t]; !ok {
                signatset[t] = struct{}{}
                signatslice = append(signatslice, t)
        }
 }
 
-func addsignats(dcls []*Node) {
-       // copy types from dcl list to signatset
-       for _, n := range dcls {
-               if n.Op == OTYPE {
-                       addsignat(n.Type)
-               }
-       }
-}
-
-func dumpsignats() {
-       // Process signatset. Use a loop, as dtypesym adds
+func WriteRuntimeTypes() {
+       // Process signatset. Use a loop, as writeType adds
        // entries to signatset while it is being processed.
        signats := make([]typeAndStr, len(signatslice))
        for len(signatslice) > 0 {
                signats = signats[:0]
                // Transfer entries to a slice and sort, for reproducible builds.
                for _, t := range signatslice {
-                       signats = append(signats, typeAndStr{t: t, short: typesymname(t), regular: t.String()})
+                       signats = append(signats, typeAndStr{t: t, short: types.TypeSymName(t), regular: t.String()})
                        delete(signatset, t)
                }
                signatslice = signatslice[:0]
                sort.Sort(typesByString(signats))
                for _, ts := range signats {
                        t := ts.t
-                       dtypesym(t)
-                       if t.Sym != nil {
-                               dtypesym(types.NewPtr(t))
+                       writeType(t)
+                       if t.Sym() != nil {
+                               writeType(types.NewPtr(t))
                        }
                }
        }
 }
 
-func dumptabs() {
+func WriteTabs() {
        // process itabs
        for _, i := range itabs {
                // dump empty itab symbol into i.sym
@@ -1567,22 +1328,22 @@ func dumptabs() {
                //   _      [4]byte
                //   fun    [1]uintptr // variable sized
                // }
-               o := dsymptr(i.lsym, 0, dtypesym(i.itype), 0)
-               o = dsymptr(i.lsym, o, dtypesym(i.t), 0)
-               o = duint32(i.lsym, o, typehash(i.t)) // copy of type hash
-               o += 4                                // skip unused field
+               o := objw.SymPtr(i.lsym, 0, writeType(i.itype), 0)
+               o = objw.SymPtr(i.lsym, o, writeType(i.t), 0)
+               o = objw.Uint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
+               o += 4                                          // skip unused field
                for _, fn := range genfun(i.t, i.itype) {
-                       o = dsymptr(i.lsym, o, fn, 0) // method pointer for each method
+                       o = objw.SymPtr(i.lsym, o, fn, 0) // method pointer for each method
                }
                // Nothing writes static itabs, so they are read only.
-               ggloblsym(i.lsym, int32(o), int16(obj.DUPOK|obj.RODATA))
+               objw.Global(i.lsym, int32(o), int16(obj.DUPOK|obj.RODATA))
                i.lsym.Set(obj.AttrContentAddressable, true)
        }
 
        // process ptabs
-       if localpkg.Name == "main" && len(ptabs) > 0 {
+       if types.LocalPkg.Name == "main" && len(ptabs) > 0 {
                ot := 0
-               s := Ctxt.Lookup("go.plugin.tabs")
+               s := base.Ctxt.Lookup("go.plugin.tabs")
                for _, p := range ptabs {
                        // Dump ptab symbol into go.pluginsym package.
                        //
@@ -1590,61 +1351,70 @@ func dumptabs() {
                        //      name nameOff
                        //      typ  typeOff // pointer to symbol
                        // }
-                       nsym := dname(p.s.Name, "", nil, true)
-                       tsym := dtypesym(p.t)
-                       ot = dsymptrOff(s, ot, nsym)
-                       ot = dsymptrOff(s, ot, tsym)
+                       nsym := dname(p.Sym().Name, "", nil, true)
+                       t := p.Type()
+                       if p.Class != ir.PFUNC {
+                               t = types.NewPtr(t)
+                       }
+                       tsym := writeType(t)
+                       ot = objw.SymPtrOff(s, ot, nsym)
+                       ot = objw.SymPtrOff(s, ot, tsym)
                        // Plugin exports symbols as interfaces. Mark their types
                        // as UsedInIface.
                        tsym.Set(obj.AttrUsedInIface, true)
                }
-               ggloblsym(s, int32(ot), int16(obj.RODATA))
+               objw.Global(s, int32(ot), int16(obj.RODATA))
 
                ot = 0
-               s = Ctxt.Lookup("go.plugin.exports")
+               s = base.Ctxt.Lookup("go.plugin.exports")
                for _, p := range ptabs {
-                       ot = dsymptr(s, ot, p.s.Linksym(), 0)
+                       ot = objw.SymPtr(s, ot, p.Linksym(), 0)
                }
-               ggloblsym(s, int32(ot), int16(obj.RODATA))
+               objw.Global(s, int32(ot), int16(obj.RODATA))
        }
 }
 
-func dumpimportstrings() {
+func WriteImportStrings() {
        // generate import strings for imported packages
        for _, p := range types.ImportedPkgList() {
                dimportpath(p)
        }
 }
 
-func dumpbasictypes() {
+func WriteBasicTypes() {
        // do basic types if compiling package runtime.
        // they have to be in at least one package,
        // and runtime is always loaded implicitly,
        // so this is as good as any.
        // another possible choice would be package main,
        // but using runtime means fewer copies in object files.
-       if myimportpath == "runtime" {
-               for i := types.EType(1); i <= TBOOL; i++ {
-                       dtypesym(types.NewPtr(types.Types[i]))
+       if base.Ctxt.Pkgpath == "runtime" {
+               for i := types.Kind(1); i <= types.TBOOL; i++ {
+                       writeType(types.NewPtr(types.Types[i]))
                }
-               dtypesym(types.NewPtr(types.Types[TSTRING]))
-               dtypesym(types.NewPtr(types.Types[TUNSAFEPTR]))
+               writeType(types.NewPtr(types.Types[types.TSTRING]))
+               writeType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
 
                // emit type structs for error and func(error) string.
                // The latter is the type of an auto-generated wrapper.
-               dtypesym(types.NewPtr(types.Errortype))
+               writeType(types.NewPtr(types.ErrorType))
 
-               dtypesym(functype(nil, []*Node{anonfield(types.Errortype)}, []*Node{anonfield(types.Types[TSTRING])}))
+               writeType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+                       types.NewField(base.Pos, nil, types.ErrorType),
+               }, []*types.Field{
+                       types.NewField(base.Pos, nil, types.Types[types.TSTRING]),
+               }))
 
                // add paths for runtime and main, which 6l imports implicitly.
-               dimportpath(Runtimepkg)
+               dimportpath(ir.Pkgs.Runtime)
 
-               if flag_race {
-                       dimportpath(racepkg)
+               if base.Flag.Race {
+                       dimportpath(types.NewPkg("runtime/race", ""))
                }
-               if flag_msan {
-                       dimportpath(msanpkg)
+               if base.Flag.MSan {
+                       dimportpath(types.NewPkg("runtime/msan", ""))
                }
+
                dimportpath(types.NewPkg("main", ""))
        }
 }
@@ -1673,7 +1443,7 @@ func (a typesByString) Less(i, j int) bool {
        // will be equal for the above checks, but different in DWARF output.
        // Sort by source position to ensure deterministic order.
        // See issues 27013 and 30202.
-       if a[i].t.Etype == types.TINTER && a[i].t.Methods().Len() > 0 {
+       if a[i].t.Kind() == types.TINTER && a[i].t.Methods().Len() > 0 {
                return a[i].t.Methods().Index(0).Pos.Before(a[j].t.Methods().Index(0).Pos)
        }
        return false
@@ -1718,8 +1488,8 @@ const maxPtrmaskBytes = 2048
 // along with a boolean reporting whether the UseGCProg bit should be set in
 // the type kind, and the ptrdata field to record in the reflect type information.
 func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
-       ptrdata = typeptrdata(t)
-       if ptrdata/int64(Widthptr) <= maxPtrmaskBytes*8 {
+       ptrdata = types.PtrDataSize(t)
+       if ptrdata/int64(types.PtrSize) <= maxPtrmaskBytes*8 {
                lsym = dgcptrmask(t)
                return
        }
@@ -1731,18 +1501,18 @@ func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
 
 // dgcptrmask emits and returns the symbol containing a pointer mask for type t.
 func dgcptrmask(t *types.Type) *obj.LSym {
-       ptrmask := make([]byte, (typeptrdata(t)/int64(Widthptr)+7)/8)
+       ptrmask := make([]byte, (types.PtrDataSize(t)/int64(types.PtrSize)+7)/8)
        fillptrmask(t, ptrmask)
        p := fmt.Sprintf("gcbits.%x", ptrmask)
 
-       sym := Runtimepkg.Lookup(p)
+       sym := ir.Pkgs.Runtime.Lookup(p)
        lsym := sym.Linksym()
        if !sym.Uniq() {
                sym.SetUniq(true)
                for i, x := range ptrmask {
-                       duint8(lsym, i, x)
+                       objw.Uint8(lsym, i, x)
                }
-               ggloblsym(lsym, int32(len(ptrmask)), obj.DUPOK|obj.RODATA|obj.LOCAL)
+               objw.Global(lsym, int32(len(ptrmask)), obj.DUPOK|obj.RODATA|obj.LOCAL)
                lsym.Set(obj.AttrContentAddressable, true)
        }
        return lsym
@@ -1759,10 +1529,10 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
                return
        }
 
-       vec := bvalloc(8 * int32(len(ptrmask)))
-       onebitwalktype1(t, 0, vec)
+       vec := bitvec.New(8 * int32(len(ptrmask)))
+       typebits.Set(t, 0, vec)
 
-       nptr := typeptrdata(t) / int64(Widthptr)
+       nptr := types.PtrDataSize(t) / int64(types.PtrSize)
        for i := int64(0); i < nptr; i++ {
                if vec.Get(int32(i)) {
                        ptrmask[i/8] |= 1 << (uint(i) % 8)
@@ -1775,80 +1545,78 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 // In practice, the size is typeptrdata(t) except for non-trivial arrays.
 // For non-trivial arrays, the program describes the full t.Width size.
 func dgcprog(t *types.Type) (*obj.LSym, int64) {
-       dowidth(t)
-       if t.Width == BADWIDTH {
-               Fatalf("dgcprog: %v badwidth", t)
+       types.CalcSize(t)
+       if t.Width == types.BADWIDTH {
+               base.Fatalf("dgcprog: %v badwidth", t)
        }
-       lsym := typesymprefix(".gcprog", t).Linksym()
-       var p GCProg
+       lsym := TypeLinksymPrefix(".gcprog", t)
+       var p gcProg
        p.init(lsym)
        p.emit(t, 0)
-       offset := p.w.BitIndex() * int64(Widthptr)
+       offset := p.w.BitIndex() * int64(types.PtrSize)
        p.end()
-       if ptrdata := typeptrdata(t); offset < ptrdata || offset > t.Width {
-               Fatalf("dgcprog: %v: offset=%d but ptrdata=%d size=%d", t, offset, ptrdata, t.Width)
+       if ptrdata := types.PtrDataSize(t); offset < ptrdata || offset > t.Width {
+               base.Fatalf("dgcprog: %v: offset=%d but ptrdata=%d size=%d", t, offset, ptrdata, t.Width)
        }
        return lsym, offset
 }
 
-type GCProg struct {
+type gcProg struct {
        lsym   *obj.LSym
        symoff int
        w      gcprog.Writer
 }
 
-var Debug_gcprog int // set by -d gcprog
-
-func (p *GCProg) init(lsym *obj.LSym) {
+func (p *gcProg) init(lsym *obj.LSym) {
        p.lsym = lsym
        p.symoff = 4 // first 4 bytes hold program length
        p.w.Init(p.writeByte)
-       if Debug_gcprog > 0 {
+       if base.Debug.GCProg > 0 {
                fmt.Fprintf(os.Stderr, "compile: start GCProg for %v\n", lsym)
                p.w.Debug(os.Stderr)
        }
 }
 
-func (p *GCProg) writeByte(x byte) {
-       p.symoff = duint8(p.lsym, p.symoff, x)
+func (p *gcProg) writeByte(x byte) {
+       p.symoff = objw.Uint8(p.lsym, p.symoff, x)
 }
 
-func (p *GCProg) end() {
+func (p *gcProg) end() {
        p.w.End()
-       duint32(p.lsym, 0, uint32(p.symoff-4))
-       ggloblsym(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
-       if Debug_gcprog > 0 {
+       objw.Uint32(p.lsym, 0, uint32(p.symoff-4))
+       objw.Global(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
+       if base.Debug.GCProg > 0 {
                fmt.Fprintf(os.Stderr, "compile: end GCProg for %v\n", p.lsym)
        }
 }
 
-func (p *GCProg) emit(t *types.Type, offset int64) {
-       dowidth(t)
+func (p *gcProg) emit(t *types.Type, offset int64) {
+       types.CalcSize(t)
        if !t.HasPointers() {
                return
        }
-       if t.Width == int64(Widthptr) {
-               p.w.Ptr(offset / int64(Widthptr))
+       if t.Width == int64(types.PtrSize) {
+               p.w.Ptr(offset / int64(types.PtrSize))
                return
        }
-       switch t.Etype {
+       switch t.Kind() {
        default:
-               Fatalf("GCProg.emit: unexpected type %v", t)
+               base.Fatalf("gcProg.emit: unexpected type %v", t)
 
-       case TSTRING:
-               p.w.Ptr(offset / int64(Widthptr))
+       case types.TSTRING:
+               p.w.Ptr(offset / int64(types.PtrSize))
 
-       case TINTER:
-               // Note: the first word isn't a pointer. See comment in plive.go:onebitwalktype1.
-               p.w.Ptr(offset/int64(Widthptr) + 1)
+       case types.TINTER:
+               // Note: the first word isn't a pointer. See comment in typebits.Set
+               p.w.Ptr(offset/int64(types.PtrSize) + 1)
 
-       case TSLICE:
-               p.w.Ptr(offset / int64(Widthptr))
+       case types.TSLICE:
+               p.w.Ptr(offset / int64(types.PtrSize))
 
-       case TARRAY:
+       case types.TARRAY:
                if t.NumElem() == 0 {
                        // should have been handled by haspointers check above
-                       Fatalf("GCProg.emit: empty array")
+                       base.Fatalf("gcProg.emit: empty array")
                }
 
                // Flatten array-of-array-of-array to just a big array by multiplying counts.
@@ -1859,7 +1627,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
                        elem = elem.Elem()
                }
 
-               if !p.w.ShouldRepeat(elem.Width/int64(Widthptr), count) {
+               if !p.w.ShouldRepeat(elem.Width/int64(types.PtrSize), count) {
                        // Cheaper to just emit the bits.
                        for i := int64(0); i < count; i++ {
                                p.emit(elem, offset+i*elem.Width)
@@ -1867,35 +1635,202 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
                        return
                }
                p.emit(elem, offset)
-               p.w.ZeroUntil((offset + elem.Width) / int64(Widthptr))
-               p.w.Repeat(elem.Width/int64(Widthptr), count-1)
+               p.w.ZeroUntil((offset + elem.Width) / int64(types.PtrSize))
+               p.w.Repeat(elem.Width/int64(types.PtrSize), count-1)
 
-       case TSTRUCT:
+       case types.TSTRUCT:
                for _, t1 := range t.Fields().Slice() {
                        p.emit(t1.Type, offset+t1.Offset)
                }
        }
 }
 
-// zeroaddr returns the address of a symbol with at least
+// ZeroAddr returns the address of a symbol with at least
 // size bytes of zeros.
-func zeroaddr(size int64) *Node {
+func ZeroAddr(size int64) ir.Node {
        if size >= 1<<31 {
-               Fatalf("map elem too big %d", size)
-       }
-       if zerosize < size {
-               zerosize = size
-       }
-       s := mappkg.Lookup("zero")
-       if s.Def == nil {
-               x := newname(s)
-               x.Type = types.Types[TUINT8]
-               x.SetClass(PEXTERN)
-               x.SetTypecheck(1)
-               s.Def = asTypesNode(x)
-       }
-       z := nod(OADDR, asNode(s.Def), nil)
-       z.Type = types.NewPtr(types.Types[TUINT8])
-       z.SetTypecheck(1)
-       return z
+               base.Fatalf("map elem too big %d", size)
+       }
+       if ZeroSize < size {
+               ZeroSize = size
+       }
+       lsym := base.PkgLinksym("go.map", "zero", obj.ABI0)
+       x := ir.NewLinksymExpr(base.Pos, lsym, types.Types[types.TUINT8])
+       return typecheck.Expr(typecheck.NodAddr(x))
+}
+
+func CollectPTabs() {
+       if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
+               return
+       }
+       for _, exportn := range typecheck.Target.Exports {
+               s := exportn.Sym()
+               nn := ir.AsNode(s.Def)
+               if nn == nil {
+                       continue
+               }
+               if nn.Op() != ir.ONAME {
+                       continue
+               }
+               n := nn.(*ir.Name)
+               if !types.IsExported(s.Name) {
+                       continue
+               }
+               if s.Pkg.Name != "main" {
+                       continue
+               }
+               ptabs = append(ptabs, n)
+       }
+}
+
+// Generate a wrapper function to convert from
+// a receiver of type T to a receiver of type U.
+// That is,
+//
+//     func (t T) M() {
+//             ...
+//     }
+//
+// already exists; this function generates
+//
+//     func (u U) M() {
+//             u.M()
+//     }
+//
+// where the types T and U are such that u.M() is valid
+// and calls the T.M method.
+// The resulting function is for use in method tables.
+//
+//     rcvr - U
+//     method - M func (t T)(), a TFIELD type struct
+func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
+       newnam := ir.MethodSym(rcvr, method.Sym)
+       lsym := newnam.Linksym()
+       if newnam.Siggen() {
+               return lsym
+       }
+       newnam.SetSiggen(true)
+
+       if types.Identical(rcvr, method.Type.Recv().Type) {
+               return lsym
+       }
+
+       // Only generate (*T).M wrappers for T.M in T's own package.
+       if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
+               rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != types.LocalPkg {
+               return lsym
+       }
+
+       // Only generate I.M wrappers for I in I's own package
+       // but keep doing it for error.Error (was issue #29304).
+       if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != types.LocalPkg && rcvr != types.ErrorType {
+               return lsym
+       }
+
+       base.Pos = base.AutogeneratedPos
+       typecheck.DeclContext = ir.PEXTERN
+
+       tfn := ir.NewFuncType(base.Pos,
+               ir.NewField(base.Pos, typecheck.Lookup(".this"), nil, rcvr),
+               typecheck.NewFuncParams(method.Type.Params(), true),
+               typecheck.NewFuncParams(method.Type.Results(), false))
+
+       fn := typecheck.DeclFunc(newnam, tfn)
+       fn.SetDupok(true)
+
+       nthis := ir.AsNode(tfn.Type().Recv().Nname)
+
+       methodrcvr := method.Type.Recv().Type
+
+       // generate nil pointer check for better error
+       if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
+               // generating wrapper from *T to T.
+               n := ir.NewIfStmt(base.Pos, nil, nil, nil)
+               n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
+               n.Body = []ir.Node{call}
+               fn.Body.Append(n)
+       }
+
+       dot := typecheck.AddImplicitDots(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
+
+       // generate call
+       // It's not possible to use a tail call when dynamic linking on ppc64le. The
+       // bad scenario is when a local call is made to the wrapper: the wrapper will
+       // call the implementation, which might be in a different module and so set
+       // the TOC to the appropriate value for that module. But if it returns
+       // directly to the wrapper's caller, nothing will reset it to the correct
+       // value for that function.
+       if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+               // generate tail call: adjust pointer receiver and jump to embedded method.
+               left := dot.X // skip final .M
+               if !left.Type().IsPtr() {
+                       left = typecheck.NodAddr(left)
+               }
+               as := ir.NewAssignStmt(base.Pos, nthis, typecheck.ConvNop(left, rcvr))
+               fn.Body.Append(as)
+               fn.Body.Append(ir.NewTailCallStmt(base.Pos, method.Nname.(*ir.Name)))
+       } else {
+               fn.SetWrapper(true) // ignore frame for panic+recover matching
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
+               call.Args = ir.ParamNames(tfn.Type())
+               call.IsDDD = tfn.Type().IsVariadic()
+               if method.Type.NumResults() > 0 {
+                       ret := ir.NewReturnStmt(base.Pos, nil)
+                       ret.Results = []ir.Node{call}
+                       fn.Body.Append(ret)
+               } else {
+                       fn.Body.Append(call)
+               }
+       }
+
+       typecheck.FinishFuncBody()
+       if base.Debug.DclStack != 0 {
+               types.CheckDclstack()
+       }
+
+       typecheck.Func(fn)
+       ir.CurFunc = fn
+       typecheck.Stmts(fn.Body)
+
+       // Inline calls within (*T).M wrappers. This is safe because we only
+       // generate those wrappers within the same compilation unit as (T).M.
+       // TODO(mdempsky): Investigate why we can't enable this more generally.
+       if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
+               inline.InlineCalls(fn)
+       }
+       escape.Batch([]*ir.Func{fn}, false)
+
+       ir.CurFunc = nil
+       typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+       return lsym
+}
+
+var ZeroSize int64
+
+// MarkTypeUsedInInterface marks that type t is converted to an interface.
+// This information is used in the linker in dead method elimination.
+func MarkTypeUsedInInterface(t *types.Type, from *obj.LSym) {
+       tsym := TypeLinksym(t)
+       // Emit a marker relocation. The linker will know the type is converted
+       // to an interface if "from" is reachable.
+       r := obj.Addrel(from)
+       r.Sym = tsym
+       r.Type = objabi.R_USEIFACE
+}
+
+// MarkUsedIfaceMethod marks that an interface method is used in the current
+// function. n is OCALLINTER node.
+func MarkUsedIfaceMethod(n *ir.CallExpr) {
+       dot := n.X.(*ir.SelectorExpr)
+       ityp := dot.X.Type()
+       tsym := TypeLinksym(ityp)
+       r := obj.Addrel(ir.CurFunc.LSym)
+       r.Sym = tsym
+       // dot.Xoffset is the method index * Widthptr (the offset of code pointer
+       // in itab).
+       midx := dot.Offset() / int64(types.PtrSize)
+       r.Add = InterfaceMethodOffset(ityp, midx)
+       r.Type = objabi.R_USEIFACEMETHOD
 }

diff --git a/src/cmd/compile/internal/riscv64/galign.go b/src/cmd/compile/internal/riscv64/galign.go
index 4db0fac52e42b3e8e4069153c25a7df292b17574..338248a7cf27ab13b71ec4ed25f90a015fdc6511 100644 (file)
--- a/src/cmd/compile/internal/riscv64/galign.go
+++ b/src/cmd/compile/internal/riscv64/galign.go
@@ -5,11 +5,11 @@
 package riscv64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/riscv"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &riscv.LinkRISCV64
 
        arch.REGSP = riscv.REG_SP

diff --git a/src/cmd/compile/internal/riscv64/ggen.go b/src/cmd/compile/internal/riscv64/ggen.go
index f7c03fe7c2173560c569c610490a8c8fe6ecfbc6..9df739456b9e5a50ec503fd3ccdc39d8ccec93e6 100644 (file)
--- a/src/cmd/compile/internal/riscv64/ggen.go
+++ b/src/cmd/compile/internal/riscv64/ggen.go
@@ -5,33 +5,36 @@
 package riscv64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/riscv"
 )
 
-func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zeroRange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
 
        // Adjust the frame to account for LR.
-       off += gc.Ctxt.FixedFrameSize()
+       off += base.Ctxt.FixedFrameSize()
 
-       if cnt < int64(4*gc.Widthptr) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-                       p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_SP, off+i)
+       if cnt < int64(4*types.PtrSize) {
+               for i := int64(0); i < cnt; i += int64(types.PtrSize) {
+                       p = pp.Append(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_SP, off+i)
                }
                return p
        }
 
-       if cnt <= int64(128*gc.Widthptr) {
-               p = pp.Appendpp(p, riscv.AADDI, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_A0, 0)
+       if cnt <= int64(128*types.PtrSize) {
+               p = pp.Append(p, riscv.AADDI, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_A0, 0)
                p.Reg = riscv.REG_SP
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
-               p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
+               p.To.Sym = ir.Syms.Duffzero
+               p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
                return p
        }
 
@@ -42,15 +45,15 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        //      MOV     ZERO, (T0)
        //      ADD     $Widthptr, T0
        //      BNE     T0, T1, loop
-       p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_T0, 0)
+       p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_T0, 0)
        p.Reg = riscv.REG_SP
-       p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, riscv.REG_T1, 0)
+       p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, riscv.REG_T1, 0)
        p.Reg = riscv.REG_T0
-       p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_T0, 0)
+       p = pp.Append(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_T0, 0)
        loop := p
-       p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, riscv.REG_T0, 0)
-       p = pp.Appendpp(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
+       p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, riscv.REG_T0, 0)
+       p = pp.Append(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
        p.Reg = riscv.REG_T1
-       gc.Patch(p, loop)
+       p.To.SetTarget(loop)
        return p
 }

diff --git a/src/cmd/compile/internal/riscv64/gsubr.go b/src/cmd/compile/internal/riscv64/gsubr.go
index d40bdf7a1d3627487e6a30e9d98b57a8a51989e4..74bccf8d42ab1b00cad26b7c06e79b8824bf294e 100644 (file)
--- a/src/cmd/compile/internal/riscv64/gsubr.go
+++ b/src/cmd/compile/internal/riscv64/gsubr.go
@@ -5,12 +5,12 @@
 package riscv64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/objw"
        "cmd/internal/obj"
        "cmd/internal/obj/riscv"
 )
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        // Hardware nop is ADD $0, ZERO
        p := pp.Prog(riscv.AADD)
        p.From.Type = obj.TYPE_CONST

diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 0beb5b4bd180a2460fb69e57311416a9b391202f..70c29a4b7b3435e5fc8224a99feb74afc62248f0 100644 (file)
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -5,8 +5,10 @@
 package riscv64
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/riscv"
@@ -91,7 +93,7 @@ func loadByType(t *types.Type) obj.As {
                case 8:
                        return riscv.AMOVD
                default:
-                       gc.Fatalf("unknown float width for load %d in type %v", width, t)
+                       base.Fatalf("unknown float width for load %d in type %v", width, t)
                        return 0
                }
        }
@@ -118,7 +120,7 @@ func loadByType(t *types.Type) obj.As {
        case 8:
                return riscv.AMOV
        default:
-               gc.Fatalf("unknown width for load %d in type %v", width, t)
+               base.Fatalf("unknown width for load %d in type %v", width, t)
                return 0
        }
 }
@@ -134,7 +136,7 @@ func storeByType(t *types.Type) obj.As {
                case 8:
                        return riscv.AMOVD
                default:
-                       gc.Fatalf("unknown float width for store %d in type %v", width, t)
+                       base.Fatalf("unknown float width for store %d in type %v", width, t)
                        return 0
                }
        }
@@ -149,7 +151,7 @@ func storeByType(t *types.Type) obj.As {
        case 8:
                return riscv.AMOV
        default:
-               gc.Fatalf("unknown width for store %d in type %v", width, t)
+               base.Fatalf("unknown width for store %d in type %v", width, t)
                return 0
        }
 }
@@ -178,9 +180,9 @@ func largestMove(alignment int64) (obj.As, int64) {
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
 // RISC-V has no flags, so this is a no-op.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {}
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {}
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        s.SetPos(v.Pos)
 
        switch v.Op {
@@ -189,7 +191,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.OpArg:
                // input args need no code
        case ssa.OpPhi:
-               gc.CheckLoweredPhi(v)
+               ssagen.CheckLoweredPhi(v)
        case ssa.OpCopy, ssa.OpRISCV64MOVconvert, ssa.OpRISCV64MOVDreg:
                if v.Type.IsMemory() {
                        return
@@ -219,7 +221,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpStoreReg:
@@ -230,7 +232,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpSP, ssa.OpSB, ssa.OpGetG:
                // nothing to do
        case ssa.OpRISCV64MOVBreg, ssa.OpRISCV64MOVHreg, ssa.OpRISCV64MOVWreg,
@@ -321,10 +323,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        v.Fatalf("aux is of unknown type %T", v.Aux)
                case *obj.LSym:
                        wantreg = "SB"
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        wantreg = "SP"
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                case nil:
                        // No sym, just MOVW $off(SP), R
                        wantreg = "SP"
@@ -340,7 +342,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpRISCV64MOVBstore, ssa.OpRISCV64MOVHstore, ssa.OpRISCV64MOVWstore, ssa.OpRISCV64MOVDstore,
@@ -350,14 +352,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpRISCV64MOVBstorezero, ssa.OpRISCV64MOVHstorezero, ssa.OpRISCV64MOVWstorezero, ssa.OpRISCV64MOVDstorezero:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_REG
                p.From.Reg = riscv.REG_ZERO
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpRISCV64SEQZ, ssa.OpRISCV64SNEZ:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_REG
@@ -375,7 +377,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(16) // space used in callee args area by assembly stubs
 
        case ssa.OpRISCV64LoweredAtomicLoad8:
@@ -500,7 +502,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p4.From.Reg = riscv.REG_TMP
                p4.Reg = riscv.REG_ZERO
                p4.To.Type = obj.TYPE_BRANCH
-               gc.Patch(p4, p1)
+               p4.To.SetTarget(p1)
 
                p5 := s.Prog(riscv.AMOV)
                p5.From.Type = obj.TYPE_CONST
@@ -509,7 +511,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p5.To.Reg = out
 
                p6 := s.Prog(obj.ANOP)
-               gc.Patch(p2, p6)
+               p2.To.SetTarget(p6)
 
        case ssa.OpRISCV64LoweredZero:
                mov, sz := largestMove(v.AuxInt)
@@ -535,7 +537,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p3.Reg = v.Args[0].Reg()
                p3.From.Type = obj.TYPE_REG
                p3.From.Reg = v.Args[1].Reg()
-               gc.Patch(p3, p)
+               p3.To.SetTarget(p)
 
        case ssa.OpRISCV64LoweredMove:
                mov, sz := largestMove(v.AuxInt)
@@ -575,7 +577,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p5.Reg = v.Args[1].Reg()
                p5.From.Type = obj.TYPE_REG
                p5.From.Reg = v.Args[2].Reg()
-               gc.Patch(p5, p)
+               p5.To.SetTarget(p)
 
        case ssa.OpRISCV64LoweredNilCheck:
                // Issue a load which will fault if arg is nil.
@@ -583,22 +585,22 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(riscv.AMOVB)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = riscv.REG_ZERO
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
 
        case ssa.OpRISCV64LoweredGetClosurePtr:
                // Closure pointer is S4 (riscv.REG_CTXT).
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
 
        case ssa.OpRISCV64LoweredGetCallerSP:
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(riscv.AMOV)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -612,14 +614,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = v.AuxInt
 
        case ssa.OpRISCV64DUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                p.To.Offset = v.AuxInt
 
        default:
@@ -642,7 +644,7 @@ var blockBranch = [...]obj.As{
        ssa.BlockRISCV64BNEZ: riscv.ABNEZ,
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        s.SetPos(b.Pos)
 
        switch b.Kind {
@@ -655,17 +657,17 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.From.Type = obj.TYPE_REG
                p.From.Reg = riscv.REG_ZERO
                p.Reg = riscv.REG_A0
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:

diff --git a/src/cmd/compile/internal/s390x/galign.go b/src/cmd/compile/internal/s390x/galign.go
index cb68fd36c14bf682d4861f080f03d10c15440fe1..b004a2db0a39b3f61c9b8e1d93d648d3d44bcd0a 100644 (file)
--- a/src/cmd/compile/internal/s390x/galign.go
+++ b/src/cmd/compile/internal/s390x/galign.go
@@ -5,11 +5,11 @@
 package s390x
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/s390x"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &s390x.Links390x
        arch.REGSP = s390x.REGSP
        arch.MAXWIDTH = 1 << 50

diff --git a/src/cmd/compile/internal/s390x/ggen.go b/src/cmd/compile/internal/s390x/ggen.go
index 5a837d85742367acba04fe01381b3e9671632b71..488a080c468886db6d769269ff5387c93dc33447 100644 (file)
--- a/src/cmd/compile/internal/s390x/ggen.go
+++ b/src/cmd/compile/internal/s390x/ggen.go
@@ -5,7 +5,8 @@
 package s390x
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/objw"
        "cmd/internal/obj"
        "cmd/internal/obj/s390x"
 )
@@ -17,20 +18,20 @@ import (
 const clearLoopCutoff = 1024
 
 // zerorange clears the stack in the given range.
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
 
        // Adjust the frame to account for LR.
-       off += gc.Ctxt.FixedFrameSize()
+       off += base.Ctxt.FixedFrameSize()
        reg := int16(s390x.REGSP)
 
        // If the off cannot fit in a 12-bit unsigned displacement then we
        // need to create a copy of the stack pointer that we can adjust.
        // We also need to do this if we are going to loop.
        if off < 0 || off > 4096-clearLoopCutoff || cnt > clearLoopCutoff {
-               p = pp.Appendpp(p, s390x.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, s390x.REGRT1, 0)
+               p = pp.Append(p, s390x.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, s390x.REGRT1, 0)
                p.Reg = int16(s390x.REGSP)
                reg = s390x.REGRT1
                off = 0
@@ -39,12 +40,12 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        // Generate a loop of large clears.
        if cnt > clearLoopCutoff {
                ireg := int16(s390x.REGRT2) // register holds number of remaining loop iterations
-               p = pp.Appendpp(p, s390x.AMOVD, obj.TYPE_CONST, 0, cnt/256, obj.TYPE_REG, ireg, 0)
-               p = pp.Appendpp(p, s390x.ACLEAR, obj.TYPE_CONST, 0, 256, obj.TYPE_MEM, reg, off)
+               p = pp.Append(p, s390x.AMOVD, obj.TYPE_CONST, 0, cnt/256, obj.TYPE_REG, ireg, 0)
+               p = pp.Append(p, s390x.ACLEAR, obj.TYPE_CONST, 0, 256, obj.TYPE_MEM, reg, off)
                pl := p
-               p = pp.Appendpp(p, s390x.AADD, obj.TYPE_CONST, 0, 256, obj.TYPE_REG, reg, 0)
-               p = pp.Appendpp(p, s390x.ABRCTG, obj.TYPE_REG, ireg, 0, obj.TYPE_BRANCH, 0, 0)
-               gc.Patch(p, pl)
+               p = pp.Append(p, s390x.AADD, obj.TYPE_CONST, 0, 256, obj.TYPE_REG, reg, 0)
+               p = pp.Append(p, s390x.ABRCTG, obj.TYPE_REG, ireg, 0, obj.TYPE_BRANCH, 0, 0)
+               p.To.SetTarget(pl)
                cnt = cnt % 256
        }
 
@@ -69,11 +70,11 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
                        case 2:
                                ins = s390x.AMOVH
                        }
-                       p = pp.Appendpp(p, ins, obj.TYPE_CONST, 0, 0, obj.TYPE_MEM, reg, off)
+                       p = pp.Append(p, ins, obj.TYPE_CONST, 0, 0, obj.TYPE_MEM, reg, off)
 
                // Handle clears that would require multiple move instructions with CLEAR (assembled as XC).
                default:
-                       p = pp.Appendpp(p, s390x.ACLEAR, obj.TYPE_CONST, 0, n, obj.TYPE_MEM, reg, off)
+                       p = pp.Append(p, s390x.ACLEAR, obj.TYPE_CONST, 0, n, obj.TYPE_MEM, reg, off)
                }
 
                cnt -= n
@@ -83,6 +84,6 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        return pp.Prog(s390x.ANOPH)
 }

diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 8037357131c79fac0f6ee350a398d994fa5fcaed..d4c7a286e268855f1d03e873594c3dac65f576ab 100644 (file)
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -7,16 +7,17 @@ package s390x
 import (
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/s390x"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
        flive := b.FlagsLiveAtEnd
        for _, c := range b.ControlValues() {
                flive = c.Type.IsFlags() || flive
@@ -134,7 +135,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
        p := s.Prog(op)
        p.From.Type = obj.TYPE_REG
        p.To.Type = obj.TYPE_REG
@@ -147,7 +148,7 @@ func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
 //     dest := src(From) op off
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregregimm(s *gc.SSAGenState, op obj.As, dest, src int16, off int64) *obj.Prog {
+func opregregimm(s *ssagen.State, op obj.As, dest, src int16, off int64) *obj.Prog {
        p := s.Prog(op)
        p.From.Type = obj.TYPE_CONST
        p.From.Offset = off
@@ -157,7 +158,7 @@ func opregregimm(s *gc.SSAGenState, op obj.As, dest, src int16, off int64) *obj.
        return p
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpS390XSLD, ssa.OpS390XSLW,
                ssa.OpS390XSRD, ssa.OpS390XSRW,
@@ -394,14 +395,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Type = obj.TYPE_ADDR
                p.From.Reg = r
                p.From.Index = i
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpS390XMOVDaddr:
                p := s.Prog(s390x.AMOVD)
                p.From.Type = obj.TYPE_ADDR
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpS390XCMP, ssa.OpS390XCMPW, ssa.OpS390XCMPU, ssa.OpS390XCMPWU:
@@ -447,7 +448,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[1].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = r
        case ssa.OpS390XMOVDload,
@@ -458,7 +459,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpS390XMOVBZloadidx, ssa.OpS390XMOVHZloadidx, ssa.OpS390XMOVWZloadidx,
@@ -475,7 +476,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = r
                p.From.Scale = 1
                p.From.Index = i
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpS390XMOVBstore, ssa.OpS390XMOVHstore, ssa.OpS390XMOVWstore, ssa.OpS390XMOVDstore,
@@ -486,7 +487,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpS390XMOVBstoreidx, ssa.OpS390XMOVHstoreidx, ssa.OpS390XMOVWstoreidx, ssa.OpS390XMOVDstoreidx,
                ssa.OpS390XMOVHBRstoreidx, ssa.OpS390XMOVWBRstoreidx, ssa.OpS390XMOVDBRstoreidx,
                ssa.OpS390XFMOVSstoreidx, ssa.OpS390XFMOVDstoreidx:
@@ -502,7 +503,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Reg = r
                p.To.Scale = 1
                p.To.Index = i
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpS390XMOVDstoreconst, ssa.OpS390XMOVWstoreconst, ssa.OpS390XMOVHstoreconst, ssa.OpS390XMOVBstoreconst:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_CONST
@@ -510,7 +511,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = sc.Val()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
        case ssa.OpS390XMOVBreg, ssa.OpS390XMOVHreg, ssa.OpS390XMOVWreg,
                ssa.OpS390XMOVBZreg, ssa.OpS390XMOVHZreg, ssa.OpS390XMOVWZreg,
                ssa.OpS390XLDGR, ssa.OpS390XLGDR,
@@ -529,7 +530,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = sc.Val()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
        case ssa.OpCopy:
                if v.Type.IsMemory() {
                        return
@@ -545,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.OpStoreReg:
@@ -556,10 +557,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.OpS390XLoweredGetClosurePtr:
                // Closure pointer is R12 (already)
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.OpS390XLoweredRound32F, ssa.OpS390XLoweredRound64F:
                // input is already rounded
        case ssa.OpS390XLoweredGetG:
@@ -573,7 +574,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // caller's SP is FixedFrameSize below the address of the first arg
                p := s.Prog(s390x.AMOVD)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize()
+               p.From.Offset = -base.Ctxt.FixedFrameSize()
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -592,7 +593,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(16) // space used in callee args area by assembly stubs
        case ssa.OpS390XFLOGR, ssa.OpS390XPOPCNT,
                ssa.OpS390XNEG, ssa.OpS390XNEGW,
@@ -636,14 +637,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(s390x.AMOVBZ)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = s390x.REGTMP
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpS390XMVC:
                vo := v.AuxValAndOff()
@@ -671,7 +672,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.Reg = v.Args[len(v.Args)-2].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpS390XLoweredMove:
                // Inputs must be valid pointers to memory,
                // so adjust arg0 and arg1 as part of the expansion.
@@ -708,7 +709,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
                bne := s.Prog(s390x.ABLT)
                bne.To.Type = obj.TYPE_BRANCH
-               gc.Patch(bne, mvc)
+               bne.To.SetTarget(mvc)
 
                if v.AuxInt > 0 {
                        mvc := s.Prog(s390x.AMVC)
@@ -750,7 +751,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
                bne := s.Prog(s390x.ABLT)
                bne.To.Type = obj.TYPE_BRANCH
-               gc.Patch(bne, clear)
+               bne.To.SetTarget(clear)
 
                if v.AuxInt > 0 {
                        clear := s.Prog(s390x.ACLEAR)
@@ -763,7 +764,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg0()
        case ssa.OpS390XMOVBatomicstore, ssa.OpS390XMOVWatomicstore, ssa.OpS390XMOVDatomicstore:
@@ -772,7 +773,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpS390XLAN, ssa.OpS390XLAO:
                // LA(N|O) Ry, TMP, 0(Rx)
                op := s.Prog(v.Op.Asm())
@@ -807,7 +808,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.OpS390XLoweredAtomicCas32, ssa.OpS390XLoweredAtomicCas64:
                // Convert the flags output of CS{,G} into a bool.
                //    CS{,G} arg1, arg2, arg0
@@ -823,7 +824,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                cs.Reg = v.Args[2].Reg()      // new
                cs.To.Type = obj.TYPE_MEM
                cs.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&cs.To, v)
+               ssagen.AddAux(&cs.To, v)
 
                // MOVD $0, ret
                movd := s.Prog(s390x.AMOVD)
@@ -845,7 +846,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
                // NOP (so the BNE has somewhere to land)
                nop := s.Prog(obj.ANOP)
-               gc.Patch(bne, nop)
+               bne.To.SetTarget(nop)
        case ssa.OpS390XLoweredAtomicExchange32, ssa.OpS390XLoweredAtomicExchange64:
                // Loop until the CS{,G} succeeds.
                //     MOV{WZ,D} arg0, ret
@@ -858,7 +859,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                load.From.Reg = v.Args[0].Reg()
                load.To.Type = obj.TYPE_REG
                load.To.Reg = v.Reg0()
-               gc.AddAux(&load.From, v)
+               ssagen.AddAux(&load.From, v)
 
                // CS{,G} ret, arg1, arg0
                cs := s.Prog(v.Op.Asm())
@@ -867,12 +868,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                cs.Reg = v.Args[1].Reg() // new
                cs.To.Type = obj.TYPE_MEM
                cs.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&cs.To, v)
+               ssagen.AddAux(&cs.To, v)
 
                // BNE cs
                bne := s.Prog(s390x.ABNE)
                bne.To.Type = obj.TYPE_BRANCH
-               gc.Patch(bne, cs)
+               bne.To.SetTarget(cs)
        case ssa.OpS390XSYNC:
                s.Prog(s390x.ASYNC)
        case ssa.OpClobber:
@@ -907,14 +908,14 @@ func blockAsm(b *ssa.Block) obj.As {
        panic("unreachable")
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        // Handle generic blocks first.
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(s390x.ABR)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
                return
        case ssa.BlockDefer:

diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go
index 519ac214caef220ddae40f6cd7b49048fba4fc3e..937c757b2153bed33b90b9981f3ba498b8cf022e 100644 (file)
--- a/src/cmd/compile/internal/ssa/block.go
+++ b/src/cmd/compile/internal/ssa/block.go
@@ -52,7 +52,7 @@ type Block struct {
        Controls [2]*Value
 
        // Auxiliary info for the block. Its value depends on the Kind.
-       Aux    interface{}
+       Aux    Aux
        AuxInt int64
 
        // The unordered set of Values that define the operation of this block.

diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go
index 5f5dfc328a3f848bef815917988408719bb81018..9e4aa6cd79f27d7bb6fddc9d3bbef1e77c7dd09a 100644 (file)
--- a/src/cmd/compile/internal/ssa/check.go
+++ b/src/cmd/compile/internal/ssa/check.go
@@ -147,6 +147,11 @@ func checkFunc(f *Func) {
                                canHaveAuxInt = true
                        case auxInt128:
                                // AuxInt must be zero, so leave canHaveAuxInt set to false.
+                       case auxUInt8:
+                               if v.AuxInt != int64(uint8(v.AuxInt)) {
+                                       f.Fatalf("bad uint8 AuxInt value for %v", v)
+                               }
+                               canHaveAuxInt = true
                        case auxFloat32:
                                canHaveAuxInt = true
                                if math.IsNaN(v.AuxFloat()) {
@@ -161,7 +166,7 @@ func checkFunc(f *Func) {
                                        f.Fatalf("value %v has an AuxInt that encodes a NaN", v)
                                }
                        case auxString:
-                               if _, ok := v.Aux.(string); !ok {
+                               if _, ok := v.Aux.(stringAux); !ok {
                                        f.Fatalf("value %v has Aux type %T, want string", v, v.Aux)
                                }
                                canHaveAux = true

diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index 63994d1778ed029a9d59f8042db4af96837c2ac0..c267274366b35a8f32e57c457ed249d6fa9378a7 100644 (file)
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -431,7 +431,6 @@ var passes = [...]pass{
        {name: "early copyelim", fn: copyelim},
        {name: "early deadcode", fn: deadcode}, // remove generated dead code to avoid doing pointless work during opt
        {name: "short circuit", fn: shortcircuit},
-       {name: "decompose args", fn: decomposeArgs, required: !go116lateCallExpansion, disabled: go116lateCallExpansion}, // handled by late call lowering
        {name: "decompose user", fn: decomposeUser, required: true},
        {name: "pre-opt deadcode", fn: deadcode},
        {name: "opt", fn: opt, required: true},               // NB: some generic rules know the name of the opt pass. TODO: split required rules and optimizing rules

diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 0fe0337ddfa309c4d6bab1538fd31faf5a5bfaef..c29bc8fae6f70bf0a7cca248b2730f68f40bc586 100644 (file)
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -5,6 +5,8 @@
 package ssa
 
 import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/objabi"
@@ -138,7 +140,7 @@ type Frontend interface {
 
        // Auto returns a Node for an auto variable of the given type.
        // The SSA compiler uses this function to allocate space for spills.
-       Auto(src.XPos, *types.Type) GCNode
+       Auto(src.XPos, *types.Type) *ir.Name
 
        // Given the name for a compound type, returns the name we should use
        // for the parts of that compound type.
@@ -178,32 +180,6 @@ type Frontend interface {
        MyImportPath() string
 }
 
-// interface used to hold a *gc.Node (a stack variable).
-// We'd use *gc.Node directly but that would lead to an import cycle.
-type GCNode interface {
-       Typ() *types.Type
-       String() string
-       IsSynthetic() bool
-       IsAutoTmp() bool
-       StorageClass() StorageClass
-}
-
-type StorageClass uint8
-
-const (
-       ClassAuto     StorageClass = iota // local stack variable
-       ClassParam                        // argument
-       ClassParamOut                     // return value
-)
-
-const go116lateCallExpansion = true
-
-// LateCallExpansionEnabledWithin returns true if late call expansion should be tested
-// within compilation of a function/method.
-func LateCallExpansionEnabledWithin(f *Func) bool {
-       return go116lateCallExpansion
-}
-
 // NewConfig returns a new configuration object for the given architecture.
 func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config {
        c := &Config{arch: arch, Types: types}
@@ -219,9 +195,10 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
                c.registers = registersAMD64[:]
                c.gpRegMask = gpRegMaskAMD64
                c.fpRegMask = fpRegMaskAMD64
+               c.specialRegMask = specialRegMaskAMD64
                c.FPReg = framepointerRegAMD64
                c.LinkReg = linkRegAMD64
-               c.hasGReg = false
+               c.hasGReg = base.Flag.ABIWrap
        case "386":
                c.PtrSize = 4
                c.RegSize = 4

diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go
index 3b4f2be37e7beabe44ec6e569be52d4660604056..f78527410c8dde5952b96661c2a15ef166e7afcc 100644 (file)
--- a/src/cmd/compile/internal/ssa/cse.go
+++ b/src/cmd/compile/internal/ssa/cse.go
@@ -275,7 +275,7 @@ func lt2Cmp(isLt bool) types.Cmp {
        return types.CMPgt
 }
 
-type auxmap map[interface{}]int32
+type auxmap map[Aux]int32
 
 func cmpVal(v, w *Value, auxIDs auxmap) types.Cmp {
        // Try to order these comparison by cost (cheaper first)

diff --git a/src/cmd/compile/internal/ssa/cse_test.go b/src/cmd/compile/internal/ssa/cse_test.go
index 9e76645f54fa5bf77df40eaecaff0f19ddcc98b8..8052016f3af6928fde492839c8b521b1d814aa63 100644 (file)
--- a/src/cmd/compile/internal/ssa/cse_test.go
+++ b/src/cmd/compile/internal/ssa/cse_test.go
@@ -14,6 +14,8 @@ type tstAux struct {
        s string
 }
 
+func (*tstAux) CanBeAnSSAAux() {}
+
 // This tests for a bug found when partitioning, but not sorting by the Aux value.
 func TestCSEAuxPartitionBug(t *testing.T) {
        c := testConfig(t)

diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 0664013b397ed0668552fe2174d0351cb21623a5..31d3f62d4e7cef68637d8c2552f22a7ad085122d 100644 (file)
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/src"
 )
@@ -136,9 +137,9 @@ func dse(f *Func) {
 // reaches stores then we delete all the stores. The other operations will then
 // be eliminated by the dead code elimination pass.
 func elimDeadAutosGeneric(f *Func) {
-       addr := make(map[*Value]GCNode) // values that the address of the auto reaches
-       elim := make(map[*Value]GCNode) // values that could be eliminated if the auto is
-       used := make(map[GCNode]bool)   // used autos that must be kept
+       addr := make(map[*Value]*ir.Name) // values that the address of the auto reaches
+       elim := make(map[*Value]*ir.Name) // values that could be eliminated if the auto is
+       var used ir.NameSet               // used autos that must be kept
 
        // visit the value and report whether any of the maps are updated
        visit := func(v *Value) (changed bool) {
@@ -146,8 +147,8 @@ func elimDeadAutosGeneric(f *Func) {
                switch v.Op {
                case OpAddr, OpLocalAddr:
                        // Propagate the address if it points to an auto.
-                       n, ok := v.Aux.(GCNode)
-                       if !ok || n.StorageClass() != ClassAuto {
+                       n, ok := v.Aux.(*ir.Name)
+                       if !ok || n.Class != ir.PAUTO {
                                return
                        }
                        if addr[v] == nil {
@@ -157,8 +158,8 @@ func elimDeadAutosGeneric(f *Func) {
                        return
                case OpVarDef, OpVarKill:
                        // v should be eliminated if we eliminate the auto.
-                       n, ok := v.Aux.(GCNode)
-                       if !ok || n.StorageClass() != ClassAuto {
+                       n, ok := v.Aux.(*ir.Name)
+                       if !ok || n.Class != ir.PAUTO {
                                return
                        }
                        if elim[v] == nil {
@@ -173,12 +174,12 @@ func elimDeadAutosGeneric(f *Func) {
                        // for open-coded defers from being removed (since they
                        // may not be used by the inline code, but will be used by
                        // panic processing).
-                       n, ok := v.Aux.(GCNode)
-                       if !ok || n.StorageClass() != ClassAuto {
+                       n, ok := v.Aux.(*ir.Name)
+                       if !ok || n.Class != ir.PAUTO {
                                return
                        }
-                       if !used[n] {
-                               used[n] = true
+                       if !used.Has(n) {
+                               used.Add(n)
                                changed = true
                        }
                        return
@@ -211,8 +212,8 @@ func elimDeadAutosGeneric(f *Func) {
                if v.Type.IsMemory() || v.Type.IsFlags() || v.Op == OpPhi || v.MemoryArg() != nil {
                        for _, a := range args {
                                if n, ok := addr[a]; ok {
-                                       if !used[n] {
-                                               used[n] = true
+                                       if !used.Has(n) {
+                                               used.Add(n)
                                                changed = true
                                        }
                                }
@@ -221,9 +222,9 @@ func elimDeadAutosGeneric(f *Func) {
                }
 
                // Propagate any auto addresses through v.
-               node := GCNode(nil)
+               var node *ir.Name
                for _, a := range args {
-                       if n, ok := addr[a]; ok && !used[n] {
+                       if n, ok := addr[a]; ok && !used.Has(n) {
                                if node == nil {
                                        node = n
                                } else if node != n {
@@ -232,7 +233,7 @@ func elimDeadAutosGeneric(f *Func) {
                                        // multiple pointers (e.g. NeqPtr, Phi etc.).
                                        // This is rare, so just propagate the first
                                        // value to keep things simple.
-                                       used[n] = true
+                                       used.Add(n)
                                        changed = true
                                }
                        }
@@ -248,7 +249,7 @@ func elimDeadAutosGeneric(f *Func) {
                }
                if addr[v] != node {
                        // This doesn't happen in practice, but catch it just in case.
-                       used[node] = true
+                       used.Add(node)
                        changed = true
                }
                return
@@ -268,8 +269,8 @@ func elimDeadAutosGeneric(f *Func) {
                        }
                        // keep the auto if its address reaches a control value
                        for _, c := range b.ControlValues() {
-                               if n, ok := addr[c]; ok && !used[n] {
-                                       used[n] = true
+                               if n, ok := addr[c]; ok && !used.Has(n) {
+                                       used.Add(n)
                                        changed = true
                                }
                        }
@@ -281,7 +282,7 @@ func elimDeadAutosGeneric(f *Func) {
 
        // Eliminate stores to unread autos.
        for v, n := range elim {
-               if used[n] {
+               if used.Has(n) {
                        continue
                }
                // replace with OpCopy
@@ -298,15 +299,15 @@ func elimUnreadAutos(f *Func) {
        // Loop over all ops that affect autos taking note of which
        // autos we need and also stores that we might be able to
        // eliminate.
-       seen := make(map[GCNode]bool)
+       var seen ir.NameSet
        var stores []*Value
        for _, b := range f.Blocks {
                for _, v := range b.Values {
-                       n, ok := v.Aux.(GCNode)
+                       n, ok := v.Aux.(*ir.Name)
                        if !ok {
                                continue
                        }
-                       if n.StorageClass() != ClassAuto {
+                       if n.Class != ir.PAUTO {
                                continue
                        }
 
@@ -316,7 +317,7 @@ func elimUnreadAutos(f *Func) {
                                // If we haven't seen the auto yet
                                // then this might be a store we can
                                // eliminate.
-                               if !seen[n] {
+                               if !seen.Has(n) {
                                        stores = append(stores, v)
                                }
                        default:
@@ -326,7 +327,7 @@ func elimUnreadAutos(f *Func) {
                                // because dead loads haven't been
                                // eliminated yet.
                                if v.Uses > 0 {
-                                       seen[n] = true
+                                       seen.Add(n)
                                }
                        }
                }
@@ -334,8 +335,8 @@ func elimUnreadAutos(f *Func) {
 
        // Eliminate stores to unread autos.
        for _, store := range stores {
-               n, _ := store.Aux.(GCNode)
-               if seen[n] {
+               n, _ := store.Aux.(*ir.Name)
+               if seen.Has(n) {
                        continue
                }
 

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 6353f7289785880aa734606e8453f4a398cc1d8a..68b6ab5fe9e7690a9fd4b4c5c03f430f573a21f1 100644 (file)
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/internal/dwarf"
        "cmd/internal/obj"
        "encoding/hex"
@@ -24,7 +25,7 @@ type FuncDebug struct {
        // Slots is all the slots used in the debug info, indexed by their SlotID.
        Slots []LocalSlot
        // The user variables, indexed by VarID.
-       Vars []GCNode
+       Vars []*ir.Name
        // The slots that make up each variable, indexed by VarID.
        VarSlots [][]SlotID
        // The location list data, indexed by VarID. Must be processed by PutLocationList.
@@ -142,13 +143,13 @@ func (loc VarLoc) absent() bool {
 var BlockStart = &Value{
        ID:  -10000,
        Op:  OpInvalid,
-       Aux: "BlockStart",
+       Aux: StringToAux("BlockStart"),
 }
 
 var BlockEnd = &Value{
        ID:  -20000,
        Op:  OpInvalid,
-       Aux: "BlockEnd",
+       Aux: StringToAux("BlockEnd"),
 }
 
 // RegisterSet is a bitmap of registers, indexed by Register.num.
@@ -165,7 +166,7 @@ func (s *debugState) logf(msg string, args ...interface{}) {
 type debugState struct {
        // See FuncDebug.
        slots    []LocalSlot
-       vars     []GCNode
+       vars     []*ir.Name
        varSlots [][]SlotID
        lists    [][]byte
 
@@ -189,7 +190,7 @@ type debugState struct {
        // The pending location list entry for each user variable, indexed by VarID.
        pendingEntries []pendingEntry
 
-       varParts           map[GCNode][]SlotID
+       varParts           map[*ir.Name][]SlotID
        blockDebug         []BlockDebug
        pendingSlotLocs    []VarLoc
        liveSlots          []liveSlot
@@ -346,7 +347,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
        }
 
        if state.varParts == nil {
-               state.varParts = make(map[GCNode][]SlotID)
+               state.varParts = make(map[*ir.Name][]SlotID)
        } else {
                for n := range state.varParts {
                        delete(state.varParts, n)
@@ -360,7 +361,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
        state.vars = state.vars[:0]
        for i, slot := range f.Names {
                state.slots = append(state.slots, slot)
-               if slot.N.IsSynthetic() {
+               if ir.IsSynthetic(slot.N) {
                        continue
                }
 
@@ -379,8 +380,8 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
        for _, b := range f.Blocks {
                for _, v := range b.Values {
                        if v.Op == OpVarDef || v.Op == OpVarKill {
-                               n := v.Aux.(GCNode)
-                               if n.IsSynthetic() {
+                               n := v.Aux.(*ir.Name)
+                               if ir.IsSynthetic(n) {
                                        continue
                                }
 
@@ -425,7 +426,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
        state.initializeCache(f, len(state.varParts), len(state.slots))
 
        for i, slot := range f.Names {
-               if slot.N.IsSynthetic() {
+               if ir.IsSynthetic(slot.N) {
                        continue
                }
                for _, value := range f.NamedValues[slot] {
@@ -717,8 +718,8 @@ func (state *debugState) processValue(v *Value, vSlots []SlotID, vReg *Register)
 
        switch {
        case v.Op == OpVarDef, v.Op == OpVarKill:
-               n := v.Aux.(GCNode)
-               if n.IsSynthetic() {
+               n := v.Aux.(*ir.Name)
+               if ir.IsSynthetic(n) {
                        break
                }
 

diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
index bf7f1e826b17ee66fae6d219d54cb037be25d496..ea988e44f61a6ffe1a2cbfe195d2da09b0690db6 100644 (file)
--- a/src/cmd/compile/internal/ssa/decompose.go
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -219,10 +219,6 @@ func decomposeInterfacePhi(v *Value) {
        v.AddArg(data)
 }
 
-func decomposeArgs(f *Func) {
-       applyRewrite(f, rewriteBlockdecArgs, rewriteValuedecArgs, removeDeadValues)
-}
-
 func decomposeUser(f *Func) {
        for _, b := range f.Blocks {
                for _, v := range b.Values {

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index fbde19d94c29927a2a50a0d396ced550fed31dcb..579818e4f3cf7d5312313dfd4be17fc021186a5d 100644 (file)
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -24,652 +24,670 @@ type offsetKey struct {
        pt     *types.Type
 }
 
-// expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
-// that is more oriented to a platform's ABI.  The SelectN operations that extract results are rewritten into
-// more appropriate forms, and any StructMake or ArrayMake inputs are decomposed until non-struct values are
-// reached.  On the callee side, OpArg nodes are not decomposed until this phase is run.
-// TODO results should not be lowered until this phase.
-func expandCalls(f *Func) {
-       // Calls that need lowering have some number of inputs, including a memory input,
-       // and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
-
-       // With the current ABI those inputs need to be converted into stores to memory,
-       // rethreading the call's memory input to the first, and the new call now receiving the last.
-
-       // With the current ABI, the outputs need to be converted to loads, which will all use the call's
-       // memory output as their input.
-       if !LateCallExpansionEnabledWithin(f) {
-               return
-       }
-       debug := f.pass.debug > 0
+func isBlockMultiValueExit(b *Block) bool {
+       return (b.Kind == BlockRet || b.Kind == BlockRetJmp) && len(b.Controls) > 0 && b.Controls[0].Op == OpMakeResult
+}
 
-       if debug {
-               fmt.Printf("\nexpandsCalls(%s)\n", f.Name)
+// removeTrivialWrapperTypes unwraps layers of
+// struct { singleField SomeType } and [1]SomeType
+// until a non-wrapper type is reached.  This is useful
+// for working with assignments to/from interface data
+// fields (either second operand to OpIMake or OpIData)
+// where the wrapping or type conversion can be elided
+// because of type conversions/assertions in source code
+// that do not appear in SSA.
+func removeTrivialWrapperTypes(t *types.Type) *types.Type {
+       for {
+               if t.IsStruct() && t.NumFields() == 1 {
+                       t = t.Field(0).Type
+                       continue
+               }
+               if t.IsArray() && t.NumElem() == 1 {
+                       t = t.Elem()
+                       continue
+               }
+               break
        }
+       return t
+}
 
-       canSSAType := f.fe.CanSSA
-       regSize := f.Config.RegSize
-       sp, _ := f.spSb()
-       typ := &f.Config.Types
-       ptrSize := f.Config.PtrSize
+type expandState struct {
+       f            *Func
+       debug        bool
+       canSSAType   func(*types.Type) bool
+       regSize      int64
+       sp           *Value
+       typs         *Types
+       ptrSize      int64
+       hiOffset     int64
+       lowOffset    int64
+       namedSelects map[*Value][]namedVal
+       sdom         SparseTree
+       common       map[selKey]*Value
+       offsets      map[offsetKey]*Value
+}
 
-       // For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
-       var hiOffset, lowOffset int64
-       if f.Config.BigEndian {
-               lowOffset = 4
-       } else {
-               hiOffset = 4
+// intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
+// that has no 64-bit integer registers.
+func (x *expandState) intPairTypes(et types.Kind) (tHi, tLo *types.Type) {
+       tHi = x.typs.UInt32
+       if et == types.TINT64 {
+               tHi = x.typs.Int32
        }
+       tLo = x.typs.UInt32
+       return
+}
 
-       namedSelects := make(map[*Value][]namedVal)
-
-       sdom := f.Sdom()
-
-       common := make(map[selKey]*Value)
-
-       // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
-       // that has no 64-bit integer registers.
-       intPairTypes := func(et types.EType) (tHi, tLo *types.Type) {
-               tHi = typ.UInt32
-               if et == types.TINT64 {
-                       tHi = typ.Int32
-               }
-               tLo = typ.UInt32
-               return
+// isAlreadyExpandedAggregateType returns whether a type is an SSA-able "aggregate" (multiple register) type
+// that was expanded in an earlier phase (currently, expand_calls is intended to run after decomposeBuiltin,
+// so this is all aggregate types -- small struct and array, complex, interface, string, slice, and 64-bit
+// integer on 32-bit).
+func (x *expandState) isAlreadyExpandedAggregateType(t *types.Type) bool {
+       if !x.canSSAType(t) {
+               return false
        }
+       return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice() ||
+               t.Size() > x.regSize && t.IsInteger()
+}
 
-       // isAlreadyExpandedAggregateType returns whether a type is an SSA-able "aggregate" (multiple register) type
-       // that was expanded in an earlier phase (currently, expand_calls is intended to run after decomposeBuiltin,
-       // so this is all aggregate types -- small struct and array, complex, interface, string, slice, and 64-bit
-       // integer on 32-bit).
-       isAlreadyExpandedAggregateType := func(t *types.Type) bool {
-               if !canSSAType(t) {
-                       return false
-               }
-               return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice() ||
-                       t.Size() > regSize && t.IsInteger()
+// offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
+// TODO should also optimize offsets from SB?
+func (x *expandState) offsetFrom(from *Value, offset int64, pt *types.Type) *Value {
+       if offset == 0 && from.Type == pt { // this is not actually likely
+               return from
        }
-
-       offsets := make(map[offsetKey]*Value)
-
-       // offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
-       // TODO should also optimize offsets from SB?
-       offsetFrom := func(from *Value, offset int64, pt *types.Type) *Value {
-               if offset == 0 && from.Type == pt { // this is not actually likely
-                       return from
-               }
-               // Simplify, canonicalize
-               for from.Op == OpOffPtr {
-                       offset += from.AuxInt
-                       from = from.Args[0]
-               }
-               if from == sp {
-                       return f.ConstOffPtrSP(pt, offset, sp)
-               }
-               key := offsetKey{from, offset, pt}
-               v := offsets[key]
-               if v != nil {
-                       return v
-               }
-               v = from.Block.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
-               offsets[key] = v
+       // Simplify, canonicalize
+       for from.Op == OpOffPtr {
+               offset += from.AuxInt
+               from = from.Args[0]
+       }
+       if from == x.sp {
+               return x.f.ConstOffPtrSP(pt, offset, x.sp)
+       }
+       key := offsetKey{from, offset, pt}
+       v := x.offsets[key]
+       if v != nil {
                return v
        }
+       v = from.Block.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
+       x.offsets[key] = v
+       return v
+}
 
-       // splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
-       splitSlots := func(ls []LocalSlot, sfx string, offset int64, ty *types.Type) []LocalSlot {
-               var locs []LocalSlot
-               for i := range ls {
-                       locs = append(locs, f.fe.SplitSlot(&ls[i], sfx, offset, ty))
-               }
-               return locs
+// splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
+func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *types.Type) []LocalSlot {
+       var locs []LocalSlot
+       for i := range ls {
+               locs = append(locs, x.f.fe.SplitSlot(&ls[i], sfx, offset, ty))
        }
+       return locs
+}
 
-       // removeTrivialWrapperTypes unwraps layers of
-       // struct { singleField SomeType } and [1]SomeType
-       // until a non-wrapper type is reached.  This is useful
-       // for working with assignments to/from interface data
-       // fields (either second operand to OpIMake or OpIData)
-       // where the wrapping or type conversion can be elided
-       // because of type conversions/assertions in source code
-       // that do not appear in SSA.
-       removeTrivialWrapperTypes := func(t *types.Type) *types.Type {
-               for {
-                       if t.IsStruct() && t.NumFields() == 1 {
-                               t = t.Field(0).Type
-                               continue
-                       }
-                       if t.IsArray() && t.NumElem() == 1 {
-                               t = t.Elem()
-                               continue
-                       }
-                       break
-               }
-               return t
+// Calls that need lowering have some number of inputs, including a memory input,
+// and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
+
+// With the current ABI those inputs need to be converted into stores to memory,
+// rethreading the call's memory input to the first, and the new call now receiving the last.
+
+// With the current ABI, the outputs need to be converted to loads, which will all use the call's
+// memory output as their input.
+
+// rewriteSelect recursively walks from leaf selector to a root (OpSelectN, OpLoad, OpArg)
+// through a chain of Struct/Array/builtin Select operations.  If the chain of selectors does not
+// end in an expected root, it does nothing (this can happen depending on compiler phase ordering).
+// The "leaf" provides the type, the root supplies the container, and the leaf-to-root path
+// accumulates the offset.
+// It emits the code necessary to implement the leaf select operation that leads to the root.
+//
+// TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
+func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64) []LocalSlot {
+       if x.debug {
+               fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
        }
-
-       // Calls that need lowering have some number of inputs, including a memory input,
-       // and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
-
-       // With the current ABI those inputs need to be converted into stores to memory,
-       // rethreading the call's memory input to the first, and the new call now receiving the last.
-
-       // With the current ABI, the outputs need to be converted to loads, which will all use the call's
-       // memory output as their input.
-
-       // rewriteSelect recursively walks from leaf selector to a root (OpSelectN, OpLoad, OpArg)
-       // through a chain of Struct/Array/builtin Select operations.  If the chain of selectors does not
-       // end in an expected root, it does nothing (this can happen depending on compiler phase ordering).
-       // The "leaf" provides the type, the root supplies the container, and the leaf-to-root path
-       // accumulates the offset.
-       // It emits the code necessary to implement the leaf select operation that leads to the root.
-       //
-       // TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
-       var rewriteSelect func(leaf *Value, selector *Value, offset int64) []LocalSlot
-       rewriteSelect = func(leaf *Value, selector *Value, offset int64) []LocalSlot {
-               if debug {
-                       fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
-               }
-               var locs []LocalSlot
-               leafType := leaf.Type
-               if len(selector.Args) > 0 {
-                       w := selector.Args[0]
-                       if w.Op == OpCopy {
-                               for w.Op == OpCopy {
-                                       w = w.Args[0]
-                               }
-                               selector.SetArg(0, w)
+       var locs []LocalSlot
+       leafType := leaf.Type
+       if len(selector.Args) > 0 {
+               w := selector.Args[0]
+               if w.Op == OpCopy {
+                       for w.Op == OpCopy {
+                               w = w.Args[0]
                        }
+                       selector.SetArg(0, w)
                }
-               switch selector.Op {
-               case OpArg:
-                       if !isAlreadyExpandedAggregateType(selector.Type) {
-                               if leafType == selector.Type { // OpIData leads us here, sometimes.
-                                       leaf.copyOf(selector)
-                               } else {
-                                       f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
-                               }
-                               if debug {
-                                       fmt.Printf("\tOpArg, break\n")
-                               }
-                               break
-                       }
-                       if leaf.Op == OpIData {
-                               leafType = removeTrivialWrapperTypes(leaf.Type)
-                       }
-                       aux := selector.Aux
-                       auxInt := selector.AuxInt + offset
-                       if leaf.Block == selector.Block {
-                               leaf.reset(OpArg)
-                               leaf.Aux = aux
-                               leaf.AuxInt = auxInt
-                               leaf.Type = leafType
+       }
+       switch selector.Op {
+       case OpArg:
+               if !x.isAlreadyExpandedAggregateType(selector.Type) {
+                       if leafType == selector.Type { // OpIData leads us here, sometimes.
+                               leaf.copyOf(selector)
                        } else {
-                               w := selector.Block.NewValue0IA(leaf.Pos, OpArg, leafType, auxInt, aux)
-                               leaf.copyOf(w)
-                               if debug {
-                                       fmt.Printf("\tnew %s\n", w.LongString())
-                               }
-                       }
-                       for _, s := range namedSelects[selector] {
-                               locs = append(locs, f.Names[s.locIndex])
+                               x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
                        }
-
-               case OpLoad: // We end up here because of IData of immediate structures.
-                       // Failure case:
-                       // (note the failure case is very rare; w/o this case, make.bash and run.bash both pass, as well as
-                       // the hard cases of building {syscall,math,math/cmplx,math/bits,go/constant} on ppc64le and mips-softfloat).
-                       //
-                       // GOSSAFUNC='(*dumper).dump' go build -gcflags=-l -tags=math_big_pure_go cmd/compile/internal/gc
-                       // cmd/compile/internal/gc/dump.go:136:14: internal compiler error: '(*dumper).dump': not lowered: v827, StructSelect PTR PTR
-                       // b2: ← b1
-                       // v20 (+142) = StaticLECall <interface {},mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v8 v1
-                       // v21 (142) = SelectN <mem> [1] v20
-                       // v22 (142) = SelectN <interface {}> [0] v20
-                       // b15: ← b8
-                       // v71 (+143) = IData <Nodes> v22 (v[Nodes])
-                       // v73 (+146) = StaticLECall <[]*Node,mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v71 v21
-                       //
-                       // translates (w/o the "case OpLoad:" above) to:
-                       //
-                       // b2: ← b1
-                       // v20 (+142) = StaticCall <mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v715
-                       // v23 (142) = Load <*uintptr> v19 v20
-                       // v823 (142) = IsNonNil <bool> v23
-                       // v67 (+143) = Load <*[]*Node> v880 v20
-                       // b15: ← b8
-                       // v827 (146) = StructSelect <*[]*Node> [0] v67
-                       // v846 (146) = Store <mem> {*[]*Node} v769 v827 v20
-                       // v73 (+146) = StaticCall <mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v846
-                       // i.e., the struct select is generated and remains in because it is not applied to an actual structure.
-                       // The OpLoad was created to load the single field of the IData
-                       // This case removes that StructSelect.
-                       if leafType != selector.Type {
-                               f.Fatalf("Unexpected Load as selector, leaf=%s, selector=%s\n", leaf.LongString(), selector.LongString())
+                       if x.debug {
+                               fmt.Printf("\tOpArg, break\n")
                        }
-                       leaf.copyOf(selector)
-                       for _, s := range namedSelects[selector] {
-                               locs = append(locs, f.Names[s.locIndex])
+                       break
+               }
+               switch leaf.Op {
+               case OpIData, OpStructSelect, OpArraySelect:
+                       leafType = removeTrivialWrapperTypes(leaf.Type)
+               }
+               aux := selector.Aux
+               auxInt := selector.AuxInt + offset
+               if leaf.Block == selector.Block {
+                       leaf.reset(OpArg)
+                       leaf.Aux = aux
+                       leaf.AuxInt = auxInt
+                       leaf.Type = leafType
+               } else {
+                       w := selector.Block.NewValue0IA(leaf.Pos, OpArg, leafType, auxInt, aux)
+                       leaf.copyOf(w)
+                       if x.debug {
+                               fmt.Printf("\tnew %s\n", w.LongString())
                        }
+               }
+               for _, s := range x.namedSelects[selector] {
+                       locs = append(locs, x.f.Names[s.locIndex])
+               }
 
-               case OpSelectN:
-                       // TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
-                       call := selector.Args[0]
-                       aux := call.Aux.(*AuxCall)
-                       which := selector.AuxInt
-                       if which == aux.NResults() { // mem is after the results.
-                               // rewrite v as a Copy of call -- the replacement call will produce a mem.
-                               leaf.copyOf(call)
-                       } else {
-                               leafType := removeTrivialWrapperTypes(leaf.Type)
-                               if canSSAType(leafType) {
-                                       pt := types.NewPtr(leafType)
-                                       off := offsetFrom(sp, offset+aux.OffsetOfResult(which), pt)
-                                       // Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
-                                       if leaf.Block == call.Block {
-                                               leaf.reset(OpLoad)
-                                               leaf.SetArgs2(off, call)
-                                               leaf.Type = leafType
-                                       } else {
-                                               w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
-                                               leaf.copyOf(w)
-                                               if debug {
-                                                       fmt.Printf("\tnew %s\n", w.LongString())
-                                               }
-                                       }
-                                       for _, s := range namedSelects[selector] {
-                                               locs = append(locs, f.Names[s.locIndex])
-                                       }
+       case OpLoad: // We end up here because of IData of immediate structures.
+               // Failure case:
+               // (note the failure case is very rare; w/o this case, make.bash and run.bash both pass, as well as
+               // the hard cases of building {syscall,math,math/cmplx,math/bits,go/constant} on ppc64le and mips-softfloat).
+               //
+               // GOSSAFUNC='(*dumper).dump' go build -gcflags=-l -tags=math_big_pure_go cmd/compile/internal/gc
+               // cmd/compile/internal/gc/dump.go:136:14: internal compiler error: '(*dumper).dump': not lowered: v827, StructSelect PTR PTR
+               // b2: ← b1
+               // v20 (+142) = StaticLECall <interface {},mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v8 v1
+               // v21 (142) = SelectN <mem> [1] v20
+               // v22 (142) = SelectN <interface {}> [0] v20
+               // b15: ← b8
+               // v71 (+143) = IData <Nodes> v22 (v[Nodes])
+               // v73 (+146) = StaticLECall <[]*Node,mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v71 v21
+               //
+               // translates (w/o the "case OpLoad:" above) to:
+               //
+               // b2: ← b1
+               // v20 (+142) = StaticCall <mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v715
+               // v23 (142) = Load <*uintptr> v19 v20
+               // v823 (142) = IsNonNil <bool> v23
+               // v67 (+143) = Load <*[]*Node> v880 v20
+               // b15: ← b8
+               // v827 (146) = StructSelect <*[]*Node> [0] v67
+               // v846 (146) = Store <mem> {*[]*Node} v769 v827 v20
+               // v73 (+146) = StaticCall <mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v846
+               // i.e., the struct select is generated and remains in because it is not applied to an actual structure.
+               // The OpLoad was created to load the single field of the IData
+               // This case removes that StructSelect.
+               if leafType != selector.Type {
+                       x.f.Fatalf("Unexpected Load as selector, leaf=%s, selector=%s\n", leaf.LongString(), selector.LongString())
+               }
+               leaf.copyOf(selector)
+               for _, s := range x.namedSelects[selector] {
+                       locs = append(locs, x.f.Names[s.locIndex])
+               }
+
+       case OpSelectN:
+               // TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
+               call := selector.Args[0]
+               aux := call.Aux.(*AuxCall)
+               which := selector.AuxInt
+               if which == aux.NResults() { // mem is after the results.
+                       // rewrite v as a Copy of call -- the replacement call will produce a mem.
+                       leaf.copyOf(call)
+               } else {
+                       leafType := removeTrivialWrapperTypes(leaf.Type)
+                       if x.canSSAType(leafType) {
+                               pt := types.NewPtr(leafType)
+                               off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
+                               // Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
+                               if leaf.Block == call.Block {
+                                       leaf.reset(OpLoad)
+                                       leaf.SetArgs2(off, call)
+                                       leaf.Type = leafType
                                } else {
-                                       f.Fatalf("Should not have non-SSA-able OpSelectN, selector=%s", selector.LongString())
+                                       w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
+                                       leaf.copyOf(w)
+                                       if x.debug {
+                                               fmt.Printf("\tnew %s\n", w.LongString())
+                                       }
+                               }
+                               for _, s := range x.namedSelects[selector] {
+                                       locs = append(locs, x.f.Names[s.locIndex])
                                }
+                       } else {
+                               x.f.Fatalf("Should not have non-SSA-able OpSelectN, selector=%s", selector.LongString())
                        }
+               }
 
-               case OpStructSelect:
-                       w := selector.Args[0]
-                       var ls []LocalSlot
-                       if w.Type.Etype != types.TSTRUCT { // IData artifact
-                               ls = rewriteSelect(leaf, w, offset)
-                       } else {
-                               ls = rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
-                               if w.Op != OpIData {
-                                       for _, l := range ls {
-                                               locs = append(locs, f.fe.SplitStruct(l, int(selector.AuxInt)))
-                                       }
+       case OpStructSelect:
+               w := selector.Args[0]
+               var ls []LocalSlot
+               if w.Type.Kind() != types.TSTRUCT { // IData artifact
+                       ls = x.rewriteSelect(leaf, w, offset)
+               } else {
+                       ls = x.rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
+                       if w.Op != OpIData {
+                               for _, l := range ls {
+                                       locs = append(locs, x.f.fe.SplitStruct(l, int(selector.AuxInt)))
                                }
                        }
+               }
 
-               case OpArraySelect:
-                       w := selector.Args[0]
-                       rewriteSelect(leaf, w, offset+selector.Type.Size()*selector.AuxInt)
-
-               case OpInt64Hi:
-                       w := selector.Args[0]
-                       ls := rewriteSelect(leaf, w, offset+hiOffset)
-                       locs = splitSlots(ls, ".hi", hiOffset, leafType)
-
-               case OpInt64Lo:
-                       w := selector.Args[0]
-                       ls := rewriteSelect(leaf, w, offset+lowOffset)
-                       locs = splitSlots(ls, ".lo", lowOffset, leafType)
-
-               case OpStringPtr:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset)
-                       locs = splitSlots(ls, ".ptr", 0, typ.BytePtr)
-
-               case OpSlicePtr:
-                       w := selector.Args[0]
-                       ls := rewriteSelect(leaf, w, offset)
-                       locs = splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
-
-               case OpITab:
-                       w := selector.Args[0]
-                       ls := rewriteSelect(leaf, w, offset)
-                       sfx := ".itab"
-                       if w.Type.IsEmptyInterface() {
-                               sfx = ".type"
-                       }
-                       locs = splitSlots(ls, sfx, 0, typ.Uintptr)
+       case OpArraySelect:
+               w := selector.Args[0]
+               x.rewriteSelect(leaf, w, offset+selector.Type.Size()*selector.AuxInt)
+
+       case OpInt64Hi:
+               w := selector.Args[0]
+               ls := x.rewriteSelect(leaf, w, offset+x.hiOffset)
+               locs = x.splitSlots(ls, ".hi", x.hiOffset, leafType)
+
+       case OpInt64Lo:
+               w := selector.Args[0]
+               ls := x.rewriteSelect(leaf, w, offset+x.lowOffset)
+               locs = x.splitSlots(ls, ".lo", x.lowOffset, leafType)
+
+       case OpStringPtr:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+               locs = x.splitSlots(ls, ".ptr", 0, x.typs.BytePtr)
+
+       case OpSlicePtr:
+               w := selector.Args[0]
+               ls := x.rewriteSelect(leaf, w, offset)
+               locs = x.splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
+
+       case OpITab:
+               w := selector.Args[0]
+               ls := x.rewriteSelect(leaf, w, offset)
+               sfx := ".itab"
+               if w.Type.IsEmptyInterface() {
+                       sfx = ".type"
+               }
+               locs = x.splitSlots(ls, sfx, 0, x.typs.Uintptr)
 
-               case OpComplexReal:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset)
-                       locs = splitSlots(ls, ".real", 0, leafType)
+       case OpComplexReal:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+               locs = x.splitSlots(ls, ".real", 0, leafType)
 
-               case OpComplexImag:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset+leafType.Width) // result is FloatNN, width of result is offset of imaginary part.
-                       locs = splitSlots(ls, ".imag", leafType.Width, leafType)
+       case OpComplexImag:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset+leafType.Width) // result is FloatNN, width of result is offset of imaginary part.
+               locs = x.splitSlots(ls, ".imag", leafType.Width, leafType)
 
-               case OpStringLen, OpSliceLen:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset+ptrSize)
-                       locs = splitSlots(ls, ".len", ptrSize, leafType)
+       case OpStringLen, OpSliceLen:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+               locs = x.splitSlots(ls, ".len", x.ptrSize, leafType)
 
-               case OpIData:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset+ptrSize)
-                       locs = splitSlots(ls, ".data", ptrSize, leafType)
+       case OpIData:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+               locs = x.splitSlots(ls, ".data", x.ptrSize, leafType)
 
-               case OpSliceCap:
-                       ls := rewriteSelect(leaf, selector.Args[0], offset+2*ptrSize)
-                       locs = splitSlots(ls, ".cap", 2*ptrSize, leafType)
-
-               case OpCopy: // If it's an intermediate result, recurse
-                       locs = rewriteSelect(leaf, selector.Args[0], offset)
-                       for _, s := range namedSelects[selector] {
-                               // this copy may have had its own name, preserve that, too.
-                               locs = append(locs, f.Names[s.locIndex])
-                       }
+       case OpSliceCap:
+               ls := x.rewriteSelect(leaf, selector.Args[0], offset+2*x.ptrSize)
+               locs = x.splitSlots(ls, ".cap", 2*x.ptrSize, leafType)
 
-               default:
-                       // Ignore dead ends. These can occur if this phase is run before decompose builtin (which is not intended, but allowed).
+       case OpCopy: // If it's an intermediate result, recurse
+               locs = x.rewriteSelect(leaf, selector.Args[0], offset)
+               for _, s := range x.namedSelects[selector] {
+                       // this copy may have had its own name, preserve that, too.
+                       locs = append(locs, x.f.Names[s.locIndex])
                }
 
-               return locs
+       default:
+               // Ignore dead ends. These can occur if this phase is run before decompose builtin (which is not intended, but allowed).
        }
 
-       // storeArgOrLoad converts stores of SSA-able aggregate arguments (passed to a call) into a series of primitive-typed
-       // stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
-       // If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
-       var storeArgOrLoad func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value
+       return locs
+}
 
-       // decomposeArgOrLoad is a helper for storeArgOrLoad.
-       // It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
-       // passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
-       decomposeArgOrLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64,
-               decomposeOne func(pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
-               decomposeTwo func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
-               u := source.Type
-               switch u.Etype {
-               case types.TARRAY:
-                       elem := u.Elem()
-                       for i := int64(0); i < u.NumElem(); i++ {
-                               elemOff := i * elem.Size()
-                               mem = decomposeOne(pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff)
-                               pos = pos.WithNotStmt()
-                       }
-                       return mem
-               case types.TSTRUCT:
-                       for i := 0; i < u.NumFields(); i++ {
-                               fld := u.Field(i)
-                               mem = decomposeOne(pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset)
-                               pos = pos.WithNotStmt()
-                       }
-                       return mem
-               case types.TINT64, types.TUINT64:
-                       if t.Width == regSize {
-                               break
-                       }
-                       tHi, tLo := intPairTypes(t.Etype)
-                       mem = decomposeOne(pos, b, base, source, mem, tHi, source.AuxInt+hiOffset, offset+hiOffset)
+func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset, size int64, typ *types.Type, pos src.XPos) *Value {
+       source := a.Args[0]
+       dst := x.offsetFrom(base, offset, source.Type)
+       if a.Uses == 1 && a.Block == b {
+               a.reset(OpMove)
+               a.Pos = pos
+               a.Type = types.TypeMem
+               a.Aux = typ
+               a.AuxInt = size
+               a.SetArgs3(dst, source, mem)
+               mem = a
+       } else {
+               mem = b.NewValue3A(pos, OpMove, types.TypeMem, typ, dst, source, mem)
+               mem.AuxInt = size
+       }
+       return mem
+}
+
+// decomposeArgOrLoad is a helper for storeArgOrLoad.
+// It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
+// passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
+func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64,
+       decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
+       decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
+       u := source.Type
+       switch u.Kind() {
+       case types.TARRAY:
+               elem := u.Elem()
+               for i := int64(0); i < u.NumElem(); i++ {
+                       elemOff := i * elem.Size()
+                       mem = decomposeOne(x, pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff)
+                       pos = pos.WithNotStmt()
+               }
+               return mem
+       case types.TSTRUCT:
+               for i := 0; i < u.NumFields(); i++ {
+                       fld := u.Field(i)
+                       mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset)
                        pos = pos.WithNotStmt()
-                       return decomposeOne(pos, b, base, source, mem, tLo, source.AuxInt+lowOffset, offset+lowOffset)
-               case types.TINTER:
-                       return decomposeTwo(pos, b, base, source, mem, typ.Uintptr, typ.BytePtr, source.AuxInt, offset)
-               case types.TSTRING:
-                       return decomposeTwo(pos, b, base, source, mem, typ.BytePtr, typ.Int, source.AuxInt, offset)
-               case types.TCOMPLEX64:
-                       return decomposeTwo(pos, b, base, source, mem, typ.Float32, typ.Float32, source.AuxInt, offset)
-               case types.TCOMPLEX128:
-                       return decomposeTwo(pos, b, base, source, mem, typ.Float64, typ.Float64, source.AuxInt, offset)
-               case types.TSLICE:
-                       mem = decomposeTwo(pos, b, base, source, mem, typ.BytePtr, typ.Int, source.AuxInt, offset)
-                       return decomposeOne(pos, b, base, source, mem, typ.Int, source.AuxInt+2*ptrSize, offset+2*ptrSize)
-               }
-               return nil
-       }
-
-       // storeOneArg creates a decomposed (one step) arg that is then stored.
-       // pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
-       // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-       storeOneArg := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
-               w := common[selKey{source, offArg, t.Width, t}]
-               if w == nil {
-                       w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
-                       common[selKey{source, offArg, t.Width, t}] = w
-               }
-               return storeArgOrLoad(pos, b, base, w, mem, t, offStore)
-       }
-
-       // storeOneLoad creates a decomposed (one step) load that is then stored.
-       storeOneLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
-               from := offsetFrom(source.Args[0], offArg, types.NewPtr(t))
-               w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
-               return storeArgOrLoad(pos, b, base, w, mem, t, offStore)
-       }
-
-       storeTwoArg := func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-               mem = storeOneArg(pos, b, base, source, mem, t1, offArg, offStore)
+               }
+               return mem
+       case types.TINT64, types.TUINT64:
+               if t.Width == x.regSize {
+                       break
+               }
+               tHi, tLo := x.intPairTypes(t.Kind())
+               mem = decomposeOne(x, pos, b, base, source, mem, tHi, source.AuxInt+x.hiOffset, offset+x.hiOffset)
                pos = pos.WithNotStmt()
-               t1Size := t1.Size()
-               return storeOneArg(pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+               return decomposeOne(x, pos, b, base, source, mem, tLo, source.AuxInt+x.lowOffset, offset+x.lowOffset)
+       case types.TINTER:
+               return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, source.AuxInt, offset)
+       case types.TSTRING:
+               return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
+       case types.TCOMPLEX64:
+               return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, source.AuxInt, offset)
+       case types.TCOMPLEX128:
+               return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, source.AuxInt, offset)
+       case types.TSLICE:
+               mem = decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
+               return decomposeOne(x, pos, b, base, source, mem, x.typs.Int, source.AuxInt+2*x.ptrSize, offset+2*x.ptrSize)
        }
+       return nil
+}
 
-       storeTwoLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-               mem = storeOneLoad(pos, b, base, source, mem, t1, offArg, offStore)
-               pos = pos.WithNotStmt()
-               t1Size := t1.Size()
-               return storeOneLoad(pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+// storeOneArg creates a decomposed (one step) arg that is then stored.
+// pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
+// mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
+func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+       w := x.common[selKey{source, offArg, t.Width, t}]
+       if w == nil {
+               w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
+               x.common[selKey{source, offArg, t.Width, t}] = w
        }
+       return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+}
 
-       storeArgOrLoad = func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value {
-               if debug {
-                       fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
-               }
+// storeOneLoad creates a decomposed (one step) load that is then stored.
+func storeOneLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+       from := x.offsetFrom(source.Args[0], offArg, types.NewPtr(t))
+       w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
+       return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+}
 
-               switch source.Op {
-               case OpCopy:
-                       return storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset)
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
+       mem = storeOneArg(x, pos, b, base, source, mem, t1, offArg, offStore)
+       pos = pos.WithNotStmt()
+       t1Size := t1.Size()
+       return storeOneArg(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+}
 
-               case OpLoad:
-                       ret := decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneLoad, storeTwoLoad)
-                       if ret != nil {
-                               return ret
-                       }
+func storeTwoLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
+       mem = storeOneLoad(x, pos, b, base, source, mem, t1, offArg, offStore)
+       pos = pos.WithNotStmt()
+       t1Size := t1.Size()
+       return storeOneLoad(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+}
 
-               case OpArg:
-                       ret := decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneArg, storeTwoArg)
-                       if ret != nil {
-                               return ret
-                       }
+// storeArgOrLoad converts stores of SSA-able aggregate arguments (passed to a call) into a series of primitive-typed
+// stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
+// If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
+func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value {
+       if x.debug {
+               fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
+       }
 
-               case OpArrayMake0, OpStructMake0:
-                       return mem
+       switch source.Op {
+       case OpCopy:
+               return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset)
 
-               case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
-                       for i := 0; i < t.NumFields(); i++ {
-                               fld := t.Field(i)
-                               mem = storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset)
-                               pos = pos.WithNotStmt()
-                       }
-                       return mem
+       case OpLoad:
+               ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneLoad, storeTwoLoad)
+               if ret != nil {
+                       return ret
+               }
 
-               case OpArrayMake1:
-                       return storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
+       case OpArg:
+               ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneArg, storeTwoArg)
+               if ret != nil {
+                       return ret
+               }
 
-               case OpInt64Make:
-                       tHi, tLo := intPairTypes(t.Etype)
-                       mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+hiOffset)
-                       pos = pos.WithNotStmt()
-                       return storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+lowOffset)
+       case OpArrayMake0, OpStructMake0:
+               return mem
 
-               case OpComplexMake:
-                       tPart := typ.Float32
-                       wPart := t.Width / 2
-                       if wPart == 8 {
-                               tPart = typ.Float64
-                       }
-                       mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset)
+       case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
+               for i := 0; i < t.NumFields(); i++ {
+                       fld := t.Field(i)
+                       mem = x.storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset)
                        pos = pos.WithNotStmt()
-                       return storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart)
+               }
+               return mem
 
-               case OpIMake:
-                       mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.Uintptr, offset)
-                       pos = pos.WithNotStmt()
-                       return storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.BytePtr, offset+ptrSize)
+       case OpArrayMake1:
+               return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
 
-               case OpStringMake:
-                       mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.BytePtr, offset)
-                       pos = pos.WithNotStmt()
-                       return storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.Int, offset+ptrSize)
+       case OpInt64Make:
+               tHi, tLo := x.intPairTypes(t.Kind())
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+x.hiOffset)
+               pos = pos.WithNotStmt()
+               return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+x.lowOffset)
 
-               case OpSliceMake:
-                       mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.BytePtr, offset)
-                       pos = pos.WithNotStmt()
-                       mem = storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.Int, offset+ptrSize)
-                       return storeArgOrLoad(pos, b, base, source.Args[2], mem, typ.Int, offset+2*ptrSize)
-               }
-
-               // For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
-               switch t.Etype {
-               case types.TARRAY:
-                       elt := t.Elem()
-                       if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == regSize {
-                               t = removeTrivialWrapperTypes(t)
-                               // it could be a leaf type, but the "leaf" could be complex64 (for example)
-                               return storeArgOrLoad(pos, b, base, source, mem, t, offset)
-                       }
-                       for i := int64(0); i < t.NumElem(); i++ {
-                               sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
-                               mem = storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width)
-                               pos = pos.WithNotStmt()
-                       }
-                       return mem
-
-               case types.TSTRUCT:
-                       if source.Type != t && t.NumFields() == 1 && t.Field(0).Type.Width == t.Width && t.Width == regSize {
-                               // This peculiar test deals with accesses to immediate interface data.
-                               // It works okay because everything is the same size.
-                               // Example code that triggers this can be found in go/constant/value.go, function ToComplex
-                               // v119 (+881) = IData <intVal> v6
-                               // v121 (+882) = StaticLECall <floatVal,mem> {AuxCall{"".itof([intVal,0])[floatVal,8]}} [16] v119 v1
-                               // This corresponds to the generic rewrite rule "(StructSelect [0] (IData x)) => (IData x)"
-                               // Guard against "struct{struct{*foo}}"
-                               // Other rewriting phases create minor glitches when they transform IData, for instance the
-                               // interface-typed Arg "x" of ToFloat in go/constant/value.go
-                               //   v6 (858) = Arg <Value> {x} (x[Value], x[Value])
-                               // is rewritten by decomposeArgs into
-                               //   v141 (858) = Arg <uintptr> {x}
-                               //   v139 (858) = Arg <*uint8> {x} [8]
-                               // because of a type case clause on line 862 of go/constant/value.go
-                               //      case intVal:
-                               //                 return itof(x)
-                               // v139 is later stored as an intVal == struct{val *big.Int} which naively requires the fields of
-                               // of a *uint8, which does not succeed.
-                               t = removeTrivialWrapperTypes(t)
-                               // it could be a leaf type, but the "leaf" could be complex64 (for example)
-                               return storeArgOrLoad(pos, b, base, source, mem, t, offset)
-                       }
+       case OpComplexMake:
+               tPart := x.typs.Float32
+               wPart := t.Width / 2
+               if wPart == 8 {
+                       tPart = x.typs.Float64
+               }
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset)
+               pos = pos.WithNotStmt()
+               return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart)
 
-                       for i := 0; i < t.NumFields(); i++ {
-                               fld := t.Field(i)
-                               sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
-                               mem = storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset)
-                               pos = pos.WithNotStmt()
-                       }
-                       return mem
+       case OpIMake:
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.Uintptr, offset)
+               pos = pos.WithNotStmt()
+               return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize)
 
-               case types.TINT64, types.TUINT64:
-                       if t.Width == regSize {
-                               break
-                       }
-                       tHi, tLo := intPairTypes(t.Etype)
-                       sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+hiOffset)
-                       pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+lowOffset)
+       case OpStringMake:
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+               pos = pos.WithNotStmt()
+               return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
 
-               case types.TINTER:
-                       sel := source.Block.NewValue1(pos, OpITab, typ.BytePtr, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset)
-                       pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpIData, typ.BytePtr, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset+ptrSize)
+       case OpSliceMake:
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+               pos = pos.WithNotStmt()
+               mem = x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
+               return x.storeArgOrLoad(pos, b, base, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize)
+       }
 
-               case types.TSTRING:
-                       sel := source.Block.NewValue1(pos, OpStringPtr, typ.BytePtr, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset)
+       // For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
+       switch t.Kind() {
+       case types.TARRAY:
+               elt := t.Elem()
+               if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == x.regSize {
+                       t = removeTrivialWrapperTypes(t)
+                       // it could be a leaf type, but the "leaf" could be complex64 (for example)
+                       return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+               }
+               for i := int64(0); i < t.NumElem(); i++ {
+                       sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
+                       mem = x.storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width)
                        pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpStringLen, typ.Int, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+ptrSize)
+               }
+               return mem
 
-               case types.TSLICE:
-                       et := types.NewPtr(t.Elem())
-                       sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, et, offset)
-                       pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpSliceLen, typ.Int, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+ptrSize)
-                       sel = source.Block.NewValue1(pos, OpSliceCap, typ.Int, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+2*ptrSize)
-
-               case types.TCOMPLEX64:
-                       sel := source.Block.NewValue1(pos, OpComplexReal, typ.Float32, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Float32, offset)
-                       pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpComplexImag, typ.Float32, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, typ.Float32, offset+4)
+       case types.TSTRUCT:
+               if source.Type != t && t.NumFields() == 1 && t.Field(0).Type.Width == t.Width && t.Width == x.regSize {
+                       // This peculiar test deals with accesses to immediate interface data.
+                       // It works okay because everything is the same size.
+                       // Example code that triggers this can be found in go/constant/value.go, function ToComplex
+                       // v119 (+881) = IData <intVal> v6
+                       // v121 (+882) = StaticLECall <floatVal,mem> {AuxCall{"".itof([intVal,0])[floatVal,8]}} [16] v119 v1
+                       // This corresponds to the generic rewrite rule "(StructSelect [0] (IData x)) => (IData x)"
+                       // Guard against "struct{struct{*foo}}"
+                       // Other rewriting phases create minor glitches when they transform IData, for instance the
+                       // interface-typed Arg "x" of ToFloat in go/constant/value.go
+                       //   v6 (858) = Arg <Value> {x} (x[Value], x[Value])
+                       // is rewritten by decomposeArgs into
+                       //   v141 (858) = Arg <uintptr> {x}
+                       //   v139 (858) = Arg <*uint8> {x} [8]
+                       // because of a type case clause on line 862 of go/constant/value.go
+                       //      case intVal:
+                       //                 return itof(x)
+                       // v139 is later stored as an intVal == struct{val *big.Int} which naively requires the fields of
+                       // of a *uint8, which does not succeed.
+                       t = removeTrivialWrapperTypes(t)
+                       // it could be a leaf type, but the "leaf" could be complex64 (for example)
+                       return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+               }
 
-               case types.TCOMPLEX128:
-                       sel := source.Block.NewValue1(pos, OpComplexReal, typ.Float64, source)
-                       mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Float64, offset)
+               for i := 0; i < t.NumFields(); i++ {
+                       fld := t.Field(i)
+                       sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
+                       mem = x.storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset)
                        pos = pos.WithNotStmt()
-                       sel = source.Block.NewValue1(pos, OpComplexImag, typ.Float64, source)
-                       return storeArgOrLoad(pos, b, base, sel, mem, typ.Float64, offset+8)
                }
+               return mem
 
-               dst := offsetFrom(base, offset, types.NewPtr(t))
-               x := b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
-               if debug {
-                       fmt.Printf("\t\tstoreArg returns %s\n", x.LongString())
+       case types.TINT64, types.TUINT64:
+               if t.Width == x.regSize {
+                       break
                }
-               return x
+               tHi, tLo := x.intPairTypes(t.Kind())
+               sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+x.hiOffset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+x.lowOffset)
+
+       case types.TINTER:
+               sel := source.Block.NewValue1(pos, OpITab, x.typs.BytePtr, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpIData, x.typs.BytePtr, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset+x.ptrSize)
+
+       case types.TSTRING:
+               sel := source.Block.NewValue1(pos, OpStringPtr, x.typs.BytePtr, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpStringLen, x.typs.Int, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+
+       case types.TSLICE:
+               et := types.NewPtr(t.Elem())
+               sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, et, offset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpSliceLen, x.typs.Int, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+               sel = source.Block.NewValue1(pos, OpSliceCap, x.typs.Int, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+2*x.ptrSize)
+
+       case types.TCOMPLEX64:
+               sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float32, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float32, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset+4)
+
+       case types.TCOMPLEX128:
+               sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float64, source)
+               mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset)
+               pos = pos.WithNotStmt()
+               sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float64, source)
+               return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset+8)
        }
 
-       // rewriteArgs removes all the Args from a call and converts the call args into appropriate
-       // stores (or later, register movement).  Extra args for interface and closure calls are ignored,
-       // but removed.
-       rewriteArgs := func(v *Value, firstArg int) *Value {
-               // Thread the stores on the memory arg
-               aux := v.Aux.(*AuxCall)
-               pos := v.Pos.WithNotStmt()
-               m0 := v.Args[len(v.Args)-1]
-               mem := m0
-               for i, a := range v.Args {
-                       if i < firstArg {
-                               continue
-                       }
-                       if a == m0 { // mem is last.
-                               break
+       dst := x.offsetFrom(base, offset, types.NewPtr(t))
+       s := b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
+       if x.debug {
+               fmt.Printf("\t\tstoreArg returns %s\n", s.LongString())
+       }
+       return s
+}
+
+// rewriteArgs removes all the Args from a call and converts the call args into appropriate
+// stores (or later, register movement).  Extra args for interface and closure calls are ignored,
+// but removed.
+func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
+       // Thread the stores on the memory arg
+       aux := v.Aux.(*AuxCall)
+       pos := v.Pos.WithNotStmt()
+       m0 := v.MemoryArg()
+       mem := m0
+       for i, a := range v.Args {
+               if i < firstArg {
+                       continue
+               }
+               if a == m0 { // mem is last.
+                       break
+               }
+               auxI := int64(i - firstArg)
+               if a.Op == OpDereference {
+                       if a.MemoryArg() != m0 {
+                               x.f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
                        }
-                       auxI := int64(i - firstArg)
-                       if a.Op == OpDereference {
-                               if a.MemoryArg() != m0 {
-                                       f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
-                               }
-                               // "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
-                               // TODO this will be more complicated with registers in the picture.
-                               source := a.Args[0]
-                               dst := f.ConstOffPtrSP(source.Type, aux.OffsetOfArg(auxI), sp)
-                               if a.Uses == 1 && a.Block == v.Block {
-                                       a.reset(OpMove)
-                                       a.Pos = pos
-                                       a.Type = types.TypeMem
-                                       a.Aux = aux.TypeOfArg(auxI)
-                                       a.AuxInt = aux.SizeOfArg(auxI)
-                                       a.SetArgs3(dst, source, mem)
-                                       mem = a
-                               } else {
-                                       mem = v.Block.NewValue3A(pos, OpMove, types.TypeMem, aux.TypeOfArg(auxI), dst, source, mem)
-                                       mem.AuxInt = aux.SizeOfArg(auxI)
-                               }
-                       } else {
-                               if debug {
-                                       fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
-                               }
-                               mem = storeArgOrLoad(pos, v.Block, sp, a, mem, aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
+                       // "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
+                       // TODO this will be more complicated with registers in the picture.
+                       mem = x.rewriteDereference(v.Block, x.sp, a, mem, aux.OffsetOfArg(auxI), aux.SizeOfArg(auxI), aux.TypeOfArg(auxI), pos)
+               } else {
+                       if x.debug {
+                               fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
                        }
+                       mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
                }
-               v.resetArgs()
-               return mem
+       }
+       v.resetArgs()
+       return mem
+}
+
+// expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
+// that is more oriented to a platform's ABI.  The SelectN operations that extract results are rewritten into
+// more appropriate forms, and any StructMake or ArrayMake inputs are decomposed until non-struct values are
+// reached.  On the callee side, OpArg nodes are not decomposed until this phase is run.
+// TODO results should not be lowered until this phase.
+func expandCalls(f *Func) {
+       // Calls that need lowering have some number of inputs, including a memory input,
+       // and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
+
+       // With the current ABI those inputs need to be converted into stores to memory,
+       // rethreading the call's memory input to the first, and the new call now receiving the last.
+
+       // With the current ABI, the outputs need to be converted to loads, which will all use the call's
+       // memory output as their input.
+       sp, _ := f.spSb()
+       x := &expandState{
+               f:            f,
+               debug:        f.pass.debug > 0,
+               canSSAType:   f.fe.CanSSA,
+               regSize:      f.Config.RegSize,
+               sp:           sp,
+               typs:         &f.Config.Types,
+               ptrSize:      f.Config.PtrSize,
+               namedSelects: make(map[*Value][]namedVal),
+               sdom:         f.Sdom(),
+               common:       make(map[selKey]*Value),
+               offsets:      make(map[offsetKey]*Value),
+       }
+
+       // For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
+       if f.Config.BigEndian {
+               x.lowOffset = 4
+       } else {
+               x.hiOffset = 4
+       }
+
+       if x.debug {
+               fmt.Printf("\nexpandsCalls(%s)\n", f.Name)
        }
 
        // TODO if too slow, whole program iteration can be replaced w/ slices of appropriate values, accumulated in first loop here.
@@ -679,28 +697,67 @@ func expandCalls(f *Func) {
                for _, v := range b.Values {
                        switch v.Op {
                        case OpStaticLECall:
-                               mem := rewriteArgs(v, 0)
+                               mem := x.rewriteArgs(v, 0)
                                v.SetArgs1(mem)
                        case OpClosureLECall:
                                code := v.Args[0]
                                context := v.Args[1]
-                               mem := rewriteArgs(v, 2)
+                               mem := x.rewriteArgs(v, 2)
                                v.SetArgs3(code, context, mem)
                        case OpInterLECall:
                                code := v.Args[0]
-                               mem := rewriteArgs(v, 1)
+                               mem := x.rewriteArgs(v, 1)
                                v.SetArgs2(code, mem)
                        }
                }
+               if isBlockMultiValueExit(b) {
+                       // Very similar to code in rewriteArgs, but results instead of args.
+                       v := b.Controls[0]
+                       m0 := v.MemoryArg()
+                       mem := m0
+                       aux := f.OwnAux
+                       pos := v.Pos.WithNotStmt()
+                       for j, a := range v.Args {
+                               i := int64(j)
+                               if a == m0 {
+                                       break
+                               }
+                               auxType := aux.TypeOfResult(i)
+                               auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, x.sp, mem)
+                               auxOffset := int64(0)
+                               auxSize := aux.SizeOfResult(i)
+                               if a.Op == OpDereference {
+                                       // Avoid a self-move, and if one is detected try to remove the already-inserted VarDef for the assignment that won't happen.
+                                       if dAddr, dMem := a.Args[0], a.Args[1]; dAddr.Op == OpLocalAddr && dAddr.Args[0].Op == OpSP &&
+                                               dAddr.Args[1] == dMem && dAddr.Aux == aux.results[i].Name {
+                                               if dMem.Op == OpVarDef && dMem.Aux == dAddr.Aux {
+                                                       dMem.copyOf(dMem.MemoryArg()) // elide the VarDef
+                                               }
+                                               continue
+                                       }
+                                       mem = x.rewriteDereference(v.Block, auxBase, a, mem, auxOffset, auxSize, auxType, pos)
+                               } else {
+                                       if a.Op == OpLoad && a.Args[0].Op == OpLocalAddr {
+                                               addr := a.Args[0]
+                                               if addr.MemoryArg() == a.MemoryArg() && addr.Aux == aux.results[i].Name {
+                                                       continue
+                                               }
+                                       }
+                                       mem = x.storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset)
+                               }
+                       }
+                       b.SetControl(mem)
+                       v.reset(OpInvalid) // otherwise it can have a mem operand which will fail check(), even though it is dead.
+               }
        }
 
        for i, name := range f.Names {
                t := name.Type
-               if isAlreadyExpandedAggregateType(t) {
+               if x.isAlreadyExpandedAggregateType(t) {
                        for j, v := range f.NamedValues[name] {
-                               if v.Op == OpSelectN || v.Op == OpArg && isAlreadyExpandedAggregateType(v.Type) {
-                                       ns := namedSelects[v]
-                                       namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
+                               if v.Op == OpSelectN || v.Op == OpArg && x.isAlreadyExpandedAggregateType(v.Type) {
+                                       ns := x.namedSelects[v]
+                                       x.namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
                                }
                        }
                }
@@ -714,22 +771,22 @@ func expandCalls(f *Func) {
                                t := v.Aux.(*types.Type)
                                source := v.Args[1]
                                tSrc := source.Type
-                               iAEATt := isAlreadyExpandedAggregateType(t)
+                               iAEATt := x.isAlreadyExpandedAggregateType(t)
 
                                if !iAEATt {
                                        // guarding against store immediate struct into interface data field -- store type is *uint8
                                        // TODO can this happen recursively?
-                                       iAEATt = isAlreadyExpandedAggregateType(tSrc)
+                                       iAEATt = x.isAlreadyExpandedAggregateType(tSrc)
                                        if iAEATt {
                                                t = tSrc
                                        }
                                }
                                if iAEATt {
-                                       if debug {
+                                       if x.debug {
                                                fmt.Printf("Splitting store %s\n", v.LongString())
                                        }
                                        dst, mem := v.Args[0], v.Args[2]
-                                       mem = storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0)
+                                       mem = x.storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0)
                                        v.copyOf(mem)
                                }
                        }
@@ -758,7 +815,7 @@ func expandCalls(f *Func) {
                                switch w.Op {
                                case OpStructSelect, OpArraySelect, OpSelectN, OpArg:
                                        val2Preds[w] += 1
-                                       if debug {
+                                       if x.debug {
                                                fmt.Printf("v2p[%s] = %d\n", w.LongString(), val2Preds[w])
                                        }
                                }
@@ -767,18 +824,18 @@ func expandCalls(f *Func) {
                        case OpSelectN:
                                if _, ok := val2Preds[v]; !ok {
                                        val2Preds[v] = 0
-                                       if debug {
+                                       if x.debug {
                                                fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
                                        }
                                }
 
                        case OpArg:
-                               if !isAlreadyExpandedAggregateType(v.Type) {
+                               if !x.isAlreadyExpandedAggregateType(v.Type) {
                                        continue
                                }
                                if _, ok := val2Preds[v]; !ok {
                                        val2Preds[v] = 0
-                                       if debug {
+                                       if x.debug {
                                                fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
                                        }
                                }
@@ -789,7 +846,7 @@ func expandCalls(f *Func) {
                                which := v.AuxInt
                                aux := call.Aux.(*AuxCall)
                                pt := v.Type
-                               off := offsetFrom(sp, aux.OffsetOfResult(which), pt)
+                               off := x.offsetFrom(x.sp, aux.OffsetOfResult(which), pt)
                                v.copyOf(off)
                        }
                }
@@ -811,7 +868,7 @@ func expandCalls(f *Func) {
                if bi == bj {
                        return vi.ID < vj.ID
                }
-               return sdom.domorder(bi) > sdom.domorder(bj) // reverse the order to put dominators last.
+               return x.sdom.domorder(bi) > x.sdom.domorder(bj) // reverse the order to put dominators last.
        }
 
        // Accumulate order in allOrdered
@@ -845,7 +902,7 @@ func expandCalls(f *Func) {
                }
        }
 
-       common = make(map[selKey]*Value)
+       x.common = make(map[selKey]*Value)
        // Rewrite duplicate selectors as copies where possible.
        for i := len(allOrdered) - 1; i >= 0; i-- {
                v := allOrdered[i]
@@ -867,7 +924,7 @@ func expandCalls(f *Func) {
                offset := int64(0)
                switch v.Op {
                case OpStructSelect:
-                       if w.Type.Etype == types.TSTRUCT {
+                       if w.Type.Kind() == types.TSTRUCT {
                                offset = w.Type.FieldOff(int(v.AuxInt))
                        } else { // Immediate interface data artifact, offset is zero.
                                f.Fatalf("Expand calls interface data problem, func %s, v=%s, w=%s\n", f.Name, v.LongString(), w.LongString())
@@ -877,26 +934,26 @@ func expandCalls(f *Func) {
                case OpSelectN:
                        offset = w.Aux.(*AuxCall).OffsetOfResult(v.AuxInt)
                case OpInt64Hi:
-                       offset = hiOffset
+                       offset = x.hiOffset
                case OpInt64Lo:
-                       offset = lowOffset
+                       offset = x.lowOffset
                case OpStringLen, OpSliceLen, OpIData:
-                       offset = ptrSize
+                       offset = x.ptrSize
                case OpSliceCap:
-                       offset = 2 * ptrSize
+                       offset = 2 * x.ptrSize
                case OpComplexImag:
                        offset = size
                }
                sk := selKey{from: w, size: size, offset: offset, typ: typ}
-               dupe := common[sk]
+               dupe := x.common[sk]
                if dupe == nil {
-                       common[sk] = v
-               } else if sdom.IsAncestorEq(dupe.Block, v.Block) {
+                       x.common[sk] = v
+               } else if x.sdom.IsAncestorEq(dupe.Block, v.Block) {
                        v.copyOf(dupe)
                } else {
                        // Because values are processed in dominator order, the old common[s] will never dominate after a miss is seen.
                        // Installing the new value might match some future values.
-                       common[sk] = v
+                       x.common[sk] = v
                }
        }
 
@@ -905,7 +962,7 @@ func expandCalls(f *Func) {
 
        // Rewrite selectors.
        for i, v := range allOrdered {
-               if debug {
+               if x.debug {
                        b := v.Block
                        fmt.Printf("allOrdered[%d] = b%d, %s, uses=%d\n", i, b.ID, v.LongString(), v.Uses)
                }
@@ -916,13 +973,13 @@ func expandCalls(f *Func) {
                if v.Op == OpCopy {
                        continue
                }
-               locs := rewriteSelect(v, v, 0)
+               locs := x.rewriteSelect(v, v, 0)
                // Install new names.
                if v.Type.IsMemory() {
                        continue
                }
                // Leaf types may have debug locations
-               if !isAlreadyExpandedAggregateType(v.Type) {
+               if !x.isAlreadyExpandedAggregateType(v.Type) {
                        for _, l := range locs {
                                f.NamedValues[l] = append(f.NamedValues[l], v)
                        }
@@ -930,7 +987,7 @@ func expandCalls(f *Func) {
                        continue
                }
                // Not-leaf types that had debug locations need to lose them.
-               if ns, ok := namedSelects[v]; ok {
+               if ns, ok := x.namedSelects[v]; ok {
                        toDelete = append(toDelete, ns...)
                }
        }

diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index b4c3e5cfdfb73a6a3965caff7e7a67ff3f3d5809..32e6d09d1bc32281aebcbd0baf4f665a2f2292bb 100644 (file)
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -5,13 +5,13 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/arm64"
        "cmd/internal/obj/s390x"
        "cmd/internal/obj/x86"
        "cmd/internal/src"
-       "fmt"
        "testing"
 )
 
@@ -36,10 +36,10 @@ func testConfigArch(tb testing.TB, arch string) *Conf {
                tb.Fatalf("unknown arch %s", arch)
        }
        if ctxt.Arch.PtrSize != 8 {
-               tb.Fatal("dummyTypes is 64-bit only")
+               tb.Fatal("testTypes is 64-bit only")
        }
        c := &Conf{
-               config: NewConfig(arch, dummyTypes, ctxt, true),
+               config: NewConfig(arch, testTypes, ctxt, true),
                tb:     tb,
        }
        return c
@@ -53,131 +53,94 @@ type Conf struct {
 
 func (c *Conf) Frontend() Frontend {
        if c.fe == nil {
-               c.fe = DummyFrontend{t: c.tb, ctxt: c.config.ctxt}
+               c.fe = TestFrontend{t: c.tb, ctxt: c.config.ctxt}
        }
        return c.fe
 }
 
-// DummyFrontend is a test-only frontend.
+// TestFrontend is a test-only frontend.
 // It assumes 64 bit integers and pointers.
-type DummyFrontend struct {
+type TestFrontend struct {
        t    testing.TB
        ctxt *obj.Link
 }
 
-type DummyAuto struct {
-       t *types.Type
-       s string
-}
-
-func (d *DummyAuto) Typ() *types.Type {
-       return d.t
-}
-
-func (d *DummyAuto) String() string {
-       return d.s
-}
-
-func (d *DummyAuto) StorageClass() StorageClass {
-       return ClassAuto
-}
-
-func (d *DummyAuto) IsSynthetic() bool {
-       return false
-}
-
-func (d *DummyAuto) IsAutoTmp() bool {
-       return true
-}
-
-func (DummyFrontend) StringData(s string) *obj.LSym {
+func (TestFrontend) StringData(s string) *obj.LSym {
        return nil
 }
-func (DummyFrontend) Auto(pos src.XPos, t *types.Type) GCNode {
-       return &DummyAuto{t: t, s: "aDummyAuto"}
+func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Name {
+       n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"})
+       n.Class = ir.PAUTO
+       return n
 }
-func (d DummyFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
-       return LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 8}
+func (d TestFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
+       return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8}
 }
-func (d DummyFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
-       return LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off + 8}
+func (d TestFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
+       return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off + 8}
 }
-func (d DummyFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
        return LocalSlot{N: s.N, Type: s.Type.Elem().PtrTo(), Off: s.Off},
-               LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 8},
-               LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 16}
+               LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8},
+               LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 16}
 }
-func (d DummyFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
        if s.Type.Size() == 16 {
-               return LocalSlot{N: s.N, Type: dummyTypes.Float64, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Float64, Off: s.Off + 8}
+               return LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off + 8}
        }
-       return LocalSlot{N: s.N, Type: dummyTypes.Float32, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Float32, Off: s.Off + 4}
+       return LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off + 4}
 }
-func (d DummyFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
        if s.Type.IsSigned() {
-               return LocalSlot{N: s.N, Type: dummyTypes.Int32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off}
+               return LocalSlot{N: s.N, Type: testTypes.Int32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
        }
-       return LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off}
+       return LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
 }
-func (d DummyFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
+func (d TestFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
        return LocalSlot{N: s.N, Type: s.Type.FieldType(i), Off: s.Off + s.Type.FieldOff(i)}
 }
-func (d DummyFrontend) SplitArray(s LocalSlot) LocalSlot {
+func (d TestFrontend) SplitArray(s LocalSlot) LocalSlot {
        return LocalSlot{N: s.N, Type: s.Type.Elem(), Off: s.Off}
 }
 
-func (d DummyFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
+func (d TestFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
        return LocalSlot{N: parent.N, Type: t, Off: offset}
 }
-func (DummyFrontend) Line(_ src.XPos) string {
+func (TestFrontend) Line(_ src.XPos) string {
        return "unknown.go:0"
 }
-func (DummyFrontend) AllocFrame(f *Func) {
+func (TestFrontend) AllocFrame(f *Func) {
 }
-func (d DummyFrontend) Syslook(s string) *obj.LSym {
+func (d TestFrontend) Syslook(s string) *obj.LSym {
        return d.ctxt.Lookup(s)
 }
-func (DummyFrontend) UseWriteBarrier() bool {
+func (TestFrontend) UseWriteBarrier() bool {
        return true // only writebarrier_test cares
 }
-func (DummyFrontend) SetWBPos(pos src.XPos) {
+func (TestFrontend) SetWBPos(pos src.XPos) {
 }
 
-func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
-func (d DummyFrontend) Log() bool                            { return true }
+func (d TestFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
+func (d TestFrontend) Log() bool                            { return true }
 
-func (d DummyFrontend) Fatalf(_ src.XPos, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
-func (d DummyFrontend) Warnl(_ src.XPos, msg string, args ...interface{})  { d.t.Logf(msg, args...) }
-func (d DummyFrontend) Debug_checknil() bool                               { return false }
+func (d TestFrontend) Fatalf(_ src.XPos, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
+func (d TestFrontend) Warnl(_ src.XPos, msg string, args ...interface{})  { d.t.Logf(msg, args...) }
+func (d TestFrontend) Debug_checknil() bool                               { return false }
 
-func (d DummyFrontend) MyImportPath() string {
+func (d TestFrontend) MyImportPath() string {
        return "my/import/path"
 }
 
-var dummyTypes Types
+var testTypes Types
 
 func init() {
        // Initialize just enough of the universe and the types package to make our tests function.
        // TODO(josharian): move universe initialization to the types package,
        // so this test setup can share it.
 
-       types.Tconv = func(t *types.Type, flag, mode int) string {
-               return t.Etype.String()
-       }
-       types.Sconv = func(s *types.Sym, flag, mode int) string {
-               return "sym"
-       }
-       types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-               fmt.Fprintf(s, "sym")
-       }
-       types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-               fmt.Fprintf(s, "%v", t.Etype)
-       }
-       types.Dowidth = func(t *types.Type) {}
-
        for _, typ := range [...]struct {
                width int64
-               et    types.EType
+               et    types.Kind
        }{
                {1, types.TINT8},
                {1, types.TUINT8},
@@ -198,12 +161,12 @@ func init() {
                t.Align = uint8(typ.width)
                types.Types[typ.et] = t
        }
-       dummyTypes.SetTypPtrs()
+       testTypes.SetTypPtrs()
 }
 
-func (d DummyFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
+func (d TestFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
 
-func (d DummyFrontend) CanSSA(t *types.Type) bool {
-       // There are no un-SSAable types in dummy land.
+func (d TestFrontend) CanSSA(t *types.Type) bool {
+       // There are no un-SSAable types in test land.
        return true
 }

diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index e6f899a2c77b1e098166ef08592bec620e6917f2..de99a8d4af9cb89fd5c189b7d6c13f511525b268 100644 (file)
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -58,6 +58,11 @@ type Func struct {
        // of keys to make iteration order deterministic.
        Names []LocalSlot
 
+       // RegArgs is a slice of register-memory pairs that must be spilled and unspilled in the uncommon path of function entry.
+       RegArgs []ArgPair
+       // AuxCall describing parameters and results for this function.
+       OwnAux *AuxCall
+
        // WBLoads is a list of Blocks that branch on the write
        // barrier flag. Safe-points are disabled from the OpLoad that
        // reads the write-barrier flag until the control flow rejoins
@@ -377,13 +382,7 @@ func (b *Block) NewValue0I(pos src.XPos, op Op, t *types.Type, auxint int64) *Va
 }
 
 // NewValue returns a new value in the block with no arguments and an aux value.
-func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux interface{}) *Value {
-       if _, ok := aux.(int64); ok {
-               // Disallow int64 aux values. They should be in the auxint field instead.
-               // Maybe we want to allow this at some point, but for now we disallow it
-               // to prevent errors like using NewValue1A instead of NewValue1I.
-               b.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux)
-       }
+func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux Aux) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = 0
        v.Aux = aux
@@ -392,7 +391,7 @@ func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux interface{})
 }
 
 // NewValue returns a new value in the block with no arguments and both an auxint and aux values.
-func (b *Block) NewValue0IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}) *Value {
+func (b *Block) NewValue0IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = auxint
        v.Aux = aux
@@ -421,7 +420,7 @@ func (b *Block) NewValue1I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue1A returns a new value in the block with one argument and an aux value.
-func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg *Value) *Value {
+func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux Aux, arg *Value) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = 0
        v.Aux = aux
@@ -432,7 +431,7 @@ func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux interface{},
 }
 
 // NewValue1IA returns a new value in the block with one argument and both an auxint and aux values.
-func (b *Block) NewValue1IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}, arg *Value) *Value {
+func (b *Block) NewValue1IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg *Value) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = auxint
        v.Aux = aux
@@ -455,7 +454,7 @@ func (b *Block) NewValue2(pos src.XPos, op Op, t *types.Type, arg0, arg1 *Value)
 }
 
 // NewValue2A returns a new value in the block with two arguments and one aux values.
-func (b *Block) NewValue2A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg0, arg1 *Value) *Value {
+func (b *Block) NewValue2A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0, arg1 *Value) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = 0
        v.Aux = aux
@@ -480,7 +479,7 @@ func (b *Block) NewValue2I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue2IA returns a new value in the block with two arguments and both an auxint and aux values.
-func (b *Block) NewValue2IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}, arg0, arg1 *Value) *Value {
+func (b *Block) NewValue2IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg0, arg1 *Value) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = auxint
        v.Aux = aux
@@ -521,7 +520,7 @@ func (b *Block) NewValue3I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue3A returns a new value in the block with three argument and an aux value.
-func (b *Block) NewValue3A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *Value) *Value {
+func (b *Block) NewValue3A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0, arg1, arg2 *Value) *Value {
        v := b.Func.newValue(op, t, b, pos)
        v.AuxInt = 0
        v.Aux = aux
@@ -633,7 +632,7 @@ func (f *Func) ConstNil(t *types.Type) *Value {
 }
 func (f *Func) ConstEmptyString(t *types.Type) *Value {
        v := f.constVal(OpConstString, t, constEmptyStringMagic, false)
-       v.Aux = ""
+       v.Aux = StringToAux("")
        return v
 }
 func (f *Func) ConstOffPtrSP(t *types.Type, c int64, sp *Value) *Value {
@@ -777,7 +776,7 @@ func DebugNameMatch(evname, name string) bool {
 }
 
 func (f *Func) spSb() (sp, sb *Value) {
-       initpos := f.Entry.Pos
+       initpos := src.NoXPos // These are originally created with no position in ssa.go; if they are optimized out then recreated, should be the same.
        for _, v := range f.Entry.Values {
                if v.Op == OpSB {
                        sb = v
@@ -786,7 +785,7 @@ func (f *Func) spSb() (sp, sb *Value) {
                        sp = v
                }
                if sb != nil && sp != nil {
-                       break
+                       return
                }
        }
        if sb == nil {

diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go
index 568c6436f5bb5f767e56a50600399d49950d9d1e..276c444b9a88f01a3eeff5824c3550ebe205af03 100644 (file)
--- a/src/cmd/compile/internal/ssa/func_test.go
+++ b/src/cmd/compile/internal/ssa/func_test.go
@@ -232,7 +232,7 @@ func Bloc(name string, entries ...interface{}) bloc {
 }
 
 // Valu defines a value in a block.
-func Valu(name string, op Op, t *types.Type, auxint int64, aux interface{}, args ...string) valu {
+func Valu(name string, op Op, t *types.Type, auxint int64, aux Aux, args ...string) valu {
        return valu{name, op, t, auxint, aux, args}
 }
 
@@ -277,7 +277,7 @@ type valu struct {
        op     Op
        t      *types.Type
        auxint int64
-       aux    interface{}
+       aux    Aux
        args   []string
 }
 
@@ -402,12 +402,12 @@ func TestEquiv(t *testing.T) {
                        cfg.Fun("entry",
                                Bloc("entry",
                                        Valu("mem", OpInitMem, types.TypeMem, 0, nil),
-                                       Valu("a", OpConst64, cfg.config.Types.Int64, 0, 14),
+                                       Valu("a", OpConstString, cfg.config.Types.String, 0, StringToAux("foo")),
                                        Exit("mem"))),
                        cfg.Fun("entry",
                                Bloc("entry",
                                        Valu("mem", OpInitMem, types.TypeMem, 0, nil),
-                                       Valu("a", OpConst64, cfg.config.Types.Int64, 0, 26),
+                                       Valu("a", OpConstString, cfg.config.Types.String, 0, StringToAux("bar")),
                                        Exit("mem"))),
                },
                // value args different

diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules
index fbc12fd67219a87050a0c61a9238408044f912b1..df03cb71a6e3c54608c629af0dfb68eb2e3f8470 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/386.rules
+++ b/src/cmd/compile/internal/ssa/gen/386.rules
@@ -475,7 +475,7 @@
 (CMPB (MOVLconst [c]) x) => (InvertFlags (CMPBconst x [int8(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP(L|W|B) x y) && x.ID > y.ID => (InvertFlags (CMP(L|W|B) y x))
+(CMP(L|W|B) x y) && canonLessThan(x,y) => (InvertFlags (CMP(L|W|B) y x))
 
 // strength reduction
 // Assumes that the following costs from https://gmplib.org/~tege/x86-timing.pdf:

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index a866a967b92834014eeeab19aed8c10f7aec5774..3c75bcfa05f61f8974d60b5c7051685f72d7e0c6 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -361,31 +361,31 @@
 // Adjust zeros to be a multiple of 16 bytes.
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 > 8 && config.useSSE =>
        (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16])
-               (MOVOstore destptr (MOVOconst [0]) mem))
+               (MOVOstorezero destptr mem))
 
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 <= 8 && config.useSSE =>
        (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16])
                (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
 
 (Zero [16] destptr mem) && config.useSSE =>
-       (MOVOstore destptr (MOVOconst [0]) mem)
+       (MOVOstorezero destptr mem)
 (Zero [32] destptr mem) && config.useSSE =>
-       (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-               (MOVOstore destptr (MOVOconst [0]) mem))
+       (MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+               (MOVOstorezero destptr mem))
 (Zero [48] destptr mem) && config.useSSE =>
-       (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0])
-               (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-                       (MOVOstore destptr (MOVOconst [0]) mem)))
+       (MOVOstorezero (OffPtr <destptr.Type> destptr [32])
+               (MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+                       (MOVOstorezero destptr mem)))
 (Zero [64] destptr mem) && config.useSSE =>
-       (MOVOstore (OffPtr <destptr.Type> destptr [48]) (MOVOconst [0])
-               (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0])
-                       (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-                               (MOVOstore destptr (MOVOconst [0]) mem))))
+       (MOVOstorezero (OffPtr <destptr.Type> destptr [48])
+               (MOVOstorezero (OffPtr <destptr.Type> destptr [32])
+                       (MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+                               (MOVOstorezero destptr mem))))
 
 // Medium zeroing uses a duff device.
 (Zero [s] destptr mem)
        && s > 64 && s <= 1024 && s%16 == 0 && !config.noDuffDevice =>
-       (DUFFZERO [s] destptr (MOVOconst [0]) mem)
+       (DUFFZERO [s] destptr mem)
 
 // Large zeroing uses REP STOSQ.
 (Zero [s] destptr mem)
@@ -459,7 +459,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG ...) => (LoweredGetG ...)
+(GetG mem) && !base.Flag.ABIWrap => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
@@ -916,7 +916,7 @@
 (CMPB (MOVLconst [c]) x) => (InvertFlags (CMPBconst x [int8(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP(Q|L|W|B) x y) && x.ID > y.ID => (InvertFlags (CMP(Q|L|W|B) y x))
+(CMP(Q|L|W|B) x y) && canonLessThan(x,y) => (InvertFlags (CMP(Q|L|W|B) y x))
 
 // Using MOVZX instead of AND is cheaper.
 (AND(Q|L)const [  0xFF] x) => (MOVBQZX x)
@@ -1900,7 +1900,7 @@
   && c.Val() == 0
   && c2.Val() == 0
   && clobber(x)
-  => (MOVOstore [c2.Off32()] {s} p (MOVOconst [0]) mem)
+  => (MOVOstorezero [c2.Off32()] {s} p mem)
 
 // Combine stores into larger (unaligned) stores. Little endian.
 (MOVBstore [i] {s} p (SHR(W|L|Q)const [8] w) x:(MOVBstore [i-1] {s} p w mem))

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index de5372670b3657981b605d3d75928dd74c2cda06..043162e544e5e5e944c3c7f5df88d52c1a25f4ae 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -44,7 +44,7 @@ var regNamesAMD64 = []string{
        "R11",
        "R12",
        "R13",
-       "R14",
+       "g", // a.k.a. R14
        "R15",
        "X0",
        "X1",
@@ -61,7 +61,7 @@ var regNamesAMD64 = []string{
        "X12",
        "X13",
        "X14",
-       "X15",
+       "X15", // constant 0 in ABIInternal
 
        // If you add registers, update asyncPreempt in runtime
 
@@ -96,11 +96,14 @@ func init() {
                cx         = buildReg("CX")
                dx         = buildReg("DX")
                bx         = buildReg("BX")
-               gp         = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
-               fp         = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15")
+               gp         = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15")
+               g          = buildReg("g")
+               fp         = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14")
+               x15        = buildReg("X15")
                gpsp       = gp | buildReg("SP")
                gpspsb     = gpsp | buildReg("SB")
-               callerSave = gp | fp
+               gpspsbg    = gpspsb | g
+               callerSave = gp | fp | g // runtime.setg (and anything calling it) may clobber g
        )
        // Common slices of register masks
        var (
@@ -113,10 +116,10 @@ func init() {
                gp01           = regInfo{inputs: nil, outputs: gponly}
                gp11           = regInfo{inputs: []regMask{gp}, outputs: gponly}
                gp11sp         = regInfo{inputs: []regMask{gpsp}, outputs: gponly}
-               gp11sb         = regInfo{inputs: []regMask{gpspsb}, outputs: gponly}
+               gp11sb         = regInfo{inputs: []regMask{gpspsbg}, outputs: gponly}
                gp21           = regInfo{inputs: []regMask{gp, gp}, outputs: gponly}
                gp21sp         = regInfo{inputs: []regMask{gpsp, gp}, outputs: gponly}
-               gp21sb         = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly}
+               gp21sb         = regInfo{inputs: []regMask{gpspsbg, gpsp}, outputs: gponly}
                gp21shift      = regInfo{inputs: []regMask{gp, cx}, outputs: []regMask{gp}}
                gp11div        = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{ax, dx}}
                gp21hmul       = regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{dx}, clobbers: ax}
@@ -125,9 +128,9 @@ func init() {
 
                gp2flags     = regInfo{inputs: []regMask{gpsp, gpsp}}
                gp1flags     = regInfo{inputs: []regMask{gpsp}}
-               gp0flagsLoad = regInfo{inputs: []regMask{gpspsb, 0}}
-               gp1flagsLoad = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-               gp2flagsLoad = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}}
+               gp0flagsLoad = regInfo{inputs: []regMask{gpspsbg, 0}}
+               gp1flagsLoad = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+               gp2flagsLoad = regInfo{inputs: []regMask{gpspsbg, gpsp, gpsp, 0}}
                flagsgp      = regInfo{inputs: nil, outputs: gponly}
 
                gp11flags      = regInfo{inputs: []regMask{gp}, outputs: []regMask{gp, 0}}
@@ -136,24 +139,24 @@ func init() {
                readflags = regInfo{inputs: nil, outputs: gponly}
                flagsgpax = regInfo{inputs: nil, clobbers: ax, outputs: []regMask{gp &^ ax}}
 
-               gpload      = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly}
-               gp21load    = regInfo{inputs: []regMask{gp, gpspsb, 0}, outputs: gponly}
-               gploadidx   = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly}
-               gp21loadidx = regInfo{inputs: []regMask{gp, gpspsb, gpsp, 0}, outputs: gponly}
+               gpload      = regInfo{inputs: []regMask{gpspsbg, 0}, outputs: gponly}
+               gp21load    = regInfo{inputs: []regMask{gp, gpspsbg, 0}, outputs: gponly}
+               gploadidx   = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}, outputs: gponly}
+               gp21loadidx = regInfo{inputs: []regMask{gp, gpspsbg, gpsp, 0}, outputs: gponly}
                gp21pax     = regInfo{inputs: []regMask{gp &^ ax, gp}, outputs: []regMask{gp &^ ax}, clobbers: ax}
 
-               gpstore         = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-               gpstoreconst    = regInfo{inputs: []regMask{gpspsb, 0}}
-               gpstoreidx      = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}}
-               gpstoreconstidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-               gpstorexchg     = regInfo{inputs: []regMask{gp, gpspsb, 0}, outputs: []regMask{gp}}
+               gpstore         = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+               gpstoreconst    = regInfo{inputs: []regMask{gpspsbg, 0}}
+               gpstoreidx      = regInfo{inputs: []regMask{gpspsbg, gpsp, gpsp, 0}}
+               gpstoreconstidx = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+               gpstorexchg     = regInfo{inputs: []regMask{gp, gpspsbg, 0}, outputs: []regMask{gp}}
                cmpxchg         = regInfo{inputs: []regMask{gp, ax, gp, 0}, outputs: []regMask{gp, 0}, clobbers: ax}
 
                fp01        = regInfo{inputs: nil, outputs: fponly}
                fp21        = regInfo{inputs: []regMask{fp, fp}, outputs: fponly}
                fp31        = regInfo{inputs: []regMask{fp, fp, fp}, outputs: fponly}
-               fp21load    = regInfo{inputs: []regMask{fp, gpspsb, 0}, outputs: fponly}
-               fp21loadidx = regInfo{inputs: []regMask{fp, gpspsb, gpspsb, 0}, outputs: fponly}
+               fp21load    = regInfo{inputs: []regMask{fp, gpspsbg, 0}, outputs: fponly}
+               fp21loadidx = regInfo{inputs: []regMask{fp, gpspsbg, gpspsb, 0}, outputs: fponly}
                fpgp        = regInfo{inputs: fponly, outputs: gponly}
                gpfp        = regInfo{inputs: gponly, outputs: fponly}
                fp11        = regInfo{inputs: fponly, outputs: fponly}
@@ -684,19 +687,20 @@ func init() {
                // Note: LEAx{1,2,4,8} must not have OpSB as either argument.
 
                // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address
-               {name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8", faultOnNilArg0: true, symEffect: "Read"},  // load byte from arg0+auxint+aux. arg1=mem.  Zero extend.
-               {name: "MOVBQSXload", argLength: 2, reg: gpload, asm: "MOVBQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-               {name: "MOVWload", argLength: 2, reg: gpload, asm: "MOVWLZX", aux: "SymOff", typ: "UInt16", faultOnNilArg0: true, symEffect: "Read"}, // load 2 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
-               {name: "MOVWQSXload", argLength: 2, reg: gpload, asm: "MOVWQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-               {name: "MOVLload", argLength: 2, reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32", faultOnNilArg0: true, symEffect: "Read"},    // load 4 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
-               {name: "MOVLQSXload", argLength: 2, reg: gpload, asm: "MOVLQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-               {name: "MOVQload", argLength: 2, reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64", faultOnNilArg0: true, symEffect: "Read"},    // load 8 bytes from arg0+auxint+aux. arg1=mem
-               {name: "MOVBstore", argLength: 3, reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store byte in arg1 to arg0+auxint+aux. arg2=mem
-               {name: "MOVWstore", argLength: 3, reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem
-               {name: "MOVLstore", argLength: 3, reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem
-               {name: "MOVQstore", argLength: 3, reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem
-               {name: "MOVOload", argLength: 2, reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128", faultOnNilArg0: true, symEffect: "Read"},  // load 16 bytes from arg0+auxint+aux. arg1=mem
-               {name: "MOVOstore", argLength: 3, reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},  // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8", faultOnNilArg0: true, symEffect: "Read"},                                   // load byte from arg0+auxint+aux. arg1=mem.  Zero extend.
+               {name: "MOVBQSXload", argLength: 2, reg: gpload, asm: "MOVBQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+               {name: "MOVWload", argLength: 2, reg: gpload, asm: "MOVWLZX", aux: "SymOff", typ: "UInt16", faultOnNilArg0: true, symEffect: "Read"},                                  // load 2 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
+               {name: "MOVWQSXload", argLength: 2, reg: gpload, asm: "MOVWQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+               {name: "MOVLload", argLength: 2, reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32", faultOnNilArg0: true, symEffect: "Read"},                                     // load 4 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
+               {name: "MOVLQSXload", argLength: 2, reg: gpload, asm: "MOVLQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+               {name: "MOVQload", argLength: 2, reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64", faultOnNilArg0: true, symEffect: "Read"},                                     // load 8 bytes from arg0+auxint+aux. arg1=mem
+               {name: "MOVBstore", argLength: 3, reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store byte in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVWstore", argLength: 3, reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVLstore", argLength: 3, reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVQstore", argLength: 3, reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVOload", argLength: 2, reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128", faultOnNilArg0: true, symEffect: "Read"},                                   // load 16 bytes from arg0+auxint+aux. arg1=mem
+               {name: "MOVOstore", argLength: 3, reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                   // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem
+               {name: "MOVOstorezero", argLength: 2, reg: regInfo{inputs: []regMask{gpspsb, 0}}, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"}, // store 16 bytes of zero to arg0+auxint+aux. arg1=mem
 
                // indexed loads/stores
                {name: "MOVBloadidx1", argLength: 3, reg: gploadidx, commutative: true, asm: "MOVBLZX", scale: 1, aux: "SymOff", typ: "UInt8", symEffect: "Read"},  // load a byte from arg0+arg1+auxint+aux. arg2=mem
@@ -735,22 +739,20 @@ func init() {
                {name: "MOVQstoreconstidx8", argLength: 3, reg: gpstoreconstidx, asm: "MOVQ", scale: 8, aux: "SymValAndOff", typ: "Mem", symEffect: "Write"},                    // store 8 bytes of ... 8*arg1 ...
 
                // arg0 = pointer to start of memory to zero
-               // arg1 = value to store (will always be zero)
-               // arg2 = mem
+               // arg1 = mem
                // auxint = # of bytes to zero
                // returns mem
                {
                        name:      "DUFFZERO",
                        aux:       "Int64",
-                       argLength: 3,
+                       argLength: 2,
                        reg: regInfo{
-                               inputs:   []regMask{buildReg("DI"), buildReg("X0")},
+                               inputs:   []regMask{buildReg("DI")},
                                clobbers: buildReg("DI"),
                        },
                        faultOnNilArg0: true,
                        unsafePoint:    true, // FP maintenance around DUFFCOPY can be clobbered by interrupts
                },
-               {name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Int128", aux: "Int128", rematerializeable: true},
 
                // arg0 = address of memory to zero
                // arg1 = # of 8-byte words to zero
@@ -830,7 +832,7 @@ func init() {
                {name: "LoweredNilCheck", argLength: 2, reg: regInfo{inputs: []regMask{gpsp}}, clobberFlags: true, nilCheck: true, faultOnNilArg0: true},
                // LoweredWB invokes runtime.gcWriteBarrier. arg0=destptr, arg1=srcptr, arg2=mem, aux=runtime.gcWriteBarrier
                // It saves all GP registers if necessary, but may clobber others.
-               {name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("DI"), buildReg("AX CX DX BX BP SI R8 R9")}, clobbers: callerSave &^ gp}, clobberFlags: true, aux: "Sym", symEffect: "None"},
+               {name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("DI"), buildReg("AX CX DX BX BP SI R8 R9")}, clobbers: callerSave &^ (gp | g)}, clobberFlags: true, aux: "Sym", symEffect: "None"},
 
                {name: "LoweredHasCPUFeature", argLength: 0, reg: gp01, rematerializeable: true, typ: "UInt64", aux: "Sym", symEffect: "None"},
 
@@ -935,6 +937,7 @@ func init() {
                regnames:        regNamesAMD64,
                gpregmask:       gp,
                fpregmask:       fp,
+               specialregmask:  x15,
                framepointerreg: int8(num["BP"]),
                linkreg:         -1, // not used
        })

diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index 11c36b5da3567ed6728cdfc191d5676e28e401e6..de0df363e496402389719e6f289fd0e359074c51 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -507,7 +507,7 @@
 (TEQ x (MOVWconst [c])) => (TEQconst [c] x)
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP x y) && x.ID > y.ID => (InvertFlags (CMP y x))
+(CMP x y) && canonLessThan(x,y) => (InvertFlags (CMP y x))
 
 // don't extend after proper load
 // MOVWreg instruction is not emitted if src and dst registers are same, but it ensures the type.

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 3f4d0c1c52769e33091e92312800b77bda669617..a0e2a0d5e2722e6e88df9a8c8fc382560d95a82f 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1151,7 +1151,7 @@
 (CMPW (MOVDconst [c]) x) => (InvertFlags (CMPWconst [int32(c)] x))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW) y x))
+((CMP|CMPW) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW) y x))
 
 // mul-neg => mneg
 (NEG (MUL x y)) => (MNEG x y)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 87db2b7c9d906a950746080150bfaf84e67e2de9..b0bc9c78ff6ca2dc8c42a4209b8844254062226d 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -478,20 +478,24 @@ func init() {
                // pseudo-ops
                {name: "LoweredNilCheck", argLength: 2, reg: regInfo{inputs: []regMask{gpg}}, nilCheck: true, faultOnNilArg0: true}, // panic if arg0 is nil.  arg1=mem.
 
-               {name: "Equal", argLength: 1, reg: readflags},         // bool, true flags encode x==y false otherwise.
-               {name: "NotEqual", argLength: 1, reg: readflags},      // bool, true flags encode x!=y false otherwise.
-               {name: "LessThan", argLength: 1, reg: readflags},      // bool, true flags encode signed x<y false otherwise.
-               {name: "LessEqual", argLength: 1, reg: readflags},     // bool, true flags encode signed x<=y false otherwise.
-               {name: "GreaterThan", argLength: 1, reg: readflags},   // bool, true flags encode signed x>y false otherwise.
-               {name: "GreaterEqual", argLength: 1, reg: readflags},  // bool, true flags encode signed x>=y false otherwise.
-               {name: "LessThanU", argLength: 1, reg: readflags},     // bool, true flags encode unsigned x<y false otherwise.
-               {name: "LessEqualU", argLength: 1, reg: readflags},    // bool, true flags encode unsigned x<=y false otherwise.
-               {name: "GreaterThanU", argLength: 1, reg: readflags},  // bool, true flags encode unsigned x>y false otherwise.
-               {name: "GreaterEqualU", argLength: 1, reg: readflags}, // bool, true flags encode unsigned x>=y false otherwise.
-               {name: "LessThanF", argLength: 1, reg: readflags},     // bool, true flags encode floating-point x<y false otherwise.
-               {name: "LessEqualF", argLength: 1, reg: readflags},    // bool, true flags encode floating-point x<=y false otherwise.
-               {name: "GreaterThanF", argLength: 1, reg: readflags},  // bool, true flags encode floating-point x>y false otherwise.
-               {name: "GreaterEqualF", argLength: 1, reg: readflags}, // bool, true flags encode floating-point x>=y false otherwise.
+               {name: "Equal", argLength: 1, reg: readflags},            // bool, true flags encode x==y false otherwise.
+               {name: "NotEqual", argLength: 1, reg: readflags},         // bool, true flags encode x!=y false otherwise.
+               {name: "LessThan", argLength: 1, reg: readflags},         // bool, true flags encode signed x<y false otherwise.
+               {name: "LessEqual", argLength: 1, reg: readflags},        // bool, true flags encode signed x<=y false otherwise.
+               {name: "GreaterThan", argLength: 1, reg: readflags},      // bool, true flags encode signed x>y false otherwise.
+               {name: "GreaterEqual", argLength: 1, reg: readflags},     // bool, true flags encode signed x>=y false otherwise.
+               {name: "LessThanU", argLength: 1, reg: readflags},        // bool, true flags encode unsigned x<y false otherwise.
+               {name: "LessEqualU", argLength: 1, reg: readflags},       // bool, true flags encode unsigned x<=y false otherwise.
+               {name: "GreaterThanU", argLength: 1, reg: readflags},     // bool, true flags encode unsigned x>y false otherwise.
+               {name: "GreaterEqualU", argLength: 1, reg: readflags},    // bool, true flags encode unsigned x>=y false otherwise.
+               {name: "LessThanF", argLength: 1, reg: readflags},        // bool, true flags encode floating-point x<y false otherwise.
+               {name: "LessEqualF", argLength: 1, reg: readflags},       // bool, true flags encode floating-point x<=y false otherwise.
+               {name: "GreaterThanF", argLength: 1, reg: readflags},     // bool, true flags encode floating-point x>y false otherwise.
+               {name: "GreaterEqualF", argLength: 1, reg: readflags},    // bool, true flags encode floating-point x>=y false otherwise.
+               {name: "NotLessThanF", argLength: 1, reg: readflags},     // bool, true flags encode floating-point x>=y || x is unordered with y, false otherwise.
+               {name: "NotLessEqualF", argLength: 1, reg: readflags},    // bool, true flags encode floating-point x>y || x is unordered with y, false otherwise.
+               {name: "NotGreaterThanF", argLength: 1, reg: readflags},  // bool, true flags encode floating-point x<=y || x is unordered with y, false otherwise.
+               {name: "NotGreaterEqualF", argLength: 1, reg: readflags}, // bool, true flags encode floating-point x<y || x is unordered with y, false otherwise.
                // duffzero
                // arg0 = address of memory to zero
                // arg1 = mem

diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index c06404617297a5877b81d186811c43e37ff775e2..a762be65d42595175d7a3d45cf96df4da8ebde6c 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -1088,7 +1088,7 @@
 (CMPWU (MOVDconst [c]) y) && isU16Bit(c) => (InvertFlags (CMPWUconst y [int32(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW|CMPU|CMPWU) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
+((CMP|CMPW|CMPU|CMPWU) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
 
 // ISEL auxInt values 0=LT 1=GT 2=EQ   arg2 ? arg0 : arg1
 // ISEL auxInt values 4=GE 5=LE 6=NE   arg2 ? arg1 : arg0

diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index 39949edbc2b1a1498464c1466c4b7fb3ac035f25..c3421da0a242cc37f7e2ab8beb011ce8db411962 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -663,8 +663,8 @@
 ((OR|XOR)W x (MOVDconst [c])) => ((OR|XOR)Wconst [int32(c)] x)
 
 // Constant shifts.
-(S(LD|RD|RAD) x (MOVDconst [c])) => (S(LD|RD|RAD)const x [int8(c&63)])
-(S(LW|RW|RAW) x (MOVDconst [c])) && c&32 == 0 => (S(LW|RW|RAW)const x [int8(c&31)])
+(S(LD|RD|RAD) x (MOVDconst [c])) => (S(LD|RD|RAD)const x [uint8(c&63)])
+(S(LW|RW|RAW) x (MOVDconst [c])) && c&32 == 0 => (S(LW|RW|RAW)const x [uint8(c&31)])
 (S(LW|RW)     _ (MOVDconst [c])) && c&32 != 0 => (MOVDconst [0])
 (SRAW         x (MOVDconst [c])) && c&32 != 0 => (SRAWconst x [31])
 
@@ -685,8 +685,8 @@
 (SRAW x (MOV(W|H|B|WZ|HZ|BZ)reg y)) => (SRAW x y)
 
 // Match rotate by constant.
-(RLLG x (MOVDconst [c])) => (RISBGZ x {s390x.NewRotateParams(0, 63, int8(c&63))})
-(RLL  x (MOVDconst [c])) => (RLLconst x [int8(c&31)])
+(RLLG x (MOVDconst [c])) => (RISBGZ x {s390x.NewRotateParams(0, 63, uint8(c&63))})
+(RLL  x (MOVDconst [c])) => (RLLconst x [uint8(c&31)])
 
 // Match rotate by constant pattern.
 ((ADD|OR|XOR)  (SLDconst x [c]) (SRDconst x [64-c])) => (RISBGZ x {s390x.NewRotateParams(0, 63, c)})
@@ -705,10 +705,10 @@
 (CMP(W|WU) (MOVDconst [c]) x) => (InvertFlags (CMP(W|WU)const x [int32(c)]))
 
 // Match (x >> c) << d to 'rotate then insert selected bits [into zero]'.
-(SLDconst (SRDconst x [c]) [d]) => (RISBGZ x {s390x.NewRotateParams(max8(0, c-d), 63-d, (d-c)&63)})
+(SLDconst (SRDconst x [c]) [d]) => (RISBGZ x {s390x.NewRotateParams(uint8(max8(0, int8(c-d))), 63-d, uint8(int8(d-c)&63))})
 
 // Match (x << c) >> d to 'rotate then insert selected bits [into zero]'.
-(SRDconst (SLDconst x [c]) [d]) => (RISBGZ x {s390x.NewRotateParams(d, min8(63, 63-c+d), (c-d)&63)})
+(SRDconst (SLDconst x [c]) [d]) => (RISBGZ x {s390x.NewRotateParams(d, uint8(min8(63, int8(63-c+d))), uint8(int8(c-d)&63))})
 
 // Absorb input zero extension into 'rotate then insert selected bits [into zero]'.
 (RISBGZ (MOVWZreg x) {r}) && r.InMerge(0xffffffff) != nil => (RISBGZ x {*r.InMerge(0xffffffff)})
@@ -785,7 +785,7 @@
   => (RISBGZ x {s390x.NewRotateParams(r.Start, r.Start, -r.Start&63)})
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW|CMPU|CMPWU) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
+((CMP|CMPW|CMPU|CMPWU) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
 
 // Use sign/zero extend instead of RISBGZ.
 (RISBGZ x {r}) && r == s390x.NewRotateParams(56, 63, 0) => (MOVBZreg x)
@@ -818,18 +818,18 @@
 
 // c = 2ˣ + 2ʸ => c - 2ˣ = 2ʸ
 (MULL(D|W)const <t> x [c]) && isPowerOfTwo32(c&(c-1))
-  => ((ADD|ADDW) (SL(D|W)const <t> x [int8(log32(c&(c-1)))])
-                 (SL(D|W)const <t> x [int8(log32(c&^(c-1)))]))
+  => ((ADD|ADDW) (SL(D|W)const <t> x [uint8(log32(c&(c-1)))])
+                 (SL(D|W)const <t> x [uint8(log32(c&^(c-1)))]))
 
 // c = 2ʸ - 2ˣ => c + 2ˣ = 2ʸ
 (MULL(D|W)const <t> x [c]) && isPowerOfTwo32(c+(c&^(c-1)))
-  => ((SUB|SUBW) (SL(D|W)const <t> x [int8(log32(c+(c&^(c-1))))])
-                 (SL(D|W)const <t> x [int8(log32(c&^(c-1)))]))
+  => ((SUB|SUBW) (SL(D|W)const <t> x [uint8(log32(c+(c&^(c-1))))])
+                 (SL(D|W)const <t> x [uint8(log32(c&^(c-1)))]))
 
 // c = 2ˣ - 2ʸ => -c + 2ˣ = 2ʸ
 (MULL(D|W)const <t> x [c]) && isPowerOfTwo32(-c+(-c&^(-c-1)))
-  => ((SUB|SUBW) (SL(D|W)const <t> x [int8(log32(-c&^(-c-1)))])
-                 (SL(D|W)const <t> x [int8(log32(-c+(-c&^(-c-1))))]))
+  => ((SUB|SUBW) (SL(D|W)const <t> x [uint8(log32(-c&^(-c-1)))])
+                 (SL(D|W)const <t> x [uint8(log32(-c+(-c&^(-c-1))))]))
 
 // Fold ADD into MOVDaddr. Odd offsets from SB shouldn't be folded (LARL can't handle them).
 (ADDconst [c] (MOVDaddr [d] {s} x:(SB))) && ((c+d)&1 == 0) && is32Bit(int64(c)+int64(d)) => (MOVDaddr [c+d] {s} x)

diff --git a/src/cmd/compile/internal/ssa/gen/S390XOps.go b/src/cmd/compile/internal/ssa/gen/S390XOps.go
index f0cf2f2f6e62d681c23b902a06a976152e260595..b24fd619422c292cd7ad67451d2106df28d67531 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/S390XOps.go
+++ b/src/cmd/compile/internal/ssa/gen/S390XOps.go
@@ -330,27 +330,27 @@ func init() {
                {name: "LTDBR", argLength: 1, reg: fp1flags, asm: "LTDBR", typ: "Flags"}, // arg0 compare to 0, f64
                {name: "LTEBR", argLength: 1, reg: fp1flags, asm: "LTEBR", typ: "Flags"}, // arg0 compare to 0, f32
 
-               {name: "SLD", argLength: 2, reg: sh21, asm: "SLD"},                   // arg0 << arg1, shift amount is mod 64
-               {name: "SLW", argLength: 2, reg: sh21, asm: "SLW"},                   // arg0 << arg1, shift amount is mod 64
-               {name: "SLDconst", argLength: 1, reg: gp11, asm: "SLD", aux: "Int8"}, // arg0 << auxint, shift amount 0-63
-               {name: "SLWconst", argLength: 1, reg: gp11, asm: "SLW", aux: "Int8"}, // arg0 << auxint, shift amount 0-31
+               {name: "SLD", argLength: 2, reg: sh21, asm: "SLD"},                    // arg0 << arg1, shift amount is mod 64
+               {name: "SLW", argLength: 2, reg: sh21, asm: "SLW"},                    // arg0 << arg1, shift amount is mod 64
+               {name: "SLDconst", argLength: 1, reg: gp11, asm: "SLD", aux: "UInt8"}, // arg0 << auxint, shift amount 0-63
+               {name: "SLWconst", argLength: 1, reg: gp11, asm: "SLW", aux: "UInt8"}, // arg0 << auxint, shift amount 0-31
 
-               {name: "SRD", argLength: 2, reg: sh21, asm: "SRD"},                   // unsigned arg0 >> arg1, shift amount is mod 64
-               {name: "SRW", argLength: 2, reg: sh21, asm: "SRW"},                   // unsigned uint32(arg0) >> arg1, shift amount is mod 64
-               {name: "SRDconst", argLength: 1, reg: gp11, asm: "SRD", aux: "Int8"}, // unsigned arg0 >> auxint, shift amount 0-63
-               {name: "SRWconst", argLength: 1, reg: gp11, asm: "SRW", aux: "Int8"}, // unsigned uint32(arg0) >> auxint, shift amount 0-31
+               {name: "SRD", argLength: 2, reg: sh21, asm: "SRD"},                    // unsigned arg0 >> arg1, shift amount is mod 64
+               {name: "SRW", argLength: 2, reg: sh21, asm: "SRW"},                    // unsigned uint32(arg0) >> arg1, shift amount is mod 64
+               {name: "SRDconst", argLength: 1, reg: gp11, asm: "SRD", aux: "UInt8"}, // unsigned arg0 >> auxint, shift amount 0-63
+               {name: "SRWconst", argLength: 1, reg: gp11, asm: "SRW", aux: "UInt8"}, // unsigned uint32(arg0) >> auxint, shift amount 0-31
 
                // Arithmetic shifts clobber flags.
-               {name: "SRAD", argLength: 2, reg: sh21, asm: "SRAD", clobberFlags: true},                   // signed arg0 >> arg1, shift amount is mod 64
-               {name: "SRAW", argLength: 2, reg: sh21, asm: "SRAW", clobberFlags: true},                   // signed int32(arg0) >> arg1, shift amount is mod 64
-               {name: "SRADconst", argLength: 1, reg: gp11, asm: "SRAD", aux: "Int8", clobberFlags: true}, // signed arg0 >> auxint, shift amount 0-63
-               {name: "SRAWconst", argLength: 1, reg: gp11, asm: "SRAW", aux: "Int8", clobberFlags: true}, // signed int32(arg0) >> auxint, shift amount 0-31
+               {name: "SRAD", argLength: 2, reg: sh21, asm: "SRAD", clobberFlags: true},                    // signed arg0 >> arg1, shift amount is mod 64
+               {name: "SRAW", argLength: 2, reg: sh21, asm: "SRAW", clobberFlags: true},                    // signed int32(arg0) >> arg1, shift amount is mod 64
+               {name: "SRADconst", argLength: 1, reg: gp11, asm: "SRAD", aux: "UInt8", clobberFlags: true}, // signed arg0 >> auxint, shift amount 0-63
+               {name: "SRAWconst", argLength: 1, reg: gp11, asm: "SRAW", aux: "UInt8", clobberFlags: true}, // signed int32(arg0) >> auxint, shift amount 0-31
 
                // Rotate instructions.
                // Note: no RLLGconst - use RISBGZ instead.
-               {name: "RLLG", argLength: 2, reg: sh21, asm: "RLLG"},                 // arg0 rotate left arg1, rotate amount 0-63
-               {name: "RLL", argLength: 2, reg: sh21, asm: "RLL"},                   // arg0 rotate left arg1, rotate amount 0-31
-               {name: "RLLconst", argLength: 1, reg: gp11, asm: "RLL", aux: "Int8"}, // arg0 rotate left auxint, rotate amount 0-31
+               {name: "RLLG", argLength: 2, reg: sh21, asm: "RLLG"},                  // arg0 rotate left arg1, rotate amount 0-63
+               {name: "RLL", argLength: 2, reg: sh21, asm: "RLL"},                    // arg0 rotate left arg1, rotate amount 0-31
+               {name: "RLLconst", argLength: 1, reg: gp11, asm: "RLL", aux: "UInt8"}, // arg0 rotate left auxint, rotate amount 0-31
 
                // Rotate then (and|or|xor|insert) selected bits instructions.
                //

diff --git a/src/cmd/compile/internal/ssa/gen/dec64.rules b/src/cmd/compile/internal/ssa/gen/dec64.rules
index 9297ed8d2e0a04aeedb3d831210704c6f6205307..b0f10d0a0f4e9f21faaceba703ab1579f296495e 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/dec64.rules
+++ b/src/cmd/compile/internal/ssa/gen/dec64.rules
@@ -42,20 +42,20 @@
                (Store {hi.Type} dst hi mem))
 
 // These are not enabled during decomposeBuiltin if late call expansion, but they are always enabled for softFloat
-(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.Int32> {n} [off+4])
     (Arg <typ.UInt32> {n} [off]))
-(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")  =>
+(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")  =>
   (Int64Make
     (Arg <typ.UInt32> {n} [off+4])
     (Arg <typ.UInt32> {n} [off]))
 
-(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.Int32> {n} [off])
     (Arg <typ.UInt32> {n} [off+4]))
-(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.UInt32> {n} [off])
     (Arg <typ.UInt32> {n} [off+4]))

diff --git a/src/cmd/compile/internal/ssa/gen/decArgs.rules b/src/cmd/compile/internal/ssa/gen/decArgs.rules
deleted file mode 100644 (file)
index 1c9a0bb..0000000
--- a/src/cmd/compile/internal/ssa/gen/decArgs.rules
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Decompose compound argument values
-// Do this early to simplify tracking names for debugging.
-
-(Arg {n} [off]) && v.Type.IsString() =>
-  (StringMake
-    (Arg <typ.BytePtr> {n} [off])
-    (Arg <typ.Int> {n} [off+int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsSlice() =>
-  (SliceMake
-    (Arg <v.Type.Elem().PtrTo()> {n} [off])
-    (Arg <typ.Int> {n} [off+int32(config.PtrSize)])
-    (Arg <typ.Int> {n} [off+2*int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsInterface() =>
-  (IMake
-    (Arg <typ.Uintptr> {n} [off])
-    (Arg <typ.BytePtr> {n} [off+int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 =>
-  (ComplexMake
-    (Arg <typ.Float64> {n} [off])
-    (Arg <typ.Float64> {n} [off+8]))
-
-(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 =>
-  (ComplexMake
-    (Arg <typ.Float32> {n} [off])
-    (Arg <typ.Float32> {n} [off+4]))
-
-(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) =>
-  (StructMake0)
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) =>
-  (StructMake1
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) =>
-  (StructMake2
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) =>
-  (StructMake3
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))])
-    (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) =>
-  (StructMake4
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))])
-    (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))])
-    (Arg <t.FieldType(3)> {n} [off+int32(t.FieldOff(3))]))
-
-(Arg <t>) && t.IsArray() && t.NumElem() == 0 =>
-  (ArrayMake0)
-(Arg <t> {n} [off]) && t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) =>
-  (ArrayMake1 (Arg <t.Elem()> {n} [off]))

diff --git a/src/cmd/compile/internal/ssa/gen/decArgsOps.go b/src/cmd/compile/internal/ssa/gen/decArgsOps.go
deleted file mode 100644 (file)
index b73d9d3..0000000
--- a/src/cmd/compile/internal/ssa/gen/decArgsOps.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-var decArgsOps = []opData{}
-
-var decArgsBlocks = []blockData{}
-
-func init() {
-       archs = append(archs, arch{
-               name:    "decArgs",
-               ops:     decArgsOps,
-               blocks:  decArgsBlocks,
-               generic: true,
-       })
-}

diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index 81568b7b7af6529d473eab38314443c16b32498c..1784923224d2b48d12ae0e1a4a961dcc147728fa 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -2512,7 +2512,7 @@
 (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _))
        && t1.Compare(t2) == types.CMPeq
        && isSamePtr(tmp1, tmp2)
-       && isStackPtr(src)
+       && isStackPtr(src) && !isVolatile(src)
        && disjoint(src, s, tmp2, s)
        && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
        => (Move {t1} [s] dst src midmem)
@@ -2521,7 +2521,7 @@
 (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _)))
        && t1.Compare(t2) == types.CMPeq
        && isSamePtr(tmp1, tmp2)
-       && isStackPtr(src)
+       && isStackPtr(src) && !isVolatile(src)
        && disjoint(src, s, tmp2, s)
        && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
        => (Move {t1} [s] dst src midmem)

diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index 120ccbbdb350747d88de3b008a3b42f4f0c8191d..6388aab3621b902ec73d221150332385d5907f64 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -582,6 +582,7 @@ func fprint(w io.Writer, n Node) {
                        "math",
                        "cmd/internal/obj",
                        "cmd/internal/objabi",
+                       "cmd/compile/internal/base",
                        "cmd/compile/internal/types",
                }, n.Arch.imports...) {
                        fmt.Fprintf(w, "import %q\n", path)
@@ -1395,7 +1396,7 @@ func parseValue(val string, arch arch, loc string) (op opData, oparch, typ, auxi
 
 func opHasAuxInt(op opData) bool {
        switch op.aux {
-       case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "Float32", "Float64",
+       case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "UInt8", "Float32", "Float64",
                "SymOff", "CallOff", "SymValAndOff", "TypSize", "ARM64BitField", "FlagConstant", "CCop":
                return true
        }
@@ -1780,6 +1781,8 @@ func (op opData) auxIntType() string {
                return "int64"
        case "Int128":
                return "int128"
+       case "UInt8":
+               return "uint8"
        case "Float32":
                return "float32"
        case "Float64":

diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go
index a9d52fa4ee056c16d7c3cfc840c71a495f757071..c06b5808e1c00296653f87cfd56a680c4a22c9b4 100644 (file)
--- a/src/cmd/compile/internal/ssa/html.go
+++ b/src/cmd/compile/internal/ssa/html.go
@@ -9,9 +9,9 @@ import (
        "cmd/internal/src"
        "fmt"
        "html"
+       exec "internal/execabs"
        "io"
        "os"
-       "os/exec"
        "path/filepath"
        "strconv"
        "strings"

diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index a333982389aa45c9d98e7b118b2bf7434b5e9738..4cd0ac8d777b3468db9a45e0cbad6deb0987652c 100644 (file)
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "fmt"
 )
@@ -59,7 +60,7 @@ func (r *Register) GCNum() int16 {
 //                           { N: len, Type: int, Off: 0, SplitOf: parent, SplitOffset: 8}
 //                           parent = &{N: s, Type: string}
 type LocalSlot struct {
-       N    GCNode      // an ONAME *gc.Node representing a stack location.
+       N    *ir.Name    // an ONAME *ir.Name representing a stack location.
        Type *types.Type // type of slot
        Off  int64       // offset of slot in N
 
@@ -86,3 +87,29 @@ func (t LocPair) String() string {
        }
        return fmt.Sprintf("<%s,%s>", n0, n1)
 }
+
+type ArgPair struct {
+       reg *Register
+       mem LocalSlot
+}
+
+func (ap *ArgPair) Reg() int16 {
+       return ap.reg.objNum
+}
+
+func (ap *ArgPair) Type() *types.Type {
+       return ap.mem.Type
+}
+
+func (ap *ArgPair) Mem() *LocalSlot {
+       return &ap.mem
+}
+
+func (t ArgPair) String() string {
+       n0 := "nil"
+       if t.reg != nil {
+               n0 = t.reg.String()
+       }
+       n1 := t.mem.String()
+       return fmt.Sprintf("<%s,%s>", n0, n1)
+}

diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index d1bad529e700cecf3c20b13fe4d5f99bc07a9cb2..bae50657c9adc08311759abe4eb37e2a617c7a3e 100644 (file)
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/internal/objabi"
        "cmd/internal/src"
 )
@@ -235,7 +236,7 @@ func nilcheckelim2(f *Func) {
                                continue
                        }
                        if v.Type.IsMemory() || v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
-                               if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(GCNode).Typ().HasPointers()) {
+                               if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Name).Type().HasPointers()) {
                                        // These ops don't really change memory.
                                        continue
                                        // Note: OpVarDef requires that the defined variable not have pointers.

diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go
index 16d94614d815c575435a220ee1a4e385d61e5dbc..2e32afe2a6ba6d6f6e5689d04b7c6e9e68a5ef97 100644 (file)
--- a/src/cmd/compile/internal/ssa/nilcheck_test.go
+++ b/src/cmd/compile/internal/ssa/nilcheck_test.go
@@ -212,7 +212,7 @@ func TestNilcheckPhi(t *testing.T) {
                        Valu("mem", OpInitMem, types.TypeMem, 0, nil),
                        Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
                        Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
-                       Valu("baddr", OpLocalAddr, c.config.Types.Bool, 0, "b", "sp", "mem"),
+                       Valu("baddr", OpLocalAddr, c.config.Types.Bool, 0, StringToAux("b"), "sp", "mem"),
                        Valu("bool1", OpLoad, c.config.Types.Bool, 0, nil, "baddr", "mem"),
                        If("bool1", "b1", "b2")),
                Bloc("b1",

diff --git a/src/cmd/compile/internal/ssa/numberlines.go b/src/cmd/compile/internal/ssa/numberlines.go
index f4e62b88c4f6b64ab6665914c570973222e12182..2a9c8e4f326fce9bf99fde33acb731f00b83fada 100644 (file)
--- a/src/cmd/compile/internal/ssa/numberlines.go
+++ b/src/cmd/compile/internal/ssa/numberlines.go
@@ -5,7 +5,6 @@
 package ssa
 
 import (
-       "cmd/internal/obj"
        "cmd/internal/src"
        "fmt"
        "sort"
@@ -23,15 +22,6 @@ func isPoorStatementOp(op Op) bool {
        return false
 }
 
-// LosesStmtMark reports whether a prog with op as loses its statement mark on the way to DWARF.
-// The attributes from some opcodes are lost in translation.
-// TODO: this is an artifact of how funcpctab combines information for instructions at a single PC.
-// Should try to fix it there.
-func LosesStmtMark(as obj.As) bool {
-       // is_stmt does not work for these; it DOES for ANOP even though that generates no code.
-       return as == obj.APCDATA || as == obj.AFUNCDATA
-}
-
 // nextGoodStatementIndex returns an index at i or later that is believed
 // to be a good place to start the statement for b.  This decision is
 // based on v's Op, the possibility of a better later operation, and

diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 6f029a421e18ac35e530151094587ed18d92ce97..f41d014d4138d18444edbdf4757bf4a54edd107b 100644 (file)
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "fmt"
@@ -70,7 +71,8 @@ type auxType int8
 
 type Param struct {
        Type   *types.Type
-       Offset int32 // TODO someday this will be a register
+       Offset int32    // Offset of Param if not in a register.
+       Name   *ir.Name // For OwnAux, need to prepend stores with Vardefs
 }
 
 type AuxCall struct {
@@ -197,6 +199,14 @@ func ClosureAuxCall(args []Param, results []Param) *AuxCall {
        return &AuxCall{Fn: nil, args: args, results: results}
 }
 
+func (*AuxCall) CanBeAnSSAAux() {}
+
+// OwnAuxCall returns a function's own AuxCall
+func OwnAuxCall(fn *obj.LSym, args []Param, results []Param) *AuxCall {
+       // TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
+       return &AuxCall{Fn: fn, args: args, results: results}
+}
+
 const (
        auxNone         auxType = iota
        auxBool                 // auxInt is 0/1 for false/true
@@ -205,6 +215,7 @@ const (
        auxInt32                // auxInt is a 32-bit integer
        auxInt64                // auxInt is a 64-bit integer
        auxInt128               // auxInt represents a 128-bit integer.  Always 0.
+       auxUInt8                // auxInt is an 8-bit unsigned integer
        auxFloat32              // auxInt is a float32 (encoded with math.Float64bits)
        auxFloat64              // auxInt is a float64 (encoded with math.Float64bits)
        auxFlagConstant         // auxInt is a flagConstant
@@ -246,8 +257,8 @@ const (
 //  - a *obj.LSym, for an offset from SB (the global pointer)
 //  - nil, for no offset
 type Sym interface {
-       String() string
        CanBeAnSSASym()
+       CanBeAnSSAAux()
 }
 
 // A ValAndOff is used by the several opcodes. It holds

diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index eceef1d91ad7ace410dfe750b1e263415fdd4f84..ccfed93475ddb78e6333e6bbac9fe5bfa12ab980 100644 (file)
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -970,6 +970,7 @@ const (
        OpAMD64MOVQstore
        OpAMD64MOVOload
        OpAMD64MOVOstore
+       OpAMD64MOVOstorezero
        OpAMD64MOVBloadidx1
        OpAMD64MOVWloadidx1
        OpAMD64MOVWloadidx2
@@ -998,7 +999,6 @@ const (
        OpAMD64MOVQstoreconstidx1
        OpAMD64MOVQstoreconstidx8
        OpAMD64DUFFZERO
-       OpAMD64MOVOconst
        OpAMD64REPSTOSQ
        OpAMD64CALLstatic
        OpAMD64CALLclosure
@@ -1564,6 +1564,10 @@ const (
        OpARM64LessEqualF
        OpARM64GreaterThanF
        OpARM64GreaterEqualF
+       OpARM64NotLessThanF
+       OpARM64NotLessEqualF
+       OpARM64NotGreaterThanF
+       OpARM64NotGreaterEqualF
        OpARM64DUFFZERO
        OpARM64LoweredZero
        OpARM64DUFFCOPY
@@ -6158,11 +6162,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6174,11 +6178,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6189,11 +6193,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6204,11 +6208,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6220,11 +6224,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AMULSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6236,11 +6240,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AMULSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6251,11 +6255,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ADIVSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6266,11 +6270,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ADIVSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6283,10 +6287,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6299,10 +6303,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6314,7 +6318,7 @@ var opcodeTable = [...]opInfo{
                asm:               x86.AMOVSS,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6326,7 +6330,7 @@ var opcodeTable = [...]opInfo{
                asm:               x86.AMOVSD,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6339,11 +6343,11 @@ var opcodeTable = [...]opInfo{
                scale:     1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6356,11 +6360,11 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6373,11 +6377,11 @@ var opcodeTable = [...]opInfo{
                scale:     1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6390,11 +6394,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6407,8 +6411,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6421,8 +6425,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6435,9 +6439,9 @@ var opcodeTable = [...]opInfo{
                scale:     1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6450,9 +6454,9 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6465,9 +6469,9 @@ var opcodeTable = [...]opInfo{
                scale:     1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6480,9 +6484,9 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -6496,11 +6500,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6514,11 +6518,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6532,11 +6536,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6550,11 +6554,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6568,11 +6572,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMULSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6586,11 +6590,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMULSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6604,11 +6608,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ADIVSS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6622,11 +6626,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ADIVSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6640,12 +6644,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6659,12 +6663,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6678,12 +6682,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6697,12 +6701,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6716,12 +6720,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6735,12 +6739,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6754,12 +6758,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6773,12 +6777,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6792,12 +6796,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6811,12 +6815,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6830,12 +6834,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6849,12 +6853,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6868,12 +6872,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6887,12 +6891,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6906,12 +6910,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6925,12 +6929,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-                               {2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -6942,11 +6946,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -6958,11 +6962,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -6974,10 +6978,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -6989,10 +6993,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7006,7 +7010,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7020,7 +7024,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7032,11 +7036,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7048,11 +7052,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7065,10 +7069,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7081,10 +7085,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7097,11 +7101,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AIMULQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7114,11 +7118,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AIMULL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7130,10 +7134,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AIMUL3Q,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7145,10 +7149,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AIMUL3L,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7161,7 +7165,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 4, // DX
                        outputs: []outputInfo{
@@ -7179,7 +7183,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 4, // DX
                        outputs: []outputInfo{
@@ -7196,7 +7200,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
@@ -7212,7 +7216,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
@@ -7228,7 +7232,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
@@ -7244,7 +7248,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
@@ -7260,11 +7264,11 @@ var opcodeTable = [...]opInfo{
                clobberFlags: true,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7277,7 +7281,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7294,7 +7298,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7311,7 +7315,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7327,7 +7331,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7343,7 +7347,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7359,7 +7363,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7374,11 +7378,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ANEGL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7390,12 +7394,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7407,12 +7411,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7424,11 +7428,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7440,11 +7444,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AADCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7455,12 +7459,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7471,12 +7475,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASBBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7488,11 +7492,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7504,11 +7508,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASBBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7521,7 +7525,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {0, 1},     // AX
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 4}, // DX
@@ -7538,7 +7542,7 @@ var opcodeTable = [...]opInfo{
                        inputs: []inputInfo{
                                {0, 4},     // DX
                                {1, 1},     // AX
-                               {2, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {2, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {0, 1}, // AX
@@ -7555,11 +7559,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AANDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7572,11 +7576,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7589,10 +7593,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AANDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7605,10 +7609,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7622,7 +7626,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7636,7 +7640,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7649,11 +7653,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7666,11 +7670,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7683,10 +7687,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7699,10 +7703,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7716,7 +7720,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7730,7 +7734,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7743,11 +7747,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AXORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7760,11 +7764,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AXORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7777,10 +7781,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AXORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7793,10 +7797,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AXORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7810,7 +7814,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7824,7 +7828,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7834,8 +7838,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACMPQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7845,8 +7849,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACMPL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7856,8 +7860,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACMPW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7867,8 +7871,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACMPB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7879,7 +7883,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ACMPQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7890,7 +7894,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ACMPL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7901,7 +7905,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ACMPW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7912,7 +7916,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ACMPB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -7925,8 +7929,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7939,8 +7943,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7953,8 +7957,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7967,8 +7971,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7981,7 +7985,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -7994,7 +7998,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8007,7 +8011,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8020,7 +8024,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ACMPB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8033,9 +8037,9 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8049,9 +8053,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8064,9 +8068,9 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8080,9 +8084,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8095,9 +8099,9 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8111,9 +8115,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8127,9 +8131,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8142,8 +8146,8 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8157,8 +8161,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8171,8 +8175,8 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8186,8 +8190,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8200,8 +8204,8 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8215,8 +8219,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8230,8 +8234,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8241,8 +8245,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AUCOMISS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -8252,8 +8256,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AUCOMISD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -8263,8 +8267,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ABTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8274,8 +8278,8 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ABTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8287,11 +8291,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTCL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8303,11 +8307,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8319,11 +8323,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8335,11 +8339,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8351,11 +8355,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTSL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8367,11 +8371,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTSQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8382,7 +8386,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ABTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8393,7 +8397,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ABTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8406,10 +8410,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTCL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8422,10 +8426,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8438,10 +8442,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8454,10 +8458,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8470,10 +8474,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTSL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8486,10 +8490,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABTSQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8503,8 +8507,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8518,8 +8522,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTCL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8533,8 +8537,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTSQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8548,8 +8552,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTSL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8563,8 +8567,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8578,8 +8582,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8593,7 +8597,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTCQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8607,7 +8611,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTCL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8621,7 +8625,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTSQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8635,7 +8639,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTSL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8649,7 +8653,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8663,7 +8667,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ABTRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -8674,8 +8678,8 @@ var opcodeTable = [...]opInfo{
                asm:         x86.ATESTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8686,8 +8690,8 @@ var opcodeTable = [...]opInfo{
                asm:         x86.ATESTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8698,8 +8702,8 @@ var opcodeTable = [...]opInfo{
                asm:         x86.ATESTW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8710,8 +8714,8 @@ var opcodeTable = [...]opInfo{
                asm:         x86.ATESTB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8722,7 +8726,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ATESTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8733,7 +8737,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ATESTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8744,7 +8748,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ATESTW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8755,7 +8759,7 @@ var opcodeTable = [...]opInfo{
                asm:     x86.ATESTB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8768,10 +8772,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8784,10 +8788,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8800,10 +8804,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHLQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8816,10 +8820,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHLL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8832,10 +8836,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8848,10 +8852,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8864,10 +8868,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8880,10 +8884,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8896,10 +8900,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8912,10 +8916,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8928,10 +8932,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHRW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8944,10 +8948,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASHRB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8960,10 +8964,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8976,10 +8980,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -8992,10 +8996,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9008,10 +9012,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9024,10 +9028,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASARQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9040,10 +9044,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASARL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9056,10 +9060,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASARW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9072,10 +9076,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ASARB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9088,10 +9092,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9104,10 +9108,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9120,10 +9124,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9136,10 +9140,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9152,10 +9156,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9168,10 +9172,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9184,10 +9188,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9200,10 +9204,10 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 2},     // CX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9216,10 +9220,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AROLQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9232,10 +9236,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AROLL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9248,10 +9252,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AROLW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9264,10 +9268,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AROLB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9282,11 +9286,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9301,11 +9305,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9320,11 +9324,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9339,11 +9343,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9358,11 +9362,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9377,11 +9381,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9396,11 +9400,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9415,11 +9419,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9434,11 +9438,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9453,11 +9457,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9472,12 +9476,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9492,12 +9496,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9512,12 +9516,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9532,12 +9536,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9552,12 +9556,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9572,12 +9576,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9592,12 +9596,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9612,12 +9616,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9632,12 +9636,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9652,12 +9656,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9672,12 +9676,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9692,12 +9696,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9712,12 +9716,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9732,12 +9736,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9752,12 +9756,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9772,12 +9776,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9792,12 +9796,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9812,12 +9816,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9832,12 +9836,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9852,12 +9856,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9872,12 +9876,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9892,12 +9896,12 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9912,12 +9916,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9932,12 +9936,12 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9952,12 +9956,12 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -9971,8 +9975,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -9986,8 +9990,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10001,8 +10005,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10016,8 +10020,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10031,8 +10035,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10046,8 +10050,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10061,8 +10065,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASUBL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10076,8 +10080,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10091,8 +10095,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10106,8 +10110,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10121,9 +10125,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10137,9 +10141,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10153,9 +10157,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10169,9 +10173,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10185,9 +10189,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10201,9 +10205,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10217,9 +10221,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10233,9 +10237,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10249,9 +10253,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10265,9 +10269,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10281,9 +10285,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10297,9 +10301,9 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10313,9 +10317,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10329,9 +10333,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10345,9 +10349,9 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10361,9 +10365,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10377,9 +10381,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10393,9 +10397,9 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10409,9 +10413,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10425,9 +10429,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10441,9 +10445,9 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10457,9 +10461,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10473,9 +10477,9 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10489,9 +10493,9 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10505,9 +10509,9 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10521,8 +10525,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10536,8 +10540,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10551,8 +10555,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10566,8 +10570,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10581,8 +10585,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10596,8 +10600,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10611,8 +10615,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10626,8 +10630,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10641,8 +10645,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10656,8 +10660,8 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10671,8 +10675,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10686,8 +10690,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10701,8 +10705,8 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10716,8 +10720,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10731,8 +10735,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10746,8 +10750,8 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10761,8 +10765,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10776,8 +10780,8 @@ var opcodeTable = [...]opInfo{
                scale:        1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10791,8 +10795,8 @@ var opcodeTable = [...]opInfo{
                scale:        4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10806,8 +10810,8 @@ var opcodeTable = [...]opInfo{
                scale:        8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -10819,10 +10823,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ANEGQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10834,10 +10838,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ANEGL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10849,10 +10853,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ANOTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10864,10 +10868,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ANOTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10877,11 +10881,11 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ABSFQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10892,10 +10896,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABSFL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10905,11 +10909,11 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ABSRQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10920,10 +10924,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABSRL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10934,11 +10938,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQEQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10949,11 +10953,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10964,11 +10968,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQLT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10979,11 +10983,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQGT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -10994,11 +10998,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQLE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11009,11 +11013,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQGE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11024,11 +11028,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQLS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11039,11 +11043,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11054,11 +11058,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11069,11 +11073,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQCS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11084,11 +11088,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLEQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11099,11 +11103,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11114,11 +11118,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLLT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11129,11 +11133,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLGT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11144,11 +11148,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLLE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11159,11 +11163,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLGE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11174,11 +11178,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLLS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11189,11 +11193,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11204,11 +11208,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11219,11 +11223,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLCS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11234,11 +11238,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWEQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11249,11 +11253,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11264,11 +11268,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWLT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11279,11 +11283,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWGT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11294,11 +11298,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWLE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11309,11 +11313,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWGE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11324,11 +11328,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWLS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11339,11 +11343,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11354,11 +11358,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11369,11 +11373,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWCS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11384,12 +11388,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11400,11 +11404,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11415,11 +11419,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11430,11 +11434,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVQCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11445,12 +11449,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11461,11 +11465,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11476,11 +11480,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11491,11 +11495,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVLCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11506,12 +11510,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11522,11 +11526,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11537,11 +11541,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11552,11 +11556,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ACMOVWCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11568,10 +11572,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABSWAPQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11583,10 +11587,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.ABSWAPL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11597,10 +11601,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.APOPCNTQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11611,10 +11615,10 @@ var opcodeTable = [...]opInfo{
                asm:          x86.APOPCNTL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11624,10 +11628,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASQRTSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -11638,10 +11642,10 @@ var opcodeTable = [...]opInfo{
                asm:     x86.AROUNDSD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -11652,12 +11656,12 @@ var opcodeTable = [...]opInfo{
                asm:          x86.AVFMADD231SD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -11667,7 +11671,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASBBQ,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11677,7 +11681,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASBBL,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11687,7 +11691,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETEQ,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11697,7 +11701,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETNE,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11707,7 +11711,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETLT,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11717,7 +11721,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETLE,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11727,7 +11731,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETGT,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11737,7 +11741,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETGE,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11747,7 +11751,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETCS,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11757,7 +11761,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETLS,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11767,7 +11771,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETHI,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11777,7 +11781,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETCC,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11787,7 +11791,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETOS,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11800,7 +11804,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETEQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11813,7 +11817,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETNE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11826,7 +11830,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETLT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11839,7 +11843,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETLE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11852,7 +11856,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETGT,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11865,7 +11869,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETGE,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11878,7 +11882,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETCS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11891,7 +11895,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETLS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11904,7 +11908,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETHI,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11917,7 +11921,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.ASETCC,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -11929,7 +11933,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        clobbers: 1, // AX
                        outputs: []outputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11941,7 +11945,7 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        clobbers: 1, // AX
                        outputs: []outputInfo{
-                               {0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11951,7 +11955,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETPC,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11961,7 +11965,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETPS,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11971,7 +11975,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETHI,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11981,7 +11985,7 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ASETCC,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -11991,10 +11995,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVBQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12004,10 +12008,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVBLZX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12017,10 +12021,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVWQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12030,10 +12034,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVWLZX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12043,10 +12047,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVLQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12056,10 +12060,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.AMOVL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12071,7 +12075,7 @@ var opcodeTable = [...]opInfo{
                asm:               x86.AMOVL,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12083,7 +12087,7 @@ var opcodeTable = [...]opInfo{
                asm:               x86.AMOVQ,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12093,10 +12097,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTTSD2SL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12106,10 +12110,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTTSD2SQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12119,10 +12123,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTTSS2SL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12132,10 +12136,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTTSS2SQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12145,10 +12149,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSL2SS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12158,10 +12162,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSL2SD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12171,10 +12175,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSQ2SS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12184,10 +12188,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSQ2SD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12197,10 +12201,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSD2SS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12210,10 +12214,10 @@ var opcodeTable = [...]opInfo{
                asm:    x86.ACVTSS2SD,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12222,10 +12226,10 @@ var opcodeTable = [...]opInfo{
                argLen: 1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12234,10 +12238,10 @@ var opcodeTable = [...]opInfo{
                argLen: 1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12246,10 +12250,10 @@ var opcodeTable = [...]opInfo{
                argLen: 1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12258,10 +12262,10 @@ var opcodeTable = [...]opInfo{
                argLen: 1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12273,11 +12277,11 @@ var opcodeTable = [...]opInfo{
                asm:          x86.APXOR,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12290,10 +12294,10 @@ var opcodeTable = [...]opInfo{
                asm:               x86.ALEAQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12306,10 +12310,10 @@ var opcodeTable = [...]opInfo{
                asm:               x86.ALEAL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12322,10 +12326,10 @@ var opcodeTable = [...]opInfo{
                asm:               x86.ALEAW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12339,11 +12343,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12357,11 +12361,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12375,11 +12379,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12392,11 +12396,11 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12409,11 +12413,11 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12426,11 +12430,11 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12443,11 +12447,11 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12460,11 +12464,11 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12477,11 +12481,11 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12494,11 +12498,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12511,11 +12515,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12528,11 +12532,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12545,10 +12549,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVBLZX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12561,10 +12565,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVBQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12577,10 +12581,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVWLZX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12593,10 +12597,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVWQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12609,10 +12613,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12625,10 +12629,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVLQSX,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12641,10 +12645,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12657,8 +12661,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12671,8 +12675,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12685,8 +12689,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12699,8 +12703,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12713,10 +12717,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVUPS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                        },
                },
        },
@@ -12729,8 +12733,21 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVUPS,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+                       },
+               },
+       },
+       {
+               name:           "MOVOstorezero",
+               auxType:        auxSymOff,
+               argLen:         2,
+               faultOnNilArg0: true,
+               symEffect:      SymWrite,
+               asm:            x86.AMOVUPS,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
                        },
                },
        },
@@ -12744,11 +12761,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12762,11 +12779,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12779,11 +12796,11 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12797,11 +12814,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12814,11 +12831,11 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12831,11 +12848,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12849,11 +12866,11 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12866,11 +12883,11 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -12884,9 +12901,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12900,9 +12917,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12915,9 +12932,9 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12931,9 +12948,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12946,9 +12963,9 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12961,9 +12978,9 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12977,9 +12994,9 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -12992,9 +13009,9 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13007,7 +13024,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13020,7 +13037,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVW,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13033,7 +13050,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13046,7 +13063,7 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13060,8 +13077,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13075,8 +13092,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13089,8 +13106,8 @@ var opcodeTable = [...]opInfo{
                scale:     2,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13104,8 +13121,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13118,8 +13135,8 @@ var opcodeTable = [...]opInfo{
                scale:     4,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13133,8 +13150,8 @@ var opcodeTable = [...]opInfo{
                scale:       1,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13147,36 +13164,24 @@ var opcodeTable = [...]opInfo{
                scale:     8,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
        {
                name:           "DUFFZERO",
                auxType:        auxInt64,
-               argLen:         3,
+               argLen:         2,
                faultOnNilArg0: true,
                unsafePoint:    true,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 128},   // DI
-                               {1, 65536}, // X0
+                               {0, 128}, // DI
                        },
                        clobbers: 128, // DI
                },
        },
-       {
-               name:              "MOVOconst",
-               auxType:           auxInt128,
-               argLen:            0,
-               rematerializeable: true,
-               reg: regInfo{
-                       outputs: []outputInfo{
-                               {0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-                       },
-               },
-       },
        {
                name:           "REPSTOSQ",
                argLen:         4,
@@ -13197,7 +13202,7 @@ var opcodeTable = [...]opInfo{
                clobberFlags: true,
                call:         true,
                reg: regInfo{
-                       clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                       clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                },
        },
        {
@@ -13209,9 +13214,9 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 4},     // DX
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
-                       clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                       clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                },
        },
        {
@@ -13222,9 +13227,9 @@ var opcodeTable = [...]opInfo{
                call:         true,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
-                       clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                       clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                },
        },
        {
@@ -13267,7 +13272,7 @@ var opcodeTable = [...]opInfo{
                argLen: 1,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13287,7 +13292,7 @@ var opcodeTable = [...]opInfo{
                rematerializeable: true,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13297,7 +13302,7 @@ var opcodeTable = [...]opInfo{
                rematerializeable: true,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13309,7 +13314,7 @@ var opcodeTable = [...]opInfo{
                faultOnNilArg0: true,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13324,7 +13329,7 @@ var opcodeTable = [...]opInfo{
                                {0, 128}, // DI
                                {1, 879}, // AX CX DX BX BP SI R8 R9
                        },
-                       clobbers: 4294901760, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+                       clobbers: 2147418112, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
                },
        },
        {
@@ -13335,7 +13340,7 @@ var opcodeTable = [...]opInfo{
                symEffect:         SymNone,
                reg: regInfo{
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13409,10 +13414,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13425,10 +13430,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13441,10 +13446,10 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AMOVQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13459,11 +13464,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXCHGB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13478,11 +13483,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXCHGL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13497,11 +13502,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXCHGQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13517,11 +13522,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXADDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13537,11 +13542,11 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AXADDQ,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                        outputs: []outputInfo{
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13567,13 +13572,13 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 1},     // AX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13589,13 +13594,13 @@ var opcodeTable = [...]opInfo{
                reg: regInfo{
                        inputs: []inputInfo{
                                {1, 1},     // AX
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {2, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {2, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                        clobbers: 1, // AX
                        outputs: []outputInfo{
                                {1, 0},
-                               {0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
                        },
                },
        },
@@ -13610,8 +13615,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13626,8 +13631,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AANDL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13642,8 +13647,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORB,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -13658,8 +13663,8 @@ var opcodeTable = [...]opInfo{
                asm:            x86.AORL,
                reg: regInfo{
                        inputs: []inputInfo{
-                               {1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+                               {1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+                               {0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
                        },
                },
        },
@@ -20798,6 +20803,42 @@ var opcodeTable = [...]opInfo{
                        },
                },
        },
+       {
+               name:   "NotLessThanF",
+               argLen: 1,
+               reg: regInfo{
+                       outputs: []outputInfo{
+                               {0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+                       },
+               },
+       },
+       {
+               name:   "NotLessEqualF",
+               argLen: 1,
+               reg: regInfo{
+                       outputs: []outputInfo{
+                               {0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+                       },
+               },
+       },
+       {
+               name:   "NotGreaterThanF",
+               argLen: 1,
+               reg: regInfo{
+                       outputs: []outputInfo{
+                               {0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+                       },
+               },
+       },
+       {
+               name:   "NotGreaterEqualF",
+               argLen: 1,
+               reg: regInfo{
+                       outputs: []outputInfo{
+                               {0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+                       },
+               },
+       },
        {
                name:           "DUFFZERO",
                auxType:        auxInt64,
@@ -30569,7 +30610,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:    "SLDconst",
-               auxType: auxInt8,
+               auxType: auxUInt8,
                argLen:  1,
                asm:     s390x.ASLD,
                reg: regInfo{
@@ -30583,7 +30624,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:    "SLWconst",
-               auxType: auxInt8,
+               auxType: auxUInt8,
                argLen:  1,
                asm:     s390x.ASLW,
                reg: regInfo{
@@ -30625,7 +30666,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:    "SRDconst",
-               auxType: auxInt8,
+               auxType: auxUInt8,
                argLen:  1,
                asm:     s390x.ASRD,
                reg: regInfo{
@@ -30639,7 +30680,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:    "SRWconst",
-               auxType: auxInt8,
+               auxType: auxUInt8,
                argLen:  1,
                asm:     s390x.ASRW,
                reg: regInfo{
@@ -30683,7 +30724,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:         "SRADconst",
-               auxType:      auxInt8,
+               auxType:      auxUInt8,
                argLen:       1,
                clobberFlags: true,
                asm:          s390x.ASRAD,
@@ -30698,7 +30739,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:         "SRAWconst",
-               auxType:      auxInt8,
+               auxType:      auxUInt8,
                argLen:       1,
                clobberFlags: true,
                asm:          s390x.ASRAW,
@@ -30741,7 +30782,7 @@ var opcodeTable = [...]opInfo{
        },
        {
                name:    "RLLconst",
-               auxType: auxInt8,
+               auxType: auxUInt8,
                argLen:  1,
                asm:     s390x.ARLL,
                reg: regInfo{
@@ -36132,8 +36173,8 @@ var registersAMD64 = [...]Register{
        {11, x86.REG_R11, 10, "R11"},
        {12, x86.REG_R12, 11, "R12"},
        {13, x86.REG_R13, 12, "R13"},
-       {14, x86.REG_R14, 13, "R14"},
-       {15, x86.REG_R15, 14, "R15"},
+       {14, x86.REGG, -1, "g"},
+       {15, x86.REG_R15, 13, "R15"},
        {16, x86.REG_X0, -1, "X0"},
        {17, x86.REG_X1, -1, "X1"},
        {18, x86.REG_X2, -1, "X2"},
@@ -36152,9 +36193,9 @@ var registersAMD64 = [...]Register{
        {31, x86.REG_X15, -1, "X15"},
        {32, 0, -1, "SB"},
 }
-var gpRegMaskAMD64 = regMask(65519)
-var fpRegMaskAMD64 = regMask(4294901760)
-var specialRegMaskAMD64 = regMask(0)
+var gpRegMaskAMD64 = regMask(49135)
+var fpRegMaskAMD64 = regMask(2147418112)
+var specialRegMaskAMD64 = regMask(2147483648)
 var framepointerRegAMD64 = int8(5)
 var linkRegAMD64 = int8(-1)
 var registersARM = [...]Register{

diff --git a/src/cmd/compile/internal/ssa/poset.go b/src/cmd/compile/internal/ssa/poset.go
index f5a2b3a8c2104ff785f4daf0bb3decb2a64a8d01..1e04b48ba4612ed29d4e22ebe03552abf69595e3 100644 (file)
--- a/src/cmd/compile/internal/ssa/poset.go
+++ b/src/cmd/compile/internal/ssa/poset.go
@@ -136,13 +136,13 @@ type posetNode struct {
 // Most internal data structures are pre-allocated and flat, so for instance adding a
 // new relation does not cause any allocation. For performance reasons,
 // each node has only up to two outgoing edges (like a binary tree), so intermediate
-// "dummy" nodes are required to represent more than two relations. For instance,
+// "extra" nodes are required to represent more than two relations. For instance,
 // to record that A<I, A<J, A<K (with no known relation between I,J,K), we create the
 // following DAG:
 //
 //         A
 //        / \
-//       I  dummy
+//       I  extra
 //           /  \
 //          J    K
 //
@@ -223,7 +223,7 @@ func (po *poset) addchild(i1, i2 uint32, strict bool) {
                po.setchr(i1, e2)
                po.upush(undoSetChr, i1, 0)
        } else {
-               // If n1 already has two children, add an intermediate dummy
+               // If n1 already has two children, add an intermediate extra
                // node to record the relation correctly (without relating
                // n2 to other existing nodes). Use a non-deterministic value
                // to decide whether to append on the left or the right, to avoid
@@ -231,27 +231,27 @@ func (po *poset) addchild(i1, i2 uint32, strict bool) {
                //
                //      n1
                //     /  \
-               //   i1l  dummy
+               //   i1l  extra
                //        /   \
                //      i1r   n2
                //
-               dummy := po.newnode(nil)
+               extra := po.newnode(nil)
                if (i1^i2)&1 != 0 { // non-deterministic
-                       po.setchl(dummy, i1r)
-                       po.setchr(dummy, e2)
-                       po.setchr(i1, newedge(dummy, false))
+                       po.setchl(extra, i1r)
+                       po.setchr(extra, e2)
+                       po.setchr(i1, newedge(extra, false))
                        po.upush(undoSetChr, i1, i1r)
                } else {
-                       po.setchl(dummy, i1l)
-                       po.setchr(dummy, e2)
-                       po.setchl(i1, newedge(dummy, false))
+                       po.setchl(extra, i1l)
+                       po.setchr(extra, e2)
+                       po.setchl(i1, newedge(extra, false))
                        po.upush(undoSetChl, i1, i1l)
                }
        }
 }
 
 // newnode allocates a new node bound to SSA value n.
-// If n is nil, this is a dummy node (= only used internally).
+// If n is nil, this is an extra node (= only used internally).
 func (po *poset) newnode(n *Value) uint32 {
        i := po.lastidx + 1
        po.lastidx++
@@ -380,9 +380,9 @@ func (po *poset) newconst(n *Value) {
 
        case higherptr != 0:
                // Higher bound only. To record n < higher, we need
-               // a dummy root:
+               // an extra root:
                //
-               //        dummy
+               //        extra
                //        /   \
                //      root   \
                //       /      n
@@ -395,11 +395,11 @@ func (po *poset) newconst(n *Value) {
                if r2 != po.roots[0] { // all constants should be in root #0
                        panic("constant not in root #0")
                }
-               dummy := po.newnode(nil)
-               po.changeroot(r2, dummy)
-               po.upush(undoChangeRoot, dummy, newedge(r2, false))
-               po.addchild(dummy, r2, false)
-               po.addchild(dummy, i, false)
+               extra := po.newnode(nil)
+               po.changeroot(r2, extra)
+               po.upush(undoChangeRoot, extra, newedge(r2, false))
+               po.addchild(extra, r2, false)
+               po.addchild(extra, i, false)
                po.addchild(i, i2, true)
        }
 
@@ -612,7 +612,7 @@ func (po *poset) findroot(i uint32) uint32 {
        panic("findroot didn't find any root")
 }
 
-// mergeroot merges two DAGs into one DAG by creating a new dummy root
+// mergeroot merges two DAGs into one DAG by creating a new extra root
 func (po *poset) mergeroot(r1, r2 uint32) uint32 {
        // Root #0 is special as it contains all constants. Since mergeroot
        // discards r2 as root and keeps r1, make sure that r2 is not root #0,
@@ -1004,7 +1004,7 @@ func (po *poset) setOrder(n1, n2 *Value, strict bool) bool {
        case !f1 && f2:
                // n1 is not in any DAG but n2 is. If n2 is a root, we can put
                // n1 in its place as a root; otherwise, we need to create a new
-               // dummy root to record the relation.
+               // extra root to record the relation.
                i1 = po.newnode(n1)
 
                if po.isroot(i2) {
@@ -1020,17 +1020,17 @@ func (po *poset) setOrder(n1, n2 *Value, strict bool) bool {
 
                // Re-parent as follows:
                //
-               //                  dummy
+               //                  extra
                //     r            /   \
                //      \   ===>   r    i1
                //      i2          \   /
                //                    i2
                //
-               dummy := po.newnode(nil)
-               po.changeroot(r, dummy)
-               po.upush(undoChangeRoot, dummy, newedge(r, false))
-               po.addchild(dummy, r, false)
-               po.addchild(dummy, i1, false)
+               extra := po.newnode(nil)
+               po.changeroot(r, extra)
+               po.upush(undoChangeRoot, extra, newedge(r, false))
+               po.addchild(extra, r, false)
+               po.addchild(extra, i1, false)
                po.addchild(i1, i2, strict)
 
        case f1 && f2:

diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 0339b073ae15f6a5077eddeb571f66162522afa2..8c25b1c81dc0c45bafd1d480b697171b7cd17340 100644 (file)
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -104,7 +104,7 @@
 // If b3 is the primary predecessor of b2, then we use x3 in b2 and
 // add a x4:CX->BX copy at the end of b4.
 // But the definition of x3 doesn't dominate b2.  We should really
-// insert a dummy phi at the start of b2 (x5=phi(x3,x4):BX) to keep
+// insert an extra phi at the start of b2 (x5=phi(x3,x4):BX) to keep
 // SSA form. For now, we ignore this problem as remaining in strict
 // SSA form isn't needed after regalloc. We'll just leave the use
 // of x3 not dominated by the definition of x3, and the CX->BX copy
@@ -114,6 +114,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/objabi"
        "cmd/internal/src"
@@ -782,9 +783,9 @@ func (s *regAllocState) compatRegs(t *types.Type) regMask {
                return 0
        }
        if t.IsFloat() || t == types.TypeInt128 {
-               if t.Etype == types.TFLOAT32 && s.f.Config.fp32RegMask != 0 {
+               if t.Kind() == types.TFLOAT32 && s.f.Config.fp32RegMask != 0 {
                        m = s.f.Config.fp32RegMask
-               } else if t.Etype == types.TFLOAT64 && s.f.Config.fp64RegMask != 0 {
+               } else if t.Kind() == types.TFLOAT64 && s.f.Config.fp64RegMask != 0 {
                        m = s.f.Config.fp64RegMask
                } else {
                        m = s.f.Config.fpRegMask
@@ -1248,7 +1249,7 @@ func (s *regAllocState) regalloc(f *Func) {
                                        // This forces later liveness analysis to make the
                                        // value live at this point.
                                        v.SetArg(0, s.makeSpill(a, b))
-                               } else if _, ok := a.Aux.(GCNode); ok && vi.rematerializeable {
+                               } else if _, ok := a.Aux.(*ir.Name); ok && vi.rematerializeable {
                                        // Rematerializeable value with a gc.Node. This is the address of
                                        // a stack object (e.g. an LEAQ). Keep the object live.
                                        // Change it to VarLive, which is what plive expects for locals.

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 24efd38fb7c44957b5bf3f8c26a08781e7efa48d..e82aa84cdfa96367e924aa6585fcc35aad04a7a4 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -521,6 +521,18 @@ func shiftIsBounded(v *Value) bool {
        return v.AuxInt != 0
 }
 
+// canonLessThan returns whether x is "ordered" less than y, for purposes of normalizing
+// generated code as much as possible.
+func canonLessThan(x, y *Value) bool {
+       if x.Op != y.Op {
+               return x.Op < y.Op
+       }
+       if !x.Pos.SameFileAndLine(y.Pos) {
+               return x.Pos.Before(y.Pos)
+       }
+       return x.ID < y.ID
+}
+
 // truncate64Fto32F converts a float64 value to a float32 preserving the bit pattern
 // of the mantissa. It will panic if the truncation results in lost information.
 func truncate64Fto32F(f float64) float32 {
@@ -678,43 +690,53 @@ func opToAuxInt(o Op) int64 {
        return int64(o)
 }
 
-func auxToString(i interface{}) string {
-       return i.(string)
+// Aux is an interface to hold miscellaneous data in Blocks and Values.
+type Aux interface {
+       CanBeAnSSAAux()
 }
-func auxToSym(i interface{}) Sym {
+
+// stringAux wraps string values for use in Aux.
+type stringAux string
+
+func (stringAux) CanBeAnSSAAux() {}
+
+func auxToString(i Aux) string {
+       return string(i.(stringAux))
+}
+func auxToSym(i Aux) Sym {
        // TODO: kind of a hack - allows nil interface through
        s, _ := i.(Sym)
        return s
 }
-func auxToType(i interface{}) *types.Type {
+func auxToType(i Aux) *types.Type {
        return i.(*types.Type)
 }
-func auxToCall(i interface{}) *AuxCall {
+func auxToCall(i Aux) *AuxCall {
        return i.(*AuxCall)
 }
-func auxToS390xCCMask(i interface{}) s390x.CCMask {
+func auxToS390xCCMask(i Aux) s390x.CCMask {
        return i.(s390x.CCMask)
 }
-func auxToS390xRotateParams(i interface{}) s390x.RotateParams {
+func auxToS390xRotateParams(i Aux) s390x.RotateParams {
        return i.(s390x.RotateParams)
 }
 
-func stringToAux(s string) interface{} {
-       return s
+func StringToAux(s string) Aux {
+       return stringAux(s)
 }
-func symToAux(s Sym) interface{} {
+func symToAux(s Sym) Aux {
        return s
 }
-func callToAux(s *AuxCall) interface{} {
+func callToAux(s *AuxCall) Aux {
        return s
 }
-func typeToAux(t *types.Type) interface{} {
+func typeToAux(t *types.Type) Aux {
        return t
 }
-func s390xCCMaskToAux(c s390x.CCMask) interface{} {
+func s390xCCMaskToAux(c s390x.CCMask) Aux {
        return c
 }
-func s390xRotateParamsToAux(r s390x.RotateParams) interface{} {
+func s390xRotateParamsToAux(r s390x.RotateParams) Aux {
        return r
 }
 
@@ -725,7 +747,7 @@ func uaddOvf(a, b int64) bool {
 
 // de-virtualize an InterCall
 // 'sym' is the symbol for the itab
-func devirt(v *Value, aux interface{}, sym Sym, offset int64) *AuxCall {
+func devirt(v *Value, aux Aux, sym Sym, offset int64) *AuxCall {
        f := v.Block.Func
        n, ok := sym.(*obj.LSym)
        if !ok {
@@ -748,7 +770,7 @@ func devirt(v *Value, aux interface{}, sym Sym, offset int64) *AuxCall {
 
 // de-virtualize an InterLECall
 // 'sym' is the symbol for the itab
-func devirtLESym(v *Value, aux interface{}, sym Sym, offset int64) *obj.LSym {
+func devirtLESym(v *Value, aux Aux, sym Sym, offset int64) *obj.LSym {
        n, ok := sym.(*obj.LSym)
        if !ok {
                return nil
@@ -974,9 +996,10 @@ func flagArg(v *Value) *Value {
 }
 
 // arm64Negate finds the complement to an ARM64 condition code,
-// for example Equal -> NotEqual or LessThan -> GreaterEqual
+// for example !Equal -> NotEqual or !LessThan -> GreaterEqual
 //
-// TODO: add floating-point conditions
+// For floating point, it's more subtle because NaN is unordered. We do
+// !LessThanF -> NotLessThanF, the latter takes care of NaNs.
 func arm64Negate(op Op) Op {
        switch op {
        case OpARM64LessThan:
@@ -1000,13 +1023,21 @@ func arm64Negate(op Op) Op {
        case OpARM64NotEqual:
                return OpARM64Equal
        case OpARM64LessThanF:
-               return OpARM64GreaterEqualF
-       case OpARM64GreaterThanF:
-               return OpARM64LessEqualF
+               return OpARM64NotLessThanF
+       case OpARM64NotLessThanF:
+               return OpARM64LessThanF
        case OpARM64LessEqualF:
+               return OpARM64NotLessEqualF
+       case OpARM64NotLessEqualF:
+               return OpARM64LessEqualF
+       case OpARM64GreaterThanF:
+               return OpARM64NotGreaterThanF
+       case OpARM64NotGreaterThanF:
                return OpARM64GreaterThanF
        case OpARM64GreaterEqualF:
-               return OpARM64LessThanF
+               return OpARM64NotGreaterEqualF
+       case OpARM64NotGreaterEqualF:
+               return OpARM64GreaterEqualF
        default:
                panic("unreachable")
        }
@@ -1017,8 +1048,6 @@ func arm64Negate(op Op) Op {
 // that the same result would be produced if the arguments
 // to the flag-generating instruction were reversed, e.g.
 // (InvertFlags (CMP x y)) -> (CMP y x)
-//
-// TODO: add floating-point conditions
 func arm64Invert(op Op) Op {
        switch op {
        case OpARM64LessThan:
@@ -1047,6 +1076,14 @@ func arm64Invert(op Op) Op {
                return OpARM64GreaterEqualF
        case OpARM64GreaterEqualF:
                return OpARM64LessEqualF
+       case OpARM64NotLessThanF:
+               return OpARM64NotGreaterThanF
+       case OpARM64NotGreaterThanF:
+               return OpARM64NotLessThanF
+       case OpARM64NotLessEqualF:
+               return OpARM64NotGreaterEqualF
+       case OpARM64NotGreaterEqualF:
+               return OpARM64NotLessEqualF
        default:
                panic("unreachable")
        }

diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 2acdccd5684aaf5364eb4a58ae44d9688769dc8d..4e7fdb9e639ce5d7a19dca729cc7255343c94df3 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -1785,12 +1785,12 @@ func rewriteValue386_Op386CMPB(v *Value) bool {
                return true
        }
        // match: (CMPB x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPB y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(Op386InvertFlags)
@@ -2078,12 +2078,12 @@ func rewriteValue386_Op386CMPL(v *Value) bool {
                return true
        }
        // match: (CMPL x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPL y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(Op386InvertFlags)
@@ -2386,12 +2386,12 @@ func rewriteValue386_Op386CMPW(v *Value) bool {
                return true
        }
        // match: (CMPW x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPW y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(Op386InvertFlags)

diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 75d4ff7357a76693ac01e71c41d08cc93752b8bf..03498c719c0956094970f77ee88324ee5012630d 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -4,6 +4,7 @@
 package ssa
 
 import "math"
+import "cmd/compile/internal/base"
 import "cmd/compile/internal/types"
 
 func rewriteValueAMD64(v *Value) bool {
@@ -767,8 +768,7 @@ func rewriteValueAMD64(v *Value) bool {
                v.Op = OpAMD64LoweredGetClosurePtr
                return true
        case OpGetG:
-               v.Op = OpAMD64LoweredGetG
-               return true
+               return rewriteValueAMD64_OpGetG(v)
        case OpHasCPUFeature:
                return rewriteValueAMD64_OpHasCPUFeature(v)
        case OpHmul32:
@@ -6749,12 +6749,12 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
                return true
        }
        // match: (CMPB x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPB y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpAMD64InvertFlags)
@@ -7135,12 +7135,12 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
                return true
        }
        // match: (CMPL x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPL y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpAMD64InvertFlags)
@@ -7544,12 +7544,12 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
                return true
        }
        // match: (CMPQ x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPQ y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpAMD64InvertFlags)
@@ -8106,12 +8106,12 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
                return true
        }
        // match: (CMPW x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPW y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpAMD64InvertFlags)
@@ -14226,7 +14226,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
        }
        // match: (MOVQstoreconst [c] {s} p x:(MOVQstoreconst [c2] {s} p mem))
        // cond: config.useSSE && x.Uses == 1 && c2.Off() + 8 == c.Off() && c.Val() == 0 && c2.Val() == 0 && clobber(x)
-       // result: (MOVOstore [c2.Off32()] {s} p (MOVOconst [0]) mem)
+       // result: (MOVOstorezero [c2.Off32()] {s} p mem)
        for {
                c := auxIntToValAndOff(v.AuxInt)
                s := auxToSym(v.Aux)
@@ -14243,12 +14243,10 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
                if p != x.Args[0] || !(config.useSSE && x.Uses == 1 && c2.Off()+8 == c.Off() && c.Val() == 0 && c2.Val() == 0 && clobber(x)) {
                        break
                }
-               v.reset(OpAMD64MOVOstore)
+               v.reset(OpAMD64MOVOstorezero)
                v.AuxInt = int32ToAuxInt(c2.Off32())
                v.Aux = symToAux(s)
-               v0 := b.NewValue0(x.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v0.AuxInt = int128ToAuxInt(0)
-               v.AddArg3(p, v0, mem)
+               v.AddArg2(p, mem)
                return true
        }
        // match: (MOVQstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
@@ -30128,6 +30126,22 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
                return true
        }
 }
+func rewriteValueAMD64_OpGetG(v *Value) bool {
+       v_0 := v.Args[0]
+       // match: (GetG mem)
+       // cond: !base.Flag.ABIWrap
+       // result: (LoweredGetG mem)
+       for {
+               mem := v_0
+               if !(!base.Flag.ABIWrap) {
+                       break
+               }
+               v.reset(OpAMD64LoweredGetG)
+               v.AddArg(mem)
+               return true
+       }
+       return false
+}
 func rewriteValueAMD64_OpHasCPUFeature(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
@@ -34163,7 +34177,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
        }
        // match: (Zero [s] destptr mem)
        // cond: s%16 != 0 && s > 16 && s%16 > 8 && config.useSSE
-       // result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVOstore destptr (MOVOconst [0]) mem))
+       // result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVOstorezero destptr mem))
        for {
                s := auxIntToInt64(v.AuxInt)
                destptr := v_0
@@ -34176,10 +34190,8 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
                v0.AuxInt = int64ToAuxInt(s % 16)
                v0.AddArg(destptr)
-               v1 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v2 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v2.AuxInt = int128ToAuxInt(0)
-               v1.AddArg3(destptr, v2, mem)
+               v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v1.AddArg2(destptr, mem)
                v.AddArg2(v0, v1)
                return true
        }
@@ -34206,7 +34218,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
        }
        // match: (Zero [16] destptr mem)
        // cond: config.useSSE
-       // result: (MOVOstore destptr (MOVOconst [0]) mem)
+       // result: (MOVOstorezero destptr mem)
        for {
                if auxIntToInt64(v.AuxInt) != 16 {
                        break
@@ -34216,15 +34228,13 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                if !(config.useSSE) {
                        break
                }
-               v.reset(OpAMD64MOVOstore)
-               v0 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v0.AuxInt = int128ToAuxInt(0)
-               v.AddArg3(destptr, v0, mem)
+               v.reset(OpAMD64MOVOstorezero)
+               v.AddArg2(destptr, mem)
                return true
        }
        // match: (Zero [32] destptr mem)
        // cond: config.useSSE
-       // result: (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem))
+       // result: (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem))
        for {
                if auxIntToInt64(v.AuxInt) != 32 {
                        break
@@ -34234,20 +34244,18 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                if !(config.useSSE) {
                        break
                }
-               v.reset(OpAMD64MOVOstore)
+               v.reset(OpAMD64MOVOstorezero)
                v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
                v0.AuxInt = int64ToAuxInt(16)
                v0.AddArg(destptr)
-               v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v1.AuxInt = int128ToAuxInt(0)
-               v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v2.AddArg3(destptr, v1, mem)
-               v.AddArg3(v0, v1, v2)
+               v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v1.AddArg2(destptr, mem)
+               v.AddArg2(v0, v1)
                return true
        }
        // match: (Zero [48] destptr mem)
        // cond: config.useSSE
-       // result: (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem)))
+       // result: (MOVOstorezero (OffPtr <destptr.Type> destptr [32]) (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem)))
        for {
                if auxIntToInt64(v.AuxInt) != 48 {
                        break
@@ -34257,25 +34265,23 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                if !(config.useSSE) {
                        break
                }
-               v.reset(OpAMD64MOVOstore)
+               v.reset(OpAMD64MOVOstorezero)
                v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
                v0.AuxInt = int64ToAuxInt(32)
                v0.AddArg(destptr)
-               v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v1.AuxInt = int128ToAuxInt(0)
-               v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v3 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-               v3.AuxInt = int64ToAuxInt(16)
-               v3.AddArg(destptr)
-               v4 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v4.AddArg3(destptr, v1, mem)
-               v2.AddArg3(v3, v1, v4)
-               v.AddArg3(v0, v1, v2)
+               v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v2 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+               v2.AuxInt = int64ToAuxInt(16)
+               v2.AddArg(destptr)
+               v3 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v3.AddArg2(destptr, mem)
+               v1.AddArg2(v2, v3)
+               v.AddArg2(v0, v1)
                return true
        }
        // match: (Zero [64] destptr mem)
        // cond: config.useSSE
-       // result: (MOVOstore (OffPtr <destptr.Type> destptr [48]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem))))
+       // result: (MOVOstorezero (OffPtr <destptr.Type> destptr [48]) (MOVOstorezero (OffPtr <destptr.Type> destptr [32]) (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem))))
        for {
                if auxIntToInt64(v.AuxInt) != 64 {
                        break
@@ -34285,30 +34291,28 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                if !(config.useSSE) {
                        break
                }
-               v.reset(OpAMD64MOVOstore)
+               v.reset(OpAMD64MOVOstorezero)
                v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
                v0.AuxInt = int64ToAuxInt(48)
                v0.AddArg(destptr)
-               v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v1.AuxInt = int128ToAuxInt(0)
-               v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v3 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-               v3.AuxInt = int64ToAuxInt(32)
-               v3.AddArg(destptr)
-               v4 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v5 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-               v5.AuxInt = int64ToAuxInt(16)
-               v5.AddArg(destptr)
-               v6 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-               v6.AddArg3(destptr, v1, mem)
-               v4.AddArg3(v5, v1, v6)
-               v2.AddArg3(v3, v1, v4)
-               v.AddArg3(v0, v1, v2)
+               v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v2 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+               v2.AuxInt = int64ToAuxInt(32)
+               v2.AddArg(destptr)
+               v3 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v4 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+               v4.AuxInt = int64ToAuxInt(16)
+               v4.AddArg(destptr)
+               v5 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+               v5.AddArg2(destptr, mem)
+               v3.AddArg2(v4, v5)
+               v1.AddArg2(v2, v3)
+               v.AddArg2(v0, v1)
                return true
        }
        // match: (Zero [s] destptr mem)
        // cond: s > 64 && s <= 1024 && s%16 == 0 && !config.noDuffDevice
-       // result: (DUFFZERO [s] destptr (MOVOconst [0]) mem)
+       // result: (DUFFZERO [s] destptr mem)
        for {
                s := auxIntToInt64(v.AuxInt)
                destptr := v_0
@@ -34318,9 +34322,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
                }
                v.reset(OpAMD64DUFFZERO)
                v.AuxInt = int64ToAuxInt(s)
-               v0 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-               v0.AuxInt = int128ToAuxInt(0)
-               v.AddArg3(destptr, v0, mem)
+               v.AddArg2(destptr, mem)
                return true
        }
        // match: (Zero [s] destptr mem)

diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index d9d439fa63ee1d5c93930552d1c7aefeef7a83df..c958aae2c4abdceceb8cd39885d324ce4f6e3c18 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -3728,12 +3728,12 @@ func rewriteValueARM_OpARMCMP(v *Value) bool {
                return true
        }
        // match: (CMP x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMP y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpARMInvertFlags)

diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 5d5e526add31fbd8ca8fafd4f1e7861b750bfbab..ff1156d9011ea2df6fb570b446f8e21b02772315 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -2772,12 +2772,12 @@ func rewriteValueARM64_OpARM64CMP(v *Value) bool {
                return true
        }
        // match: (CMP x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMP y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpARM64InvertFlags)
@@ -2941,12 +2941,12 @@ func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
                return true
        }
        // match: (CMPW x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPW y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpARM64InvertFlags)

diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 455f9b138859b0e0e31231b644e6584ed9b2841c..98f748e5fa41d3063ec951ccdbffc144ebe5a762 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -4777,12 +4777,12 @@ func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
                return true
        }
        // match: (CMP x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMP y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpPPC64InvertFlags)
@@ -4834,12 +4834,12 @@ func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
                return true
        }
        // match: (CMPU x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPU y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpPPC64InvertFlags)
@@ -4964,12 +4964,12 @@ func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
                return true
        }
        // match: (CMPW x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPW y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpPPC64InvertFlags)
@@ -5045,12 +5045,12 @@ func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
                return true
        }
        // match: (CMPWU x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPWU y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpPPC64InvertFlags)

diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index d66113d1118261f47aa63d7bcc839bbb1eab01d1..b52a1b6745e0805033ac7214977a8233642772f9 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -1240,7 +1240,7 @@ func rewriteValueS390X_OpAvg64u(v *Value) bool {
                y := v_1
                v.reset(OpS390XADD)
                v0 := b.NewValue0(v.Pos, OpS390XSRDconst, t)
-               v0.AuxInt = int8ToAuxInt(1)
+               v0.AuxInt = uint8ToAuxInt(1)
                v1 := b.NewValue0(v.Pos, OpS390XSUB, t)
                v1.AddArg2(x, y)
                v0.AddArg(v1)
@@ -1737,7 +1737,7 @@ func rewriteValueS390X_OpHmul32(v *Value) bool {
                x := v_0
                y := v_1
                v.reset(OpS390XSRDconst)
-               v.AuxInt = int8ToAuxInt(32)
+               v.AuxInt = uint8ToAuxInt(32)
                v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
                v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
                v1.AddArg(x)
@@ -1759,7 +1759,7 @@ func rewriteValueS390X_OpHmul32u(v *Value) bool {
                x := v_0
                y := v_1
                v.reset(OpS390XSRDconst)
-               v.AuxInt = int8ToAuxInt(32)
+               v.AuxInt = uint8ToAuxInt(32)
                v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
                v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
                v1.AddArg(x)
@@ -5281,9 +5281,9 @@ func rewriteValueS390X_OpS390XADD(v *Value) bool {
                        if v_0.Op != OpS390XSLDconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRISBGZ)
@@ -5474,13 +5474,13 @@ func rewriteValueS390X_OpS390XADDW(v *Value) bool {
                        if v_0.Op != OpS390XSLWconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRWconst || auxIntToInt8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRWconst || auxIntToUint8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRLLconst)
-                       v.AuxInt = int8ToAuxInt(c)
+                       v.AuxInt = uint8ToAuxInt(c)
                        v.AddArg(x)
                        return true
                }
@@ -6332,12 +6332,12 @@ func rewriteValueS390X_OpS390XCMP(v *Value) bool {
                return true
        }
        // match: (CMP x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMP y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpS390XInvertFlags)
@@ -6389,12 +6389,12 @@ func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
                return true
        }
        // match: (CMPU x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPU y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpS390XInvertFlags)
@@ -6460,7 +6460,7 @@ func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool {
                if v_0.Op != OpS390XSRDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                if !(c > 0 && c < 64 && (1<<uint(64-c)) <= uint64(n)) {
                        break
                }
@@ -6624,12 +6624,12 @@ func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
                return true
        }
        // match: (CMPW x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPW y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpS390XInvertFlags)
@@ -6721,12 +6721,12 @@ func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
                return true
        }
        // match: (CMPWU x y)
-       // cond: x.ID > y.ID
+       // cond: canonLessThan(x,y)
        // result: (InvertFlags (CMPWU y x))
        for {
                x := v_0
                y := v_1
-               if !(x.ID > y.ID) {
+               if !(canonLessThan(x, y)) {
                        break
                }
                v.reset(OpS390XInvertFlags)
@@ -6862,7 +6862,7 @@ func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool {
                if v_0.Op != OpS390XSRWconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                if !(c > 0 && c < 32 && (1<<uint(32-c)) <= uint32(n)) {
                        break
                }
@@ -6989,7 +6989,7 @@ func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
                if v_0.Op != OpS390XSRWconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                if !(c > 0 && n < 0) {
                        break
                }
@@ -7020,7 +7020,7 @@ func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
                if x.Op != OpS390XSRWconst {
                        break
                }
-               c := auxIntToInt8(x.AuxInt)
+               c := auxIntToUint8(x.AuxInt)
                if !(c > 0 && n >= 0) {
                        break
                }
@@ -7112,7 +7112,7 @@ func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
                if v_0.Op != OpS390XSRDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                if !(c > 0 && n < 0) {
                        break
                }
@@ -7250,7 +7250,7 @@ func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
                if x.Op != OpS390XSRDconst {
                        break
                }
-               c := auxIntToInt8(x.AuxInt)
+               c := auxIntToUint8(x.AuxInt)
                if !(c > 0 && n >= 0) {
                        break
                }
@@ -8673,7 +8673,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRDconst || auxIntToInt8(x_1.AuxInt) != 8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRDconst || auxIntToUint8(x_1.AuxInt) != 8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHstore)
@@ -8693,7 +8693,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                if w0.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(w0.AuxInt)
+               j := auxIntToUint8(w0.AuxInt)
                w := w0.Args[0]
                x := v_2
                if x.Op != OpS390XMOVBstore || auxIntToInt32(x.AuxInt) != i-1 || auxToSym(x.Aux) != s {
@@ -8704,7 +8704,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRDconst || auxIntToInt8(x_1.AuxInt) != j+8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRDconst || auxIntToUint8(x_1.AuxInt) != j+8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHstore)
@@ -8730,7 +8730,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRWconst || auxIntToInt8(x_1.AuxInt) != 8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRWconst || auxIntToUint8(x_1.AuxInt) != 8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHstore)
@@ -8750,7 +8750,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                if w0.Op != OpS390XSRWconst {
                        break
                }
-               j := auxIntToInt8(w0.AuxInt)
+               j := auxIntToUint8(w0.AuxInt)
                w := w0.Args[0]
                x := v_2
                if x.Op != OpS390XMOVBstore || auxIntToInt32(x.AuxInt) != i-1 || auxToSym(x.Aux) != s {
@@ -8761,7 +8761,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRWconst || auxIntToInt8(x_1.AuxInt) != j+8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRWconst || auxIntToUint8(x_1.AuxInt) != j+8 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHstore)
@@ -8777,7 +8777,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 8 {
+               if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 8 {
                        break
                }
                w := v_1.Args[0]
@@ -8805,7 +8805,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                if v_1.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(v_1.AuxInt)
+               j := auxIntToUint8(v_1.AuxInt)
                w := v_1.Args[0]
                x := v_2
                if x.Op != OpS390XMOVBstore || auxIntToInt32(x.AuxInt) != i-1 || auxToSym(x.Aux) != s {
@@ -8816,7 +8816,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                w0 := x.Args[1]
-               if w0.Op != OpS390XSRDconst || auxIntToInt8(w0.AuxInt) != j-8 || w != w0.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if w0.Op != OpS390XSRDconst || auxIntToUint8(w0.AuxInt) != j-8 || w != w0.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHBRstore)
@@ -8832,7 +8832,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRWconst || auxIntToInt8(v_1.AuxInt) != 8 {
+               if v_1.Op != OpS390XSRWconst || auxIntToUint8(v_1.AuxInt) != 8 {
                        break
                }
                w := v_1.Args[0]
@@ -8860,7 +8860,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                if v_1.Op != OpS390XSRWconst {
                        break
                }
-               j := auxIntToInt8(v_1.AuxInt)
+               j := auxIntToUint8(v_1.AuxInt)
                w := v_1.Args[0]
                x := v_2
                if x.Op != OpS390XMOVBstore || auxIntToInt32(x.AuxInt) != i-1 || auxToSym(x.Aux) != s {
@@ -8871,7 +8871,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
                        break
                }
                w0 := x.Args[1]
-               if w0.Op != OpS390XSRWconst || auxIntToInt8(w0.AuxInt) != j-8 || w != w0.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if w0.Op != OpS390XSRWconst || auxIntToUint8(w0.AuxInt) != j-8 || w != w0.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVHBRstore)
@@ -9345,7 +9345,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 16 {
+               if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 16 {
                        break
                }
                w := v_1.Args[0]
@@ -9373,7 +9373,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                if v_1.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(v_1.AuxInt)
+               j := auxIntToUint8(v_1.AuxInt)
                w := v_1.Args[0]
                x := v_2
                if x.Op != OpS390XMOVHBRstore || auxIntToInt32(x.AuxInt) != i-2 || auxToSym(x.Aux) != s {
@@ -9384,7 +9384,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                        break
                }
                w0 := x.Args[1]
-               if w0.Op != OpS390XSRDconst || auxIntToInt8(w0.AuxInt) != j-16 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
+               if w0.Op != OpS390XSRDconst || auxIntToUint8(w0.AuxInt) != j-16 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWBRstore)
@@ -9400,7 +9400,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRWconst || auxIntToInt8(v_1.AuxInt) != 16 {
+               if v_1.Op != OpS390XSRWconst || auxIntToUint8(v_1.AuxInt) != 16 {
                        break
                }
                w := v_1.Args[0]
@@ -9428,7 +9428,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                if v_1.Op != OpS390XSRWconst {
                        break
                }
-               j := auxIntToInt8(v_1.AuxInt)
+               j := auxIntToUint8(v_1.AuxInt)
                w := v_1.Args[0]
                x := v_2
                if x.Op != OpS390XMOVHBRstore || auxIntToInt32(x.AuxInt) != i-2 || auxToSym(x.Aux) != s {
@@ -9439,7 +9439,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
                        break
                }
                w0 := x.Args[1]
-               if w0.Op != OpS390XSRWconst || auxIntToInt8(w0.AuxInt) != j-16 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
+               if w0.Op != OpS390XSRWconst || auxIntToUint8(w0.AuxInt) != j-16 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWBRstore)
@@ -10086,7 +10086,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRDconst || auxIntToInt8(x_1.AuxInt) != 16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRDconst || auxIntToUint8(x_1.AuxInt) != 16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWstore)
@@ -10106,7 +10106,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                if w0.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(w0.AuxInt)
+               j := auxIntToUint8(w0.AuxInt)
                w := w0.Args[0]
                x := v_2
                if x.Op != OpS390XMOVHstore || auxIntToInt32(x.AuxInt) != i-2 || auxToSym(x.Aux) != s {
@@ -10117,7 +10117,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRDconst || auxIntToInt8(x_1.AuxInt) != j+16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRDconst || auxIntToUint8(x_1.AuxInt) != j+16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWstore)
@@ -10143,7 +10143,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRWconst || auxIntToInt8(x_1.AuxInt) != 16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRWconst || auxIntToUint8(x_1.AuxInt) != 16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWstore)
@@ -10163,7 +10163,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                if w0.Op != OpS390XSRWconst {
                        break
                }
-               j := auxIntToInt8(w0.AuxInt)
+               j := auxIntToUint8(w0.AuxInt)
                w := w0.Args[0]
                x := v_2
                if x.Op != OpS390XMOVHstore || auxIntToInt32(x.AuxInt) != i-2 || auxToSym(x.Aux) != s {
@@ -10174,7 +10174,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRWconst || auxIntToInt8(x_1.AuxInt) != j+16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRWconst || auxIntToUint8(x_1.AuxInt) != j+16 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVWstore)
@@ -10273,7 +10273,7 @@ func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 32 {
+               if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 32 {
                        break
                }
                w := v_1.Args[0]
@@ -10301,7 +10301,7 @@ func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
                if v_1.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(v_1.AuxInt)
+               j := auxIntToUint8(v_1.AuxInt)
                w := v_1.Args[0]
                x := v_2
                if x.Op != OpS390XMOVWBRstore || auxIntToInt32(x.AuxInt) != i-4 || auxToSym(x.Aux) != s {
@@ -10312,7 +10312,7 @@ func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
                        break
                }
                w0 := x.Args[1]
-               if w0.Op != OpS390XSRDconst || auxIntToInt8(w0.AuxInt) != j-32 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
+               if w0.Op != OpS390XSRDconst || auxIntToUint8(w0.AuxInt) != j-32 || w != w0.Args[0] || !(x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVDBRstore)
@@ -10914,7 +10914,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 32 {
+               if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 32 {
                        break
                }
                w := v_1.Args[0]
@@ -10943,7 +10943,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
                if w0.Op != OpS390XSRDconst {
                        break
                }
-               j := auxIntToInt8(w0.AuxInt)
+               j := auxIntToUint8(w0.AuxInt)
                w := w0.Args[0]
                x := v_2
                if x.Op != OpS390XMOVWstore || auxIntToInt32(x.AuxInt) != i-4 || auxToSym(x.Aux) != s {
@@ -10954,7 +10954,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
                        break
                }
                x_1 := x.Args[1]
-               if x_1.Op != OpS390XSRDconst || auxIntToInt8(x_1.AuxInt) != j+32 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
+               if x_1.Op != OpS390XSRDconst || auxIntToUint8(x_1.AuxInt) != j+32 || w != x_1.Args[0] || !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
                        break
                }
                v.reset(OpS390XMOVDstore)
@@ -11180,7 +11180,7 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
        b := v.Block
        // match: (MULLDconst <t> x [c])
        // cond: isPowerOfTwo32(c&(c-1))
-       // result: (ADD (SLDconst <t> x [int8(log32(c&(c-1)))]) (SLDconst <t> x [int8(log32(c&^(c-1)))]))
+       // result: (ADD (SLDconst <t> x [uint8(log32(c&(c-1)))]) (SLDconst <t> x [uint8(log32(c&^(c-1)))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11190,17 +11190,17 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
                }
                v.reset(OpS390XADD)
                v0 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(c & (c - 1))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(c & (c - 1))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(c &^ (c - 1))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(c &^ (c - 1))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
        }
        // match: (MULLDconst <t> x [c])
        // cond: isPowerOfTwo32(c+(c&^(c-1)))
-       // result: (SUB (SLDconst <t> x [int8(log32(c+(c&^(c-1))))]) (SLDconst <t> x [int8(log32(c&^(c-1)))]))
+       // result: (SUB (SLDconst <t> x [uint8(log32(c+(c&^(c-1))))]) (SLDconst <t> x [uint8(log32(c&^(c-1)))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11210,17 +11210,17 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
                }
                v.reset(OpS390XSUB)
                v0 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(c + (c &^ (c - 1)))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(c + (c &^ (c - 1)))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(c &^ (c - 1))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(c &^ (c - 1))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
        }
        // match: (MULLDconst <t> x [c])
        // cond: isPowerOfTwo32(-c+(-c&^(-c-1)))
-       // result: (SUB (SLDconst <t> x [int8(log32(-c&^(-c-1)))]) (SLDconst <t> x [int8(log32(-c+(-c&^(-c-1))))]))
+       // result: (SUB (SLDconst <t> x [uint8(log32(-c&^(-c-1)))]) (SLDconst <t> x [uint8(log32(-c+(-c&^(-c-1))))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11230,10 +11230,10 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
                }
                v.reset(OpS390XSUB)
                v0 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(-c &^ (-c - 1))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(-c &^ (-c - 1))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLDconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(-c + (-c &^ (-c - 1)))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(-c + (-c &^ (-c - 1)))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
@@ -11407,7 +11407,7 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
        b := v.Block
        // match: (MULLWconst <t> x [c])
        // cond: isPowerOfTwo32(c&(c-1))
-       // result: (ADDW (SLWconst <t> x [int8(log32(c&(c-1)))]) (SLWconst <t> x [int8(log32(c&^(c-1)))]))
+       // result: (ADDW (SLWconst <t> x [uint8(log32(c&(c-1)))]) (SLWconst <t> x [uint8(log32(c&^(c-1)))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11417,17 +11417,17 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
                }
                v.reset(OpS390XADDW)
                v0 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(c & (c - 1))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(c & (c - 1))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(c &^ (c - 1))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(c &^ (c - 1))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
        }
        // match: (MULLWconst <t> x [c])
        // cond: isPowerOfTwo32(c+(c&^(c-1)))
-       // result: (SUBW (SLWconst <t> x [int8(log32(c+(c&^(c-1))))]) (SLWconst <t> x [int8(log32(c&^(c-1)))]))
+       // result: (SUBW (SLWconst <t> x [uint8(log32(c+(c&^(c-1))))]) (SLWconst <t> x [uint8(log32(c&^(c-1)))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11437,17 +11437,17 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
                }
                v.reset(OpS390XSUBW)
                v0 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(c + (c &^ (c - 1)))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(c + (c &^ (c - 1)))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(c &^ (c - 1))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(c &^ (c - 1))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
        }
        // match: (MULLWconst <t> x [c])
        // cond: isPowerOfTwo32(-c+(-c&^(-c-1)))
-       // result: (SUBW (SLWconst <t> x [int8(log32(-c&^(-c-1)))]) (SLWconst <t> x [int8(log32(-c+(-c&^(-c-1))))]))
+       // result: (SUBW (SLWconst <t> x [uint8(log32(-c&^(-c-1)))]) (SLWconst <t> x [uint8(log32(-c+(-c&^(-c-1))))]))
        for {
                t := v.Type
                c := auxIntToInt32(v.AuxInt)
@@ -11457,10 +11457,10 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
                }
                v.reset(OpS390XSUBW)
                v0 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v0.AuxInt = int8ToAuxInt(int8(log32(-c &^ (-c - 1))))
+               v0.AuxInt = uint8ToAuxInt(uint8(log32(-c &^ (-c - 1))))
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpS390XSLWconst, t)
-               v1.AuxInt = int8ToAuxInt(int8(log32(-c + (-c &^ (-c - 1)))))
+               v1.AuxInt = uint8ToAuxInt(uint8(log32(-c + (-c &^ (-c - 1)))))
                v1.AddArg(x)
                v.AddArg2(v0, v1)
                return true
@@ -11640,9 +11640,9 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        if v_0.Op != OpS390XSLDconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRISBGZ)
@@ -11804,7 +11804,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x1.Args[1]
                        p := x1.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 8 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 8 {
                                continue
                        }
                        x0 := sh.Args[0]
@@ -11843,7 +11843,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x1.Args[1]
                        p := x1.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 16 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 16 {
                                continue
                        }
                        x0 := sh.Args[0]
@@ -11882,7 +11882,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x1.Args[1]
                        p := x1.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 32 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 32 {
                                continue
                        }
                        x0 := sh.Args[0]
@@ -11916,7 +11916,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        if s0.Op != OpS390XSLDconst {
                                continue
                        }
-                       j0 := auxIntToInt8(s0.AuxInt)
+                       j0 := auxIntToUint8(s0.AuxInt)
                        x0 := s0.Args[0]
                        if x0.Op != OpS390XMOVBZload {
                                continue
@@ -11937,7 +11937,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                if s1.Op != OpS390XSLDconst {
                                        continue
                                }
-                               j1 := auxIntToInt8(s1.AuxInt)
+                               j1 := auxIntToUint8(s1.AuxInt)
                                x1 := s1.Args[0]
                                if x1.Op != OpS390XMOVBZload {
                                        continue
@@ -11958,7 +11958,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j1)
+                               v1.AuxInt = uint8ToAuxInt(j1)
                                v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
                                v2.AuxInt = int32ToAuxInt(i0)
                                v2.Aux = symToAux(s)
@@ -11979,7 +11979,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        if s0.Op != OpS390XSLDconst {
                                continue
                        }
-                       j0 := auxIntToInt8(s0.AuxInt)
+                       j0 := auxIntToUint8(s0.AuxInt)
                        x0 := s0.Args[0]
                        if x0.Op != OpS390XMOVHZload {
                                continue
@@ -12000,7 +12000,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                if s1.Op != OpS390XSLDconst {
                                        continue
                                }
-                               j1 := auxIntToInt8(s1.AuxInt)
+                               j1 := auxIntToUint8(s1.AuxInt)
                                x1 := s1.Args[0]
                                if x1.Op != OpS390XMOVHZload {
                                        continue
@@ -12021,7 +12021,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j1)
+                               v1.AuxInt = uint8ToAuxInt(j1)
                                v2 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
                                v2.AuxInt = int32ToAuxInt(i0)
                                v2.Aux = symToAux(s)
@@ -12047,7 +12047,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x0.Args[1]
                        p := x0.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 8 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 8 {
                                continue
                        }
                        x1 := sh.Args[0]
@@ -12092,7 +12092,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x0.Args[1]
                        p := x0.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 16 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 16 {
                                continue
                        }
                        r1 := sh.Args[0]
@@ -12141,7 +12141,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        mem := x0.Args[1]
                        p := x0.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLDconst || auxIntToInt8(sh.AuxInt) != 32 {
+                       if sh.Op != OpS390XSLDconst || auxIntToUint8(sh.AuxInt) != 32 {
                                continue
                        }
                        r1 := sh.Args[0]
@@ -12179,7 +12179,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        if s1.Op != OpS390XSLDconst {
                                continue
                        }
-                       j1 := auxIntToInt8(s1.AuxInt)
+                       j1 := auxIntToUint8(s1.AuxInt)
                        x1 := s1.Args[0]
                        if x1.Op != OpS390XMOVBZload {
                                continue
@@ -12200,7 +12200,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                if s0.Op != OpS390XSLDconst {
                                        continue
                                }
-                               j0 := auxIntToInt8(s0.AuxInt)
+                               j0 := auxIntToUint8(s0.AuxInt)
                                x0 := s0.Args[0]
                                if x0.Op != OpS390XMOVBZload {
                                        continue
@@ -12221,7 +12221,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j0)
+                               v1.AuxInt = uint8ToAuxInt(j0)
                                v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
                                v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
                                v3.AuxInt = int32ToAuxInt(i0)
@@ -12244,7 +12244,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                        if s1.Op != OpS390XSLDconst {
                                continue
                        }
-                       j1 := auxIntToInt8(s1.AuxInt)
+                       j1 := auxIntToUint8(s1.AuxInt)
                        r1 := s1.Args[0]
                        if r1.Op != OpS390XMOVHZreg {
                                continue
@@ -12269,7 +12269,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                if s0.Op != OpS390XSLDconst {
                                        continue
                                }
-                               j0 := auxIntToInt8(s0.AuxInt)
+                               j0 := auxIntToUint8(s0.AuxInt)
                                r0 := s0.Args[0]
                                if r0.Op != OpS390XMOVHZreg {
                                        continue
@@ -12294,7 +12294,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool {
                                v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j0)
+                               v1.AuxInt = uint8ToAuxInt(j0)
                                v2 := b.NewValue0(x0.Pos, OpS390XMOVWZreg, typ.UInt64)
                                v3 := b.NewValue0(x0.Pos, OpS390XMOVWBRload, typ.UInt32)
                                v3.AuxInt = int32ToAuxInt(i0)
@@ -12338,13 +12338,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        if v_0.Op != OpS390XSLWconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRWconst || auxIntToInt8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRWconst || auxIntToUint8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRLLconst)
-                       v.AuxInt = int8ToAuxInt(c)
+                       v.AuxInt = uint8ToAuxInt(c)
                        v.AddArg(x)
                        return true
                }
@@ -12428,7 +12428,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        mem := x1.Args[1]
                        p := x1.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLWconst || auxIntToInt8(sh.AuxInt) != 8 {
+                       if sh.Op != OpS390XSLWconst || auxIntToUint8(sh.AuxInt) != 8 {
                                continue
                        }
                        x0 := sh.Args[0]
@@ -12467,7 +12467,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        mem := x1.Args[1]
                        p := x1.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLWconst || auxIntToInt8(sh.AuxInt) != 16 {
+                       if sh.Op != OpS390XSLWconst || auxIntToUint8(sh.AuxInt) != 16 {
                                continue
                        }
                        x0 := sh.Args[0]
@@ -12501,7 +12501,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        if s0.Op != OpS390XSLWconst {
                                continue
                        }
-                       j0 := auxIntToInt8(s0.AuxInt)
+                       j0 := auxIntToUint8(s0.AuxInt)
                        x0 := s0.Args[0]
                        if x0.Op != OpS390XMOVBZload {
                                continue
@@ -12522,7 +12522,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                                if s1.Op != OpS390XSLWconst {
                                        continue
                                }
-                               j1 := auxIntToInt8(s1.AuxInt)
+                               j1 := auxIntToUint8(s1.AuxInt)
                                x1 := s1.Args[0]
                                if x1.Op != OpS390XMOVBZload {
                                        continue
@@ -12543,7 +12543,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                                v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j1)
+                               v1.AuxInt = uint8ToAuxInt(j1)
                                v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
                                v2.AuxInt = int32ToAuxInt(i0)
                                v2.Aux = symToAux(s)
@@ -12569,7 +12569,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        mem := x0.Args[1]
                        p := x0.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLWconst || auxIntToInt8(sh.AuxInt) != 8 {
+                       if sh.Op != OpS390XSLWconst || auxIntToUint8(sh.AuxInt) != 8 {
                                continue
                        }
                        x1 := sh.Args[0]
@@ -12614,7 +12614,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        mem := x0.Args[1]
                        p := x0.Args[0]
                        sh := v_1
-                       if sh.Op != OpS390XSLWconst || auxIntToInt8(sh.AuxInt) != 16 {
+                       if sh.Op != OpS390XSLWconst || auxIntToUint8(sh.AuxInt) != 16 {
                                continue
                        }
                        r1 := sh.Args[0]
@@ -12652,7 +12652,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                        if s1.Op != OpS390XSLWconst {
                                continue
                        }
-                       j1 := auxIntToInt8(s1.AuxInt)
+                       j1 := auxIntToUint8(s1.AuxInt)
                        x1 := s1.Args[0]
                        if x1.Op != OpS390XMOVBZload {
                                continue
@@ -12673,7 +12673,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                                if s0.Op != OpS390XSLWconst {
                                        continue
                                }
-                               j0 := auxIntToInt8(s0.AuxInt)
+                               j0 := auxIntToUint8(s0.AuxInt)
                                x0 := s0.Args[0]
                                if x0.Op != OpS390XMOVBZload {
                                        continue
@@ -12694,7 +12694,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool {
                                v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
                                v.copyOf(v0)
                                v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
-                               v1.AuxInt = int8ToAuxInt(j0)
+                               v1.AuxInt = uint8ToAuxInt(j0)
                                v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
                                v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
                                v3.AuxInt = int32ToAuxInt(i0)
@@ -12974,7 +12974,7 @@ func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool {
                if v_0.Op != OpS390XSLDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                x := v_0.Args[0]
                if !(r.InMerge(^uint64(0)<<c) != nil) {
                        break
@@ -12992,7 +12992,7 @@ func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool {
                if v_0.Op != OpS390XSRDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                x := v_0.Args[0]
                if !(r.InMerge(^uint64(0)>>c) != nil) {
                        break
@@ -13030,7 +13030,7 @@ func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool {
                        break
                }
                v.reset(OpS390XSRDconst)
-               v.AuxInt = int8ToAuxInt(-r.Amount & 63)
+               v.AuxInt = uint8ToAuxInt(-r.Amount & 63)
                v.AddArg(x)
                return true
        }
@@ -13044,7 +13044,7 @@ func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool {
                        break
                }
                v.reset(OpS390XSLDconst)
-               v.AuxInt = int8ToAuxInt(r.Amount)
+               v.AuxInt = uint8ToAuxInt(r.Amount)
                v.AddArg(x)
                return true
        }
@@ -13056,7 +13056,7 @@ func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool {
                if v_0.Op != OpS390XSRADconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                x := v_0.Args[0]
                if !(r.Start == r.End && (r.Start+r.Amount)&63 <= c) {
                        break
@@ -13131,7 +13131,7 @@ func rewriteValueS390X_OpS390XRLL(v *Value) bool {
        v_1 := v.Args[1]
        v_0 := v.Args[0]
        // match: (RLL x (MOVDconst [c]))
-       // result: (RLLconst x [int8(c&31)])
+       // result: (RLLconst x [uint8(c&31)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13139,7 +13139,7 @@ func rewriteValueS390X_OpS390XRLL(v *Value) bool {
                }
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpS390XRLLconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 31))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 31))
                v.AddArg(x)
                return true
        }
@@ -13149,7 +13149,7 @@ func rewriteValueS390X_OpS390XRLLG(v *Value) bool {
        v_1 := v.Args[1]
        v_0 := v.Args[0]
        // match: (RLLG x (MOVDconst [c]))
-       // result: (RISBGZ x {s390x.NewRotateParams(0, 63, int8(c&63))})
+       // result: (RISBGZ x {s390x.NewRotateParams(0, 63, uint8(c&63))})
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13157,7 +13157,7 @@ func rewriteValueS390X_OpS390XRLLG(v *Value) bool {
                }
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpS390XRISBGZ)
-               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(0, 63, int8(c&63)))
+               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(0, 63, uint8(c&63)))
                v.AddArg(x)
                return true
        }
@@ -13169,7 +13169,7 @@ func rewriteValueS390X_OpS390XSLD(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (SLD x (MOVDconst [c]))
-       // result: (SLDconst x [int8(c&63)])
+       // result: (SLDconst x [uint8(c&63)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13177,7 +13177,7 @@ func rewriteValueS390X_OpS390XSLD(v *Value) bool {
                }
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpS390XSLDconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 63))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 63))
                v.AddArg(x)
                return true
        }
@@ -13317,16 +13317,16 @@ func rewriteValueS390X_OpS390XSLD(v *Value) bool {
 func rewriteValueS390X_OpS390XSLDconst(v *Value) bool {
        v_0 := v.Args[0]
        // match: (SLDconst (SRDconst x [c]) [d])
-       // result: (RISBGZ x {s390x.NewRotateParams(max8(0, c-d), 63-d, (d-c)&63)})
+       // result: (RISBGZ x {s390x.NewRotateParams(uint8(max8(0, int8(c-d))), 63-d, uint8(int8(d-c)&63))})
        for {
-               d := auxIntToInt8(v.AuxInt)
+               d := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XSRDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                x := v_0.Args[0]
                v.reset(OpS390XRISBGZ)
-               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(max8(0, c-d), 63-d, (d-c)&63))
+               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(uint8(max8(0, int8(c-d))), 63-d, uint8(int8(d-c)&63)))
                v.AddArg(x)
                return true
        }
@@ -13334,7 +13334,7 @@ func rewriteValueS390X_OpS390XSLDconst(v *Value) bool {
        // cond: s390x.NewRotateParams(0, 63-c, c).InMerge(r.OutMask()) != nil
        // result: (RISBGZ x {(*s390x.NewRotateParams(0, 63-c, c).InMerge(r.OutMask())).RotateLeft(r.Amount)})
        for {
-               c := auxIntToInt8(v.AuxInt)
+               c := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XRISBGZ {
                        break
                }
@@ -13351,7 +13351,7 @@ func rewriteValueS390X_OpS390XSLDconst(v *Value) bool {
        // match: (SLDconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -13367,7 +13367,7 @@ func rewriteValueS390X_OpS390XSLW(v *Value) bool {
        typ := &b.Func.Config.Types
        // match: (SLW x (MOVDconst [c]))
        // cond: c&32 == 0
-       // result: (SLWconst x [int8(c&31)])
+       // result: (SLWconst x [uint8(c&31)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13378,7 +13378,7 @@ func rewriteValueS390X_OpS390XSLW(v *Value) bool {
                        break
                }
                v.reset(OpS390XSLWconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 31))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 31))
                v.AddArg(x)
                return true
        }
@@ -13535,7 +13535,7 @@ func rewriteValueS390X_OpS390XSLWconst(v *Value) bool {
        // match: (SLWconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -13550,7 +13550,7 @@ func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (SRAD x (MOVDconst [c]))
-       // result: (SRADconst x [int8(c&63)])
+       // result: (SRADconst x [uint8(c&63)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13558,7 +13558,7 @@ func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
                }
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpS390XSRADconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 63))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 63))
                v.AddArg(x)
                return true
        }
@@ -13700,7 +13700,7 @@ func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
        // match: (SRADconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -13710,7 +13710,7 @@ func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
        // match: (SRADconst [c] (MOVDconst [d]))
        // result: (MOVDconst [d>>uint64(c)])
        for {
-               c := auxIntToInt8(v.AuxInt)
+               c := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XMOVDconst {
                        break
                }
@@ -13728,7 +13728,7 @@ func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
        typ := &b.Func.Config.Types
        // match: (SRAW x (MOVDconst [c]))
        // cond: c&32 == 0
-       // result: (SRAWconst x [int8(c&31)])
+       // result: (SRAWconst x [uint8(c&31)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13739,7 +13739,7 @@ func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
                        break
                }
                v.reset(OpS390XSRAWconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 31))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 31))
                v.AddArg(x)
                return true
        }
@@ -13756,7 +13756,7 @@ func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
                        break
                }
                v.reset(OpS390XSRAWconst)
-               v.AuxInt = int8ToAuxInt(31)
+               v.AuxInt = uint8ToAuxInt(31)
                v.AddArg(x)
                return true
        }
@@ -13898,7 +13898,7 @@ func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
        // match: (SRAWconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -13908,7 +13908,7 @@ func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
        // match: (SRAWconst [c] (MOVDconst [d]))
        // result: (MOVDconst [int64(int32(d))>>uint64(c)])
        for {
-               c := auxIntToInt8(v.AuxInt)
+               c := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XMOVDconst {
                        break
                }
@@ -13925,7 +13925,7 @@ func rewriteValueS390X_OpS390XSRD(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (SRD x (MOVDconst [c]))
-       // result: (SRDconst x [int8(c&63)])
+       // result: (SRDconst x [uint8(c&63)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -13933,7 +13933,7 @@ func rewriteValueS390X_OpS390XSRD(v *Value) bool {
                }
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpS390XSRDconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 63))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 63))
                v.AddArg(x)
                return true
        }
@@ -14073,16 +14073,16 @@ func rewriteValueS390X_OpS390XSRD(v *Value) bool {
 func rewriteValueS390X_OpS390XSRDconst(v *Value) bool {
        v_0 := v.Args[0]
        // match: (SRDconst (SLDconst x [c]) [d])
-       // result: (RISBGZ x {s390x.NewRotateParams(d, min8(63, 63-c+d), (c-d)&63)})
+       // result: (RISBGZ x {s390x.NewRotateParams(d, uint8(min8(63, int8(63-c+d))), uint8(int8(c-d)&63))})
        for {
-               d := auxIntToInt8(v.AuxInt)
+               d := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XSLDconst {
                        break
                }
-               c := auxIntToInt8(v_0.AuxInt)
+               c := auxIntToUint8(v_0.AuxInt)
                x := v_0.Args[0]
                v.reset(OpS390XRISBGZ)
-               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(d, min8(63, 63-c+d), (c-d)&63))
+               v.Aux = s390xRotateParamsToAux(s390x.NewRotateParams(d, uint8(min8(63, int8(63-c+d))), uint8(int8(c-d)&63)))
                v.AddArg(x)
                return true
        }
@@ -14090,7 +14090,7 @@ func rewriteValueS390X_OpS390XSRDconst(v *Value) bool {
        // cond: s390x.NewRotateParams(c, 63, -c&63).InMerge(r.OutMask()) != nil
        // result: (RISBGZ x {(*s390x.NewRotateParams(c, 63, -c&63).InMerge(r.OutMask())).RotateLeft(r.Amount)})
        for {
-               c := auxIntToInt8(v.AuxInt)
+               c := auxIntToUint8(v.AuxInt)
                if v_0.Op != OpS390XRISBGZ {
                        break
                }
@@ -14107,7 +14107,7 @@ func rewriteValueS390X_OpS390XSRDconst(v *Value) bool {
        // match: (SRDconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -14123,7 +14123,7 @@ func rewriteValueS390X_OpS390XSRW(v *Value) bool {
        typ := &b.Func.Config.Types
        // match: (SRW x (MOVDconst [c]))
        // cond: c&32 == 0
-       // result: (SRWconst x [int8(c&31)])
+       // result: (SRWconst x [uint8(c&31)])
        for {
                x := v_0
                if v_1.Op != OpS390XMOVDconst {
@@ -14134,7 +14134,7 @@ func rewriteValueS390X_OpS390XSRW(v *Value) bool {
                        break
                }
                v.reset(OpS390XSRWconst)
-               v.AuxInt = int8ToAuxInt(int8(c & 31))
+               v.AuxInt = uint8ToAuxInt(uint8(c & 31))
                v.AddArg(x)
                return true
        }
@@ -14291,7 +14291,7 @@ func rewriteValueS390X_OpS390XSRWconst(v *Value) bool {
        // match: (SRWconst x [0])
        // result: x
        for {
-               if auxIntToInt8(v.AuxInt) != 0 {
+               if auxIntToUint8(v.AuxInt) != 0 {
                        break
                }
                x := v_0
@@ -14339,7 +14339,7 @@ func rewriteValueS390X_OpS390XSTM2(v *Value) bool {
                i := auxIntToInt32(v.AuxInt)
                s := auxToSym(v.Aux)
                p := v_0
-               if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 32 {
+               if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 32 {
                        break
                }
                x := v_1.Args[0]
@@ -14851,7 +14851,7 @@ func rewriteValueS390X_OpS390XSumBytes2(v *Value) bool {
                x := v_0
                v.reset(OpS390XADDW)
                v0 := b.NewValue0(v.Pos, OpS390XSRWconst, typ.UInt8)
-               v0.AuxInt = int8ToAuxInt(8)
+               v0.AuxInt = uint8ToAuxInt(8)
                v0.AddArg(x)
                v.AddArg2(v0, x)
                return true
@@ -14868,7 +14868,7 @@ func rewriteValueS390X_OpS390XSumBytes4(v *Value) bool {
                v.reset(OpS390XSumBytes2)
                v0 := b.NewValue0(v.Pos, OpS390XADDW, typ.UInt16)
                v1 := b.NewValue0(v.Pos, OpS390XSRWconst, typ.UInt16)
-               v1.AuxInt = int8ToAuxInt(16)
+               v1.AuxInt = uint8ToAuxInt(16)
                v1.AddArg(x)
                v0.AddArg2(v1, x)
                v.AddArg(v0)
@@ -14886,7 +14886,7 @@ func rewriteValueS390X_OpS390XSumBytes8(v *Value) bool {
                v.reset(OpS390XSumBytes4)
                v0 := b.NewValue0(v.Pos, OpS390XADDW, typ.UInt32)
                v1 := b.NewValue0(v.Pos, OpS390XSRDconst, typ.UInt32)
-               v1.AuxInt = int8ToAuxInt(32)
+               v1.AuxInt = uint8ToAuxInt(32)
                v1.AddArg(x)
                v0.AddArg2(v1, x)
                v.AddArg(v0)
@@ -14923,9 +14923,9 @@ func rewriteValueS390X_OpS390XXOR(v *Value) bool {
                        if v_0.Op != OpS390XSLDconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRDconst || auxIntToInt8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRDconst || auxIntToUint8(v_1.AuxInt) != 64-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRISBGZ)
@@ -15019,13 +15019,13 @@ func rewriteValueS390X_OpS390XXORW(v *Value) bool {
                        if v_0.Op != OpS390XSLWconst {
                                continue
                        }
-                       c := auxIntToInt8(v_0.AuxInt)
+                       c := auxIntToUint8(v_0.AuxInt)
                        x := v_0.Args[0]
-                       if v_1.Op != OpS390XSRWconst || auxIntToInt8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
+                       if v_1.Op != OpS390XSRWconst || auxIntToUint8(v_1.AuxInt) != 32-c || x != v_1.Args[0] {
                                continue
                        }
                        v.reset(OpS390XRLLconst)
-                       v.AuxInt = int8ToAuxInt(c)
+                       v.AuxInt = uint8ToAuxInt(c)
                        v.AddArg(x)
                        return true
                }
@@ -15649,7 +15649,7 @@ func rewriteValueS390X_OpSlicemask(v *Value) bool {
                t := v.Type
                x := v_0
                v.reset(OpS390XSRADconst)
-               v.AuxInt = int8ToAuxInt(63)
+               v.AuxInt = uint8ToAuxInt(63)
                v0 := b.NewValue0(v.Pos, OpS390XNEG, t)
                v0.AddArg(x)
                v.AddArg(v0)

diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index c49bc8043e7f2b584a5bd19266b55a6a10514b58..60b727f45fdcb1fdb55960db18fb8e1e6aa4c76b 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -184,12 +184,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
        config := b.Func.Config
        typ := &b.Func.Config.Types
        // match: (Arg {n} [off])
-       // cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+       // cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
        // result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
        for {
                off := auxIntToInt32(v.AuxInt)
                n := auxToSym(v.Aux)
-               if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+               if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
                        break
                }
                v.reset(OpInt64Make)
@@ -203,12 +203,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
                return true
        }
        // match: (Arg {n} [off])
-       // cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+       // cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
        // result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
        for {
                off := auxIntToInt32(v.AuxInt)
                n := auxToSym(v.Aux)
-               if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+               if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
                        break
                }
                v.reset(OpInt64Make)
@@ -222,12 +222,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
                return true
        }
        // match: (Arg {n} [off])
-       // cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+       // cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
        // result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
        for {
                off := auxIntToInt32(v.AuxInt)
                n := auxToSym(v.Aux)
-               if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+               if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
                        break
                }
                v.reset(OpInt64Make)
@@ -241,12 +241,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
                return true
        }
        // match: (Arg {n} [off])
-       // cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+       // cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
        // result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
        for {
                off := auxIntToInt32(v.AuxInt)
                n := auxToSym(v.Aux)
-               if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+               if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
                        break
                }
                v.reset(OpInt64Make)

diff --git a/src/cmd/compile/internal/ssa/rewritedecArgs.go b/src/cmd/compile/internal/ssa/rewritedecArgs.go
deleted file mode 100644 (file)
index 23ff417..0000000
--- a/src/cmd/compile/internal/ssa/rewritedecArgs.go
+++ /dev/null
@@ -1,247 +0,0 @@
-// Code generated from gen/decArgs.rules; DO NOT EDIT.
-// generated with: cd gen; go run *.go
-
-package ssa
-
-func rewriteValuedecArgs(v *Value) bool {
-       switch v.Op {
-       case OpArg:
-               return rewriteValuedecArgs_OpArg(v)
-       }
-       return false
-}
-func rewriteValuedecArgs_OpArg(v *Value) bool {
-       b := v.Block
-       config := b.Func.Config
-       fe := b.Func.fe
-       typ := &b.Func.Config.Types
-       // match: (Arg {n} [off])
-       // cond: v.Type.IsString()
-       // result: (StringMake (Arg <typ.BytePtr> {n} [off]) (Arg <typ.Int> {n} [off+int32(config.PtrSize)]))
-       for {
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(v.Type.IsString()) {
-                       break
-               }
-               v.reset(OpStringMake)
-               v0 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
-               v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-               v1.Aux = symToAux(n)
-               v.AddArg2(v0, v1)
-               return true
-       }
-       // match: (Arg {n} [off])
-       // cond: v.Type.IsSlice()
-       // result: (SliceMake (Arg <v.Type.Elem().PtrTo()> {n} [off]) (Arg <typ.Int> {n} [off+int32(config.PtrSize)]) (Arg <typ.Int> {n} [off+2*int32(config.PtrSize)]))
-       for {
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(v.Type.IsSlice()) {
-                       break
-               }
-               v.reset(OpSliceMake)
-               v0 := b.NewValue0(v.Pos, OpArg, v.Type.Elem().PtrTo())
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
-               v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-               v1.Aux = symToAux(n)
-               v2 := b.NewValue0(v.Pos, OpArg, typ.Int)
-               v2.AuxInt = int32ToAuxInt(off + 2*int32(config.PtrSize))
-               v2.Aux = symToAux(n)
-               v.AddArg3(v0, v1, v2)
-               return true
-       }
-       // match: (Arg {n} [off])
-       // cond: v.Type.IsInterface()
-       // result: (IMake (Arg <typ.Uintptr> {n} [off]) (Arg <typ.BytePtr> {n} [off+int32(config.PtrSize)]))
-       for {
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(v.Type.IsInterface()) {
-                       break
-               }
-               v.reset(OpIMake)
-               v0 := b.NewValue0(v.Pos, OpArg, typ.Uintptr)
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
-               v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-               v1.Aux = symToAux(n)
-               v.AddArg2(v0, v1)
-               return true
-       }
-       // match: (Arg {n} [off])
-       // cond: v.Type.IsComplex() && v.Type.Size() == 16
-       // result: (ComplexMake (Arg <typ.Float64> {n} [off]) (Arg <typ.Float64> {n} [off+8]))
-       for {
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(v.Type.IsComplex() && v.Type.Size() == 16) {
-                       break
-               }
-               v.reset(OpComplexMake)
-               v0 := b.NewValue0(v.Pos, OpArg, typ.Float64)
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, typ.Float64)
-               v1.AuxInt = int32ToAuxInt(off + 8)
-               v1.Aux = symToAux(n)
-               v.AddArg2(v0, v1)
-               return true
-       }
-       // match: (Arg {n} [off])
-       // cond: v.Type.IsComplex() && v.Type.Size() == 8
-       // result: (ComplexMake (Arg <typ.Float32> {n} [off]) (Arg <typ.Float32> {n} [off+4]))
-       for {
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(v.Type.IsComplex() && v.Type.Size() == 8) {
-                       break
-               }
-               v.reset(OpComplexMake)
-               v0 := b.NewValue0(v.Pos, OpArg, typ.Float32)
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, typ.Float32)
-               v1.AuxInt = int32ToAuxInt(off + 4)
-               v1.Aux = symToAux(n)
-               v.AddArg2(v0, v1)
-               return true
-       }
-       // match: (Arg <t>)
-       // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)
-       // result: (StructMake0)
-       for {
-               t := v.Type
-               if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpStructMake0)
-               return true
-       }
-       // match: (Arg <t> {n} [off])
-       // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
-       // result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]))
-       for {
-               t := v.Type
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpStructMake1)
-               v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-               v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-               v0.Aux = symToAux(n)
-               v.AddArg(v0)
-               return true
-       }
-       // match: (Arg <t> {n} [off])
-       // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)
-       // result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]))
-       for {
-               t := v.Type
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpStructMake2)
-               v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-               v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-               v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-               v1.Aux = symToAux(n)
-               v.AddArg2(v0, v1)
-               return true
-       }
-       // match: (Arg <t> {n} [off])
-       // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)
-       // result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]) (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]))
-       for {
-               t := v.Type
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpStructMake3)
-               v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-               v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-               v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-               v1.Aux = symToAux(n)
-               v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
-               v2.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(2)))
-               v2.Aux = symToAux(n)
-               v.AddArg3(v0, v1, v2)
-               return true
-       }
-       // match: (Arg <t> {n} [off])
-       // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)
-       // result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]) (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]) (Arg <t.FieldType(3)> {n} [off+int32(t.FieldOff(3))]))
-       for {
-               t := v.Type
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpStructMake4)
-               v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-               v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-               v0.Aux = symToAux(n)
-               v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-               v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-               v1.Aux = symToAux(n)
-               v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
-               v2.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(2)))
-               v2.Aux = symToAux(n)
-               v3 := b.NewValue0(v.Pos, OpArg, t.FieldType(3))
-               v3.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(3)))
-               v3.Aux = symToAux(n)
-               v.AddArg4(v0, v1, v2, v3)
-               return true
-       }
-       // match: (Arg <t>)
-       // cond: t.IsArray() && t.NumElem() == 0
-       // result: (ArrayMake0)
-       for {
-               t := v.Type
-               if !(t.IsArray() && t.NumElem() == 0) {
-                       break
-               }
-               v.reset(OpArrayMake0)
-               return true
-       }
-       // match: (Arg <t> {n} [off])
-       // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)
-       // result: (ArrayMake1 (Arg <t.Elem()> {n} [off]))
-       for {
-               t := v.Type
-               off := auxIntToInt32(v.AuxInt)
-               n := auxToSym(v.Aux)
-               if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) {
-                       break
-               }
-               v.reset(OpArrayMake1)
-               v0 := b.NewValue0(v.Pos, OpArg, t.Elem())
-               v0.AuxInt = int32ToAuxInt(off)
-               v0.Aux = symToAux(n)
-               v.AddArg(v0)
-               return true
-       }
-       return false
-}
-func rewriteBlockdecArgs(b *Block) bool {
-       switch b.Kind {
-       }
-       return false
-}

diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 4cb9a8f3287ed534477967793e8309d668d75646..958e24d29f02e167c473fec5b3061c44ba145419 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -13637,7 +13637,7 @@ func rewriteValuegeneric_OpMove(v *Value) bool {
                return true
        }
        // match: (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _))
-       // cond: t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
+       // cond: t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && !isVolatile(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
        // result: (Move {t1} [s] dst src midmem)
        for {
                s := auxIntToInt64(v.AuxInt)
@@ -13651,7 +13651,7 @@ func rewriteValuegeneric_OpMove(v *Value) bool {
                t2 := auxToType(midmem.Aux)
                src := midmem.Args[1]
                tmp2 := midmem.Args[0]
-               if !(t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
+               if !(t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && !isVolatile(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
                        break
                }
                v.reset(OpMove)
@@ -13661,7 +13661,7 @@ func rewriteValuegeneric_OpMove(v *Value) bool {
                return true
        }
        // match: (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _)))
-       // cond: t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
+       // cond: t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && !isVolatile(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
        // result: (Move {t1} [s] dst src midmem)
        for {
                s := auxIntToInt64(v.AuxInt)
@@ -13679,7 +13679,7 @@ func rewriteValuegeneric_OpMove(v *Value) bool {
                t2 := auxToType(midmem_0.Aux)
                src := midmem_0.Args[1]
                tmp2 := midmem_0.Args[0]
-               if !(t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
+               if !(t1.Compare(t2) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && !isVolatile(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
                        break
                }
                v.reset(OpMove)

diff --git a/src/cmd/compile/internal/ssa/sizeof_test.go b/src/cmd/compile/internal/ssa/sizeof_test.go
index 60ada011e3e0b7dc552383442226509d3b883710..a27002ee3ac3b26a557decab61d33de604665398 100644 (file)
--- a/src/cmd/compile/internal/ssa/sizeof_test.go
+++ b/src/cmd/compile/internal/ssa/sizeof_test.go
@@ -22,7 +22,7 @@ func TestSizeof(t *testing.T) {
        }{
                {Value{}, 72, 112},
                {Block{}, 164, 304},
-               {LocalSlot{}, 32, 48},
+               {LocalSlot{}, 28, 40},
                {valState{}, 28, 40},
        }
 

diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 406a3c3ea53faa46455823ee34309ddaa16be37f..68a6f08a2a9b23faefa7bb6dd2f0a4641ef33fa7 100644 (file)
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -7,6 +7,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/src"
        "fmt"
@@ -156,7 +157,7 @@ func (s *stackAllocState) stackalloc() {
                if v.Aux == nil {
                        f.Fatalf("%s has nil Aux\n", v.LongString())
                }
-               loc := LocalSlot{N: v.Aux.(GCNode), Type: v.Type, Off: v.AuxInt}
+               loc := LocalSlot{N: v.Aux.(*ir.Name), Type: v.Type, Off: v.AuxInt}
                if f.pass.debug > stackDebug {
                        fmt.Printf("stackalloc %s to %s\n", v, loc)
                }

diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index edc43aaae72185217487cc7fc68c3ad43d197ad7..d000b7cce011a9de9e38e0327637230f037feda5 100644 (file)
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/types"
        "cmd/internal/src"
        "fmt"
@@ -36,7 +37,7 @@ type Value struct {
        // Users of AuxInt which interpret AuxInt as unsigned (e.g. shifts) must be careful.
        // Use Value.AuxUnsigned to get the zero-extended value of AuxInt.
        AuxInt int64
-       Aux    interface{}
+       Aux    Aux
 
        // Arguments of this value
        Args []*Value
@@ -492,3 +493,16 @@ func (v *Value) removeable() bool {
        }
        return true
 }
+
+// TODO(mdempsky): Shouldn't be necessary; see discussion at golang.org/cl/275756
+func (*Value) CanBeAnSSAAux() {}
+
+// AutoVar returns a *Name and int64 representing the auto variable and offset within it
+// where v should be spilled.
+func AutoVar(v *Value) (*ir.Name, int64) {
+       loc := v.Block.Func.RegAlloc[v.ID].(LocalSlot)
+       if v.Type.Size() > loc.Type.Size() {
+               v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
+       }
+       return loc.N, loc.Off
+}

diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 849c9e8967c60f73a60c2f2d8606c5ba68158f86..4378f2d62763c0c14a40534fb05e584f34938b96 100644 (file)
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+       "cmd/compile/internal/reflectdata"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/objabi"
@@ -270,11 +271,11 @@ func writebarrier(f *Func) {
                        case OpMoveWB:
                                fn = typedmemmove
                                val = w.Args[1]
-                               typ = w.Aux.(*types.Type).Symbol()
+                               typ = reflectdata.TypeLinksym(w.Aux.(*types.Type))
                                nWBops--
                        case OpZeroWB:
                                fn = typedmemclr
-                               typ = w.Aux.(*types.Type).Symbol()
+                               typ = reflectdata.TypeLinksym(w.Aux.(*types.Type))
                                nWBops--
                        case OpVarDef, OpVarLive, OpVarKill:
                        }

diff --git a/src/cmd/compile/internal/ssa/zcse.go b/src/cmd/compile/internal/ssa/zcse.go
index ec38b7d1ba4ae2abd55dfa045b3283cd008b2642..e08272c34580173c60929b7c9edc4183d80050f4 100644 (file)
--- a/src/cmd/compile/internal/ssa/zcse.go
+++ b/src/cmd/compile/internal/ssa/zcse.go
@@ -57,7 +57,7 @@ func zcse(f *Func) {
 type vkey struct {
        op Op
        ai int64       // aux int
-       ax interface{} // aux
+       ax Aux         // aux
        t  *types.Type // type
 }
 

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
new file mode 100644 (file)
index 0000000..7180b38
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -0,0 +1,379 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssagen
+
+import (
+       "fmt"
+       "io/ioutil"
+       "log"
+       "os"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/escape"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+)
+
+// useNewABIWrapGen returns TRUE if the compiler should generate an
+// ABI wrapper for the function 'f'.
+func useABIWrapGen(f *ir.Func) bool {
+       if !base.Flag.ABIWrap {
+               return false
+       }
+
+       // Support limit option for bisecting.
+       if base.Flag.ABIWrapLimit == 1 {
+               return false
+       }
+       if base.Flag.ABIWrapLimit < 1 {
+               return true
+       }
+       base.Flag.ABIWrapLimit--
+       if base.Debug.ABIWrap != 0 && base.Flag.ABIWrapLimit == 1 {
+               fmt.Fprintf(os.Stderr, "=-= limit reached after new wrapper for %s\n",
+                       f.LSym.Name)
+       }
+
+       return true
+}
+
+// symabiDefs and symabiRefs record the defined and referenced ABIs of
+// symbols required by non-Go code. These are keyed by link symbol
+// name, where the local package prefix is always `"".`
+var symabiDefs, symabiRefs map[string]obj.ABI
+
+func CgoSymABIs() {
+       // The linker expects an ABI0 wrapper for all cgo-exported
+       // functions.
+       for _, prag := range typecheck.Target.CgoPragmas {
+               switch prag[0] {
+               case "cgo_export_static", "cgo_export_dynamic":
+                       if symabiRefs == nil {
+                               symabiRefs = make(map[string]obj.ABI)
+                       }
+                       symabiRefs[prag[1]] = obj.ABI0
+               }
+       }
+}
+
+// ReadSymABIs reads a symabis file that specifies definitions and
+// references of text symbols by ABI.
+//
+// The symabis format is a set of lines, where each line is a sequence
+// of whitespace-separated fields. The first field is a verb and is
+// either "def" for defining a symbol ABI or "ref" for referencing a
+// symbol using an ABI. For both "def" and "ref", the second field is
+// the symbol name and the third field is the ABI name, as one of the
+// named cmd/internal/obj.ABI constants.
+func ReadSymABIs(file, myimportpath string) {
+       data, err := ioutil.ReadFile(file)
+       if err != nil {
+               log.Fatalf("-symabis: %v", err)
+       }
+
+       symabiDefs = make(map[string]obj.ABI)
+       symabiRefs = make(map[string]obj.ABI)
+
+       localPrefix := ""
+       if myimportpath != "" {
+               // Symbols in this package may be written either as
+               // "".X or with the package's import path already in
+               // the symbol.
+               localPrefix = objabi.PathToPrefix(myimportpath) + "."
+       }
+
+       for lineNum, line := range strings.Split(string(data), "\n") {
+               lineNum++ // 1-based
+               line = strings.TrimSpace(line)
+               if line == "" || strings.HasPrefix(line, "#") {
+                       continue
+               }
+
+               parts := strings.Fields(line)
+               switch parts[0] {
+               case "def", "ref":
+                       // Parse line.
+                       if len(parts) != 3 {
+                               log.Fatalf(`%s:%d: invalid symabi: syntax is "%s sym abi"`, file, lineNum, parts[0])
+                       }
+                       sym, abistr := parts[1], parts[2]
+                       abi, valid := obj.ParseABI(abistr)
+                       if !valid {
+                               log.Fatalf(`%s:%d: invalid symabi: unknown abi "%s"`, file, lineNum, abistr)
+                       }
+
+                       // If the symbol is already prefixed with
+                       // myimportpath, rewrite it to start with ""
+                       // so it matches the compiler's internal
+                       // symbol names.
+                       if localPrefix != "" && strings.HasPrefix(sym, localPrefix) {
+                               sym = `"".` + sym[len(localPrefix):]
+                       }
+
+                       // Record for later.
+                       if parts[0] == "def" {
+                               symabiDefs[sym] = abi
+                       } else {
+                               symabiRefs[sym] = abi
+                       }
+               default:
+                       log.Fatalf(`%s:%d: invalid symabi type "%s"`, file, lineNum, parts[0])
+               }
+       }
+}
+
+// InitLSym defines f's obj.LSym and initializes it based on the
+// properties of f. This includes setting the symbol flags and ABI and
+// creating and initializing related DWARF symbols.
+//
+// InitLSym must be called exactly once per function and must be
+// called for both functions with bodies and functions without bodies.
+// For body-less functions, we only create the LSym; for functions
+// with bodies call a helper to setup up / populate the LSym.
+func InitLSym(f *ir.Func, hasBody bool) {
+       // FIXME: for new-style ABI wrappers, we set up the lsym at the
+       // point the wrapper is created.
+       if f.LSym != nil && base.Flag.ABIWrap {
+               return
+       }
+       staticdata.NeedFuncSym(f.Sym())
+       selectLSym(f, hasBody)
+       if hasBody {
+               setupTextLSym(f, 0)
+       }
+}
+
+// selectLSym sets up the LSym for a given function, and
+// makes calls to helpers to create ABI wrappers if needed.
+func selectLSym(f *ir.Func, hasBody bool) {
+       if f.LSym != nil {
+               base.FatalfAt(f.Pos(), "InitLSym called twice on %v", f)
+       }
+
+       if nam := f.Nname; !ir.IsBlank(nam) {
+
+               var wrapperABI obj.ABI
+               needABIWrapper := false
+               defABI, hasDefABI := symabiDefs[nam.Linksym().Name]
+               if hasDefABI && defABI == obj.ABI0 {
+                       // Symbol is defined as ABI0. Create an
+                       // Internal -> ABI0 wrapper.
+                       f.LSym = nam.LinksymABI(obj.ABI0)
+                       needABIWrapper, wrapperABI = true, obj.ABIInternal
+               } else {
+                       f.LSym = nam.Linksym()
+                       // No ABI override. Check that the symbol is
+                       // using the expected ABI.
+                       want := obj.ABIInternal
+                       if f.LSym.ABI() != want {
+                               base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
+                       }
+               }
+               if f.Pragma&ir.Systemstack != 0 {
+                       f.LSym.Set(obj.AttrCFunc, true)
+               }
+
+               isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
+               if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
+                       // Either 1) this symbol is definitely
+                       // referenced as ABI0 from this package; or 2)
+                       // this symbol is defined in this package but
+                       // given a linkname, indicating that it may be
+                       // referenced from another package. Create an
+                       // ABI0 -> Internal wrapper so it can be
+                       // called as ABI0. In case 2, it's important
+                       // that we know it's defined in this package
+                       // since other packages may "pull" symbols
+                       // using linkname and we don't want to create
+                       // duplicate ABI wrappers.
+                       if f.LSym.ABI() != obj.ABI0 {
+                               needABIWrapper, wrapperABI = true, obj.ABI0
+                       }
+               }
+
+               if needABIWrapper {
+                       if !useABIWrapGen(f) {
+                               // Fallback: use alias instead. FIXME.
+
+                               // These LSyms have the same name as the
+                               // native function, so we create them directly
+                               // rather than looking them up. The uniqueness
+                               // of f.lsym ensures uniqueness of asym.
+                               asym := &obj.LSym{
+                                       Name: f.LSym.Name,
+                                       Type: objabi.SABIALIAS,
+                                       R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
+                               }
+                               asym.SetABI(wrapperABI)
+                               asym.Set(obj.AttrDuplicateOK, true)
+                               base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
+                       } else {
+                               if base.Debug.ABIWrap != 0 {
+                                       fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %s.%s\n",
+                                               wrapperABI, 1-wrapperABI, types.LocalPkg.Path, f.LSym.Name)
+                               }
+                               makeABIWrapper(f, wrapperABI)
+                       }
+               }
+       }
+}
+
+// makeABIWrapper creates a new function that wraps a cross-ABI call
+// to "f".  The wrapper is marked as an ABIWRAPPER.
+func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
+
+       // Q: is this needed?
+       savepos := base.Pos
+       savedclcontext := typecheck.DeclContext
+       savedcurfn := ir.CurFunc
+
+       base.Pos = base.AutogeneratedPos
+       typecheck.DeclContext = ir.PEXTERN
+
+       // At the moment we don't support wrapping a method, we'd need machinery
+       // below to handle the receiver. Panic if we see this scenario.
+       ft := f.Nname.Ntype.Type()
+       if ft.NumRecvs() != 0 {
+               panic("makeABIWrapper support for wrapping methods not implemented")
+       }
+
+       // Manufacture a new func type to use for the wrapper.
+       var noReceiver *ir.Field
+       tfn := ir.NewFuncType(base.Pos,
+               noReceiver,
+               typecheck.NewFuncParams(ft.Params(), true),
+               typecheck.NewFuncParams(ft.Results(), false))
+
+       // Reuse f's types.Sym to create a new ODCLFUNC/function.
+       fn := typecheck.DeclFunc(f.Nname.Sym(), tfn)
+       fn.SetDupok(true)
+       fn.SetWrapper(true) // ignore frame for panic+recover matching
+
+       // Select LSYM now.
+       asym := base.Ctxt.LookupABI(f.LSym.Name, wrapperABI)
+       asym.Type = objabi.STEXT
+       if fn.LSym != nil {
+               panic("unexpected")
+       }
+       fn.LSym = asym
+
+       // ABI0-to-ABIInternal wrappers will be mainly loading params from
+       // stack into registers (and/or storing stack locations back to
+       // registers after the wrapped call); in most cases they won't
+       // need to allocate stack space, so it should be OK to mark them
+       // as NOSPLIT in these cases. In addition, my assumption is that
+       // functions written in assembly are NOSPLIT in most (but not all)
+       // cases. In the case of an ABIInternal target that has too many
+       // parameters to fit into registers, the wrapper would need to
+       // allocate stack space, but this seems like an unlikely scenario.
+       // Hence: mark these wrappers NOSPLIT.
+       //
+       // ABIInternal-to-ABI0 wrappers on the other hand will be taking
+       // things in registers and pushing them onto the stack prior to
+       // the ABI0 call, meaning that they will always need to allocate
+       // stack space. If the compiler marks them as NOSPLIT this seems
+       // as though it could lead to situations where the the linker's
+       // nosplit-overflow analysis would trigger a link failure. On the
+       // other hand if they not tagged NOSPLIT then this could cause
+       // problems when building the runtime (since there may be calls to
+       // asm routine in cases where it's not safe to grow the stack). In
+       // most cases the wrapper would be (in effect) inlined, but are
+       // there (perhaps) indirect calls from the runtime that could run
+       // into trouble here.
+       // FIXME: at the moment all.bash does not pass when I leave out
+       // NOSPLIT for these wrappers, so all are currently tagged with NOSPLIT.
+       setupTextLSym(fn, obj.NOSPLIT|obj.ABIWRAPPER)
+
+       // Generate call. Use tail call if no params and no returns,
+       // but a regular call otherwise.
+       //
+       // Note: ideally we would be using a tail call in cases where
+       // there are params but no returns for ABI0->ABIInternal wrappers,
+       // provided that all params fit into registers (e.g. we don't have
+       // to allocate any stack space). Doing this will require some
+       // extra work in typecheck/walk/ssa, might want to add a new node
+       // OTAILCALL or something to this effect.
+       tailcall := tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0
+       if base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink {
+               // cannot tailcall on PPC64 with dynamic linking, as we need
+               // to restore R2 after call.
+               tailcall = false
+       }
+       if base.Ctxt.Arch.Name == "amd64" && wrapperABI == obj.ABIInternal {
+               // cannot tailcall from ABIInternal to ABI0 on AMD64, as we need
+               // to special registers (X15) when returning to ABIInternal.
+               tailcall = false
+       }
+
+       var tail ir.Node
+       if tailcall {
+               tail = ir.NewTailCallStmt(base.Pos, f.Nname)
+       } else {
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
+               call.Args = ir.ParamNames(tfn.Type())
+               call.IsDDD = tfn.Type().IsVariadic()
+               tail = call
+               if tfn.Type().NumResults() > 0 {
+                       n := ir.NewReturnStmt(base.Pos, nil)
+                       n.Results = []ir.Node{call}
+                       tail = n
+               }
+       }
+       fn.Body.Append(tail)
+
+       typecheck.FinishFuncBody()
+       if base.Debug.DclStack != 0 {
+               types.CheckDclstack()
+       }
+
+       typecheck.Func(fn)
+       ir.CurFunc = fn
+       typecheck.Stmts(fn.Body)
+
+       escape.Batch([]*ir.Func{fn}, false)
+
+       typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+       // Restore previous context.
+       base.Pos = savepos
+       typecheck.DeclContext = savedclcontext
+       ir.CurFunc = savedcurfn
+}
+
+// setupTextLsym initializes the LSym for a with-body text symbol.
+func setupTextLSym(f *ir.Func, flag int) {
+       if f.Dupok() {
+               flag |= obj.DUPOK
+       }
+       if f.Wrapper() {
+               flag |= obj.WRAPPER
+       }
+       if f.Needctxt() {
+               flag |= obj.NEEDCTXT
+       }
+       if f.Pragma&ir.Nosplit != 0 {
+               flag |= obj.NOSPLIT
+       }
+       if f.ReflectMethod() {
+               flag |= obj.REFLECTMETHOD
+       }
+
+       // Clumsy but important.
+       // See test/recover.go for test cases and src/reflect/value.go
+       // for the actual functions being considered.
+       if base.Ctxt.Pkgpath == "reflect" {
+               switch f.Sym().Name {
+               case "callReflect", "callMethod":
+                       flag |= obj.WRAPPER
+               }
+       }
+
+       base.Ctxt.InitTextSym(f.LSym, flag)
+}

diff --git a/src/cmd/compile/internal/ssagen/arch.go b/src/cmd/compile/internal/ssagen/arch.go
new file mode 100644 (file)
index 0000000..cc50ab3
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/arch.go
@@ -0,0 +1,42 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssagen
+
+import (
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/ssa"
+       "cmd/internal/obj"
+)
+
+var Arch ArchInfo
+
+// interface to back end
+
+type ArchInfo struct {
+       LinkArch *obj.LinkArch
+
+       REGSP     int
+       MAXWIDTH  int64
+       SoftFloat bool
+
+       PadFrame func(int64) int64
+
+       // ZeroRange zeroes a range of memory on stack. It is only inserted
+       // at function entry, and it is ok to clobber registers.
+       ZeroRange func(*objw.Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog
+
+       Ginsnop      func(*objw.Progs) *obj.Prog
+       Ginsnopdefer func(*objw.Progs) *obj.Prog // special ginsnop for deferreturn
+
+       // SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
+       SSAMarkMoves func(*State, *ssa.Block)
+
+       // SSAGenValue emits Prog(s) for the Value.
+       SSAGenValue func(*State, *ssa.Value)
+
+       // SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
+       // for all values in the block before SSAGenBlock.
+       SSAGenBlock func(s *State, b, next *ssa.Block)
+}

diff --git a/src/cmd/compile/internal/ssagen/nowb.go b/src/cmd/compile/internal/ssagen/nowb.go
new file mode 100644 (file)
index 0000000..a243436
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -0,0 +1,200 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssagen
+
+import (
+       "bytes"
+       "fmt"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+func EnableNoWriteBarrierRecCheck() {
+       nowritebarrierrecCheck = newNowritebarrierrecChecker()
+}
+
+func NoWriteBarrierRecCheck() {
+       // Write barriers are now known. Check the
+       // call graph.
+       nowritebarrierrecCheck.check()
+       nowritebarrierrecCheck = nil
+}
+
+var nowritebarrierrecCheck *nowritebarrierrecChecker
+
+type nowritebarrierrecChecker struct {
+       // extraCalls contains extra function calls that may not be
+       // visible during later analysis. It maps from the ODCLFUNC of
+       // the caller to a list of callees.
+       extraCalls map[*ir.Func][]nowritebarrierrecCall
+
+       // curfn is the current function during AST walks.
+       curfn *ir.Func
+}
+
+type nowritebarrierrecCall struct {
+       target *ir.Func // caller or callee
+       lineno src.XPos // line of call
+}
+
+// newNowritebarrierrecChecker creates a nowritebarrierrecChecker. It
+// must be called before walk
+func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
+       c := &nowritebarrierrecChecker{
+               extraCalls: make(map[*ir.Func][]nowritebarrierrecCall),
+       }
+
+       // Find all systemstack calls and record their targets. In
+       // general, flow analysis can't see into systemstack, but it's
+       // important to handle it for this check, so we model it
+       // directly. This has to happen before transforming closures in walk since
+       // it's a lot harder to work out the argument after.
+       for _, n := range typecheck.Target.Decls {
+               if n.Op() != ir.ODCLFUNC {
+                       continue
+               }
+               c.curfn = n.(*ir.Func)
+               ir.Visit(n, c.findExtraCalls)
+       }
+       c.curfn = nil
+       return c
+}
+
+func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
+       if nn.Op() != ir.OCALLFUNC {
+               return
+       }
+       n := nn.(*ir.CallExpr)
+       if n.X == nil || n.X.Op() != ir.ONAME {
+               return
+       }
+       fn := n.X.(*ir.Name)
+       if fn.Class != ir.PFUNC || fn.Defn == nil {
+               return
+       }
+       if !types.IsRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
+               return
+       }
+
+       var callee *ir.Func
+       arg := n.Args[0]
+       switch arg.Op() {
+       case ir.ONAME:
+               arg := arg.(*ir.Name)
+               callee = arg.Defn.(*ir.Func)
+       case ir.OCLOSURE:
+               arg := arg.(*ir.ClosureExpr)
+               callee = arg.Func
+       default:
+               base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
+       }
+       if callee.Op() != ir.ODCLFUNC {
+               base.Fatalf("expected ODCLFUNC node, got %+v", callee)
+       }
+       c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos()})
+}
+
+// recordCall records a call from ODCLFUNC node "from", to function
+// symbol "to" at position pos.
+//
+// This should be done as late as possible during compilation to
+// capture precise call graphs. The target of the call is an LSym
+// because that's all we know after we start SSA.
+//
+// This can be called concurrently for different from Nodes.
+func (c *nowritebarrierrecChecker) recordCall(fn *ir.Func, to *obj.LSym, pos src.XPos) {
+       // We record this information on the *Func so this is concurrent-safe.
+       if fn.NWBRCalls == nil {
+               fn.NWBRCalls = new([]ir.SymAndPos)
+       }
+       *fn.NWBRCalls = append(*fn.NWBRCalls, ir.SymAndPos{Sym: to, Pos: pos})
+}
+
+func (c *nowritebarrierrecChecker) check() {
+       // We walk the call graph as late as possible so we can
+       // capture all calls created by lowering, but this means we
+       // only get to see the obj.LSyms of calls. symToFunc lets us
+       // get back to the ODCLFUNCs.
+       symToFunc := make(map[*obj.LSym]*ir.Func)
+       // funcs records the back-edges of the BFS call graph walk. It
+       // maps from the ODCLFUNC of each function that must not have
+       // write barriers to the call that inhibits them. Functions
+       // that are directly marked go:nowritebarrierrec are in this
+       // map with a zero-valued nowritebarrierrecCall. This also
+       // acts as the set of marks for the BFS of the call graph.
+       funcs := make(map[*ir.Func]nowritebarrierrecCall)
+       // q is the queue of ODCLFUNC Nodes to visit in BFS order.
+       var q ir.NameQueue
+
+       for _, n := range typecheck.Target.Decls {
+               if n.Op() != ir.ODCLFUNC {
+                       continue
+               }
+               fn := n.(*ir.Func)
+
+               symToFunc[fn.LSym] = fn
+
+               // Make nowritebarrierrec functions BFS roots.
+               if fn.Pragma&ir.Nowritebarrierrec != 0 {
+                       funcs[fn] = nowritebarrierrecCall{}
+                       q.PushRight(fn.Nname)
+               }
+               // Check go:nowritebarrier functions.
+               if fn.Pragma&ir.Nowritebarrier != 0 && fn.WBPos.IsKnown() {
+                       base.ErrorfAt(fn.WBPos, "write barrier prohibited")
+               }
+       }
+
+       // Perform a BFS of the call graph from all
+       // go:nowritebarrierrec functions.
+       enqueue := func(src, target *ir.Func, pos src.XPos) {
+               if target.Pragma&ir.Yeswritebarrierrec != 0 {
+                       // Don't flow into this function.
+                       return
+               }
+               if _, ok := funcs[target]; ok {
+                       // Already found a path to target.
+                       return
+               }
+
+               // Record the path.
+               funcs[target] = nowritebarrierrecCall{target: src, lineno: pos}
+               q.PushRight(target.Nname)
+       }
+       for !q.Empty() {
+               fn := q.PopLeft().Func
+
+               // Check fn.
+               if fn.WBPos.IsKnown() {
+                       var err bytes.Buffer
+                       call := funcs[fn]
+                       for call.target != nil {
+                               fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Nname)
+                               call = funcs[call.target]
+                       }
+                       base.ErrorfAt(fn.WBPos, "write barrier prohibited by caller; %v%s", fn.Nname, err.String())
+                       continue
+               }
+
+               // Enqueue fn's calls.
+               for _, callee := range c.extraCalls[fn] {
+                       enqueue(fn, callee.target, callee.lineno)
+               }
+               if fn.NWBRCalls == nil {
+                       continue
+               }
+               for _, callee := range *fn.NWBRCalls {
+                       target := symToFunc[callee.Sym]
+                       if target != nil {
+                               enqueue(fn, target, callee.Pos)
+                       }
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
new file mode 100644 (file)
index 0000000..40f07a8
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -0,0 +1,272 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssagen
+
+import (
+       "internal/race"
+       "math/rand"
+       "sort"
+       "sync"
+       "time"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/ssa"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+       "cmd/internal/sys"
+)
+
+// cmpstackvarlt reports whether the stack variable a sorts before b.
+//
+// Sort the list of stack variables. Autos after anything else,
+// within autos, unused after used, within used, things with
+// pointers first, zeroed things first, and then decreasing size.
+// Because autos are laid out in decreasing addresses
+// on the stack, pointers first, zeroed things first and decreasing size
+// really means, in memory, things with pointers needing zeroing at
+// the top of the stack and increasing in size.
+// Non-autos sort on offset.
+func cmpstackvarlt(a, b *ir.Name) bool {
+       if (a.Class == ir.PAUTO) != (b.Class == ir.PAUTO) {
+               return b.Class == ir.PAUTO
+       }
+
+       if a.Class != ir.PAUTO {
+               return a.FrameOffset() < b.FrameOffset()
+       }
+
+       if a.Used() != b.Used() {
+               return a.Used()
+       }
+
+       ap := a.Type().HasPointers()
+       bp := b.Type().HasPointers()
+       if ap != bp {
+               return ap
+       }
+
+       ap = a.Needzero()
+       bp = b.Needzero()
+       if ap != bp {
+               return ap
+       }
+
+       if a.Type().Width != b.Type().Width {
+               return a.Type().Width > b.Type().Width
+       }
+
+       return a.Sym().Name < b.Sym().Name
+}
+
+// byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
+type byStackVar []*ir.Name
+
+func (s byStackVar) Len() int           { return len(s) }
+func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
+func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func (s *ssafn) AllocFrame(f *ssa.Func) {
+       s.stksize = 0
+       s.stkptrsize = 0
+       fn := s.curfn
+
+       // Mark the PAUTO's unused.
+       for _, ln := range fn.Dcl {
+               if ln.Class == ir.PAUTO {
+                       ln.SetUsed(false)
+               }
+       }
+
+       for _, l := range f.RegAlloc {
+               if ls, ok := l.(ssa.LocalSlot); ok {
+                       ls.N.SetUsed(true)
+               }
+       }
+
+       scratchUsed := false
+       for _, b := range f.Blocks {
+               for _, v := range b.Values {
+                       if n, ok := v.Aux.(*ir.Name); ok {
+                               switch n.Class {
+                               case ir.PPARAM, ir.PPARAMOUT:
+                                       // Don't modify RegFP; it is a global.
+                                       if n != ir.RegFP {
+                                               n.SetUsed(true)
+                                       }
+                               case ir.PAUTO:
+                                       n.SetUsed(true)
+                               }
+                       }
+                       if !scratchUsed {
+                               scratchUsed = v.Op.UsesScratch()
+                       }
+
+               }
+       }
+
+       if f.Config.NeedsFpScratch && scratchUsed {
+               s.scratchFpMem = typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
+       }
+
+       sort.Sort(byStackVar(fn.Dcl))
+
+       // Reassign stack offsets of the locals that are used.
+       lastHasPtr := false
+       for i, n := range fn.Dcl {
+               if n.Op() != ir.ONAME || n.Class != ir.PAUTO {
+                       continue
+               }
+               if !n.Used() {
+                       fn.Dcl = fn.Dcl[:i]
+                       break
+               }
+
+               types.CalcSize(n.Type())
+               w := n.Type().Width
+               if w >= types.MaxWidth || w < 0 {
+                       base.Fatalf("bad width")
+               }
+               if w == 0 && lastHasPtr {
+                       // Pad between a pointer-containing object and a zero-sized object.
+                       // This prevents a pointer to the zero-sized object from being interpreted
+                       // as a pointer to the pointer-containing object (and causing it
+                       // to be scanned when it shouldn't be). See issue 24993.
+                       w = 1
+               }
+               s.stksize += w
+               s.stksize = types.Rnd(s.stksize, int64(n.Type().Align))
+               if n.Type().HasPointers() {
+                       s.stkptrsize = s.stksize
+                       lastHasPtr = true
+               } else {
+                       lastHasPtr = false
+               }
+               if Arch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
+                       s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
+               }
+               n.SetFrameOffset(-s.stksize)
+       }
+
+       s.stksize = types.Rnd(s.stksize, int64(types.RegSize))
+       s.stkptrsize = types.Rnd(s.stkptrsize, int64(types.RegSize))
+}
+
+const maxStackSize = 1 << 30
+
+// Compile builds an SSA backend function,
+// uses it to generate a plist,
+// and flushes that plist to machine code.
+// worker indicates which of the backend workers is doing the processing.
+func Compile(fn *ir.Func, worker int) {
+       f := buildssa(fn, worker)
+       // Note: check arg size to fix issue 25507.
+       if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
+               largeStackFramesMu.Lock()
+               largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
+               largeStackFramesMu.Unlock()
+               return
+       }
+       pp := objw.NewProgs(fn, worker)
+       defer pp.Free()
+       genssa(f, pp)
+       // Check frame size again.
+       // The check above included only the space needed for local variables.
+       // After genssa, the space needed includes local variables and the callee arg region.
+       // We must do this check prior to calling pp.Flush.
+       // If there are any oversized stack frames,
+       // the assembler may emit inscrutable complaints about invalid instructions.
+       if pp.Text.To.Offset >= maxStackSize {
+               largeStackFramesMu.Lock()
+               locals := f.Frontend().(*ssafn).stksize
+               largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
+               largeStackFramesMu.Unlock()
+               return
+       }
+
+       pp.Flush() // assemble, fill in boilerplate, etc.
+       // fieldtrack must be called after pp.Flush. See issue 20014.
+       fieldtrack(pp.Text.From.Sym, fn.FieldTrack)
+}
+
+func init() {
+       if race.Enabled {
+               rand.Seed(time.Now().UnixNano())
+       }
+}
+
+// StackOffset returns the stack location of a LocalSlot relative to the
+// stack pointer, suitable for use in a DWARF location entry. This has nothing
+// to do with its offset in the user variable.
+func StackOffset(slot ssa.LocalSlot) int32 {
+       n := slot.N
+       var off int64
+       switch n.Class {
+       case ir.PAUTO:
+               off = n.FrameOffset()
+               if base.Ctxt.FixedFrameSize() == 0 {
+                       off -= int64(types.PtrSize)
+               }
+               if objabi.Framepointer_enabled {
+                       off -= int64(types.PtrSize)
+               }
+       case ir.PPARAM, ir.PPARAMOUT:
+               off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+       }
+       return int32(off + slot.Off)
+}
+
+// fieldtrack adds R_USEFIELD relocations to fnsym to record any
+// struct fields that it used.
+func fieldtrack(fnsym *obj.LSym, tracked map[*obj.LSym]struct{}) {
+       if fnsym == nil {
+               return
+       }
+       if objabi.Fieldtrack_enabled == 0 || len(tracked) == 0 {
+               return
+       }
+
+       trackSyms := make([]*obj.LSym, 0, len(tracked))
+       for sym := range tracked {
+               trackSyms = append(trackSyms, sym)
+       }
+       sort.Slice(trackSyms, func(i, j int) bool { return trackSyms[i].Name < trackSyms[j].Name })
+       for _, sym := range trackSyms {
+               r := obj.Addrel(fnsym)
+               r.Sym = sym
+               r.Type = objabi.R_USEFIELD
+       }
+}
+
+// largeStack is info about a function whose stack frame is too large (rare).
+type largeStack struct {
+       locals int64
+       args   int64
+       callee int64
+       pos    src.XPos
+}
+
+var (
+       largeStackFramesMu sync.Mutex // protects largeStackFrames
+       largeStackFrames   []largeStack
+)
+
+func CheckLargeStacks() {
+       // Check whether any of the functions we have compiled have gigantic stack frames.
+       sort.Slice(largeStackFrames, func(i, j int) bool {
+               return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
+       })
+       for _, large := range largeStackFrames {
+               if large.callee != 0 {
+                       base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
+               } else {
+                       base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/ssagen/pgen_test.go b/src/cmd/compile/internal/ssagen/pgen_test.go
new file mode 100644 (file)
index 0000000..69ed8ad
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/pgen_test.go
@@ -0,0 +1,209 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssagen
+
+import (
+       "reflect"
+       "sort"
+       "testing"
+
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+func typeWithoutPointers() *types.Type {
+       return types.NewStruct(types.NoPkg, []*types.Field{
+               types.NewField(src.NoXPos, nil, types.New(types.TINT)),
+       })
+}
+
+func typeWithPointers() *types.Type {
+       return types.NewStruct(types.NoPkg, []*types.Field{
+               types.NewField(src.NoXPos, nil, types.NewPtr(types.New(types.TINT))),
+       })
+}
+
+func markUsed(n *ir.Name) *ir.Name {
+       n.SetUsed(true)
+       return n
+}
+
+func markNeedZero(n *ir.Name) *ir.Name {
+       n.SetNeedzero(true)
+       return n
+}
+
+// Test all code paths for cmpstackvarlt.
+func TestCmpstackvar(t *testing.T) {
+       nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
+               if s == nil {
+                       s = &types.Sym{Name: "."}
+               }
+               n := typecheck.NewName(s)
+               n.SetType(t)
+               n.SetFrameOffset(xoffset)
+               n.Class = cl
+               return n
+       }
+       testdata := []struct {
+               a, b *ir.Name
+               lt   bool
+       }{
+               {
+                       nod(0, nil, nil, ir.PAUTO),
+                       nod(0, nil, nil, ir.PFUNC),
+                       false,
+               },
+               {
+                       nod(0, nil, nil, ir.PFUNC),
+                       nod(0, nil, nil, ir.PAUTO),
+                       true,
+               },
+               {
+                       nod(0, nil, nil, ir.PFUNC),
+                       nod(10, nil, nil, ir.PFUNC),
+                       true,
+               },
+               {
+                       nod(20, nil, nil, ir.PFUNC),
+                       nod(10, nil, nil, ir.PFUNC),
+                       false,
+               },
+               {
+                       nod(10, nil, nil, ir.PFUNC),
+                       nod(10, nil, nil, ir.PFUNC),
+                       false,
+               },
+               {
+                       nod(10, nil, nil, ir.PPARAM),
+                       nod(20, nil, nil, ir.PPARAMOUT),
+                       true,
+               },
+               {
+                       nod(10, nil, nil, ir.PPARAMOUT),
+                       nod(20, nil, nil, ir.PPARAM),
+                       true,
+               },
+               {
+                       markUsed(nod(0, nil, nil, ir.PAUTO)),
+                       nod(0, nil, nil, ir.PAUTO),
+                       true,
+               },
+               {
+                       nod(0, nil, nil, ir.PAUTO),
+                       markUsed(nod(0, nil, nil, ir.PAUTO)),
+                       false,
+               },
+               {
+                       nod(0, typeWithoutPointers(), nil, ir.PAUTO),
+                       nod(0, typeWithPointers(), nil, ir.PAUTO),
+                       false,
+               },
+               {
+                       nod(0, typeWithPointers(), nil, ir.PAUTO),
+                       nod(0, typeWithoutPointers(), nil, ir.PAUTO),
+                       true,
+               },
+               {
+                       markNeedZero(nod(0, &types.Type{}, nil, ir.PAUTO)),
+                       nod(0, &types.Type{}, nil, ir.PAUTO),
+                       true,
+               },
+               {
+                       nod(0, &types.Type{}, nil, ir.PAUTO),
+                       markNeedZero(nod(0, &types.Type{}, nil, ir.PAUTO)),
+                       false,
+               },
+               {
+                       nod(0, &types.Type{Width: 1}, nil, ir.PAUTO),
+                       nod(0, &types.Type{Width: 2}, nil, ir.PAUTO),
+                       false,
+               },
+               {
+                       nod(0, &types.Type{Width: 2}, nil, ir.PAUTO),
+                       nod(0, &types.Type{Width: 1}, nil, ir.PAUTO),
+                       true,
+               },
+               {
+                       nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+                       nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+                       true,
+               },
+               {
+                       nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+                       nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+                       false,
+               },
+               {
+                       nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+                       nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+                       false,
+               },
+       }
+       for _, d := range testdata {
+               got := cmpstackvarlt(d.a, d.b)
+               if got != d.lt {
+                       t.Errorf("want %v < %v", d.a, d.b)
+               }
+               // If we expect a < b to be true, check that b < a is false.
+               if d.lt && cmpstackvarlt(d.b, d.a) {
+                       t.Errorf("unexpected %v < %v", d.b, d.a)
+               }
+       }
+}
+
+func TestStackvarSort(t *testing.T) {
+       nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
+               n := typecheck.NewName(s)
+               n.SetType(t)
+               n.SetFrameOffset(xoffset)
+               n.Class = cl
+               return n
+       }
+       inp := []*ir.Name{
+               nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(20, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               markUsed(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+               nod(0, typeWithoutPointers(), &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+               markNeedZero(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+               nod(0, &types.Type{Width: 1}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{Width: 2}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+       }
+       want := []*ir.Name{
+               nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               nod(20, &types.Type{}, &types.Sym{}, ir.PFUNC),
+               markUsed(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+               markNeedZero(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+               nod(0, &types.Type{Width: 2}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{Width: 1}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+               nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+               nod(0, typeWithoutPointers(), &types.Sym{}, ir.PAUTO),
+       }
+       sort.Sort(byStackVar(inp))
+       if !reflect.DeepEqual(want, inp) {
+               t.Error("sort failed")
+               for i := range inp {
+                       g := inp[i]
+                       w := want[i]
+                       eq := reflect.DeepEqual(w, g)
+                       if !eq {
+                               t.Log(i, w, g)
+                       }
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/ssagen/phi.go
similarity index 90%
rename from src/cmd/compile/internal/gc/phi.go
rename to src/cmd/compile/internal/ssagen/phi.go
index 5218cd0ef3d1443ffa44219426a7670c5711c134..01ad211282cf3436310e49a325ec8586f8147351 100644 (file)
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/ssagen/phi.go
@@ -2,14 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
+       "container/heap"
+       "fmt"
+
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/ssa"
        "cmd/compile/internal/types"
        "cmd/internal/src"
-       "container/heap"
-       "fmt"
 )
 
 // This file contains the algorithm to place phi nodes in a function.
@@ -22,6 +24,14 @@ const smallBlocks = 500
 
 const debugPhi = false
 
+// fwdRefAux wraps an arbitrary ir.Node as an ssa.Aux for use with OpFwdref.
+type fwdRefAux struct {
+       _ [0]func() // ensure ir.Node isn't compared for equality
+       N ir.Node
+}
+
+func (fwdRefAux) CanBeAnSSAAux() {}
+
 // insertPhis finds all the places in the function where a phi is
 // necessary and inserts them.
 // Uses FwdRef ops to find all uses of variables, and s.defvars to find
@@ -40,11 +50,11 @@ func (s *state) insertPhis() {
 }
 
 type phiState struct {
-       s       *state                 // SSA state
-       f       *ssa.Func              // function to work on
-       defvars []map[*Node]*ssa.Value // defined variables at end of each block
+       s       *state                   // SSA state
+       f       *ssa.Func                // function to work on
+       defvars []map[ir.Node]*ssa.Value // defined variables at end of each block
 
-       varnum map[*Node]int32 // variable numbering
+       varnum map[ir.Node]int32 // variable numbering
 
        // properties of the dominator tree
        idom  []*ssa.Block // dominator parents
@@ -59,7 +69,7 @@ type phiState struct {
        hasDef *sparseSet   // has a write of the variable we're processing
 
        // miscellaneous
-       placeholder *ssa.Value // dummy value to use as a "not set yet" placeholder.
+       placeholder *ssa.Value // value to use as a "not set yet" placeholder.
 }
 
 func (s *phiState) insertPhis() {
@@ -70,15 +80,15 @@ func (s *phiState) insertPhis() {
        // Find all the variables for which we need to match up reads & writes.
        // This step prunes any basic-block-only variables from consideration.
        // Generate a numbering for these variables.
-       s.varnum = map[*Node]int32{}
-       var vars []*Node
+       s.varnum = map[ir.Node]int32{}
+       var vars []ir.Node
        var vartypes []*types.Type
        for _, b := range s.f.Blocks {
                for _, v := range b.Values {
                        if v.Op != ssa.OpFwdRef {
                                continue
                        }
-                       var_ := v.Aux.(*Node)
+                       var_ := v.Aux.(fwdRefAux).N
 
                        // Optimization: look back 1 block for the definition.
                        if len(b.Preds) == 1 {
@@ -179,11 +189,16 @@ levels:
                        if v.Op == ssa.OpPhi {
                                v.AuxInt = 0
                        }
+                       // Any remaining FwdRefs are dead code.
+                       if v.Op == ssa.OpFwdRef {
+                               v.Op = ssa.OpUnknown
+                               v.Aux = nil
+                       }
                }
        }
 }
 
-func (s *phiState) insertVarPhis(n int, var_ *Node, defs []*ssa.Block, typ *types.Type) {
+func (s *phiState) insertVarPhis(n int, var_ ir.Node, defs []*ssa.Block, typ *types.Type) {
        priq := &s.priq
        q := s.q
        queued := s.queued
@@ -240,7 +255,9 @@ func (s *phiState) insertVarPhis(n int, var_ *Node, defs []*ssa.Block, typ *type
                                hasPhi.add(c.ID)
                                v := c.NewValue0I(currentRoot.Pos, ssa.OpPhi, typ, int64(n)) // TODO: line number right?
                                // Note: we store the variable number in the phi's AuxInt field. Used temporarily by phi building.
-                               s.s.addNamedValue(var_, v)
+                               if var_.Op() == ir.ONAME {
+                                       s.s.addNamedValue(var_.(*ir.Name), v)
+                               }
                                for range c.Preds {
                                        v.AddArg(s.placeholder) // Actual args will be filled in by resolveFwdRefs.
                                }
@@ -318,7 +335,7 @@ func (s *phiState) resolveFwdRefs() {
                        if v.Op != ssa.OpFwdRef {
                                continue
                        }
-                       n := s.varnum[v.Aux.(*Node)]
+                       n := s.varnum[v.Aux.(fwdRefAux).N]
                        v.Op = ssa.OpCopy
                        v.Aux = nil
                        v.AddArg(values[n])
@@ -432,11 +449,11 @@ func (s *sparseSet) clear() {
 
 // Variant to use for small functions.
 type simplePhiState struct {
-       s         *state                 // SSA state
-       f         *ssa.Func              // function to work on
-       fwdrefs   []*ssa.Value           // list of FwdRefs to be processed
-       defvars   []map[*Node]*ssa.Value // defined variables at end of each block
-       reachable []bool                 // which blocks are reachable
+       s         *state                   // SSA state
+       f         *ssa.Func                // function to work on
+       fwdrefs   []*ssa.Value             // list of FwdRefs to be processed
+       defvars   []map[ir.Node]*ssa.Value // defined variables at end of each block
+       reachable []bool                   // which blocks are reachable
 }
 
 func (s *simplePhiState) insertPhis() {
@@ -449,7 +466,7 @@ func (s *simplePhiState) insertPhis() {
                                continue
                        }
                        s.fwdrefs = append(s.fwdrefs, v)
-                       var_ := v.Aux.(*Node)
+                       var_ := v.Aux.(fwdRefAux).N
                        if _, ok := s.defvars[b.ID][var_]; !ok {
                                s.defvars[b.ID][var_] = v // treat FwdDefs as definitions.
                        }
@@ -463,7 +480,7 @@ loop:
                v := s.fwdrefs[len(s.fwdrefs)-1]
                s.fwdrefs = s.fwdrefs[:len(s.fwdrefs)-1]
                b := v.Block
-               var_ := v.Aux.(*Node)
+               var_ := v.Aux.(fwdRefAux).N
                if b == s.f.Entry {
                        // No variable should be live at entry.
                        s.s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, var_, v)
@@ -511,7 +528,7 @@ loop:
 }
 
 // lookupVarOutgoing finds the variable's value at the end of block b.
-func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ *Node, line src.XPos) *ssa.Value {
+func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ ir.Node, line src.XPos) *ssa.Value {
        for {
                if v := s.defvars[b.ID][var_]; v != nil {
                        return v
@@ -530,9 +547,11 @@ func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ *No
                }
        }
        // Generate a FwdRef for the variable and return that.
-       v := b.NewValue0A(line, ssa.OpFwdRef, t, var_)
+       v := b.NewValue0A(line, ssa.OpFwdRef, t, fwdRefAux{N: var_})
        s.defvars[b.ID][var_] = v
-       s.s.addNamedValue(var_, v)
+       if var_.Op() == ir.ONAME {
+               s.s.addNamedValue(var_.(*ir.Name), v)
+       }
        s.fwdrefs = append(s.fwdrefs, v)
        return v
 }

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
similarity index 56%
rename from src/cmd/compile/internal/gc/ssa.go
rename to src/cmd/compile/internal/ssagen/ssa.go
index 5b74754b53291211f486cca9d28017ed1ce60f23..6b1ddebd32aae2f33a9c52ea2d0039543c2499c5 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2,19 +2,28 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
+       "bufio"
+       "bytes"
        "encoding/binary"
        "fmt"
+       "go/constant"
        "html"
        "os"
        "path/filepath"
        "sort"
+       "strings"
 
-       "bufio"
-       "bytes"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/liveness"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/reflectdata"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/typecheck"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/x86"
@@ -32,165 +41,181 @@ var ssaDumpStdout bool // whether to dump to stdout
 var ssaDumpCFG string  // generate CFGs for these phases
 const ssaDumpFile = "ssa.html"
 
-// The max number of defers in a function using open-coded defers. We enforce this
-// limit because the deferBits bitmask is currently a single byte (to minimize code size)
-const maxOpenDefers = 8
-
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
-var ssaDumpInlined []*Node
+var ssaDumpInlined []*ir.Func
+
+func DumpInline(fn *ir.Func) {
+       if ssaDump != "" && ssaDump == ir.FuncName(fn) {
+               ssaDumpInlined = append(ssaDumpInlined, fn)
+       }
+}
+
+func InitEnv() {
+       ssaDump = os.Getenv("GOSSAFUNC")
+       ssaDir = os.Getenv("GOSSADIR")
+       if ssaDump != "" {
+               if strings.HasSuffix(ssaDump, "+") {
+                       ssaDump = ssaDump[:len(ssaDump)-1]
+                       ssaDumpStdout = true
+               }
+               spl := strings.Split(ssaDump, ":")
+               if len(spl) > 1 {
+                       ssaDump = spl[0]
+                       ssaDumpCFG = spl[1]
+               }
+       }
+}
 
-func initssaconfig() {
+func InitConfig() {
        types_ := ssa.NewTypes()
 
-       if thearch.SoftFloat {
+       if Arch.SoftFloat {
                softfloatInit()
        }
 
        // Generate a few pointer types that are uncommon in the frontend but common in the backend.
        // Caching is disabled in the backend, so generating these here avoids allocations.
-       _ = types.NewPtr(types.Types[TINTER])                             // *interface{}
-       _ = types.NewPtr(types.NewPtr(types.Types[TSTRING]))              // **string
-       _ = types.NewPtr(types.NewSlice(types.Types[TINTER]))             // *[]interface{}
-       _ = types.NewPtr(types.NewPtr(types.Bytetype))                    // **byte
-       _ = types.NewPtr(types.NewSlice(types.Bytetype))                  // *[]byte
-       _ = types.NewPtr(types.NewSlice(types.Types[TSTRING]))            // *[]string
-       _ = types.NewPtr(types.NewPtr(types.NewPtr(types.Types[TUINT8]))) // ***uint8
-       _ = types.NewPtr(types.Types[TINT16])                             // *int16
-       _ = types.NewPtr(types.Types[TINT64])                             // *int64
-       _ = types.NewPtr(types.Errortype)                                 // *error
+       _ = types.NewPtr(types.Types[types.TINTER])                             // *interface{}
+       _ = types.NewPtr(types.NewPtr(types.Types[types.TSTRING]))              // **string
+       _ = types.NewPtr(types.NewSlice(types.Types[types.TINTER]))             // *[]interface{}
+       _ = types.NewPtr(types.NewPtr(types.ByteType))                          // **byte
+       _ = types.NewPtr(types.NewSlice(types.ByteType))                        // *[]byte
+       _ = types.NewPtr(types.NewSlice(types.Types[types.TSTRING]))            // *[]string
+       _ = types.NewPtr(types.NewPtr(types.NewPtr(types.Types[types.TUINT8]))) // ***uint8
+       _ = types.NewPtr(types.Types[types.TINT16])                             // *int16
+       _ = types.NewPtr(types.Types[types.TINT64])                             // *int64
+       _ = types.NewPtr(types.ErrorType)                                       // *error
        types.NewPtrCacheEnabled = false
-       ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, Ctxt, Debug.N == 0)
-       ssaConfig.SoftFloat = thearch.SoftFloat
-       ssaConfig.Race = flag_race
-       ssaCaches = make([]ssa.Cache, nBackendWorkers)
+       ssaConfig = ssa.NewConfig(base.Ctxt.Arch.Name, *types_, base.Ctxt, base.Flag.N == 0)
+       ssaConfig.SoftFloat = Arch.SoftFloat
+       ssaConfig.Race = base.Flag.Race
+       ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
 
        // Set up some runtime functions we'll need to call.
-       assertE2I = sysfunc("assertE2I")
-       assertE2I2 = sysfunc("assertE2I2")
-       assertI2I = sysfunc("assertI2I")
-       assertI2I2 = sysfunc("assertI2I2")
-       deferproc = sysfunc("deferproc")
-       deferprocStack = sysfunc("deferprocStack")
-       Deferreturn = sysfunc("deferreturn")
-       Duffcopy = sysfunc("duffcopy")
-       Duffzero = sysfunc("duffzero")
-       gcWriteBarrier = sysfunc("gcWriteBarrier")
-       goschedguarded = sysfunc("goschedguarded")
-       growslice = sysfunc("growslice")
-       msanread = sysfunc("msanread")
-       msanwrite = sysfunc("msanwrite")
-       msanmove = sysfunc("msanmove")
-       newobject = sysfunc("newobject")
-       newproc = sysfunc("newproc")
-       panicdivide = sysfunc("panicdivide")
-       panicdottypeE = sysfunc("panicdottypeE")
-       panicdottypeI = sysfunc("panicdottypeI")
-       panicnildottype = sysfunc("panicnildottype")
-       panicoverflow = sysfunc("panicoverflow")
-       panicshift = sysfunc("panicshift")
-       raceread = sysfunc("raceread")
-       racereadrange = sysfunc("racereadrange")
-       racewrite = sysfunc("racewrite")
-       racewriterange = sysfunc("racewriterange")
-       x86HasPOPCNT = sysvar("x86HasPOPCNT")       // bool
-       x86HasSSE41 = sysvar("x86HasSSE41")         // bool
-       x86HasFMA = sysvar("x86HasFMA")             // bool
-       armHasVFPv4 = sysvar("armHasVFPv4")         // bool
-       arm64HasATOMICS = sysvar("arm64HasATOMICS") // bool
-       typedmemclr = sysfunc("typedmemclr")
-       typedmemmove = sysfunc("typedmemmove")
-       Udiv = sysvar("udiv")                 // asm func with special ABI
-       writeBarrier = sysvar("writeBarrier") // struct { bool; ... }
-       zerobaseSym = sysvar("zerobase")
+       ir.Syms.AssertE2I = typecheck.LookupRuntimeFunc("assertE2I")
+       ir.Syms.AssertE2I2 = typecheck.LookupRuntimeFunc("assertE2I2")
+       ir.Syms.AssertI2I = typecheck.LookupRuntimeFunc("assertI2I")
+       ir.Syms.AssertI2I2 = typecheck.LookupRuntimeFunc("assertI2I2")
+       ir.Syms.Deferproc = typecheck.LookupRuntimeFunc("deferproc")
+       ir.Syms.DeferprocStack = typecheck.LookupRuntimeFunc("deferprocStack")
+       ir.Syms.Deferreturn = typecheck.LookupRuntimeFunc("deferreturn")
+       ir.Syms.Duffcopy = typecheck.LookupRuntimeFunc("duffcopy")
+       ir.Syms.Duffzero = typecheck.LookupRuntimeFunc("duffzero")
+       ir.Syms.GCWriteBarrier = typecheck.LookupRuntimeFunc("gcWriteBarrier")
+       ir.Syms.Goschedguarded = typecheck.LookupRuntimeFunc("goschedguarded")
+       ir.Syms.Growslice = typecheck.LookupRuntimeFunc("growslice")
+       ir.Syms.Msanread = typecheck.LookupRuntimeFunc("msanread")
+       ir.Syms.Msanwrite = typecheck.LookupRuntimeFunc("msanwrite")
+       ir.Syms.Msanmove = typecheck.LookupRuntimeFunc("msanmove")
+       ir.Syms.Newobject = typecheck.LookupRuntimeFunc("newobject")
+       ir.Syms.Newproc = typecheck.LookupRuntimeFunc("newproc")
+       ir.Syms.Panicdivide = typecheck.LookupRuntimeFunc("panicdivide")
+       ir.Syms.PanicdottypeE = typecheck.LookupRuntimeFunc("panicdottypeE")
+       ir.Syms.PanicdottypeI = typecheck.LookupRuntimeFunc("panicdottypeI")
+       ir.Syms.Panicnildottype = typecheck.LookupRuntimeFunc("panicnildottype")
+       ir.Syms.Panicoverflow = typecheck.LookupRuntimeFunc("panicoverflow")
+       ir.Syms.Panicshift = typecheck.LookupRuntimeFunc("panicshift")
+       ir.Syms.Raceread = typecheck.LookupRuntimeFunc("raceread")
+       ir.Syms.Racereadrange = typecheck.LookupRuntimeFunc("racereadrange")
+       ir.Syms.Racewrite = typecheck.LookupRuntimeFunc("racewrite")
+       ir.Syms.Racewriterange = typecheck.LookupRuntimeFunc("racewriterange")
+       ir.Syms.X86HasPOPCNT = typecheck.LookupRuntimeVar("x86HasPOPCNT")       // bool
+       ir.Syms.X86HasSSE41 = typecheck.LookupRuntimeVar("x86HasSSE41")         // bool
+       ir.Syms.X86HasFMA = typecheck.LookupRuntimeVar("x86HasFMA")             // bool
+       ir.Syms.ARMHasVFPv4 = typecheck.LookupRuntimeVar("armHasVFPv4")         // bool
+       ir.Syms.ARM64HasATOMICS = typecheck.LookupRuntimeVar("arm64HasATOMICS") // bool
+       ir.Syms.Staticuint64s = typecheck.LookupRuntimeVar("staticuint64s")
+       ir.Syms.Typedmemclr = typecheck.LookupRuntimeFunc("typedmemclr")
+       ir.Syms.Typedmemmove = typecheck.LookupRuntimeFunc("typedmemmove")
+       ir.Syms.Udiv = typecheck.LookupRuntimeVar("udiv")                 // asm func with special ABI
+       ir.Syms.WriteBarrier = typecheck.LookupRuntimeVar("writeBarrier") // struct { bool; ... }
+       ir.Syms.Zerobase = typecheck.LookupRuntimeVar("zerobase")
 
        // asm funcs with special ABI
-       if thearch.LinkArch.Name == "amd64" {
+       if base.Ctxt.Arch.Name == "amd64" {
                GCWriteBarrierReg = map[int16]*obj.LSym{
-                       x86.REG_AX: sysfunc("gcWriteBarrier"),
-                       x86.REG_CX: sysfunc("gcWriteBarrierCX"),
-                       x86.REG_DX: sysfunc("gcWriteBarrierDX"),
-                       x86.REG_BX: sysfunc("gcWriteBarrierBX"),
-                       x86.REG_BP: sysfunc("gcWriteBarrierBP"),
-                       x86.REG_SI: sysfunc("gcWriteBarrierSI"),
-                       x86.REG_R8: sysfunc("gcWriteBarrierR8"),
-                       x86.REG_R9: sysfunc("gcWriteBarrierR9"),
-               }
-       }
-
-       if thearch.LinkArch.Family == sys.Wasm {
-               BoundsCheckFunc[ssa.BoundsIndex] = sysfunc("goPanicIndex")
-               BoundsCheckFunc[ssa.BoundsIndexU] = sysfunc("goPanicIndexU")
-               BoundsCheckFunc[ssa.BoundsSliceAlen] = sysfunc("goPanicSliceAlen")
-               BoundsCheckFunc[ssa.BoundsSliceAlenU] = sysfunc("goPanicSliceAlenU")
-               BoundsCheckFunc[ssa.BoundsSliceAcap] = sysfunc("goPanicSliceAcap")
-               BoundsCheckFunc[ssa.BoundsSliceAcapU] = sysfunc("goPanicSliceAcapU")
-               BoundsCheckFunc[ssa.BoundsSliceB] = sysfunc("goPanicSliceB")
-               BoundsCheckFunc[ssa.BoundsSliceBU] = sysfunc("goPanicSliceBU")
-               BoundsCheckFunc[ssa.BoundsSlice3Alen] = sysfunc("goPanicSlice3Alen")
-               BoundsCheckFunc[ssa.BoundsSlice3AlenU] = sysfunc("goPanicSlice3AlenU")
-               BoundsCheckFunc[ssa.BoundsSlice3Acap] = sysfunc("goPanicSlice3Acap")
-               BoundsCheckFunc[ssa.BoundsSlice3AcapU] = sysfunc("goPanicSlice3AcapU")
-               BoundsCheckFunc[ssa.BoundsSlice3B] = sysfunc("goPanicSlice3B")
-               BoundsCheckFunc[ssa.BoundsSlice3BU] = sysfunc("goPanicSlice3BU")
-               BoundsCheckFunc[ssa.BoundsSlice3C] = sysfunc("goPanicSlice3C")
-               BoundsCheckFunc[ssa.BoundsSlice3CU] = sysfunc("goPanicSlice3CU")
+                       x86.REG_AX: typecheck.LookupRuntimeFunc("gcWriteBarrier"),
+                       x86.REG_CX: typecheck.LookupRuntimeFunc("gcWriteBarrierCX"),
+                       x86.REG_DX: typecheck.LookupRuntimeFunc("gcWriteBarrierDX"),
+                       x86.REG_BX: typecheck.LookupRuntimeFunc("gcWriteBarrierBX"),
+                       x86.REG_BP: typecheck.LookupRuntimeFunc("gcWriteBarrierBP"),
+                       x86.REG_SI: typecheck.LookupRuntimeFunc("gcWriteBarrierSI"),
+                       x86.REG_R8: typecheck.LookupRuntimeFunc("gcWriteBarrierR8"),
+                       x86.REG_R9: typecheck.LookupRuntimeFunc("gcWriteBarrierR9"),
+               }
+       }
+
+       if Arch.LinkArch.Family == sys.Wasm {
+               BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("goPanicIndex")
+               BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("goPanicIndexU")
+               BoundsCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeFunc("goPanicSliceAlen")
+               BoundsCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeFunc("goPanicSliceAlenU")
+               BoundsCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeFunc("goPanicSliceAcap")
+               BoundsCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeFunc("goPanicSliceAcapU")
+               BoundsCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeFunc("goPanicSliceB")
+               BoundsCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeFunc("goPanicSliceBU")
+               BoundsCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeFunc("goPanicSlice3Alen")
+               BoundsCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeFunc("goPanicSlice3AlenU")
+               BoundsCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeFunc("goPanicSlice3Acap")
+               BoundsCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeFunc("goPanicSlice3AcapU")
+               BoundsCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeFunc("goPanicSlice3B")
+               BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("goPanicSlice3BU")
+               BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("goPanicSlice3C")
+               BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("goPanicSlice3CU")
        } else {
-               BoundsCheckFunc[ssa.BoundsIndex] = sysfunc("panicIndex")
-               BoundsCheckFunc[ssa.BoundsIndexU] = sysfunc("panicIndexU")
-               BoundsCheckFunc[ssa.BoundsSliceAlen] = sysfunc("panicSliceAlen")
-               BoundsCheckFunc[ssa.BoundsSliceAlenU] = sysfunc("panicSliceAlenU")
-               BoundsCheckFunc[ssa.BoundsSliceAcap] = sysfunc("panicSliceAcap")
-               BoundsCheckFunc[ssa.BoundsSliceAcapU] = sysfunc("panicSliceAcapU")
-               BoundsCheckFunc[ssa.BoundsSliceB] = sysfunc("panicSliceB")
-               BoundsCheckFunc[ssa.BoundsSliceBU] = sysfunc("panicSliceBU")
-               BoundsCheckFunc[ssa.BoundsSlice3Alen] = sysfunc("panicSlice3Alen")
-               BoundsCheckFunc[ssa.BoundsSlice3AlenU] = sysfunc("panicSlice3AlenU")
-               BoundsCheckFunc[ssa.BoundsSlice3Acap] = sysfunc("panicSlice3Acap")
-               BoundsCheckFunc[ssa.BoundsSlice3AcapU] = sysfunc("panicSlice3AcapU")
-               BoundsCheckFunc[ssa.BoundsSlice3B] = sysfunc("panicSlice3B")
-               BoundsCheckFunc[ssa.BoundsSlice3BU] = sysfunc("panicSlice3BU")
-               BoundsCheckFunc[ssa.BoundsSlice3C] = sysfunc("panicSlice3C")
-               BoundsCheckFunc[ssa.BoundsSlice3CU] = sysfunc("panicSlice3CU")
-       }
-       if thearch.LinkArch.PtrSize == 4 {
-               ExtendCheckFunc[ssa.BoundsIndex] = sysvar("panicExtendIndex")
-               ExtendCheckFunc[ssa.BoundsIndexU] = sysvar("panicExtendIndexU")
-               ExtendCheckFunc[ssa.BoundsSliceAlen] = sysvar("panicExtendSliceAlen")
-               ExtendCheckFunc[ssa.BoundsSliceAlenU] = sysvar("panicExtendSliceAlenU")
-               ExtendCheckFunc[ssa.BoundsSliceAcap] = sysvar("panicExtendSliceAcap")
-               ExtendCheckFunc[ssa.BoundsSliceAcapU] = sysvar("panicExtendSliceAcapU")
-               ExtendCheckFunc[ssa.BoundsSliceB] = sysvar("panicExtendSliceB")
-               ExtendCheckFunc[ssa.BoundsSliceBU] = sysvar("panicExtendSliceBU")
-               ExtendCheckFunc[ssa.BoundsSlice3Alen] = sysvar("panicExtendSlice3Alen")
-               ExtendCheckFunc[ssa.BoundsSlice3AlenU] = sysvar("panicExtendSlice3AlenU")
-               ExtendCheckFunc[ssa.BoundsSlice3Acap] = sysvar("panicExtendSlice3Acap")
-               ExtendCheckFunc[ssa.BoundsSlice3AcapU] = sysvar("panicExtendSlice3AcapU")
-               ExtendCheckFunc[ssa.BoundsSlice3B] = sysvar("panicExtendSlice3B")
-               ExtendCheckFunc[ssa.BoundsSlice3BU] = sysvar("panicExtendSlice3BU")
-               ExtendCheckFunc[ssa.BoundsSlice3C] = sysvar("panicExtendSlice3C")
-               ExtendCheckFunc[ssa.BoundsSlice3CU] = sysvar("panicExtendSlice3CU")
+               BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("panicIndex")
+               BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("panicIndexU")
+               BoundsCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeFunc("panicSliceAlen")
+               BoundsCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeFunc("panicSliceAlenU")
+               BoundsCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeFunc("panicSliceAcap")
+               BoundsCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeFunc("panicSliceAcapU")
+               BoundsCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeFunc("panicSliceB")
+               BoundsCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeFunc("panicSliceBU")
+               BoundsCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeFunc("panicSlice3Alen")
+               BoundsCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeFunc("panicSlice3AlenU")
+               BoundsCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeFunc("panicSlice3Acap")
+               BoundsCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeFunc("panicSlice3AcapU")
+               BoundsCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeFunc("panicSlice3B")
+               BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("panicSlice3BU")
+               BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("panicSlice3C")
+               BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("panicSlice3CU")
+       }
+       if Arch.LinkArch.PtrSize == 4 {
+               ExtendCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeVar("panicExtendIndex")
+               ExtendCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeVar("panicExtendIndexU")
+               ExtendCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeVar("panicExtendSliceAlen")
+               ExtendCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeVar("panicExtendSliceAlenU")
+               ExtendCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeVar("panicExtendSliceAcap")
+               ExtendCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeVar("panicExtendSliceAcapU")
+               ExtendCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeVar("panicExtendSliceB")
+               ExtendCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeVar("panicExtendSliceBU")
+               ExtendCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeVar("panicExtendSlice3Alen")
+               ExtendCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeVar("panicExtendSlice3AlenU")
+               ExtendCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeVar("panicExtendSlice3Acap")
+               ExtendCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeVar("panicExtendSlice3AcapU")
+               ExtendCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeVar("panicExtendSlice3B")
+               ExtendCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeVar("panicExtendSlice3BU")
+               ExtendCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeVar("panicExtendSlice3C")
+               ExtendCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeVar("panicExtendSlice3CU")
        }
 
        // Wasm (all asm funcs with special ABIs)
-       WasmMove = sysvar("wasmMove")
-       WasmZero = sysvar("wasmZero")
-       WasmDiv = sysvar("wasmDiv")
-       WasmTruncS = sysvar("wasmTruncS")
-       WasmTruncU = sysvar("wasmTruncU")
-       SigPanic = sysfunc("sigpanic")
+       ir.Syms.WasmMove = typecheck.LookupRuntimeVar("wasmMove")
+       ir.Syms.WasmZero = typecheck.LookupRuntimeVar("wasmZero")
+       ir.Syms.WasmDiv = typecheck.LookupRuntimeVar("wasmDiv")
+       ir.Syms.WasmTruncS = typecheck.LookupRuntimeVar("wasmTruncS")
+       ir.Syms.WasmTruncU = typecheck.LookupRuntimeVar("wasmTruncU")
+       ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
-func getParam(n *Node, i int) *types.Field {
-       t := n.Left.Type
-       if n.Op == OCALLMETH {
-               if i == 0 {
-                       return t.Recv()
-               }
-               return t.Params().Field(i - 1)
+func getParam(n *ir.CallExpr, i int) *types.Field {
+       t := n.X.Type()
+       if n.Op() == ir.OCALLMETH {
+               base.Fatalf("OCALLMETH missed by walkCall")
        }
        return t.Params().Field(i)
 }
@@ -201,22 +226,22 @@ func dvarint(x *obj.LSym, off int, v int64) int {
                panic(fmt.Sprintf("dvarint: bad offset for funcdata - %v", v))
        }
        if v < 1<<7 {
-               return duint8(x, off, uint8(v))
+               return objw.Uint8(x, off, uint8(v))
        }
-       off = duint8(x, off, uint8((v&127)|128))
+       off = objw.Uint8(x, off, uint8((v&127)|128))
        if v < 1<<14 {
-               return duint8(x, off, uint8(v>>7))
+               return objw.Uint8(x, off, uint8(v>>7))
        }
-       off = duint8(x, off, uint8(((v>>7)&127)|128))
+       off = objw.Uint8(x, off, uint8(((v>>7)&127)|128))
        if v < 1<<21 {
-               return duint8(x, off, uint8(v>>14))
+               return objw.Uint8(x, off, uint8(v>>14))
        }
-       off = duint8(x, off, uint8(((v>>14)&127)|128))
+       off = objw.Uint8(x, off, uint8(((v>>14)&127)|128))
        if v < 1<<28 {
-               return duint8(x, off, uint8(v>>21))
+               return objw.Uint8(x, off, uint8(v>>21))
        }
-       off = duint8(x, off, uint8(((v>>21)&127)|128))
-       return duint8(x, off, uint8(v>>28))
+       off = objw.Uint8(x, off, uint8(((v>>21)&127)|128))
+       return objw.Uint8(x, off, uint8(v>>28))
 }
 
 // emitOpenDeferInfo emits FUNCDATA information about the defers in a function
@@ -240,8 +265,8 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 //      - Size of the argument
 //      - Offset of where argument should be placed in the args frame when making call
 func (s *state) emitOpenDeferInfo() {
-       x := Ctxt.Lookup(s.curfn.Func.lsym.Name + ".opendefer")
-       s.curfn.Func.lsym.Func().OpenCodedDeferInfo = x
+       x := base.Ctxt.Lookup(s.curfn.LSym.Name + ".opendefer")
+       s.curfn.LSym.Func().OpenCodedDeferInfo = x
        off := 0
 
        // Compute maxargsize (max size of arguments for all defers)
@@ -249,20 +274,20 @@ func (s *state) emitOpenDeferInfo() {
        var maxargsize int64
        for i := len(s.openDefers) - 1; i >= 0; i-- {
                r := s.openDefers[i]
-               argsize := r.n.Left.Type.ArgWidth()
+               argsize := r.n.X.Type().ArgWidth()
                if argsize > maxargsize {
                        maxargsize = argsize
                }
        }
        off = dvarint(x, off, maxargsize)
-       off = dvarint(x, off, -s.deferBitsTemp.Xoffset)
+       off = dvarint(x, off, -s.deferBitsTemp.FrameOffset())
        off = dvarint(x, off, int64(len(s.openDefers)))
 
        // Write in reverse-order, for ease of running in that order at runtime
        for i := len(s.openDefers) - 1; i >= 0; i-- {
                r := s.openDefers[i]
-               off = dvarint(x, off, r.n.Left.Type.ArgWidth())
-               off = dvarint(x, off, -r.closureNode.Xoffset)
+               off = dvarint(x, off, r.n.X.Type().ArgWidth())
+               off = dvarint(x, off, -r.closureNode.FrameOffset())
                numArgs := len(r.argNodes)
                if r.rcvrNode != nil {
                        // If there's an interface receiver, treat/place it as the first
@@ -272,13 +297,13 @@ func (s *state) emitOpenDeferInfo() {
                }
                off = dvarint(x, off, int64(numArgs))
                if r.rcvrNode != nil {
-                       off = dvarint(x, off, -r.rcvrNode.Xoffset)
+                       off = dvarint(x, off, -r.rcvrNode.FrameOffset())
                        off = dvarint(x, off, s.config.PtrSize)
                        off = dvarint(x, off, 0)
                }
                for j, arg := range r.argNodes {
                        f := getParam(r.n, j)
-                       off = dvarint(x, off, -arg.Xoffset)
+                       off = dvarint(x, off, -arg.FrameOffset())
                        off = dvarint(x, off, f.Type.Size())
                        off = dvarint(x, off, f.Offset)
                }
@@ -287,18 +312,18 @@ func (s *state) emitOpenDeferInfo() {
 
 // buildssa builds an SSA function for fn.
 // worker indicates which of the backend workers is doing the processing.
-func buildssa(fn *Node, worker int) *ssa.Func {
-       name := fn.funcname()
+func buildssa(fn *ir.Func, worker int) *ssa.Func {
+       name := ir.FuncName(fn)
        printssa := false
        if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
-               printssa = name == ssaDump || myimportpath+"."+name == ssaDump
+               printssa = name == ssaDump || base.Ctxt.Pkgpath+"."+name == ssaDump
        }
        var astBuf *bytes.Buffer
        if printssa {
                astBuf = &bytes.Buffer{}
-               fdumplist(astBuf, "buildssa-enter", fn.Func.Enter)
-               fdumplist(astBuf, "buildssa-body", fn.Nbody)
-               fdumplist(astBuf, "buildssa-exit", fn.Func.Exit)
+               ir.FDumpList(astBuf, "buildssa-enter", fn.Enter)
+               ir.FDumpList(astBuf, "buildssa-body", fn.Body)
+               ir.FDumpList(astBuf, "buildssa-exit", fn.Exit)
                if ssaDumpStdout {
                        fmt.Println("generating SSA for", name)
                        fmt.Print(astBuf.String())
@@ -306,11 +331,11 @@ func buildssa(fn *Node, worker int) *ssa.Func {
        }
 
        var s state
-       s.pushLine(fn.Pos)
+       s.pushLine(fn.Pos())
        defer s.popLine()
 
-       s.hasdefer = fn.Func.HasDefer()
-       if fn.Func.Pragma&CgoUnsafeArgs != 0 {
+       s.hasdefer = fn.HasDefer()
+       if fn.Pragma&ir.CgoUnsafeArgs != 0 {
                s.cgoUnsafeArgs = true
        }
 
@@ -322,27 +347,34 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 
        s.f = ssa.NewFunc(&fe)
        s.config = ssaConfig
-       s.f.Type = fn.Type
+       s.f.Type = fn.Type()
        s.f.Config = ssaConfig
        s.f.Cache = &ssaCaches[worker]
        s.f.Cache.Reset()
        s.f.Name = name
        s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH")
        s.f.PrintOrHtmlSSA = printssa
-       if fn.Func.Pragma&Nosplit != 0 {
+       if fn.Pragma&ir.Nosplit != 0 {
                s.f.NoSplit = true
        }
+       if fn.Pragma&ir.RegisterParams != 0 { // TODO remove after register abi is working
+               if strings.Contains(name, ".") {
+                       base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+               }
+               s.f.Warnl(fn.Pos(), "declared function %v has register params", fn)
+       }
+
        s.panics = map[funcLine]*ssa.Block{}
        s.softFloat = s.config.SoftFloat
 
        // Allocate starting block
        s.f.Entry = s.f.NewBlock(ssa.BlockPlain)
-       s.f.Entry.Pos = fn.Pos
+       s.f.Entry.Pos = fn.Pos()
 
        if printssa {
                ssaDF := ssaDumpFile
                if ssaDir != "" {
-                       ssaDF = filepath.Join(ssaDir, myimportpath+"."+name+".html")
+                       ssaDF = filepath.Join(ssaDir, base.Ctxt.Pkgpath+"."+name+".html")
                        ssaD := filepath.Dir(ssaDF)
                        os.MkdirAll(ssaD, 0755)
                }
@@ -354,28 +386,36 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 
        // Allocate starting values
        s.labels = map[string]*ssaLabel{}
-       s.labeledNodes = map[*Node]*ssaLabel{}
-       s.fwdVars = map[*Node]*ssa.Value{}
+       s.fwdVars = map[ir.Node]*ssa.Value{}
        s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
-       s.hasOpenDefers = Debug.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
+       s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed()
        switch {
-       case s.hasOpenDefers && (Ctxt.Flag_shared || Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
+       case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && base.Ctxt.Arch.Name == "386":
                // Don't support open-coded defers for 386 ONLY when using shared
                // libraries, because there is extra code (added by rewriteToUseGot())
                // preceding the deferreturn/ret code that is generated by gencallret()
                // that we don't track correctly.
                s.hasOpenDefers = false
        }
-       if s.hasOpenDefers && s.curfn.Func.Exit.Len() > 0 {
+       if s.hasOpenDefers && len(s.curfn.Exit) > 0 {
                // Skip doing open defers if there is any extra exit code (likely
-               // copying heap-allocated return values or race detection), since
-               // we will not generate that code in the case of the extra
-               // deferreturn/ret segment.
+               // race detection), since we will not generate that code in the
+               // case of the extra deferreturn/ret segment.
                s.hasOpenDefers = false
        }
+       if s.hasOpenDefers {
+               // Similarly, skip if there are any heap-allocated result
+               // parameters that need to be copied back to their stack slots.
+               for _, f := range s.curfn.Type().Results().FieldSlice() {
+                       if !f.Nname.(*ir.Name).OnStack() {
+                               s.hasOpenDefers = false
+                               break
+                       }
+               }
+       }
        if s.hasOpenDefers &&
-               s.curfn.Func.numReturns*s.curfn.Func.numDefers > 15 {
+               s.curfn.NumReturns*s.curfn.NumDefers > 15 {
                // Since we are generating defer calls at every exit for
                // open-coded defers, skip doing open-coded defers if there are
                // too many returns (especially if there are multiple defers).
@@ -384,76 +424,106 @@ func buildssa(fn *Node, worker int) *ssa.Func {
                s.hasOpenDefers = false
        }
 
-       s.sp = s.entryNewValue0(ssa.OpSP, types.Types[TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
-       s.sb = s.entryNewValue0(ssa.OpSB, types.Types[TUINTPTR])
+       s.sp = s.entryNewValue0(ssa.OpSP, types.Types[types.TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
+       s.sb = s.entryNewValue0(ssa.OpSB, types.Types[types.TUINTPTR])
 
        s.startBlock(s.f.Entry)
-       s.vars[&memVar] = s.startmem
+       s.vars[memVar] = s.startmem
        if s.hasOpenDefers {
                // Create the deferBits variable and stack slot.  deferBits is a
                // bitmask showing which of the open-coded defers in this function
                // have been activated.
-               deferBitsTemp := tempAt(src.NoXPos, s.curfn, types.Types[TUINT8])
+               deferBitsTemp := typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT8])
+               deferBitsTemp.SetAddrtaken(true)
                s.deferBitsTemp = deferBitsTemp
                // For this value, AuxInt is initialized to zero by default
-               startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[TUINT8])
-               s.vars[&deferBitsVar] = startDeferBits
+               startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[types.TUINT8])
+               s.vars[deferBitsVar] = startDeferBits
                s.deferBitsAddr = s.addr(deferBitsTemp)
-               s.store(types.Types[TUINT8], s.deferBitsAddr, startDeferBits)
+               s.store(types.Types[types.TUINT8], s.deferBitsAddr, startDeferBits)
                // Make sure that the deferBits stack slot is kept alive (for use
                // by panics) and stores to deferBits are not eliminated, even if
                // all checking code on deferBits in the function exit can be
                // eliminated, because the defer statements were all
                // unconditional.
-               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
+               s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
        }
 
        // Generate addresses of local declarations
-       s.decladdrs = map[*Node]*ssa.Value{}
+       s.decladdrs = map[*ir.Name]*ssa.Value{}
        var args []ssa.Param
        var results []ssa.Param
-       for _, n := range fn.Func.Dcl {
-               switch n.Class() {
-               case PPARAM:
-                       s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
-                       args = append(args, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
-               case PPARAMOUT:
-                       s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
-                       results = append(results, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
-                       if s.canSSA(n) {
-                               // Save ssa-able PPARAMOUT variables so we can
-                               // store them back to the stack at the end of
-                               // the function.
-                               s.returns = append(s.returns, n)
-                       }
-               case PAUTO:
+       for _, n := range fn.Dcl {
+               switch n.Class {
+               case ir.PPARAM:
+                       s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
+                       args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
+               case ir.PPARAMOUT:
+                       s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
+                       results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset()), Name: n})
+               case ir.PAUTO:
                        // processed at each use, to prevent Addr coming
                        // before the decl.
-               case PAUTOHEAP:
-                       // moved to heap - already handled by frontend
-               case PFUNC:
-                       // local function - already handled by frontend
                default:
-                       s.Fatalf("local variable with class %v unimplemented", n.Class())
+                       s.Fatalf("local variable with class %v unimplemented", n.Class)
                }
        }
+       s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, args, results)
 
        // Populate SSAable arguments.
-       for _, n := range fn.Func.Dcl {
-               if n.Class() == PPARAM && s.canSSA(n) {
-                       v := s.newValue0A(ssa.OpArg, n.Type, n)
+       for _, n := range fn.Dcl {
+               if n.Class == ir.PPARAM && s.canSSA(n) {
+                       v := s.newValue0A(ssa.OpArg, n.Type(), n)
                        s.vars[n] = v
                        s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
                }
        }
 
+       // Populate closure variables.
+       if !fn.ClosureCalled() {
+               clo := s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr)
+               offset := int64(types.PtrSize) // PtrSize to skip past function entry PC field
+               for _, n := range fn.ClosureVars {
+                       typ := n.Type()
+                       if !n.Byval() {
+                               typ = types.NewPtr(typ)
+                       }
+
+                       offset = types.Rnd(offset, typ.Alignment())
+                       ptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(typ), offset, clo)
+                       offset += typ.Size()
+
+                       // If n is a small variable captured by value, promote
+                       // it to PAUTO so it can be converted to SSA.
+                       //
+                       // Note: While we never capture a variable by value if
+                       // the user took its address, we may have generated
+                       // runtime calls that did (#43701). Since we don't
+                       // convert Addrtaken variables to SSA anyway, no point
+                       // in promoting them either.
+                       if n.Byval() && !n.Addrtaken() && TypeOK(n.Type()) {
+                               n.Class = ir.PAUTO
+                               fn.Dcl = append(fn.Dcl, n)
+                               s.assign(n, s.load(n.Type(), ptr), false, 0)
+                               continue
+                       }
+
+                       if !n.Byval() {
+                               ptr = s.load(typ, ptr)
+                       }
+                       s.setHeapaddr(fn.Pos(), n, ptr)
+               }
+       }
+
        // Convert the AST-based IR to the SSA-based IR
-       s.stmtList(fn.Func.Enter)
-       s.stmtList(fn.Nbody)
+       s.stmtList(fn.Enter)
+       s.zeroResults()
+       s.paramsToHeap()
+       s.stmtList(fn.Body)
 
        // fallthrough to exit
        if s.curBlock != nil {
-               s.pushLine(fn.Func.Endlineno)
+               s.pushLine(fn.Endlineno)
                s.exit()
                s.popLine()
        }
@@ -464,6 +534,8 @@ func buildssa(fn *Node, worker int) *ssa.Func {
                }
        }
 
+       s.f.HTMLWriter.WritePhase("before insert phis", "before insert phis")
+
        s.insertPhis()
 
        // Main call to ssa package to compile function
@@ -476,10 +548,104 @@ func buildssa(fn *Node, worker int) *ssa.Func {
        return s.f
 }
 
-func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *Node) {
+// zeroResults zeros the return values at the start of the function.
+// We need to do this very early in the function.  Defer might stop a
+// panic and show the return values as they exist at the time of
+// panic.  For precise stacks, the garbage collector assumes results
+// are always live, so we need to zero them before any allocations,
+// even allocations to move params/results to the heap.
+func (s *state) zeroResults() {
+       for _, f := range s.curfn.Type().Results().FieldSlice() {
+               n := f.Nname.(*ir.Name)
+               if !n.OnStack() {
+                       // The local which points to the return value is the
+                       // thing that needs zeroing. This is already handled
+                       // by a Needzero annotation in plive.go:(*liveness).epilogue.
+                       continue
+               }
+               // Zero the stack location containing f.
+               if typ := n.Type(); TypeOK(typ) {
+                       s.assign(n, s.zeroVal(typ), false, 0)
+               } else {
+                       s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+                       s.zero(n.Type(), s.decladdrs[n])
+               }
+       }
+}
+
+// paramsToHeap produces code to allocate memory for heap-escaped parameters
+// and to copy non-result parameters' values from the stack.
+func (s *state) paramsToHeap() {
+       do := func(params *types.Type) {
+               for _, f := range params.FieldSlice() {
+                       if f.Nname == nil {
+                               continue // anonymous or blank parameter
+                       }
+                       n := f.Nname.(*ir.Name)
+                       if ir.IsBlank(n) || n.OnStack() {
+                               continue
+                       }
+                       s.newHeapaddr(n)
+                       if n.Class == ir.PPARAM {
+                               s.move(n.Type(), s.expr(n.Heapaddr), s.decladdrs[n])
+                       }
+               }
+       }
+
+       typ := s.curfn.Type()
+       do(typ.Recvs())
+       do(typ.Params())
+       do(typ.Results())
+}
+
+// newHeapaddr allocates heap memory for n and sets its heap address.
+func (s *state) newHeapaddr(n *ir.Name) {
+       s.setHeapaddr(n.Pos(), n, s.newObject(n.Type()))
+}
+
+// setHeapaddr allocates a new PAUTO variable to store ptr (which must be non-nil)
+// and then sets it as n's heap address.
+func (s *state) setHeapaddr(pos src.XPos, n *ir.Name, ptr *ssa.Value) {
+       if !ptr.Type.IsPtr() || !types.Identical(n.Type(), ptr.Type.Elem()) {
+               base.FatalfAt(n.Pos(), "setHeapaddr %L with type %v", n, ptr.Type)
+       }
+
+       // Declare variable to hold address.
+       addr := ir.NewNameAt(pos, &types.Sym{Name: "&" + n.Sym().Name, Pkg: types.LocalPkg})
+       addr.SetType(types.NewPtr(n.Type()))
+       addr.Class = ir.PAUTO
+       addr.SetUsed(true)
+       addr.Curfn = s.curfn
+       s.curfn.Dcl = append(s.curfn.Dcl, addr)
+       types.CalcSize(addr.Type())
+
+       if n.Class == ir.PPARAMOUT {
+               addr.SetIsOutputParamHeapAddr(true)
+       }
+
+       n.Heapaddr = addr
+       s.assign(addr, ptr, false, 0)
+}
+
+// newObject returns an SSA value denoting new(typ).
+func (s *state) newObject(typ *types.Type) *ssa.Value {
+       if typ.Size() == 0 {
+               return s.newValue1A(ssa.OpAddr, types.NewPtr(typ), ir.Syms.Zerobase, s.sb)
+       }
+       return s.rtcall(ir.Syms.Newobject, true, []*types.Type{types.NewPtr(typ)}, s.reflectType(typ))[0]
+}
+
+// reflectType returns an SSA value representing a pointer to typ's
+// reflection type descriptor.
+func (s *state) reflectType(typ *types.Type) *ssa.Value {
+       lsym := reflectdata.TypeLinksym(typ)
+       return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(types.Types[types.TUINT8]), lsym, s.sb)
+}
+
+func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Func) {
        // Read sources of target function fn.
-       fname := Ctxt.PosTable.Pos(fn.Pos).Filename()
-       targetFn, err := readFuncLines(fname, fn.Pos.Line(), fn.Func.Endlineno.Line())
+       fname := base.Ctxt.PosTable.Pos(fn.Pos()).Filename()
+       targetFn, err := readFuncLines(fname, fn.Pos().Line(), fn.Endlineno.Line())
        if err != nil {
                writer.Logf("cannot read sources for function %v: %v", fn, err)
        }
@@ -487,15 +653,9 @@ func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *Node) {
        // Read sources of inlined functions.
        var inlFns []*ssa.FuncLines
        for _, fi := range ssaDumpInlined {
-               var elno src.XPos
-               if fi.Name.Defn == nil {
-                       // Endlineno is filled from exported data.
-                       elno = fi.Func.Endlineno
-               } else {
-                       elno = fi.Name.Defn.Func.Endlineno
-               }
-               fname := Ctxt.PosTable.Pos(fi.Pos).Filename()
-               fnLines, err := readFuncLines(fname, fi.Pos.Line(), elno.Line())
+               elno := fi.Endlineno
+               fname := base.Ctxt.PosTable.Pos(fi.Pos()).Filename()
+               fnLines, err := readFuncLines(fname, fi.Pos().Line(), elno.Line())
                if err != nil {
                        writer.Logf("cannot read sources for inlined function %v: %v", fi, err)
                        continue
@@ -563,25 +723,25 @@ func (s *state) updateUnsetPredPos(b *ssa.Block) {
 
 // Information about each open-coded defer.
 type openDeferInfo struct {
-       // The ODEFER node representing the function call of the defer
-       n *Node
+       // The node representing the call of the defer
+       n *ir.CallExpr
        // If defer call is closure call, the address of the argtmp where the
        // closure is stored.
        closure *ssa.Value
        // The node representing the argtmp where the closure is stored - used for
        // function, method, or interface call, to store a closure that panic
        // processing can use for this defer.
-       closureNode *Node
+       closureNode *ir.Name
        // If defer call is interface call, the address of the argtmp where the
        // receiver is stored
        rcvr *ssa.Value
        // The node representing the argtmp where the receiver is stored
-       rcvrNode *Node
+       rcvrNode *ir.Name
        // The addresses of the argtmps where the evaluated arguments of the defer
        // function call are stored.
        argVals []*ssa.Value
        // The nodes representing the argtmps where the args of the defer are stored
-       argNodes []*Node
+       argNodes []*ir.Name
 }
 
 type state struct {
@@ -592,11 +752,10 @@ type state struct {
        f *ssa.Func
 
        // Node for function
-       curfn *Node
+       curfn *ir.Func
 
-       // labels and labeled control flow nodes (OFOR, OFORUNTIL, OSWITCH, OSELECT) in f
-       labels       map[string]*ssaLabel
-       labeledNodes map[*Node]*ssaLabel
+       // labels in f
+       labels map[string]*ssaLabel
 
        // unlabeled break and continue statement tracking
        breakTo    *ssa.Block // current target for plain break statement
@@ -608,18 +767,18 @@ type state struct {
        // variable assignments in the current block (map from variable symbol to ssa value)
        // *Node is the unique identifier (an ONAME Node) for the variable.
        // TODO: keep a single varnum map, then make all of these maps slices instead?
-       vars map[*Node]*ssa.Value
+       vars map[ir.Node]*ssa.Value
 
        // fwdVars are variables that are used before they are defined in the current block.
        // This map exists just to coalesce multiple references into a single FwdRef op.
        // *Node is the unique identifier (an ONAME Node) for the variable.
-       fwdVars map[*Node]*ssa.Value
+       fwdVars map[ir.Node]*ssa.Value
 
        // all defined variables at the end of each block. Indexed by block ID.
-       defvars []map[*Node]*ssa.Value
+       defvars []map[ir.Node]*ssa.Value
 
-       // addresses of PPARAM and PPARAMOUT variables.
-       decladdrs map[*Node]*ssa.Value
+       // addresses of PPARAM and PPARAMOUT variables on the stack.
+       decladdrs map[*ir.Name]*ssa.Value
 
        // starting values. Memory, stack pointer, and globals pointer
        startmem *ssa.Value
@@ -627,7 +786,7 @@ type state struct {
        sb       *ssa.Value
        // value representing address of where deferBits autotmp is stored
        deferBitsAddr *ssa.Value
-       deferBitsTemp *Node
+       deferBitsTemp *ir.Name
 
        // line number stack. The current line number is top of stack
        line []src.XPos
@@ -638,9 +797,6 @@ type state struct {
        // Used to deduplicate panic calls.
        panics map[funcLine]*ssa.Block
 
-       // list of PPARAMOUT (return) variables.
-       returns []*Node
-
        cgoUnsafeArgs bool
        hasdefer      bool // whether the function contains a defer statement
        softFloat     bool
@@ -691,18 +847,22 @@ func (s *state) Fatalf(msg string, args ...interface{}) {
 func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl(pos, msg, args...) }
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
+func ssaMarker(name string) *ir.Name {
+       return typecheck.NewName(&types.Sym{Name: name})
+}
+
 var (
-       // dummy node for the memory variable
-       memVar = Node{Op: ONAME, Sym: &types.Sym{Name: "mem"}}
-
-       // dummy nodes for temporary variables
-       ptrVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "ptr"}}
-       lenVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "len"}}
-       newlenVar    = Node{Op: ONAME, Sym: &types.Sym{Name: "newlen"}}
-       capVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "cap"}}
-       typVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "typ"}}
-       okVar        = Node{Op: ONAME, Sym: &types.Sym{Name: "ok"}}
-       deferBitsVar = Node{Op: ONAME, Sym: &types.Sym{Name: "deferBits"}}
+       // marker node for the memory variable
+       memVar = ssaMarker("mem")
+
+       // marker nodes for temporary variables
+       ptrVar       = ssaMarker("ptr")
+       lenVar       = ssaMarker("len")
+       newlenVar    = ssaMarker("newlen")
+       capVar       = ssaMarker("cap")
+       typVar       = ssaMarker("typ")
+       okVar        = ssaMarker("ok")
+       deferBitsVar = ssaMarker("deferBits")
 )
 
 // startBlock sets the current block we're generating code in to b.
@@ -711,7 +871,7 @@ func (s *state) startBlock(b *ssa.Block) {
                s.Fatalf("starting block %v when block %v has not ended", b, s.curBlock)
        }
        s.curBlock = b
-       s.vars = map[*Node]*ssa.Value{}
+       s.vars = map[ir.Node]*ssa.Value{}
        for n := range s.fwdVars {
                delete(s.fwdVars, n)
        }
@@ -748,8 +908,8 @@ func (s *state) pushLine(line src.XPos) {
                // the frontend may emit node with line number missing,
                // use the parent line number in this case.
                line = s.peekPos()
-               if Debug.K != 0 {
-                       Warn("buildssa: unknown position (line 0)")
+               if base.Flag.K != 0 {
+                       base.Warn("buildssa: unknown position (line 0)")
                }
        } else {
                s.lastPos = line
@@ -774,7 +934,7 @@ func (s *state) newValue0(op ssa.Op, t *types.Type) *ssa.Value {
 }
 
 // newValue0A adds a new value with no arguments and an aux value to the current block.
-func (s *state) newValue0A(op ssa.Op, t *types.Type, aux interface{}) *ssa.Value {
+func (s *state) newValue0A(op ssa.Op, t *types.Type, aux ssa.Aux) *ssa.Value {
        return s.curBlock.NewValue0A(s.peekPos(), op, t, aux)
 }
 
@@ -789,14 +949,14 @@ func (s *state) newValue1(op ssa.Op, t *types.Type, arg *ssa.Value) *ssa.Value {
 }
 
 // newValue1A adds a new value with one argument and an aux value to the current block.
-func (s *state) newValue1A(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+func (s *state) newValue1A(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value) *ssa.Value {
        return s.curBlock.NewValue1A(s.peekPos(), op, t, aux, arg)
 }
 
 // newValue1Apos adds a new value with one argument and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue1Apos(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue1Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value, isStmt bool) *ssa.Value {
        if isStmt {
                return s.curBlock.NewValue1A(s.peekPos(), op, t, aux, arg)
        }
@@ -814,14 +974,14 @@ func (s *state) newValue2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Value) *ssa.
 }
 
 // newValue2A adds a new value with two arguments and an aux value to the current block.
-func (s *state) newValue2A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value {
+func (s *state) newValue2A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value) *ssa.Value {
        return s.curBlock.NewValue2A(s.peekPos(), op, t, aux, arg0, arg1)
 }
 
 // newValue2Apos adds a new value with two arguments and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue2Apos(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue2Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value, isStmt bool) *ssa.Value {
        if isStmt {
                return s.curBlock.NewValue2A(s.peekPos(), op, t, aux, arg0, arg1)
        }
@@ -844,14 +1004,14 @@ func (s *state) newValue3I(op ssa.Op, t *types.Type, aux int64, arg0, arg1, arg2
 }
 
 // newValue3A adds a new value with three arguments and an aux value to the current block.
-func (s *state) newValue3A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
+func (s *state) newValue3A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
        return s.curBlock.NewValue3A(s.peekPos(), op, t, aux, arg0, arg1, arg2)
 }
 
 // newValue3Apos adds a new value with three arguments and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue3Apos(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue3Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1, arg2 *ssa.Value, isStmt bool) *ssa.Value {
        if isStmt {
                return s.curBlock.NewValue3A(s.peekPos(), op, t, aux, arg0, arg1, arg2)
        }
@@ -874,7 +1034,7 @@ func (s *state) entryNewValue0(op ssa.Op, t *types.Type) *ssa.Value {
 }
 
 // entryNewValue0A adds a new value with no arguments and an aux value to the entry block.
-func (s *state) entryNewValue0A(op ssa.Op, t *types.Type, aux interface{}) *ssa.Value {
+func (s *state) entryNewValue0A(op ssa.Op, t *types.Type, aux ssa.Aux) *ssa.Value {
        return s.f.Entry.NewValue0A(src.NoXPos, op, t, aux)
 }
 
@@ -889,7 +1049,7 @@ func (s *state) entryNewValue1I(op ssa.Op, t *types.Type, auxint int64, arg *ssa
 }
 
 // entryNewValue1A adds a new value with one argument and an aux value to the entry block.
-func (s *state) entryNewValue1A(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+func (s *state) entryNewValue1A(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value) *ssa.Value {
        return s.f.Entry.NewValue1A(src.NoXPos, op, t, aux, arg)
 }
 
@@ -899,7 +1059,7 @@ func (s *state) entryNewValue2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Value)
 }
 
 // entryNewValue2A adds a new value with two arguments and an aux value to the entry block.
-func (s *state) entryNewValue2A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value {
+func (s *state) entryNewValue2A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value) *ssa.Value {
        return s.f.Entry.NewValue2A(src.NoXPos, op, t, aux, arg0, arg1)
 }
 
@@ -915,7 +1075,7 @@ func (s *state) constEmptyString(t *types.Type) *ssa.Value {
        return s.f.ConstEmptyString(t)
 }
 func (s *state) constBool(c bool) *ssa.Value {
-       return s.f.ConstBool(types.Types[TBOOL], c)
+       return s.f.ConstBool(types.Types[types.TBOOL], c)
 }
 func (s *state) constInt8(t *types.Type, c int8) *ssa.Value {
        return s.f.ConstInt8(t, c)
@@ -983,7 +1143,7 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, kind instrumentKind)
 // If it is instrumenting for MSAN and t is a struct type, it instruments
 // operation for each field, instead of for the whole struct.
 func (s *state) instrumentFields(t *types.Type, addr *ssa.Value, kind instrumentKind) {
-       if !flag_msan || !t.IsStruct() {
+       if !base.Flag.MSan || !t.IsStruct() {
                s.instrument(t, addr, kind)
                return
        }
@@ -997,7 +1157,7 @@ func (s *state) instrumentFields(t *types.Type, addr *ssa.Value, kind instrument
 }
 
 func (s *state) instrumentMove(t *types.Type, dst, src *ssa.Value) {
-       if flag_msan {
+       if base.Flag.MSan {
                s.instrument2(t, dst, src, instrumentMove)
        } else {
                s.instrument(t, src, instrumentRead)
@@ -1006,7 +1166,7 @@ func (s *state) instrumentMove(t *types.Type, dst, src *ssa.Value) {
 }
 
 func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrumentKind) {
-       if !s.curfn.Func.InstrumentBody() {
+       if !s.curfn.InstrumentBody() {
                return
        }
 
@@ -1026,39 +1186,39 @@ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrume
                panic("instrument2: non-nil addr2 for non-move instrumentation")
        }
 
-       if flag_msan {
+       if base.Flag.MSan {
                switch kind {
                case instrumentRead:
-                       fn = msanread
+                       fn = ir.Syms.Msanread
                case instrumentWrite:
-                       fn = msanwrite
+                       fn = ir.Syms.Msanwrite
                case instrumentMove:
-                       fn = msanmove
+                       fn = ir.Syms.Msanmove
                default:
                        panic("unreachable")
                }
                needWidth = true
-       } else if flag_race && t.NumComponents(types.CountBlankFields) > 1 {
+       } else if base.Flag.Race && t.NumComponents(types.CountBlankFields) > 1 {
                // for composite objects we have to write every address
                // because a write might happen to any subobject.
                // composites with only one element don't have subobjects, though.
                switch kind {
                case instrumentRead:
-                       fn = racereadrange
+                       fn = ir.Syms.Racereadrange
                case instrumentWrite:
-                       fn = racewriterange
+                       fn = ir.Syms.Racewriterange
                default:
                        panic("unreachable")
                }
                needWidth = true
-       } else if flag_race {
+       } else if base.Flag.Race {
                // for non-composite objects we can write just the start
                // address, as any write must write the first byte.
                switch kind {
                case instrumentRead:
-                       fn = raceread
+                       fn = ir.Syms.Raceread
                case instrumentWrite:
-                       fn = racewrite
+                       fn = ir.Syms.Racewrite
                default:
                        panic("unreachable")
                }
@@ -1071,7 +1231,7 @@ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrume
                args = append(args, addr2)
        }
        if needWidth {
-               args = append(args, s.constInt(types.Types[TUINTPTR], w))
+               args = append(args, s.constInt(types.Types[types.TUINTPTR], w))
        }
        s.rtcall(fn, true, nil, args...)
 }
@@ -1086,66 +1246,69 @@ func (s *state) rawLoad(t *types.Type, src *ssa.Value) *ssa.Value {
 }
 
 func (s *state) store(t *types.Type, dst, val *ssa.Value) {
-       s.vars[&memVar] = s.newValue3A(ssa.OpStore, types.TypeMem, t, dst, val, s.mem())
+       s.vars[memVar] = s.newValue3A(ssa.OpStore, types.TypeMem, t, dst, val, s.mem())
 }
 
 func (s *state) zero(t *types.Type, dst *ssa.Value) {
        s.instrument(t, dst, instrumentWrite)
        store := s.newValue2I(ssa.OpZero, types.TypeMem, t.Size(), dst, s.mem())
        store.Aux = t
-       s.vars[&memVar] = store
+       s.vars[memVar] = store
 }
 
 func (s *state) move(t *types.Type, dst, src *ssa.Value) {
        s.instrumentMove(t, dst, src)
        store := s.newValue3I(ssa.OpMove, types.TypeMem, t.Size(), dst, src, s.mem())
        store.Aux = t
-       s.vars[&memVar] = store
+       s.vars[memVar] = store
 }
 
 // stmtList converts the statement list n to SSA and adds it to s.
-func (s *state) stmtList(l Nodes) {
-       for _, n := range l.Slice() {
+func (s *state) stmtList(l ir.Nodes) {
+       for _, n := range l {
                s.stmt(n)
        }
 }
 
 // stmt converts the statement n to SSA and adds it to s.
-func (s *state) stmt(n *Node) {
-       if !(n.Op == OVARKILL || n.Op == OVARLIVE || n.Op == OVARDEF) {
+func (s *state) stmt(n ir.Node) {
+       if !(n.Op() == ir.OVARKILL || n.Op() == ir.OVARLIVE || n.Op() == ir.OVARDEF) {
                // OVARKILL, OVARLIVE, and OVARDEF are invisible to the programmer, so we don't use their line numbers to avoid confusion in debugging.
-               s.pushLine(n.Pos)
+               s.pushLine(n.Pos())
                defer s.popLine()
        }
 
        // If s.curBlock is nil, and n isn't a label (which might have an associated goto somewhere),
        // then this code is dead. Stop here.
-       if s.curBlock == nil && n.Op != OLABEL {
+       if s.curBlock == nil && n.Op() != ir.OLABEL {
                return
        }
 
-       s.stmtList(n.Ninit)
-       switch n.Op {
+       s.stmtList(n.Init())
+       switch n.Op() {
 
-       case OBLOCK:
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
                s.stmtList(n.List)
 
        // No-ops
-       case OEMPTY, ODCLCONST, ODCLTYPE, OFALL:
+       case ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
 
        // Expression statements
-       case OCALLFUNC:
-               if isIntrinsicCall(n) {
+       case ir.OCALLFUNC:
+               n := n.(*ir.CallExpr)
+               if ir.IsIntrinsicCall(n) {
                        s.intrinsicCall(n)
                        return
                }
                fallthrough
 
-       case OCALLMETH, OCALLINTER:
+       case ir.OCALLINTER:
+               n := n.(*ir.CallExpr)
                s.callResult(n, callNormal)
-               if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class() == PFUNC {
-                       if fn := n.Left.Sym.Name; compiling_runtime && fn == "throw" ||
-                               n.Left.Sym.Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
+               if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class == ir.PFUNC {
+                       if fn := n.X.Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
+                               n.X.Sym().Pkg == ir.Pkgs.Runtime && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
                                m := s.mem()
                                b := s.endBlock()
                                b.Kind = ssa.BlockExit
@@ -1155,34 +1318,37 @@ func (s *state) stmt(n *Node) {
                                // go through SSA.
                        }
                }
-       case ODEFER:
-               if Debug_defer > 0 {
+       case ir.ODEFER:
+               n := n.(*ir.GoDeferStmt)
+               if base.Debug.Defer > 0 {
                        var defertype string
                        if s.hasOpenDefers {
                                defertype = "open-coded"
-                       } else if n.Esc == EscNever {
+                       } else if n.Esc() == ir.EscNever {
                                defertype = "stack-allocated"
                        } else {
                                defertype = "heap-allocated"
                        }
-                       Warnl(n.Pos, "%s defer", defertype)
+                       base.WarnfAt(n.Pos(), "%s defer", defertype)
                }
                if s.hasOpenDefers {
-                       s.openDeferRecord(n.Left)
+                       s.openDeferRecord(n.Call.(*ir.CallExpr))
                } else {
                        d := callDefer
-                       if n.Esc == EscNever {
+                       if n.Esc() == ir.EscNever {
                                d = callDeferStack
                        }
-                       s.callResult(n.Left, d)
+                       s.callResult(n.Call.(*ir.CallExpr), d)
                }
-       case OGO:
-               s.callResult(n.Left, callGo)
+       case ir.OGO:
+               n := n.(*ir.GoDeferStmt)
+               s.callResult(n.Call.(*ir.CallExpr), callGo)
 
-       case OAS2DOTTYPE:
-               res, resok := s.dottype(n.Right, true)
+       case ir.OAS2DOTTYPE:
+               n := n.(*ir.AssignListStmt)
+               res, resok := s.dottype(n.Rhs[0].(*ir.TypeAssertExpr), true)
                deref := false
-               if !canSSAType(n.Right.Type) {
+               if !TypeOK(n.Rhs[0].Type()) {
                        if res.Op != ssa.OpLoad {
                                s.Fatalf("dottype of non-load")
                        }
@@ -1196,36 +1362,35 @@ func (s *state) stmt(n *Node) {
                        deref = true
                        res = res.Args[0]
                }
-               s.assign(n.List.First(), res, deref, 0)
-               s.assign(n.List.Second(), resok, false, 0)
+               s.assign(n.Lhs[0], res, deref, 0)
+               s.assign(n.Lhs[1], resok, false, 0)
                return
 
-       case OAS2FUNC:
+       case ir.OAS2FUNC:
                // We come here only when it is an intrinsic call returning two values.
-               if !isIntrinsicCall(n.Right) {
-                       s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Right)
-               }
-               v := s.intrinsicCall(n.Right)
-               v1 := s.newValue1(ssa.OpSelect0, n.List.First().Type, v)
-               v2 := s.newValue1(ssa.OpSelect1, n.List.Second().Type, v)
-               s.assign(n.List.First(), v1, false, 0)
-               s.assign(n.List.Second(), v2, false, 0)
+               n := n.(*ir.AssignListStmt)
+               call := n.Rhs[0].(*ir.CallExpr)
+               if !ir.IsIntrinsicCall(call) {
+                       s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
+               }
+               v := s.intrinsicCall(call)
+               v1 := s.newValue1(ssa.OpSelect0, n.Lhs[0].Type(), v)
+               v2 := s.newValue1(ssa.OpSelect1, n.Lhs[1].Type(), v)
+               s.assign(n.Lhs[0], v1, false, 0)
+               s.assign(n.Lhs[1], v2, false, 0)
                return
 
-       case ODCL:
-               if n.Left.Class() == PAUTOHEAP {
-                       s.Fatalf("DCL %v", n)
+       case ir.ODCL:
+               n := n.(*ir.Decl)
+               if v := n.X; v.Esc() == ir.EscHeap {
+                       s.newHeapaddr(v)
                }
 
-       case OLABEL:
-               sym := n.Sym
+       case ir.OLABEL:
+               n := n.(*ir.LabelStmt)
+               sym := n.Label
                lab := s.label(sym)
 
-               // Associate label with its control flow node, if any
-               if ctl := n.labeledControl(); ctl != nil {
-                       s.labeledNodes[ctl] = lab
-               }
-
                // The label might already have a target block via a goto.
                if lab.target == nil {
                        lab.target = s.f.NewBlock(ssa.BlockPlain)
@@ -1239,8 +1404,9 @@ func (s *state) stmt(n *Node) {
                }
                s.startBlock(lab.target)
 
-       case OGOTO:
-               sym := n.Sym
+       case ir.OGOTO:
+               n := n.(*ir.BranchStmt)
+               sym := n.Label
 
                lab := s.label(sym)
                if lab.target == nil {
@@ -1251,8 +1417,9 @@ func (s *state) stmt(n *Node) {
                b.Pos = s.lastPos.WithIsStmt() // Do this even if b is an empty block.
                b.AddEdgeTo(lab.target)
 
-       case OAS:
-               if n.Left == n.Right && n.Left.Op == ONAME {
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               if n.X == n.Y && n.X.Op() == ir.ONAME {
                        // An x=x assignment. No point in doing anything
                        // here. In addition, skipping this assignment
                        // prevents generating:
@@ -1264,42 +1431,43 @@ func (s *state) stmt(n *Node) {
                }
 
                // Evaluate RHS.
-               rhs := n.Right
+               rhs := n.Y
                if rhs != nil {
-                       switch rhs.Op {
-                       case OSTRUCTLIT, OARRAYLIT, OSLICELIT:
+                       switch rhs.Op() {
+                       case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
                                // All literals with nonzero fields have already been
                                // rewritten during walk. Any that remain are just T{}
                                // or equivalents. Use the zero value.
-                               if !isZero(rhs) {
+                               if !ir.IsZero(rhs) {
                                        s.Fatalf("literal with nonzero value in SSA: %v", rhs)
                                }
                                rhs = nil
-                       case OAPPEND:
+                       case ir.OAPPEND:
+                               rhs := rhs.(*ir.CallExpr)
                                // Check whether we're writing the result of an append back to the same slice.
                                // If so, we handle it specially to avoid write barriers on the fast
                                // (non-growth) path.
-                               if !samesafeexpr(n.Left, rhs.List.First()) || Debug.N != 0 {
+                               if !ir.SameSafeExpr(n.X, rhs.Args[0]) || base.Flag.N != 0 {
                                        break
                                }
                                // If the slice can be SSA'd, it'll be on the stack,
                                // so there will be no write barriers,
                                // so there's no need to attempt to prevent them.
-                               if s.canSSA(n.Left) {
-                                       if Debug_append > 0 { // replicating old diagnostic message
-                                               Warnl(n.Pos, "append: len-only update (in local slice)")
+                               if s.canSSA(n.X) {
+                                       if base.Debug.Append > 0 { // replicating old diagnostic message
+                                               base.WarnfAt(n.Pos(), "append: len-only update (in local slice)")
                                        }
                                        break
                                }
-                               if Debug_append > 0 {
-                                       Warnl(n.Pos, "append: len-only update")
+                               if base.Debug.Append > 0 {
+                                       base.WarnfAt(n.Pos(), "append: len-only update")
                                }
                                s.append(rhs, true)
                                return
                        }
                }
 
-               if n.Left.isBlank() {
+               if ir.IsBlank(n.X) {
                        // _ = rhs
                        // Just evaluate rhs for side-effects.
                        if rhs != nil {
@@ -1309,14 +1477,14 @@ func (s *state) stmt(n *Node) {
                }
 
                var t *types.Type
-               if n.Right != nil {
-                       t = n.Right.Type
+               if n.Y != nil {
+                       t = n.Y.Type()
                } else {
-                       t = n.Left.Type
+                       t = n.X.Type()
                }
 
                var r *ssa.Value
-               deref := !canSSAType(t)
+               deref := !TypeOK(t)
                if deref {
                        if rhs == nil {
                                r = nil // Signal assign to use OpZero.
@@ -1332,11 +1500,12 @@ func (s *state) stmt(n *Node) {
                }
 
                var skip skipMask
-               if rhs != nil && (rhs.Op == OSLICE || rhs.Op == OSLICE3 || rhs.Op == OSLICESTR) && samesafeexpr(rhs.Left, n.Left) {
+               if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && ir.SameSafeExpr(rhs.(*ir.SliceExpr).X, n.X) {
                        // We're assigning a slicing operation back to its source.
                        // Don't write back fields we aren't changing. See issue #14855.
-                       i, j, k := rhs.SliceBounds()
-                       if i != nil && (i.Op == OLITERAL && i.Val().Ctype() == CTINT && i.Int64Val() == 0) {
+                       rhs := rhs.(*ir.SliceExpr)
+                       i, j, k := rhs.Low, rhs.High, rhs.Max
+                       if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && ir.Int64Val(i) == 0) {
                                // [0:...] is the same as [:...]
                                i = nil
                        }
@@ -1344,10 +1513,10 @@ func (s *state) stmt(n *Node) {
                        // Currently doesn't really work because (*p)[:len(*p)] appears here as:
                        //    tmp = len(*p)
                        //    (*p)[:tmp]
-                       //if j != nil && (j.Op == OLEN && samesafeexpr(j.Left, n.Left)) {
+                       //if j != nil && (j.Op == OLEN && SameSafeExpr(j.Left, n.Left)) {
                        //      j = nil
                        //}
-                       //if k != nil && (k.Op == OCAP && samesafeexpr(k.Left, n.Left)) {
+                       //if k != nil && (k.Op == OCAP && SameSafeExpr(k.Left, n.Left)) {
                        //      k = nil
                        //}
                        if i == nil {
@@ -1361,83 +1530,86 @@ func (s *state) stmt(n *Node) {
                        }
                }
 
-               s.assign(n.Left, r, deref, skip)
+               s.assign(n.X, r, deref, skip)
 
-       case OIF:
-               if Isconst(n.Left, CTBOOL) {
-                       s.stmtList(n.Left.Ninit)
-                       if n.Left.BoolVal() {
-                               s.stmtList(n.Nbody)
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               if ir.IsConst(n.Cond, constant.Bool) {
+                       s.stmtList(n.Cond.Init())
+                       if ir.BoolVal(n.Cond) {
+                               s.stmtList(n.Body)
                        } else {
-                               s.stmtList(n.Rlist)
+                               s.stmtList(n.Else)
                        }
                        break
                }
 
                bEnd := s.f.NewBlock(ssa.BlockPlain)
                var likely int8
-               if n.Likely() {
+               if n.Likely {
                        likely = 1
                }
                var bThen *ssa.Block
-               if n.Nbody.Len() != 0 {
+               if len(n.Body) != 0 {
                        bThen = s.f.NewBlock(ssa.BlockPlain)
                } else {
                        bThen = bEnd
                }
                var bElse *ssa.Block
-               if n.Rlist.Len() != 0 {
+               if len(n.Else) != 0 {
                        bElse = s.f.NewBlock(ssa.BlockPlain)
                } else {
                        bElse = bEnd
                }
-               s.condBranch(n.Left, bThen, bElse, likely)
+               s.condBranch(n.Cond, bThen, bElse, likely)
 
-               if n.Nbody.Len() != 0 {
+               if len(n.Body) != 0 {
                        s.startBlock(bThen)
-                       s.stmtList(n.Nbody)
+                       s.stmtList(n.Body)
                        if b := s.endBlock(); b != nil {
                                b.AddEdgeTo(bEnd)
                        }
                }
-               if n.Rlist.Len() != 0 {
+               if len(n.Else) != 0 {
                        s.startBlock(bElse)
-                       s.stmtList(n.Rlist)
+                       s.stmtList(n.Else)
                        if b := s.endBlock(); b != nil {
                                b.AddEdgeTo(bEnd)
                        }
                }
                s.startBlock(bEnd)
 
-       case ORETURN:
-               s.stmtList(n.List)
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               s.stmtList(n.Results)
                b := s.exit()
                b.Pos = s.lastPos.WithIsStmt()
 
-       case ORETJMP:
-               s.stmtList(n.List)
+       case ir.OTAILCALL:
+               n := n.(*ir.TailCallStmt)
                b := s.exit()
                b.Kind = ssa.BlockRetJmp // override BlockRet
-               b.Aux = n.Sym.Linksym()
+               b.Aux = callTargetLSym(n.Target, s.curfn.LSym)
 
-       case OCONTINUE, OBREAK:
+       case ir.OCONTINUE, ir.OBREAK:
+               n := n.(*ir.BranchStmt)
                var to *ssa.Block
-               if n.Sym == nil {
+               if n.Label == nil {
                        // plain break/continue
-                       switch n.Op {
-                       case OCONTINUE:
+                       switch n.Op() {
+                       case ir.OCONTINUE:
                                to = s.continueTo
-                       case OBREAK:
+                       case ir.OBREAK:
                                to = s.breakTo
                        }
                } else {
                        // labeled break/continue; look up the target
-                       sym := n.Sym
+                       sym := n.Label
                        lab := s.label(sym)
-                       switch n.Op {
-                       case OCONTINUE:
+                       switch n.Op() {
+                       case ir.OCONTINUE:
                                to = lab.continueTarget
-                       case OBREAK:
+                       case ir.OBREAK:
                                to = lab.breakTarget
                        }
                }
@@ -1446,28 +1618,29 @@ func (s *state) stmt(n *Node) {
                b.Pos = s.lastPos.WithIsStmt() // Do this even if b is an empty block.
                b.AddEdgeTo(to)
 
-       case OFOR, OFORUNTIL:
+       case ir.OFOR, ir.OFORUNTIL:
                // OFOR: for Ninit; Left; Right { Nbody }
                // cond (Left); body (Nbody); incr (Right)
                //
                // OFORUNTIL: for Ninit; Left; Right; List { Nbody }
                // => body: { Nbody }; incr: Right; if Left { lateincr: List; goto body }; end:
+               n := n.(*ir.ForStmt)
                bCond := s.f.NewBlock(ssa.BlockPlain)
                bBody := s.f.NewBlock(ssa.BlockPlain)
                bIncr := s.f.NewBlock(ssa.BlockPlain)
                bEnd := s.f.NewBlock(ssa.BlockPlain)
 
                // ensure empty for loops have correct position; issue #30167
-               bBody.Pos = n.Pos
+               bBody.Pos = n.Pos()
 
                // first, jump to condition test (OFOR) or body (OFORUNTIL)
                b := s.endBlock()
-               if n.Op == OFOR {
+               if n.Op() == ir.OFOR {
                        b.AddEdgeTo(bCond)
                        // generate code to test condition
                        s.startBlock(bCond)
-                       if n.Left != nil {
-                               s.condBranch(n.Left, bBody, bEnd, 1)
+                       if n.Cond != nil {
+                               s.condBranch(n.Cond, bBody, bEnd, 1)
                        } else {
                                b := s.endBlock()
                                b.Kind = ssa.BlockPlain
@@ -1483,16 +1656,17 @@ func (s *state) stmt(n *Node) {
                prevBreak := s.breakTo
                s.continueTo = bIncr
                s.breakTo = bEnd
-               lab := s.labeledNodes[n]
-               if lab != nil {
+               var lab *ssaLabel
+               if sym := n.Label; sym != nil {
                        // labeled for loop
+                       lab = s.label(sym)
                        lab.continueTarget = bIncr
                        lab.breakTarget = bEnd
                }
 
                // generate body
                s.startBlock(bBody)
-               s.stmtList(n.Nbody)
+               s.stmtList(n.Body)
 
                // tear down continue/break
                s.continueTo = prevContinue
@@ -1509,15 +1683,15 @@ func (s *state) stmt(n *Node) {
 
                // generate incr (and, for OFORUNTIL, condition)
                s.startBlock(bIncr)
-               if n.Right != nil {
-                       s.stmt(n.Right)
+               if n.Post != nil {
+                       s.stmt(n.Post)
                }
-               if n.Op == OFOR {
+               if n.Op() == ir.OFOR {
                        if b := s.endBlock(); b != nil {
                                b.AddEdgeTo(bCond)
                                // It can happen that bIncr ends in a block containing only VARKILL,
                                // and that muddles the debugging experience.
-                               if n.Op != OFORUNTIL && b.Pos == src.NoXPos {
+                               if n.Op() != ir.OFORUNTIL && b.Pos == src.NoXPos {
                                        b.Pos = bCond.Pos
                                }
                        }
@@ -1525,30 +1699,43 @@ func (s *state) stmt(n *Node) {
                        // bCond is unused in OFORUNTIL, so repurpose it.
                        bLateIncr := bCond
                        // test condition
-                       s.condBranch(n.Left, bLateIncr, bEnd, 1)
+                       s.condBranch(n.Cond, bLateIncr, bEnd, 1)
                        // generate late increment
                        s.startBlock(bLateIncr)
-                       s.stmtList(n.List)
+                       s.stmtList(n.Late)
                        s.endBlock().AddEdgeTo(bBody)
                }
 
                s.startBlock(bEnd)
 
-       case OSWITCH, OSELECT:
+       case ir.OSWITCH, ir.OSELECT:
                // These have been mostly rewritten by the front end into their Nbody fields.
                // Our main task is to correctly hook up any break statements.
                bEnd := s.f.NewBlock(ssa.BlockPlain)
 
                prevBreak := s.breakTo
                s.breakTo = bEnd
-               lab := s.labeledNodes[n]
-               if lab != nil {
+               var sym *types.Sym
+               var body ir.Nodes
+               if n.Op() == ir.OSWITCH {
+                       n := n.(*ir.SwitchStmt)
+                       sym = n.Label
+                       body = n.Compiled
+               } else {
+                       n := n.(*ir.SelectStmt)
+                       sym = n.Label
+                       body = n.Compiled
+               }
+
+               var lab *ssaLabel
+               if sym != nil {
                        // labeled
+                       lab = s.label(sym)
                        lab.breakTarget = bEnd
                }
 
                // generate body code
-               s.stmtList(n.Nbody)
+               s.stmtList(body)
 
                s.breakTo = prevBreak
                if lab != nil {
@@ -1565,40 +1752,46 @@ func (s *state) stmt(n *Node) {
                }
                s.startBlock(bEnd)
 
-       case OVARDEF:
-               if !s.canSSA(n.Left) {
-                       s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left, s.mem(), false)
+       case ir.OVARDEF:
+               n := n.(*ir.UnaryExpr)
+               if !s.canSSA(n.X) {
+                       s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.X.(*ir.Name), s.mem(), false)
                }
-       case OVARKILL:
+       case ir.OVARKILL:
                // Insert a varkill op to record that a variable is no longer live.
                // We only care about liveness info at call sites, so putting the
                // varkill in the store chain is enough to keep it correctly ordered
                // with respect to call ops.
-               if !s.canSSA(n.Left) {
-                       s.vars[&memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left, s.mem(), false)
+               n := n.(*ir.UnaryExpr)
+               if !s.canSSA(n.X) {
+                       s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.X.(*ir.Name), s.mem(), false)
                }
 
-       case OVARLIVE:
+       case ir.OVARLIVE:
                // Insert a varlive op to record that a variable is still live.
-               if !n.Left.Name.Addrtaken() {
-                       s.Fatalf("VARLIVE variable %v must have Addrtaken set", n.Left)
+               n := n.(*ir.UnaryExpr)
+               v := n.X.(*ir.Name)
+               if !v.Addrtaken() {
+                       s.Fatalf("VARLIVE variable %v must have Addrtaken set", v)
                }
-               switch n.Left.Class() {
-               case PAUTO, PPARAM, PPARAMOUT:
+               switch v.Class {
+               case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
                default:
-                       s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left)
+                       s.Fatalf("VARLIVE variable %v must be Auto or Arg", v)
                }
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left, s.mem())
+               s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, v, s.mem())
 
-       case OCHECKNIL:
-               p := s.expr(n.Left)
+       case ir.OCHECKNIL:
+               n := n.(*ir.UnaryExpr)
+               p := s.expr(n.X)
                s.nilCheck(p)
 
-       case OINLMARK:
-               s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Xoffset, s.mem())
+       case ir.OINLMARK:
+               n := n.(*ir.InlineMarkStmt)
+               s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Index, s.mem())
 
        default:
-               s.Fatalf("unhandled stmt %v", n.Op)
+               s.Fatalf("unhandled stmt %v", n.Op())
        }
 }
 
@@ -1610,6 +1803,7 @@ const shareDeferExits = false
 // It returns a BlockRet block that ends the control flow. Its control value
 // will be set to the final memory state.
 func (s *state) exit() *ssa.Block {
+       lateResultLowering := s.f.DebugTest
        if s.hasdefer {
                if s.hasOpenDefers {
                        if shareDeferExits && s.lastDeferExit != nil && len(s.openDefers) == s.lastDeferCount {
@@ -1622,28 +1816,65 @@ func (s *state) exit() *ssa.Block {
                        }
                        s.openDeferExit()
                } else {
-                       s.rtcall(Deferreturn, true, nil)
+                       s.rtcall(ir.Syms.Deferreturn, true, nil)
                }
        }
 
-       // Run exit code. Typically, this code copies heap-allocated PPARAMOUT
-       // variables back to the stack.
-       s.stmtList(s.curfn.Func.Exit)
+       var b *ssa.Block
+       var m *ssa.Value
+       // Do actual return.
+       // These currently turn into self-copies (in many cases).
+       if lateResultLowering {
+               resultFields := s.curfn.Type().Results().FieldSlice()
+               results := make([]*ssa.Value, len(resultFields)+1, len(resultFields)+1)
+               m = s.newValue0(ssa.OpMakeResult, s.f.OwnAux.LateExpansionResultType())
+               // Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+               for i, f := range resultFields {
+                       n := f.Nname.(*ir.Name)
+                       s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+                       if s.canSSA(n) { // result is in some SSA variable
+                               results[i] = s.variable(n, n.Type())
+                       } else if !n.OnStack() { // result is actually heap allocated
+                               ha := s.expr(n.Heapaddr)
+                               s.instrumentFields(n.Type(), ha, instrumentRead)
+                               results[i] = s.newValue2(ssa.OpDereference, n.Type(), ha, s.mem())
+                       } else { // result is not SSA-able; not escaped, so not on heap, but too large for SSA.
+                               // Before register ABI this ought to be a self-move, home=dest,
+                               // With register ABI, it's still a self-move if parameter is on stack (i.e., too big or overflowed)
+                               results[i] = s.newValue2(ssa.OpDereference, n.Type(), s.addr(n), s.mem())
+                       }
+               }
+
+               // Run exit code. Today, this is just racefuncexit, in -race mode.
+               // TODO this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
+               // Spills in register allocation might just fix it.
+               s.stmtList(s.curfn.Exit)
 
-       // Store SSAable PPARAMOUT variables back to stack locations.
-       for _, n := range s.returns {
-               addr := s.decladdrs[n]
-               val := s.variable(n, n.Type)
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-               s.store(n.Type, addr, val)
-               // TODO: if val is ever spilled, we'd like to use the
-               // PPARAMOUT slot for spilling it. That won't happen
-               // currently.
-       }
+               results[len(results)-1] = s.mem()
+               m.AddArgs(results...)
+       } else {
+               // Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+               for _, f := range s.curfn.Type().Results().FieldSlice() {
+                       n := f.Nname.(*ir.Name)
+                       if s.canSSA(n) {
+                               val := s.variable(n, n.Type())
+                               s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+                               s.store(n.Type(), s.decladdrs[n], val)
+                       } else if !n.OnStack() {
+                               s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+                               s.move(n.Type(), s.decladdrs[n], s.expr(n.Heapaddr))
+                       } // else, on stack but too large to SSA, the result is already in its destination by construction, so no store needed.
 
-       // Do actual return.
-       m := s.mem()
-       b := s.endBlock()
+                       // TODO: if (SSA) val is ever spilled, we'd like to use the PPARAMOUT slot for spilling it. That won't happen currently.
+               }
+
+               // Run exit code. Today, this is just racefuncexit, in -race mode.
+               s.stmtList(s.curfn.Exit)
+
+               // Do actual return.
+               m = s.mem()
+       }
+       b = s.endBlock()
        b.Kind = ssa.BlockRet
        b.SetControl(m)
        if s.hasdefer && s.hasOpenDefers {
@@ -1653,206 +1884,206 @@ func (s *state) exit() *ssa.Block {
 }
 
 type opAndType struct {
-       op    Op
-       etype types.EType
+       op    ir.Op
+       etype types.Kind
 }
 
 var opToSSA = map[opAndType]ssa.Op{
-       opAndType{OADD, TINT8}:    ssa.OpAdd8,
-       opAndType{OADD, TUINT8}:   ssa.OpAdd8,
-       opAndType{OADD, TINT16}:   ssa.OpAdd16,
-       opAndType{OADD, TUINT16}:  ssa.OpAdd16,
-       opAndType{OADD, TINT32}:   ssa.OpAdd32,
-       opAndType{OADD, TUINT32}:  ssa.OpAdd32,
-       opAndType{OADD, TINT64}:   ssa.OpAdd64,
-       opAndType{OADD, TUINT64}:  ssa.OpAdd64,
-       opAndType{OADD, TFLOAT32}: ssa.OpAdd32F,
-       opAndType{OADD, TFLOAT64}: ssa.OpAdd64F,
-
-       opAndType{OSUB, TINT8}:    ssa.OpSub8,
-       opAndType{OSUB, TUINT8}:   ssa.OpSub8,
-       opAndType{OSUB, TINT16}:   ssa.OpSub16,
-       opAndType{OSUB, TUINT16}:  ssa.OpSub16,
-       opAndType{OSUB, TINT32}:   ssa.OpSub32,
-       opAndType{OSUB, TUINT32}:  ssa.OpSub32,
-       opAndType{OSUB, TINT64}:   ssa.OpSub64,
-       opAndType{OSUB, TUINT64}:  ssa.OpSub64,
-       opAndType{OSUB, TFLOAT32}: ssa.OpSub32F,
-       opAndType{OSUB, TFLOAT64}: ssa.OpSub64F,
-
-       opAndType{ONOT, TBOOL}: ssa.OpNot,
-
-       opAndType{ONEG, TINT8}:    ssa.OpNeg8,
-       opAndType{ONEG, TUINT8}:   ssa.OpNeg8,
-       opAndType{ONEG, TINT16}:   ssa.OpNeg16,
-       opAndType{ONEG, TUINT16}:  ssa.OpNeg16,
-       opAndType{ONEG, TINT32}:   ssa.OpNeg32,
-       opAndType{ONEG, TUINT32}:  ssa.OpNeg32,
-       opAndType{ONEG, TINT64}:   ssa.OpNeg64,
-       opAndType{ONEG, TUINT64}:  ssa.OpNeg64,
-       opAndType{ONEG, TFLOAT32}: ssa.OpNeg32F,
-       opAndType{ONEG, TFLOAT64}: ssa.OpNeg64F,
-
-       opAndType{OBITNOT, TINT8}:   ssa.OpCom8,
-       opAndType{OBITNOT, TUINT8}:  ssa.OpCom8,
-       opAndType{OBITNOT, TINT16}:  ssa.OpCom16,
-       opAndType{OBITNOT, TUINT16}: ssa.OpCom16,
-       opAndType{OBITNOT, TINT32}:  ssa.OpCom32,
-       opAndType{OBITNOT, TUINT32}: ssa.OpCom32,
-       opAndType{OBITNOT, TINT64}:  ssa.OpCom64,
-       opAndType{OBITNOT, TUINT64}: ssa.OpCom64,
-
-       opAndType{OIMAG, TCOMPLEX64}:  ssa.OpComplexImag,
-       opAndType{OIMAG, TCOMPLEX128}: ssa.OpComplexImag,
-       opAndType{OREAL, TCOMPLEX64}:  ssa.OpComplexReal,
-       opAndType{OREAL, TCOMPLEX128}: ssa.OpComplexReal,
-
-       opAndType{OMUL, TINT8}:    ssa.OpMul8,
-       opAndType{OMUL, TUINT8}:   ssa.OpMul8,
-       opAndType{OMUL, TINT16}:   ssa.OpMul16,
-       opAndType{OMUL, TUINT16}:  ssa.OpMul16,
-       opAndType{OMUL, TINT32}:   ssa.OpMul32,
-       opAndType{OMUL, TUINT32}:  ssa.OpMul32,
-       opAndType{OMUL, TINT64}:   ssa.OpMul64,
-       opAndType{OMUL, TUINT64}:  ssa.OpMul64,
-       opAndType{OMUL, TFLOAT32}: ssa.OpMul32F,
-       opAndType{OMUL, TFLOAT64}: ssa.OpMul64F,
-
-       opAndType{ODIV, TFLOAT32}: ssa.OpDiv32F,
-       opAndType{ODIV, TFLOAT64}: ssa.OpDiv64F,
-
-       opAndType{ODIV, TINT8}:   ssa.OpDiv8,
-       opAndType{ODIV, TUINT8}:  ssa.OpDiv8u,
-       opAndType{ODIV, TINT16}:  ssa.OpDiv16,
-       opAndType{ODIV, TUINT16}: ssa.OpDiv16u,
-       opAndType{ODIV, TINT32}:  ssa.OpDiv32,
-       opAndType{ODIV, TUINT32}: ssa.OpDiv32u,
-       opAndType{ODIV, TINT64}:  ssa.OpDiv64,
-       opAndType{ODIV, TUINT64}: ssa.OpDiv64u,
-
-       opAndType{OMOD, TINT8}:   ssa.OpMod8,
-       opAndType{OMOD, TUINT8}:  ssa.OpMod8u,
-       opAndType{OMOD, TINT16}:  ssa.OpMod16,
-       opAndType{OMOD, TUINT16}: ssa.OpMod16u,
-       opAndType{OMOD, TINT32}:  ssa.OpMod32,
-       opAndType{OMOD, TUINT32}: ssa.OpMod32u,
-       opAndType{OMOD, TINT64}:  ssa.OpMod64,
-       opAndType{OMOD, TUINT64}: ssa.OpMod64u,
-
-       opAndType{OAND, TINT8}:   ssa.OpAnd8,
-       opAndType{OAND, TUINT8}:  ssa.OpAnd8,
-       opAndType{OAND, TINT16}:  ssa.OpAnd16,
-       opAndType{OAND, TUINT16}: ssa.OpAnd16,
-       opAndType{OAND, TINT32}:  ssa.OpAnd32,
-       opAndType{OAND, TUINT32}: ssa.OpAnd32,
-       opAndType{OAND, TINT64}:  ssa.OpAnd64,
-       opAndType{OAND, TUINT64}: ssa.OpAnd64,
-
-       opAndType{OOR, TINT8}:   ssa.OpOr8,
-       opAndType{OOR, TUINT8}:  ssa.OpOr8,
-       opAndType{OOR, TINT16}:  ssa.OpOr16,
-       opAndType{OOR, TUINT16}: ssa.OpOr16,
-       opAndType{OOR, TINT32}:  ssa.OpOr32,
-       opAndType{OOR, TUINT32}: ssa.OpOr32,
-       opAndType{OOR, TINT64}:  ssa.OpOr64,
-       opAndType{OOR, TUINT64}: ssa.OpOr64,
-
-       opAndType{OXOR, TINT8}:   ssa.OpXor8,
-       opAndType{OXOR, TUINT8}:  ssa.OpXor8,
-       opAndType{OXOR, TINT16}:  ssa.OpXor16,
-       opAndType{OXOR, TUINT16}: ssa.OpXor16,
-       opAndType{OXOR, TINT32}:  ssa.OpXor32,
-       opAndType{OXOR, TUINT32}: ssa.OpXor32,
-       opAndType{OXOR, TINT64}:  ssa.OpXor64,
-       opAndType{OXOR, TUINT64}: ssa.OpXor64,
-
-       opAndType{OEQ, TBOOL}:      ssa.OpEqB,
-       opAndType{OEQ, TINT8}:      ssa.OpEq8,
-       opAndType{OEQ, TUINT8}:     ssa.OpEq8,
-       opAndType{OEQ, TINT16}:     ssa.OpEq16,
-       opAndType{OEQ, TUINT16}:    ssa.OpEq16,
-       opAndType{OEQ, TINT32}:     ssa.OpEq32,
-       opAndType{OEQ, TUINT32}:    ssa.OpEq32,
-       opAndType{OEQ, TINT64}:     ssa.OpEq64,
-       opAndType{OEQ, TUINT64}:    ssa.OpEq64,
-       opAndType{OEQ, TINTER}:     ssa.OpEqInter,
-       opAndType{OEQ, TSLICE}:     ssa.OpEqSlice,
-       opAndType{OEQ, TFUNC}:      ssa.OpEqPtr,
-       opAndType{OEQ, TMAP}:       ssa.OpEqPtr,
-       opAndType{OEQ, TCHAN}:      ssa.OpEqPtr,
-       opAndType{OEQ, TPTR}:       ssa.OpEqPtr,
-       opAndType{OEQ, TUINTPTR}:   ssa.OpEqPtr,
-       opAndType{OEQ, TUNSAFEPTR}: ssa.OpEqPtr,
-       opAndType{OEQ, TFLOAT64}:   ssa.OpEq64F,
-       opAndType{OEQ, TFLOAT32}:   ssa.OpEq32F,
-
-       opAndType{ONE, TBOOL}:      ssa.OpNeqB,
-       opAndType{ONE, TINT8}:      ssa.OpNeq8,
-       opAndType{ONE, TUINT8}:     ssa.OpNeq8,
-       opAndType{ONE, TINT16}:     ssa.OpNeq16,
-       opAndType{ONE, TUINT16}:    ssa.OpNeq16,
-       opAndType{ONE, TINT32}:     ssa.OpNeq32,
-       opAndType{ONE, TUINT32}:    ssa.OpNeq32,
-       opAndType{ONE, TINT64}:     ssa.OpNeq64,
-       opAndType{ONE, TUINT64}:    ssa.OpNeq64,
-       opAndType{ONE, TINTER}:     ssa.OpNeqInter,
-       opAndType{ONE, TSLICE}:     ssa.OpNeqSlice,
-       opAndType{ONE, TFUNC}:      ssa.OpNeqPtr,
-       opAndType{ONE, TMAP}:       ssa.OpNeqPtr,
-       opAndType{ONE, TCHAN}:      ssa.OpNeqPtr,
-       opAndType{ONE, TPTR}:       ssa.OpNeqPtr,
-       opAndType{ONE, TUINTPTR}:   ssa.OpNeqPtr,
-       opAndType{ONE, TUNSAFEPTR}: ssa.OpNeqPtr,
-       opAndType{ONE, TFLOAT64}:   ssa.OpNeq64F,
-       opAndType{ONE, TFLOAT32}:   ssa.OpNeq32F,
-
-       opAndType{OLT, TINT8}:    ssa.OpLess8,
-       opAndType{OLT, TUINT8}:   ssa.OpLess8U,
-       opAndType{OLT, TINT16}:   ssa.OpLess16,
-       opAndType{OLT, TUINT16}:  ssa.OpLess16U,
-       opAndType{OLT, TINT32}:   ssa.OpLess32,
-       opAndType{OLT, TUINT32}:  ssa.OpLess32U,
-       opAndType{OLT, TINT64}:   ssa.OpLess64,
-       opAndType{OLT, TUINT64}:  ssa.OpLess64U,
-       opAndType{OLT, TFLOAT64}: ssa.OpLess64F,
-       opAndType{OLT, TFLOAT32}: ssa.OpLess32F,
-
-       opAndType{OLE, TINT8}:    ssa.OpLeq8,
-       opAndType{OLE, TUINT8}:   ssa.OpLeq8U,
-       opAndType{OLE, TINT16}:   ssa.OpLeq16,
-       opAndType{OLE, TUINT16}:  ssa.OpLeq16U,
-       opAndType{OLE, TINT32}:   ssa.OpLeq32,
-       opAndType{OLE, TUINT32}:  ssa.OpLeq32U,
-       opAndType{OLE, TINT64}:   ssa.OpLeq64,
-       opAndType{OLE, TUINT64}:  ssa.OpLeq64U,
-       opAndType{OLE, TFLOAT64}: ssa.OpLeq64F,
-       opAndType{OLE, TFLOAT32}: ssa.OpLeq32F,
-}
-
-func (s *state) concreteEtype(t *types.Type) types.EType {
-       e := t.Etype
+       opAndType{ir.OADD, types.TINT8}:    ssa.OpAdd8,
+       opAndType{ir.OADD, types.TUINT8}:   ssa.OpAdd8,
+       opAndType{ir.OADD, types.TINT16}:   ssa.OpAdd16,
+       opAndType{ir.OADD, types.TUINT16}:  ssa.OpAdd16,
+       opAndType{ir.OADD, types.TINT32}:   ssa.OpAdd32,
+       opAndType{ir.OADD, types.TUINT32}:  ssa.OpAdd32,
+       opAndType{ir.OADD, types.TINT64}:   ssa.OpAdd64,
+       opAndType{ir.OADD, types.TUINT64}:  ssa.OpAdd64,
+       opAndType{ir.OADD, types.TFLOAT32}: ssa.OpAdd32F,
+       opAndType{ir.OADD, types.TFLOAT64}: ssa.OpAdd64F,
+
+       opAndType{ir.OSUB, types.TINT8}:    ssa.OpSub8,
+       opAndType{ir.OSUB, types.TUINT8}:   ssa.OpSub8,
+       opAndType{ir.OSUB, types.TINT16}:   ssa.OpSub16,
+       opAndType{ir.OSUB, types.TUINT16}:  ssa.OpSub16,
+       opAndType{ir.OSUB, types.TINT32}:   ssa.OpSub32,
+       opAndType{ir.OSUB, types.TUINT32}:  ssa.OpSub32,
+       opAndType{ir.OSUB, types.TINT64}:   ssa.OpSub64,
+       opAndType{ir.OSUB, types.TUINT64}:  ssa.OpSub64,
+       opAndType{ir.OSUB, types.TFLOAT32}: ssa.OpSub32F,
+       opAndType{ir.OSUB, types.TFLOAT64}: ssa.OpSub64F,
+
+       opAndType{ir.ONOT, types.TBOOL}: ssa.OpNot,
+
+       opAndType{ir.ONEG, types.TINT8}:    ssa.OpNeg8,
+       opAndType{ir.ONEG, types.TUINT8}:   ssa.OpNeg8,
+       opAndType{ir.ONEG, types.TINT16}:   ssa.OpNeg16,
+       opAndType{ir.ONEG, types.TUINT16}:  ssa.OpNeg16,
+       opAndType{ir.ONEG, types.TINT32}:   ssa.OpNeg32,
+       opAndType{ir.ONEG, types.TUINT32}:  ssa.OpNeg32,
+       opAndType{ir.ONEG, types.TINT64}:   ssa.OpNeg64,
+       opAndType{ir.ONEG, types.TUINT64}:  ssa.OpNeg64,
+       opAndType{ir.ONEG, types.TFLOAT32}: ssa.OpNeg32F,
+       opAndType{ir.ONEG, types.TFLOAT64}: ssa.OpNeg64F,
+
+       opAndType{ir.OBITNOT, types.TINT8}:   ssa.OpCom8,
+       opAndType{ir.OBITNOT, types.TUINT8}:  ssa.OpCom8,
+       opAndType{ir.OBITNOT, types.TINT16}:  ssa.OpCom16,
+       opAndType{ir.OBITNOT, types.TUINT16}: ssa.OpCom16,
+       opAndType{ir.OBITNOT, types.TINT32}:  ssa.OpCom32,
+       opAndType{ir.OBITNOT, types.TUINT32}: ssa.OpCom32,
+       opAndType{ir.OBITNOT, types.TINT64}:  ssa.OpCom64,
+       opAndType{ir.OBITNOT, types.TUINT64}: ssa.OpCom64,
+
+       opAndType{ir.OIMAG, types.TCOMPLEX64}:  ssa.OpComplexImag,
+       opAndType{ir.OIMAG, types.TCOMPLEX128}: ssa.OpComplexImag,
+       opAndType{ir.OREAL, types.TCOMPLEX64}:  ssa.OpComplexReal,
+       opAndType{ir.OREAL, types.TCOMPLEX128}: ssa.OpComplexReal,
+
+       opAndType{ir.OMUL, types.TINT8}:    ssa.OpMul8,
+       opAndType{ir.OMUL, types.TUINT8}:   ssa.OpMul8,
+       opAndType{ir.OMUL, types.TINT16}:   ssa.OpMul16,
+       opAndType{ir.OMUL, types.TUINT16}:  ssa.OpMul16,
+       opAndType{ir.OMUL, types.TINT32}:   ssa.OpMul32,
+       opAndType{ir.OMUL, types.TUINT32}:  ssa.OpMul32,
+       opAndType{ir.OMUL, types.TINT64}:   ssa.OpMul64,
+       opAndType{ir.OMUL, types.TUINT64}:  ssa.OpMul64,
+       opAndType{ir.OMUL, types.TFLOAT32}: ssa.OpMul32F,
+       opAndType{ir.OMUL, types.TFLOAT64}: ssa.OpMul64F,
+
+       opAndType{ir.ODIV, types.TFLOAT32}: ssa.OpDiv32F,
+       opAndType{ir.ODIV, types.TFLOAT64}: ssa.OpDiv64F,
+
+       opAndType{ir.ODIV, types.TINT8}:   ssa.OpDiv8,
+       opAndType{ir.ODIV, types.TUINT8}:  ssa.OpDiv8u,
+       opAndType{ir.ODIV, types.TINT16}:  ssa.OpDiv16,
+       opAndType{ir.ODIV, types.TUINT16}: ssa.OpDiv16u,
+       opAndType{ir.ODIV, types.TINT32}:  ssa.OpDiv32,
+       opAndType{ir.ODIV, types.TUINT32}: ssa.OpDiv32u,
+       opAndType{ir.ODIV, types.TINT64}:  ssa.OpDiv64,
+       opAndType{ir.ODIV, types.TUINT64}: ssa.OpDiv64u,
+
+       opAndType{ir.OMOD, types.TINT8}:   ssa.OpMod8,
+       opAndType{ir.OMOD, types.TUINT8}:  ssa.OpMod8u,
+       opAndType{ir.OMOD, types.TINT16}:  ssa.OpMod16,
+       opAndType{ir.OMOD, types.TUINT16}: ssa.OpMod16u,
+       opAndType{ir.OMOD, types.TINT32}:  ssa.OpMod32,
+       opAndType{ir.OMOD, types.TUINT32}: ssa.OpMod32u,
+       opAndType{ir.OMOD, types.TINT64}:  ssa.OpMod64,
+       opAndType{ir.OMOD, types.TUINT64}: ssa.OpMod64u,
+
+       opAndType{ir.OAND, types.TINT8}:   ssa.OpAnd8,
+       opAndType{ir.OAND, types.TUINT8}:  ssa.OpAnd8,
+       opAndType{ir.OAND, types.TINT16}:  ssa.OpAnd16,
+       opAndType{ir.OAND, types.TUINT16}: ssa.OpAnd16,
+       opAndType{ir.OAND, types.TINT32}:  ssa.OpAnd32,
+       opAndType{ir.OAND, types.TUINT32}: ssa.OpAnd32,
+       opAndType{ir.OAND, types.TINT64}:  ssa.OpAnd64,
+       opAndType{ir.OAND, types.TUINT64}: ssa.OpAnd64,
+
+       opAndType{ir.OOR, types.TINT8}:   ssa.OpOr8,
+       opAndType{ir.OOR, types.TUINT8}:  ssa.OpOr8,
+       opAndType{ir.OOR, types.TINT16}:  ssa.OpOr16,
+       opAndType{ir.OOR, types.TUINT16}: ssa.OpOr16,
+       opAndType{ir.OOR, types.TINT32}:  ssa.OpOr32,
+       opAndType{ir.OOR, types.TUINT32}: ssa.OpOr32,
+       opAndType{ir.OOR, types.TINT64}:  ssa.OpOr64,
+       opAndType{ir.OOR, types.TUINT64}: ssa.OpOr64,
+
+       opAndType{ir.OXOR, types.TINT8}:   ssa.OpXor8,
+       opAndType{ir.OXOR, types.TUINT8}:  ssa.OpXor8,
+       opAndType{ir.OXOR, types.TINT16}:  ssa.OpXor16,
+       opAndType{ir.OXOR, types.TUINT16}: ssa.OpXor16,
+       opAndType{ir.OXOR, types.TINT32}:  ssa.OpXor32,
+       opAndType{ir.OXOR, types.TUINT32}: ssa.OpXor32,
+       opAndType{ir.OXOR, types.TINT64}:  ssa.OpXor64,
+       opAndType{ir.OXOR, types.TUINT64}: ssa.OpXor64,
+
+       opAndType{ir.OEQ, types.TBOOL}:      ssa.OpEqB,
+       opAndType{ir.OEQ, types.TINT8}:      ssa.OpEq8,
+       opAndType{ir.OEQ, types.TUINT8}:     ssa.OpEq8,
+       opAndType{ir.OEQ, types.TINT16}:     ssa.OpEq16,
+       opAndType{ir.OEQ, types.TUINT16}:    ssa.OpEq16,
+       opAndType{ir.OEQ, types.TINT32}:     ssa.OpEq32,
+       opAndType{ir.OEQ, types.TUINT32}:    ssa.OpEq32,
+       opAndType{ir.OEQ, types.TINT64}:     ssa.OpEq64,
+       opAndType{ir.OEQ, types.TUINT64}:    ssa.OpEq64,
+       opAndType{ir.OEQ, types.TINTER}:     ssa.OpEqInter,
+       opAndType{ir.OEQ, types.TSLICE}:     ssa.OpEqSlice,
+       opAndType{ir.OEQ, types.TFUNC}:      ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TMAP}:       ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TCHAN}:      ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TPTR}:       ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TUINTPTR}:   ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TUNSAFEPTR}: ssa.OpEqPtr,
+       opAndType{ir.OEQ, types.TFLOAT64}:   ssa.OpEq64F,
+       opAndType{ir.OEQ, types.TFLOAT32}:   ssa.OpEq32F,
+
+       opAndType{ir.ONE, types.TBOOL}:      ssa.OpNeqB,
+       opAndType{ir.ONE, types.TINT8}:      ssa.OpNeq8,
+       opAndType{ir.ONE, types.TUINT8}:     ssa.OpNeq8,
+       opAndType{ir.ONE, types.TINT16}:     ssa.OpNeq16,
+       opAndType{ir.ONE, types.TUINT16}:    ssa.OpNeq16,
+       opAndType{ir.ONE, types.TINT32}:     ssa.OpNeq32,
+       opAndType{ir.ONE, types.TUINT32}:    ssa.OpNeq32,
+       opAndType{ir.ONE, types.TINT64}:     ssa.OpNeq64,
+       opAndType{ir.ONE, types.TUINT64}:    ssa.OpNeq64,
+       opAndType{ir.ONE, types.TINTER}:     ssa.OpNeqInter,
+       opAndType{ir.ONE, types.TSLICE}:     ssa.OpNeqSlice,
+       opAndType{ir.ONE, types.TFUNC}:      ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TMAP}:       ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TCHAN}:      ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TPTR}:       ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TUINTPTR}:   ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TUNSAFEPTR}: ssa.OpNeqPtr,
+       opAndType{ir.ONE, types.TFLOAT64}:   ssa.OpNeq64F,
+       opAndType{ir.ONE, types.TFLOAT32}:   ssa.OpNeq32F,
+
+       opAndType{ir.OLT, types.TINT8}:    ssa.OpLess8,
+       opAndType{ir.OLT, types.TUINT8}:   ssa.OpLess8U,
+       opAndType{ir.OLT, types.TINT16}:   ssa.OpLess16,
+       opAndType{ir.OLT, types.TUINT16}:  ssa.OpLess16U,
+       opAndType{ir.OLT, types.TINT32}:   ssa.OpLess32,
+       opAndType{ir.OLT, types.TUINT32}:  ssa.OpLess32U,
+       opAndType{ir.OLT, types.TINT64}:   ssa.OpLess64,
+       opAndType{ir.OLT, types.TUINT64}:  ssa.OpLess64U,
+       opAndType{ir.OLT, types.TFLOAT64}: ssa.OpLess64F,
+       opAndType{ir.OLT, types.TFLOAT32}: ssa.OpLess32F,
+
+       opAndType{ir.OLE, types.TINT8}:    ssa.OpLeq8,
+       opAndType{ir.OLE, types.TUINT8}:   ssa.OpLeq8U,
+       opAndType{ir.OLE, types.TINT16}:   ssa.OpLeq16,
+       opAndType{ir.OLE, types.TUINT16}:  ssa.OpLeq16U,
+       opAndType{ir.OLE, types.TINT32}:   ssa.OpLeq32,
+       opAndType{ir.OLE, types.TUINT32}:  ssa.OpLeq32U,
+       opAndType{ir.OLE, types.TINT64}:   ssa.OpLeq64,
+       opAndType{ir.OLE, types.TUINT64}:  ssa.OpLeq64U,
+       opAndType{ir.OLE, types.TFLOAT64}: ssa.OpLeq64F,
+       opAndType{ir.OLE, types.TFLOAT32}: ssa.OpLeq32F,
+}
+
+func (s *state) concreteEtype(t *types.Type) types.Kind {
+       e := t.Kind()
        switch e {
        default:
                return e
-       case TINT:
+       case types.TINT:
                if s.config.PtrSize == 8 {
-                       return TINT64
+                       return types.TINT64
                }
-               return TINT32
-       case TUINT:
+               return types.TINT32
+       case types.TUINT:
                if s.config.PtrSize == 8 {
-                       return TUINT64
+                       return types.TUINT64
                }
-               return TUINT32
-       case TUINTPTR:
+               return types.TUINT32
+       case types.TUINTPTR:
                if s.config.PtrSize == 8 {
-                       return TUINT64
+                       return types.TUINT64
                }
-               return TUINT32
+               return types.TUINT32
        }
 }
 
-func (s *state) ssaOp(op Op, t *types.Type) ssa.Op {
+func (s *state) ssaOp(op ir.Op, t *types.Type) ssa.Op {
        etype := s.concreteEtype(t)
        x, ok := opToSSA[opAndType{op, etype}]
        if !ok {
@@ -1861,186 +2092,164 @@ func (s *state) ssaOp(op Op, t *types.Type) ssa.Op {
        return x
 }
 
-func floatForComplex(t *types.Type) *types.Type {
-       switch t.Etype {
-       case TCOMPLEX64:
-               return types.Types[TFLOAT32]
-       case TCOMPLEX128:
-               return types.Types[TFLOAT64]
-       }
-       Fatalf("unexpected type: %v", t)
-       return nil
-}
-
-func complexForFloat(t *types.Type) *types.Type {
-       switch t.Etype {
-       case TFLOAT32:
-               return types.Types[TCOMPLEX64]
-       case TFLOAT64:
-               return types.Types[TCOMPLEX128]
-       }
-       Fatalf("unexpected type: %v", t)
-       return nil
-}
-
 type opAndTwoTypes struct {
-       op     Op
-       etype1 types.EType
-       etype2 types.EType
+       op     ir.Op
+       etype1 types.Kind
+       etype2 types.Kind
 }
 
 type twoTypes struct {
-       etype1 types.EType
-       etype2 types.EType
+       etype1 types.Kind
+       etype2 types.Kind
 }
 
 type twoOpsAndType struct {
        op1              ssa.Op
        op2              ssa.Op
-       intermediateType types.EType
+       intermediateType types.Kind
 }
 
 var fpConvOpToSSA = map[twoTypes]twoOpsAndType{
 
-       twoTypes{TINT8, TFLOAT32}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to32F, TINT32},
-       twoTypes{TINT16, TFLOAT32}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to32F, TINT32},
-       twoTypes{TINT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to32F, TINT32},
-       twoTypes{TINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to32F, TINT64},
-
-       twoTypes{TINT8, TFLOAT64}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to64F, TINT32},
-       twoTypes{TINT16, TFLOAT64}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to64F, TINT32},
-       twoTypes{TINT32, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to64F, TINT32},
-       twoTypes{TINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to64F, TINT64},
-
-       twoTypes{TFLOAT32, TINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
-       twoTypes{TFLOAT32, TINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
-       twoTypes{TFLOAT32, TINT32}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpCopy, TINT32},
-       twoTypes{TFLOAT32, TINT64}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpCopy, TINT64},
-
-       twoTypes{TFLOAT64, TINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
-       twoTypes{TFLOAT64, TINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
-       twoTypes{TFLOAT64, TINT32}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpCopy, TINT32},
-       twoTypes{TFLOAT64, TINT64}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpCopy, TINT64},
+       twoTypes{types.TINT8, types.TFLOAT32}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to32F, types.TINT32},
+       twoTypes{types.TINT16, types.TFLOAT32}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to32F, types.TINT32},
+       twoTypes{types.TINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to32F, types.TINT32},
+       twoTypes{types.TINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to32F, types.TINT64},
+
+       twoTypes{types.TINT8, types.TFLOAT64}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to64F, types.TINT32},
+       twoTypes{types.TINT16, types.TFLOAT64}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to64F, types.TINT32},
+       twoTypes{types.TINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to64F, types.TINT32},
+       twoTypes{types.TINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to64F, types.TINT64},
+
+       twoTypes{types.TFLOAT32, types.TINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, types.TINT32},
+       twoTypes{types.TFLOAT32, types.TINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, types.TINT32},
+       twoTypes{types.TFLOAT32, types.TINT32}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpCopy, types.TINT32},
+       twoTypes{types.TFLOAT32, types.TINT64}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpCopy, types.TINT64},
+
+       twoTypes{types.TFLOAT64, types.TINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, types.TINT32},
+       twoTypes{types.TFLOAT64, types.TINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, types.TINT32},
+       twoTypes{types.TFLOAT64, types.TINT32}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpCopy, types.TINT32},
+       twoTypes{types.TFLOAT64, types.TINT64}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpCopy, types.TINT64},
        // unsigned
-       twoTypes{TUINT8, TFLOAT32}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to32F, TINT32},
-       twoTypes{TUINT16, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to32F, TINT32},
-       twoTypes{TUINT32, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to32F, TINT64}, // go wide to dodge unsigned
-       twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64},            // Cvt64Uto32F, branchy code expansion instead
-
-       twoTypes{TUINT8, TFLOAT64}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to64F, TINT32},
-       twoTypes{TUINT16, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to64F, TINT32},
-       twoTypes{TUINT32, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to64F, TINT64}, // go wide to dodge unsigned
-       twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64},            // Cvt64Uto64F, branchy code expansion instead
-
-       twoTypes{TFLOAT32, TUINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
-       twoTypes{TFLOAT32, TUINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
-       twoTypes{TFLOAT32, TUINT32}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
-       twoTypes{TFLOAT32, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64},          // Cvt32Fto64U, branchy code expansion instead
-
-       twoTypes{TFLOAT64, TUINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
-       twoTypes{TFLOAT64, TUINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
-       twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
-       twoTypes{TFLOAT64, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64},          // Cvt64Fto64U, branchy code expansion instead
+       twoTypes{types.TUINT8, types.TFLOAT32}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to32F, types.TINT32},
+       twoTypes{types.TUINT16, types.TFLOAT32}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to32F, types.TINT32},
+       twoTypes{types.TUINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to32F, types.TINT64}, // go wide to dodge unsigned
+       twoTypes{types.TUINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, types.TUINT64},            // Cvt64Uto32F, branchy code expansion instead
+
+       twoTypes{types.TUINT8, types.TFLOAT64}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to64F, types.TINT32},
+       twoTypes{types.TUINT16, types.TFLOAT64}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to64F, types.TINT32},
+       twoTypes{types.TUINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to64F, types.TINT64}, // go wide to dodge unsigned
+       twoTypes{types.TUINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, types.TUINT64},            // Cvt64Uto64F, branchy code expansion instead
+
+       twoTypes{types.TFLOAT32, types.TUINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, types.TINT32},
+       twoTypes{types.TFLOAT32, types.TUINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, types.TINT32},
+       twoTypes{types.TFLOAT32, types.TUINT32}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpTrunc64to32, types.TINT64}, // go wide to dodge unsigned
+       twoTypes{types.TFLOAT32, types.TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, types.TUINT64},          // Cvt32Fto64U, branchy code expansion instead
+
+       twoTypes{types.TFLOAT64, types.TUINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, types.TINT32},
+       twoTypes{types.TFLOAT64, types.TUINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, types.TINT32},
+       twoTypes{types.TFLOAT64, types.TUINT32}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpTrunc64to32, types.TINT64}, // go wide to dodge unsigned
+       twoTypes{types.TFLOAT64, types.TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, types.TUINT64},          // Cvt64Fto64U, branchy code expansion instead
 
        // float
-       twoTypes{TFLOAT64, TFLOAT32}: twoOpsAndType{ssa.OpCvt64Fto32F, ssa.OpCopy, TFLOAT32},
-       twoTypes{TFLOAT64, TFLOAT64}: twoOpsAndType{ssa.OpRound64F, ssa.OpCopy, TFLOAT64},
-       twoTypes{TFLOAT32, TFLOAT32}: twoOpsAndType{ssa.OpRound32F, ssa.OpCopy, TFLOAT32},
-       twoTypes{TFLOAT32, TFLOAT64}: twoOpsAndType{ssa.OpCvt32Fto64F, ssa.OpCopy, TFLOAT64},
+       twoTypes{types.TFLOAT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCvt64Fto32F, ssa.OpCopy, types.TFLOAT32},
+       twoTypes{types.TFLOAT64, types.TFLOAT64}: twoOpsAndType{ssa.OpRound64F, ssa.OpCopy, types.TFLOAT64},
+       twoTypes{types.TFLOAT32, types.TFLOAT32}: twoOpsAndType{ssa.OpRound32F, ssa.OpCopy, types.TFLOAT32},
+       twoTypes{types.TFLOAT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCvt32Fto64F, ssa.OpCopy, types.TFLOAT64},
 }
 
 // this map is used only for 32-bit arch, and only includes the difference
 // on 32-bit arch, don't use int64<->float conversion for uint32
 var fpConvOpToSSA32 = map[twoTypes]twoOpsAndType{
-       twoTypes{TUINT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto32F, TUINT32},
-       twoTypes{TUINT32, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto64F, TUINT32},
-       twoTypes{TFLOAT32, TUINT32}: twoOpsAndType{ssa.OpCvt32Fto32U, ssa.OpCopy, TUINT32},
-       twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto32U, ssa.OpCopy, TUINT32},
+       twoTypes{types.TUINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto32F, types.TUINT32},
+       twoTypes{types.TUINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto64F, types.TUINT32},
+       twoTypes{types.TFLOAT32, types.TUINT32}: twoOpsAndType{ssa.OpCvt32Fto32U, ssa.OpCopy, types.TUINT32},
+       twoTypes{types.TFLOAT64, types.TUINT32}: twoOpsAndType{ssa.OpCvt64Fto32U, ssa.OpCopy, types.TUINT32},
 }
 
 // uint64<->float conversions, only on machines that have instructions for that
 var uint64fpConvOpToSSA = map[twoTypes]twoOpsAndType{
-       twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto32F, TUINT64},
-       twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto64F, TUINT64},
-       twoTypes{TFLOAT32, TUINT64}: twoOpsAndType{ssa.OpCvt32Fto64U, ssa.OpCopy, TUINT64},
-       twoTypes{TFLOAT64, TUINT64}: twoOpsAndType{ssa.OpCvt64Fto64U, ssa.OpCopy, TUINT64},
+       twoTypes{types.TUINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto32F, types.TUINT64},
+       twoTypes{types.TUINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto64F, types.TUINT64},
+       twoTypes{types.TFLOAT32, types.TUINT64}: twoOpsAndType{ssa.OpCvt32Fto64U, ssa.OpCopy, types.TUINT64},
+       twoTypes{types.TFLOAT64, types.TUINT64}: twoOpsAndType{ssa.OpCvt64Fto64U, ssa.OpCopy, types.TUINT64},
 }
 
 var shiftOpToSSA = map[opAndTwoTypes]ssa.Op{
-       opAndTwoTypes{OLSH, TINT8, TUINT8}:   ssa.OpLsh8x8,
-       opAndTwoTypes{OLSH, TUINT8, TUINT8}:  ssa.OpLsh8x8,
-       opAndTwoTypes{OLSH, TINT8, TUINT16}:  ssa.OpLsh8x16,
-       opAndTwoTypes{OLSH, TUINT8, TUINT16}: ssa.OpLsh8x16,
-       opAndTwoTypes{OLSH, TINT8, TUINT32}:  ssa.OpLsh8x32,
-       opAndTwoTypes{OLSH, TUINT8, TUINT32}: ssa.OpLsh8x32,
-       opAndTwoTypes{OLSH, TINT8, TUINT64}:  ssa.OpLsh8x64,
-       opAndTwoTypes{OLSH, TUINT8, TUINT64}: ssa.OpLsh8x64,
-
-       opAndTwoTypes{OLSH, TINT16, TUINT8}:   ssa.OpLsh16x8,
-       opAndTwoTypes{OLSH, TUINT16, TUINT8}:  ssa.OpLsh16x8,
-       opAndTwoTypes{OLSH, TINT16, TUINT16}:  ssa.OpLsh16x16,
-       opAndTwoTypes{OLSH, TUINT16, TUINT16}: ssa.OpLsh16x16,
-       opAndTwoTypes{OLSH, TINT16, TUINT32}:  ssa.OpLsh16x32,
-       opAndTwoTypes{OLSH, TUINT16, TUINT32}: ssa.OpLsh16x32,
-       opAndTwoTypes{OLSH, TINT16, TUINT64}:  ssa.OpLsh16x64,
-       opAndTwoTypes{OLSH, TUINT16, TUINT64}: ssa.OpLsh16x64,
-
-       opAndTwoTypes{OLSH, TINT32, TUINT8}:   ssa.OpLsh32x8,
-       opAndTwoTypes{OLSH, TUINT32, TUINT8}:  ssa.OpLsh32x8,
-       opAndTwoTypes{OLSH, TINT32, TUINT16}:  ssa.OpLsh32x16,
-       opAndTwoTypes{OLSH, TUINT32, TUINT16}: ssa.OpLsh32x16,
-       opAndTwoTypes{OLSH, TINT32, TUINT32}:  ssa.OpLsh32x32,
-       opAndTwoTypes{OLSH, TUINT32, TUINT32}: ssa.OpLsh32x32,
-       opAndTwoTypes{OLSH, TINT32, TUINT64}:  ssa.OpLsh32x64,
-       opAndTwoTypes{OLSH, TUINT32, TUINT64}: ssa.OpLsh32x64,
-
-       opAndTwoTypes{OLSH, TINT64, TUINT8}:   ssa.OpLsh64x8,
-       opAndTwoTypes{OLSH, TUINT64, TUINT8}:  ssa.OpLsh64x8,
-       opAndTwoTypes{OLSH, TINT64, TUINT16}:  ssa.OpLsh64x16,
-       opAndTwoTypes{OLSH, TUINT64, TUINT16}: ssa.OpLsh64x16,
-       opAndTwoTypes{OLSH, TINT64, TUINT32}:  ssa.OpLsh64x32,
-       opAndTwoTypes{OLSH, TUINT64, TUINT32}: ssa.OpLsh64x32,
-       opAndTwoTypes{OLSH, TINT64, TUINT64}:  ssa.OpLsh64x64,
-       opAndTwoTypes{OLSH, TUINT64, TUINT64}: ssa.OpLsh64x64,
-
-       opAndTwoTypes{ORSH, TINT8, TUINT8}:   ssa.OpRsh8x8,
-       opAndTwoTypes{ORSH, TUINT8, TUINT8}:  ssa.OpRsh8Ux8,
-       opAndTwoTypes{ORSH, TINT8, TUINT16}:  ssa.OpRsh8x16,
-       opAndTwoTypes{ORSH, TUINT8, TUINT16}: ssa.OpRsh8Ux16,
-       opAndTwoTypes{ORSH, TINT8, TUINT32}:  ssa.OpRsh8x32,
-       opAndTwoTypes{ORSH, TUINT8, TUINT32}: ssa.OpRsh8Ux32,
-       opAndTwoTypes{ORSH, TINT8, TUINT64}:  ssa.OpRsh8x64,
-       opAndTwoTypes{ORSH, TUINT8, TUINT64}: ssa.OpRsh8Ux64,
-
-       opAndTwoTypes{ORSH, TINT16, TUINT8}:   ssa.OpRsh16x8,
-       opAndTwoTypes{ORSH, TUINT16, TUINT8}:  ssa.OpRsh16Ux8,
-       opAndTwoTypes{ORSH, TINT16, TUINT16}:  ssa.OpRsh16x16,
-       opAndTwoTypes{ORSH, TUINT16, TUINT16}: ssa.OpRsh16Ux16,
-       opAndTwoTypes{ORSH, TINT16, TUINT32}:  ssa.OpRsh16x32,
-       opAndTwoTypes{ORSH, TUINT16, TUINT32}: ssa.OpRsh16Ux32,
-       opAndTwoTypes{ORSH, TINT16, TUINT64}:  ssa.OpRsh16x64,
-       opAndTwoTypes{ORSH, TUINT16, TUINT64}: ssa.OpRsh16Ux64,
-
-       opAndTwoTypes{ORSH, TINT32, TUINT8}:   ssa.OpRsh32x8,
-       opAndTwoTypes{ORSH, TUINT32, TUINT8}:  ssa.OpRsh32Ux8,
-       opAndTwoTypes{ORSH, TINT32, TUINT16}:  ssa.OpRsh32x16,
-       opAndTwoTypes{ORSH, TUINT32, TUINT16}: ssa.OpRsh32Ux16,
-       opAndTwoTypes{ORSH, TINT32, TUINT32}:  ssa.OpRsh32x32,
-       opAndTwoTypes{ORSH, TUINT32, TUINT32}: ssa.OpRsh32Ux32,
-       opAndTwoTypes{ORSH, TINT32, TUINT64}:  ssa.OpRsh32x64,
-       opAndTwoTypes{ORSH, TUINT32, TUINT64}: ssa.OpRsh32Ux64,
-
-       opAndTwoTypes{ORSH, TINT64, TUINT8}:   ssa.OpRsh64x8,
-       opAndTwoTypes{ORSH, TUINT64, TUINT8}:  ssa.OpRsh64Ux8,
-       opAndTwoTypes{ORSH, TINT64, TUINT16}:  ssa.OpRsh64x16,
-       opAndTwoTypes{ORSH, TUINT64, TUINT16}: ssa.OpRsh64Ux16,
-       opAndTwoTypes{ORSH, TINT64, TUINT32}:  ssa.OpRsh64x32,
-       opAndTwoTypes{ORSH, TUINT64, TUINT32}: ssa.OpRsh64Ux32,
-       opAndTwoTypes{ORSH, TINT64, TUINT64}:  ssa.OpRsh64x64,
-       opAndTwoTypes{ORSH, TUINT64, TUINT64}: ssa.OpRsh64Ux64,
-}
-
-func (s *state) ssaShiftOp(op Op, t *types.Type, u *types.Type) ssa.Op {
+       opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT8}:   ssa.OpLsh8x8,
+       opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT8}:  ssa.OpLsh8x8,
+       opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT16}:  ssa.OpLsh8x16,
+       opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT16}: ssa.OpLsh8x16,
+       opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT32}:  ssa.OpLsh8x32,
+       opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT32}: ssa.OpLsh8x32,
+       opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT64}:  ssa.OpLsh8x64,
+       opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT64}: ssa.OpLsh8x64,
+
+       opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT8}:   ssa.OpLsh16x8,
+       opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT8}:  ssa.OpLsh16x8,
+       opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT16}:  ssa.OpLsh16x16,
+       opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT16}: ssa.OpLsh16x16,
+       opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT32}:  ssa.OpLsh16x32,
+       opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT32}: ssa.OpLsh16x32,
+       opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT64}:  ssa.OpLsh16x64,
+       opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT64}: ssa.OpLsh16x64,
+
+       opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT8}:   ssa.OpLsh32x8,
+       opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT8}:  ssa.OpLsh32x8,
+       opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT16}:  ssa.OpLsh32x16,
+       opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT16}: ssa.OpLsh32x16,
+       opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT32}:  ssa.OpLsh32x32,
+       opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT32}: ssa.OpLsh32x32,
+       opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT64}:  ssa.OpLsh32x64,
+       opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT64}: ssa.OpLsh32x64,
+
+       opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT8}:   ssa.OpLsh64x8,
+       opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT8}:  ssa.OpLsh64x8,
+       opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT16}:  ssa.OpLsh64x16,
+       opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT16}: ssa.OpLsh64x16,
+       opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT32}:  ssa.OpLsh64x32,
+       opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT32}: ssa.OpLsh64x32,
+       opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT64}:  ssa.OpLsh64x64,
+       opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT64}: ssa.OpLsh64x64,
+
+       opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT8}:   ssa.OpRsh8x8,
+       opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT8}:  ssa.OpRsh8Ux8,
+       opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT16}:  ssa.OpRsh8x16,
+       opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT16}: ssa.OpRsh8Ux16,
+       opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT32}:  ssa.OpRsh8x32,
+       opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT32}: ssa.OpRsh8Ux32,
+       opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT64}:  ssa.OpRsh8x64,
+       opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT64}: ssa.OpRsh8Ux64,
+
+       opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT8}:   ssa.OpRsh16x8,
+       opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT8}:  ssa.OpRsh16Ux8,
+       opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT16}:  ssa.OpRsh16x16,
+       opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT16}: ssa.OpRsh16Ux16,
+       opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT32}:  ssa.OpRsh16x32,
+       opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT32}: ssa.OpRsh16Ux32,
+       opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT64}:  ssa.OpRsh16x64,
+       opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT64}: ssa.OpRsh16Ux64,
+
+       opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT8}:   ssa.OpRsh32x8,
+       opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT8}:  ssa.OpRsh32Ux8,
+       opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT16}:  ssa.OpRsh32x16,
+       opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT16}: ssa.OpRsh32Ux16,
+       opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT32}:  ssa.OpRsh32x32,
+       opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT32}: ssa.OpRsh32Ux32,
+       opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT64}:  ssa.OpRsh32x64,
+       opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT64}: ssa.OpRsh32Ux64,
+
+       opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT8}:   ssa.OpRsh64x8,
+       opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT8}:  ssa.OpRsh64Ux8,
+       opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT16}:  ssa.OpRsh64x16,
+       opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT16}: ssa.OpRsh64Ux16,
+       opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT32}:  ssa.OpRsh64x32,
+       opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT32}: ssa.OpRsh64Ux32,
+       opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT64}:  ssa.OpRsh64x64,
+       opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT64}: ssa.OpRsh64Ux64,
+}
+
+func (s *state) ssaShiftOp(op ir.Op, t *types.Type, u *types.Type) ssa.Op {
        etype1 := s.concreteEtype(t)
        etype2 := s.concreteEtype(u)
        x, ok := shiftOpToSSA[opAndTwoTypes{op, etype1, etype2}]
@@ -2051,117 +2260,126 @@ func (s *state) ssaShiftOp(op Op, t *types.Type, u *types.Type) ssa.Op {
 }
 
 // expr converts the expression n to ssa, adds it to s and returns the ssa result.
-func (s *state) expr(n *Node) *ssa.Value {
-       if !(n.Op == ONAME || n.Op == OLITERAL && n.Sym != nil) {
+func (s *state) expr(n ir.Node) *ssa.Value {
+       if ir.HasUniquePos(n) {
                // ONAMEs and named OLITERALs have the line number
                // of the decl, not the use. See issue 14742.
-               s.pushLine(n.Pos)
+               s.pushLine(n.Pos())
                defer s.popLine()
        }
 
-       s.stmtList(n.Ninit)
-       switch n.Op {
-       case OBYTES2STRTMP:
-               slice := s.expr(n.Left)
+       s.stmtList(n.Init())
+       switch n.Op() {
+       case ir.OBYTES2STRTMP:
+               n := n.(*ir.ConvExpr)
+               slice := s.expr(n.X)
                ptr := s.newValue1(ssa.OpSlicePtr, s.f.Config.Types.BytePtr, slice)
-               len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], slice)
-               return s.newValue2(ssa.OpStringMake, n.Type, ptr, len)
-       case OSTR2BYTESTMP:
-               str := s.expr(n.Left)
+               len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
+               return s.newValue2(ssa.OpStringMake, n.Type(), ptr, len)
+       case ir.OSTR2BYTESTMP:
+               n := n.(*ir.ConvExpr)
+               str := s.expr(n.X)
                ptr := s.newValue1(ssa.OpStringPtr, s.f.Config.Types.BytePtr, str)
-               len := s.newValue1(ssa.OpStringLen, types.Types[TINT], str)
-               return s.newValue3(ssa.OpSliceMake, n.Type, ptr, len, len)
-       case OCFUNC:
-               aux := n.Left.Sym.Linksym()
-               return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb)
-       case ONAME:
-               if n.Class() == PFUNC {
+               len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], str)
+               return s.newValue3(ssa.OpSliceMake, n.Type(), ptr, len, len)
+       case ir.OCFUNC:
+               n := n.(*ir.UnaryExpr)
+               aux := n.X.(*ir.Name).Linksym()
+               return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Class == ir.PFUNC {
                        // "value" of a function is the address of the function's closure
-                       sym := funcsym(n.Sym).Linksym()
-                       return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
+                       sym := staticdata.FuncLinksym(n)
+                       return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
                }
                if s.canSSA(n) {
-                       return s.variable(n, n.Type)
-               }
-               addr := s.addr(n)
-               return s.load(n.Type, addr)
-       case OCLOSUREVAR:
-               addr := s.addr(n)
-               return s.load(n.Type, addr)
-       case OLITERAL:
-               switch u := n.Val().U.(type) {
-               case *Mpint:
-                       i := u.Int64()
-                       switch n.Type.Size() {
+                       return s.variable(n, n.Type())
+               }
+               return s.load(n.Type(), s.addr(n))
+       case ir.OLINKSYMOFFSET:
+               n := n.(*ir.LinksymOffsetExpr)
+               return s.load(n.Type(), s.addr(n))
+       case ir.ONIL:
+               n := n.(*ir.NilExpr)
+               t := n.Type()
+               switch {
+               case t.IsSlice():
+                       return s.constSlice(t)
+               case t.IsInterface():
+                       return s.constInterface(t)
+               default:
+                       return s.constNil(t)
+               }
+       case ir.OLITERAL:
+               switch u := n.Val(); u.Kind() {
+               case constant.Int:
+                       i := ir.IntVal(n.Type(), u)
+                       switch n.Type().Size() {
                        case 1:
-                               return s.constInt8(n.Type, int8(i))
+                               return s.constInt8(n.Type(), int8(i))
                        case 2:
-                               return s.constInt16(n.Type, int16(i))
+                               return s.constInt16(n.Type(), int16(i))
                        case 4:
-                               return s.constInt32(n.Type, int32(i))
+                               return s.constInt32(n.Type(), int32(i))
                        case 8:
-                               return s.constInt64(n.Type, i)
+                               return s.constInt64(n.Type(), i)
                        default:
-                               s.Fatalf("bad integer size %d", n.Type.Size())
+                               s.Fatalf("bad integer size %d", n.Type().Size())
                                return nil
                        }
-               case string:
-                       if u == "" {
-                               return s.constEmptyString(n.Type)
-                       }
-                       return s.entryNewValue0A(ssa.OpConstString, n.Type, u)
-               case bool:
-                       return s.constBool(u)
-               case *NilVal:
-                       t := n.Type
-                       switch {
-                       case t.IsSlice():
-                               return s.constSlice(t)
-                       case t.IsInterface():
-                               return s.constInterface(t)
-                       default:
-                               return s.constNil(t)
+               case constant.String:
+                       i := constant.StringVal(u)
+                       if i == "" {
+                               return s.constEmptyString(n.Type())
                        }
-               case *Mpflt:
-                       switch n.Type.Size() {
+                       return s.entryNewValue0A(ssa.OpConstString, n.Type(), ssa.StringToAux(i))
+               case constant.Bool:
+                       return s.constBool(constant.BoolVal(u))
+               case constant.Float:
+                       f, _ := constant.Float64Val(u)
+                       switch n.Type().Size() {
                        case 4:
-                               return s.constFloat32(n.Type, u.Float32())
+                               return s.constFloat32(n.Type(), f)
                        case 8:
-                               return s.constFloat64(n.Type, u.Float64())
+                               return s.constFloat64(n.Type(), f)
                        default:
-                               s.Fatalf("bad float size %d", n.Type.Size())
+                               s.Fatalf("bad float size %d", n.Type().Size())
                                return nil
                        }
-               case *Mpcplx:
-                       r := &u.Real
-                       i := &u.Imag
-                       switch n.Type.Size() {
+               case constant.Complex:
+                       re, _ := constant.Float64Val(constant.Real(u))
+                       im, _ := constant.Float64Val(constant.Imag(u))
+                       switch n.Type().Size() {
                        case 8:
-                               pt := types.Types[TFLOAT32]
-                               return s.newValue2(ssa.OpComplexMake, n.Type,
-                                       s.constFloat32(pt, r.Float32()),
-                                       s.constFloat32(pt, i.Float32()))
+                               pt := types.Types[types.TFLOAT32]
+                               return s.newValue2(ssa.OpComplexMake, n.Type(),
+                                       s.constFloat32(pt, re),
+                                       s.constFloat32(pt, im))
                        case 16:
-                               pt := types.Types[TFLOAT64]
-                               return s.newValue2(ssa.OpComplexMake, n.Type,
-                                       s.constFloat64(pt, r.Float64()),
-                                       s.constFloat64(pt, i.Float64()))
+                               pt := types.Types[types.TFLOAT64]
+                               return s.newValue2(ssa.OpComplexMake, n.Type(),
+                                       s.constFloat64(pt, re),
+                                       s.constFloat64(pt, im))
                        default:
-                               s.Fatalf("bad float size %d", n.Type.Size())
+                               s.Fatalf("bad complex size %d", n.Type().Size())
                                return nil
                        }
-
                default:
-                       s.Fatalf("unhandled OLITERAL %v", n.Val().Ctype())
+                       s.Fatalf("unhandled OLITERAL %v", u.Kind())
                        return nil
                }
-       case OCONVNOP:
-               to := n.Type
-               from := n.Left.Type
+       case ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               to := n.Type()
+               from := n.X.Type()
 
                // Assume everything will work out, so set up our return value.
                // Anything interesting that happens from here is a fatal.
-               x := s.expr(n.Left)
+               x := s.expr(n.X)
+               if to == from {
+                       return x
+               }
 
                // Special case for not confusing GC and liveness.
                // We don't want pointers accidentally classified
@@ -2174,12 +2392,12 @@ func (s *state) expr(n *Node) *ssa.Value {
                v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type
 
                // CONVNOP closure
-               if to.Etype == TFUNC && from.IsPtrShaped() {
+               if to.Kind() == types.TFUNC && from.IsPtrShaped() {
                        return v
                }
 
                // named <--> unnamed type or typed <--> untyped const
-               if from.Etype == to.Etype {
+               if from.Kind() == to.Kind() {
                        return v
                }
 
@@ -2189,30 +2407,30 @@ func (s *state) expr(n *Node) *ssa.Value {
                }
 
                // map <--> *hmap
-               if to.Etype == TMAP && from.IsPtr() &&
+               if to.Kind() == types.TMAP && from.IsPtr() &&
                        to.MapType().Hmap == from.Elem() {
                        return v
                }
 
-               dowidth(from)
-               dowidth(to)
+               types.CalcSize(from)
+               types.CalcSize(to)
                if from.Width != to.Width {
                        s.Fatalf("CONVNOP width mismatch %v (%d) -> %v (%d)\n", from, from.Width, to, to.Width)
                        return nil
                }
-               if etypesign(from.Etype) != etypesign(to.Etype) {
-                       s.Fatalf("CONVNOP sign mismatch %v (%s) -> %v (%s)\n", from, from.Etype, to, to.Etype)
+               if etypesign(from.Kind()) != etypesign(to.Kind()) {
+                       s.Fatalf("CONVNOP sign mismatch %v (%s) -> %v (%s)\n", from, from.Kind(), to, to.Kind())
                        return nil
                }
 
-               if instrumenting {
+               if base.Flag.Cfg.Instrumenting {
                        // These appear to be fine, but they fail the
                        // integer constraint below, so okay them here.
                        // Sample non-integer conversion: map[string]string -> *uint8
                        return v
                }
 
-               if etypesign(from.Etype) == 0 {
+               if etypesign(from.Kind()) == 0 {
                        s.Fatalf("CONVNOP unrecognized non-integer %v -> %v\n", from, to)
                        return nil
                }
@@ -2220,13 +2438,14 @@ func (s *state) expr(n *Node) *ssa.Value {
                // integer, same width, same sign
                return v
 
-       case OCONV:
-               x := s.expr(n.Left)
-               ft := n.Left.Type // from type
-               tt := n.Type      // to type
-               if ft.IsBoolean() && tt.IsKind(TUINT8) {
+       case ir.OCONV:
+               n := n.(*ir.ConvExpr)
+               x := s.expr(n.X)
+               ft := n.X.Type() // from type
+               tt := n.Type()   // to type
+               if ft.IsBoolean() && tt.IsKind(types.TUINT8) {
                        // Bool -> uint8 is generated internally when indexing into runtime.staticbyte.
-                       return s.newValue1(ssa.OpCopy, n.Type, x)
+                       return s.newValue1(ssa.OpCopy, n.Type(), x)
                }
                if ft.IsInteger() && tt.IsInteger() {
                        var op ssa.Op
@@ -2287,23 +2506,23 @@ func (s *state) expr(n *Node) *ssa.Value {
                                        s.Fatalf("weird integer sign extension %v -> %v", ft, tt)
                                }
                        }
-                       return s.newValue1(op, n.Type, x)
+                       return s.newValue1(op, n.Type(), x)
                }
 
                if ft.IsFloat() || tt.IsFloat() {
                        conv, ok := fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]
-                       if s.config.RegSize == 4 && thearch.LinkArch.Family != sys.MIPS && !s.softFloat {
+                       if s.config.RegSize == 4 && Arch.LinkArch.Family != sys.MIPS && !s.softFloat {
                                if conv1, ok1 := fpConvOpToSSA32[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]; ok1 {
                                        conv = conv1
                                }
                        }
-                       if thearch.LinkArch.Family == sys.ARM64 || thearch.LinkArch.Family == sys.Wasm || thearch.LinkArch.Family == sys.S390X || s.softFloat {
+                       if Arch.LinkArch.Family == sys.ARM64 || Arch.LinkArch.Family == sys.Wasm || Arch.LinkArch.Family == sys.S390X || s.softFloat {
                                if conv1, ok1 := uint64fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]; ok1 {
                                        conv = conv1
                                }
                        }
 
-                       if thearch.LinkArch.Family == sys.MIPS && !s.softFloat {
+                       if Arch.LinkArch.Family == sys.MIPS && !s.softFloat {
                                if ft.Size() == 4 && ft.IsInteger() && !ft.IsSigned() {
                                        // tt is float32 or float64, and ft is also unsigned
                                        if tt.Size() == 4 {
@@ -2334,12 +2553,12 @@ func (s *state) expr(n *Node) *ssa.Value {
                                        if op2 == ssa.OpCopy {
                                                return x
                                        }
-                                       return s.newValueOrSfCall1(op2, n.Type, x)
+                                       return s.newValueOrSfCall1(op2, n.Type(), x)
                                }
                                if op2 == ssa.OpCopy {
-                                       return s.newValueOrSfCall1(op1, n.Type, x)
+                                       return s.newValueOrSfCall1(op1, n.Type(), x)
                                }
-                               return s.newValueOrSfCall1(op2, n.Type, s.newValueOrSfCall1(op1, types.Types[it], x))
+                               return s.newValueOrSfCall1(op2, n.Type(), s.newValueOrSfCall1(op1, types.Types[it], x))
                        }
                        // Tricky 64-bit unsigned cases.
                        if ft.IsInteger() {
@@ -2381,63 +2600,66 @@ func (s *state) expr(n *Node) *ssa.Value {
                        } else {
                                s.Fatalf("weird complex conversion %v -> %v", ft, tt)
                        }
-                       ftp := floatForComplex(ft)
-                       ttp := floatForComplex(tt)
+                       ftp := types.FloatForComplex(ft)
+                       ttp := types.FloatForComplex(tt)
                        return s.newValue2(ssa.OpComplexMake, tt,
                                s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexReal, ftp, x)),
                                s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
                }
 
-               s.Fatalf("unhandled OCONV %s -> %s", n.Left.Type.Etype, n.Type.Etype)
+               s.Fatalf("unhandled OCONV %s -> %s", n.X.Type().Kind(), n.Type().Kind())
                return nil
 
-       case ODOTTYPE:
+       case ir.ODOTTYPE:
+               n := n.(*ir.TypeAssertExpr)
                res, _ := s.dottype(n, false)
                return res
 
        // binary ops
-       case OLT, OEQ, ONE, OLE, OGE, OGT:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               if n.Left.Type.IsComplex() {
-                       pt := floatForComplex(n.Left.Type)
-                       op := s.ssaOp(OEQ, pt)
-                       r := s.newValueOrSfCall2(op, types.Types[TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
-                       i := s.newValueOrSfCall2(op, types.Types[TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
-                       c := s.newValue2(ssa.OpAndB, types.Types[TBOOL], r, i)
-                       switch n.Op {
-                       case OEQ:
+       case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               if n.X.Type().IsComplex() {
+                       pt := types.FloatForComplex(n.X.Type())
+                       op := s.ssaOp(ir.OEQ, pt)
+                       r := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
+                       i := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
+                       c := s.newValue2(ssa.OpAndB, types.Types[types.TBOOL], r, i)
+                       switch n.Op() {
+                       case ir.OEQ:
                                return c
-                       case ONE:
-                               return s.newValue1(ssa.OpNot, types.Types[TBOOL], c)
+                       case ir.ONE:
+                               return s.newValue1(ssa.OpNot, types.Types[types.TBOOL], c)
                        default:
-                               s.Fatalf("ordered complex compare %v", n.Op)
+                               s.Fatalf("ordered complex compare %v", n.Op())
                        }
                }
 
                // Convert OGE and OGT into OLE and OLT.
-               op := n.Op
+               op := n.Op()
                switch op {
-               case OGE:
-                       op, a, b = OLE, b, a
-               case OGT:
-                       op, a, b = OLT, b, a
+               case ir.OGE:
+                       op, a, b = ir.OLE, b, a
+               case ir.OGT:
+                       op, a, b = ir.OLT, b, a
                }
-               if n.Left.Type.IsFloat() {
+               if n.X.Type().IsFloat() {
                        // float comparison
-                       return s.newValueOrSfCall2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
+                       return s.newValueOrSfCall2(s.ssaOp(op, n.X.Type()), types.Types[types.TBOOL], a, b)
                }
                // integer comparison
-               return s.newValue2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
-       case OMUL:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               if n.Type.IsComplex() {
+               return s.newValue2(s.ssaOp(op, n.X.Type()), types.Types[types.TBOOL], a, b)
+       case ir.OMUL:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               if n.Type().IsComplex() {
                        mulop := ssa.OpMul64F
                        addop := ssa.OpAdd64F
                        subop := ssa.OpSub64F
-                       pt := floatForComplex(n.Type) // Could be Float32 or Float64
-                       wt := types.Types[TFLOAT64]   // Compute in Float64 to minimize cancellation error
+                       pt := types.FloatForComplex(n.Type()) // Could be Float32 or Float64
+                       wt := types.Types[types.TFLOAT64]     // Compute in Float64 to minimize cancellation error
 
                        areal := s.newValue1(ssa.OpComplexReal, pt, a)
                        breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2459,19 +2681,20 @@ func (s *state) expr(n *Node) *ssa.Value {
                                ximag = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, ximag)
                        }
 
-                       return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+                       return s.newValue2(ssa.OpComplexMake, n.Type(), xreal, ximag)
                }
 
-               if n.Type.IsFloat() {
-                       return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+               if n.Type().IsFloat() {
+                       return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
                }
 
-               return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+               return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 
-       case ODIV:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               if n.Type.IsComplex() {
+       case ir.ODIV:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               if n.Type().IsComplex() {
                        // TODO this is not executed because the front-end substitutes a runtime call.
                        // That probably ought to change; with modest optimization the widen/narrow
                        // conversions could all be elided in larger expression trees.
@@ -2479,8 +2702,8 @@ func (s *state) expr(n *Node) *ssa.Value {
                        addop := ssa.OpAdd64F
                        subop := ssa.OpSub64F
                        divop := ssa.OpDiv64F
-                       pt := floatForComplex(n.Type) // Could be Float32 or Float64
-                       wt := types.Types[TFLOAT64]   // Compute in Float64 to minimize cancellation error
+                       pt := types.FloatForComplex(n.Type()) // Could be Float32 or Float64
+                       wt := types.Types[types.TFLOAT64]     // Compute in Float64 to minimize cancellation error
 
                        areal := s.newValue1(ssa.OpComplexReal, pt, a)
                        breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2509,50 +2732,55 @@ func (s *state) expr(n *Node) *ssa.Value {
                                xreal = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, xreal)
                                ximag = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, ximag)
                        }
-                       return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+                       return s.newValue2(ssa.OpComplexMake, n.Type(), xreal, ximag)
                }
-               if n.Type.IsFloat() {
-                       return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+               if n.Type().IsFloat() {
+                       return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
                }
                return s.intDivide(n, a, b)
-       case OMOD:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
+       case ir.OMOD:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
                return s.intDivide(n, a, b)
-       case OADD, OSUB:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               if n.Type.IsComplex() {
-                       pt := floatForComplex(n.Type)
-                       op := s.ssaOp(n.Op, pt)
-                       return s.newValue2(ssa.OpComplexMake, n.Type,
+       case ir.OADD, ir.OSUB:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               if n.Type().IsComplex() {
+                       pt := types.FloatForComplex(n.Type())
+                       op := s.ssaOp(n.Op(), pt)
+                       return s.newValue2(ssa.OpComplexMake, n.Type(),
                                s.newValueOrSfCall2(op, pt, s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b)),
                                s.newValueOrSfCall2(op, pt, s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b)))
                }
-               if n.Type.IsFloat() {
-                       return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
-               }
-               return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
-       case OAND, OOR, OXOR:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
-       case OANDNOT:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
-               b = s.newValue1(s.ssaOp(OBITNOT, b.Type), b.Type, b)
-               return s.newValue2(s.ssaOp(OAND, n.Type), a.Type, a, b)
-       case OLSH, ORSH:
-               a := s.expr(n.Left)
-               b := s.expr(n.Right)
+               if n.Type().IsFloat() {
+                       return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
+               }
+               return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
+       case ir.OAND, ir.OOR, ir.OXOR:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
+       case ir.OANDNOT:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
+               b = s.newValue1(s.ssaOp(ir.OBITNOT, b.Type), b.Type, b)
+               return s.newValue2(s.ssaOp(ir.OAND, n.Type()), a.Type, a, b)
+       case ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               a := s.expr(n.X)
+               b := s.expr(n.Y)
                bt := b.Type
                if bt.IsSigned() {
-                       cmp := s.newValue2(s.ssaOp(OLE, bt), types.Types[TBOOL], s.zeroVal(bt), b)
-                       s.check(cmp, panicshift)
+                       cmp := s.newValue2(s.ssaOp(ir.OLE, bt), types.Types[types.TBOOL], s.zeroVal(bt), b)
+                       s.check(cmp, ir.Syms.Panicshift)
                        bt = bt.ToUnsigned()
                }
-               return s.newValue2(s.ssaShiftOp(n.Op, n.Type, bt), a.Type, a, b)
-       case OANDAND, OOROR:
+               return s.newValue2(s.ssaShiftOp(n.Op(), n.Type(), bt), a.Type, a, b)
+       case ir.OANDAND, ir.OOROR:
                // To implement OANDAND (and OOROR), we introduce a
                // new temporary variable to hold the result. The
                // variable is associated with the OANDAND node in the
@@ -2566,7 +2794,8 @@ func (s *state) expr(n *Node) *ssa.Value {
                //     }
                // Using var in the subsequent block introduces the
                // necessary phi variable.
-               el := s.expr(n.Left)
+               n := n.(*ir.LogicalExpr)
+               el := s.expr(n.X)
                s.vars[n] = el
 
                b := s.endBlock()
@@ -2579,255 +2808,272 @@ func (s *state) expr(n *Node) *ssa.Value {
 
                bRight := s.f.NewBlock(ssa.BlockPlain)
                bResult := s.f.NewBlock(ssa.BlockPlain)
-               if n.Op == OANDAND {
+               if n.Op() == ir.OANDAND {
                        b.AddEdgeTo(bRight)
                        b.AddEdgeTo(bResult)
-               } else if n.Op == OOROR {
+               } else if n.Op() == ir.OOROR {
                        b.AddEdgeTo(bResult)
                        b.AddEdgeTo(bRight)
                }
 
                s.startBlock(bRight)
-               er := s.expr(n.Right)
+               er := s.expr(n.Y)
                s.vars[n] = er
 
                b = s.endBlock()
                b.AddEdgeTo(bResult)
 
                s.startBlock(bResult)
-               return s.variable(n, types.Types[TBOOL])
-       case OCOMPLEX:
-               r := s.expr(n.Left)
-               i := s.expr(n.Right)
-               return s.newValue2(ssa.OpComplexMake, n.Type, r, i)
+               return s.variable(n, types.Types[types.TBOOL])
+       case ir.OCOMPLEX:
+               n := n.(*ir.BinaryExpr)
+               r := s.expr(n.X)
+               i := s.expr(n.Y)
+               return s.newValue2(ssa.OpComplexMake, n.Type(), r, i)
 
        // unary ops
-       case ONEG:
-               a := s.expr(n.Left)
-               if n.Type.IsComplex() {
-                       tp := floatForComplex(n.Type)
-                       negop := s.ssaOp(n.Op, tp)
-                       return s.newValue2(ssa.OpComplexMake, n.Type,
+       case ir.ONEG:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               if n.Type().IsComplex() {
+                       tp := types.FloatForComplex(n.Type())
+                       negop := s.ssaOp(n.Op(), tp)
+                       return s.newValue2(ssa.OpComplexMake, n.Type(),
                                s.newValue1(negop, tp, s.newValue1(ssa.OpComplexReal, tp, a)),
                                s.newValue1(negop, tp, s.newValue1(ssa.OpComplexImag, tp, a)))
                }
-               return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
-       case ONOT, OBITNOT:
-               a := s.expr(n.Left)
-               return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
-       case OIMAG, OREAL:
-               a := s.expr(n.Left)
-               return s.newValue1(s.ssaOp(n.Op, n.Left.Type), n.Type, a)
-       case OPLUS:
-               return s.expr(n.Left)
-
-       case OADDR:
-               return s.addr(n.Left)
-
-       case ORESULT:
+               return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
+       case ir.ONOT, ir.OBITNOT:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
+       case ir.OIMAG, ir.OREAL:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               return s.newValue1(s.ssaOp(n.Op(), n.X.Type()), n.Type(), a)
+       case ir.OPLUS:
+               n := n.(*ir.UnaryExpr)
+               return s.expr(n.X)
+
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               return s.addr(n.X)
+
+       case ir.ORESULT:
+               n := n.(*ir.ResultExpr)
                if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
                        // Do the old thing
-                       addr := s.constOffPtrSP(types.NewPtr(n.Type), n.Xoffset)
-                       return s.rawLoad(n.Type, addr)
+                       addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
+                       return s.rawLoad(n.Type(), addr)
                }
-               which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Xoffset)
+               which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
                if which == -1 {
                        // Do the old thing // TODO: Panic instead.
-                       addr := s.constOffPtrSP(types.NewPtr(n.Type), n.Xoffset)
-                       return s.rawLoad(n.Type, addr)
+                       addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
+                       return s.rawLoad(n.Type(), addr)
                }
-               if canSSAType(n.Type) {
-                       return s.newValue1I(ssa.OpSelectN, n.Type, which, s.prevCall)
+               if TypeOK(n.Type()) {
+                       return s.newValue1I(ssa.OpSelectN, n.Type(), which, s.prevCall)
                } else {
-                       addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type), which, s.prevCall)
-                       return s.rawLoad(n.Type, addr)
+                       addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type()), which, s.prevCall)
+                       return s.rawLoad(n.Type(), addr)
                }
 
-       case ODEREF:
-               p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-               return s.load(n.Type, p)
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               p := s.exprPtr(n.X, n.Bounded(), n.Pos())
+               return s.load(n.Type(), p)
 
-       case ODOT:
-               if n.Left.Op == OSTRUCTLIT {
+       case ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               if n.X.Op() == ir.OSTRUCTLIT {
                        // All literals with nonzero fields have already been
                        // rewritten during walk. Any that remain are just T{}
                        // or equivalents. Use the zero value.
-                       if !isZero(n.Left) {
-                               s.Fatalf("literal with nonzero value in SSA: %v", n.Left)
+                       if !ir.IsZero(n.X) {
+                               s.Fatalf("literal with nonzero value in SSA: %v", n.X)
                        }
-                       return s.zeroVal(n.Type)
+                       return s.zeroVal(n.Type())
                }
                // If n is addressable and can't be represented in
                // SSA, then load just the selected field. This
                // prevents false memory dependencies in race/msan
                // instrumentation.
-               if islvalue(n) && !s.canSSA(n) {
+               if ir.IsAddressable(n) && !s.canSSA(n) {
                        p := s.addr(n)
-                       return s.load(n.Type, p)
+                       return s.load(n.Type(), p)
                }
-               v := s.expr(n.Left)
-               return s.newValue1I(ssa.OpStructSelect, n.Type, int64(fieldIdx(n)), v)
+               v := s.expr(n.X)
+               return s.newValue1I(ssa.OpStructSelect, n.Type(), int64(fieldIdx(n)), v)
 
-       case ODOTPTR:
-               p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-               p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type), n.Xoffset, p)
-               return s.load(n.Type, p)
+       case ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               p := s.exprPtr(n.X, n.Bounded(), n.Pos())
+               p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset(), p)
+               return s.load(n.Type(), p)
 
-       case OINDEX:
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
                switch {
-               case n.Left.Type.IsString():
-                       if n.Bounded() && Isconst(n.Left, CTSTR) && Isconst(n.Right, CTINT) {
+               case n.X.Type().IsString():
+                       if n.Bounded() && ir.IsConst(n.X, constant.String) && ir.IsConst(n.Index, constant.Int) {
                                // Replace "abc"[1] with 'b'.
                                // Delayed until now because "abc"[1] is not an ideal constant.
                                // See test/fixedbugs/issue11370.go.
-                               return s.newValue0I(ssa.OpConst8, types.Types[TUINT8], int64(int8(n.Left.StringVal()[n.Right.Int64Val()])))
+                               return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(ir.StringVal(n.X)[ir.Int64Val(n.Index)])))
                        }
-                       a := s.expr(n.Left)
-                       i := s.expr(n.Right)
-                       len := s.newValue1(ssa.OpStringLen, types.Types[TINT], a)
+                       a := s.expr(n.X)
+                       i := s.expr(n.Index)
+                       len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], a)
                        i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
                        ptrtyp := s.f.Config.Types.BytePtr
                        ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-                       if Isconst(n.Right, CTINT) {
-                               ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right.Int64Val(), ptr)
+                       if ir.IsConst(n.Index, constant.Int) {
+                               ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, ir.Int64Val(n.Index), ptr)
                        } else {
                                ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
                        }
-                       return s.load(types.Types[TUINT8], ptr)
-               case n.Left.Type.IsSlice():
+                       return s.load(types.Types[types.TUINT8], ptr)
+               case n.X.Type().IsSlice():
                        p := s.addr(n)
-                       return s.load(n.Left.Type.Elem(), p)
-               case n.Left.Type.IsArray():
-                       if canSSAType(n.Left.Type) {
+                       return s.load(n.X.Type().Elem(), p)
+               case n.X.Type().IsArray():
+                       if TypeOK(n.X.Type()) {
                                // SSA can handle arrays of length at most 1.
-                               bound := n.Left.Type.NumElem()
-                               a := s.expr(n.Left)
-                               i := s.expr(n.Right)
+                               bound := n.X.Type().NumElem()
+                               a := s.expr(n.X)
+                               i := s.expr(n.Index)
                                if bound == 0 {
                                        // Bounds check will never succeed.  Might as well
                                        // use constants for the bounds check.
-                                       z := s.constInt(types.Types[TINT], 0)
+                                       z := s.constInt(types.Types[types.TINT], 0)
                                        s.boundsCheck(z, z, ssa.BoundsIndex, false)
                                        // The return value won't be live, return junk.
-                                       return s.newValue0(ssa.OpUnknown, n.Type)
+                                       return s.newValue0(ssa.OpUnknown, n.Type())
                                }
-                               len := s.constInt(types.Types[TINT], bound)
+                               len := s.constInt(types.Types[types.TINT], bound)
                                s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded()) // checks i == 0
-                               return s.newValue1I(ssa.OpArraySelect, n.Type, 0, a)
+                               return s.newValue1I(ssa.OpArraySelect, n.Type(), 0, a)
                        }
                        p := s.addr(n)
-                       return s.load(n.Left.Type.Elem(), p)
+                       return s.load(n.X.Type().Elem(), p)
                default:
-                       s.Fatalf("bad type for index %v", n.Left.Type)
+                       s.Fatalf("bad type for index %v", n.X.Type())
                        return nil
                }
 
-       case OLEN, OCAP:
+       case ir.OLEN, ir.OCAP:
+               n := n.(*ir.UnaryExpr)
                switch {
-               case n.Left.Type.IsSlice():
+               case n.X.Type().IsSlice():
                        op := ssa.OpSliceLen
-                       if n.Op == OCAP {
+                       if n.Op() == ir.OCAP {
                                op = ssa.OpSliceCap
                        }
-                       return s.newValue1(op, types.Types[TINT], s.expr(n.Left))
-               case n.Left.Type.IsString(): // string; not reachable for OCAP
-                       return s.newValue1(ssa.OpStringLen, types.Types[TINT], s.expr(n.Left))
-               case n.Left.Type.IsMap(), n.Left.Type.IsChan():
-                       return s.referenceTypeBuiltin(n, s.expr(n.Left))
+                       return s.newValue1(op, types.Types[types.TINT], s.expr(n.X))
+               case n.X.Type().IsString(): // string; not reachable for OCAP
+                       return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.X))
+               case n.X.Type().IsMap(), n.X.Type().IsChan():
+                       return s.referenceTypeBuiltin(n, s.expr(n.X))
                default: // array
-                       return s.constInt(types.Types[TINT], n.Left.Type.NumElem())
+                       return s.constInt(types.Types[types.TINT], n.X.Type().NumElem())
                }
 
-       case OSPTR:
-               a := s.expr(n.Left)
-               if n.Left.Type.IsSlice() {
-                       return s.newValue1(ssa.OpSlicePtr, n.Type, a)
+       case ir.OSPTR:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               if n.X.Type().IsSlice() {
+                       return s.newValue1(ssa.OpSlicePtr, n.Type(), a)
                } else {
-                       return s.newValue1(ssa.OpStringPtr, n.Type, a)
-               }
-
-       case OITAB:
-               a := s.expr(n.Left)
-               return s.newValue1(ssa.OpITab, n.Type, a)
-
-       case OIDATA:
-               a := s.expr(n.Left)
-               return s.newValue1(ssa.OpIData, n.Type, a)
-
-       case OEFACE:
-               tab := s.expr(n.Left)
-               data := s.expr(n.Right)
-               return s.newValue2(ssa.OpIMake, n.Type, tab, data)
-
-       case OSLICEHEADER:
-               p := s.expr(n.Left)
-               l := s.expr(n.List.First())
-               c := s.expr(n.List.Second())
-               return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
-
-       case OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR:
-               v := s.expr(n.Left)
+                       return s.newValue1(ssa.OpStringPtr, n.Type(), a)
+               }
+
+       case ir.OITAB:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               return s.newValue1(ssa.OpITab, n.Type(), a)
+
+       case ir.OIDATA:
+               n := n.(*ir.UnaryExpr)
+               a := s.expr(n.X)
+               return s.newValue1(ssa.OpIData, n.Type(), a)
+
+       case ir.OEFACE:
+               n := n.(*ir.BinaryExpr)
+               tab := s.expr(n.X)
+               data := s.expr(n.Y)
+               return s.newValue2(ssa.OpIMake, n.Type(), tab, data)
+
+       case ir.OSLICEHEADER:
+               n := n.(*ir.SliceHeaderExpr)
+               p := s.expr(n.Ptr)
+               l := s.expr(n.Len)
+               c := s.expr(n.Cap)
+               return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
+
+       case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
+               n := n.(*ir.SliceExpr)
+               v := s.expr(n.X)
                var i, j, k *ssa.Value
-               low, high, max := n.SliceBounds()
-               if low != nil {
-                       i = s.expr(low)
+               if n.Low != nil {
+                       i = s.expr(n.Low)
                }
-               if high != nil {
-                       j = s.expr(high)
+               if n.High != nil {
+                       j = s.expr(n.High)
                }
-               if max != nil {
-                       k = s.expr(max)
+               if n.Max != nil {
+                       k = s.expr(n.Max)
                }
                p, l, c := s.slice(v, i, j, k, n.Bounded())
-               return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
+               return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
-       case OSLICESTR:
-               v := s.expr(n.Left)
+       case ir.OSLICESTR:
+               n := n.(*ir.SliceExpr)
+               v := s.expr(n.X)
                var i, j *ssa.Value
-               low, high, _ := n.SliceBounds()
-               if low != nil {
-                       i = s.expr(low)
+               if n.Low != nil {
+                       i = s.expr(n.Low)
                }
-               if high != nil {
-                       j = s.expr(high)
+               if n.High != nil {
+                       j = s.expr(n.High)
                }
                p, l, _ := s.slice(v, i, j, nil, n.Bounded())
-               return s.newValue2(ssa.OpStringMake, n.Type, p, l)
+               return s.newValue2(ssa.OpStringMake, n.Type(), p, l)
 
-       case OCALLFUNC:
-               if isIntrinsicCall(n) {
+       case ir.OCALLFUNC:
+               n := n.(*ir.CallExpr)
+               if ir.IsIntrinsicCall(n) {
                        return s.intrinsicCall(n)
                }
                fallthrough
 
-       case OCALLINTER, OCALLMETH:
+       case ir.OCALLINTER, ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
                return s.callResult(n, callNormal)
 
-       case OGETG:
-               return s.newValue1(ssa.OpGetG, n.Type, s.mem())
+       case ir.OGETG:
+               n := n.(*ir.CallExpr)
+               return s.newValue1(ssa.OpGetG, n.Type(), s.mem())
 
-       case OAPPEND:
-               return s.append(n, false)
+       case ir.OAPPEND:
+               return s.append(n.(*ir.CallExpr), false)
 
-       case OSTRUCTLIT, OARRAYLIT:
+       case ir.OSTRUCTLIT, ir.OARRAYLIT:
                // All literals with nonzero fields have already been
                // rewritten during walk. Any that remain are just T{}
                // or equivalents. Use the zero value.
-               if !isZero(n) {
+               n := n.(*ir.CompLitExpr)
+               if !ir.IsZero(n) {
                        s.Fatalf("literal with nonzero value in SSA: %v", n)
                }
-               return s.zeroVal(n.Type)
+               return s.zeroVal(n.Type())
 
-       case ONEWOBJ:
-               if n.Type.Elem().Size() == 0 {
-                       return s.newValue1A(ssa.OpAddr, n.Type, zerobaseSym, s.sb)
-               }
-               typ := s.expr(n.Left)
-               vv := s.rtcall(newobject, true, []*types.Type{n.Type}, typ)
-               return vv[0]
+       case ir.ONEW:
+               n := n.(*ir.UnaryExpr)
+               return s.newObject(n.Type().Elem())
 
        default:
-               s.Fatalf("unhandled expr %v", n.Op)
+               s.Fatalf("unhandled expr %v", n.Op())
                return nil
        }
 }
@@ -2838,7 +3084,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 // If inplace is true, it writes the result of the OAPPEND expression n
 // back to the slice being appended to, and returns nil.
 // inplace MUST be set to false if the slice can be SSA'd.
-func (s *state) append(n *Node, inplace bool) *ssa.Value {
+func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
        // If inplace is false, process as expression "append(s, e1, e2, e3)":
        //
        // ptr, len, cap := s
@@ -2872,16 +3118,16 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
        // *(ptr+len+1) = e2
        // *(ptr+len+2) = e3
 
-       et := n.Type.Elem()
+       et := n.Type().Elem()
        pt := types.NewPtr(et)
 
        // Evaluate slice
-       sn := n.List.First() // the slice node is the first in the list
+       sn := n.Args[0] // the slice node is the first in the list
 
        var slice, addr *ssa.Value
        if inplace {
                addr = s.addr(sn)
-               slice = s.load(n.Type, addr)
+               slice = s.load(n.Type(), addr)
        } else {
                slice = s.expr(sn)
        }
@@ -2891,20 +3137,20 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
        assign := s.f.NewBlock(ssa.BlockPlain)
 
        // Decide if we need to grow
-       nargs := int64(n.List.Len() - 1)
+       nargs := int64(len(n.Args) - 1)
        p := s.newValue1(ssa.OpSlicePtr, pt, slice)
-       l := s.newValue1(ssa.OpSliceLen, types.Types[TINT], slice)
-       c := s.newValue1(ssa.OpSliceCap, types.Types[TINT], slice)
-       nl := s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
+       l := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
+       c := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], slice)
+       nl := s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], l, s.constInt(types.Types[types.TINT], nargs))
 
-       cmp := s.newValue2(s.ssaOp(OLT, types.Types[TUINT]), types.Types[TBOOL], c, nl)
-       s.vars[&ptrVar] = p
+       cmp := s.newValue2(s.ssaOp(ir.OLT, types.Types[types.TUINT]), types.Types[types.TBOOL], c, nl)
+       s.vars[ptrVar] = p
 
        if !inplace {
-               s.vars[&newlenVar] = nl
-               s.vars[&capVar] = c
+               s.vars[newlenVar] = nl
+               s.vars[capVar] = c
        } else {
-               s.vars[&lenVar] = l
+               s.vars[lenVar] = l
        }
 
        b := s.endBlock()
@@ -2916,24 +3162,27 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 
        // Call growslice
        s.startBlock(grow)
-       taddr := s.expr(n.Left)
-       r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[TINT], types.Types[TINT]}, taddr, p, l, c, nl)
+       taddr := s.expr(n.X)
+       r := s.rtcall(ir.Syms.Growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
        if inplace {
-               if sn.Op == ONAME && sn.Class() != PEXTERN {
-                       // Tell liveness we're about to build a new slice
-                       s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
+               if sn.Op() == ir.ONAME {
+                       sn := sn.(*ir.Name)
+                       if sn.Class != ir.PEXTERN {
+                               // Tell liveness we're about to build a new slice
+                               s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
+                       }
                }
-               capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
-               s.store(types.Types[TINT], capaddr, r[2])
+               capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, types.SliceCapOffset, addr)
+               s.store(types.Types[types.TINT], capaddr, r[2])
                s.store(pt, addr, r[0])
                // load the value we just stored to avoid having to spill it
-               s.vars[&ptrVar] = s.load(pt, addr)
-               s.vars[&lenVar] = r[1] // avoid a spill in the fast path
+               s.vars[ptrVar] = s.load(pt, addr)
+               s.vars[lenVar] = r[1] // avoid a spill in the fast path
        } else {
-               s.vars[&ptrVar] = r[0]
-               s.vars[&newlenVar] = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], r[1], s.constInt(types.Types[TINT], nargs))
-               s.vars[&capVar] = r[2]
+               s.vars[ptrVar] = r[0]
+               s.vars[newlenVar] = s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], r[1], s.constInt(types.Types[types.TINT], nargs))
+               s.vars[capVar] = r[2]
        }
 
        b = s.endBlock()
@@ -2943,10 +3192,10 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
        s.startBlock(assign)
 
        if inplace {
-               l = s.variable(&lenVar, types.Types[TINT]) // generates phi for len
-               nl = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
-               lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceLenOffset, addr)
-               s.store(types.Types[TINT], lenaddr, nl)
+               l = s.variable(lenVar, types.Types[types.TINT]) // generates phi for len
+               nl = s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], l, s.constInt(types.Types[types.TINT], nargs))
+               lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, types.SliceLenOffset, addr)
+               s.store(types.Types[types.TINT], lenaddr, nl)
        }
 
        // Evaluate args
@@ -2957,8 +3206,8 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
                store bool
        }
        args := make([]argRec, 0, nargs)
-       for _, n := range n.List.Slice()[1:] {
-               if canSSAType(n.Type) {
+       for _, n := range n.Args[1:] {
+               if TypeOK(n.Type()) {
                        args = append(args, argRec{v: s.expr(n), store: true})
                } else {
                        v := s.addr(n)
@@ -2966,14 +3215,14 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
                }
        }
 
-       p = s.variable(&ptrVar, pt) // generates phi for ptr
+       p = s.variable(ptrVar, pt) // generates phi for ptr
        if !inplace {
-               nl = s.variable(&newlenVar, types.Types[TINT]) // generates phi for nl
-               c = s.variable(&capVar, types.Types[TINT])     // generates phi for cap
+               nl = s.variable(newlenVar, types.Types[types.TINT]) // generates phi for nl
+               c = s.variable(capVar, types.Types[types.TINT])     // generates phi for cap
        }
        p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l)
        for i, arg := range args {
-               addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(types.Types[TINT], int64(i)))
+               addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(types.Types[types.TINT], int64(i)))
                if arg.store {
                        s.storeType(et, addr, arg.v, 0, true)
                } else {
@@ -2981,29 +3230,30 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
                }
        }
 
-       delete(s.vars, &ptrVar)
+       delete(s.vars, ptrVar)
        if inplace {
-               delete(s.vars, &lenVar)
+               delete(s.vars, lenVar)
                return nil
        }
-       delete(s.vars, &newlenVar)
-       delete(s.vars, &capVar)
+       delete(s.vars, newlenVar)
+       delete(s.vars, capVar)
        // make result
-       return s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c)
+       return s.newValue3(ssa.OpSliceMake, n.Type(), p, nl, c)
 }
 
 // condBranch evaluates the boolean expression cond and branches to yes
 // if cond is true and no if cond is false.
 // This function is intended to handle && and || better than just calling
 // s.expr(cond) and branching on the result.
-func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
-       switch cond.Op {
-       case OANDAND:
+func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
+       switch cond.Op() {
+       case ir.OANDAND:
+               cond := cond.(*ir.LogicalExpr)
                mid := s.f.NewBlock(ssa.BlockPlain)
-               s.stmtList(cond.Ninit)
-               s.condBranch(cond.Left, mid, no, max8(likely, 0))
+               s.stmtList(cond.Init())
+               s.condBranch(cond.X, mid, no, max8(likely, 0))
                s.startBlock(mid)
-               s.condBranch(cond.Right, yes, no, likely)
+               s.condBranch(cond.Y, yes, no, likely)
                return
                // Note: if likely==1, then both recursive calls pass 1.
                // If likely==-1, then we don't have enough information to decide
@@ -3011,19 +3261,26 @@ func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
                // the likeliness of the first branch.
                // TODO: have the frontend give us branch prediction hints for
                // OANDAND and OOROR nodes (if it ever has such info).
-       case OOROR:
+       case ir.OOROR:
+               cond := cond.(*ir.LogicalExpr)
                mid := s.f.NewBlock(ssa.BlockPlain)
-               s.stmtList(cond.Ninit)
-               s.condBranch(cond.Left, yes, mid, min8(likely, 0))
+               s.stmtList(cond.Init())
+               s.condBranch(cond.X, yes, mid, min8(likely, 0))
                s.startBlock(mid)
-               s.condBranch(cond.Right, yes, no, likely)
+               s.condBranch(cond.Y, yes, no, likely)
                return
                // Note: if likely==-1, then both recursive calls pass -1.
                // If likely==1, then we don't have enough info to decide
                // the likelihood of the first branch.
-       case ONOT:
-               s.stmtList(cond.Ninit)
-               s.condBranch(cond.Left, no, yes, -likely)
+       case ir.ONOT:
+               cond := cond.(*ir.UnaryExpr)
+               s.stmtList(cond.Init())
+               s.condBranch(cond.X, no, yes, -likely)
+               return
+       case ir.OCONVNOP:
+               cond := cond.(*ir.ConvExpr)
+               s.stmtList(cond.Init())
+               s.condBranch(cond.X, yes, no, likely)
                return
        }
        c := s.expr(cond)
@@ -3048,17 +3305,17 @@ const (
 // If deref is true, then we do left = *right instead (and right has already been nil-checked).
 // If deref is true and right == nil, just do left = 0.
 // skip indicates assignments (at the top level) that can be avoided.
-func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask) {
-       if left.Op == ONAME && left.isBlank() {
+func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask) {
+       if left.Op() == ir.ONAME && ir.IsBlank(left) {
                return
        }
-       t := left.Type
-       dowidth(t)
+       t := left.Type()
+       types.CalcSize(t)
        if s.canSSA(left) {
                if deref {
                        s.Fatalf("can SSA LHS %v but not RHS %s", left, right)
                }
-               if left.Op == ODOT {
+               if left.Op() == ir.ODOT {
                        // We're assigning to a field of an ssa-able value.
                        // We need to build a new structure with the new value for the
                        // field we're assigning and the old values for the other fields.
@@ -3069,12 +3326,13 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
                        // For the x.b = 5 assignment we want to generate x = T{x.a, 5, x.c}
 
                        // Grab information about the structure type.
-                       t := left.Left.Type
+                       left := left.(*ir.SelectorExpr)
+                       t := left.X.Type()
                        nf := t.NumFields()
                        idx := fieldIdx(left)
 
                        // Grab old value of structure.
-                       old := s.expr(left.Left)
+                       old := s.expr(left.X)
 
                        // Make new structure.
                        new := s.newValue0(ssa.StructMakeOp(t.NumFields()), t)
@@ -3089,23 +3347,24 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
                        }
 
                        // Recursively assign the new value we've made to the base of the dot op.
-                       s.assign(left.Left, new, false, 0)
+                       s.assign(left.X, new, false, 0)
                        // TODO: do we need to update named values here?
                        return
                }
-               if left.Op == OINDEX && left.Left.Type.IsArray() {
-                       s.pushLine(left.Pos)
+               if left.Op() == ir.OINDEX && left.(*ir.IndexExpr).X.Type().IsArray() {
+                       left := left.(*ir.IndexExpr)
+                       s.pushLine(left.Pos())
                        defer s.popLine()
                        // We're assigning to an element of an ssa-able array.
                        // a[i] = v
-                       t := left.Left.Type
+                       t := left.X.Type()
                        n := t.NumElem()
 
-                       i := s.expr(left.Right) // index
+                       i := s.expr(left.Index) // index
                        if n == 0 {
                                // The bounds check must fail.  Might as well
                                // ignore the actual index and just use zeros.
-                               z := s.constInt(types.Types[TINT], 0)
+                               z := s.constInt(types.Types[types.TINT], 0)
                                s.boundsCheck(z, z, ssa.BoundsIndex, false)
                                return
                        }
@@ -3113,12 +3372,13 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
                                s.Fatalf("assigning to non-1-length array")
                        }
                        // Rewrite to a = [1]{v}
-                       len := s.constInt(types.Types[TINT], 1)
+                       len := s.constInt(types.Types[types.TINT], 1)
                        s.boundsCheck(i, len, ssa.BoundsIndex, false) // checks i == 0
                        v := s.newValue1(ssa.OpArrayMake1, t, right)
-                       s.assign(left.Left, v, false, 0)
+                       s.assign(left.X, v, false, 0)
                        return
                }
+               left := left.(*ir.Name)
                // Update variable assignment.
                s.vars[left] = right
                s.addNamedValue(left, right)
@@ -3127,19 +3387,19 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 
        // If this assignment clobbers an entire local variable, then emit
        // OpVarDef so liveness analysis knows the variable is redefined.
-       if base := clobberBase(left); base.Op == ONAME && base.Class() != PEXTERN && skip == 0 {
-               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !base.IsAutoTmp())
+       if base, ok := clobberBase(left).(*ir.Name); ok && base.OnStack() && skip == 0 {
+               s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
        }
 
        // Left is not ssa-able. Compute its address.
        addr := s.addr(left)
-       if isReflectHeaderDataField(left) {
+       if ir.IsReflectHeaderDataField(left) {
                // Package unsafe's documentation says storing pointers into
                // reflect.SliceHeader and reflect.StringHeader's Data fields
                // is valid, even though they have type uintptr (#19168).
                // Mark it pointer type to signal the writebarrier pass to
                // insert a write barrier.
-               t = types.Types[TUNSAFEPTR]
+               t = types.Types[types.TUNSAFEPTR]
        }
        if deref {
                // Treat as a mem->mem move.
@@ -3151,7 +3411,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
                return
        }
        // Treat as a store.
-       s.storeType(t, addr, right, skip, !left.IsAutoTmp())
+       s.storeType(t, addr, right, skip, !ir.IsAutoTmp(left))
 }
 
 // zeroVal returns the zero value for type t.
@@ -3182,10 +3442,10 @@ func (s *state) zeroVal(t *types.Type) *ssa.Value {
        case t.IsComplex():
                switch t.Size() {
                case 8:
-                       z := s.constFloat32(types.Types[TFLOAT32], 0)
+                       z := s.constFloat32(types.Types[types.TFLOAT32], 0)
                        return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
                case 16:
-                       z := s.constFloat64(types.Types[TFLOAT64], 0)
+                       z := s.constFloat64(types.Types[types.TFLOAT64], 0)
                        return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
                default:
                        s.Fatalf("bad sized complex type %v", t)
@@ -3231,7 +3491,7 @@ const (
 
 type sfRtCallDef struct {
        rtfn  *obj.LSym
-       rtype types.EType
+       rtype types.Kind
 }
 
 var softFloatOps map[ssa.Op]sfRtCallDef
@@ -3239,38 +3499,38 @@ var softFloatOps map[ssa.Op]sfRtCallDef
 func softfloatInit() {
        // Some of these operations get transformed by sfcall.
        softFloatOps = map[ssa.Op]sfRtCallDef{
-               ssa.OpAdd32F: sfRtCallDef{sysfunc("fadd32"), TFLOAT32},
-               ssa.OpAdd64F: sfRtCallDef{sysfunc("fadd64"), TFLOAT64},
-               ssa.OpSub32F: sfRtCallDef{sysfunc("fadd32"), TFLOAT32},
-               ssa.OpSub64F: sfRtCallDef{sysfunc("fadd64"), TFLOAT64},
-               ssa.OpMul32F: sfRtCallDef{sysfunc("fmul32"), TFLOAT32},
-               ssa.OpMul64F: sfRtCallDef{sysfunc("fmul64"), TFLOAT64},
-               ssa.OpDiv32F: sfRtCallDef{sysfunc("fdiv32"), TFLOAT32},
-               ssa.OpDiv64F: sfRtCallDef{sysfunc("fdiv64"), TFLOAT64},
-
-               ssa.OpEq64F:   sfRtCallDef{sysfunc("feq64"), TBOOL},
-               ssa.OpEq32F:   sfRtCallDef{sysfunc("feq32"), TBOOL},
-               ssa.OpNeq64F:  sfRtCallDef{sysfunc("feq64"), TBOOL},
-               ssa.OpNeq32F:  sfRtCallDef{sysfunc("feq32"), TBOOL},
-               ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), TBOOL},
-               ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), TBOOL},
-               ssa.OpLeq64F:  sfRtCallDef{sysfunc("fge64"), TBOOL},
-               ssa.OpLeq32F:  sfRtCallDef{sysfunc("fge32"), TBOOL},
-
-               ssa.OpCvt32to32F:  sfRtCallDef{sysfunc("fint32to32"), TFLOAT32},
-               ssa.OpCvt32Fto32:  sfRtCallDef{sysfunc("f32toint32"), TINT32},
-               ssa.OpCvt64to32F:  sfRtCallDef{sysfunc("fint64to32"), TFLOAT32},
-               ssa.OpCvt32Fto64:  sfRtCallDef{sysfunc("f32toint64"), TINT64},
-               ssa.OpCvt64Uto32F: sfRtCallDef{sysfunc("fuint64to32"), TFLOAT32},
-               ssa.OpCvt32Fto64U: sfRtCallDef{sysfunc("f32touint64"), TUINT64},
-               ssa.OpCvt32to64F:  sfRtCallDef{sysfunc("fint32to64"), TFLOAT64},
-               ssa.OpCvt64Fto32:  sfRtCallDef{sysfunc("f64toint32"), TINT32},
-               ssa.OpCvt64to64F:  sfRtCallDef{sysfunc("fint64to64"), TFLOAT64},
-               ssa.OpCvt64Fto64:  sfRtCallDef{sysfunc("f64toint64"), TINT64},
-               ssa.OpCvt64Uto64F: sfRtCallDef{sysfunc("fuint64to64"), TFLOAT64},
-               ssa.OpCvt64Fto64U: sfRtCallDef{sysfunc("f64touint64"), TUINT64},
-               ssa.OpCvt32Fto64F: sfRtCallDef{sysfunc("f32to64"), TFLOAT64},
-               ssa.OpCvt64Fto32F: sfRtCallDef{sysfunc("f64to32"), TFLOAT32},
+               ssa.OpAdd32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd32"), types.TFLOAT32},
+               ssa.OpAdd64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd64"), types.TFLOAT64},
+               ssa.OpSub32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd32"), types.TFLOAT32},
+               ssa.OpSub64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd64"), types.TFLOAT64},
+               ssa.OpMul32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fmul32"), types.TFLOAT32},
+               ssa.OpMul64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fmul64"), types.TFLOAT64},
+               ssa.OpDiv32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fdiv32"), types.TFLOAT32},
+               ssa.OpDiv64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fdiv64"), types.TFLOAT64},
+
+               ssa.OpEq64F:   sfRtCallDef{typecheck.LookupRuntimeFunc("feq64"), types.TBOOL},
+               ssa.OpEq32F:   sfRtCallDef{typecheck.LookupRuntimeFunc("feq32"), types.TBOOL},
+               ssa.OpNeq64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("feq64"), types.TBOOL},
+               ssa.OpNeq32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("feq32"), types.TBOOL},
+               ssa.OpLess64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fgt64"), types.TBOOL},
+               ssa.OpLess32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fgt32"), types.TBOOL},
+               ssa.OpLeq64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fge64"), types.TBOOL},
+               ssa.OpLeq32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fge32"), types.TBOOL},
+
+               ssa.OpCvt32to32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint32to32"), types.TFLOAT32},
+               ssa.OpCvt32Fto32:  sfRtCallDef{typecheck.LookupRuntimeFunc("f32toint32"), types.TINT32},
+               ssa.OpCvt64to32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint64to32"), types.TFLOAT32},
+               ssa.OpCvt32Fto64:  sfRtCallDef{typecheck.LookupRuntimeFunc("f32toint64"), types.TINT64},
+               ssa.OpCvt64Uto32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fuint64to32"), types.TFLOAT32},
+               ssa.OpCvt32Fto64U: sfRtCallDef{typecheck.LookupRuntimeFunc("f32touint64"), types.TUINT64},
+               ssa.OpCvt32to64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint32to64"), types.TFLOAT64},
+               ssa.OpCvt64Fto32:  sfRtCallDef{typecheck.LookupRuntimeFunc("f64toint32"), types.TINT32},
+               ssa.OpCvt64to64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint64to64"), types.TFLOAT64},
+               ssa.OpCvt64Fto64:  sfRtCallDef{typecheck.LookupRuntimeFunc("f64toint64"), types.TINT64},
+               ssa.OpCvt64Uto64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fuint64to64"), types.TFLOAT64},
+               ssa.OpCvt64Fto64U: sfRtCallDef{typecheck.LookupRuntimeFunc("f64touint64"), types.TUINT64},
+               ssa.OpCvt32Fto64F: sfRtCallDef{typecheck.LookupRuntimeFunc("f32to64"), types.TFLOAT64},
+               ssa.OpCvt64Fto32F: sfRtCallDef{typecheck.LookupRuntimeFunc("f64to32"), types.TFLOAT32},
        }
 }
 
@@ -3286,7 +3546,7 @@ func (s *state) sfcall(op ssa.Op, args ...*ssa.Value) (*ssa.Value, bool) {
                        args[0], args[1] = args[1], args[0]
                case ssa.OpSub32F,
                        ssa.OpSub64F:
-                       args[1] = s.newValue1(s.ssaOp(ONEG, types.Types[callDef.rtype]), args[1].Type, args[1])
+                       args[1] = s.newValue1(s.ssaOp(ir.ONEG, types.Types[callDef.rtype]), args[1].Type, args[1])
                }
 
                result := s.rtcall(callDef.rtfn, true, []*types.Type{types.Types[callDef.rtype]}, args...)[0]
@@ -3302,7 +3562,7 @@ var intrinsics map[intrinsicKey]intrinsicBuilder
 
 // An intrinsicBuilder converts a call node n into an ssa value that
 // implements that call as an intrinsic. args is a list of arguments to the func.
-type intrinsicBuilder func(s *state, n *Node, args []*ssa.Value) *ssa.Value
+type intrinsicBuilder func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value
 
 type intrinsicKey struct {
        arch *sys.Arch
@@ -3310,7 +3570,7 @@ type intrinsicKey struct {
        fn   string
 }
 
-func init() {
+func InitTables() {
        intrinsics = map[intrinsicKey]intrinsicBuilder{}
 
        var all []*sys.Arch
@@ -3365,175 +3625,175 @@ func init() {
        }
 
        /******** runtime ********/
-       if !instrumenting {
+       if !base.Flag.Cfg.Instrumenting {
                add("runtime", "slicebytetostringtmp",
-                       func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+                       func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                                // Compiler frontend optimizations emit OBYTES2STRTMP nodes
                                // for the backend instead of slicebytetostringtmp calls
                                // when not instrumenting.
-                               return s.newValue2(ssa.OpStringMake, n.Type, args[0], args[1])
+                               return s.newValue2(ssa.OpStringMake, n.Type(), args[0], args[1])
                        },
                        all...)
        }
        addF("runtime/internal/math", "MulUintptr",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[TUINT], types.Types[TUINT]), args[0], args[1])
+                               return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
                        }
-                       return s.newValue2(ssa.OpMul64uover, types.NewTuple(types.Types[TUINT], types.Types[TUINT]), args[0], args[1])
+                       return s.newValue2(ssa.OpMul64uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
                },
                sys.AMD64, sys.I386, sys.MIPS64)
        add("runtime", "KeepAlive",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        data := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, args[0])
-                       s.vars[&memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
+                       s.vars[memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
                        return nil
                },
                all...)
        add("runtime", "getclosureptr",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        return s.newValue0(ssa.OpGetClosurePtr, s.f.Config.Types.Uintptr)
                },
                all...)
 
        add("runtime", "getcallerpc",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        return s.newValue0(ssa.OpGetCallerPC, s.f.Config.Types.Uintptr)
                },
                all...)
 
        add("runtime", "getcallersp",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        return s.newValue0(ssa.OpGetCallerSP, s.f.Config.Types.Uintptr)
                },
                all...)
 
        /******** runtime/internal/sys ********/
        addF("runtime/internal/sys", "Ctz32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz32, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
        addF("runtime/internal/sys", "Ctz64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz64, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
        addF("runtime/internal/sys", "Bswap32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBswap32, types.Types[TUINT32], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBswap32, types.Types[types.TUINT32], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
        addF("runtime/internal/sys", "Bswap64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBswap64, types.Types[TUINT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBswap64, types.Types[types.TUINT64], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 
        /******** runtime/internal/atomic ********/
        addF("runtime/internal/atomic", "Load",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Load8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[TUINT8], types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT8], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[types.TUINT8], types.TypeMem), args[0], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT8], v)
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Load64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
                },
                sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "LoadAcq",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
                },
                sys.PPC64, sys.S390X)
        addF("runtime/internal/atomic", "LoadAcq64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
                },
                sys.PPC64)
        addF("runtime/internal/atomic", "Loadp",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        v := s.newValue2(ssa.OpAtomicLoadPtr, types.NewTuple(s.f.Config.Types.BytePtr, types.TypeMem), args[0], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
                        return s.newValue1(ssa.OpSelect0, s.f.Config.Types.BytePtr, v)
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
        addF("runtime/internal/atomic", "Store",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Store8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Store64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "StorepNoWB",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "StoreRel",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.PPC64, sys.S390X)
        addF("runtime/internal/atomic", "StoreRel64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.PPC64)
 
        addF("runtime/internal/atomic", "Xchg",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
                },
                sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Xchg64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
                },
                sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
-       type atomicOpEmitter func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType)
+       type atomicOpEmitter func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind)
 
-       makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.EType, emit atomicOpEmitter) intrinsicBuilder {
+       makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.Kind, emit atomicOpEmitter) intrinsicBuilder {
 
-               return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        // Target Atomic feature is identified by dynamic detection
-                       addr := s.entryNewValue1A(ssa.OpAddr, types.Types[TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
-                       v := s.load(types.Types[TBOOL], addr)
+                       addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), ir.Syms.ARM64HasATOMICS, s.sb)
+                       v := s.load(types.Types[types.TBOOL], addr)
                        b := s.endBlock()
                        b.Kind = ssa.BlockIf
                        b.SetControl(v)
@@ -3556,7 +3816,7 @@ func init() {
 
                        // Merge results.
                        s.startBlock(bEnd)
-                       if rtyp == TNIL {
+                       if rtyp == types.TNIL {
                                return nil
                        } else {
                                return s.variable(n, types.Types[rtyp])
@@ -3564,115 +3824,115 @@ func init() {
                }
        }
 
-       atomicXchgXaddEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+       atomicXchgXaddEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
                v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
-               s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+               s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
                s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
        }
        addF("runtime/internal/atomic", "Xchg",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange32, ssa.OpAtomicExchange32Variant, TUINT32, TUINT32, atomicXchgXaddEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange32, ssa.OpAtomicExchange32Variant, types.TUINT32, types.TUINT32, atomicXchgXaddEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "Xchg64",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange64, ssa.OpAtomicExchange64Variant, TUINT64, TUINT64, atomicXchgXaddEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange64, ssa.OpAtomicExchange64Variant, types.TUINT64, types.TUINT64, atomicXchgXaddEmitterARM64),
                sys.ARM64)
 
        addF("runtime/internal/atomic", "Xadd",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
                },
                sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Xadd64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
                },
                sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
        addF("runtime/internal/atomic", "Xadd",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd32, ssa.OpAtomicAdd32Variant, TUINT32, TUINT32, atomicXchgXaddEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd32, ssa.OpAtomicAdd32Variant, types.TUINT32, types.TUINT32, atomicXchgXaddEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "Xadd64",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd64, ssa.OpAtomicAdd64Variant, TUINT64, TUINT64, atomicXchgXaddEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd64, ssa.OpAtomicAdd64Variant, types.TUINT64, types.TUINT64, atomicXchgXaddEmitterARM64),
                sys.ARM64)
 
        addF("runtime/internal/atomic", "Cas",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
                },
                sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "Cas64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
                },
                sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
        addF("runtime/internal/atomic", "CasRel",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-                       s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-                       return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+                       s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+                       return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
                },
                sys.PPC64)
 
-       atomicCasEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
-               v := s.newValue4(op, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-               s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+       atomicCasEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
+               v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+               s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
                s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
        }
 
        addF("runtime/internal/atomic", "Cas",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap32, ssa.OpAtomicCompareAndSwap32Variant, TUINT32, TBOOL, atomicCasEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap32, ssa.OpAtomicCompareAndSwap32Variant, types.TUINT32, types.TBOOL, atomicCasEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "Cas64",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap64, ssa.OpAtomicCompareAndSwap64Variant, TUINT64, TBOOL, atomicCasEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap64, ssa.OpAtomicCompareAndSwap64Variant, types.TUINT64, types.TBOOL, atomicCasEmitterARM64),
                sys.ARM64)
 
        addF("runtime/internal/atomic", "And8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
        addF("runtime/internal/atomic", "And",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
        addF("runtime/internal/atomic", "Or8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
        addF("runtime/internal/atomic", "Or",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       s.vars[&memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
                        return nil
                },
                sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
-       atomicAndOrEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
-               s.vars[&memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
+       atomicAndOrEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
+               s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
        }
 
        addF("runtime/internal/atomic", "And8",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd8, ssa.OpAtomicAnd8Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd8, ssa.OpAtomicAnd8Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "And",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd32, ssa.OpAtomicAnd32Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd32, ssa.OpAtomicAnd32Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "Or8",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr8, ssa.OpAtomicOr8Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr8, ssa.OpAtomicOr8Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
                sys.ARM64)
        addF("runtime/internal/atomic", "Or",
-               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr32, ssa.OpAtomicOr32Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+               makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr32, ssa.OpAtomicOr32Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
                sys.ARM64)
 
        alias("runtime/internal/atomic", "Loadint64", "runtime/internal/atomic", "Load64", all...)
@@ -3707,57 +3967,57 @@ func init() {
 
        /******** math ********/
        addF("math", "Sqrt",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpSqrt, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpSqrt, types.Types[types.TFLOAT64], args[0])
                },
                sys.I386, sys.AMD64, sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm)
        addF("math", "Trunc",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpTrunc, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpTrunc, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
        addF("math", "Ceil",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCeil, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCeil, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
        addF("math", "Floor",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpFloor, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpFloor, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
        addF("math", "Round",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpRound, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpRound, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.PPC64, sys.S390X)
        addF("math", "RoundToEven",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpRoundToEven, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpRoundToEven, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.S390X, sys.Wasm)
        addF("math", "Abs",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpAbs, types.Types[TFLOAT64], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpAbs, types.Types[types.TFLOAT64], args[0])
                },
                sys.ARM64, sys.ARM, sys.PPC64, sys.Wasm)
        addF("math", "Copysign",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpCopysign, types.Types[TFLOAT64], args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpCopysign, types.Types[types.TFLOAT64], args[0], args[1])
                },
                sys.PPC64, sys.Wasm)
        addF("math", "FMA",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
                },
                sys.ARM64, sys.PPC64, sys.S390X)
        addF("math", "FMA",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if !s.config.UseFMA {
                                s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
-                               return s.variable(n, types.Types[TFLOAT64])
+                               return s.variable(n, types.Types[types.TFLOAT64])
                        }
-                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasFMA)
+                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasFMA)
                        b := s.endBlock()
                        b.Kind = ssa.BlockIf
                        b.SetControl(v)
@@ -3770,7 +4030,7 @@ func init() {
 
                        // We have the intrinsic - use it directly.
                        s.startBlock(bTrue)
-                       s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+                       s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
                        s.endBlock().AddEdgeTo(bEnd)
 
                        // Call the pure Go version.
@@ -3780,17 +4040,17 @@ func init() {
 
                        // Merge results.
                        s.startBlock(bEnd)
-                       return s.variable(n, types.Types[TFLOAT64])
+                       return s.variable(n, types.Types[types.TFLOAT64])
                },
                sys.AMD64)
        addF("math", "FMA",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if !s.config.UseFMA {
                                s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
-                               return s.variable(n, types.Types[TFLOAT64])
+                               return s.variable(n, types.Types[types.TFLOAT64])
                        }
-                       addr := s.entryNewValue1A(ssa.OpAddr, types.Types[TBOOL].PtrTo(), armHasVFPv4, s.sb)
-                       v := s.load(types.Types[TBOOL], addr)
+                       addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), ir.Syms.ARMHasVFPv4, s.sb)
+                       v := s.load(types.Types[types.TBOOL], addr)
                        b := s.endBlock()
                        b.Kind = ssa.BlockIf
                        b.SetControl(v)
@@ -3803,7 +4063,7 @@ func init() {
 
                        // We have the intrinsic - use it directly.
                        s.startBlock(bTrue)
-                       s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+                       s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
                        s.endBlock().AddEdgeTo(bEnd)
 
                        // Call the pure Go version.
@@ -3813,13 +4073,13 @@ func init() {
 
                        // Merge results.
                        s.startBlock(bEnd)
-                       return s.variable(n, types.Types[TFLOAT64])
+                       return s.variable(n, types.Types[types.TFLOAT64])
                },
                sys.ARM)
 
-       makeRoundAMD64 := func(op ssa.Op) func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-               return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasSSE41)
+       makeRoundAMD64 := func(op ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+               return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasSSE41)
                        b := s.endBlock()
                        b.Kind = ssa.BlockIf
                        b.SetControl(v)
@@ -3832,7 +4092,7 @@ func init() {
 
                        // We have the intrinsic - use it directly.
                        s.startBlock(bTrue)
-                       s.vars[n] = s.newValue1(op, types.Types[TFLOAT64], args[0])
+                       s.vars[n] = s.newValue1(op, types.Types[types.TFLOAT64], args[0])
                        s.endBlock().AddEdgeTo(bEnd)
 
                        // Call the pure Go version.
@@ -3842,7 +4102,7 @@ func init() {
 
                        // Merge results.
                        s.startBlock(bEnd)
-                       return s.variable(n, types.Types[TFLOAT64])
+                       return s.variable(n, types.Types[types.TFLOAT64])
                }
        }
        addF("math", "RoundToEven",
@@ -3860,55 +4120,55 @@ func init() {
 
        /******** math/bits ********/
        addF("math/bits", "TrailingZeros64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz64, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "TrailingZeros32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz32, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "TrailingZeros16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       x := s.newValue1(ssa.OpZeroExt16to32, types.Types[TUINT32], args[0])
-                       c := s.constInt32(types.Types[TUINT32], 1<<16)
-                       y := s.newValue2(ssa.OpOr32, types.Types[TUINT32], x, c)
-                       return s.newValue1(ssa.OpCtz32, types.Types[TINT], y)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
+                       c := s.constInt32(types.Types[types.TUINT32], 1<<16)
+                       y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
+                       return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], y)
                },
                sys.MIPS)
        addF("math/bits", "TrailingZeros16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz16, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz16, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.I386, sys.ARM, sys.ARM64, sys.Wasm)
        addF("math/bits", "TrailingZeros16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       x := s.newValue1(ssa.OpZeroExt16to64, types.Types[TUINT64], args[0])
-                       c := s.constInt64(types.Types[TUINT64], 1<<16)
-                       y := s.newValue2(ssa.OpOr64, types.Types[TUINT64], x, c)
-                       return s.newValue1(ssa.OpCtz64, types.Types[TINT], y)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
+                       c := s.constInt64(types.Types[types.TUINT64], 1<<16)
+                       y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
+                       return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], y)
                },
                sys.S390X, sys.PPC64)
        addF("math/bits", "TrailingZeros8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       x := s.newValue1(ssa.OpZeroExt8to32, types.Types[TUINT32], args[0])
-                       c := s.constInt32(types.Types[TUINT32], 1<<8)
-                       y := s.newValue2(ssa.OpOr32, types.Types[TUINT32], x, c)
-                       return s.newValue1(ssa.OpCtz32, types.Types[TINT], y)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
+                       c := s.constInt32(types.Types[types.TUINT32], 1<<8)
+                       y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
+                       return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], y)
                },
                sys.MIPS)
        addF("math/bits", "TrailingZeros8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpCtz8, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM, sys.ARM64, sys.Wasm)
        addF("math/bits", "TrailingZeros8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       x := s.newValue1(ssa.OpZeroExt8to64, types.Types[TUINT64], args[0])
-                       c := s.constInt64(types.Types[TUINT64], 1<<8)
-                       y := s.newValue2(ssa.OpOr64, types.Types[TUINT64], x, c)
-                       return s.newValue1(ssa.OpCtz64, types.Types[TINT], y)
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
+                       c := s.constInt64(types.Types[types.TUINT64], 1<<8)
+                       y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
+                       return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], y)
                },
                sys.S390X)
        alias("math/bits", "ReverseBytes64", "runtime/internal/sys", "Bswap64", all...)
@@ -3916,116 +4176,116 @@ func init() {
        // ReverseBytes inlines correctly, no need to intrinsify it.
        // ReverseBytes16 lowers to a rotate, no need for anything special here.
        addF("math/bits", "Len64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitLen64, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "Len32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64)
        addF("math/bits", "Len32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+                               return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
                        }
-                       x := s.newValue1(ssa.OpZeroExt32to64, types.Types[TUINT64], args[0])
-                       return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+                       x := s.newValue1(ssa.OpZeroExt32to64, types.Types[types.TUINT64], args[0])
+                       return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
                },
                sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "Len16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               x := s.newValue1(ssa.OpZeroExt16to32, types.Types[TUINT32], args[0])
-                               return s.newValue1(ssa.OpBitLen32, types.Types[TINT], x)
+                               x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
+                               return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
                        }
-                       x := s.newValue1(ssa.OpZeroExt16to64, types.Types[TUINT64], args[0])
-                       return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+                       x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
+                       return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
                },
                sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "Len16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitLen16, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitLen16, types.Types[types.TINT], args[0])
                },
                sys.AMD64)
        addF("math/bits", "Len8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               x := s.newValue1(ssa.OpZeroExt8to32, types.Types[TUINT32], args[0])
-                               return s.newValue1(ssa.OpBitLen32, types.Types[TINT], x)
+                               x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
+                               return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
                        }
-                       x := s.newValue1(ssa.OpZeroExt8to64, types.Types[TUINT64], args[0])
-                       return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+                       x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
+                       return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
                },
                sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        addF("math/bits", "Len8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitLen8, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitLen8, types.Types[types.TINT], args[0])
                },
                sys.AMD64)
        addF("math/bits", "Len",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+                               return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
                        }
-                       return s.newValue1(ssa.OpBitLen64, types.Types[TINT], args[0])
+                       return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
                },
                sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
        // LeadingZeros is handled because it trivially calls Len.
        addF("math/bits", "Reverse64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitRev64, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
                },
                sys.ARM64)
        addF("math/bits", "Reverse32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitRev32, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
                },
                sys.ARM64)
        addF("math/bits", "Reverse16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitRev16, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitRev16, types.Types[types.TINT], args[0])
                },
                sys.ARM64)
        addF("math/bits", "Reverse8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpBitRev8, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpBitRev8, types.Types[types.TINT], args[0])
                },
                sys.ARM64)
        addF("math/bits", "Reverse",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        if s.config.PtrSize == 4 {
-                               return s.newValue1(ssa.OpBitRev32, types.Types[TINT], args[0])
+                               return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
                        }
-                       return s.newValue1(ssa.OpBitRev64, types.Types[TINT], args[0])
+                       return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
                },
                sys.ARM64)
        addF("math/bits", "RotateLeft8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpRotateLeft8, types.Types[TUINT8], args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpRotateLeft8, types.Types[types.TUINT8], args[0], args[1])
                },
                sys.AMD64)
        addF("math/bits", "RotateLeft16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpRotateLeft16, types.Types[TUINT16], args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpRotateLeft16, types.Types[types.TUINT16], args[0], args[1])
                },
                sys.AMD64)
        addF("math/bits", "RotateLeft32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpRotateLeft32, types.Types[TUINT32], args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpRotateLeft32, types.Types[types.TUINT32], args[0], args[1])
                },
                sys.AMD64, sys.ARM, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
        addF("math/bits", "RotateLeft64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpRotateLeft64, types.Types[TUINT64], args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpRotateLeft64, types.Types[types.TUINT64], args[0], args[1])
                },
                sys.AMD64, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
        alias("math/bits", "RotateLeft", "math/bits", "RotateLeft64", p8...)
 
-       makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-               return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasPOPCNT)
+       makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+               return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasPOPCNT)
                        b := s.endBlock()
                        b.Kind = ssa.BlockIf
                        b.SetControl(v)
@@ -4042,7 +4302,7 @@ func init() {
                        if s.config.PtrSize == 4 {
                                op = op32
                        }
-                       s.vars[n] = s.newValue1(op, types.Types[TINT], args[0])
+                       s.vars[n] = s.newValue1(op, types.Types[types.TINT], args[0])
                        s.endBlock().AddEdgeTo(bEnd)
 
                        // Call the pure Go version.
@@ -4052,67 +4312,67 @@ func init() {
 
                        // Merge results.
                        s.startBlock(bEnd)
-                       return s.variable(n, types.Types[TINT])
+                       return s.variable(n, types.Types[types.TINT])
                }
        }
        addF("math/bits", "OnesCount64",
                makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount64),
                sys.AMD64)
        addF("math/bits", "OnesCount64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpPopCount64, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpPopCount64, types.Types[types.TINT], args[0])
                },
                sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
        addF("math/bits", "OnesCount32",
                makeOnesCountAMD64(ssa.OpPopCount32, ssa.OpPopCount32),
                sys.AMD64)
        addF("math/bits", "OnesCount32",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpPopCount32, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpPopCount32, types.Types[types.TINT], args[0])
                },
                sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
        addF("math/bits", "OnesCount16",
                makeOnesCountAMD64(ssa.OpPopCount16, ssa.OpPopCount16),
                sys.AMD64)
        addF("math/bits", "OnesCount16",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpPopCount16, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpPopCount16, types.Types[types.TINT], args[0])
                },
                sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
        addF("math/bits", "OnesCount8",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue1(ssa.OpPopCount8, types.Types[TINT], args[0])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue1(ssa.OpPopCount8, types.Types[types.TINT], args[0])
                },
                sys.S390X, sys.PPC64, sys.Wasm)
        addF("math/bits", "OnesCount",
                makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount32),
                sys.AMD64)
        addF("math/bits", "Mul64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
                },
                sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
        alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
        addF("math/bits", "Add64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
                },
                sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X)
        alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X)
        addF("math/bits", "Sub64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
                },
                sys.AMD64, sys.ARM64, sys.S390X)
        alias("math/bits", "Sub", "math/bits", "Sub64", sys.ArchAMD64, sys.ArchARM64, sys.ArchS390X)
        addF("math/bits", "Div64",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
                        // check for divide-by-zero/overflow and panic with appropriate message
-                       cmpZero := s.newValue2(s.ssaOp(ONE, types.Types[TUINT64]), types.Types[TBOOL], args[2], s.zeroVal(types.Types[TUINT64]))
-                       s.check(cmpZero, panicdivide)
-                       cmpOverflow := s.newValue2(s.ssaOp(OLT, types.Types[TUINT64]), types.Types[TBOOL], args[0], args[2])
-                       s.check(cmpOverflow, panicoverflow)
-                       return s.newValue3(ssa.OpDiv128u, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+                       cmpZero := s.newValue2(s.ssaOp(ir.ONE, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[2], s.zeroVal(types.Types[types.TUINT64]))
+                       s.check(cmpZero, ir.Syms.Panicdivide)
+                       cmpOverflow := s.newValue2(s.ssaOp(ir.OLT, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[0], args[2])
+                       s.check(cmpOverflow, ir.Syms.Panicoverflow)
+                       return s.newValue3(ssa.OpDiv128u, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
                },
                sys.AMD64)
        alias("math/bits", "Div", "math/bits", "Div64", sys.ArchAMD64)
@@ -4166,8 +4426,8 @@ func init() {
 
        /******** math/big ********/
        add("math/big", "mulWW",
-               func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-                       return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1])
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
                },
                sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64LE, sys.ArchPPC64, sys.ArchS390X)
 }
@@ -4179,17 +4439,17 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
                return nil
        }
        pkg := sym.Pkg.Path
-       if sym.Pkg == localpkg {
-               pkg = myimportpath
+       if sym.Pkg == types.LocalPkg {
+               pkg = base.Ctxt.Pkgpath
        }
-       if flag_race && pkg == "sync/atomic" {
+       if base.Flag.Race && pkg == "sync/atomic" {
                // The race detector needs to be able to intercept these calls.
                // We can't intrinsify them.
                return nil
        }
        // Skip intrinsifying math functions (which may contain hard-float
        // instructions) when soft-float
-       if thearch.SoftFloat && pkg == "math" {
+       if Arch.SoftFloat && pkg == "math" {
                return nil
        }
 
@@ -4201,19 +4461,23 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
                        return nil
                }
        }
-       return intrinsics[intrinsicKey{thearch.LinkArch.Arch, pkg, fn}]
+       return intrinsics[intrinsicKey{Arch.LinkArch.Arch, pkg, fn}]
 }
 
-func isIntrinsicCall(n *Node) bool {
-       if n == nil || n.Left == nil {
+func IsIntrinsicCall(n *ir.CallExpr) bool {
+       if n == nil {
+               return false
+       }
+       name, ok := n.X.(*ir.Name)
+       if !ok {
                return false
        }
-       return findIntrinsic(n.Left.Sym) != nil
+       return findIntrinsic(name.Sym()) != nil
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
-func (s *state) intrinsicCall(n *Node) *ssa.Value {
-       v := findIntrinsic(n.Left.Sym)(s, n, s.intrinsicArgs(n))
+func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
+       v := findIntrinsic(n.X.Sym())(s, n, s.intrinsicArgs(n))
        if ssa.IntrinsicsDebug > 0 {
                x := v
                if x == nil {
@@ -4222,36 +4486,15 @@ func (s *state) intrinsicCall(n *Node) *ssa.Value {
                if x.Op == ssa.OpSelect0 || x.Op == ssa.OpSelect1 {
                        x = x.Args[0]
                }
-               Warnl(n.Pos, "intrinsic substitution for %v with %s", n.Left.Sym.Name, x.LongString())
+               base.WarnfAt(n.Pos(), "intrinsic substitution for %v with %s", n.X.Sym().Name, x.LongString())
        }
        return v
 }
 
 // intrinsicArgs extracts args from n, evaluates them to SSA values, and returns them.
-func (s *state) intrinsicArgs(n *Node) []*ssa.Value {
-       // Construct map of temps; see comments in s.call about the structure of n.
-       temps := map[*Node]*ssa.Value{}
-       for _, a := range n.List.Slice() {
-               if a.Op != OAS {
-                       s.Fatalf("non-assignment as a temp function argument %v", a.Op)
-               }
-               l, r := a.Left, a.Right
-               if l.Op != ONAME {
-                       s.Fatalf("non-ONAME temp function argument %v", a.Op)
-               }
-               // Evaluate and store to "temporary".
-               // Walk ensures these temporaries are dead outside of n.
-               temps[l] = s.expr(r)
-       }
-       args := make([]*ssa.Value, n.Rlist.Len())
-       for i, n := range n.Rlist.Slice() {
-               // Store a value to an argument slot.
-               if x, ok := temps[n]; ok {
-                       // This is a previously computed temporary.
-                       args[i] = x
-                       continue
-               }
-               // This is an explicit value; evaluate it.
+func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
+       args := make([]*ssa.Value, len(n.Args))
+       for i, n := range n.Args {
                args[i] = s.expr(n)
        }
        return args
@@ -4263,62 +4506,48 @@ func (s *state) intrinsicArgs(n *Node) []*ssa.Value {
 // call. We will also record funcdata information on where the args are stored
 // (as well as the deferBits variable), and this will enable us to run the proper
 // defer calls during panics.
-func (s *state) openDeferRecord(n *Node) {
-       // Do any needed expression evaluation for the args (including the
-       // receiver, if any). This may be evaluating something like 'autotmp_3 =
-       // once.mutex'. Such a statement will create a mapping in s.vars[] from
-       // the autotmp name to the evaluated SSA arg value, but won't do any
-       // stores to the stack.
-       s.stmtList(n.List)
-
+func (s *state) openDeferRecord(n *ir.CallExpr) {
        var args []*ssa.Value
-       var argNodes []*Node
+       var argNodes []*ir.Name
 
        opendefer := &openDeferInfo{
                n: n,
        }
-       fn := n.Left
-       if n.Op == OCALLFUNC {
+       fn := n.X
+       if n.Op() == ir.OCALLFUNC {
                // We must always store the function value in a stack slot for the
                // runtime panic code to use. But in the defer exit code, we will
                // call the function directly if it is a static function.
                closureVal := s.expr(fn)
-               closure := s.openDeferSave(nil, fn.Type, closureVal)
-               opendefer.closureNode = closure.Aux.(*Node)
-               if !(fn.Op == ONAME && fn.Class() == PFUNC) {
+               closure := s.openDeferSave(nil, fn.Type(), closureVal)
+               opendefer.closureNode = closure.Aux.(*ir.Name)
+               if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC) {
                        opendefer.closure = closure
                }
-       } else if n.Op == OCALLMETH {
-               if fn.Op != ODOTMETH {
-                       Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
-               }
-               closureVal := s.getMethodClosure(fn)
-               // We must always store the function value in a stack slot for the
-               // runtime panic code to use. But in the defer exit code, we will
-               // call the method directly.
-               closure := s.openDeferSave(nil, fn.Type, closureVal)
-               opendefer.closureNode = closure.Aux.(*Node)
+       } else if n.Op() == ir.OCALLMETH {
+               base.Fatalf("OCALLMETH missed by walkCall")
        } else {
-               if fn.Op != ODOTINTER {
-                       Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
+               if fn.Op() != ir.ODOTINTER {
+                       base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
                }
+               fn := fn.(*ir.SelectorExpr)
                closure, rcvr := s.getClosureAndRcvr(fn)
                opendefer.closure = s.openDeferSave(nil, closure.Type, closure)
                // Important to get the receiver type correct, so it is recognized
                // as a pointer for GC purposes.
-               opendefer.rcvr = s.openDeferSave(nil, fn.Type.Recv().Type, rcvr)
-               opendefer.closureNode = opendefer.closure.Aux.(*Node)
-               opendefer.rcvrNode = opendefer.rcvr.Aux.(*Node)
+               opendefer.rcvr = s.openDeferSave(nil, fn.Type().Recv().Type, rcvr)
+               opendefer.closureNode = opendefer.closure.Aux.(*ir.Name)
+               opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Name)
        }
-       for _, argn := range n.Rlist.Slice() {
+       for _, argn := range n.Args {
                var v *ssa.Value
-               if canSSAType(argn.Type) {
-                       v = s.openDeferSave(nil, argn.Type, s.expr(argn))
+               if TypeOK(argn.Type()) {
+                       v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
                } else {
-                       v = s.openDeferSave(argn, argn.Type, nil)
+                       v = s.openDeferSave(argn, argn.Type(), nil)
                }
                args = append(args, v)
-               argNodes = append(argNodes, v.Aux.(*Node))
+               argNodes = append(argNodes, v.Aux.(*ir.Name))
        }
        opendefer.argVals = args
        opendefer.argNodes = argNodes
@@ -4327,10 +4556,10 @@ func (s *state) openDeferRecord(n *Node) {
 
        // Update deferBits only after evaluation and storage to stack of
        // args/receiver/interface is successful.
-       bitvalue := s.constInt8(types.Types[TUINT8], 1<<uint(index))
-       newDeferBits := s.newValue2(ssa.OpOr8, types.Types[TUINT8], s.variable(&deferBitsVar, types.Types[TUINT8]), bitvalue)
-       s.vars[&deferBitsVar] = newDeferBits
-       s.store(types.Types[TUINT8], s.deferBitsAddr, newDeferBits)
+       bitvalue := s.constInt8(types.Types[types.TUINT8], 1<<uint(index))
+       newDeferBits := s.newValue2(ssa.OpOr8, types.Types[types.TUINT8], s.variable(deferBitsVar, types.Types[types.TUINT8]), bitvalue)
+       s.vars[deferBitsVar] = newDeferBits
+       s.store(types.Types[types.TUINT8], s.deferBitsAddr, newDeferBits)
 }
 
 // openDeferSave generates SSA nodes to store a value (with type t) for an
@@ -4340,16 +4569,16 @@ func (s *state) openDeferRecord(n *Node) {
 // type t is non-SSAable, then n must be non-nil (and val should be nil) and n is
 // evaluated (via s.addr() below) to get the value that is to be stored. The
 // function returns an SSA value representing a pointer to the autotmp location.
-func (s *state) openDeferSave(n *Node, t *types.Type, val *ssa.Value) *ssa.Value {
-       canSSA := canSSAType(t)
+func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Value {
+       canSSA := TypeOK(t)
        var pos src.XPos
        if canSSA {
                pos = val.Pos
        } else {
-               pos = n.Pos
+               pos = n.Pos()
        }
-       argTemp := tempAt(pos.WithNotStmt(), s.curfn, t)
-       argTemp.Name.SetOpenDeferSlot(true)
+       argTemp := typecheck.TempAt(pos.WithNotStmt(), s.curfn, t)
+       argTemp.SetOpenDeferSlot(true)
        var addrArgTemp *ssa.Value
        // Use OpVarLive to make sure stack slots for the args, etc. are not
        // removed by dead-store elimination
@@ -4358,16 +4587,16 @@ func (s *state) openDeferSave(n *Node, t *types.Type, val *ssa.Value) *ssa.Value
                // declared in the entry block, so that it will be live for the
                // defer exit code (which will actually access it only if the
                // associated defer call has been activated).
-               s.defvars[s.f.Entry.ID][&memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][&memVar])
-               s.defvars[s.f.Entry.ID][&memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][&memVar])
-               addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.defvars[s.f.Entry.ID][&memVar])
+               s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+               s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+               addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
        } else {
                // Special case if we're still in the entry block. We can't use
                // the above code, since s.defvars[s.f.Entry.ID] isn't defined
                // until we end the entry block with s.endBlock().
-               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, argTemp, s.mem(), false)
-               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argTemp, s.mem(), false)
-               addrArgTemp = s.newValue2Apos(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.mem(), false)
+               s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, argTemp, s.mem(), false)
+               s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argTemp, s.mem(), false)
+               addrArgTemp = s.newValue2Apos(ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.mem(), false)
        }
        if t.HasPointers() {
                // Since we may use this argTemp during exit depending on the
@@ -4375,7 +4604,7 @@ func (s *state) openDeferSave(n *Node, t *types.Type, val *ssa.Value) *ssa.Value
                // Therefore, we must make sure it is zeroed out in the entry
                // block if it contains pointers, else GC may wrongly follow an
                // uninitialized pointer value.
-               argTemp.Name.SetNeedzero(true)
+               argTemp.SetNeedzero(true)
        }
        if !canSSA {
                a := s.addr(n)
@@ -4398,20 +4627,19 @@ func (s *state) openDeferExit() {
        s.startBlock(deferExit)
        s.lastDeferExit = deferExit
        s.lastDeferCount = len(s.openDefers)
-       zeroval := s.constInt8(types.Types[TUINT8], 0)
-       testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
+       zeroval := s.constInt8(types.Types[types.TUINT8], 0)
        // Test for and run defers in reverse order
        for i := len(s.openDefers) - 1; i >= 0; i-- {
                r := s.openDefers[i]
                bCond := s.f.NewBlock(ssa.BlockPlain)
                bEnd := s.f.NewBlock(ssa.BlockPlain)
 
-               deferBits := s.variable(&deferBitsVar, types.Types[TUINT8])
+               deferBits := s.variable(deferBitsVar, types.Types[types.TUINT8])
                // Generate code to check if the bit associated with the current
                // defer is set.
-               bitval := s.constInt8(types.Types[TUINT8], 1<<uint(i))
-               andval := s.newValue2(ssa.OpAnd8, types.Types[TUINT8], deferBits, bitval)
-               eqVal := s.newValue2(ssa.OpEq8, types.Types[TBOOL], andval, zeroval)
+               bitval := s.constInt8(types.Types[types.TUINT8], 1<<uint(i))
+               andval := s.newValue2(ssa.OpAnd8, types.Types[types.TUINT8], deferBits, bitval)
+               eqVal := s.newValue2(ssa.OpEq8, types.Types[types.TBOOL], andval, zeroval)
                b := s.endBlock()
                b.Kind = ssa.BlockIf
                b.SetControl(eqVal)
@@ -4422,100 +4650,69 @@ func (s *state) openDeferExit() {
 
                // Clear this bit in deferBits and force store back to stack, so
                // we will not try to re-run this defer call if this defer call panics.
-               nbitval := s.newValue1(ssa.OpCom8, types.Types[TUINT8], bitval)
-               maskedval := s.newValue2(ssa.OpAnd8, types.Types[TUINT8], deferBits, nbitval)
-               s.store(types.Types[TUINT8], s.deferBitsAddr, maskedval)
+               nbitval := s.newValue1(ssa.OpCom8, types.Types[types.TUINT8], bitval)
+               maskedval := s.newValue2(ssa.OpAnd8, types.Types[types.TUINT8], deferBits, nbitval)
+               s.store(types.Types[types.TUINT8], s.deferBitsAddr, maskedval)
                // Use this value for following tests, so we keep previous
                // bits cleared.
-               s.vars[&deferBitsVar] = maskedval
+               s.vars[deferBitsVar] = maskedval
 
                // Generate code to call the function call of the defer, using the
                // closure/receiver/args that were stored in argtmps at the point
                // of the defer statement.
-               argStart := Ctxt.FixedFrameSize()
-               fn := r.n.Left
-               stksize := fn.Type.ArgWidth()
+               argStart := base.Ctxt.FixedFrameSize()
+               fn := r.n.X
+               stksize := fn.Type().ArgWidth()
                var ACArgs []ssa.Param
                var ACResults []ssa.Param
                var callArgs []*ssa.Value
                if r.rcvr != nil {
                        // rcvr in case of OCALLINTER
                        v := s.load(r.rcvr.Type.Elem(), r.rcvr)
-                       addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
-                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart)})
-                       if testLateExpansion {
-                               callArgs = append(callArgs, v)
-                       } else {
-                               s.store(types.Types[TUINTPTR], addr, v)
-                       }
+                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
+                       callArgs = append(callArgs, v)
                }
                for j, argAddrVal := range r.argVals {
                        f := getParam(r.n, j)
-                       pt := types.NewPtr(f.Type)
                        ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + f.Offset)})
-                       if testLateExpansion {
-                               var a *ssa.Value
-                               if !canSSAType(f.Type) {
-                                       a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
-                               } else {
-                                       a = s.load(f.Type, argAddrVal)
-                               }
-                               callArgs = append(callArgs, a)
+                       var a *ssa.Value
+                       if !TypeOK(f.Type) {
+                               a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
                        } else {
-                               addr := s.constOffPtrSP(pt, argStart+f.Offset)
-                               if !canSSAType(f.Type) {
-                                       s.move(f.Type, addr, argAddrVal)
-                               } else {
-                                       argVal := s.load(f.Type, argAddrVal)
-                                       s.storeType(f.Type, addr, argVal, 0, false)
-                               }
+                               a = s.load(f.Type, argAddrVal)
                        }
+                       callArgs = append(callArgs, a)
                }
                var call *ssa.Value
                if r.closure != nil {
                        v := s.load(r.closure.Type.Elem(), r.closure)
                        s.maybeNilCheckClosure(v, callDefer)
-                       codeptr := s.rawLoad(types.Types[TUINTPTR], v)
+                       codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
                        aux := ssa.ClosureAuxCall(ACArgs, ACResults)
-                       if testLateExpansion {
-                               callArgs = append(callArgs, s.mem())
-                               call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, aux, codeptr, v, s.mem())
-                       }
+                       call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
                } else {
-                       aux := ssa.StaticAuxCall(fn.Sym.Linksym(), ACArgs, ACResults)
-                       if testLateExpansion {
-                               callArgs = append(callArgs, s.mem())
-                               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               // Do a static call if the original call was a static function or method
-                               call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-                       }
+                       aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults)
+                       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
                }
+               callArgs = append(callArgs, s.mem())
+               call.AddArgs(callArgs...)
                call.AuxInt = stksize
-               if testLateExpansion {
-                       s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-               } else {
-                       s.vars[&memVar] = call
-               }
+               s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
                // Make sure that the stack slots with pointers are kept live
                // through the call (which is a pre-emption point). Also, we will
                // use the first call of the last defer exit to compute liveness
                // for the deferreturn, so we want all stack slots to be live.
                if r.closureNode != nil {
-                       s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
+                       s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
                }
                if r.rcvrNode != nil {
-                       if r.rcvrNode.Type.HasPointers() {
-                               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
+                       if r.rcvrNode.Type().HasPointers() {
+                               s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
                        }
                }
                for _, argNode := range r.argNodes {
-                       if argNode.Type.HasPointers() {
-                               s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
+                       if argNode.Type().HasPointers() {
+                               s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
                        }
                }
 
@@ -4524,42 +4721,49 @@ func (s *state) openDeferExit() {
        }
 }
 
-func (s *state) callResult(n *Node, k callKind) *ssa.Value {
+func (s *state) callResult(n *ir.CallExpr, k callKind) *ssa.Value {
        return s.call(n, k, false)
 }
 
-func (s *state) callAddr(n *Node, k callKind) *ssa.Value {
+func (s *state) callAddr(n *ir.CallExpr, k callKind) *ssa.Value {
        return s.call(n, k, true)
 }
 
 // Calls the function n using the specified call type.
 // Returns the address of the return value (or nil if none).
-func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
+func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Value {
        s.prevCall = nil
-       var sym *types.Sym     // target symbol (if static)
+       var callee *ir.Name    // target function (if static)
        var closure *ssa.Value // ptr to closure to run (if dynamic)
        var codeptr *ssa.Value // ptr to target code (if dynamic)
        var rcvr *ssa.Value    // receiver to set
-       fn := n.Left
+       fn := n.X
        var ACArgs []ssa.Param
        var ACResults []ssa.Param
        var callArgs []*ssa.Value
-       res := n.Left.Type.Results()
+       res := n.X.Type().Results()
        if k == callNormal {
                nf := res.NumFields()
                for i := 0; i < nf; i++ {
                        fp := res.Field(i)
-                       ACResults = append(ACResults, ssa.Param{Type: fp.Type, Offset: int32(fp.Offset + Ctxt.FixedFrameSize())})
+                       ACResults = append(ACResults, ssa.Param{Type: fp.Type, Offset: int32(fp.Offset + base.Ctxt.FixedFrameSize())})
                }
        }
 
-       testLateExpansion := false
+       inRegisters := false
 
-       switch n.Op {
-       case OCALLFUNC:
-               testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-               if k == callNormal && fn.Op == ONAME && fn.Class() == PFUNC {
-                       sym = fn.Sym
+       switch n.Op() {
+       case ir.OCALLFUNC:
+               if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
+                       fn := fn.(*ir.Name)
+                       callee = fn
+                       // TODO remove after register abi is working
+                       inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
+                       inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
+                       inRegisters = inRegistersImported || inRegistersSamePackage
+                       if inRegisters {
+                               s.f.Warnl(n.Pos(), "called function %v has register params", callee)
+                       }
                        break
                }
                closure = s.expr(fn)
@@ -4568,54 +4772,38 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
                        // not the point of defer statement.
                        s.maybeNilCheckClosure(closure, k)
                }
-       case OCALLMETH:
-               if fn.Op != ODOTMETH {
-                       s.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
+       case ir.OCALLMETH:
+               base.Fatalf("OCALLMETH missed by walkCall")
+       case ir.OCALLINTER:
+               if fn.Op() != ir.ODOTINTER {
+                       s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
                }
-               testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-               if k == callNormal {
-                       sym = fn.Sym
-                       break
-               }
-               closure = s.getMethodClosure(fn)
-               // Note: receiver is already present in n.Rlist, so we don't
-               // want to set it here.
-       case OCALLINTER:
-               if fn.Op != ODOTINTER {
-                       s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
-               }
-               testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
+               fn := fn.(*ir.SelectorExpr)
                var iclosure *ssa.Value
                iclosure, rcvr = s.getClosureAndRcvr(fn)
                if k == callNormal {
-                       codeptr = s.load(types.Types[TUINTPTR], iclosure)
+                       codeptr = s.load(types.Types[types.TUINTPTR], iclosure)
                } else {
                        closure = iclosure
                }
        }
-       dowidth(fn.Type)
-       stksize := fn.Type.ArgWidth() // includes receiver, args, and results
-
-       // Run all assignments of temps.
-       // The temps are introduced to avoid overwriting argument
-       // slots when arguments themselves require function calls.
-       s.stmtList(n.List)
+       types.CalcSize(fn.Type())
+       stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
        var call *ssa.Value
        if k == callDeferStack {
-               testLateExpansion = ssa.LateCallExpansionEnabledWithin(s.f)
                // Make a defer struct d on the stack.
                t := deferstruct(stksize)
-               d := tempAt(n.Pos, s.curfn, t)
+               d := typecheck.TempAt(n.Pos(), s.curfn, t)
 
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
+               s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
                addr := s.addr(d)
 
                // Must match reflect.go:deferstruct and src/runtime/runtime2.go:_defer.
                // 0: siz
-               s.store(types.Types[TUINT32],
-                       s.newValue1I(ssa.OpOffPtr, types.Types[TUINT32].PtrTo(), t.FieldOff(0), addr),
-                       s.constInt32(types.Types[TUINT32], int32(stksize)))
+               s.store(types.Types[types.TUINT32],
+                       s.newValue1I(ssa.OpOffPtr, types.Types[types.TUINT32].PtrTo(), t.FieldOff(0), addr),
+                       s.constInt32(types.Types[types.TUINT32], int32(stksize)))
                // 1: started, set in deferprocStack
                // 2: heap, set in deferprocStack
                // 3: openDefer
@@ -4632,20 +4820,18 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
                // 11: fd
 
                // Then, store all the arguments of the defer call.
-               ft := fn.Type
+               ft := fn.Type()
                off := t.FieldOff(12)
-               args := n.Rlist.Slice()
+               args := n.Args
 
                // Set receiver (for interface calls). Always a pointer.
                if rcvr != nil {
                        p := s.newValue1I(ssa.OpOffPtr, ft.Recv().Type.PtrTo(), off, addr)
-                       s.store(types.Types[TUINTPTR], p, rcvr)
+                       s.store(types.Types[types.TUINTPTR], p, rcvr)
                }
                // Set receiver (for method calls).
-               if n.Op == OCALLMETH {
-                       f := ft.Recv()
-                       s.storeArgWithBase(args[0], f.Type, addr, off+f.Offset)
-                       args = args[1:]
+               if n.Op() == ir.OCALLMETH {
+                       base.Fatalf("OCALLMETH missed by walkCall")
                }
                // Set other args.
                for _, f := range ft.Params().Fields().Slice() {
@@ -4654,74 +4840,49 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
                }
 
                // Call runtime.deferprocStack with pointer to _defer record.
-               ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(Ctxt.FixedFrameSize())})
-               aux := ssa.StaticAuxCall(deferprocStack, ACArgs, ACResults)
-               if testLateExpansion {
-                       callArgs = append(callArgs, addr, s.mem())
-                       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-                       call.AddArgs(callArgs...)
-               } else {
-                       arg0 := s.constOffPtrSP(types.Types[TUINTPTR], Ctxt.FixedFrameSize())
-                       s.store(types.Types[TUINTPTR], arg0, addr)
-                       call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-               }
-               if stksize < int64(Widthptr) {
+               ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
+               aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults)
+               callArgs = append(callArgs, addr, s.mem())
+               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+               call.AddArgs(callArgs...)
+               if stksize < int64(types.PtrSize) {
                        // We need room for both the call to deferprocStack and the call to
                        // the deferred function.
                        // TODO Revisit this if/when we pass args in registers.
-                       stksize = int64(Widthptr)
+                       stksize = int64(types.PtrSize)
                }
                call.AuxInt = stksize
        } else {
                // Store arguments to stack, including defer/go arguments and receiver for method calls.
                // These are written in SP-offset order.
-               argStart := Ctxt.FixedFrameSize()
+               argStart := base.Ctxt.FixedFrameSize()
                // Defer/go args.
                if k != callNormal {
                        // Write argsize and closure (args to newproc/deferproc).
-                       argsize := s.constInt32(types.Types[TUINT32], int32(stksize))
-                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINT32], Offset: int32(argStart)})
-                       if testLateExpansion {
-                               callArgs = append(callArgs, argsize)
-                       } else {
-                               addr := s.constOffPtrSP(s.f.Config.Types.UInt32Ptr, argStart)
-                               s.store(types.Types[TUINT32], addr, argsize)
-                       }
-                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart) + int32(Widthptr)})
-                       if testLateExpansion {
-                               callArgs = append(callArgs, closure)
-                       } else {
-                               addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart+int64(Widthptr))
-                               s.store(types.Types[TUINTPTR], addr, closure)
-                       }
-                       stksize += 2 * int64(Widthptr)
-                       argStart += 2 * int64(Widthptr)
+                       argsize := s.constInt32(types.Types[types.TUINT32], int32(stksize))
+                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)})
+                       callArgs = append(callArgs, argsize)
+                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(types.PtrSize)})
+                       callArgs = append(callArgs, closure)
+                       stksize += 2 * int64(types.PtrSize)
+                       argStart += 2 * int64(types.PtrSize)
                }
 
                // Set receiver (for interface calls).
                if rcvr != nil {
-                       addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
-                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart)})
-                       if testLateExpansion {
-                               callArgs = append(callArgs, rcvr)
-                       } else {
-                               s.store(types.Types[TUINTPTR], addr, rcvr)
-                       }
+                       ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
+                       callArgs = append(callArgs, rcvr)
                }
 
                // Write args.
-               t := n.Left.Type
-               args := n.Rlist.Slice()
-               if n.Op == OCALLMETH {
-                       f := t.Recv()
-                       ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
-                       ACArgs = append(ACArgs, ACArg)
-                       callArgs = append(callArgs, arg)
-                       args = args[1:]
+               t := n.X.Type()
+               args := n.Args
+               if n.Op() == ir.OCALLMETH {
+                       base.Fatalf("OCALLMETH missed by walkCall")
                }
                for i, n := range args {
                        f := t.Params().Field(i)
-                       ACArg, arg := s.putArg(n, f.Type, argStart+f.Offset, testLateExpansion)
+                       ACArg, arg := s.putArg(n, f.Type, argStart+f.Offset)
                        ACArgs = append(ACArgs, ACArg)
                        callArgs = append(callArgs, arg)
                }
@@ -4731,64 +4892,38 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
                // call target
                switch {
                case k == callDefer:
-                       aux := ssa.StaticAuxCall(deferproc, ACArgs, ACResults)
-                       if testLateExpansion {
-                               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-                       }
+                       aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults)
+                       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
                case k == callGo:
-                       aux := ssa.StaticAuxCall(newproc, ACArgs, ACResults)
-                       if testLateExpansion {
-                               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-                       }
+                       aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults)
+                       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
                case closure != nil:
                        // rawLoad because loading the code pointer from a
                        // closure is always safe, but IsSanitizerSafeAddr
                        // can't always figure that out currently, and it's
                        // critical that we not clobber any arguments already
                        // stored onto the stack.
-                       codeptr = s.rawLoad(types.Types[TUINTPTR], closure)
-                       if testLateExpansion {
-                               aux := ssa.ClosureAuxCall(ACArgs, ACResults)
-                               call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, ssa.ClosureAuxCall(ACArgs, ACResults), codeptr, closure, s.mem())
-                       }
+                       codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
+                       aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+                       call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
                case codeptr != nil:
-                       if testLateExpansion {
-                               aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
-                               call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue2A(ssa.OpInterCall, types.TypeMem, ssa.InterfaceAuxCall(ACArgs, ACResults), codeptr, s.mem())
-                       }
-               case sym != nil:
-                       if testLateExpansion {
-                               aux := ssa.StaticAuxCall(sym.Linksym(), ACArgs, ACResults)
-                               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-                               call.AddArgs(callArgs...)
-                       } else {
-                               call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(sym.Linksym(), ACArgs, ACResults), s.mem())
-                       }
+                       aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
+                       call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
+               case callee != nil:
+                       aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
+                       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
                default:
-                       s.Fatalf("bad call type %v %v", n.Op, n)
+                       s.Fatalf("bad call type %v %v", n.Op(), n)
                }
+               call.AddArgs(callArgs...)
                call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
        }
-       if testLateExpansion {
-               s.prevCall = call
-               s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-       } else {
-               s.vars[&memVar] = call
-       }
+       s.prevCall = call
+       s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
        // Insert OVARLIVE nodes
-       s.stmtList(n.Nbody)
+       for _, name := range n.KeepAlive {
+               s.stmt(ir.NewUnaryExpr(n.Pos(), ir.OVARLIVE, name))
+       }
 
        // Finish block for defers
        if k == callDefer || k == callDeferStack {
@@ -4813,51 +4948,29 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
        fp := res.Field(0)
        if returnResultAddr {
                pt := types.NewPtr(fp.Type)
-               if testLateExpansion {
-                       return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
-               }
-               return s.constOffPtrSP(pt, fp.Offset+Ctxt.FixedFrameSize())
+               return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
        }
 
-       if testLateExpansion {
-               return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
-       }
-       return s.load(n.Type, s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+Ctxt.FixedFrameSize()))
+       return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
 }
 
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
 // architecture-dependent situations and, if so, emits the nil check.
 func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
-       if thearch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
+       if Arch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
                // On AIX, the closure needs to be verified as fn can be nil, except if it's a call go. This needs to be handled by the runtime to have the "go of nil func value" error.
                // TODO(neelance): On other architectures this should be eliminated by the optimization steps
                s.nilCheck(closure)
        }
 }
 
-// getMethodClosure returns a value representing the closure for a method call
-func (s *state) getMethodClosure(fn *Node) *ssa.Value {
-       // Make a name n2 for the function.
-       // fn.Sym might be sync.(*Mutex).Unlock.
-       // Make a PFUNC node out of that, then evaluate it.
-       // We get back an SSA value representing &sync.(*Mutex).Unlock·f.
-       // We can then pass that to defer or go.
-       n2 := newnamel(fn.Pos, fn.Sym)
-       n2.Name.Curfn = s.curfn
-       n2.SetClass(PFUNC)
-       // n2.Sym already existed, so it's already marked as a function.
-       n2.Pos = fn.Pos
-       n2.Type = types.Types[TUINT8] // dummy type for a static closure. Could use runtime.funcval if we had it.
-       return s.expr(n2)
-}
-
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
-func (s *state) getClosureAndRcvr(fn *Node) (*ssa.Value, *ssa.Value) {
-       i := s.expr(fn.Left)
-       itab := s.newValue1(ssa.OpITab, types.Types[TUINTPTR], i)
+func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value) {
+       i := s.expr(fn.X)
+       itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
        s.nilCheck(itab)
-       itabidx := fn.Xoffset + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
+       itabidx := fn.Offset() + 2*int64(types.PtrSize) + 8 // offset of fun field in runtime.itab
        closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
        rcvr := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, i)
        return closure, rcvr
@@ -4865,11 +4978,11 @@ func (s *state) getClosureAndRcvr(fn *Node) (*ssa.Value, *ssa.Value) {
 
 // etypesign returns the signed-ness of e, for integer/pointer etypes.
 // -1 means signed, +1 means unsigned, 0 means non-integer/non-pointer.
-func etypesign(e types.EType) int8 {
+func etypesign(e types.Kind) int8 {
        switch e {
-       case TINT8, TINT16, TINT32, TINT64, TINT:
+       case types.TINT8, types.TINT16, types.TINT32, types.TINT64, types.TINT:
                return -1
-       case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR, TUNSAFEPTR:
+       case types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINT, types.TUINTPTR, types.TUNSAFEPTR:
                return +1
        }
        return 0
@@ -4877,92 +4990,114 @@ func etypesign(e types.EType) int8 {
 
 // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result.
 // The value that the returned Value represents is guaranteed to be non-nil.
-func (s *state) addr(n *Node) *ssa.Value {
-       if n.Op != ONAME {
-               s.pushLine(n.Pos)
+func (s *state) addr(n ir.Node) *ssa.Value {
+       if n.Op() != ir.ONAME {
+               s.pushLine(n.Pos())
                defer s.popLine()
        }
 
-       t := types.NewPtr(n.Type)
-       switch n.Op {
-       case ONAME:
-               switch n.Class() {
-               case PEXTERN:
+       if s.canSSA(n) {
+               s.Fatalf("addr of canSSA expression: %+v", n)
+       }
+
+       t := types.NewPtr(n.Type())
+       linksymOffset := func(lsym *obj.LSym, offset int64) *ssa.Value {
+               v := s.entryNewValue1A(ssa.OpAddr, t, lsym, s.sb)
+               // TODO: Make OpAddr use AuxInt as well as Aux.
+               if offset != 0 {
+                       v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, offset, v)
+               }
+               return v
+       }
+       switch n.Op() {
+       case ir.OLINKSYMOFFSET:
+               no := n.(*ir.LinksymOffsetExpr)
+               return linksymOffset(no.Linksym, no.Offset_)
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Heapaddr != nil {
+                       return s.expr(n.Heapaddr)
+               }
+               switch n.Class {
+               case ir.PEXTERN:
                        // global variable
-                       v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym.Linksym(), s.sb)
-                       // TODO: Make OpAddr use AuxInt as well as Aux.
-                       if n.Xoffset != 0 {
-                               v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v)
-                       }
-                       return v
-               case PPARAM:
+                       return linksymOffset(n.Linksym(), 0)
+               case ir.PPARAM:
                        // parameter slot
                        v := s.decladdrs[n]
                        if v != nil {
                                return v
                        }
-                       if n == nodfp {
+                       if n == ir.RegFP {
                                // Special arg that points to the frame pointer (Used by ORECOVER).
                                return s.entryNewValue2A(ssa.OpLocalAddr, t, n, s.sp, s.startmem)
                        }
                        s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
                        return nil
-               case PAUTO:
-                       return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !n.IsAutoTmp())
+               case ir.PAUTO:
+                       return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !ir.IsAutoTmp(n))
 
-               case PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
+               case ir.PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
                        // ensure that we reuse symbols for out parameters so
                        // that cse works on their addresses
                        return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
                default:
-                       s.Fatalf("variable address class %v not implemented", n.Class())
+                       s.Fatalf("variable address class %v not implemented", n.Class)
                        return nil
                }
-       case ORESULT:
+       case ir.ORESULT:
                // load return from callee
+               n := n.(*ir.ResultExpr)
                if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
-                       return s.constOffPtrSP(t, n.Xoffset)
+                       return s.constOffPtrSP(t, n.Offset)
                }
-               which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Xoffset)
+               which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
                if which == -1 {
                        // Do the old thing // TODO: Panic instead.
-                       return s.constOffPtrSP(t, n.Xoffset)
+                       return s.constOffPtrSP(t, n.Offset)
                }
                x := s.newValue1I(ssa.OpSelectNAddr, t, which, s.prevCall)
                return x
 
-       case OINDEX:
-               if n.Left.Type.IsSlice() {
-                       a := s.expr(n.Left)
-                       i := s.expr(n.Right)
-                       len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], a)
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               if n.X.Type().IsSlice() {
+                       a := s.expr(n.X)
+                       i := s.expr(n.Index)
+                       len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], a)
                        i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
                        p := s.newValue1(ssa.OpSlicePtr, t, a)
                        return s.newValue2(ssa.OpPtrIndex, t, p, i)
                } else { // array
-                       a := s.addr(n.Left)
-                       i := s.expr(n.Right)
-                       len := s.constInt(types.Types[TINT], n.Left.Type.NumElem())
+                       a := s.addr(n.X)
+                       i := s.expr(n.Index)
+                       len := s.constInt(types.Types[types.TINT], n.X.Type().NumElem())
                        i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
-                       return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left.Type.Elem()), a, i)
-               }
-       case ODEREF:
-               return s.exprPtr(n.Left, n.Bounded(), n.Pos)
-       case ODOT:
-               p := s.addr(n.Left)
-               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
-       case ODOTPTR:
-               p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
-       case OCLOSUREVAR:
-               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset,
-                       s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
-       case OCONVNOP:
-               addr := s.addr(n.Left)
+                       return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.X.Type().Elem()), a, i)
+               }
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               return s.exprPtr(n.X, n.Bounded(), n.Pos())
+       case ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               p := s.addr(n.X)
+               return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
+       case ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               p := s.exprPtr(n.X, n.Bounded(), n.Pos())
+               return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
+       case ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               if n.Type() == n.X.Type() {
+                       return s.addr(n.X)
+               }
+               addr := s.addr(n.X)
                return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
-       case OCALLFUNC, OCALLINTER, OCALLMETH:
+       case ir.OCALLFUNC, ir.OCALLINTER:
+               n := n.(*ir.CallExpr)
                return s.callAddr(n, callNormal)
-       case ODOTTYPE:
+       case ir.ODOTTYPE:
+               n := n.(*ir.TypeAssertExpr)
                v, _ := s.dottype(n, false)
                if v.Op != ssa.OpLoad {
                        s.Fatalf("dottype of non-load")
@@ -4972,36 +5107,45 @@ func (s *state) addr(n *Node) *ssa.Value {
                }
                return v.Args[0]
        default:
-               s.Fatalf("unhandled addr %v", n.Op)
+               s.Fatalf("unhandled addr %v", n.Op())
                return nil
        }
 }
 
 // canSSA reports whether n is SSA-able.
 // n must be an ONAME (or an ODOT sequence with an ONAME base).
-func (s *state) canSSA(n *Node) bool {
-       if Debug.N != 0 {
+func (s *state) canSSA(n ir.Node) bool {
+       if base.Flag.N != 0 {
                return false
        }
-       for n.Op == ODOT || (n.Op == OINDEX && n.Left.Type.IsArray()) {
-               n = n.Left
-       }
-       if n.Op != ONAME {
-               return false
+       for {
+               nn := n
+               if nn.Op() == ir.ODOT {
+                       nn := nn.(*ir.SelectorExpr)
+                       n = nn.X
+                       continue
+               }
+               if nn.Op() == ir.OINDEX {
+                       nn := nn.(*ir.IndexExpr)
+                       if nn.X.Type().IsArray() {
+                               n = nn.X
+                               continue
+                       }
+               }
+               break
        }
-       if n.Name.Addrtaken() {
+       if n.Op() != ir.ONAME {
                return false
        }
-       if n.isParamHeapCopy() {
+       return s.canSSAName(n.(*ir.Name)) && TypeOK(n.Type())
+}
+
+func (s *state) canSSAName(name *ir.Name) bool {
+       if name.Addrtaken() || !name.OnStack() {
                return false
        }
-       if n.Class() == PAUTOHEAP {
-               s.Fatalf("canSSA of PAUTOHEAP %v", n)
-       }
-       switch n.Class() {
-       case PEXTERN:
-               return false
-       case PPARAMOUT:
+       switch name.Class {
+       case ir.PPARAMOUT:
                if s.hasdefer {
                        // TODO: handle this case? Named return values must be
                        // in memory so that the deferred function can see them.
@@ -5016,40 +5160,40 @@ func (s *state) canSSA(n *Node) bool {
                        return false
                }
        }
-       if n.Class() == PPARAM && n.Sym != nil && n.Sym.Name == ".this" {
+       if name.Class == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
                // wrappers generated by genwrapper need to update
                // the .this pointer in place.
                // TODO: treat as a PPARAMOUT?
                return false
        }
-       return canSSAType(n.Type)
+       return true
        // TODO: try to make more variables SSAable?
 }
 
-// canSSA reports whether variables of type t are SSA-able.
-func canSSAType(t *types.Type) bool {
-       dowidth(t)
-       if t.Width > int64(4*Widthptr) {
+// TypeOK reports whether variables of type t are SSA-able.
+func TypeOK(t *types.Type) bool {
+       types.CalcSize(t)
+       if t.Width > int64(4*types.PtrSize) {
                // 4*Widthptr is an arbitrary constant. We want it
                // to be at least 3*Widthptr so slices can be registerized.
                // Too big and we'll introduce too much register pressure.
                return false
        }
-       switch t.Etype {
-       case TARRAY:
+       switch t.Kind() {
+       case types.TARRAY:
                // We can't do larger arrays because dynamic indexing is
                // not supported on SSA variables.
                // TODO: allow if all indexes are constant.
                if t.NumElem() <= 1 {
-                       return canSSAType(t.Elem())
+                       return TypeOK(t.Elem())
                }
                return false
-       case TSTRUCT:
+       case types.TSTRUCT:
                if t.NumFields() > ssa.MaxStruct {
                        return false
                }
                for _, t1 := range t.Fields().Slice() {
-                       if !canSSAType(t1.Type) {
+                       if !TypeOK(t1.Type) {
                                return false
                        }
                }
@@ -5060,7 +5204,7 @@ func canSSAType(t *types.Type) bool {
 }
 
 // exprPtr evaluates n to a pointer and nil-checks it.
-func (s *state) exprPtr(n *Node, bounded bool, lineno src.XPos) *ssa.Value {
+func (s *state) exprPtr(n ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
        p := s.expr(n)
        if bounded || n.NonNil() {
                if s.f.Frontend().Debug_checknil() && lineno.Line() > 1 {
@@ -5076,7 +5220,7 @@ func (s *state) exprPtr(n *Node, bounded bool, lineno src.XPos) *ssa.Value {
 // Used only for automatically inserted nil checks,
 // not for user code like 'x != nil'.
 func (s *state) nilCheck(ptr *ssa.Value) {
-       if disable_checknil != 0 || s.curfn.Func.NilCheckDisabled() {
+       if base.Debug.DisableNil != 0 || s.curfn.NilCheckDisabled() {
                return
        }
        s.newValue2(ssa.OpNilCheck, types.TypeVoid, ptr, s.mem())
@@ -5091,7 +5235,7 @@ func (s *state) nilCheck(ptr *ssa.Value) {
 func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bool) *ssa.Value {
        idx = s.extendIndex(idx, len, kind, bounded)
 
-       if bounded || Debug.B != 0 {
+       if bounded || base.Flag.B != 0 {
                // If bounded or bounds checking is flag-disabled, then no check necessary,
                // just return the extended index.
                //
@@ -5141,9 +5285,9 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 
        var cmp *ssa.Value
        if kind == ssa.BoundsIndex || kind == ssa.BoundsIndexU {
-               cmp = s.newValue2(ssa.OpIsInBounds, types.Types[TBOOL], idx, len)
+               cmp = s.newValue2(ssa.OpIsInBounds, types.Types[types.TBOOL], idx, len)
        } else {
-               cmp = s.newValue2(ssa.OpIsSliceInBounds, types.Types[TBOOL], idx, len)
+               cmp = s.newValue2(ssa.OpIsSliceInBounds, types.Types[types.TBOOL], idx, len)
        }
        b := s.endBlock()
        b.Kind = ssa.BlockIf
@@ -5153,7 +5297,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
        b.AddEdgeTo(bPanic)
 
        s.startBlock(bPanic)
-       if thearch.LinkArch.Family == sys.Wasm {
+       if Arch.LinkArch.Family == sys.Wasm {
                // TODO(khr): figure out how to do "register" based calling convention for bounds checks.
                // Should be similar to gcWriteBarrier, but I can't make it work.
                s.rtcall(BoundsCheckFunc[kind], false, nil, idx, len)
@@ -5164,12 +5308,12 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
        s.startBlock(bNext)
 
        // In Spectre index mode, apply an appropriate mask to avoid speculative out-of-bounds accesses.
-       if spectreIndex {
+       if base.Flag.Cfg.SpectreIndex {
                op := ssa.OpSpectreIndex
                if kind != ssa.BoundsIndex && kind != ssa.BoundsIndexU {
                        op = ssa.OpSpectreSliceIndex
                }
-               idx = s.newValue2(op, types.Types[TINT], idx, len)
+               idx = s.newValue2(op, types.Types[types.TINT], idx, len)
        }
 
        return idx
@@ -5183,7 +5327,7 @@ func (s *state) check(cmp *ssa.Value, fn *obj.LSym) {
        b.Likely = ssa.BranchLikely
        bNext := s.f.NewBlock(ssa.BlockPlain)
        line := s.peekPos()
-       pos := Ctxt.PosTable.Pos(line)
+       pos := base.Ctxt.PosTable.Pos(line)
        fl := funcLine{f: fn, base: pos.Base(), line: pos.Line()}
        bPanic := s.panics[fl]
        if bPanic == nil {
@@ -5199,7 +5343,7 @@ func (s *state) check(cmp *ssa.Value, fn *obj.LSym) {
        s.startBlock(bNext)
 }
 
-func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
+func (s *state) intDivide(n ir.Node, a, b *ssa.Value) *ssa.Value {
        needcheck := true
        switch b.Op {
        case ssa.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64:
@@ -5209,10 +5353,10 @@ func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
        }
        if needcheck {
                // do a size-appropriate check for zero
-               cmp := s.newValue2(s.ssaOp(ONE, n.Type), types.Types[TBOOL], b, s.zeroVal(n.Type))
-               s.check(cmp, panicdivide)
+               cmp := s.newValue2(s.ssaOp(ir.ONE, n.Type()), types.Types[types.TBOOL], b, s.zeroVal(n.Type()))
+               s.check(cmp, ir.Syms.Panicdivide)
        }
-       return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+       return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 }
 
 // rtcall issues a call to the given runtime function fn with the listed args.
@@ -5222,31 +5366,25 @@ func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
 func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args ...*ssa.Value) []*ssa.Value {
        s.prevCall = nil
        // Write args to the stack
-       off := Ctxt.FixedFrameSize()
-       testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
+       off := base.Ctxt.FixedFrameSize()
        var ACArgs []ssa.Param
        var ACResults []ssa.Param
        var callArgs []*ssa.Value
 
        for _, arg := range args {
                t := arg.Type
-               off = Rnd(off, t.Alignment())
+               off = types.Rnd(off, t.Alignment())
                size := t.Size()
                ACArgs = append(ACArgs, ssa.Param{Type: t, Offset: int32(off)})
-               if testLateExpansion {
-                       callArgs = append(callArgs, arg)
-               } else {
-                       ptr := s.constOffPtrSP(t.PtrTo(), off)
-                       s.store(t, ptr, arg)
-               }
+               callArgs = append(callArgs, arg)
                off += size
        }
-       off = Rnd(off, int64(Widthreg))
+       off = types.Rnd(off, int64(types.RegSize))
 
        // Accumulate results types and offsets
        offR := off
        for _, t := range results {
-               offR = Rnd(offR, t.Alignment())
+               offR = types.Rnd(offR, t.Alignment())
                ACResults = append(ACResults, ssa.Param{Type: t, Offset: int32(offR)})
                offR += t.Size()
        }
@@ -5254,22 +5392,17 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
        // Issue call
        var call *ssa.Value
        aux := ssa.StaticAuxCall(fn, ACArgs, ACResults)
-       if testLateExpansion {
-               callArgs = append(callArgs, s.mem())
-               call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-               call.AddArgs(callArgs...)
-               s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-       } else {
-               call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-               s.vars[&memVar] = call
-       }
+       callArgs = append(callArgs, s.mem())
+       call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+       call.AddArgs(callArgs...)
+       s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 
        if !returns {
                // Finish block
                b := s.endBlock()
                b.Kind = ssa.BlockExit
                b.SetControl(call)
-               call.AuxInt = off - Ctxt.FixedFrameSize()
+               call.AuxInt = off - base.Ctxt.FixedFrameSize()
                if len(results) > 0 {
                        s.Fatalf("panic call can't have results")
                }
@@ -5278,26 +5411,17 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
        // Load results
        res := make([]*ssa.Value, len(results))
-       if testLateExpansion {
-               for i, t := range results {
-                       off = Rnd(off, t.Alignment())
-                       if canSSAType(t) {
-                               res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
-                       } else {
-                               addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
-                               res[i] = s.rawLoad(t, addr)
-                       }
-                       off += t.Size()
-               }
-       } else {
-               for i, t := range results {
-                       off = Rnd(off, t.Alignment())
-                       ptr := s.constOffPtrSP(types.NewPtr(t), off)
-                       res[i] = s.load(t, ptr)
-                       off += t.Size()
+       for i, t := range results {
+               off = types.Rnd(off, t.Alignment())
+               if TypeOK(t) {
+                       res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
+               } else {
+                       addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
+                       res[i] = s.rawLoad(t, addr)
                }
+               off += t.Size()
        }
-       off = Rnd(off, int64(Widthptr))
+       off = types.Rnd(off, int64(types.PtrSize))
 
        // Remember how much callee stack space we needed.
        call.AuxInt = off
@@ -5311,7 +5435,7 @@ func (s *state) storeType(t *types.Type, left, right *ssa.Value, skip skipMask,
 
        if skip == 0 && (!t.HasPointers() || ssa.IsStackAddr(left)) {
                // Known to not have write barrier. Store the whole type.
-               s.vars[&memVar] = s.newValue3Apos(ssa.OpStore, types.TypeMem, t, left, right, s.mem(), leftIsStmt)
+               s.vars[memVar] = s.newValue3Apos(ssa.OpStore, types.TypeMem, t, left, right, s.mem(), leftIsStmt)
                return
        }
 
@@ -5340,24 +5464,24 @@ func (s *state) storeTypeScalars(t *types.Type, left, right *ssa.Value, skip ski
                if skip&skipLen != 0 {
                        return
                }
-               len := s.newValue1(ssa.OpStringLen, types.Types[TINT], right)
+               len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], right)
                lenAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, s.config.PtrSize, left)
-               s.store(types.Types[TINT], lenAddr, len)
+               s.store(types.Types[types.TINT], lenAddr, len)
        case t.IsSlice():
                if skip&skipLen == 0 {
-                       len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], right)
+                       len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], right)
                        lenAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, s.config.PtrSize, left)
-                       s.store(types.Types[TINT], lenAddr, len)
+                       s.store(types.Types[types.TINT], lenAddr, len)
                }
                if skip&skipCap == 0 {
-                       cap := s.newValue1(ssa.OpSliceCap, types.Types[TINT], right)
+                       cap := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], right)
                        capAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, 2*s.config.PtrSize, left)
-                       s.store(types.Types[TINT], capAddr, cap)
+                       s.store(types.Types[types.TINT], capAddr, cap)
                }
        case t.IsInterface():
                // itab field doesn't need a write barrier (even though it is a pointer).
                itab := s.newValue1(ssa.OpITab, s.f.Config.Types.BytePtr, right)
-               s.store(types.Types[TUINTPTR], left, itab)
+               s.store(types.Types[types.TUINTPTR], left, itab)
        case t.IsStruct():
                n := t.NumFields()
                for i := 0; i < n; i++ {
@@ -5415,24 +5539,18 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
        }
 }
 
-// putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param for the call.
-// If forLateExpandedCall is true, it returns the argument value to pass to the call operation.
-// If forLateExpandedCall is false, then the value is stored at the specified stack offset, and the returned value is nil.
-func (s *state) putArg(n *Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
+// putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param and value for the call.
+func (s *state) putArg(n ir.Node, t *types.Type, off int64) (ssa.Param, *ssa.Value) {
        var a *ssa.Value
-       if forLateExpandedCall {
-               if !canSSAType(t) {
-                       a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
-               } else {
-                       a = s.expr(n)
-               }
+       if !TypeOK(t) {
+               a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
        } else {
-               s.storeArgWithBase(n, t, s.sp, off)
+               a = s.expr(n)
        }
        return ssa.Param{Type: t, Offset: int32(off)}, a
 }
 
-func (s *state) storeArgWithBase(n *Node, t *types.Type, base *ssa.Value, off int64) {
+func (s *state) storeArgWithBase(n ir.Node, t *types.Type, base *ssa.Value, off int64) {
        pt := types.NewPtr(t)
        var addr *ssa.Value
        if base == s.sp {
@@ -5442,7 +5560,7 @@ func (s *state) storeArgWithBase(n *Node, t *types.Type, base *ssa.Value, off in
                addr = s.newValue1I(ssa.OpOffPtr, pt, off, base)
        }
 
-       if !canSSAType(t) {
+       if !TypeOK(t) {
                a := s.addr(n)
                s.move(t, addr, a)
                return
@@ -5461,11 +5579,11 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
        switch {
        case t.IsSlice():
                ptr = s.newValue1(ssa.OpSlicePtr, types.NewPtr(t.Elem()), v)
-               len = s.newValue1(ssa.OpSliceLen, types.Types[TINT], v)
-               cap = s.newValue1(ssa.OpSliceCap, types.Types[TINT], v)
+               len = s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], v)
+               cap = s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], v)
        case t.IsString():
-               ptr = s.newValue1(ssa.OpStringPtr, types.NewPtr(types.Types[TUINT8]), v)
-               len = s.newValue1(ssa.OpStringLen, types.Types[TINT], v)
+               ptr = s.newValue1(ssa.OpStringPtr, types.NewPtr(types.Types[types.TUINT8]), v)
+               len = s.newValue1(ssa.OpStringLen, types.Types[types.TINT], v)
                cap = len
        case t.IsPtr():
                if !t.Elem().IsArray() {
@@ -5473,7 +5591,7 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
                }
                s.nilCheck(v)
                ptr = s.newValue1(ssa.OpCopy, types.NewPtr(t.Elem().Elem()), v)
-               len = s.constInt(types.Types[TINT], t.Elem().NumElem())
+               len = s.constInt(types.Types[types.TINT], t.Elem().NumElem())
                cap = len
        default:
                s.Fatalf("bad type in slice %v\n", t)
@@ -5481,7 +5599,7 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 
        // Set default values
        if i == nil {
-               i = s.constInt(types.Types[TINT], 0)
+               i = s.constInt(types.Types[types.TINT], 0)
        }
        if j == nil {
                j = len
@@ -5519,18 +5637,18 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
        }
 
        // Word-sized integer operations.
-       subOp := s.ssaOp(OSUB, types.Types[TINT])
-       mulOp := s.ssaOp(OMUL, types.Types[TINT])
-       andOp := s.ssaOp(OAND, types.Types[TINT])
+       subOp := s.ssaOp(ir.OSUB, types.Types[types.TINT])
+       mulOp := s.ssaOp(ir.OMUL, types.Types[types.TINT])
+       andOp := s.ssaOp(ir.OAND, types.Types[types.TINT])
 
        // Calculate the length (rlen) and capacity (rcap) of the new slice.
        // For strings the capacity of the result is unimportant. However,
        // we use rcap to test if we've generated a zero-length slice.
        // Use length of strings for that.
-       rlen := s.newValue2(subOp, types.Types[TINT], j, i)
+       rlen := s.newValue2(subOp, types.Types[types.TINT], j, i)
        rcap := rlen
        if j != k && !t.IsString() {
-               rcap = s.newValue2(subOp, types.Types[TINT], k, i)
+               rcap = s.newValue2(subOp, types.Types[types.TINT], k, i)
        }
 
        if (i.Op == ssa.OpConst64 || i.Op == ssa.OpConst32) && i.AuxInt == 0 {
@@ -5552,15 +5670,15 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
        //
        // Where mask(x) is 0 if x==0 and -1 if x>0 and stride is the width
        // of the element type.
-       stride := s.constInt(types.Types[TINT], ptr.Type.Elem().Width)
+       stride := s.constInt(types.Types[types.TINT], ptr.Type.Elem().Width)
 
        // The delta is the number of bytes to offset ptr by.
-       delta := s.newValue2(mulOp, types.Types[TINT], i, stride)
+       delta := s.newValue2(mulOp, types.Types[types.TINT], i, stride)
 
        // If we're slicing to the point where the capacity is zero,
        // zero out the delta.
-       mask := s.newValue1(ssa.OpSlicemask, types.Types[TINT], rcap)
-       delta = s.newValue2(andOp, types.Types[TINT], delta, mask)
+       mask := s.newValue1(ssa.OpSlicemask, types.Types[types.TINT], rcap)
+       delta = s.newValue2(andOp, types.Types[types.TINT], delta, mask)
 
        // Compute rptr = ptr + delta.
        rptr := s.newValue2(ssa.OpAddPtr, ptr.Type, ptr, delta)
@@ -5593,15 +5711,15 @@ var u64_f32 = u642fcvtTab{
        one:   (*state).constInt64,
 }
 
-func (s *state) uint64Tofloat64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.uint64Tofloat(&u64_f64, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.uint64Tofloat(&u64_f32, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        // if x >= 0 {
        //    result = (floatY) x
        // } else {
@@ -5627,7 +5745,7 @@ func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *Node, x *ssa.Value, ft, tt
        // equal to 10000000001; that rounds up, and the 1 cannot
        // be lost else it would round down if the LSB of the
        // candidate mantissa is 0.
-       cmp := s.newValue2(cvttab.leq, types.Types[TBOOL], s.zeroVal(ft), x)
+       cmp := s.newValue2(cvttab.leq, types.Types[types.TBOOL], s.zeroVal(ft), x)
        b := s.endBlock()
        b.Kind = ssa.BlockIf
        b.SetControl(cmp)
@@ -5657,7 +5775,7 @@ func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *Node, x *ssa.Value, ft, tt
        bElse.AddEdgeTo(bAfter)
 
        s.startBlock(bAfter)
-       return s.variable(n, n.Type)
+       return s.variable(n, n.Type())
 }
 
 type u322fcvtTab struct {
@@ -5674,21 +5792,21 @@ var u32_f32 = u322fcvtTab{
        cvtF2F: ssa.OpCvt64Fto32F,
 }
 
-func (s *state) uint32Tofloat64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.uint32Tofloat(&u32_f64, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.uint32Tofloat(&u32_f32, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        // if x >= 0 {
        //      result = floatY(x)
        // } else {
        //      result = floatY(float64(x) + (1<<32))
        // }
-       cmp := s.newValue2(ssa.OpLeq32, types.Types[TBOOL], s.zeroVal(ft), x)
+       cmp := s.newValue2(ssa.OpLeq32, types.Types[types.TBOOL], s.zeroVal(ft), x)
        b := s.endBlock()
        b.Kind = ssa.BlockIf
        b.SetControl(cmp)
@@ -5707,9 +5825,9 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt
 
        b.AddEdgeTo(bElse)
        s.startBlock(bElse)
-       a1 := s.newValue1(ssa.OpCvt32to64F, types.Types[TFLOAT64], x)
-       twoToThe32 := s.constFloat64(types.Types[TFLOAT64], float64(1<<32))
-       a2 := s.newValue2(ssa.OpAdd64F, types.Types[TFLOAT64], a1, twoToThe32)
+       a1 := s.newValue1(ssa.OpCvt32to64F, types.Types[types.TFLOAT64], x)
+       twoToThe32 := s.constFloat64(types.Types[types.TFLOAT64], float64(1<<32))
+       a2 := s.newValue2(ssa.OpAdd64F, types.Types[types.TFLOAT64], a1, twoToThe32)
        a3 := s.newValue1(cvttab.cvtF2F, tt, a2)
 
        s.vars[n] = a3
@@ -5717,12 +5835,12 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt
        bElse.AddEdgeTo(bAfter)
 
        s.startBlock(bAfter)
-       return s.variable(n, n.Type)
+       return s.variable(n, n.Type())
 }
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
-func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
-       if !n.Left.Type.IsMap() && !n.Left.Type.IsChan() {
+func (s *state) referenceTypeBuiltin(n *ir.UnaryExpr, x *ssa.Value) *ssa.Value {
+       if !n.X.Type().IsMap() && !n.X.Type().IsChan() {
                s.Fatalf("node must be a map or a channel")
        }
        // if n == nil {
@@ -5733,9 +5851,9 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
        //   // cap
        //   return *(((*int)n)+1)
        // }
-       lenType := n.Type
-       nilValue := s.constNil(types.Types[TUINTPTR])
-       cmp := s.newValue2(ssa.OpEqPtr, types.Types[TBOOL], x, nilValue)
+       lenType := n.Type()
+       nilValue := s.constNil(types.Types[types.TUINTPTR])
+       cmp := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], x, nilValue)
        b := s.endBlock()
        b.Kind = ssa.BlockIf
        b.SetControl(cmp)
@@ -5754,11 +5872,11 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
 
        b.AddEdgeTo(bElse)
        s.startBlock(bElse)
-       switch n.Op {
-       case OLEN:
+       switch n.Op() {
+       case ir.OLEN:
                // length is stored in the first word for map/chan
                s.vars[n] = s.load(lenType, x)
-       case OCAP:
+       case ir.OCAP:
                // capacity is stored in the second word for chan
                sw := s.newValue1I(ssa.OpOffPtr, lenType.PtrTo(), lenType.Width, x)
                s.vars[n] = s.load(lenType, sw)
@@ -5819,22 +5937,22 @@ var f64_u32 = f2uCvtTab{
        cutoff:     1 << 31,
 }
 
-func (s *state) float32ToUint64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.floatToUint(&f32_u64, n, x, ft, tt)
 }
-func (s *state) float64ToUint64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.floatToUint(&f64_u64, n, x, ft, tt)
 }
 
-func (s *state) float32ToUint32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.floatToUint(&f32_u32, n, x, ft, tt)
 }
 
-func (s *state) float64ToUint32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        return s.floatToUint(&f64_u32, n, x, ft, tt)
 }
 
-func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
        // cutoff:=1<<(intY_Size-1)
        // if x < floatX(cutoff) {
        //      result = uintY(x)
@@ -5844,7 +5962,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *ty
        //      result = z | -(cutoff)
        // }
        cutoff := cvttab.floatValue(s, ft, float64(cvttab.cutoff))
-       cmp := s.newValue2(cvttab.ltf, types.Types[TBOOL], x, cutoff)
+       cmp := s.newValue2(cvttab.ltf, types.Types[types.TBOOL], x, cutoff)
        b := s.endBlock()
        b.Kind = ssa.BlockIf
        b.SetControl(cmp)
@@ -5872,31 +5990,31 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *ty
        bElse.AddEdgeTo(bAfter)
 
        s.startBlock(bAfter)
-       return s.variable(n, n.Type)
+       return s.variable(n, n.Type())
 }
 
 // dottype generates SSA for a type assertion node.
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
-func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
-       iface := s.expr(n.Left)   // input interface
-       target := s.expr(n.Right) // target type
+func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Value) {
+       iface := s.expr(n.X)              // input interface
+       target := s.reflectType(n.Type()) // target type
        byteptr := s.f.Config.Types.BytePtr
 
-       if n.Type.IsInterface() {
-               if n.Type.IsEmptyInterface() {
+       if n.Type().IsInterface() {
+               if n.Type().IsEmptyInterface() {
                        // Converting to an empty interface.
                        // Input could be an empty or nonempty interface.
-                       if Debug_typeassert > 0 {
-                               Warnl(n.Pos, "type assertion inlined")
+                       if base.Debug.TypeAssert > 0 {
+                               base.WarnfAt(n.Pos(), "type assertion inlined")
                        }
 
                        // Get itab/type field from input.
                        itab := s.newValue1(ssa.OpITab, byteptr, iface)
                        // Conversion succeeds iff that field is not nil.
-                       cond := s.newValue2(ssa.OpNeqPtr, types.Types[TBOOL], itab, s.constNil(byteptr))
+                       cond := s.newValue2(ssa.OpNeqPtr, types.Types[types.TBOOL], itab, s.constNil(byteptr))
 
-                       if n.Left.Type.IsEmptyInterface() && commaok {
+                       if n.X.Type().IsEmptyInterface() && commaok {
                                // Converting empty interface to empty interface with ,ok is just a nil check.
                                return iface, cond
                        }
@@ -5914,32 +6032,32 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
                        if !commaok {
                                // On failure, panic by calling panicnildottype.
                                s.startBlock(bFail)
-                               s.rtcall(panicnildottype, false, nil, target)
+                               s.rtcall(ir.Syms.Panicnildottype, false, nil, target)
 
                                // On success, return (perhaps modified) input interface.
                                s.startBlock(bOk)
-                               if n.Left.Type.IsEmptyInterface() {
+                               if n.X.Type().IsEmptyInterface() {
                                        res = iface // Use input interface unchanged.
                                        return
                                }
                                // Load type out of itab, build interface with existing idata.
-                               off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
+                               off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(types.PtrSize), itab)
                                typ := s.load(byteptr, off)
                                idata := s.newValue1(ssa.OpIData, byteptr, iface)
-                               res = s.newValue2(ssa.OpIMake, n.Type, typ, idata)
+                               res = s.newValue2(ssa.OpIMake, n.Type(), typ, idata)
                                return
                        }
 
                        s.startBlock(bOk)
                        // nonempty -> empty
                        // Need to load type from itab
-                       off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
-                       s.vars[&typVar] = s.load(byteptr, off)
+                       off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(types.PtrSize), itab)
+                       s.vars[typVar] = s.load(byteptr, off)
                        s.endBlock()
 
                        // itab is nil, might as well use that as the nil result.
                        s.startBlock(bFail)
-                       s.vars[&typVar] = itab
+                       s.vars[typVar] = itab
                        s.endBlock()
 
                        // Merge point.
@@ -5948,59 +6066,59 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
                        bFail.AddEdgeTo(bEnd)
                        s.startBlock(bEnd)
                        idata := s.newValue1(ssa.OpIData, byteptr, iface)
-                       res = s.newValue2(ssa.OpIMake, n.Type, s.variable(&typVar, byteptr), idata)
+                       res = s.newValue2(ssa.OpIMake, n.Type(), s.variable(typVar, byteptr), idata)
                        resok = cond
-                       delete(s.vars, &typVar)
+                       delete(s.vars, typVar)
                        return
                }
                // converting to a nonempty interface needs a runtime call.
-               if Debug_typeassert > 0 {
-                       Warnl(n.Pos, "type assertion not inlined")
+               if base.Debug.TypeAssert > 0 {
+                       base.WarnfAt(n.Pos(), "type assertion not inlined")
                }
-               if n.Left.Type.IsEmptyInterface() {
+               if n.X.Type().IsEmptyInterface() {
                        if commaok {
-                               call := s.rtcall(assertE2I2, true, []*types.Type{n.Type, types.Types[TBOOL]}, target, iface)
+                               call := s.rtcall(ir.Syms.AssertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
                                return call[0], call[1]
                        }
-                       return s.rtcall(assertE2I, true, []*types.Type{n.Type}, target, iface)[0], nil
+                       return s.rtcall(ir.Syms.AssertE2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
                }
                if commaok {
-                       call := s.rtcall(assertI2I2, true, []*types.Type{n.Type, types.Types[TBOOL]}, target, iface)
+                       call := s.rtcall(ir.Syms.AssertI2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
                        return call[0], call[1]
                }
-               return s.rtcall(assertI2I, true, []*types.Type{n.Type}, target, iface)[0], nil
+               return s.rtcall(ir.Syms.AssertI2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
        }
 
-       if Debug_typeassert > 0 {
-               Warnl(n.Pos, "type assertion inlined")
+       if base.Debug.TypeAssert > 0 {
+               base.WarnfAt(n.Pos(), "type assertion inlined")
        }
 
        // Converting to a concrete type.
-       direct := isdirectiface(n.Type)
+       direct := types.IsDirectIface(n.Type())
        itab := s.newValue1(ssa.OpITab, byteptr, iface) // type word of interface
-       if Debug_typeassert > 0 {
-               Warnl(n.Pos, "type assertion inlined")
+       if base.Debug.TypeAssert > 0 {
+               base.WarnfAt(n.Pos(), "type assertion inlined")
        }
        var targetITab *ssa.Value
-       if n.Left.Type.IsEmptyInterface() {
+       if n.X.Type().IsEmptyInterface() {
                // Looking for pointer to target type.
                targetITab = target
        } else {
                // Looking for pointer to itab for target type and source interface.
-               targetITab = s.expr(n.List.First())
+               targetITab = s.expr(n.Itab)
        }
 
-       var tmp *Node       // temporary for use with large types
+       var tmp ir.Node     // temporary for use with large types
        var addr *ssa.Value // address of tmp
-       if commaok && !canSSAType(n.Type) {
+       if commaok && !TypeOK(n.Type()) {
                // unSSAable type, use temporary.
                // TODO: get rid of some of these temporaries.
-               tmp = tempAt(n.Pos, s.curfn, n.Type)
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
+               tmp = typecheck.TempAt(n.Pos(), s.curfn, n.Type())
+               s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp.(*ir.Name), s.mem())
                addr = s.addr(tmp)
        }
 
-       cond := s.newValue2(ssa.OpEqPtr, types.Types[TBOOL], itab, targetITab)
+       cond := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], itab, targetITab)
        b := s.endBlock()
        b.Kind = ssa.BlockIf
        b.SetControl(cond)
@@ -6014,20 +6132,20 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
        if !commaok {
                // on failure, panic by calling panicdottype
                s.startBlock(bFail)
-               taddr := s.expr(n.Right.Right)
-               if n.Left.Type.IsEmptyInterface() {
-                       s.rtcall(panicdottypeE, false, nil, itab, target, taddr)
+               taddr := s.reflectType(n.X.Type())
+               if n.X.Type().IsEmptyInterface() {
+                       s.rtcall(ir.Syms.PanicdottypeE, false, nil, itab, target, taddr)
                } else {
-                       s.rtcall(panicdottypeI, false, nil, itab, target, taddr)
+                       s.rtcall(ir.Syms.PanicdottypeI, false, nil, itab, target, taddr)
                }
 
                // on success, return data from interface
                s.startBlock(bOk)
                if direct {
-                       return s.newValue1(ssa.OpIData, n.Type, iface), nil
+                       return s.newValue1(ssa.OpIData, n.Type(), iface), nil
                }
-               p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-               return s.load(n.Type, p), nil
+               p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+               return s.load(n.Type(), p), nil
        }
 
        // commaok is the more complicated case because we have
@@ -6035,95 +6153,94 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
        bEnd := s.f.NewBlock(ssa.BlockPlain)
        // Note that we need a new valVar each time (unlike okVar where we can
        // reuse the variable) because it might have a different type every time.
-       valVar := &Node{Op: ONAME, Sym: &types.Sym{Name: "val"}}
+       valVar := ssaMarker("val")
 
        // type assertion succeeded
        s.startBlock(bOk)
        if tmp == nil {
                if direct {
-                       s.vars[valVar] = s.newValue1(ssa.OpIData, n.Type, iface)
+                       s.vars[valVar] = s.newValue1(ssa.OpIData, n.Type(), iface)
                } else {
-                       p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-                       s.vars[valVar] = s.load(n.Type, p)
+                       p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+                       s.vars[valVar] = s.load(n.Type(), p)
                }
        } else {
-               p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-               s.move(n.Type, addr, p)
+               p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+               s.move(n.Type(), addr, p)
        }
-       s.vars[&okVar] = s.constBool(true)
+       s.vars[okVar] = s.constBool(true)
        s.endBlock()
        bOk.AddEdgeTo(bEnd)
 
        // type assertion failed
        s.startBlock(bFail)
        if tmp == nil {
-               s.vars[valVar] = s.zeroVal(n.Type)
+               s.vars[valVar] = s.zeroVal(n.Type())
        } else {
-               s.zero(n.Type, addr)
+               s.zero(n.Type(), addr)
        }
-       s.vars[&okVar] = s.constBool(false)
+       s.vars[okVar] = s.constBool(false)
        s.endBlock()
        bFail.AddEdgeTo(bEnd)
 
        // merge point
        s.startBlock(bEnd)
        if tmp == nil {
-               res = s.variable(valVar, n.Type)
+               res = s.variable(valVar, n.Type())
                delete(s.vars, valVar)
        } else {
-               res = s.load(n.Type, addr)
-               s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp, s.mem())
+               res = s.load(n.Type(), addr)
+               s.vars[memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp.(*ir.Name), s.mem())
        }
-       resok = s.variable(&okVar, types.Types[TBOOL])
-       delete(s.vars, &okVar)
+       resok = s.variable(okVar, types.Types[types.TBOOL])
+       delete(s.vars, okVar)
        return res, resok
 }
 
 // variable returns the value of a variable at the current location.
-func (s *state) variable(name *Node, t *types.Type) *ssa.Value {
-       v := s.vars[name]
+func (s *state) variable(n ir.Node, t *types.Type) *ssa.Value {
+       v := s.vars[n]
        if v != nil {
                return v
        }
-       v = s.fwdVars[name]
+       v = s.fwdVars[n]
        if v != nil {
                return v
        }
 
        if s.curBlock == s.f.Entry {
                // No variable should be live at entry.
-               s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, name, v)
+               s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, n, v)
        }
        // Make a FwdRef, which records a value that's live on block input.
        // We'll find the matching definition as part of insertPhis.
-       v = s.newValue0A(ssa.OpFwdRef, t, name)
-       s.fwdVars[name] = v
-       s.addNamedValue(name, v)
+       v = s.newValue0A(ssa.OpFwdRef, t, fwdRefAux{N: n})
+       s.fwdVars[n] = v
+       if n.Op() == ir.ONAME {
+               s.addNamedValue(n.(*ir.Name), v)
+       }
        return v
 }
 
 func (s *state) mem() *ssa.Value {
-       return s.variable(&memVar, types.TypeMem)
+       return s.variable(memVar, types.TypeMem)
 }
 
-func (s *state) addNamedValue(n *Node, v *ssa.Value) {
-       if n.Class() == Pxxx {
-               // Don't track our dummy nodes (&memVar etc.).
+func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
+       if n.Class == ir.Pxxx {
+               // Don't track our marker nodes (memVar etc.).
                return
        }
-       if n.IsAutoTmp() {
+       if ir.IsAutoTmp(n) {
                // Don't track temporary variables.
                return
        }
-       if n.Class() == PPARAMOUT {
+       if n.Class == ir.PPARAMOUT {
                // Don't track named output values.  This prevents return values
                // from being assigned too early. See #14591 and #14762. TODO: allow this.
                return
        }
-       if n.Class() == PAUTO && n.Xoffset != 0 {
-               s.Fatalf("AUTO var with offset %v %d", n, n.Xoffset)
-       }
-       loc := ssa.LocalSlot{N: n, Type: n.Type, Off: 0}
+       loc := ssa.LocalSlot{N: n, Type: n.Type(), Off: 0}
        values, ok := s.f.NamedValues[loc]
        if !ok {
                s.f.Names = append(s.f.Names, loc)
@@ -6132,7 +6249,7 @@ func (s *state) addNamedValue(n *Node, v *ssa.Value) {
 }
 
 // Generate a disconnected call to a runtime routine and a return.
-func gencallret(pp *Progs, sym *obj.LSym) *obj.Prog {
+func gencallret(pp *objw.Progs, sym *obj.LSym) *obj.Prog {
        p := pp.Prog(obj.ACALL)
        p.To.Type = obj.TYPE_MEM
        p.To.Name = obj.NAME_EXTERN
@@ -6147,9 +6264,11 @@ type Branch struct {
        B *ssa.Block // target
 }
 
-// SSAGenState contains state needed during Prog generation.
-type SSAGenState struct {
-       pp *Progs
+// State contains state needed during Prog generation.
+type State struct {
+       ABI obj.ABI
+
+       pp *objw.Progs
 
        // Branches remembers all the branch instructions we've seen
        // and where they would like to go.
@@ -6159,13 +6278,13 @@ type SSAGenState struct {
        bstart []*obj.Prog
 
        // Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include PPC and Sparc V8.
-       ScratchFpMem *Node
+       ScratchFpMem *ir.Name
 
        maxarg int64 // largest frame size for arguments to calls made by the function
 
        // Map from GC safe points to liveness index, generated by
        // liveness analysis.
-       livenessMap LivenessMap
+       livenessMap liveness.Map
 
        // lineRunStart records the beginning of the current run of instructions
        // within a single block sharing the same line number
@@ -6177,9 +6296,9 @@ type SSAGenState struct {
 }
 
 // Prog appends a new Prog.
-func (s *SSAGenState) Prog(as obj.As) *obj.Prog {
+func (s *State) Prog(as obj.As) *obj.Prog {
        p := s.pp.Prog(as)
-       if ssa.LosesStmtMark(as) {
+       if objw.LosesStmtMark(as) {
                return p
        }
        // Float a statement start to the beginning of any same-line run.
@@ -6194,19 +6313,19 @@ func (s *SSAGenState) Prog(as obj.As) *obj.Prog {
 }
 
 // Pc returns the current Prog.
-func (s *SSAGenState) Pc() *obj.Prog {
-       return s.pp.next
+func (s *State) Pc() *obj.Prog {
+       return s.pp.Next
 }
 
 // SetPos sets the current source position.
-func (s *SSAGenState) SetPos(pos src.XPos) {
-       s.pp.pos = pos
+func (s *State) SetPos(pos src.XPos) {
+       s.pp.Pos = pos
 }
 
 // Br emits a single branch instruction and returns the instruction.
 // Not all architectures need the returned instruction, but otherwise
 // the boilerplate is common to all.
-func (s *SSAGenState) Br(op obj.As, target *ssa.Block) *obj.Prog {
+func (s *State) Br(op obj.As, target *ssa.Block) *obj.Prog {
        p := s.Prog(op)
        p.To.Type = obj.TYPE_BRANCH
        s.Branches = append(s.Branches, Branch{P: p, B: target})
@@ -6218,7 +6337,7 @@ func (s *SSAGenState) Br(op obj.As, target *ssa.Block) *obj.Prog {
 // Spill/fill/copy instructions from the register allocator,
 // phi functions, and instructions with a no-pos position
 // are examples of instructions that can cause churn.
-func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
+func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
        switch v.Op {
        case ssa.OpPhi, ssa.OpCopy, ssa.OpLoadReg, ssa.OpStoreReg:
                // These are not statements
@@ -6232,81 +6351,30 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
                        // in the generated code.
                        if p.IsStmt() != src.PosIsStmt {
                                p = p.WithNotStmt()
-                               // Calls use the pos attached to v, but copy the statement mark from SSAGenState
+                               // Calls use the pos attached to v, but copy the statement mark from State
                        }
                        s.SetPos(p)
                } else {
-                       s.SetPos(s.pp.pos.WithNotStmt())
-               }
-       }
-}
-
-// byXoffset implements sort.Interface for []*Node using Xoffset as the ordering.
-type byXoffset []*Node
-
-func (s byXoffset) Len() int           { return len(s) }
-func (s byXoffset) Less(i, j int) bool { return s[i].Xoffset < s[j].Xoffset }
-func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-func emitStackObjects(e *ssafn, pp *Progs) {
-       var vars []*Node
-       for _, n := range e.curfn.Func.Dcl {
-               if livenessShouldTrack(n) && n.Name.Addrtaken() {
-                       vars = append(vars, n)
-               }
-       }
-       if len(vars) == 0 {
-               return
-       }
-
-       // Sort variables from lowest to highest address.
-       sort.Sort(byXoffset(vars))
-
-       // Populate the stack object data.
-       // Format must match runtime/stack.go:stackObjectRecord.
-       x := e.curfn.Func.lsym.Func().StackObjects
-       off := 0
-       off = duintptr(x, off, uint64(len(vars)))
-       for _, v := range vars {
-               // Note: arguments and return values have non-negative Xoffset,
-               // in which case the offset is relative to argp.
-               // Locals have a negative Xoffset, in which case the offset is relative to varp.
-               off = duintptr(x, off, uint64(v.Xoffset))
-               if !typesym(v.Type).Siggen() {
-                       e.Fatalf(v.Pos, "stack object's type symbol not generated for type %s", v.Type)
-               }
-               off = dsymptr(x, off, dtypesym(v.Type), 0)
-       }
-
-       // Emit a funcdata pointing at the stack object data.
-       p := pp.Prog(obj.AFUNCDATA)
-       Addrconst(&p.From, objabi.FUNCDATA_StackObjects)
-       p.To.Type = obj.TYPE_MEM
-       p.To.Name = obj.NAME_EXTERN
-       p.To.Sym = x
-
-       if debuglive != 0 {
-               for _, v := range vars {
-                       Warnl(v.Pos, "stack object %v %s", v, v.Type.String())
+                       s.SetPos(s.pp.Pos.WithNotStmt())
                }
        }
 }
 
 // genssa appends entries to pp for each instruction in f.
-func genssa(f *ssa.Func, pp *Progs) {
-       var s SSAGenState
+func genssa(f *ssa.Func, pp *objw.Progs) {
+       var s State
+       s.ABI = f.OwnAux.Fn.ABI()
 
        e := f.Frontend().(*ssafn)
 
-       s.livenessMap = liveness(e, f, pp)
-       emitStackObjects(e, pp)
+       s.livenessMap = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
 
-       openDeferInfo := e.curfn.Func.lsym.Func().OpenCodedDeferInfo
+       openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
        if openDeferInfo != nil {
                // This function uses open-coded defers -- write out the funcdata
                // info that we computed at the end of genssa.
                p := pp.Prog(obj.AFUNCDATA)
-               Addrconst(&p.From, objabi.FUNCDATA_OpenCodedDeferInfo)
+               p.From.SetConst(objabi.FUNCDATA_OpenCodedDeferInfo)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
                p.To.Sym = openDeferInfo
@@ -6322,12 +6390,12 @@ func genssa(f *ssa.Func, pp *Progs) {
                progToValue = make(map[*obj.Prog]*ssa.Value, f.NumValues())
                progToBlock = make(map[*obj.Prog]*ssa.Block, f.NumBlocks())
                f.Logf("genssa %s\n", f.Name)
-               progToBlock[s.pp.next] = f.Blocks[0]
+               progToBlock[s.pp.Next] = f.Blocks[0]
        }
 
        s.ScratchFpMem = e.scratchFpMem
 
-       if Ctxt.Flag_locationlists {
+       if base.Ctxt.Flag_locationlists {
                if cap(f.Cache.ValueToProgAfter) < f.NumValues() {
                        f.Cache.ValueToProgAfter = make([]*obj.Prog, f.NumValues())
                }
@@ -6360,7 +6428,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 
        // Emit basic blocks
        for i, b := range f.Blocks {
-               s.bstart[b.ID] = s.pp.next
+               s.bstart[b.ID] = s.pp.Next
                s.lineRunStart = nil
 
                // Attach a "default" liveness info. Normally this will be
@@ -6369,12 +6437,12 @@ func genssa(f *ssa.Func, pp *Progs) {
                // instruction. We won't use the actual liveness map on a
                // control instruction. Just mark it something that is
                // preemptible, unless this function is "all unsafe".
-               s.pp.nextLive = LivenessIndex{-1, allUnsafe(f)}
+               s.pp.NextLive = objw.LivenessIndex{StackMapIndex: -1, IsUnsafePoint: liveness.IsUnsafe(f)}
 
                // Emit values in block
-               thearch.SSAMarkMoves(&s, b)
+               Arch.SSAMarkMoves(&s, b)
                for _, v := range b.Values {
-                       x := s.pp.next
+                       x := s.pp.Next
                        s.DebugFriendlySetPosFrom(v)
 
                        switch v.Op {
@@ -6399,7 +6467,7 @@ func genssa(f *ssa.Func, pp *Progs) {
                                        v.Fatalf("OpConvert should be a no-op: %s; %s", v.Args[0].LongString(), v.LongString())
                                }
                        case ssa.OpInlMark:
-                               p := thearch.Ginsnop(s.pp)
+                               p := Arch.Ginsnop(s.pp)
                                if inlMarks == nil {
                                        inlMarks = map[*obj.Prog]int32{}
                                        inlMarksByPos = map[src.XPos][]*obj.Prog{}
@@ -6412,7 +6480,7 @@ func genssa(f *ssa.Func, pp *Progs) {
                        default:
                                // Attach this safe point to the next
                                // instruction.
-                               s.pp.nextLive = s.livenessMap.Get(v)
+                               s.pp.NextLive = s.livenessMap.Get(v)
 
                                // Special case for first line in function; move it to the start.
                                if firstPos != src.NoXPos {
@@ -6420,22 +6488,22 @@ func genssa(f *ssa.Func, pp *Progs) {
                                        firstPos = src.NoXPos
                                }
                                // let the backend handle it
-                               thearch.SSAGenValue(&s, v)
+                               Arch.SSAGenValue(&s, v)
                        }
 
-                       if Ctxt.Flag_locationlists {
-                               valueToProgAfter[v.ID] = s.pp.next
+                       if base.Ctxt.Flag_locationlists {
+                               valueToProgAfter[v.ID] = s.pp.Next
                        }
 
                        if f.PrintOrHtmlSSA {
-                               for ; x != s.pp.next; x = x.Link {
+                               for ; x != s.pp.Next; x = x.Link {
                                        progToValue[x] = v
                                }
                        }
                }
                // If this is an empty infinite loop, stick a hardware NOP in there so that debuggers are less confused.
-               if s.bstart[b.ID] == s.pp.next && len(b.Succs) == 1 && b.Succs[0].Block() == b {
-                       p := thearch.Ginsnop(s.pp)
+               if s.bstart[b.ID] == s.pp.Next && len(b.Succs) == 1 && b.Succs[0].Block() == b {
+                       p := Arch.Ginsnop(s.pp)
                        p.Pos = p.Pos.WithIsStmt()
                        if b.Pos == src.NoXPos {
                                b.Pos = p.Pos // It needs a file, otherwise a no-file non-zero line causes confusion.  See #35652.
@@ -6447,18 +6515,18 @@ func genssa(f *ssa.Func, pp *Progs) {
                }
                // Emit control flow instructions for block
                var next *ssa.Block
-               if i < len(f.Blocks)-1 && Debug.N == 0 {
+               if i < len(f.Blocks)-1 && base.Flag.N == 0 {
                        // If -N, leave next==nil so every block with successors
                        // ends in a JMP (except call blocks - plive doesn't like
                        // select{send,recv} followed by a JMP call).  Helps keep
                        // line numbers for otherwise empty blocks.
                        next = f.Blocks[i+1]
                }
-               x := s.pp.next
+               x := s.pp.Next
                s.SetPos(b.Pos)
-               thearch.SSAGenBlock(&s, b, next)
+               Arch.SSAGenBlock(&s, b, next)
                if f.PrintOrHtmlSSA {
-                       for ; x != s.pp.next; x = x.Link {
+                       for ; x != s.pp.Next; x = x.Link {
                                progToBlock[x] = b
                        }
                }
@@ -6468,14 +6536,14 @@ func genssa(f *ssa.Func, pp *Progs) {
                // still be inside the function in question. So if
                // it ends in a call which doesn't return, add a
                // nop (which will never execute) after the call.
-               thearch.Ginsnop(pp)
+               Arch.Ginsnop(pp)
        }
        if openDeferInfo != nil {
                // When doing open-coded defers, generate a disconnected call to
                // deferreturn and a return. This will be used to during panic
                // recovery to unwind the stack and return back to the runtime.
-               s.pp.nextLive = s.livenessMap.deferreturn
-               gencallret(pp, Deferreturn)
+               s.pp.NextLive = s.livenessMap.DeferReturn
+               gencallret(pp, ir.Syms.Deferreturn)
        }
 
        if inlMarks != nil {
@@ -6483,7 +6551,7 @@ func genssa(f *ssa.Func, pp *Progs) {
                // going to emit anyway, and use those instructions instead of the
                // inline marks.
                for p := pp.Text; p != nil; p = p.Link {
-                       if p.As == obj.ANOP || p.As == obj.AFUNCDATA || p.As == obj.APCDATA || p.As == obj.ATEXT || p.As == obj.APCALIGN || thearch.LinkArch.Family == sys.Wasm {
+                       if p.As == obj.ANOP || p.As == obj.AFUNCDATA || p.As == obj.APCDATA || p.As == obj.ATEXT || p.As == obj.APCALIGN || Arch.LinkArch.Family == sys.Wasm {
                                // Don't use 0-sized instructions as inline marks, because we need
                                // to identify inline mark instructions by pc offset.
                                // (Some of these instructions are sometimes zero-sized, sometimes not.
@@ -6506,7 +6574,7 @@ func genssa(f *ssa.Func, pp *Progs) {
                                // some of the inline marks.
                                // Use this instruction instead.
                                p.Pos = p.Pos.WithIsStmt() // promote position to a statement
-                               pp.curfn.Func.lsym.Func().AddInlMark(p, inlMarks[m])
+                               pp.CurFunc.LSym.Func().AddInlMark(p, inlMarks[m])
                                // Make the inline mark a real nop, so it doesn't generate any code.
                                m.As = obj.ANOP
                                m.Pos = src.NoXPos
@@ -6518,18 +6586,19 @@ func genssa(f *ssa.Func, pp *Progs) {
                // Any unmatched inline marks now need to be added to the inlining tree (and will generate a nop instruction).
                for _, p := range inlMarkList {
                        if p.As != obj.ANOP {
-                               pp.curfn.Func.lsym.Func().AddInlMark(p, inlMarks[p])
+                               pp.CurFunc.LSym.Func().AddInlMark(p, inlMarks[p])
                        }
                }
        }
 
-       if Ctxt.Flag_locationlists {
-               e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(Ctxt, f, Debug_locationlist > 1, stackOffset)
+       if base.Ctxt.Flag_locationlists {
+               debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
+               e.curfn.DebugInfo = debugInfo
                bstart := s.bstart
                // Note that at this moment, Prog.Pc is a sequence number; it's
                // not a real PC until after assembly, so this mapping has to
                // be done later.
-               e.curfn.Func.DebugInfo.GetPC = func(b, v ssa.ID) int64 {
+               debugInfo.GetPC = func(b, v ssa.ID) int64 {
                        switch v {
                        case ssa.BlockStart.ID:
                                if b == f.Entry.ID {
@@ -6538,7 +6607,7 @@ func genssa(f *ssa.Func, pp *Progs) {
                                }
                                return bstart[b].Pc
                        case ssa.BlockEnd.ID:
-                               return e.curfn.Func.lsym.Size
+                               return e.curfn.LSym.Size
                        default:
                                return valueToProgAfter[v].Pc
                        }
@@ -6612,17 +6681,17 @@ func genssa(f *ssa.Func, pp *Progs) {
        f.HTMLWriter = nil
 }
 
-func defframe(s *SSAGenState, e *ssafn) {
+func defframe(s *State, e *ssafn) {
        pp := s.pp
 
-       frame := Rnd(s.maxarg+e.stksize, int64(Widthreg))
-       if thearch.PadFrame != nil {
-               frame = thearch.PadFrame(frame)
+       frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
+       if Arch.PadFrame != nil {
+               frame = Arch.PadFrame(frame)
        }
 
        // Fill in argument and frame size.
        pp.Text.To.Type = obj.TYPE_TEXTSIZE
-       pp.Text.To.Val = int32(Rnd(e.curfn.Type.ArgWidth(), int64(Widthreg)))
+       pp.Text.To.Val = int32(types.Rnd(e.curfn.Type().ArgWidth(), int64(types.RegSize)))
        pp.Text.To.Offset = frame
 
        // Insert code to zero ambiguously live variables so that the
@@ -6636,33 +6705,33 @@ func defframe(s *SSAGenState, e *ssafn) {
        var state uint32
 
        // Iterate through declarations. They are sorted in decreasing Xoffset order.
-       for _, n := range e.curfn.Func.Dcl {
-               if !n.Name.Needzero() {
+       for _, n := range e.curfn.Dcl {
+               if !n.Needzero() {
                        continue
                }
-               if n.Class() != PAUTO {
-                       e.Fatalf(n.Pos, "needzero class %d", n.Class())
+               if n.Class != ir.PAUTO {
+                       e.Fatalf(n.Pos(), "needzero class %d", n.Class)
                }
-               if n.Type.Size()%int64(Widthptr) != 0 || n.Xoffset%int64(Widthptr) != 0 || n.Type.Size() == 0 {
-                       e.Fatalf(n.Pos, "var %L has size %d offset %d", n, n.Type.Size(), n.Xoffset)
+               if n.Type().Size()%int64(types.PtrSize) != 0 || n.FrameOffset()%int64(types.PtrSize) != 0 || n.Type().Size() == 0 {
+                       e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset_)
                }
 
-               if lo != hi && n.Xoffset+n.Type.Size() >= lo-int64(2*Widthreg) {
+               if lo != hi && n.FrameOffset()+n.Type().Size() >= lo-int64(2*types.RegSize) {
                        // Merge with range we already have.
-                       lo = n.Xoffset
+                       lo = n.FrameOffset()
                        continue
                }
 
                // Zero old range
-               p = thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
+               p = Arch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 
                // Set new range.
-               lo = n.Xoffset
-               hi = lo + n.Type.Size()
+               lo = n.FrameOffset()
+               hi = lo + n.Type().Size()
        }
 
        // Zero final range.
-       thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
+       Arch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 }
 
 // For generating consecutive jump instructions to model a specific branching
@@ -6671,14 +6740,14 @@ type IndexJump struct {
        Index int
 }
 
-func (s *SSAGenState) oneJump(b *ssa.Block, jump *IndexJump) {
+func (s *State) oneJump(b *ssa.Block, jump *IndexJump) {
        p := s.Br(jump.Jump, b.Succs[jump.Index].Block())
        p.Pos = b.Pos
 }
 
 // CombJump generates combinational instructions (2 at present) for a block jump,
 // thereby the behaviour of non-standard condition codes could be simulated
-func (s *SSAGenState) CombJump(b, next *ssa.Block, jumps *[2][2]IndexJump) {
+func (s *State) CombJump(b, next *ssa.Block, jumps *[2][2]IndexJump) {
        switch next {
        case b.Succs[0].Block():
                s.oneJump(b, &jumps[0][0])
@@ -6724,16 +6793,16 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
        case *obj.LSym:
                a.Name = obj.NAME_EXTERN
                a.Sym = n
-       case *Node:
-               if n.Class() == PPARAM || n.Class() == PPARAMOUT {
+       case *ir.Name:
+               if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
                        a.Name = obj.NAME_PARAM
-                       a.Sym = n.Orig.Sym.Linksym()
-                       a.Offset += n.Xoffset
+                       a.Sym = ir.Orig(n).(*ir.Name).Linksym()
+                       a.Offset += n.FrameOffset()
                        break
                }
                a.Name = obj.NAME_AUTO
-               a.Sym = n.Sym.Linksym()
-               a.Offset += n.Xoffset
+               a.Sym = n.Linksym()
+               a.Offset += n.FrameOffset()
        default:
                v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
        }
@@ -6751,17 +6820,17 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
                // high word and branch to out-of-bounds failure if it is not 0.
                var lo *ssa.Value
                if idx.Type.IsSigned() {
-                       lo = s.newValue1(ssa.OpInt64Lo, types.Types[TINT], idx)
+                       lo = s.newValue1(ssa.OpInt64Lo, types.Types[types.TINT], idx)
                } else {
-                       lo = s.newValue1(ssa.OpInt64Lo, types.Types[TUINT], idx)
+                       lo = s.newValue1(ssa.OpInt64Lo, types.Types[types.TUINT], idx)
                }
-               if bounded || Debug.B != 0 {
+               if bounded || base.Flag.B != 0 {
                        return lo
                }
                bNext := s.f.NewBlock(ssa.BlockPlain)
                bPanic := s.f.NewBlock(ssa.BlockExit)
-               hi := s.newValue1(ssa.OpInt64Hi, types.Types[TUINT32], idx)
-               cmp := s.newValue2(ssa.OpEq32, types.Types[TBOOL], hi, s.constInt32(types.Types[TUINT32], 0))
+               hi := s.newValue1(ssa.OpInt64Hi, types.Types[types.TUINT32], idx)
+               cmp := s.newValue2(ssa.OpEq32, types.Types[types.TBOOL], hi, s.constInt32(types.Types[types.TUINT32], 0))
                if !idx.Type.IsSigned() {
                        switch kind {
                        case ssa.BoundsIndex:
@@ -6830,7 +6899,7 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
                        s.Fatalf("bad unsigned index extension %s", idx.Type)
                }
        }
-       return s.newValue1(op, types.Types[TINT], idx)
+       return s.newValue1(op, types.Types[types.TINT], idx)
 }
 
 // CheckLoweredPhi checks that regalloc and stackalloc correctly handled phi values.
@@ -6857,48 +6926,38 @@ func CheckLoweredPhi(v *ssa.Value) {
 func CheckLoweredGetClosurePtr(v *ssa.Value) {
        entry := v.Block.Func.Entry
        if entry != v.Block || entry.Values[0] != v {
-               Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
+               base.Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
        }
 }
 
-// AutoVar returns a *Node and int64 representing the auto variable and offset within it
-// where v should be spilled.
-func AutoVar(v *ssa.Value) (*Node, int64) {
-       loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
-       if v.Type.Size() > loc.Type.Size() {
-               v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
-       }
-       return loc.N.(*Node), loc.Off
-}
-
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
-       n, off := AutoVar(v)
+       n, off := ssa.AutoVar(v)
        a.Type = obj.TYPE_MEM
-       a.Sym = n.Sym.Linksym()
-       a.Reg = int16(thearch.REGSP)
-       a.Offset = n.Xoffset + off
-       if n.Class() == PPARAM || n.Class() == PPARAMOUT {
+       a.Sym = n.Linksym()
+       a.Reg = int16(Arch.REGSP)
+       a.Offset = n.FrameOffset() + off
+       if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
                a.Name = obj.NAME_PARAM
        } else {
                a.Name = obj.NAME_AUTO
        }
 }
 
-func (s *SSAGenState) AddrScratch(a *obj.Addr) {
+func (s *State) AddrScratch(a *obj.Addr) {
        if s.ScratchFpMem == nil {
                panic("no scratch memory available; forgot to declare usesScratch for Op?")
        }
        a.Type = obj.TYPE_MEM
        a.Name = obj.NAME_AUTO
-       a.Sym = s.ScratchFpMem.Sym.Linksym()
-       a.Reg = int16(thearch.REGSP)
-       a.Offset = s.ScratchFpMem.Xoffset
+       a.Sym = s.ScratchFpMem.Linksym()
+       a.Reg = int16(Arch.REGSP)
+       a.Offset = s.ScratchFpMem.Offset_
 }
 
 // Call returns a new CALL instruction for the SSA value v.
 // It uses PrepareCall to prepare the call.
-func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
-       pPosIsStmt := s.pp.pos.IsStmt() // The statement-ness fo the call comes from ssaGenState
+func (s *State) Call(v *ssa.Value) *obj.Prog {
+       pPosIsStmt := s.pp.Pos.IsStmt() // The statement-ness fo the call comes from ssaGenState
        s.PrepareCall(v)
 
        p := s.Prog(obj.ACALL)
@@ -6913,13 +6972,13 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
                p.To.Sym = sym.Fn
        } else {
                // TODO(mdempsky): Can these differences be eliminated?
-               switch thearch.LinkArch.Family {
+               switch Arch.LinkArch.Family {
                case sys.AMD64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm:
                        p.To.Type = obj.TYPE_REG
                case sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64:
                        p.To.Type = obj.TYPE_MEM
                default:
-                       Fatalf("unknown indirect call family")
+                       base.Fatalf("unknown indirect call family")
                }
                p.To.Reg = v.Args[0].Reg()
        }
@@ -6929,18 +6988,18 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
 // PrepareCall prepares to emit a CALL instruction for v and does call-related bookkeeping.
 // It must be called immediately before emitting the actual CALL instruction,
 // since it emits PCDATA for the stack map at the call (calls are safe points).
-func (s *SSAGenState) PrepareCall(v *ssa.Value) {
+func (s *State) PrepareCall(v *ssa.Value) {
        idx := s.livenessMap.Get(v)
        if !idx.StackMapValid() {
                // See Liveness.hasStackMap.
-               if sym, ok := v.Aux.(*ssa.AuxCall); !ok || !(sym.Fn == typedmemclr || sym.Fn == typedmemmove) {
-                       Fatalf("missing stack map index for %v", v.LongString())
+               if sym, ok := v.Aux.(*ssa.AuxCall); !ok || !(sym.Fn == ir.Syms.Typedmemclr || sym.Fn == ir.Syms.Typedmemmove) {
+                       base.Fatalf("missing stack map index for %v", v.LongString())
                }
        }
 
        call, ok := v.Aux.(*ssa.AuxCall)
 
-       if ok && call.Fn == Deferreturn {
+       if ok && call.Fn == ir.Syms.Deferreturn {
                // Deferred calls will appear to be returning to
                // the CALL deferreturn(SB) that we are about to emit.
                // However, the stack trace code will show the line
@@ -6949,14 +7008,14 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
                // insert an actual hardware NOP that will have the right line number.
                // This is different from obj.ANOP, which is a virtual no-op
                // that doesn't make it into the instruction stream.
-               thearch.Ginsnopdefer(s.pp)
+               Arch.Ginsnopdefer(s.pp)
        }
 
        if ok {
                // Record call graph information for nowritebarrierrec
                // analysis.
                if nowritebarrierrecCheck != nil {
-                       nowritebarrierrecCheck.recordCall(s.pp.curfn, call.Fn, v.Pos)
+                       nowritebarrierrecCheck.recordCall(s.pp.CurFunc, call.Fn, v.Pos)
                }
        }
 
@@ -6967,30 +7026,26 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 
 // UseArgs records the fact that an instruction needs a certain amount of
 // callee args space for its use.
-func (s *SSAGenState) UseArgs(n int64) {
+func (s *State) UseArgs(n int64) {
        if s.maxarg < n {
                s.maxarg = n
        }
 }
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
-func fieldIdx(n *Node) int {
-       t := n.Left.Type
-       f := n.Sym
+func fieldIdx(n *ir.SelectorExpr) int {
+       t := n.X.Type()
        if !t.IsStruct() {
                panic("ODOT's LHS is not a struct")
        }
 
-       var i int
-       for _, t1 := range t.Fields().Slice() {
-               if t1.Sym != f {
-                       i++
-                       continue
-               }
-               if t1.Offset != n.Xoffset {
-                       panic("field offset doesn't match")
+       for i, f := range t.Fields().Slice() {
+               if f.Sym == n.Sel {
+                       if f.Offset != n.Offset() {
+                               panic("field offset doesn't match")
+                       }
+                       return i
                }
-               return i
        }
        panic(fmt.Sprintf("can't find field in expr %v\n", n))
 
@@ -7001,9 +7056,9 @@ func fieldIdx(n *Node) int {
 // ssafn holds frontend information about a function that the backend is processing.
 // It also exports a bunch of compiler services for the ssa backend.
 type ssafn struct {
-       curfn        *Node
+       curfn        *ir.Func
        strings      map[string]*obj.LSym // map from constant string to data symbols
-       scratchFpMem *Node                // temp for floating point register / memory moves on some architectures
+       scratchFpMem *ir.Name             // temp for floating point register / memory moves on some architectures
        stksize      int64                // stack size for current frame
        stkptrsize   int64                // prefix of stack containing pointers
        log          bool                 // print ssa debug to the stdout
@@ -7018,19 +7073,18 @@ func (e *ssafn) StringData(s string) *obj.LSym {
        if e.strings == nil {
                e.strings = make(map[string]*obj.LSym)
        }
-       data := stringsym(e.curfn.Pos, s)
+       data := staticdata.StringSym(e.curfn.Pos(), s)
        e.strings[s] = data
        return data
 }
 
-func (e *ssafn) Auto(pos src.XPos, t *types.Type) ssa.GCNode {
-       n := tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
-       return n
+func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Name {
+       return typecheck.TempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 }
 
 func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-       ptrType := types.NewPtr(types.Types[TUINT8])
-       lenType := types.Types[TINT]
+       ptrType := types.NewPtr(types.Types[types.TUINT8])
+       lenType := types.Types[types.TINT]
        // Split this string up into two separate variables.
        p := e.SplitSlot(&name, ".ptr", 0, ptrType)
        l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
@@ -7038,22 +7092,22 @@ func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
 }
 
 func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-       n := name.N.(*Node)
-       u := types.Types[TUINTPTR]
-       t := types.NewPtr(types.Types[TUINT8])
+       n := name.N
+       u := types.Types[types.TUINTPTR]
+       t := types.NewPtr(types.Types[types.TUINT8])
        // Split this interface up into two separate variables.
        f := ".itab"
-       if n.Type.IsEmptyInterface() {
+       if n.Type().IsEmptyInterface() {
                f = ".type"
        }
-       c := e.SplitSlot(&name, f, 0, u) // see comment in plive.go:onebitwalktype1.
+       c := e.SplitSlot(&name, f, 0, u) // see comment in typebits.Set
        d := e.SplitSlot(&name, ".data", u.Size(), t)
        return c, d
 }
 
 func (e *ssafn) SplitSlice(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot, ssa.LocalSlot) {
        ptrType := types.NewPtr(name.Type.Elem())
-       lenType := types.Types[TINT]
+       lenType := types.Types[types.TINT]
        p := e.SplitSlot(&name, ".ptr", 0, ptrType)
        l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
        c := e.SplitSlot(&name, ".cap", ptrType.Size()+lenType.Size(), lenType)
@@ -7064,9 +7118,9 @@ func (e *ssafn) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot)
        s := name.Type.Size() / 2
        var t *types.Type
        if s == 8 {
-               t = types.Types[TFLOAT64]
+               t = types.Types[types.TFLOAT64]
        } else {
-               t = types.Types[TFLOAT32]
+               t = types.Types[types.TFLOAT32]
        }
        r := e.SplitSlot(&name, ".real", 0, t)
        i := e.SplitSlot(&name, ".imag", t.Size(), t)
@@ -7076,14 +7130,14 @@ func (e *ssafn) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot)
 func (e *ssafn) SplitInt64(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
        var t *types.Type
        if name.Type.IsSigned() {
-               t = types.Types[TINT32]
+               t = types.Types[types.TINT32]
        } else {
-               t = types.Types[TUINT32]
+               t = types.Types[types.TUINT32]
        }
-       if thearch.LinkArch.ByteOrder == binary.BigEndian {
-               return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[TUINT32])
+       if Arch.LinkArch.ByteOrder == binary.BigEndian {
+               return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[types.TUINT32])
        }
-       return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[TUINT32])
+       return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[types.TUINT32])
 }
 
 func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
@@ -7095,55 +7149,47 @@ func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
 }
 
 func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
-       n := name.N.(*Node)
+       n := name.N
        at := name.Type
        if at.NumElem() != 1 {
-               e.Fatalf(n.Pos, "bad array size")
+               e.Fatalf(n.Pos(), "bad array size")
        }
        et := at.Elem()
        return e.SplitSlot(&name, "[0]", 0, et)
 }
 
 func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
-       return itabsym(it, offset)
+       return reflectdata.ITabSym(it, offset)
 }
 
 // SplitSlot returns a slot representing the data of parent starting at offset.
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
-       node := parent.N.(*Node)
+       node := parent.N
 
-       if node.Class() != PAUTO || node.Name.Addrtaken() {
+       if node.Class != ir.PAUTO || node.Addrtaken() {
                // addressed things and non-autos retain their parents (i.e., cannot truly be split)
                return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
        }
 
-       s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: localpkg}
-
-       n := &Node{
-               Name: new(Name),
-               Op:   ONAME,
-               Pos:  parent.N.(*Node).Pos,
-       }
-       n.Orig = n
-
-       s.Def = asTypesNode(n)
-       asNode(s.Def).Name.SetUsed(true)
-       n.Sym = s
-       n.Type = t
-       n.SetClass(PAUTO)
-       n.Esc = EscNever
-       n.Name.Curfn = e.curfn
-       e.curfn.Func.Dcl = append(e.curfn.Func.Dcl, n)
-       dowidth(t)
+       s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: types.LocalPkg}
+       n := ir.NewNameAt(parent.N.Pos(), s)
+       s.Def = n
+       ir.AsNode(s.Def).Name().SetUsed(true)
+       n.SetType(t)
+       n.Class = ir.PAUTO
+       n.SetEsc(ir.EscNever)
+       n.Curfn = e.curfn
+       e.curfn.Dcl = append(e.curfn.Dcl, n)
+       types.CalcSize(t)
        return ssa.LocalSlot{N: n, Type: t, Off: 0, SplitOf: parent, SplitOffset: offset}
 }
 
 func (e *ssafn) CanSSA(t *types.Type) bool {
-       return canSSAType(t)
+       return TypeOK(t)
 }
 
 func (e *ssafn) Line(pos src.XPos) string {
-       return linestr(pos)
+       return base.FmtPos(pos)
 }
 
 // Log logs a message from the compiler.
@@ -7159,73 +7205,165 @@ func (e *ssafn) Log() bool {
 
 // Fatal reports a compiler error and exits.
 func (e *ssafn) Fatalf(pos src.XPos, msg string, args ...interface{}) {
-       lineno = pos
-       nargs := append([]interface{}{e.curfn.funcname()}, args...)
-       Fatalf("'%s': "+msg, nargs...)
+       base.Pos = pos
+       nargs := append([]interface{}{ir.FuncName(e.curfn)}, args...)
+       base.Fatalf("'%s': "+msg, nargs...)
 }
 
 // Warnl reports a "warning", which is usually flag-triggered
 // logging output for the benefit of tests.
 func (e *ssafn) Warnl(pos src.XPos, fmt_ string, args ...interface{}) {
-       Warnl(pos, fmt_, args...)
+       base.WarnfAt(pos, fmt_, args...)
 }
 
 func (e *ssafn) Debug_checknil() bool {
-       return Debug_checknil != 0
+       return base.Debug.Nil != 0
 }
 
 func (e *ssafn) UseWriteBarrier() bool {
-       return use_writebarrier
+       return base.Flag.WB
 }
 
 func (e *ssafn) Syslook(name string) *obj.LSym {
        switch name {
        case "goschedguarded":
-               return goschedguarded
+               return ir.Syms.Goschedguarded
        case "writeBarrier":
-               return writeBarrier
+               return ir.Syms.WriteBarrier
        case "gcWriteBarrier":
-               return gcWriteBarrier
+               return ir.Syms.GCWriteBarrier
        case "typedmemmove":
-               return typedmemmove
+               return ir.Syms.Typedmemmove
        case "typedmemclr":
-               return typedmemclr
+               return ir.Syms.Typedmemclr
        }
        e.Fatalf(src.NoXPos, "unknown Syslook func %v", name)
        return nil
 }
 
 func (e *ssafn) SetWBPos(pos src.XPos) {
-       e.curfn.Func.setWBPos(pos)
+       e.curfn.SetWBPos(pos)
 }
 
 func (e *ssafn) MyImportPath() string {
-       return myimportpath
+       return base.Ctxt.Pkgpath
 }
 
-func (n *Node) Typ() *types.Type {
-       return n.Type
+func clobberBase(n ir.Node) ir.Node {
+       if n.Op() == ir.ODOT {
+               n := n.(*ir.SelectorExpr)
+               if n.X.Type().NumFields() == 1 {
+                       return clobberBase(n.X)
+               }
+       }
+       if n.Op() == ir.OINDEX {
+               n := n.(*ir.IndexExpr)
+               if n.X.Type().IsArray() && n.X.Type().NumElem() == 1 {
+                       return clobberBase(n.X)
+               }
+       }
+       return n
 }
-func (n *Node) StorageClass() ssa.StorageClass {
-       switch n.Class() {
-       case PPARAM:
-               return ssa.ClassParam
-       case PPARAMOUT:
-               return ssa.ClassParamOut
-       case PAUTO:
-               return ssa.ClassAuto
-       default:
-               Fatalf("untranslatable storage class for %v: %s", n, n.Class())
-               return 0
+
+// callTargetLSym determines the correct LSym for 'callee' when called
+// from function 'caller'. There are a couple of different scenarios
+// to contend with here:
+//
+// 1. if 'caller' is an ABI wrapper, then we always want to use the
+//    LSym from the Func for the callee.
+//
+// 2. if 'caller' is not an ABI wrapper, then we looked at the callee
+//    to see if it corresponds to a "known" ABI0 symbol (e.g. assembly
+//    routine defined in the current package); if so, we want the call to
+//    directly target the ABI0 symbol (effectively bypassing the
+//    ABIInternal->ABI0 wrapper for 'callee').
+//
+// 3. in all other cases, want the regular ABIInternal linksym
+//
+func callTargetLSym(callee *ir.Name, callerLSym *obj.LSym) *obj.LSym {
+       lsym := callee.Linksym()
+       if !base.Flag.ABIWrap {
+               return lsym
        }
+       fn := callee.Func
+       if fn == nil {
+               return lsym
+       }
+
+       // check for case 1 above
+       if callerLSym.ABIWrapper() {
+               if nlsym := fn.LSym; nlsym != nil {
+                       lsym = nlsym
+               }
+       } else {
+               // check for case 2 above
+               defABI, hasDefABI := symabiDefs[lsym.Name]
+               if hasDefABI && defABI == obj.ABI0 {
+                       lsym = callee.LinksymABI(obj.ABI0)
+               }
+       }
+       return lsym
 }
 
-func clobberBase(n *Node) *Node {
-       if n.Op == ODOT && n.Left.Type.NumFields() == 1 {
-               return clobberBase(n.Left)
+func min8(a, b int8) int8 {
+       if a < b {
+               return a
        }
-       if n.Op == OINDEX && n.Left.Type.IsArray() && n.Left.Type.NumElem() == 1 {
-               return clobberBase(n.Left)
+       return b
+}
+
+func max8(a, b int8) int8 {
+       if a > b {
+               return a
        }
-       return n
+       return b
+}
+
+// deferstruct makes a runtime._defer structure, with additional space for
+// stksize bytes of args.
+func deferstruct(stksize int64) *types.Type {
+       makefield := func(name string, typ *types.Type) *types.Field {
+               // Unlike the global makefield function, this one needs to set Pkg
+               // because these types might be compared (in SSA CSE sorting).
+               // TODO: unify this makefield and the global one above.
+               sym := &types.Sym{Name: name, Pkg: types.LocalPkg}
+               return types.NewField(src.NoXPos, sym, typ)
+       }
+       argtype := types.NewArray(types.Types[types.TUINT8], stksize)
+       argtype.Width = stksize
+       argtype.Align = 1
+       // These fields must match the ones in runtime/runtime2.go:_defer and
+       // cmd/compile/internal/gc/ssa.go:(*state).call.
+       fields := []*types.Field{
+               makefield("siz", types.Types[types.TUINT32]),
+               makefield("started", types.Types[types.TBOOL]),
+               makefield("heap", types.Types[types.TBOOL]),
+               makefield("openDefer", types.Types[types.TBOOL]),
+               makefield("sp", types.Types[types.TUINTPTR]),
+               makefield("pc", types.Types[types.TUINTPTR]),
+               // Note: the types here don't really matter. Defer structures
+               // are always scanned explicitly during stack copying and GC,
+               // so we make them uintptr type even though they are real pointers.
+               makefield("fn", types.Types[types.TUINTPTR]),
+               makefield("_panic", types.Types[types.TUINTPTR]),
+               makefield("link", types.Types[types.TUINTPTR]),
+               makefield("framepc", types.Types[types.TUINTPTR]),
+               makefield("varp", types.Types[types.TUINTPTR]),
+               makefield("fd", types.Types[types.TUINTPTR]),
+               makefield("args", argtype),
+       }
+
+       // build struct holding the above fields
+       s := types.NewStruct(types.NoPkg, fields)
+       s.SetNoalg(true)
+       types.CalcStructSize(s)
+       return s
 }
+
+var (
+       BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
+       ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
+)
+
+// GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
+var GCWriteBarrierReg map[int16]*obj.LSym

diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
new file mode 100644 (file)
index 0000000..b06fd7a
--- /dev/null
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -0,0 +1,353 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package staticdata
+
+import (
+       "crypto/sha256"
+       "fmt"
+       "go/constant"
+       "io"
+       "io/ioutil"
+       "os"
+       "sort"
+       "strconv"
+       "sync"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+       "cmd/internal/src"
+)
+
+// InitAddrOffset writes the static name symbol lsym to n, it does not modify n.
+// It's the caller responsibility to make sure lsym is from ONAME/PEXTERN node.
+func InitAddrOffset(n *ir.Name, noff int64, lsym *obj.LSym, off int64) {
+       if n.Op() != ir.ONAME {
+               base.Fatalf("InitAddr n op %v", n.Op())
+       }
+       if n.Sym() == nil {
+               base.Fatalf("InitAddr nil n sym")
+       }
+       s := n.Linksym()
+       s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, off)
+}
+
+// InitAddr is InitAddrOffset, with offset fixed to 0.
+func InitAddr(n *ir.Name, noff int64, lsym *obj.LSym) {
+       InitAddrOffset(n, noff, lsym, 0)
+}
+
+// InitSlice writes a static slice symbol {lsym, lencap, lencap} to n+noff, it does not modify n.
+// It's the caller responsibility to make sure lsym is from ONAME node.
+func InitSlice(n *ir.Name, noff int64, lsym *obj.LSym, lencap int64) {
+       s := n.Linksym()
+       s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, 0)
+       s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
+       s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
+}
+
+func InitSliceBytes(nam *ir.Name, off int64, s string) {
+       if nam.Op() != ir.ONAME {
+               base.Fatalf("InitSliceBytes %v", nam)
+       }
+       InitSlice(nam, off, slicedata(nam.Pos(), s).Linksym(), int64(len(s)))
+}
+
+const (
+       stringSymPrefix  = "go.string."
+       stringSymPattern = ".gostring.%d.%x"
+)
+
+// StringSym returns a symbol containing the string s.
+// The symbol contains the string data, not a string header.
+func StringSym(pos src.XPos, s string) (data *obj.LSym) {
+       var symname string
+       if len(s) > 100 {
+               // Huge strings are hashed to avoid long names in object files.
+               // Indulge in some paranoia by writing the length of s, too,
+               // as protection against length extension attacks.
+               // Same pattern is known to fileStringSym below.
+               h := sha256.New()
+               io.WriteString(h, s)
+               symname = fmt.Sprintf(stringSymPattern, len(s), h.Sum(nil))
+       } else {
+               // Small strings get named directly by their contents.
+               symname = strconv.Quote(s)
+       }
+
+       symdata := base.Ctxt.Lookup(stringSymPrefix + symname)
+       if !symdata.OnList() {
+               off := dstringdata(symdata, 0, s, pos, "string")
+               objw.Global(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
+               symdata.Set(obj.AttrContentAddressable, true)
+       }
+
+       return symdata
+}
+
+// fileStringSym returns a symbol for the contents and the size of file.
+// If readonly is true, the symbol shares storage with any literal string
+// or other file with the same content and is placed in a read-only section.
+// If readonly is false, the symbol is a read-write copy separate from any other,
+// for use as the backing store of a []byte.
+// The content hash of file is copied into hash. (If hash is nil, nothing is copied.)
+// The returned symbol contains the data itself, not a string header.
+func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.LSym, int64, error) {
+       f, err := os.Open(file)
+       if err != nil {
+               return nil, 0, err
+       }
+       defer f.Close()
+       info, err := f.Stat()
+       if err != nil {
+               return nil, 0, err
+       }
+       if !info.Mode().IsRegular() {
+               return nil, 0, fmt.Errorf("not a regular file")
+       }
+       size := info.Size()
+       if size <= 1*1024 {
+               data, err := ioutil.ReadAll(f)
+               if err != nil {
+                       return nil, 0, err
+               }
+               if int64(len(data)) != size {
+                       return nil, 0, fmt.Errorf("file changed between reads")
+               }
+               var sym *obj.LSym
+               if readonly {
+                       sym = StringSym(pos, string(data))
+               } else {
+                       sym = slicedata(pos, string(data)).Linksym()
+               }
+               if len(hash) > 0 {
+                       sum := sha256.Sum256(data)
+                       copy(hash, sum[:])
+               }
+               return sym, size, nil
+       }
+       if size > 2e9 {
+               // ggloblsym takes an int32,
+               // and probably the rest of the toolchain
+               // can't handle such big symbols either.
+               // See golang.org/issue/9862.
+               return nil, 0, fmt.Errorf("file too large")
+       }
+
+       // File is too big to read and keep in memory.
+       // Compute hash if needed for read-only content hashing or if the caller wants it.
+       var sum []byte
+       if readonly || len(hash) > 0 {
+               h := sha256.New()
+               n, err := io.Copy(h, f)
+               if err != nil {
+                       return nil, 0, err
+               }
+               if n != size {
+                       return nil, 0, fmt.Errorf("file changed between reads")
+               }
+               sum = h.Sum(nil)
+               copy(hash, sum)
+       }
+
+       var symdata *obj.LSym
+       if readonly {
+               symname := fmt.Sprintf(stringSymPattern, size, sum)
+               symdata = base.Ctxt.Lookup(stringSymPrefix + symname)
+               if !symdata.OnList() {
+                       info := symdata.NewFileInfo()
+                       info.Name = file
+                       info.Size = size
+                       objw.Global(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
+                       // Note: AttrContentAddressable cannot be set here,
+                       // because the content-addressable-handling code
+                       // does not know about file symbols.
+               }
+       } else {
+               // Emit a zero-length data symbol
+               // and then fix up length and content to use file.
+               symdata = slicedata(pos, "").Linksym()
+               symdata.Size = size
+               symdata.Type = objabi.SNOPTRDATA
+               info := symdata.NewFileInfo()
+               info.Name = file
+               info.Size = size
+       }
+
+       return symdata, size, nil
+}
+
+var slicedataGen int
+
+func slicedata(pos src.XPos, s string) *ir.Name {
+       slicedataGen++
+       symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
+       sym := types.LocalPkg.Lookup(symname)
+       symnode := typecheck.NewName(sym)
+       sym.Def = symnode
+
+       lsym := symnode.Linksym()
+       off := dstringdata(lsym, 0, s, pos, "slice")
+       objw.Global(lsym, int32(off), obj.NOPTR|obj.LOCAL)
+
+       return symnode
+}
+
+func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
+       // Objects that are too large will cause the data section to overflow right away,
+       // causing a cryptic error message by the linker. Check for oversize objects here
+       // and provide a useful error message instead.
+       if int64(len(t)) > 2e9 {
+               base.ErrorfAt(pos, "%v with length %v is too big", what, len(t))
+               return 0
+       }
+
+       s.WriteString(base.Ctxt, int64(off), len(t), t)
+       return off + len(t)
+}
+
+var (
+       funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
+       funcsyms   []*types.Sym
+)
+
+// FuncSym returns s·f.
+func FuncSym(s *types.Sym) *types.Sym {
+       // funcsymsmu here serves to protect not just mutations of funcsyms (below),
+       // but also the package lookup of the func sym name,
+       // since this function gets called concurrently from the backend.
+       // There are no other concurrent package lookups in the backend,
+       // except for the types package, which is protected separately.
+       // Reusing funcsymsmu to also cover this package lookup
+       // avoids a general, broader, expensive package lookup mutex.
+       // Note NeedFuncSym also does package look-up of func sym names,
+       // but that it is only called serially, from the front end.
+       funcsymsmu.Lock()
+       sf, existed := s.Pkg.LookupOK(ir.FuncSymName(s))
+       // Don't export s·f when compiling for dynamic linking.
+       // When dynamically linking, the necessary function
+       // symbols will be created explicitly with NeedFuncSym.
+       // See the NeedFuncSym comment for details.
+       if !base.Ctxt.Flag_dynlink && !existed {
+               funcsyms = append(funcsyms, s)
+       }
+       funcsymsmu.Unlock()
+       return sf
+}
+
+func FuncLinksym(n *ir.Name) *obj.LSym {
+       if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
+               base.Fatalf("expected func name: %v", n)
+       }
+       return FuncSym(n.Sym()).Linksym()
+}
+
+func GlobalLinksym(n *ir.Name) *obj.LSym {
+       if n.Op() != ir.ONAME || n.Class != ir.PEXTERN {
+               base.Fatalf("expected global variable: %v", n)
+       }
+       return n.Linksym()
+}
+
+// NeedFuncSym ensures that s·f is exported, if needed.
+// It is only used with -dynlink.
+// When not compiling for dynamic linking,
+// the funcsyms are created as needed by
+// the packages that use them.
+// Normally we emit the s·f stubs as DUPOK syms,
+// but DUPOK doesn't work across shared library boundaries.
+// So instead, when dynamic linking, we only create
+// the s·f stubs in s's package.
+func NeedFuncSym(s *types.Sym) {
+       if base.Ctxt.InParallel {
+               // The append below probably just needs to lock
+               // funcsymsmu, like in FuncSym.
+               base.Fatalf("NeedFuncSym must be called in serial")
+       }
+       if !base.Ctxt.Flag_dynlink {
+               return
+       }
+       if s.IsBlank() {
+               return
+       }
+       if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
+               // runtime.getg(), getclosureptr(), getcallerpc(), and
+               // getcallersp() are not real functions and so do not
+               // get funcsyms.
+               return
+       }
+       funcsyms = append(funcsyms, s)
+}
+
+func WriteFuncSyms() {
+       sort.Slice(funcsyms, func(i, j int) bool {
+               return funcsyms[i].Linksym().Name < funcsyms[j].Linksym().Name
+       })
+       for _, s := range funcsyms {
+               sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
+               objw.SymPtr(sf, 0, s.Linksym(), 0)
+               objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+       }
+}
+
+// InitConst writes the static literal c to n.
+// Neither n nor c is modified.
+func InitConst(n *ir.Name, noff int64, c ir.Node, wid int) {
+       if n.Op() != ir.ONAME {
+               base.Fatalf("InitConst n op %v", n.Op())
+       }
+       if n.Sym() == nil {
+               base.Fatalf("InitConst nil n sym")
+       }
+       if c.Op() == ir.ONIL {
+               return
+       }
+       if c.Op() != ir.OLITERAL {
+               base.Fatalf("InitConst c op %v", c.Op())
+       }
+       s := n.Linksym()
+       switch u := c.Val(); u.Kind() {
+       case constant.Bool:
+               i := int64(obj.Bool2int(constant.BoolVal(u)))
+               s.WriteInt(base.Ctxt, noff, wid, i)
+
+       case constant.Int:
+               s.WriteInt(base.Ctxt, noff, wid, ir.IntVal(c.Type(), u))
+
+       case constant.Float:
+               f, _ := constant.Float64Val(u)
+               switch c.Type().Kind() {
+               case types.TFLOAT32:
+                       s.WriteFloat32(base.Ctxt, noff, float32(f))
+               case types.TFLOAT64:
+                       s.WriteFloat64(base.Ctxt, noff, f)
+               }
+
+       case constant.Complex:
+               re, _ := constant.Float64Val(constant.Real(u))
+               im, _ := constant.Float64Val(constant.Imag(u))
+               switch c.Type().Kind() {
+               case types.TCOMPLEX64:
+                       s.WriteFloat32(base.Ctxt, noff, float32(re))
+                       s.WriteFloat32(base.Ctxt, noff+4, float32(im))
+               case types.TCOMPLEX128:
+                       s.WriteFloat64(base.Ctxt, noff, re)
+                       s.WriteFloat64(base.Ctxt, noff+8, im)
+               }
+
+       case constant.String:
+               i := constant.StringVal(u)
+               symdata := StringSym(n.Pos(), i)
+               s.WriteAddr(base.Ctxt, noff, types.PtrSize, symdata, 0)
+               s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
+
+       default:
+               base.Fatalf("InitConst unhandled OLITERAL %v", c)
+       }
+}

diff --git a/src/cmd/compile/internal/staticdata/embed.go b/src/cmd/compile/internal/staticdata/embed.go
new file mode 100644 (file)
index 0000000..8936c4f
--- /dev/null
+++ b/src/cmd/compile/internal/staticdata/embed.go
@@ -0,0 +1,181 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package staticdata
+
+import (
+       "path"
+       "sort"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+const (
+       embedUnknown = iota
+       embedBytes
+       embedString
+       embedFiles
+)
+
+func embedFileList(v *ir.Name, kind int) []string {
+       // Build list of files to store.
+       have := make(map[string]bool)
+       var list []string
+       for _, e := range *v.Embed {
+               for _, pattern := range e.Patterns {
+                       files, ok := base.Flag.Cfg.Embed.Patterns[pattern]
+                       if !ok {
+                               base.ErrorfAt(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
+                       }
+                       for _, file := range files {
+                               if base.Flag.Cfg.Embed.Files[file] == "" {
+                                       base.ErrorfAt(e.Pos, "invalid go:embed: build system did not map file: %s", file)
+                                       continue
+                               }
+                               if !have[file] {
+                                       have[file] = true
+                                       list = append(list, file)
+                               }
+                               if kind == embedFiles {
+                                       for dir := path.Dir(file); dir != "." && !have[dir]; dir = path.Dir(dir) {
+                                               have[dir] = true
+                                               list = append(list, dir+"/")
+                                       }
+                               }
+                       }
+               }
+       }
+       sort.Slice(list, func(i, j int) bool {
+               return embedFileLess(list[i], list[j])
+       })
+
+       if kind == embedString || kind == embedBytes {
+               if len(list) > 1 {
+                       base.ErrorfAt(v.Pos(), "invalid go:embed: multiple files for type %v", v.Type())
+                       return nil
+               }
+       }
+
+       return list
+}
+
+// embedKind determines the kind of embedding variable.
+func embedKind(typ *types.Type) int {
+       if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == types.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
+               return embedFiles
+       }
+       if typ.Kind() == types.TSTRING {
+               return embedString
+       }
+       if typ.Sym() == nil && typ.IsSlice() && typ.Elem().Kind() == types.TUINT8 {
+               return embedBytes
+       }
+       return embedUnknown
+}
+
+func embedFileNameSplit(name string) (dir, elem string, isDir bool) {
+       if name[len(name)-1] == '/' {
+               isDir = true
+               name = name[:len(name)-1]
+       }
+       i := len(name) - 1
+       for i >= 0 && name[i] != '/' {
+               i--
+       }
+       if i < 0 {
+               return ".", name, isDir
+       }
+       return name[:i], name[i+1:], isDir
+}
+
+// embedFileLess implements the sort order for a list of embedded files.
+// See the comment inside ../../../../embed/embed.go's Files struct for rationale.
+func embedFileLess(x, y string) bool {
+       xdir, xelem, _ := embedFileNameSplit(x)
+       ydir, yelem, _ := embedFileNameSplit(y)
+       return xdir < ydir || xdir == ydir && xelem < yelem
+}
+
+// WriteEmbed emits the init data for a //go:embed variable,
+// which is either a string, a []byte, or an embed.FS.
+func WriteEmbed(v *ir.Name) {
+       // TODO(mdempsky): User errors should be reported by the frontend.
+
+       commentPos := (*v.Embed)[0].Pos
+       if !types.AllowsGoVersion(types.LocalPkg, 1, 16) {
+               prevPos := base.Pos
+               base.Pos = commentPos
+               base.ErrorfVers("go1.16", "go:embed")
+               base.Pos = prevPos
+               return
+       }
+       if base.Flag.Cfg.Embed.Patterns == nil {
+               base.ErrorfAt(commentPos, "invalid go:embed: build system did not supply embed configuration")
+               return
+       }
+       kind := embedKind(v.Type())
+       if kind == embedUnknown {
+               base.ErrorfAt(v.Pos(), "go:embed cannot apply to var of type %v", v.Type())
+               return
+       }
+
+       files := embedFileList(v, kind)
+       switch kind {
+       case embedString, embedBytes:
+               file := files[0]
+               fsym, size, err := fileStringSym(v.Pos(), base.Flag.Cfg.Embed.Files[file], kind == embedString, nil)
+               if err != nil {
+                       base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
+               }
+               sym := v.Linksym()
+               off := 0
+               off = objw.SymPtr(sym, off, fsym, 0)       // data string
+               off = objw.Uintptr(sym, off, uint64(size)) // len
+               if kind == embedBytes {
+                       objw.Uintptr(sym, off, uint64(size)) // cap for slice
+               }
+
+       case embedFiles:
+               slicedata := base.Ctxt.Lookup(`"".` + v.Sym().Name + `.files`)
+               off := 0
+               // []files pointed at by Files
+               off = objw.SymPtr(slicedata, off, slicedata, 3*types.PtrSize) // []file, pointing just past slice
+               off = objw.Uintptr(slicedata, off, uint64(len(files)))
+               off = objw.Uintptr(slicedata, off, uint64(len(files)))
+
+               // embed/embed.go type file is:
+               //      name string
+               //      data string
+               //      hash [16]byte
+               // Emit one of these per file in the set.
+               const hashSize = 16
+               hash := make([]byte, hashSize)
+               for _, file := range files {
+                       off = objw.SymPtr(slicedata, off, StringSym(v.Pos(), file), 0) // file string
+                       off = objw.Uintptr(slicedata, off, uint64(len(file)))
+                       if strings.HasSuffix(file, "/") {
+                               // entry for directory - no data
+                               off = objw.Uintptr(slicedata, off, 0)
+                               off = objw.Uintptr(slicedata, off, 0)
+                               off += hashSize
+                       } else {
+                               fsym, size, err := fileStringSym(v.Pos(), base.Flag.Cfg.Embed.Files[file], true, hash)
+                               if err != nil {
+                                       base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
+                               }
+                               off = objw.SymPtr(slicedata, off, fsym, 0) // data string
+                               off = objw.Uintptr(slicedata, off, uint64(size))
+                               off = int(slicedata.WriteBytes(base.Ctxt, int64(off), hash))
+                       }
+               }
+               objw.Global(slicedata, int32(off), obj.RODATA|obj.LOCAL)
+               sym := v.Linksym()
+               objw.SymPtr(sym, 0, slicedata, 0)
+       }
+}

diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
new file mode 100644 (file)
index 0000000..f3ad82e
--- /dev/null
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -0,0 +1,610 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package staticinit
+
+import (
+       "fmt"
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+type Entry struct {
+       Xoffset int64   // struct, array only
+       Expr    ir.Node // bytes of run-time computed expressions
+}
+
+type Plan struct {
+       E []Entry
+}
+
+// An Schedule is used to decompose assignment statements into
+// static and dynamic initialization parts. Static initializations are
+// handled by populating variables' linker symbol data, while dynamic
+// initializations are accumulated to be executed in order.
+type Schedule struct {
+       // Out is the ordered list of dynamic initialization
+       // statements.
+       Out []ir.Node
+
+       Plans map[ir.Node]*Plan
+       Temps map[ir.Node]*ir.Name
+}
+
+func (s *Schedule) append(n ir.Node) {
+       s.Out = append(s.Out, n)
+}
+
+// StaticInit adds an initialization statement n to the schedule.
+func (s *Schedule) StaticInit(n ir.Node) {
+       if !s.tryStaticInit(n) {
+               if base.Flag.Percent != 0 {
+                       ir.Dump("nonstatic", n)
+               }
+               s.append(n)
+       }
+}
+
+// tryStaticInit attempts to statically execute an initialization
+// statement and reports whether it succeeded.
+func (s *Schedule) tryStaticInit(nn ir.Node) bool {
+       // Only worry about simple "l = r" assignments. Multiple
+       // variable/expression OAS2 assignments have already been
+       // replaced by multiple simple OAS assignments, and the other
+       // OAS2* assignments mostly necessitate dynamic execution
+       // anyway.
+       if nn.Op() != ir.OAS {
+               return false
+       }
+       n := nn.(*ir.AssignStmt)
+       if ir.IsBlank(n.X) && !AnySideEffects(n.Y) {
+               // Discard.
+               return true
+       }
+       lno := ir.SetPos(n)
+       defer func() { base.Pos = lno }()
+       nam := n.X.(*ir.Name)
+       return s.StaticAssign(nam, 0, n.Y, nam.Type())
+}
+
+// like staticassign but we are copying an already
+// initialized value r.
+func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
+       if rn.Class == ir.PFUNC {
+               // TODO if roff != 0 { panic }
+               staticdata.InitAddr(l, loff, staticdata.FuncLinksym(rn))
+               return true
+       }
+       if rn.Class != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
+               return false
+       }
+       if rn.Defn.Op() != ir.OAS {
+               return false
+       }
+       if rn.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
+               return false
+       }
+       if rn.Embed != nil {
+               return false
+       }
+       orig := rn
+       r := rn.Defn.(*ir.AssignStmt).Y
+       if r == nil {
+               // No explicit initialization value. Probably zeroed but perhaps
+               // supplied externally and of unknown value.
+               return false
+       }
+
+       for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
+               r = r.(*ir.ConvExpr).X
+       }
+
+       switch r.Op() {
+       case ir.OMETHEXPR:
+               r = r.(*ir.SelectorExpr).FuncName()
+               fallthrough
+       case ir.ONAME:
+               r := r.(*ir.Name)
+               if s.staticcopy(l, loff, r, typ) {
+                       return true
+               }
+               // We may have skipped past one or more OCONVNOPs, so
+               // use conv to ensure r is assignable to l (#13263).
+               dst := ir.Node(l)
+               if loff != 0 || !types.Identical(typ, l.Type()) {
+                       dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
+               }
+               s.append(ir.NewAssignStmt(base.Pos, dst, typecheck.Conv(r, typ)))
+               return true
+
+       case ir.ONIL:
+               return true
+
+       case ir.OLITERAL:
+               if ir.IsZero(r) {
+                       return true
+               }
+               staticdata.InitConst(l, loff, r, int(typ.Width))
+               return true
+
+       case ir.OADDR:
+               r := r.(*ir.AddrExpr)
+               if a, ok := r.X.(*ir.Name); ok && a.Op() == ir.ONAME {
+                       staticdata.InitAddr(l, loff, staticdata.GlobalLinksym(a))
+                       return true
+               }
+
+       case ir.OPTRLIT:
+               r := r.(*ir.AddrExpr)
+               switch r.X.Op() {
+               case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
+                       // copy pointer
+                       staticdata.InitAddr(l, loff, staticdata.GlobalLinksym(s.Temps[r]))
+                       return true
+               }
+
+       case ir.OSLICELIT:
+               r := r.(*ir.CompLitExpr)
+               // copy slice
+               staticdata.InitSlice(l, loff, staticdata.GlobalLinksym(s.Temps[r]), r.Len)
+               return true
+
+       case ir.OARRAYLIT, ir.OSTRUCTLIT:
+               r := r.(*ir.CompLitExpr)
+               p := s.Plans[r]
+               for i := range p.E {
+                       e := &p.E[i]
+                       typ := e.Expr.Type()
+                       if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+                               staticdata.InitConst(l, loff+e.Xoffset, e.Expr, int(typ.Width))
+                               continue
+                       }
+                       x := e.Expr
+                       if x.Op() == ir.OMETHEXPR {
+                               x = x.(*ir.SelectorExpr).FuncName()
+                       }
+                       if x.Op() == ir.ONAME && s.staticcopy(l, loff+e.Xoffset, x.(*ir.Name), typ) {
+                               continue
+                       }
+                       // Requires computation, but we're
+                       // copying someone else's computation.
+                       ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
+                       rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
+                       ir.SetPos(rr)
+                       s.append(ir.NewAssignStmt(base.Pos, ll, rr))
+               }
+
+               return true
+       }
+
+       return false
+}
+
+func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
+       if r == nil {
+               // No explicit initialization value. Either zero or supplied
+               // externally.
+               return true
+       }
+       for r.Op() == ir.OCONVNOP {
+               r = r.(*ir.ConvExpr).X
+       }
+
+       assign := func(pos src.XPos, a *ir.Name, aoff int64, v ir.Node) {
+               if s.StaticAssign(a, aoff, v, v.Type()) {
+                       return
+               }
+               var lhs ir.Node
+               if ir.IsBlank(a) {
+                       // Don't use NameOffsetExpr with blank (#43677).
+                       lhs = ir.BlankNode
+               } else {
+                       lhs = ir.NewNameOffsetExpr(pos, a, aoff, v.Type())
+               }
+               s.append(ir.NewAssignStmt(pos, lhs, v))
+       }
+
+       switch r.Op() {
+       case ir.ONAME:
+               r := r.(*ir.Name)
+               return s.staticcopy(l, loff, r, typ)
+
+       case ir.OMETHEXPR:
+               r := r.(*ir.SelectorExpr)
+               return s.staticcopy(l, loff, r.FuncName(), typ)
+
+       case ir.ONIL:
+               return true
+
+       case ir.OLITERAL:
+               if ir.IsZero(r) {
+                       return true
+               }
+               staticdata.InitConst(l, loff, r, int(typ.Width))
+               return true
+
+       case ir.OADDR:
+               r := r.(*ir.AddrExpr)
+               if name, offset, ok := StaticLoc(r.X); ok && name.Class == ir.PEXTERN {
+                       staticdata.InitAddrOffset(l, loff, name.Linksym(), offset)
+                       return true
+               }
+               fallthrough
+
+       case ir.OPTRLIT:
+               r := r.(*ir.AddrExpr)
+               switch r.X.Op() {
+               case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
+                       // Init pointer.
+                       a := StaticName(r.X.Type())
+
+                       s.Temps[r] = a
+                       staticdata.InitAddr(l, loff, a.Linksym())
+
+                       // Init underlying literal.
+                       assign(base.Pos, a, 0, r.X)
+                       return true
+               }
+               //dump("not static ptrlit", r);
+
+       case ir.OSTR2BYTES:
+               r := r.(*ir.ConvExpr)
+               if l.Class == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
+                       sval := ir.StringVal(r.X)
+                       staticdata.InitSliceBytes(l, loff, sval)
+                       return true
+               }
+
+       case ir.OSLICELIT:
+               r := r.(*ir.CompLitExpr)
+               s.initplan(r)
+               // Init slice.
+               ta := types.NewArray(r.Type().Elem(), r.Len)
+               ta.SetNoalg(true)
+               a := StaticName(ta)
+               s.Temps[r] = a
+               staticdata.InitSlice(l, loff, a.Linksym(), r.Len)
+               // Fall through to init underlying array.
+               l = a
+               loff = 0
+               fallthrough
+
+       case ir.OARRAYLIT, ir.OSTRUCTLIT:
+               r := r.(*ir.CompLitExpr)
+               s.initplan(r)
+
+               p := s.Plans[r]
+               for i := range p.E {
+                       e := &p.E[i]
+                       if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+                               staticdata.InitConst(l, loff+e.Xoffset, e.Expr, int(e.Expr.Type().Width))
+                               continue
+                       }
+                       ir.SetPos(e.Expr)
+                       assign(base.Pos, l, loff+e.Xoffset, e.Expr)
+               }
+
+               return true
+
+       case ir.OMAPLIT:
+               break
+
+       case ir.OCLOSURE:
+               r := r.(*ir.ClosureExpr)
+               if ir.IsTrivialClosure(r) {
+                       if base.Debug.Closure > 0 {
+                               base.WarnfAt(r.Pos(), "closure converted to global")
+                       }
+                       // Closures with no captured variables are globals,
+                       // so the assignment can be done at link time.
+                       // TODO if roff != 0 { panic }
+                       staticdata.InitAddr(l, loff, staticdata.FuncLinksym(r.Func.Nname))
+                       return true
+               }
+               ir.ClosureDebugRuntimeCheck(r)
+
+       case ir.OCONVIFACE:
+               // This logic is mirrored in isStaticCompositeLiteral.
+               // If you change something here, change it there, and vice versa.
+
+               // Determine the underlying concrete type and value we are converting from.
+               r := r.(*ir.ConvExpr)
+               val := ir.Node(r)
+               for val.Op() == ir.OCONVIFACE {
+                       val = val.(*ir.ConvExpr).X
+               }
+
+               if val.Type().IsInterface() {
+                       // val is an interface type.
+                       // If val is nil, we can statically initialize l;
+                       // both words are zero and so there no work to do, so report success.
+                       // If val is non-nil, we have no concrete type to record,
+                       // and we won't be able to statically initialize its value, so report failure.
+                       return val.Op() == ir.ONIL
+               }
+
+               reflectdata.MarkTypeUsedInInterface(val.Type(), l.Linksym())
+
+               var itab *ir.AddrExpr
+               if typ.IsEmptyInterface() {
+                       itab = reflectdata.TypePtr(val.Type())
+               } else {
+                       itab = reflectdata.ITabAddr(val.Type(), typ)
+               }
+
+               // Create a copy of l to modify while we emit data.
+
+               // Emit itab, advance offset.
+               staticdata.InitAddr(l, loff, itab.X.(*ir.LinksymOffsetExpr).Linksym)
+
+               // Emit data.
+               if types.IsDirectIface(val.Type()) {
+                       if val.Op() == ir.ONIL {
+                               // Nil is zero, nothing to do.
+                               return true
+                       }
+                       // Copy val directly into n.
+                       ir.SetPos(val)
+                       assign(base.Pos, l, loff+int64(types.PtrSize), val)
+               } else {
+                       // Construct temp to hold val, write pointer to temp into n.
+                       a := StaticName(val.Type())
+                       s.Temps[val] = a
+                       assign(base.Pos, a, 0, val)
+                       staticdata.InitAddr(l, loff+int64(types.PtrSize), a.Linksym())
+               }
+
+               return true
+       }
+
+       //dump("not static", r);
+       return false
+}
+
+func (s *Schedule) initplan(n ir.Node) {
+       if s.Plans[n] != nil {
+               return
+       }
+       p := new(Plan)
+       s.Plans[n] = p
+       switch n.Op() {
+       default:
+               base.Fatalf("initplan")
+
+       case ir.OARRAYLIT, ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               var k int64
+               for _, a := range n.List {
+                       if a.Op() == ir.OKEY {
+                               kv := a.(*ir.KeyExpr)
+                               k = typecheck.IndexConst(kv.Key)
+                               if k < 0 {
+                                       base.Fatalf("initplan arraylit: invalid index %v", kv.Key)
+                               }
+                               a = kv.Value
+                       }
+                       s.addvalue(p, k*n.Type().Elem().Width, a)
+                       k++
+               }
+
+       case ir.OSTRUCTLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, a := range n.List {
+                       if a.Op() != ir.OSTRUCTKEY {
+                               base.Fatalf("initplan structlit")
+                       }
+                       a := a.(*ir.StructKeyExpr)
+                       if a.Field.IsBlank() {
+                               continue
+                       }
+                       s.addvalue(p, a.Offset, a.Value)
+               }
+
+       case ir.OMAPLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, a := range n.List {
+                       if a.Op() != ir.OKEY {
+                               base.Fatalf("initplan maplit")
+                       }
+                       a := a.(*ir.KeyExpr)
+                       s.addvalue(p, -1, a.Value)
+               }
+       }
+}
+
+func (s *Schedule) addvalue(p *Plan, xoffset int64, n ir.Node) {
+       // special case: zero can be dropped entirely
+       if ir.IsZero(n) {
+               return
+       }
+
+       // special case: inline struct and array (not slice) literals
+       if isvaluelit(n) {
+               s.initplan(n)
+               q := s.Plans[n]
+               for _, qe := range q.E {
+                       // qe is a copy; we are not modifying entries in q.E
+                       qe.Xoffset += xoffset
+                       p.E = append(p.E, qe)
+               }
+               return
+       }
+
+       // add to plan
+       p.E = append(p.E, Entry{Xoffset: xoffset, Expr: n})
+}
+
+// from here down is the walk analysis
+// of composite literals.
+// most of the work is to generate
+// data statements for the constant
+// part of the composite literal.
+
+var statuniqgen int // name generator for static temps
+
+// StaticName returns a name backed by a (writable) static data symbol.
+// Use readonlystaticname for read-only node.
+func StaticName(t *types.Type) *ir.Name {
+       // Don't use LookupNum; it interns the resulting string, but these are all unique.
+       n := typecheck.NewName(typecheck.Lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
+       statuniqgen++
+       typecheck.Declare(n, ir.PEXTERN)
+       n.SetType(t)
+       n.Linksym().Set(obj.AttrLocal, true)
+       return n
+}
+
+// StaticLoc returns the static address of n, if n has one, or else nil.
+func StaticLoc(n ir.Node) (name *ir.Name, offset int64, ok bool) {
+       if n == nil {
+               return nil, 0, false
+       }
+
+       switch n.Op() {
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               return n, 0, true
+
+       case ir.OMETHEXPR:
+               n := n.(*ir.SelectorExpr)
+               return StaticLoc(n.FuncName())
+
+       case ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               if name, offset, ok = StaticLoc(n.X); !ok {
+                       break
+               }
+               offset += n.Offset()
+               return name, offset, true
+
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               if n.X.Type().IsSlice() {
+                       break
+               }
+               if name, offset, ok = StaticLoc(n.X); !ok {
+                       break
+               }
+               l := getlit(n.Index)
+               if l < 0 {
+                       break
+               }
+
+               // Check for overflow.
+               if n.Type().Width != 0 && types.MaxWidth/n.Type().Width <= int64(l) {
+                       break
+               }
+               offset += int64(l) * n.Type().Width
+               return name, offset, true
+       }
+
+       return nil, 0, false
+}
+
+// AnySideEffects reports whether n contains any operations that could have observable side effects.
+func AnySideEffects(n ir.Node) bool {
+       return ir.Any(n, func(n ir.Node) bool {
+               switch n.Op() {
+               // Assume side effects unless we know otherwise.
+               default:
+                       return true
+
+               // No side effects here (arguments are checked separately).
+               case ir.ONAME,
+                       ir.ONONAME,
+                       ir.OTYPE,
+                       ir.OPACK,
+                       ir.OLITERAL,
+                       ir.ONIL,
+                       ir.OADD,
+                       ir.OSUB,
+                       ir.OOR,
+                       ir.OXOR,
+                       ir.OADDSTR,
+                       ir.OADDR,
+                       ir.OANDAND,
+                       ir.OBYTES2STR,
+                       ir.ORUNES2STR,
+                       ir.OSTR2BYTES,
+                       ir.OSTR2RUNES,
+                       ir.OCAP,
+                       ir.OCOMPLIT,
+                       ir.OMAPLIT,
+                       ir.OSTRUCTLIT,
+                       ir.OARRAYLIT,
+                       ir.OSLICELIT,
+                       ir.OPTRLIT,
+                       ir.OCONV,
+                       ir.OCONVIFACE,
+                       ir.OCONVNOP,
+                       ir.ODOT,
+                       ir.OEQ,
+                       ir.ONE,
+                       ir.OLT,
+                       ir.OLE,
+                       ir.OGT,
+                       ir.OGE,
+                       ir.OKEY,
+                       ir.OSTRUCTKEY,
+                       ir.OLEN,
+                       ir.OMUL,
+                       ir.OLSH,
+                       ir.ORSH,
+                       ir.OAND,
+                       ir.OANDNOT,
+                       ir.ONEW,
+                       ir.ONOT,
+                       ir.OBITNOT,
+                       ir.OPLUS,
+                       ir.ONEG,
+                       ir.OOROR,
+                       ir.OPAREN,
+                       ir.ORUNESTR,
+                       ir.OREAL,
+                       ir.OIMAG,
+                       ir.OCOMPLEX:
+                       return false
+
+               // Only possible side effect is division by zero.
+               case ir.ODIV, ir.OMOD:
+                       n := n.(*ir.BinaryExpr)
+                       if n.Y.Op() != ir.OLITERAL || constant.Sign(n.Y.Val()) == 0 {
+                               return true
+                       }
+
+               // Only possible side effect is panic on invalid size,
+               // but many makechan and makemap use size zero, which is definitely OK.
+               case ir.OMAKECHAN, ir.OMAKEMAP:
+                       n := n.(*ir.MakeExpr)
+                       if !ir.IsConst(n.Len, constant.Int) || constant.Sign(n.Len.Val()) != 0 {
+                               return true
+                       }
+
+               // Only possible side effect is panic on invalid size.
+               // TODO(rsc): Merge with previous case (probably breaks toolstash -cmp).
+               case ir.OMAKESLICE, ir.OMAKESLICECOPY:
+                       return true
+               }
+               return false
+       })
+}
+
+func getlit(lit ir.Node) int {
+       if ir.IsSmallIntConst(lit) {
+               return int(ir.Int64Val(lit))
+       }
+       return -1
+}
+
+func isvaluelit(n ir.Node) bool {
+       return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
+}

diff --git a/src/cmd/compile/internal/syntax/dumper_test.go b/src/cmd/compile/internal/syntax/dumper_test.go
index f84bd2d7056f03f6456017fed65a65793cc809ad..22680dce786c52214dce93b05b579cecc8f89b51 100644 (file)
--- a/src/cmd/compile/internal/syntax/dumper_test.go
+++ b/src/cmd/compile/internal/syntax/dumper_test.go
@@ -13,7 +13,7 @@ func TestDump(t *testing.T) {
                t.Skip("skipping test in short mode")
        }
 
-       // provide a dummy error handler so parsing doesn't stop after first error
+       // provide a no-op error handler so parsing doesn't stop after first error
        ast, err := ParseFile(*src_, func(error) {}, nil, CheckBranches)
        if err != nil {
                t.Error(err)

diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index 815630fcd412edbc2344c4ef468a188a851bb816..487cab19fef9cd6afc5efd50fe4c4de72781d0b0 100644 (file)
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -114,7 +114,7 @@ func (*decl) aDecl() {}
 
 // All declarations belonging to the same group point to the same Group node.
 type Group struct {
-       dummy int // not empty so we are guaranteed different Group instances
+       _ int // not empty so we are guaranteed different Group instances
 }
 
 // ----------------------------------------------------------------------------

diff --git a/src/cmd/compile/internal/syntax/operator_string.go b/src/cmd/compile/internal/syntax/operator_string.go
index 3c759b2e9befb74399a2bfdfdabd3457ac087c15..a7cd40fb13518658f8bad10c749c497fa131d63f 100644 (file)
--- a/src/cmd/compile/internal/syntax/operator_string.go
+++ b/src/cmd/compile/internal/syntax/operator_string.go
@@ -1,9 +1,37 @@
-// Code generated by "stringer -type Operator -linecomment"; DO NOT EDIT.
+// Code generated by "stringer -type Operator -linecomment tokens.go"; DO NOT EDIT.
 
 package syntax
 
 import "strconv"
 
+func _() {
+       // An "invalid array index" compiler error signifies that the constant values have changed.
+       // Re-run the stringer command to generate them again.
+       var x [1]struct{}
+       _ = x[Def-1]
+       _ = x[Not-2]
+       _ = x[Recv-3]
+       _ = x[OrOr-4]
+       _ = x[AndAnd-5]
+       _ = x[Eql-6]
+       _ = x[Neq-7]
+       _ = x[Lss-8]
+       _ = x[Leq-9]
+       _ = x[Gtr-10]
+       _ = x[Geq-11]
+       _ = x[Add-12]
+       _ = x[Sub-13]
+       _ = x[Or-14]
+       _ = x[Xor-15]
+       _ = x[Mul-16]
+       _ = x[Div-17]
+       _ = x[Rem-18]
+       _ = x[And-19]
+       _ = x[AndNot-20]
+       _ = x[Shl-21]
+       _ = x[Shr-22]
+}
+
 const _Operator_name = ":!<-||&&==!=<<=>>=+-|^*/%&&^<<>>"
 
 var _Operator_index = [...]uint8{0, 1, 2, 4, 6, 8, 10, 12, 13, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 32}

diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index c3b9aca229c3358a69ef17b7b72b3fbf8458fb87..fe72e7a374fb8dc8701de5093b0a58d0e4ffb3d1 100644 (file)
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -18,7 +18,7 @@ func TestPrint(t *testing.T) {
                t.Skip("skipping test in short mode")
        }
 
-       // provide a dummy error handler so parsing doesn't stop after first error
+       // provide a no-op error handler so parsing doesn't stop after first error
        ast, err := ParseFile(*src_, func(error) {}, nil, 0)
        if err != nil {
                t.Error(err)

diff --git a/src/cmd/compile/internal/syntax/token_string.go b/src/cmd/compile/internal/syntax/token_string.go
index 3cf5473febfd0d495763549ee6a9e7d7f12e53c9..ef295eb24b2bc9acb4b0d44ca9893f3bcb5067c2 100644 (file)
--- a/src/cmd/compile/internal/syntax/token_string.go
+++ b/src/cmd/compile/internal/syntax/token_string.go
@@ -1,9 +1,62 @@
-// Code generated by "stringer -type token -linecomment"; DO NOT EDIT.
+// Code generated by "stringer -type token -linecomment tokens.go"; DO NOT EDIT.
 
 package syntax
 
 import "strconv"
 
+func _() {
+       // An "invalid array index" compiler error signifies that the constant values have changed.
+       // Re-run the stringer command to generate them again.
+       var x [1]struct{}
+       _ = x[_EOF-1]
+       _ = x[_Name-2]
+       _ = x[_Literal-3]
+       _ = x[_Operator-4]
+       _ = x[_AssignOp-5]
+       _ = x[_IncOp-6]
+       _ = x[_Assign-7]
+       _ = x[_Define-8]
+       _ = x[_Arrow-9]
+       _ = x[_Star-10]
+       _ = x[_Lparen-11]
+       _ = x[_Lbrack-12]
+       _ = x[_Lbrace-13]
+       _ = x[_Rparen-14]
+       _ = x[_Rbrack-15]
+       _ = x[_Rbrace-16]
+       _ = x[_Comma-17]
+       _ = x[_Semi-18]
+       _ = x[_Colon-19]
+       _ = x[_Dot-20]
+       _ = x[_DotDotDot-21]
+       _ = x[_Break-22]
+       _ = x[_Case-23]
+       _ = x[_Chan-24]
+       _ = x[_Const-25]
+       _ = x[_Continue-26]
+       _ = x[_Default-27]
+       _ = x[_Defer-28]
+       _ = x[_Else-29]
+       _ = x[_Fallthrough-30]
+       _ = x[_For-31]
+       _ = x[_Func-32]
+       _ = x[_Go-33]
+       _ = x[_Goto-34]
+       _ = x[_If-35]
+       _ = x[_Import-36]
+       _ = x[_Interface-37]
+       _ = x[_Map-38]
+       _ = x[_Package-39]
+       _ = x[_Range-40]
+       _ = x[_Return-41]
+       _ = x[_Select-42]
+       _ = x[_Struct-43]
+       _ = x[_Switch-44]
+       _ = x[_Type-45]
+       _ = x[_Var-46]
+       _ = x[tokenCount-47]
+}
+
 const _token_name = "EOFnameliteralopop=opop=:=<-*([{)]},;:....breakcasechanconstcontinuedefaultdeferelsefallthroughforfuncgogotoifimportinterfacemappackagerangereturnselectstructswitchtypevar"
 
 var _token_index = [...]uint8{0, 3, 7, 14, 16, 19, 23, 24, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 42, 47, 51, 55, 60, 68, 75, 80, 84, 95, 98, 102, 104, 108, 110, 116, 125, 128, 135, 140, 146, 152, 158, 164, 168, 171, 171}

diff --git a/src/cmd/compile/internal/syntax/tokens.go b/src/cmd/compile/internal/syntax/tokens.go
index 3b97cb66f24b976f8e6b99bbc64cc45c982f55b2..2936b6576bc7ae9517a7d1f0ff92ce20366c9a68 100644 (file)
--- a/src/cmd/compile/internal/syntax/tokens.go
+++ b/src/cmd/compile/internal/syntax/tokens.go
@@ -6,7 +6,7 @@ package syntax
 
 type token uint
 
-//go:generate stringer -type token -linecomment
+//go:generate stringer -type token -linecomment tokens.go
 
 const (
        _    token = iota
@@ -105,7 +105,7 @@ const (
 
 type Operator uint
 
-//go:generate stringer -type Operator -linecomment
+//go:generate stringer -type Operator -linecomment tokens.go
 
 const (
        _ Operator = iota

diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
new file mode 100644 (file)
index 0000000..a0a1167
--- /dev/null
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -0,0 +1,295 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package test
+
+import (
+       "bufio"
+       "cmd/compile/internal/abi"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/obj/x86"
+       "cmd/internal/src"
+       "os"
+       "testing"
+)
+
+// AMD64 registers available:
+// - integer: RAX, RBX, RCX, RDI, RSI, R8, R9, r10, R11
+// - floating point: X0 - X14
+var configAMD64 = abi.NewABIConfig(9, 15)
+
+func TestMain(m *testing.M) {
+       ssagen.Arch.LinkArch = &x86.Linkamd64
+       ssagen.Arch.REGSP = x86.REGSP
+       ssagen.Arch.MAXWIDTH = 1 << 50
+       types.MaxWidth = ssagen.Arch.MAXWIDTH
+       base.Ctxt = obj.Linknew(ssagen.Arch.LinkArch)
+       base.Ctxt.DiagFunc = base.Errorf
+       base.Ctxt.DiagFlush = base.FlushErrors
+       base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
+       types.PtrSize = ssagen.Arch.LinkArch.PtrSize
+       types.RegSize = ssagen.Arch.LinkArch.RegSize
+       typecheck.InitUniverse()
+       os.Exit(m.Run())
+}
+
+func TestABIUtilsBasic1(t *testing.T) {
+
+       // func(x int32) int32
+       i32 := types.Types[types.TINT32]
+       ft := mkFuncType(nil, []*types.Type{i32}, []*types.Type{i32})
+
+       // expected results
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: int32
+        OUT 0: R{ I0 } spilloffset: -1 typ: int32
+        offsetToSpillArea: 0 spillAreaSize: 8
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsBasic2(t *testing.T) {
+       // func(x int32, y float64) (int32, float64, float64)
+       i8 := types.Types[types.TINT8]
+       i16 := types.Types[types.TINT16]
+       i32 := types.Types[types.TINT32]
+       i64 := types.Types[types.TINT64]
+       f32 := types.Types[types.TFLOAT32]
+       f64 := types.Types[types.TFLOAT64]
+       c64 := types.Types[types.TCOMPLEX64]
+       c128 := types.Types[types.TCOMPLEX128]
+       ft := mkFuncType(nil,
+               []*types.Type{
+                       i8, i16, i32, i64,
+                       f32, f32, f64, f64,
+                       i8, i16, i32, i64,
+                       f32, f32, f64, f64,
+                       c128, c128, c128, c128, c64,
+                       i8, i16, i32, i64,
+                       i8, i16, i32, i64},
+               []*types.Type{i32, f64, f64})
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: int8
+        IN 1: R{ I1 } spilloffset: 2 typ: int16
+        IN 2: R{ I2 } spilloffset: 4 typ: int32
+        IN 3: R{ I3 } spilloffset: 8 typ: int64
+        IN 4: R{ F0 } spilloffset: 16 typ: float32
+        IN 5: R{ F1 } spilloffset: 20 typ: float32
+        IN 6: R{ F2 } spilloffset: 24 typ: float64
+        IN 7: R{ F3 } spilloffset: 32 typ: float64
+        IN 8: R{ I4 } spilloffset: 40 typ: int8
+        IN 9: R{ I5 } spilloffset: 42 typ: int16
+        IN 10: R{ I6 } spilloffset: 44 typ: int32
+        IN 11: R{ I7 } spilloffset: 48 typ: int64
+        IN 12: R{ F4 } spilloffset: 56 typ: float32
+        IN 13: R{ F5 } spilloffset: 60 typ: float32
+        IN 14: R{ F6 } spilloffset: 64 typ: float64
+        IN 15: R{ F7 } spilloffset: 72 typ: float64
+        IN 16: R{ F8 F9 } spilloffset: 80 typ: complex128
+        IN 17: R{ F10 F11 } spilloffset: 96 typ: complex128
+        IN 18: R{ F12 F13 } spilloffset: 112 typ: complex128
+        IN 19: R{ } offset: 0 typ: complex128
+        IN 20: R{ } offset: 16 typ: complex64
+        IN 21: R{ I8 } spilloffset: 128 typ: int8
+        IN 22: R{ } offset: 24 typ: int16
+        IN 23: R{ } offset: 28 typ: int32
+        IN 24: R{ } offset: 32 typ: int64
+        IN 25: R{ } offset: 40 typ: int8
+        IN 26: R{ } offset: 42 typ: int16
+        IN 27: R{ } offset: 44 typ: int32
+        IN 28: R{ } offset: 48 typ: int64
+        OUT 0: R{ I0 } spilloffset: -1 typ: int32
+        OUT 1: R{ F0 } spilloffset: -1 typ: float64
+        OUT 2: R{ F1 } spilloffset: -1 typ: float64
+        offsetToSpillArea: 56 spillAreaSize: 136
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsArrays(t *testing.T) {
+       i32 := types.Types[types.TINT32]
+       ae := types.NewArray(i32, 0)
+       a1 := types.NewArray(i32, 1)
+       a2 := types.NewArray(i32, 2)
+       aa1 := types.NewArray(a1, 1)
+       ft := mkFuncType(nil, []*types.Type{a1, ae, aa1, a2},
+               []*types.Type{a2, a1, ae, aa1})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: [1]int32
+        IN 1: R{ } offset: 0 typ: [0]int32
+        IN 2: R{ I1 } spilloffset: 4 typ: [1][1]int32
+        IN 3: R{ } offset: 0 typ: [2]int32
+        OUT 0: R{ } offset: 8 typ: [2]int32
+        OUT 1: R{ I0 } spilloffset: -1 typ: [1]int32
+        OUT 2: R{ } offset: 16 typ: [0]int32
+        OUT 3: R{ I1 } spilloffset: -1 typ: [1][1]int32
+        offsetToSpillArea: 16 spillAreaSize: 8
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsStruct1(t *testing.T) {
+       i8 := types.Types[types.TINT8]
+       i16 := types.Types[types.TINT16]
+       i32 := types.Types[types.TINT32]
+       i64 := types.Types[types.TINT64]
+       s := mkstruct([]*types.Type{i8, i8, mkstruct([]*types.Type{}), i8, i16})
+       ft := mkFuncType(nil, []*types.Type{i8, s, i64},
+               []*types.Type{s, i8, i32})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: int8
+        IN 1: R{ I1 I2 I3 I4 } spilloffset: 2 typ: struct { int8; int8; struct {}; int8; int16 }
+        IN 2: R{ I5 } spilloffset: 8 typ: int64
+        OUT 0: R{ I0 I1 I2 I3 } spilloffset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
+        OUT 1: R{ I4 } spilloffset: -1 typ: int8
+        OUT 2: R{ I5 } spilloffset: -1 typ: int32
+        offsetToSpillArea: 0 spillAreaSize: 16
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsStruct2(t *testing.T) {
+       f64 := types.Types[types.TFLOAT64]
+       i64 := types.Types[types.TINT64]
+       s := mkstruct([]*types.Type{i64, mkstruct([]*types.Type{})})
+       fs := mkstruct([]*types.Type{f64, s, mkstruct([]*types.Type{})})
+       ft := mkFuncType(nil, []*types.Type{s, s, fs},
+               []*types.Type{fs, fs})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: struct { int64; struct {} }
+        IN 1: R{ I1 } spilloffset: 16 typ: struct { int64; struct {} }
+        IN 2: R{ I2 F0 } spilloffset: 32 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 0: R{ I0 F0 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 1: R{ I1 F1 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        offsetToSpillArea: 0 spillAreaSize: 64
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsSliceString(t *testing.T) {
+       i32 := types.Types[types.TINT32]
+       sli32 := types.NewSlice(i32)
+       str := types.New(types.TSTRING)
+       i8 := types.Types[types.TINT8]
+       i64 := types.Types[types.TINT64]
+       ft := mkFuncType(nil, []*types.Type{sli32, i8, sli32, i8, str, i8, i64, sli32},
+               []*types.Type{str, i64, str, sli32})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: []int32
+        IN 1: R{ I3 } spilloffset: 24 typ: int8
+        IN 2: R{ I4 I5 I6 } spilloffset: 32 typ: []int32
+        IN 3: R{ I7 } spilloffset: 56 typ: int8
+        IN 4: R{ } offset: 0 typ: string
+        IN 5: R{ I8 } spilloffset: 57 typ: int8
+        IN 6: R{ } offset: 16 typ: int64
+        IN 7: R{ } offset: 24 typ: []int32
+        OUT 0: R{ I0 I1 } spilloffset: -1 typ: string
+        OUT 1: R{ I2 } spilloffset: -1 typ: int64
+        OUT 2: R{ I3 I4 } spilloffset: -1 typ: string
+        OUT 3: R{ I5 I6 I7 } spilloffset: -1 typ: []int32
+        offsetToSpillArea: 48 spillAreaSize: 64
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsMethod(t *testing.T) {
+       i16 := types.Types[types.TINT16]
+       i64 := types.Types[types.TINT64]
+       f64 := types.Types[types.TFLOAT64]
+
+       s1 := mkstruct([]*types.Type{i16, i16, i16})
+       ps1 := types.NewPtr(s1)
+       a7 := types.NewArray(ps1, 7)
+       ft := mkFuncType(s1, []*types.Type{ps1, a7, f64, i16, i16, i16},
+               []*types.Type{a7, f64, i64})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: struct { int16; int16; int16 }
+        IN 1: R{ I3 } spilloffset: 8 typ: *struct { int16; int16; int16 }
+        IN 2: R{ } offset: 0 typ: [7]*struct { int16; int16; int16 }
+        IN 3: R{ F0 } spilloffset: 16 typ: float64
+        IN 4: R{ I4 } spilloffset: 24 typ: int16
+        IN 5: R{ I5 } spilloffset: 26 typ: int16
+        IN 6: R{ I6 } spilloffset: 28 typ: int16
+        OUT 0: R{ } offset: 56 typ: [7]*struct { int16; int16; int16 }
+        OUT 1: R{ F0 } spilloffset: -1 typ: float64
+        OUT 2: R{ I0 } spilloffset: -1 typ: int64
+        offsetToSpillArea: 112 spillAreaSize: 32
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABIUtilsInterfaces(t *testing.T) {
+       ei := types.Types[types.TINTER] // interface{}
+       pei := types.NewPtr(ei)         // *interface{}
+       fldt := mkFuncType(types.FakeRecvType(), []*types.Type{},
+               []*types.Type{types.UntypedString})
+       field := types.NewField(src.NoXPos, nil, fldt)
+       // interface{ ...() string }
+       nei := types.NewInterface(types.LocalPkg, []*types.Field{field})
+
+       i16 := types.Types[types.TINT16]
+       tb := types.Types[types.TBOOL]
+       s1 := mkstruct([]*types.Type{i16, i16, tb})
+
+       ft := mkFuncType(nil, []*types.Type{s1, ei, ei, nei, pei, nei, i16},
+               []*types.Type{ei, nei, pei})
+
+       exp := makeExpectedDump(`
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: struct { int16; int16; bool }
+        IN 1: R{ I3 I4 } spilloffset: 8 typ: interface {}
+        IN 2: R{ I5 I6 } spilloffset: 24 typ: interface {}
+        IN 3: R{ I7 I8 } spilloffset: 40 typ: interface { () untyped string }
+        IN 4: R{ } offset: 0 typ: *interface {}
+        IN 5: R{ } offset: 8 typ: interface { () untyped string }
+        IN 6: R{ } offset: 24 typ: int16
+        OUT 0: R{ I0 I1 } spilloffset: -1 typ: interface {}
+        OUT 1: R{ I2 I3 } spilloffset: -1 typ: interface { () untyped string }
+        OUT 2: R{ I4 } spilloffset: -1 typ: *interface {}
+        offsetToSpillArea: 32 spillAreaSize: 56
+`)
+
+       abitest(t, ft, exp)
+}
+
+func TestABINumParamRegs(t *testing.T) {
+       i8 := types.Types[types.TINT8]
+       i16 := types.Types[types.TINT16]
+       i32 := types.Types[types.TINT32]
+       i64 := types.Types[types.TINT64]
+       f32 := types.Types[types.TFLOAT32]
+       f64 := types.Types[types.TFLOAT64]
+       c64 := types.Types[types.TCOMPLEX64]
+       c128 := types.Types[types.TCOMPLEX128]
+
+       s := mkstruct([]*types.Type{i8, i8, mkstruct([]*types.Type{}), i8, i16})
+       a := types.NewArray(s, 3)
+
+       nrtest(t, i8, 1)
+       nrtest(t, i16, 1)
+       nrtest(t, i32, 1)
+       nrtest(t, i64, 1)
+       nrtest(t, f32, 1)
+       nrtest(t, f64, 1)
+       nrtest(t, c64, 2)
+       nrtest(t, c128, 2)
+       nrtest(t, s, 4)
+       nrtest(t, a, 12)
+
+}

diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
new file mode 100644 (file)
index 0000000..19dd3a5
--- /dev/null
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -0,0 +1,164 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package test
+
+// This file contains utility routines and harness infrastructure used
+// by the ABI tests in "abiutils_test.go".
+
+import (
+       "cmd/compile/internal/abi"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+       "fmt"
+       "strings"
+       "testing"
+       "text/scanner"
+)
+
+func mkParamResultField(t *types.Type, s *types.Sym, which ir.Class) *types.Field {
+       field := types.NewField(src.NoXPos, s, t)
+       n := typecheck.NewName(s)
+       n.Class = which
+       field.Nname = n
+       n.SetType(t)
+       return field
+}
+
+// mkstruct is a helper routine to create a struct type with fields
+// of the types specified in 'fieldtypes'.
+func mkstruct(fieldtypes []*types.Type) *types.Type {
+       fields := make([]*types.Field, len(fieldtypes))
+       for k, t := range fieldtypes {
+               if t == nil {
+                       panic("bad -- field has no type")
+               }
+               f := types.NewField(src.NoXPos, nil, t)
+               fields[k] = f
+       }
+       s := types.NewStruct(types.LocalPkg, fields)
+       return s
+}
+
+func mkFuncType(rcvr *types.Type, ins []*types.Type, outs []*types.Type) *types.Type {
+       q := typecheck.Lookup("?")
+       inf := []*types.Field{}
+       for _, it := range ins {
+               inf = append(inf, mkParamResultField(it, q, ir.PPARAM))
+       }
+       outf := []*types.Field{}
+       for _, ot := range outs {
+               outf = append(outf, mkParamResultField(ot, q, ir.PPARAMOUT))
+       }
+       var rf *types.Field
+       if rcvr != nil {
+               rf = mkParamResultField(rcvr, q, ir.PPARAM)
+       }
+       return types.NewSignature(types.LocalPkg, rf, inf, outf)
+}
+
+type expectedDump struct {
+       dump string
+       file string
+       line int
+}
+
+func tokenize(src string) []string {
+       var s scanner.Scanner
+       s.Init(strings.NewReader(src))
+       res := []string{}
+       for tok := s.Scan(); tok != scanner.EOF; tok = s.Scan() {
+               res = append(res, s.TokenText())
+       }
+       return res
+}
+
+func verifyParamResultOffset(t *testing.T, f *types.Field, r abi.ABIParamAssignment, which string, idx int) int {
+       n := ir.AsNode(f.Nname).(*ir.Name)
+       if n.FrameOffset() != int64(r.Offset()) {
+               t.Errorf("%s %d: got offset %d wanted %d t=%v",
+                       which, idx, r.Offset(), n.Offset_, f.Type)
+               return 1
+       }
+       return 0
+}
+
+func makeExpectedDump(e string) expectedDump {
+       return expectedDump{dump: e}
+}
+
+func difftokens(atoks []string, etoks []string) string {
+       if len(atoks) != len(etoks) {
+               return fmt.Sprintf("expected %d tokens got %d",
+                       len(etoks), len(atoks))
+       }
+       for i := 0; i < len(etoks); i++ {
+               if etoks[i] == atoks[i] {
+                       continue
+               }
+
+               return fmt.Sprintf("diff at token %d: expected %q got %q",
+                       i, etoks[i], atoks[i])
+       }
+       return ""
+}
+
+func nrtest(t *testing.T, ft *types.Type, expected int) {
+       types.CalcSize(ft)
+       got := configAMD64.NumParamRegs(ft)
+       if got != expected {
+               t.Errorf("]\nexpected num regs = %d, got %d, type %v", expected, got, ft)
+       }
+}
+
+func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
+
+       types.CalcSize(ft)
+
+       // Analyze with full set of registers.
+       regRes := configAMD64.ABIAnalyze(ft)
+       regResString := strings.TrimSpace(regRes.String())
+
+       // Check results.
+       reason := difftokens(tokenize(regResString), tokenize(exp.dump))
+       if reason != "" {
+               t.Errorf("\nexpected:\n%s\ngot:\n%s\nreason: %s",
+                       strings.TrimSpace(exp.dump), regResString, reason)
+       }
+
+       // Analyze again with empty register set.
+       empty := abi.NewABIConfig(0, 0)
+       emptyRes := empty.ABIAnalyze(ft)
+       emptyResString := emptyRes.String()
+
+       // Walk the results and make sure the offsets assigned match
+       // up with those assiged by CalcSize. This checks to make sure that
+       // when we have no available registers the ABI assignment degenerates
+       // back to the original ABI0.
+
+       // receiver
+       failed := 0
+       rfsl := ft.Recvs().Fields().Slice()
+       poff := 0
+       if len(rfsl) != 0 {
+               failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.InParams()[0], "receiver", 0)
+               poff = 1
+       }
+       // params
+       pfsl := ft.Params().Fields().Slice()
+       for k, f := range pfsl {
+               verifyParamResultOffset(t, f, emptyRes.InParams()[k+poff], "param", k)
+       }
+       // results
+       ofsl := ft.Results().Fields().Slice()
+       for k, f := range ofsl {
+               failed |= verifyParamResultOffset(t, f, emptyRes.OutParams()[k], "result", k)
+       }
+
+       if failed != 0 {
+               t.Logf("emptyres:\n%s\n", emptyResString)
+       }
+}

diff --git a/src/cmd/compile/internal/gc/bench_test.go b/src/cmd/compile/internal/test/bench_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/bench_test.go
rename to src/cmd/compile/internal/test/bench_test.go
index 8c4288128f25b00bc41e67d8db6a9a43da9a5320..3fffe57d082033506f71b1e1b89489f24eb1eb2b 100644 (file)
--- a/src/cmd/compile/internal/gc/bench_test.go
+++ b/src/cmd/compile/internal/test/bench_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import "testing"
 

diff --git a/src/cmd/compile/internal/gc/constFold_test.go b/src/cmd/compile/internal/test/constFold_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/constFold_test.go
rename to src/cmd/compile/internal/test/constFold_test.go
index 59f905dad9623192fbb57dca3b3fd66bbf57f619..7159f0ed33a375960c782f69940446d4c7ae5278 100644 (file)
--- a/src/cmd/compile/internal/gc/constFold_test.go
+++ b/src/cmd/compile/internal/test/constFold_test.go
@@ -1,7 +1,7 @@
 // run
 // Code generated by gen/constFoldGen.go. DO NOT EDIT.
 
-package gc
+package test
 
 import "testing"
 

diff --git a/src/cmd/compile/internal/gc/dep_test.go b/src/cmd/compile/internal/test/dep_test.go
similarity index 92%
rename from src/cmd/compile/internal/gc/dep_test.go
rename to src/cmd/compile/internal/test/dep_test.go
index c1dac9338652bf186ac42d7d0eb6d6cdd5dff132..26122e6a5b70ab1ffd1abd2d7841200f2fe5d7e3 100644 (file)
--- a/src/cmd/compile/internal/gc/dep_test.go
+++ b/src/cmd/compile/internal/test/dep_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "internal/testenv"
@@ -18,7 +18,7 @@ func TestDeps(t *testing.T) {
        }
        for _, dep := range strings.Fields(strings.Trim(string(out), "[]")) {
                switch dep {
-               case "go/build", "go/token":
+               case "go/build", "go/scanner":
                        t.Errorf("undesired dependency on %q", dep)
                }
        }

diff --git a/src/cmd/compile/internal/gc/fixedbugs_test.go b/src/cmd/compile/internal/test/fixedbugs_test.go
similarity index 97%
rename from src/cmd/compile/internal/gc/fixedbugs_test.go
rename to src/cmd/compile/internal/test/fixedbugs_test.go
index 8ac4436947f78cce3b01b2566319d8a6edc01fd2..376b45edfcf00c9f0bfce4b0668d06fcdd5d43d4 100644 (file)
--- a/src/cmd/compile/internal/gc/fixedbugs_test.go
+++ b/src/cmd/compile/internal/test/fixedbugs_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "internal/testenv"
@@ -75,7 +75,7 @@ func TestIssue16214(t *testing.T) {
        cmd := exec.Command(testenv.GoToolPath(t), "tool", "compile", "-S", "-o", filepath.Join(dir, "out.o"), src)
        out, err := cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("fail to run go tool compile: %v", err)
+               t.Fatalf("go tool compile: %v\n%s", err, out)
        }
 
        if strings.Contains(string(out), "unknown line number") {

diff --git a/src/cmd/compile/internal/gc/float_test.go b/src/cmd/compile/internal/test/float_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/float_test.go
rename to src/cmd/compile/internal/test/float_test.go
index c619d2570507f223d8345464ca16555259911a76..884a983bdd7a57ccb432848c072cc86e4d240ad4 100644 (file)
--- a/src/cmd/compile/internal/gc/float_test.go
+++ b/src/cmd/compile/internal/test/float_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "math"

diff --git a/src/cmd/compile/internal/gc/global_test.go b/src/cmd/compile/internal/test/global_test.go
similarity index 95%
rename from src/cmd/compile/internal/gc/global_test.go
rename to src/cmd/compile/internal/test/global_test.go
index edad6d042a36d824cea6e0da40c3ad8aa643697e..93de894f37e12329f55022d15780f6589b28ef17 100644 (file)
--- a/src/cmd/compile/internal/gc/global_test.go
+++ b/src/cmd/compile/internal/test/global_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "bytes"
@@ -50,7 +50,7 @@ func main() {
        cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dst, src)
        out, err := cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("could not build target: %v", err)
+               t.Fatalf("could not build target: %v\n%s", err, out)
        }
 
        // Check destination to see if scanf code was included.
@@ -95,7 +95,7 @@ func main() {
        cmd := exec.Command(testenv.GoToolPath(t), "build", "-gcflags", "-S", "-o", filepath.Join(dir, "test"), src)
        out, err := cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("could not build target: %v", err)
+               t.Fatalf("could not build target: %v\n%s", err, out)
        }
 
        patterns := []string{

diff --git a/src/cmd/compile/internal/gc/iface_test.go b/src/cmd/compile/internal/test/iface_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/iface_test.go
rename to src/cmd/compile/internal/test/iface_test.go
index 21c6587217f0ae07b80021f6fffadfb7f4f70e56..ebc4f891c963a17de4c5d668f7248e9cbc8ae47c 100644 (file)
--- a/src/cmd/compile/internal/gc/iface_test.go
+++ b/src/cmd/compile/internal/test/iface_test.go
@@ -2,15 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
+
+import "testing"
 
 // Test to make sure we make copies of the values we
 // put in interfaces.
 
-import (
-       "testing"
-)
-
 var x int
 
 func TestEfaceConv1(t *testing.T) {

diff --git a/src/cmd/compile/internal/gc/inl_test.go b/src/cmd/compile/internal/test/inl_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/inl_test.go
rename to src/cmd/compile/internal/test/inl_test.go
index 02735e50fb7f0636a25eeaa01f5c698a53a74a26..9d31975b310bf203f72b3c33ad2d250db9478a16 100644 (file)
--- a/src/cmd/compile/internal/gc/inl_test.go
+++ b/src/cmd/compile/internal/test/inl_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "bufio"

diff --git a/src/cmd/compile/internal/gc/lang_test.go b/src/cmd/compile/internal/test/lang_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/lang_test.go
rename to src/cmd/compile/internal/test/lang_test.go
index 72e7f07a21c0028ce8a6352cc63ae2a2584d08a5..67c1551292298355ab90969f5d6fa513988f2b12 100644 (file)
--- a/src/cmd/compile/internal/gc/lang_test.go
+++ b/src/cmd/compile/internal/test/lang_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "internal/testenv"

diff --git a/src/cmd/compile/internal/gc/logic_test.go b/src/cmd/compile/internal/test/logic_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/logic_test.go
rename to src/cmd/compile/internal/test/logic_test.go
index 78d2dd2fa81fad8b6f12fd22579138d15244e91f..1d7043ff605f14deb20817ed898687e865529066 100644 (file)
--- a/src/cmd/compile/internal/gc/logic_test.go
+++ b/src/cmd/compile/internal/test/logic_test.go
@@ -1,4 +1,4 @@
-package gc
+package test
 
 import "testing"
 

diff --git a/src/cmd/compile/internal/gc/reproduciblebuilds_test.go b/src/cmd/compile/internal/test/reproduciblebuilds_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/reproduciblebuilds_test.go
rename to src/cmd/compile/internal/test/reproduciblebuilds_test.go
index 8101e440793ee9e529a6318f342a83a0866a19e2..4d84f9cdeffc9acc4539753b6ff68cb5f87ab4ea 100644 (file)
--- a/src/cmd/compile/internal/gc/reproduciblebuilds_test.go
+++ b/src/cmd/compile/internal/test/reproduciblebuilds_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package test
 
 import (
        "bytes"

diff --git a/src/cmd/compile/internal/gc/shift_test.go b/src/cmd/compile/internal/test/shift_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/shift_test.go
rename to src/cmd/compile/internal/test/shift_test.go
index ce2eedf1521d9d9af087b8e7adfc5901261a3785..ea88f0a70ae22359d3be78e02a93a27f1928cfd4 100644 (file)
--- a/src/cmd/compile/internal/gc/shift_test.go
+++ b/src/cmd/compile/internal/test/shift_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "reflect"

diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/test/ssa_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/ssa_test.go
rename to src/cmd/compile/internal/test/ssa_test.go
index 7f7c9464d44fa7fc03626d34db06e46aa5e530ef..2f3e24c2d37ca0b6c9b6226e6611de369ff39cc9 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa_test.go
+++ b/src/cmd/compile/internal/test/ssa_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
        "bytes"

diff --git a/src/cmd/compile/internal/gc/testdata/addressed_test.go b/src/cmd/compile/internal/test/testdata/addressed_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/addressed_test.go
rename to src/cmd/compile/internal/test/testdata/addressed_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/append_test.go b/src/cmd/compile/internal/test/testdata/append_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/append_test.go
rename to src/cmd/compile/internal/test/testdata/append_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_test.go b/src/cmd/compile/internal/test/testdata/arithBoundary_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arithBoundary_test.go
rename to src/cmd/compile/internal/test/testdata/arithBoundary_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/arithConst_test.go b/src/cmd/compile/internal/test/testdata/arithConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arithConst_test.go
rename to src/cmd/compile/internal/test/testdata/arithConst_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/arith_test.go b/src/cmd/compile/internal/test/testdata/arith_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arith_test.go
rename to src/cmd/compile/internal/test/testdata/arith_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/array_test.go b/src/cmd/compile/internal/test/testdata/array_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/array_test.go
rename to src/cmd/compile/internal/test/testdata/array_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/assert_test.go b/src/cmd/compile/internal/test/testdata/assert_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/assert_test.go
rename to src/cmd/compile/internal/test/testdata/assert_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/break_test.go b/src/cmd/compile/internal/test/testdata/break_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/break_test.go
rename to src/cmd/compile/internal/test/testdata/break_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/chan_test.go b/src/cmd/compile/internal/test/testdata/chan_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/chan_test.go
rename to src/cmd/compile/internal/test/testdata/chan_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/closure_test.go b/src/cmd/compile/internal/test/testdata/closure_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/closure_test.go
rename to src/cmd/compile/internal/test/testdata/closure_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/cmpConst_test.go b/src/cmd/compile/internal/test/testdata/cmpConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/cmpConst_test.go
rename to src/cmd/compile/internal/test/testdata/cmpConst_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/cmp_test.go b/src/cmd/compile/internal/test/testdata/cmp_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/cmp_test.go
rename to src/cmd/compile/internal/test/testdata/cmp_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/compound_test.go b/src/cmd/compile/internal/test/testdata/compound_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/compound_test.go
rename to src/cmd/compile/internal/test/testdata/compound_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/copy_test.go b/src/cmd/compile/internal/test/testdata/copy_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/copy_test.go
rename to src/cmd/compile/internal/test/testdata/copy_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/ctl_test.go b/src/cmd/compile/internal/test/testdata/ctl_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/ctl_test.go
rename to src/cmd/compile/internal/test/testdata/ctl_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/deferNoReturn_test.go b/src/cmd/compile/internal/test/testdata/deferNoReturn_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/deferNoReturn_test.go
rename to src/cmd/compile/internal/test/testdata/deferNoReturn_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/divbyzero_test.go b/src/cmd/compile/internal/test/testdata/divbyzero_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/divbyzero_test.go
rename to src/cmd/compile/internal/test/testdata/divbyzero_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/dupLoad_test.go b/src/cmd/compile/internal/test/testdata/dupLoad_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/dupLoad_test.go
rename to src/cmd/compile/internal/test/testdata/dupLoad_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/flowgraph_generator1.go b/src/cmd/compile/internal/test/testdata/flowgraph_generator1.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/flowgraph_generator1.go
rename to src/cmd/compile/internal/test/testdata/flowgraph_generator1.go

diff --git a/src/cmd/compile/internal/gc/testdata/fp_test.go b/src/cmd/compile/internal/test/testdata/fp_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/fp_test.go
rename to src/cmd/compile/internal/test/testdata/fp_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go b/src/cmd/compile/internal/test/testdata/gen/arithBoundaryGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go
rename to src/cmd/compile/internal/test/testdata/gen/arithBoundaryGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go b/src/cmd/compile/internal/test/testdata/gen/arithConstGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go
rename to src/cmd/compile/internal/test/testdata/gen/arithConstGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/cmpConstGen.go b/src/cmd/compile/internal/test/testdata/gen/cmpConstGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/cmpConstGen.go
rename to src/cmd/compile/internal/test/testdata/gen/cmpConstGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/constFoldGen.go b/src/cmd/compile/internal/test/testdata/gen/constFoldGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/constFoldGen.go
rename to src/cmd/compile/internal/test/testdata/gen/constFoldGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/copyGen.go b/src/cmd/compile/internal/test/testdata/gen/copyGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/copyGen.go
rename to src/cmd/compile/internal/test/testdata/gen/copyGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/gen/zeroGen.go b/src/cmd/compile/internal/test/testdata/gen/zeroGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/zeroGen.go
rename to src/cmd/compile/internal/test/testdata/gen/zeroGen.go

diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_test.go b/src/cmd/compile/internal/test/testdata/loadstore_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/loadstore_test.go
rename to src/cmd/compile/internal/test/testdata/loadstore_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/map_test.go b/src/cmd/compile/internal/test/testdata/map_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/map_test.go
rename to src/cmd/compile/internal/test/testdata/map_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/namedReturn_test.go b/src/cmd/compile/internal/test/testdata/namedReturn_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/namedReturn_test.go
rename to src/cmd/compile/internal/test/testdata/namedReturn_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/phi_test.go b/src/cmd/compile/internal/test/testdata/phi_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/phi_test.go
rename to src/cmd/compile/internal/test/testdata/phi_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/regalloc_test.go b/src/cmd/compile/internal/test/testdata/regalloc_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/regalloc_test.go
rename to src/cmd/compile/internal/test/testdata/regalloc_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue20272.go b/src/cmd/compile/internal/test/testdata/reproducible/issue20272.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue20272.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue20272.go

diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue27013.go b/src/cmd/compile/internal/test/testdata/reproducible/issue27013.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue27013.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue27013.go

diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue30202.go b/src/cmd/compile/internal/test/testdata/reproducible/issue30202.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue30202.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue30202.go

diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue38068.go b/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
similarity index 95%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue38068.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
index db5ca7dcbe7f6ef498105ded20af6550f39daca8..b87daed8e9882b4727f8fc9f01cf9e1dcdcec6f5 100644 (file)
--- a/src/cmd/compile/internal/gc/testdata/reproducible/issue38068.go
+++ b/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
@@ -53,7 +53,7 @@ func G(x *A, n int) {
                return
        }
        // Address-taken local of type A, which will insure that the
-       // compiler's dtypesym() routine will create a method wrapper.
+       // compiler's writeType() routine will create a method wrapper.
        var a, b A
        a.next = x
        a.prev = &b

diff --git a/src/cmd/compile/internal/gc/testdata/short_test.go b/src/cmd/compile/internal/test/testdata/short_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/short_test.go
rename to src/cmd/compile/internal/test/testdata/short_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/slice_test.go b/src/cmd/compile/internal/test/testdata/slice_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/slice_test.go
rename to src/cmd/compile/internal/test/testdata/slice_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/sqrtConst_test.go b/src/cmd/compile/internal/test/testdata/sqrtConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/sqrtConst_test.go
rename to src/cmd/compile/internal/test/testdata/sqrtConst_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/string_test.go b/src/cmd/compile/internal/test/testdata/string_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/string_test.go
rename to src/cmd/compile/internal/test/testdata/string_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/unsafe_test.go b/src/cmd/compile/internal/test/testdata/unsafe_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/unsafe_test.go
rename to src/cmd/compile/internal/test/testdata/unsafe_test.go

diff --git a/src/cmd/compile/internal/gc/testdata/zero_test.go b/src/cmd/compile/internal/test/testdata/zero_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/zero_test.go
rename to src/cmd/compile/internal/test/testdata/zero_test.go

diff --git a/src/cmd/compile/internal/gc/truncconst_test.go b/src/cmd/compile/internal/test/truncconst_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/truncconst_test.go
rename to src/cmd/compile/internal/test/truncconst_test.go
index d1538180649dff5b8c7b76f2945923fe6f653de9..7705042ca2c84f3ef1db4ff7833035bfd22d2854 100644 (file)
--- a/src/cmd/compile/internal/gc/truncconst_test.go
+++ b/src/cmd/compile/internal/test/truncconst_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import "testing"
 

diff --git a/src/cmd/compile/internal/gc/zerorange_test.go b/src/cmd/compile/internal/test/zerorange_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/zerorange_test.go
rename to src/cmd/compile/internal/test/zerorange_test.go
index 89f4cb9bcf6e436ae6981cb1809927bd9c799676..cb1a6e04e4e77022ef4ba40b8e0a01626508dbe7 100644 (file)
--- a/src/cmd/compile/internal/gc/zerorange_test.go
+++ b/src/cmd/compile/internal/test/zerorange_test.go
@@ -2,11 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
-import (
-       "testing"
-)
+import "testing"
 
 var glob = 3
 var globp *int64

diff --git a/src/cmd/compile/internal/typebits/typebits.go b/src/cmd/compile/internal/typebits/typebits.go
new file mode 100644 (file)
index 0000000..1c1b077
--- /dev/null
+++ b/src/cmd/compile/internal/typebits/typebits.go
@@ -0,0 +1,87 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typebits
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/bitvec"
+       "cmd/compile/internal/types"
+)
+
+// NOTE: The bitmap for a specific type t could be cached in t after
+// the first run and then simply copied into bv at the correct offset
+// on future calls with the same type t.
+func Set(t *types.Type, off int64, bv bitvec.BitVec) {
+       if t.Align > 0 && off&int64(t.Align-1) != 0 {
+               base.Fatalf("typebits.Set: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
+       }
+       if !t.HasPointers() {
+               // Note: this case ensures that pointers to go:notinheap types
+               // are not considered pointers by garbage collection and stack copying.
+               return
+       }
+
+       switch t.Kind() {
+       case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
+               if off&int64(types.PtrSize-1) != 0 {
+                       base.Fatalf("typebits.Set: invalid alignment, %v", t)
+               }
+               bv.Set(int32(off / int64(types.PtrSize))) // pointer
+
+       case types.TSTRING:
+               // struct { byte *str; intgo len; }
+               if off&int64(types.PtrSize-1) != 0 {
+                       base.Fatalf("typebits.Set: invalid alignment, %v", t)
+               }
+               bv.Set(int32(off / int64(types.PtrSize))) //pointer in first slot
+
+       case types.TINTER:
+               // struct { Itab *tab;  void *data; }
+               // or, when isnilinter(t)==true:
+               // struct { Type *type; void *data; }
+               if off&int64(types.PtrSize-1) != 0 {
+                       base.Fatalf("typebits.Set: invalid alignment, %v", t)
+               }
+               // The first word of an interface is a pointer, but we don't
+               // treat it as such.
+               // 1. If it is a non-empty interface, the pointer points to an itab
+               //    which is always in persistentalloc space.
+               // 2. If it is an empty interface, the pointer points to a _type.
+               //   a. If it is a compile-time-allocated type, it points into
+               //      the read-only data section.
+               //   b. If it is a reflect-allocated type, it points into the Go heap.
+               //      Reflect is responsible for keeping a reference to
+               //      the underlying type so it won't be GCd.
+               // If we ever have a moving GC, we need to change this for 2b (as
+               // well as scan itabs to update their itab._type fields).
+               bv.Set(int32(off/int64(types.PtrSize) + 1)) // pointer in second slot
+
+       case types.TSLICE:
+               // struct { byte *array; uintgo len; uintgo cap; }
+               if off&int64(types.PtrSize-1) != 0 {
+                       base.Fatalf("typebits.Set: invalid TARRAY alignment, %v", t)
+               }
+               bv.Set(int32(off / int64(types.PtrSize))) // pointer in first slot (BitsPointer)
+
+       case types.TARRAY:
+               elt := t.Elem()
+               if elt.Width == 0 {
+                       // Short-circuit for #20739.
+                       break
+               }
+               for i := int64(0); i < t.NumElem(); i++ {
+                       Set(elt, off, bv)
+                       off += elt.Width
+               }
+
+       case types.TSTRUCT:
+               for _, f := range t.Fields().Slice() {
+                       Set(f.Type, off+f.Offset, bv)
+               }
+
+       default:
+               base.Fatalf("typebits.Set: unexpected type, %v", t)
+       }
+}

diff --git a/src/cmd/compile/internal/typecheck/bexport.go b/src/cmd/compile/internal/typecheck/bexport.go
new file mode 100644 (file)
index 0000000..4a84bb1
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/bexport.go
@@ -0,0 +1,102 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import "cmd/compile/internal/types"
+
+// ----------------------------------------------------------------------------
+// Export format
+
+// Tags. Must be < 0.
+const (
+       // Objects
+       packageTag = -(iota + 1)
+       constTag
+       typeTag
+       varTag
+       funcTag
+       endTag
+
+       // Types
+       namedTag
+       arrayTag
+       sliceTag
+       dddTag
+       structTag
+       pointerTag
+       signatureTag
+       interfaceTag
+       mapTag
+       chanTag
+
+       // Values
+       falseTag
+       trueTag
+       int64Tag
+       floatTag
+       fractionTag // not used by gc
+       complexTag
+       stringTag
+       nilTag
+       unknownTag // not used by gc (only appears in packages with errors)
+
+       // Type aliases
+       aliasTag
+)
+
+var predecl []*types.Type // initialized lazily
+
+func predeclared() []*types.Type {
+       if predecl == nil {
+               // initialize lazily to be sure that all
+               // elements have been initialized before
+               predecl = []*types.Type{
+                       // basic types
+                       types.Types[types.TBOOL],
+                       types.Types[types.TINT],
+                       types.Types[types.TINT8],
+                       types.Types[types.TINT16],
+                       types.Types[types.TINT32],
+                       types.Types[types.TINT64],
+                       types.Types[types.TUINT],
+                       types.Types[types.TUINT8],
+                       types.Types[types.TUINT16],
+                       types.Types[types.TUINT32],
+                       types.Types[types.TUINT64],
+                       types.Types[types.TUINTPTR],
+                       types.Types[types.TFLOAT32],
+                       types.Types[types.TFLOAT64],
+                       types.Types[types.TCOMPLEX64],
+                       types.Types[types.TCOMPLEX128],
+                       types.Types[types.TSTRING],
+
+                       // basic type aliases
+                       types.ByteType,
+                       types.RuneType,
+
+                       // error
+                       types.ErrorType,
+
+                       // untyped types
+                       types.UntypedBool,
+                       types.UntypedInt,
+                       types.UntypedRune,
+                       types.UntypedFloat,
+                       types.UntypedComplex,
+                       types.UntypedString,
+                       types.Types[types.TNIL],
+
+                       // package unsafe
+                       types.Types[types.TUNSAFEPTR],
+
+                       // invalid type (package contains errors)
+                       types.Types[types.Txxx],
+
+                       // any type, for builtin export data
+                       types.Types[types.TANY],
+               }
+       }
+       return predecl
+}

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
new file mode 100644 (file)
index 0000000..0dee852
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -0,0 +1,343 @@
+// Code generated by mkbuiltin.go. DO NOT EDIT.
+
+package typecheck
+
+import (
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+var runtimeDecls = [...]struct {
+       name string
+       tag  int
+       typ  int
+}{
+       {"newobject", funcTag, 4},
+       {"mallocgc", funcTag, 8},
+       {"panicdivide", funcTag, 9},
+       {"panicshift", funcTag, 9},
+       {"panicmakeslicelen", funcTag, 9},
+       {"panicmakeslicecap", funcTag, 9},
+       {"throwinit", funcTag, 9},
+       {"panicwrap", funcTag, 9},
+       {"gopanic", funcTag, 11},
+       {"gorecover", funcTag, 14},
+       {"goschedguarded", funcTag, 9},
+       {"goPanicIndex", funcTag, 16},
+       {"goPanicIndexU", funcTag, 18},
+       {"goPanicSliceAlen", funcTag, 16},
+       {"goPanicSliceAlenU", funcTag, 18},
+       {"goPanicSliceAcap", funcTag, 16},
+       {"goPanicSliceAcapU", funcTag, 18},
+       {"goPanicSliceB", funcTag, 16},
+       {"goPanicSliceBU", funcTag, 18},
+       {"goPanicSlice3Alen", funcTag, 16},
+       {"goPanicSlice3AlenU", funcTag, 18},
+       {"goPanicSlice3Acap", funcTag, 16},
+       {"goPanicSlice3AcapU", funcTag, 18},
+       {"goPanicSlice3B", funcTag, 16},
+       {"goPanicSlice3BU", funcTag, 18},
+       {"goPanicSlice3C", funcTag, 16},
+       {"goPanicSlice3CU", funcTag, 18},
+       {"printbool", funcTag, 19},
+       {"printfloat", funcTag, 21},
+       {"printint", funcTag, 23},
+       {"printhex", funcTag, 25},
+       {"printuint", funcTag, 25},
+       {"printcomplex", funcTag, 27},
+       {"printstring", funcTag, 29},
+       {"printpointer", funcTag, 30},
+       {"printuintptr", funcTag, 31},
+       {"printiface", funcTag, 30},
+       {"printeface", funcTag, 30},
+       {"printslice", funcTag, 30},
+       {"printnl", funcTag, 9},
+       {"printsp", funcTag, 9},
+       {"printlock", funcTag, 9},
+       {"printunlock", funcTag, 9},
+       {"concatstring2", funcTag, 34},
+       {"concatstring3", funcTag, 35},
+       {"concatstring4", funcTag, 36},
+       {"concatstring5", funcTag, 37},
+       {"concatstrings", funcTag, 39},
+       {"cmpstring", funcTag, 40},
+       {"intstring", funcTag, 43},
+       {"slicebytetostring", funcTag, 44},
+       {"slicebytetostringtmp", funcTag, 45},
+       {"slicerunetostring", funcTag, 48},
+       {"stringtoslicebyte", funcTag, 50},
+       {"stringtoslicerune", funcTag, 53},
+       {"slicecopy", funcTag, 54},
+       {"decoderune", funcTag, 55},
+       {"countrunes", funcTag, 56},
+       {"convI2I", funcTag, 57},
+       {"convT16", funcTag, 58},
+       {"convT32", funcTag, 58},
+       {"convT64", funcTag, 58},
+       {"convTstring", funcTag, 58},
+       {"convTslice", funcTag, 58},
+       {"convT2E", funcTag, 59},
+       {"convT2Enoptr", funcTag, 59},
+       {"convT2I", funcTag, 59},
+       {"convT2Inoptr", funcTag, 59},
+       {"assertE2I", funcTag, 57},
+       {"assertE2I2", funcTag, 60},
+       {"assertI2I", funcTag, 57},
+       {"assertI2I2", funcTag, 60},
+       {"panicdottypeE", funcTag, 61},
+       {"panicdottypeI", funcTag, 61},
+       {"panicnildottype", funcTag, 62},
+       {"ifaceeq", funcTag, 64},
+       {"efaceeq", funcTag, 64},
+       {"fastrand", funcTag, 66},
+       {"makemap64", funcTag, 68},
+       {"makemap", funcTag, 69},
+       {"makemap_small", funcTag, 70},
+       {"mapaccess1", funcTag, 71},
+       {"mapaccess1_fast32", funcTag, 72},
+       {"mapaccess1_fast64", funcTag, 72},
+       {"mapaccess1_faststr", funcTag, 72},
+       {"mapaccess1_fat", funcTag, 73},
+       {"mapaccess2", funcTag, 74},
+       {"mapaccess2_fast32", funcTag, 75},
+       {"mapaccess2_fast64", funcTag, 75},
+       {"mapaccess2_faststr", funcTag, 75},
+       {"mapaccess2_fat", funcTag, 76},
+       {"mapassign", funcTag, 71},
+       {"mapassign_fast32", funcTag, 72},
+       {"mapassign_fast32ptr", funcTag, 72},
+       {"mapassign_fast64", funcTag, 72},
+       {"mapassign_fast64ptr", funcTag, 72},
+       {"mapassign_faststr", funcTag, 72},
+       {"mapiterinit", funcTag, 77},
+       {"mapdelete", funcTag, 77},
+       {"mapdelete_fast32", funcTag, 78},
+       {"mapdelete_fast64", funcTag, 78},
+       {"mapdelete_faststr", funcTag, 78},
+       {"mapiternext", funcTag, 79},
+       {"mapclear", funcTag, 80},
+       {"makechan64", funcTag, 82},
+       {"makechan", funcTag, 83},
+       {"chanrecv1", funcTag, 85},
+       {"chanrecv2", funcTag, 86},
+       {"chansend1", funcTag, 88},
+       {"closechan", funcTag, 30},
+       {"writeBarrier", varTag, 90},
+       {"typedmemmove", funcTag, 91},
+       {"typedmemclr", funcTag, 92},
+       {"typedslicecopy", funcTag, 93},
+       {"selectnbsend", funcTag, 94},
+       {"selectnbrecv", funcTag, 95},
+       {"selectnbrecv2", funcTag, 97},
+       {"selectsetpc", funcTag, 98},
+       {"selectgo", funcTag, 99},
+       {"block", funcTag, 9},
+       {"makeslice", funcTag, 100},
+       {"makeslice64", funcTag, 101},
+       {"makeslicecopy", funcTag, 102},
+       {"growslice", funcTag, 104},
+       {"memmove", funcTag, 105},
+       {"memclrNoHeapPointers", funcTag, 106},
+       {"memclrHasPointers", funcTag, 106},
+       {"memequal", funcTag, 107},
+       {"memequal0", funcTag, 108},
+       {"memequal8", funcTag, 108},
+       {"memequal16", funcTag, 108},
+       {"memequal32", funcTag, 108},
+       {"memequal64", funcTag, 108},
+       {"memequal128", funcTag, 108},
+       {"f32equal", funcTag, 109},
+       {"f64equal", funcTag, 109},
+       {"c64equal", funcTag, 109},
+       {"c128equal", funcTag, 109},
+       {"strequal", funcTag, 109},
+       {"interequal", funcTag, 109},
+       {"nilinterequal", funcTag, 109},
+       {"memhash", funcTag, 110},
+       {"memhash0", funcTag, 111},
+       {"memhash8", funcTag, 111},
+       {"memhash16", funcTag, 111},
+       {"memhash32", funcTag, 111},
+       {"memhash64", funcTag, 111},
+       {"memhash128", funcTag, 111},
+       {"f32hash", funcTag, 111},
+       {"f64hash", funcTag, 111},
+       {"c64hash", funcTag, 111},
+       {"c128hash", funcTag, 111},
+       {"strhash", funcTag, 111},
+       {"interhash", funcTag, 111},
+       {"nilinterhash", funcTag, 111},
+       {"int64div", funcTag, 112},
+       {"uint64div", funcTag, 113},
+       {"int64mod", funcTag, 112},
+       {"uint64mod", funcTag, 113},
+       {"float64toint64", funcTag, 114},
+       {"float64touint64", funcTag, 115},
+       {"float64touint32", funcTag, 116},
+       {"int64tofloat64", funcTag, 117},
+       {"uint64tofloat64", funcTag, 118},
+       {"uint32tofloat64", funcTag, 119},
+       {"complex128div", funcTag, 120},
+       {"racefuncenter", funcTag, 31},
+       {"racefuncenterfp", funcTag, 9},
+       {"racefuncexit", funcTag, 9},
+       {"raceread", funcTag, 31},
+       {"racewrite", funcTag, 31},
+       {"racereadrange", funcTag, 121},
+       {"racewriterange", funcTag, 121},
+       {"msanread", funcTag, 121},
+       {"msanwrite", funcTag, 121},
+       {"msanmove", funcTag, 122},
+       {"checkptrAlignment", funcTag, 123},
+       {"checkptrArithmetic", funcTag, 125},
+       {"libfuzzerTraceCmp1", funcTag, 127},
+       {"libfuzzerTraceCmp2", funcTag, 129},
+       {"libfuzzerTraceCmp4", funcTag, 130},
+       {"libfuzzerTraceCmp8", funcTag, 131},
+       {"libfuzzerTraceConstCmp1", funcTag, 127},
+       {"libfuzzerTraceConstCmp2", funcTag, 129},
+       {"libfuzzerTraceConstCmp4", funcTag, 130},
+       {"libfuzzerTraceConstCmp8", funcTag, 131},
+       {"x86HasPOPCNT", varTag, 6},
+       {"x86HasSSE41", varTag, 6},
+       {"x86HasFMA", varTag, 6},
+       {"armHasVFPv4", varTag, 6},
+       {"arm64HasATOMICS", varTag, 6},
+}
+
+func runtimeTypes() []*types.Type {
+       var typs [132]*types.Type
+       typs[0] = types.ByteType
+       typs[1] = types.NewPtr(typs[0])
+       typs[2] = types.Types[types.TANY]
+       typs[3] = types.NewPtr(typs[2])
+       typs[4] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+       typs[5] = types.Types[types.TUINTPTR]
+       typs[6] = types.Types[types.TBOOL]
+       typs[7] = types.Types[types.TUNSAFEPTR]
+       typs[8] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+       typs[9] = types.NewSignature(types.NoPkg, nil, nil, nil)
+       typs[10] = types.Types[types.TINTER]
+       typs[11] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])}, nil)
+       typs[12] = types.Types[types.TINT32]
+       typs[13] = types.NewPtr(typs[12])
+       typs[14] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[13])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])})
+       typs[15] = types.Types[types.TINT]
+       typs[16] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+       typs[17] = types.Types[types.TUINT]
+       typs[18] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[17]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+       typs[19] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])}, nil)
+       typs[20] = types.Types[types.TFLOAT64]
+       typs[21] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, nil)
+       typs[22] = types.Types[types.TINT64]
+       typs[23] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, nil)
+       typs[24] = types.Types[types.TUINT64]
+       typs[25] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, nil)
+       typs[26] = types.Types[types.TCOMPLEX128]
+       typs[27] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])}, nil)
+       typs[28] = types.Types[types.TSTRING]
+       typs[29] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, nil)
+       typs[30] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, nil)
+       typs[31] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[32] = types.NewArray(typs[0], 32)
+       typs[33] = types.NewPtr(typs[32])
+       typs[34] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[35] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[36] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[37] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[38] = types.NewSlice(typs[28])
+       typs[39] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[38])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[40] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+       typs[41] = types.NewArray(typs[0], 4)
+       typs[42] = types.NewPtr(typs[41])
+       typs[43] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[42]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[44] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[45] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[46] = types.RuneType
+       typs[47] = types.NewSlice(typs[46])
+       typs[48] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[47])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+       typs[49] = types.NewSlice(typs[0])
+       typs[50] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[49])})
+       typs[51] = types.NewArray(typs[46], 32)
+       typs[52] = types.NewPtr(typs[51])
+       typs[53] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[52]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[47])})
+       typs[54] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+       typs[55] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[46]), types.NewField(src.NoXPos, nil, typs[15])})
+       typs[56] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+       typs[57] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+       typs[58] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+       typs[59] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+       typs[60] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2]), types.NewField(src.NoXPos, nil, typs[6])})
+       typs[61] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1])}, nil)
+       typs[62] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, nil)
+       typs[63] = types.NewPtr(typs[5])
+       typs[64] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[65] = types.Types[types.TUINT32]
+       typs[66] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+       typs[67] = types.NewMap(typs[2], typs[2])
+       typs[68] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+       typs[69] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+       typs[70] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+       typs[71] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+       typs[72] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+       typs[73] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+       typs[74] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+       typs[75] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+       typs[76] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+       typs[77] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[78] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, nil)
+       typs[79] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[80] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67])}, nil)
+       typs[81] = types.NewChan(typs[2], types.Cboth)
+       typs[82] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+       typs[83] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+       typs[84] = types.NewChan(typs[2], types.Crecv)
+       typs[85] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[86] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[87] = types.NewChan(typs[2], types.Csend)
+       typs[88] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[89] = types.NewArray(typs[0], 3)
+       typs[90] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[89]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+       typs[91] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[92] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+       typs[93] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+       typs[94] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[95] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[96] = types.NewPtr(typs[6])
+       typs[97] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[96]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[98] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63])}, nil)
+       typs[99] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])})
+       typs[100] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+       typs[101] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+       typs[102] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+       typs[103] = types.NewSlice(typs[2])
+       typs[104] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[103]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[103])})
+       typs[105] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[106] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[107] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[108] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[109] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+       typs[110] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+       typs[111] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+       typs[112] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+       typs[113] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+       typs[114] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+       typs[115] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+       typs[116] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+       typs[117] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+       typs[118] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+       typs[119] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+       typs[120] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26]), types.NewField(src.NoXPos, nil, typs[26])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])})
+       typs[121] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[122] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[123] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+       typs[124] = types.NewSlice(typs[7])
+       typs[125] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[124])}, nil)
+       typs[126] = types.Types[types.TUINT8]
+       typs[127] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[126]), types.NewField(src.NoXPos, nil, typs[126])}, nil)
+       typs[128] = types.Types[types.TUINT16]
+       typs[129] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[128]), types.NewField(src.NoXPos, nil, typs[128])}, nil)
+       typs[130] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65]), types.NewField(src.NoXPos, nil, typs[65])}, nil)
+       typs[131] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, nil)
+       return typs[:]
+}

diff --git a/src/cmd/compile/internal/gc/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
similarity index 100%
rename from src/cmd/compile/internal/gc/builtin/runtime.go
rename to src/cmd/compile/internal/typecheck/builtin/runtime.go

diff --git a/src/cmd/compile/internal/gc/builtin_test.go b/src/cmd/compile/internal/typecheck/builtin_test.go
similarity index 97%
rename from src/cmd/compile/internal/gc/builtin_test.go
rename to src/cmd/compile/internal/typecheck/builtin_test.go
index 57f24b2287978d23773ce506088bbe49c8be4d6a..fb9d3e393f10e15755e95508655352534aeab985 100644 (file)
--- a/src/cmd/compile/internal/gc/builtin_test.go
+++ b/src/cmd/compile/internal/typecheck/builtin_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package typecheck
 
 import (
        "bytes"

diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
new file mode 100644 (file)
index 0000000..1a8e583
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -0,0 +1,935 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "fmt"
+       "go/constant"
+       "go/token"
+       "math"
+       "math/big"
+       "strings"
+       "unicode"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+func roundFloat(v constant.Value, sz int64) constant.Value {
+       switch sz {
+       case 4:
+               f, _ := constant.Float32Val(v)
+               return makeFloat64(float64(f))
+       case 8:
+               f, _ := constant.Float64Val(v)
+               return makeFloat64(f)
+       }
+       base.Fatalf("unexpected size: %v", sz)
+       panic("unreachable")
+}
+
+// truncate float literal fv to 32-bit or 64-bit precision
+// according to type; return truncated value.
+func truncfltlit(v constant.Value, t *types.Type) constant.Value {
+       if t.IsUntyped() || overflow(v, t) {
+               // If there was overflow, simply continuing would set the
+               // value to Inf which in turn would lead to spurious follow-on
+               // errors. Avoid this by returning the existing value.
+               return v
+       }
+
+       return roundFloat(v, t.Size())
+}
+
+// truncate Real and Imag parts of Mpcplx to 32-bit or 64-bit
+// precision, according to type; return truncated value. In case of
+// overflow, calls Errorf but does not truncate the input value.
+func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
+       if t.IsUntyped() || overflow(v, t) {
+               // If there was overflow, simply continuing would set the
+               // value to Inf which in turn would lead to spurious follow-on
+               // errors. Avoid this by returning the existing value.
+               return v
+       }
+
+       fsz := t.Size() / 2
+       return makeComplex(roundFloat(constant.Real(v), fsz), roundFloat(constant.Imag(v), fsz))
+}
+
+// TODO(mdempsky): Replace these with better APIs.
+func convlit(n ir.Node, t *types.Type) ir.Node    { return convlit1(n, t, false, nil) }
+func DefaultLit(n ir.Node, t *types.Type) ir.Node { return convlit1(n, t, false, nil) }
+
+// convlit1 converts an untyped expression n to type t. If n already
+// has a type, convlit1 has no effect.
+//
+// For explicit conversions, t must be non-nil, and integer-to-string
+// conversions are allowed.
+//
+// For implicit conversions (e.g., assignments), t may be nil; if so,
+// n is converted to its default type.
+//
+// If there's an error converting n to t, context is used in the error
+// message.
+func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir.Node {
+       if explicit && t == nil {
+               base.Fatalf("explicit conversion missing type")
+       }
+       if t != nil && t.IsUntyped() {
+               base.Fatalf("bad conversion to untyped: %v", t)
+       }
+
+       if n == nil || n.Type() == nil {
+               // Allow sloppy callers.
+               return n
+       }
+       if !n.Type().IsUntyped() {
+               // Already typed; nothing to do.
+               return n
+       }
+
+       // Nil is technically not a constant, so handle it specially.
+       if n.Type().Kind() == types.TNIL {
+               if n.Op() != ir.ONIL {
+                       base.Fatalf("unexpected op: %v (%v)", n, n.Op())
+               }
+               n = ir.Copy(n)
+               if t == nil {
+                       base.Errorf("use of untyped nil")
+                       n.SetDiag(true)
+                       n.SetType(nil)
+                       return n
+               }
+
+               if !t.HasNil() {
+                       // Leave for caller to handle.
+                       return n
+               }
+
+               n.SetType(t)
+               return n
+       }
+
+       if t == nil || !ir.OKForConst[t.Kind()] {
+               t = defaultType(n.Type())
+       }
+
+       switch n.Op() {
+       default:
+               base.Fatalf("unexpected untyped expression: %v", n)
+
+       case ir.OLITERAL:
+               v := convertVal(n.Val(), t, explicit)
+               if v.Kind() == constant.Unknown {
+                       n = ir.NewConstExpr(n.Val(), n)
+                       break
+               }
+               n = ir.NewConstExpr(v, n)
+               n.SetType(t)
+               return n
+
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
+               ot := operandType(n.Op(), t)
+               if ot == nil {
+                       n = DefaultLit(n, nil)
+                       break
+               }
+
+               n := n.(*ir.UnaryExpr)
+               n.X = convlit(n.X, ot)
+               if n.X.Type() == nil {
+                       n.SetType(nil)
+                       return n
+               }
+               n.SetType(t)
+               return n
+
+       case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND, ir.OCOMPLEX:
+               ot := operandType(n.Op(), t)
+               if ot == nil {
+                       n = DefaultLit(n, nil)
+                       break
+               }
+
+               var l, r ir.Node
+               switch n := n.(type) {
+               case *ir.BinaryExpr:
+                       n.X = convlit(n.X, ot)
+                       n.Y = convlit(n.Y, ot)
+                       l, r = n.X, n.Y
+               case *ir.LogicalExpr:
+                       n.X = convlit(n.X, ot)
+                       n.Y = convlit(n.Y, ot)
+                       l, r = n.X, n.Y
+               }
+
+               if l.Type() == nil || r.Type() == nil {
+                       n.SetType(nil)
+                       return n
+               }
+               if !types.Identical(l.Type(), r.Type()) {
+                       base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+                       n.SetType(nil)
+                       return n
+               }
+
+               n.SetType(t)
+               return n
+
+       case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+               n := n.(*ir.BinaryExpr)
+               if !t.IsBoolean() {
+                       break
+               }
+               n.SetType(t)
+               return n
+
+       case ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               n.X = convlit1(n.X, t, explicit, nil)
+               n.SetType(n.X.Type())
+               if n.Type() != nil && !n.Type().IsInteger() {
+                       base.Errorf("invalid operation: %v (shift of type %v)", n, n.Type())
+                       n.SetType(nil)
+               }
+               return n
+       }
+
+       if !n.Diag() {
+               if !t.Broke() {
+                       if explicit {
+                               base.Errorf("cannot convert %L to type %v", n, t)
+                       } else if context != nil {
+                               base.Errorf("cannot use %L as type %v in %s", n, t, context())
+                       } else {
+                               base.Errorf("cannot use %L as type %v", n, t)
+                       }
+               }
+               n.SetDiag(true)
+       }
+       n.SetType(nil)
+       return n
+}
+
+func operandType(op ir.Op, t *types.Type) *types.Type {
+       switch op {
+       case ir.OCOMPLEX:
+               if t.IsComplex() {
+                       return types.FloatForComplex(t)
+               }
+       case ir.OREAL, ir.OIMAG:
+               if t.IsFloat() {
+                       return types.ComplexForFloat(t)
+               }
+       default:
+               if okfor[op][t.Kind()] {
+                       return t
+               }
+       }
+       return nil
+}
+
+// convertVal converts v into a representation appropriate for t. If
+// no such representation exists, it returns Val{} instead.
+//
+// If explicit is true, then conversions from integer to string are
+// also allowed.
+func convertVal(v constant.Value, t *types.Type, explicit bool) constant.Value {
+       switch ct := v.Kind(); ct {
+       case constant.Bool:
+               if t.IsBoolean() {
+                       return v
+               }
+
+       case constant.String:
+               if t.IsString() {
+                       return v
+               }
+
+       case constant.Int:
+               if explicit && t.IsString() {
+                       return tostr(v)
+               }
+               fallthrough
+       case constant.Float, constant.Complex:
+               switch {
+               case t.IsInteger():
+                       v = toint(v)
+                       overflow(v, t)
+                       return v
+               case t.IsFloat():
+                       v = toflt(v)
+                       v = truncfltlit(v, t)
+                       return v
+               case t.IsComplex():
+                       v = tocplx(v)
+                       v = trunccmplxlit(v, t)
+                       return v
+               }
+       }
+
+       return constant.MakeUnknown()
+}
+
+func tocplx(v constant.Value) constant.Value {
+       return constant.ToComplex(v)
+}
+
+func toflt(v constant.Value) constant.Value {
+       if v.Kind() == constant.Complex {
+               if constant.Sign(constant.Imag(v)) != 0 {
+                       base.Errorf("constant %v truncated to real", v)
+               }
+               v = constant.Real(v)
+       }
+
+       return constant.ToFloat(v)
+}
+
+func toint(v constant.Value) constant.Value {
+       if v.Kind() == constant.Complex {
+               if constant.Sign(constant.Imag(v)) != 0 {
+                       base.Errorf("constant %v truncated to integer", v)
+               }
+               v = constant.Real(v)
+       }
+
+       if v := constant.ToInt(v); v.Kind() == constant.Int {
+               return v
+       }
+
+       // The value of v cannot be represented as an integer;
+       // so we need to print an error message.
+       // Unfortunately some float values cannot be
+       // reasonably formatted for inclusion in an error
+       // message (example: 1 + 1e-100), so first we try to
+       // format the float; if the truncation resulted in
+       // something that looks like an integer we omit the
+       // value from the error message.
+       // (See issue #11371).
+       f := ir.BigFloat(v)
+       if f.MantExp(nil) > 2*ir.ConstPrec {
+               base.Errorf("integer too large")
+       } else {
+               var t big.Float
+               t.Parse(fmt.Sprint(v), 0)
+               if t.IsInt() {
+                       base.Errorf("constant truncated to integer")
+               } else {
+                       base.Errorf("constant %v truncated to integer", v)
+               }
+       }
+
+       // Prevent follow-on errors.
+       // TODO(mdempsky): Use constant.MakeUnknown() instead.
+       return constant.MakeInt64(1)
+}
+
+// overflow reports whether constant value v is too large
+// to represent with type t, and emits an error message if so.
+func overflow(v constant.Value, t *types.Type) bool {
+       // v has already been converted
+       // to appropriate form for t.
+       if t.IsUntyped() {
+               return false
+       }
+       if v.Kind() == constant.Int && constant.BitLen(v) > ir.ConstPrec {
+               base.Errorf("integer too large")
+               return true
+       }
+       if ir.ConstOverflow(v, t) {
+               base.Errorf("constant %v overflows %v", types.FmtConst(v, false), t)
+               return true
+       }
+       return false
+}
+
+func tostr(v constant.Value) constant.Value {
+       if v.Kind() == constant.Int {
+               r := unicode.ReplacementChar
+               if x, ok := constant.Uint64Val(v); ok && x <= unicode.MaxRune {
+                       r = rune(x)
+               }
+               v = constant.MakeString(string(r))
+       }
+       return v
+}
+
+var tokenForOp = [...]token.Token{
+       ir.OPLUS:   token.ADD,
+       ir.ONEG:    token.SUB,
+       ir.ONOT:    token.NOT,
+       ir.OBITNOT: token.XOR,
+
+       ir.OADD:    token.ADD,
+       ir.OSUB:    token.SUB,
+       ir.OMUL:    token.MUL,
+       ir.ODIV:    token.QUO,
+       ir.OMOD:    token.REM,
+       ir.OOR:     token.OR,
+       ir.OXOR:    token.XOR,
+       ir.OAND:    token.AND,
+       ir.OANDNOT: token.AND_NOT,
+       ir.OOROR:   token.LOR,
+       ir.OANDAND: token.LAND,
+
+       ir.OEQ: token.EQL,
+       ir.ONE: token.NEQ,
+       ir.OLT: token.LSS,
+       ir.OLE: token.LEQ,
+       ir.OGT: token.GTR,
+       ir.OGE: token.GEQ,
+
+       ir.OLSH: token.SHL,
+       ir.ORSH: token.SHR,
+}
+
+// EvalConst returns a constant-evaluated expression equivalent to n.
+// If n is not a constant, EvalConst returns n.
+// Otherwise, EvalConst returns a new OLITERAL with the same value as n,
+// and with .Orig pointing back to n.
+func EvalConst(n ir.Node) ir.Node {
+       // Pick off just the opcodes that can be constant evaluated.
+       switch n.Op() {
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+               n := n.(*ir.UnaryExpr)
+               nl := n.X
+               if nl.Op() == ir.OLITERAL {
+                       var prec uint
+                       if n.Type().IsUnsigned() {
+                               prec = uint(n.Type().Size() * 8)
+                       }
+                       return OrigConst(n, constant.UnaryOp(tokenForOp[n.Op()], nl.Val(), prec))
+               }
+
+       case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT:
+               n := n.(*ir.BinaryExpr)
+               nl, nr := n.X, n.Y
+               if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+                       rval := nr.Val()
+
+                       // check for divisor underflow in complex division (see issue 20227)
+                       if n.Op() == ir.ODIV && n.Type().IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
+                               base.Errorf("complex division by zero")
+                               n.SetType(nil)
+                               return n
+                       }
+                       if (n.Op() == ir.ODIV || n.Op() == ir.OMOD) && constant.Sign(rval) == 0 {
+                               base.Errorf("division by zero")
+                               n.SetType(nil)
+                               return n
+                       }
+
+                       tok := tokenForOp[n.Op()]
+                       if n.Op() == ir.ODIV && n.Type().IsInteger() {
+                               tok = token.QUO_ASSIGN // integer division
+                       }
+                       return OrigConst(n, constant.BinaryOp(nl.Val(), tok, rval))
+               }
+
+       case ir.OOROR, ir.OANDAND:
+               n := n.(*ir.LogicalExpr)
+               nl, nr := n.X, n.Y
+               if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+                       return OrigConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
+               }
+
+       case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+               n := n.(*ir.BinaryExpr)
+               nl, nr := n.X, n.Y
+               if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+                       return OrigBool(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
+               }
+
+       case ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               nl, nr := n.X, n.Y
+               if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+                       // shiftBound from go/types; "so we can express smallestFloat64"
+                       const shiftBound = 1023 - 1 + 52
+                       s, ok := constant.Uint64Val(nr.Val())
+                       if !ok || s > shiftBound {
+                               base.Errorf("invalid shift count %v", nr)
+                               n.SetType(nil)
+                               break
+                       }
+                       return OrigConst(n, constant.Shift(toint(nl.Val()), tokenForOp[n.Op()], uint(s)))
+               }
+
+       case ir.OCONV, ir.ORUNESTR:
+               n := n.(*ir.ConvExpr)
+               nl := n.X
+               if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
+                       return OrigConst(n, convertVal(nl.Val(), n.Type(), true))
+               }
+
+       case ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               nl := n.X
+               if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
+                       // set so n.Orig gets OCONV instead of OCONVNOP
+                       n.SetOp(ir.OCONV)
+                       return OrigConst(n, nl.Val())
+               }
+
+       case ir.OADDSTR:
+               // Merge adjacent constants in the argument list.
+               n := n.(*ir.AddStringExpr)
+               s := n.List
+               need := 0
+               for i := 0; i < len(s); i++ {
+                       if i == 0 || !ir.IsConst(s[i-1], constant.String) || !ir.IsConst(s[i], constant.String) {
+                               // Can't merge s[i] into s[i-1]; need a slot in the list.
+                               need++
+                       }
+               }
+               if need == len(s) {
+                       return n
+               }
+               if need == 1 {
+                       var strs []string
+                       for _, c := range s {
+                               strs = append(strs, ir.StringVal(c))
+                       }
+                       return OrigConst(n, constant.MakeString(strings.Join(strs, "")))
+               }
+               newList := make([]ir.Node, 0, need)
+               for i := 0; i < len(s); i++ {
+                       if ir.IsConst(s[i], constant.String) && i+1 < len(s) && ir.IsConst(s[i+1], constant.String) {
+                               // merge from i up to but not including i2
+                               var strs []string
+                               i2 := i
+                               for i2 < len(s) && ir.IsConst(s[i2], constant.String) {
+                                       strs = append(strs, ir.StringVal(s[i2]))
+                                       i2++
+                               }
+
+                               nl := ir.Copy(n).(*ir.AddStringExpr)
+                               nl.List = s[i:i2]
+                               newList = append(newList, OrigConst(nl, constant.MakeString(strings.Join(strs, ""))))
+                               i = i2 - 1
+                       } else {
+                               newList = append(newList, s[i])
+                       }
+               }
+
+               nn := ir.Copy(n).(*ir.AddStringExpr)
+               nn.List = newList
+               return nn
+
+       case ir.OCAP, ir.OLEN:
+               n := n.(*ir.UnaryExpr)
+               nl := n.X
+               switch nl.Type().Kind() {
+               case types.TSTRING:
+                       if ir.IsConst(nl, constant.String) {
+                               return OrigInt(n, int64(len(ir.StringVal(nl))))
+                       }
+               case types.TARRAY:
+                       if !anyCallOrChan(nl) {
+                               return OrigInt(n, nl.Type().NumElem())
+                       }
+               }
+
+       case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+               n := n.(*ir.UnaryExpr)
+               return OrigInt(n, evalunsafe(n))
+
+       case ir.OREAL:
+               n := n.(*ir.UnaryExpr)
+               nl := n.X
+               if nl.Op() == ir.OLITERAL {
+                       return OrigConst(n, constant.Real(nl.Val()))
+               }
+
+       case ir.OIMAG:
+               n := n.(*ir.UnaryExpr)
+               nl := n.X
+               if nl.Op() == ir.OLITERAL {
+                       return OrigConst(n, constant.Imag(nl.Val()))
+               }
+
+       case ir.OCOMPLEX:
+               n := n.(*ir.BinaryExpr)
+               nl, nr := n.X, n.Y
+               if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+                       return OrigConst(n, makeComplex(nl.Val(), nr.Val()))
+               }
+       }
+
+       return n
+}
+
+func makeFloat64(f float64) constant.Value {
+       if math.IsInf(f, 0) {
+               base.Fatalf("infinity is not a valid constant")
+       }
+       return constant.MakeFloat64(f)
+}
+
+func makeComplex(real, imag constant.Value) constant.Value {
+       return constant.BinaryOp(constant.ToFloat(real), token.ADD, constant.MakeImag(constant.ToFloat(imag)))
+}
+
+func square(x constant.Value) constant.Value {
+       return constant.BinaryOp(x, token.MUL, x)
+}
+
+// For matching historical "constant OP overflow" error messages.
+// TODO(mdempsky): Replace with error messages like go/types uses.
+var overflowNames = [...]string{
+       ir.OADD:    "addition",
+       ir.OSUB:    "subtraction",
+       ir.OMUL:    "multiplication",
+       ir.OLSH:    "shift",
+       ir.OXOR:    "bitwise XOR",
+       ir.OBITNOT: "bitwise complement",
+}
+
+// OrigConst returns an OLITERAL with orig n and value v.
+func OrigConst(n ir.Node, v constant.Value) ir.Node {
+       lno := ir.SetPos(n)
+       v = convertVal(v, n.Type(), false)
+       base.Pos = lno
+
+       switch v.Kind() {
+       case constant.Int:
+               if constant.BitLen(v) <= ir.ConstPrec {
+                       break
+               }
+               fallthrough
+       case constant.Unknown:
+               what := overflowNames[n.Op()]
+               if what == "" {
+                       base.Fatalf("unexpected overflow: %v", n.Op())
+               }
+               base.ErrorfAt(n.Pos(), "constant %v overflow", what)
+               n.SetType(nil)
+               return n
+       }
+
+       return ir.NewConstExpr(v, n)
+}
+
+func OrigBool(n ir.Node, v bool) ir.Node {
+       return OrigConst(n, constant.MakeBool(v))
+}
+
+func OrigInt(n ir.Node, v int64) ir.Node {
+       return OrigConst(n, constant.MakeInt64(v))
+}
+
+// DefaultLit on both nodes simultaneously;
+// if they're both ideal going in they better
+// get the same type going out.
+// force means must assign concrete (non-ideal) type.
+// The results of defaultlit2 MUST be assigned back to l and r, e.g.
+//     n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
+func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
+       if l.Type() == nil || r.Type() == nil {
+               return l, r
+       }
+       if !l.Type().IsUntyped() {
+               r = convlit(r, l.Type())
+               return l, r
+       }
+
+       if !r.Type().IsUntyped() {
+               l = convlit(l, r.Type())
+               return l, r
+       }
+
+       if !force {
+               return l, r
+       }
+
+       // Can't mix bool with non-bool, string with non-string, or nil with anything (untyped).
+       if l.Type().IsBoolean() != r.Type().IsBoolean() {
+               return l, r
+       }
+       if l.Type().IsString() != r.Type().IsString() {
+               return l, r
+       }
+       if ir.IsNil(l) || ir.IsNil(r) {
+               return l, r
+       }
+
+       t := defaultType(mixUntyped(l.Type(), r.Type()))
+       l = convlit(l, t)
+       r = convlit(r, t)
+       return l, r
+}
+
+func mixUntyped(t1, t2 *types.Type) *types.Type {
+       if t1 == t2 {
+               return t1
+       }
+
+       rank := func(t *types.Type) int {
+               switch t {
+               case types.UntypedInt:
+                       return 0
+               case types.UntypedRune:
+                       return 1
+               case types.UntypedFloat:
+                       return 2
+               case types.UntypedComplex:
+                       return 3
+               }
+               base.Fatalf("bad type %v", t)
+               panic("unreachable")
+       }
+
+       if rank(t2) > rank(t1) {
+               return t2
+       }
+       return t1
+}
+
+func defaultType(t *types.Type) *types.Type {
+       if !t.IsUntyped() || t.Kind() == types.TNIL {
+               return t
+       }
+
+       switch t {
+       case types.UntypedBool:
+               return types.Types[types.TBOOL]
+       case types.UntypedString:
+               return types.Types[types.TSTRING]
+       case types.UntypedInt:
+               return types.Types[types.TINT]
+       case types.UntypedRune:
+               return types.RuneType
+       case types.UntypedFloat:
+               return types.Types[types.TFLOAT64]
+       case types.UntypedComplex:
+               return types.Types[types.TCOMPLEX128]
+       }
+
+       base.Fatalf("bad type %v", t)
+       return nil
+}
+
+// IndexConst checks if Node n contains a constant expression
+// representable as a non-negative int and returns its value.
+// If n is not a constant expression, not representable as an
+// integer, or negative, it returns -1. If n is too large, it
+// returns -2.
+func IndexConst(n ir.Node) int64 {
+       if n.Op() != ir.OLITERAL {
+               return -1
+       }
+       if !n.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+               return -1
+       }
+
+       v := toint(n.Val())
+       if v.Kind() != constant.Int || constant.Sign(v) < 0 {
+               return -1
+       }
+       if ir.ConstOverflow(v, types.Types[types.TINT]) {
+               return -2
+       }
+       return ir.IntVal(types.Types[types.TINT], v)
+}
+
+// anyCallOrChan reports whether n contains any calls or channel operations.
+func anyCallOrChan(n ir.Node) bool {
+       return ir.Any(n, func(n ir.Node) bool {
+               switch n.Op() {
+               case ir.OAPPEND,
+                       ir.OCALL,
+                       ir.OCALLFUNC,
+                       ir.OCALLINTER,
+                       ir.OCALLMETH,
+                       ir.OCAP,
+                       ir.OCLOSE,
+                       ir.OCOMPLEX,
+                       ir.OCOPY,
+                       ir.ODELETE,
+                       ir.OIMAG,
+                       ir.OLEN,
+                       ir.OMAKE,
+                       ir.ONEW,
+                       ir.OPANIC,
+                       ir.OPRINT,
+                       ir.OPRINTN,
+                       ir.OREAL,
+                       ir.ORECOVER,
+                       ir.ORECV:
+                       return true
+               }
+               return false
+       })
+}
+
+// A constSet represents a set of Go constant expressions.
+type constSet struct {
+       m map[constSetKey]src.XPos
+}
+
+type constSetKey struct {
+       typ *types.Type
+       val interface{}
+}
+
+// add adds constant expression n to s. If a constant expression of
+// equal value and identical type has already been added, then add
+// reports an error about the duplicate value.
+//
+// pos provides position information for where expression n occurred
+// (in case n does not have its own position information). what and
+// where are used in the error message.
+//
+// n must not be an untyped constant.
+func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
+       if conv := n; conv.Op() == ir.OCONVIFACE {
+               conv := conv.(*ir.ConvExpr)
+               if conv.Implicit() {
+                       n = conv.X
+               }
+       }
+
+       if !ir.IsConstNode(n) {
+               return
+       }
+       if n.Type().IsUntyped() {
+               base.Fatalf("%v is untyped", n)
+       }
+
+       // Consts are only duplicates if they have the same value and
+       // identical types.
+       //
+       // In general, we have to use types.Identical to test type
+       // identity, because == gives false negatives for anonymous
+       // types and the byte/uint8 and rune/int32 builtin type
+       // aliases.  However, this is not a problem here, because
+       // constant expressions are always untyped or have a named
+       // type, and we explicitly handle the builtin type aliases
+       // below.
+       //
+       // This approach may need to be revisited though if we fix
+       // #21866 by treating all type aliases like byte/uint8 and
+       // rune/int32.
+
+       typ := n.Type()
+       switch typ {
+       case types.ByteType:
+               typ = types.Types[types.TUINT8]
+       case types.RuneType:
+               typ = types.Types[types.TINT32]
+       }
+       k := constSetKey{typ, ir.ConstValue(n)}
+
+       if ir.HasUniquePos(n) {
+               pos = n.Pos()
+       }
+
+       if s.m == nil {
+               s.m = make(map[constSetKey]src.XPos)
+       }
+
+       if prevPos, isDup := s.m[k]; isDup {
+               base.ErrorfAt(pos, "duplicate %s %s in %s\n\tprevious %s at %v",
+                       what, nodeAndVal(n), where,
+                       what, base.FmtPos(prevPos))
+       } else {
+               s.m[k] = pos
+       }
+}
+
+// nodeAndVal reports both an expression and its constant value, if
+// the latter is non-obvious.
+//
+// TODO(mdempsky): This could probably be a fmt.go flag.
+func nodeAndVal(n ir.Node) string {
+       show := fmt.Sprint(n)
+       val := ir.ConstValue(n)
+       if s := fmt.Sprintf("%#v", val); show != s {
+               show += " (value " + s + ")"
+       }
+       return show
+}
+
+// evalunsafe evaluates a package unsafe operation and returns the result.
+func evalunsafe(n ir.Node) int64 {
+       switch n.Op() {
+       case ir.OALIGNOF, ir.OSIZEOF:
+               n := n.(*ir.UnaryExpr)
+               n.X = Expr(n.X)
+               n.X = DefaultLit(n.X, nil)
+               tr := n.X.Type()
+               if tr == nil {
+                       return 0
+               }
+               types.CalcSize(tr)
+               if n.Op() == ir.OALIGNOF {
+                       return int64(tr.Align)
+               }
+               return tr.Width
+
+       case ir.OOFFSETOF:
+               // must be a selector.
+               n := n.(*ir.UnaryExpr)
+               if n.X.Op() != ir.OXDOT {
+                       base.Errorf("invalid expression %v", n)
+                       return 0
+               }
+               sel := n.X.(*ir.SelectorExpr)
+
+               // Remember base of selector to find it back after dot insertion.
+               // Since r->left may be mutated by typechecking, check it explicitly
+               // first to track it correctly.
+               sel.X = Expr(sel.X)
+               sbase := sel.X
+
+               tsel := Expr(sel)
+               n.X = tsel
+               if tsel.Type() == nil {
+                       return 0
+               }
+               switch tsel.Op() {
+               case ir.ODOT, ir.ODOTPTR:
+                       break
+               case ir.OCALLPART:
+                       base.Errorf("invalid expression %v: argument is a method value", n)
+                       return 0
+               default:
+                       base.Errorf("invalid expression %v", n)
+                       return 0
+               }
+
+               // Sum offsets for dots until we reach sbase.
+               var v int64
+               var next ir.Node
+               for r := tsel; r != sbase; r = next {
+                       switch r.Op() {
+                       case ir.ODOTPTR:
+                               // For Offsetof(s.f), s may itself be a pointer,
+                               // but accessing f must not otherwise involve
+                               // indirection via embedded pointer types.
+                               r := r.(*ir.SelectorExpr)
+                               if r.X != sbase {
+                                       base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.X)
+                                       return 0
+                               }
+                               fallthrough
+                       case ir.ODOT:
+                               r := r.(*ir.SelectorExpr)
+                               v += r.Offset()
+                               next = r.X
+                       default:
+                               ir.Dump("unsafenmagic", tsel)
+                               base.Fatalf("impossible %v node after dot insertion", r.Op())
+                       }
+               }
+               return v
+       }
+
+       base.Fatalf("unexpected op %v", n.Op())
+       return 0
+}

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
new file mode 100644 (file)
index 0000000..eab0bb0
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -0,0 +1,474 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "fmt"
+       "strconv"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+var DeclContext ir.Class = ir.PEXTERN // PEXTERN/PAUTO
+
+func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
+       if tfn.Op() != ir.OTFUNC {
+               base.Fatalf("expected OTFUNC node, got %v", tfn)
+       }
+
+       fn := ir.NewFunc(base.Pos)
+       fn.Nname = ir.NewNameAt(base.Pos, sym)
+       fn.Nname.Func = fn
+       fn.Nname.Defn = fn
+       fn.Nname.Ntype = tfn
+       ir.MarkFunc(fn.Nname)
+       StartFuncBody(fn)
+       fn.Nname.Ntype = typecheckNtype(fn.Nname.Ntype)
+       return fn
+}
+
+// Declare records that Node n declares symbol n.Sym in the specified
+// declaration context.
+func Declare(n *ir.Name, ctxt ir.Class) {
+       if ir.IsBlank(n) {
+               return
+       }
+
+       s := n.Sym()
+
+       // kludgy: TypecheckAllowed means we're past parsing. Eg reflectdata.methodWrapper may declare out of package names later.
+       if !inimport && !TypecheckAllowed && s.Pkg != types.LocalPkg {
+               base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
+       }
+
+       if ctxt == ir.PEXTERN {
+               if s.Name == "init" {
+                       base.ErrorfAt(n.Pos(), "cannot declare init - must be func")
+               }
+               if s.Name == "main" && s.Pkg.Name == "main" {
+                       base.ErrorfAt(n.Pos(), "cannot declare main - must be func")
+               }
+               Target.Externs = append(Target.Externs, n)
+       } else {
+               if ir.CurFunc == nil && ctxt == ir.PAUTO {
+                       base.Pos = n.Pos()
+                       base.Fatalf("automatic outside function")
+               }
+               if ir.CurFunc != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
+                       ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
+               }
+               types.Pushdcl(s)
+               n.Curfn = ir.CurFunc
+       }
+
+       if ctxt == ir.PAUTO {
+               n.SetFrameOffset(0)
+       }
+
+       if s.Block == types.Block {
+               // functype will print errors about duplicate function arguments.
+               // Don't repeat the error here.
+               if ctxt != ir.PPARAM && ctxt != ir.PPARAMOUT {
+                       Redeclared(n.Pos(), s, "in this block")
+               }
+       }
+
+       s.Block = types.Block
+       s.Lastlineno = base.Pos
+       s.Def = n
+       n.Class = ctxt
+       if ctxt == ir.PFUNC {
+               n.Sym().SetFunc(true)
+       }
+
+       autoexport(n, ctxt)
+}
+
+// Export marks n for export (or reexport).
+func Export(n *ir.Name) {
+       if n.Sym().OnExportList() {
+               return
+       }
+       n.Sym().SetOnExportList(true)
+
+       if base.Flag.E != 0 {
+               fmt.Printf("export symbol %v\n", n.Sym())
+       }
+
+       Target.Exports = append(Target.Exports, n)
+}
+
+// Redeclared emits a diagnostic about symbol s being redeclared at pos.
+func Redeclared(pos src.XPos, s *types.Sym, where string) {
+       if !s.Lastlineno.IsKnown() {
+               pkgName := DotImportRefs[s.Def.(*ir.Ident)]
+               base.ErrorfAt(pos, "%v redeclared %s\n"+
+                       "\t%v: previous declaration during import %q", s, where, base.FmtPos(pkgName.Pos()), pkgName.Pkg.Path)
+       } else {
+               prevPos := s.Lastlineno
+
+               // When an import and a declaration collide in separate files,
+               // present the import as the "redeclared", because the declaration
+               // is visible where the import is, but not vice versa.
+               // See issue 4510.
+               if s.Def == nil {
+                       pos, prevPos = prevPos, pos
+               }
+
+               base.ErrorfAt(pos, "%v redeclared %s\n"+
+                       "\t%v: previous declaration", s, where, base.FmtPos(prevPos))
+       }
+}
+
+// declare the function proper
+// and declare the arguments.
+// called in extern-declaration context
+// returns in auto-declaration context.
+func StartFuncBody(fn *ir.Func) {
+       // change the declaration context from extern to auto
+       funcStack = append(funcStack, funcStackEnt{ir.CurFunc, DeclContext})
+       ir.CurFunc = fn
+       DeclContext = ir.PAUTO
+
+       types.Markdcl()
+
+       if fn.Nname.Ntype != nil {
+               funcargs(fn.Nname.Ntype.(*ir.FuncType))
+       } else {
+               funcargs2(fn.Type())
+       }
+}
+
+// finish the body.
+// called in auto-declaration context.
+// returns in extern-declaration context.
+func FinishFuncBody() {
+       // change the declaration context from auto to previous context
+       types.Popdcl()
+       var e funcStackEnt
+       funcStack, e = funcStack[:len(funcStack)-1], funcStack[len(funcStack)-1]
+       ir.CurFunc, DeclContext = e.curfn, e.dclcontext
+}
+
+func CheckFuncStack() {
+       if len(funcStack) != 0 {
+               base.Fatalf("funcStack is non-empty: %v", len(funcStack))
+       }
+}
+
+// Add a method, declared as a function.
+// - msym is the method symbol
+// - t is function type (with receiver)
+// Returns a pointer to the existing or added Field; or nil if there's an error.
+func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+       if msym == nil {
+               base.Fatalf("no method symbol")
+       }
+
+       // get parent type sym
+       rf := t.Recv() // ptr to this structure
+       if rf == nil {
+               base.Errorf("missing receiver")
+               return nil
+       }
+
+       mt := types.ReceiverBaseType(rf.Type)
+       if mt == nil || mt.Sym() == nil {
+               pa := rf.Type
+               t := pa
+               if t != nil && t.IsPtr() {
+                       if t.Sym() != nil {
+                               base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
+                               return nil
+                       }
+                       t = t.Elem()
+               }
+
+               switch {
+               case t == nil || t.Broke():
+                       // rely on typecheck having complained before
+               case t.Sym() == nil:
+                       base.Errorf("invalid receiver type %v (%v is not a defined type)", pa, t)
+               case t.IsPtr():
+                       base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
+               case t.IsInterface():
+                       base.Errorf("invalid receiver type %v (%v is an interface type)", pa, t)
+               default:
+                       // Should have picked off all the reasons above,
+                       // but just in case, fall back to generic error.
+                       base.Errorf("invalid receiver type %v (%L / %L)", pa, pa, t)
+               }
+               return nil
+       }
+
+       if local && mt.Sym().Pkg != types.LocalPkg {
+               base.Errorf("cannot define new methods on non-local type %v", mt)
+               return nil
+       }
+
+       if msym.IsBlank() {
+               return nil
+       }
+
+       if mt.IsStruct() {
+               for _, f := range mt.Fields().Slice() {
+                       if f.Sym == msym {
+                               base.Errorf("type %v has both field and method named %v", mt, msym)
+                               f.SetBroke(true)
+                               return nil
+                       }
+               }
+       }
+
+       for _, f := range mt.Methods().Slice() {
+               if msym.Name != f.Sym.Name {
+                       continue
+               }
+               // types.Identical only checks that incoming and result parameters match,
+               // so explicitly check that the receiver parameters match too.
+               if !types.Identical(t, f.Type) || !types.Identical(t.Recv().Type, f.Type.Recv().Type) {
+                       base.Errorf("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
+               }
+               return f
+       }
+
+       f := types.NewField(base.Pos, msym, t)
+       f.Nname = n.Nname
+       f.SetNointerface(nointerface)
+
+       mt.Methods().Append(f)
+       return f
+}
+
+func autoexport(n *ir.Name, ctxt ir.Class) {
+       if n.Sym().Pkg != types.LocalPkg {
+               return
+       }
+       if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || DeclContext != ir.PEXTERN {
+               return
+       }
+       if n.Type() != nil && n.Type().IsKind(types.TFUNC) && ir.IsMethod(n) {
+               return
+       }
+
+       if types.IsExported(n.Sym().Name) || n.Sym().Name == "init" {
+               Export(n)
+       }
+       if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
+               n.Sym().SetAsm(true)
+               Target.Asms = append(Target.Asms, n)
+       }
+}
+
+// checkdupfields emits errors for duplicately named fields or methods in
+// a list of struct or interface types.
+func checkdupfields(what string, fss ...[]*types.Field) {
+       seen := make(map[*types.Sym]bool)
+       for _, fs := range fss {
+               for _, f := range fs {
+                       if f.Sym == nil || f.Sym.IsBlank() {
+                               continue
+                       }
+                       if seen[f.Sym] {
+                               base.ErrorfAt(f.Pos, "duplicate %s %s", what, f.Sym.Name)
+                               continue
+                       }
+                       seen[f.Sym] = true
+               }
+       }
+}
+
+// structs, functions, and methods.
+// they don't belong here, but where do they belong?
+func checkembeddedtype(t *types.Type) {
+       if t == nil {
+               return
+       }
+
+       if t.Sym() == nil && t.IsPtr() {
+               t = t.Elem()
+               if t.IsInterface() {
+                       base.Errorf("embedded type cannot be a pointer to interface")
+               }
+       }
+
+       if t.IsPtr() || t.IsUnsafePtr() {
+               base.Errorf("embedded type cannot be a pointer")
+       } else if t.Kind() == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
+               t.ForwardType().Embedlineno = base.Pos
+       }
+}
+
+// TODO(mdempsky): Move to package types.
+func FakeRecv() *types.Field {
+       return types.NewField(src.NoXPos, nil, types.FakeRecvType())
+}
+
+var fakeRecvField = FakeRecv
+
+var funcStack []funcStackEnt // stack of previous values of ir.CurFunc/DeclContext
+
+type funcStackEnt struct {
+       curfn      *ir.Func
+       dclcontext ir.Class
+}
+
+func funcarg(n *ir.Field, ctxt ir.Class) {
+       if n.Sym == nil {
+               return
+       }
+
+       name := ir.NewNameAt(n.Pos, n.Sym)
+       n.Decl = name
+       name.Ntype = n.Ntype
+       Declare(name, ctxt)
+}
+
+func funcarg2(f *types.Field, ctxt ir.Class) {
+       if f.Sym == nil {
+               return
+       }
+       n := ir.NewNameAt(f.Pos, f.Sym)
+       f.Nname = n
+       n.SetType(f.Type)
+       Declare(n, ctxt)
+}
+
+func funcargs(nt *ir.FuncType) {
+       if nt.Op() != ir.OTFUNC {
+               base.Fatalf("funcargs %v", nt.Op())
+       }
+
+       // declare the receiver and in arguments.
+       if nt.Recv != nil {
+               funcarg(nt.Recv, ir.PPARAM)
+       }
+       for _, n := range nt.Params {
+               funcarg(n, ir.PPARAM)
+       }
+
+       // declare the out arguments.
+       gen := len(nt.Params)
+       for _, n := range nt.Results {
+               if n.Sym == nil {
+                       // Name so that escape analysis can track it. ~r stands for 'result'.
+                       n.Sym = LookupNum("~r", gen)
+                       gen++
+               }
+               if n.Sym.IsBlank() {
+                       // Give it a name so we can assign to it during return. ~b stands for 'blank'.
+                       // The name must be different from ~r above because if you have
+                       //      func f() (_ int)
+                       //      func g() int
+                       // f is allowed to use a plain 'return' with no arguments, while g is not.
+                       // So the two cases must be distinguished.
+                       n.Sym = LookupNum("~b", gen)
+                       gen++
+               }
+
+               funcarg(n, ir.PPARAMOUT)
+       }
+}
+
+// Same as funcargs, except run over an already constructed TFUNC.
+// This happens during import, where the hidden_fndcl rule has
+// used functype directly to parse the function's type.
+func funcargs2(t *types.Type) {
+       if t.Kind() != types.TFUNC {
+               base.Fatalf("funcargs2 %v", t)
+       }
+
+       for _, f := range t.Recvs().Fields().Slice() {
+               funcarg2(f, ir.PPARAM)
+       }
+       for _, f := range t.Params().Fields().Slice() {
+               funcarg2(f, ir.PPARAM)
+       }
+       for _, f := range t.Results().Fields().Slice() {
+               funcarg2(f, ir.PPARAMOUT)
+       }
+}
+
+func Temp(t *types.Type) *ir.Name {
+       return TempAt(base.Pos, ir.CurFunc, t)
+}
+
+// make a new Node off the books
+func TempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
+       if curfn == nil {
+               base.Fatalf("no curfn for TempAt")
+       }
+       if curfn.Op() == ir.OCLOSURE {
+               ir.Dump("TempAt", curfn)
+               base.Fatalf("adding TempAt to wrong closure function")
+       }
+       if t == nil {
+               base.Fatalf("TempAt called with nil type")
+       }
+       if t.Kind() == types.TFUNC && t.Recv() != nil {
+               base.Fatalf("misuse of method type: %v", t)
+       }
+
+       s := &types.Sym{
+               Name: autotmpname(len(curfn.Dcl)),
+               Pkg:  types.LocalPkg,
+       }
+       n := ir.NewNameAt(pos, s)
+       s.Def = n
+       n.SetType(t)
+       n.Class = ir.PAUTO
+       n.SetEsc(ir.EscNever)
+       n.Curfn = curfn
+       n.SetUsed(true)
+       n.SetAutoTemp(true)
+       curfn.Dcl = append(curfn.Dcl, n)
+
+       types.CalcSize(t)
+
+       return n
+}
+
+// autotmpname returns the name for an autotmp variable numbered n.
+func autotmpname(n int) string {
+       // Give each tmp a different name so that they can be registerized.
+       // Add a preceding . to avoid clashing with legal names.
+       const prefix = ".autotmp_"
+       // Start with a buffer big enough to hold a large n.
+       b := []byte(prefix + "      ")[:len(prefix)]
+       b = strconv.AppendInt(b, int64(n), 10)
+       return types.InternString(b)
+}
+
+// f is method type, with receiver.
+// return function type, receiver as first argument (or not).
+func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
+       nrecvs := 0
+       if recv != nil {
+               nrecvs++
+       }
+
+       // TODO(mdempsky): Move this function to types.
+       // TODO(mdempsky): Preserve positions, names, and package from sig+recv.
+
+       params := make([]*types.Field, nrecvs+sig.Params().Fields().Len())
+       if recv != nil {
+               params[0] = types.NewField(base.Pos, nil, recv)
+       }
+       for i, param := range sig.Params().Fields().Slice() {
+               d := types.NewField(base.Pos, nil, param.Type)
+               d.SetIsDDD(param.IsDDD())
+               params[nrecvs+i] = d
+       }
+
+       results := make([]*types.Field, sig.Results().Fields().Len())
+       for i, t := range sig.Results().Fields().Slice() {
+               results[i] = types.NewField(base.Pos, nil, t.Type)
+       }
+
+       return types.NewSignature(types.LocalPkg, nil, params, results)
+}

diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
new file mode 100644 (file)
index 0000000..63d0a1e
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -0,0 +1,74 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// importalias declares symbol s as an imported type alias with type t.
+// ipkg is the package being imported
+func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       return importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
+}
+
+// importconst declares symbol s as an imported constant with type t and value val.
+// ipkg is the package being imported
+func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
+       n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
+       n.SetVal(val)
+       return n
+}
+
+// importfunc declares symbol s as an imported function with type t.
+// ipkg is the package being imported
+func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
+       n.Func = ir.NewFunc(pos)
+       n.Func.Nname = n
+       return n
+}
+
+// importobj declares symbol s as an imported object representable by op.
+// ipkg is the package being imported
+func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
+       n := importsym(ipkg, pos, s, op, ctxt)
+       n.SetType(t)
+       if ctxt == ir.PFUNC {
+               n.Sym().SetFunc(true)
+       }
+       return n
+}
+
+func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
+       if n := s.PkgDef(); n != nil {
+               base.Fatalf("importsym of symbol that already exists: %v", n)
+       }
+
+       n := ir.NewDeclNameAt(pos, op, s)
+       n.Class = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
+       s.SetPkgDef(n)
+       return n
+}
+
+// importtype returns the named type declared by symbol s.
+// If no such type has been declared yet, a forward declaration is returned.
+// ipkg is the package being imported
+func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *ir.Name {
+       n := importsym(ipkg, pos, s, ir.OTYPE, ir.PEXTERN)
+       n.SetType(types.NewNamed(n))
+       return n
+}
+
+// importvar declares symbol s as an imported variable with type t.
+// ipkg is the package being imported
+func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       return importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
+}

diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
new file mode 100644 (file)
index 0000000..339fb00
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -0,0 +1,877 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "fmt"
+       "go/constant"
+       "go/token"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+)
+
+// tcAddr typechecks an OADDR node.
+func tcAddr(n *ir.AddrExpr) ir.Node {
+       n.X = Expr(n.X)
+       if n.X.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       switch n.X.Op() {
+       case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
+               n.SetOp(ir.OPTRLIT)
+
+       default:
+               checklvalue(n.X, "take the address of")
+               r := ir.OuterValue(n.X)
+               if r.Op() == ir.ONAME {
+                       r := r.(*ir.Name)
+                       if ir.Orig(r) != r {
+                               base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
+                       }
+               }
+               n.X = DefaultLit(n.X, nil)
+               if n.X.Type() == nil {
+                       n.SetType(nil)
+                       return n
+               }
+       }
+
+       n.SetType(types.NewPtr(n.X.Type()))
+       return n
+}
+
+func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
+       if l.Type() == nil || l.Type() == nil {
+               return l, r, nil
+       }
+
+       r = DefaultLit(r, types.Types[types.TUINT])
+       t := r.Type()
+       if !t.IsInteger() {
+               base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
+               return l, r, nil
+       }
+       if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
+               base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
+               return l, r, nil
+       }
+       t = l.Type()
+       if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
+               base.Errorf("invalid operation: %v (shift of type %v)", n, t)
+               return l, r, nil
+       }
+
+       // no DefaultLit for left
+       // the outer context gives the type
+       t = l.Type()
+       if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
+               t = types.UntypedInt
+       }
+       return l, r, t
+}
+
+// tcArith typechecks operands of a binary arithmetic expression.
+// The result of tcArith MUST be assigned back to original operands,
+// t is the type of the expression, and should be set by the caller. e.g:
+//     n.X, n.Y, t = tcArith(n, op, n.X, n.Y)
+//     n.SetType(t)
+func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
+       l, r = defaultlit2(l, r, false)
+       if l.Type() == nil || r.Type() == nil {
+               return l, r, nil
+       }
+       t := l.Type()
+       if t.Kind() == types.TIDEAL {
+               t = r.Type()
+       }
+       aop := ir.OXXX
+       if iscmp[n.Op()] && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+               // comparison is okay as long as one side is
+               // assignable to the other.  convert so they have
+               // the same type.
+               //
+               // the only conversion that isn't a no-op is concrete == interface.
+               // in that case, check comparability of the concrete type.
+               // The conversion allocates, so only do it if the concrete type is huge.
+               converted := false
+               if r.Type().Kind() != types.TBLANK {
+                       aop, _ = assignop(l.Type(), r.Type())
+                       if aop != ir.OXXX {
+                               if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
+                                       base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
+                                       return l, r, nil
+                               }
+
+                               types.CalcSize(l.Type())
+                               if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
+                                       l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
+                                       l.SetTypecheck(1)
+                               }
+
+                               t = r.Type()
+                               converted = true
+                       }
+               }
+
+               if !converted && l.Type().Kind() != types.TBLANK {
+                       aop, _ = assignop(r.Type(), l.Type())
+                       if aop != ir.OXXX {
+                               if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
+                                       base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
+                                       return l, r, nil
+                               }
+
+                               types.CalcSize(r.Type())
+                               if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
+                                       r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
+                                       r.SetTypecheck(1)
+                               }
+
+                               t = l.Type()
+                       }
+               }
+       }
+
+       if t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+               l, r = defaultlit2(l, r, true)
+               if l.Type() == nil || r.Type() == nil {
+                       return l, r, nil
+               }
+               if l.Type().IsInterface() == r.Type().IsInterface() || aop == 0 {
+                       base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+                       return l, r, nil
+               }
+       }
+
+       if t.Kind() == types.TIDEAL {
+               t = mixUntyped(l.Type(), r.Type())
+       }
+       if dt := defaultType(t); !okfor[op][dt.Kind()] {
+               base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
+               return l, r, nil
+       }
+
+       // okfor allows any array == array, map == map, func == func.
+       // restrict to slice/map/func == nil and nil == slice/map/func.
+       if l.Type().IsArray() && !types.IsComparable(l.Type()) {
+               base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
+               return l, r, nil
+       }
+
+       if l.Type().IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
+               base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
+               return l, r, nil
+       }
+
+       if l.Type().IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
+               base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
+               return l, r, nil
+       }
+
+       if l.Type().Kind() == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
+               base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
+               return l, r, nil
+       }
+
+       if l.Type().IsStruct() {
+               if f := types.IncomparableField(l.Type()); f != nil {
+                       base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
+                       return l, r, nil
+               }
+       }
+
+       if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
+               if constant.Sign(r.Val()) == 0 {
+                       base.Errorf("division by zero")
+                       return l, r, nil
+               }
+       }
+
+       return l, r, t
+}
+
+// The result of tcCompLit MUST be assigned back to n, e.g.
+//     n.Left = tcCompLit(n.Left)
+func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("tcCompLit", n)(&res)
+       }
+
+       lno := base.Pos
+       defer func() {
+               base.Pos = lno
+       }()
+
+       if n.Ntype == nil {
+               base.ErrorfAt(n.Pos(), "missing type in composite literal")
+               n.SetType(nil)
+               return n
+       }
+
+       // Save original node (including n.Right)
+       n.SetOrig(ir.Copy(n))
+
+       ir.SetPos(n.Ntype)
+
+       // Need to handle [...]T arrays specially.
+       if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
+               array.Elem = typecheckNtype(array.Elem)
+               elemType := array.Elem.Type()
+               if elemType == nil {
+                       n.SetType(nil)
+                       return n
+               }
+               length := typecheckarraylit(elemType, -1, n.List, "array literal")
+               n.SetOp(ir.OARRAYLIT)
+               n.SetType(types.NewArray(elemType, length))
+               n.Ntype = nil
+               return n
+       }
+
+       n.Ntype = typecheckNtype(n.Ntype)
+       t := n.Ntype.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       n.SetType(t)
+
+       switch t.Kind() {
+       default:
+               base.Errorf("invalid composite literal type %v", t)
+               n.SetType(nil)
+
+       case types.TARRAY:
+               typecheckarraylit(t.Elem(), t.NumElem(), n.List, "array literal")
+               n.SetOp(ir.OARRAYLIT)
+               n.Ntype = nil
+
+       case types.TSLICE:
+               length := typecheckarraylit(t.Elem(), -1, n.List, "slice literal")
+               n.SetOp(ir.OSLICELIT)
+               n.Ntype = nil
+               n.Len = length
+
+       case types.TMAP:
+               var cs constSet
+               for i3, l := range n.List {
+                       ir.SetPos(l)
+                       if l.Op() != ir.OKEY {
+                               n.List[i3] = Expr(l)
+                               base.Errorf("missing key in map literal")
+                               continue
+                       }
+                       l := l.(*ir.KeyExpr)
+
+                       r := l.Key
+                       r = pushtype(r, t.Key())
+                       r = Expr(r)
+                       l.Key = AssignConv(r, t.Key(), "map key")
+                       cs.add(base.Pos, l.Key, "key", "map literal")
+
+                       r = l.Value
+                       r = pushtype(r, t.Elem())
+                       r = Expr(r)
+                       l.Value = AssignConv(r, t.Elem(), "map value")
+               }
+
+               n.SetOp(ir.OMAPLIT)
+               n.Ntype = nil
+
+       case types.TSTRUCT:
+               // Need valid field offsets for Xoffset below.
+               types.CalcSize(t)
+
+               errored := false
+               if len(n.List) != 0 && nokeys(n.List) {
+                       // simple list of variables
+                       ls := n.List
+                       for i, n1 := range ls {
+                               ir.SetPos(n1)
+                               n1 = Expr(n1)
+                               ls[i] = n1
+                               if i >= t.NumFields() {
+                                       if !errored {
+                                               base.Errorf("too many values in %v", n)
+                                               errored = true
+                                       }
+                                       continue
+                               }
+
+                               f := t.Field(i)
+                               s := f.Sym
+                               if s != nil && !types.IsExported(s.Name) && s.Pkg != types.LocalPkg {
+                                       base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
+                               }
+                               // No pushtype allowed here. Must name fields for that.
+                               n1 = AssignConv(n1, f.Type, "field value")
+                               sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
+                               sk.Offset = f.Offset
+                               ls[i] = sk
+                       }
+                       if len(ls) < t.NumFields() {
+                               base.Errorf("too few values in %v", n)
+                       }
+               } else {
+                       hash := make(map[string]bool)
+
+                       // keyed list
+                       ls := n.List
+                       for i, l := range ls {
+                               ir.SetPos(l)
+
+                               if l.Op() == ir.OKEY {
+                                       kv := l.(*ir.KeyExpr)
+                                       key := kv.Key
+
+                                       // Sym might have resolved to name in other top-level
+                                       // package, because of import dot. Redirect to correct sym
+                                       // before we do the lookup.
+                                       s := key.Sym()
+                                       if id, ok := key.(*ir.Ident); ok && DotImportRefs[id] != nil {
+                                               s = Lookup(s.Name)
+                                       }
+
+                                       // An OXDOT uses the Sym field to hold
+                                       // the field to the right of the dot,
+                                       // so s will be non-nil, but an OXDOT
+                                       // is never a valid struct literal key.
+                                       if s == nil || s.Pkg != types.LocalPkg || key.Op() == ir.OXDOT || s.IsBlank() {
+                                               base.Errorf("invalid field name %v in struct initializer", key)
+                                               continue
+                                       }
+
+                                       l = ir.NewStructKeyExpr(l.Pos(), s, kv.Value)
+                                       ls[i] = l
+                               }
+
+                               if l.Op() != ir.OSTRUCTKEY {
+                                       if !errored {
+                                               base.Errorf("mixture of field:value and value initializers")
+                                               errored = true
+                                       }
+                                       ls[i] = Expr(ls[i])
+                                       continue
+                               }
+                               l := l.(*ir.StructKeyExpr)
+
+                               f := lookdot1(nil, l.Field, t, t.Fields(), 0)
+                               if f == nil {
+                                       if ci := lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
+                                               if visible(ci.Sym) {
+                                                       base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Field, t, ci.Sym)
+                                               } else if nonexported(l.Field) && l.Field.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
+                                                       base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Field, t)
+                                               } else {
+                                                       base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
+                                               }
+                                               continue
+                                       }
+                                       var f *types.Field
+                                       p, _ := dotpath(l.Field, t, &f, true)
+                                       if p == nil || f.IsMethod() {
+                                               base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
+                                               continue
+                                       }
+                                       // dotpath returns the parent embedded types in reverse order.
+                                       var ep []string
+                                       for ei := len(p) - 1; ei >= 0; ei-- {
+                                               ep = append(ep, p[ei].field.Sym.Name)
+                                       }
+                                       ep = append(ep, l.Field.Name)
+                                       base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
+                                       continue
+                               }
+                               fielddup(f.Sym.Name, hash)
+                               l.Offset = f.Offset
+
+                               // No pushtype allowed here. Tried and rejected.
+                               l.Value = Expr(l.Value)
+                               l.Value = AssignConv(l.Value, f.Type, "field value")
+                       }
+               }
+
+               n.SetOp(ir.OSTRUCTLIT)
+               n.Ntype = nil
+       }
+
+       return n
+}
+
+// tcConv typechecks an OCONV node.
+func tcConv(n *ir.ConvExpr) ir.Node {
+       types.CheckSize(n.Type()) // ensure width is calculated for backend
+       n.X = Expr(n.X)
+       n.X = convlit1(n.X, n.Type(), true, nil)
+       t := n.X.Type()
+       if t == nil || n.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       op, why := convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
+       if op == ir.OXXX {
+               if !n.Diag() && !n.Type().Broke() && !n.X.Diag() {
+                       base.Errorf("cannot convert %L to type %v%s", n.X, n.Type(), why)
+                       n.SetDiag(true)
+               }
+               n.SetOp(ir.OCONV)
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetOp(op)
+       switch n.Op() {
+       case ir.OCONVNOP:
+               if t.Kind() == n.Type().Kind() {
+                       switch t.Kind() {
+                       case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
+                               // Floating point casts imply rounding and
+                               // so the conversion must be kept.
+                               n.SetOp(ir.OCONV)
+                       }
+               }
+
+       // do not convert to []byte literal. See CL 125796.
+       // generated code and compiler memory footprint is better without it.
+       case ir.OSTR2BYTES:
+               // ok
+
+       case ir.OSTR2RUNES:
+               if n.X.Op() == ir.OLITERAL {
+                       return stringtoruneslit(n)
+               }
+       }
+       return n
+}
+
+// tcDot typechecks an OXDOT or ODOT node.
+func tcDot(n *ir.SelectorExpr, top int) ir.Node {
+       if n.Op() == ir.OXDOT {
+               n = AddImplicitDots(n)
+               n.SetOp(ir.ODOT)
+               if n.X == nil {
+                       n.SetType(nil)
+                       return n
+               }
+       }
+
+       n.X = typecheck(n.X, ctxExpr|ctxType)
+       n.X = DefaultLit(n.X, nil)
+
+       t := n.X.Type()
+       if t == nil {
+               base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.X), fmt.Sprint(n))
+               n.SetType(nil)
+               return n
+       }
+
+       if n.X.Op() == ir.OTYPE {
+               return typecheckMethodExpr(n)
+       }
+
+       if t.IsPtr() && !t.Elem().IsInterface() {
+               t = t.Elem()
+               if t == nil {
+                       n.SetType(nil)
+                       return n
+               }
+               n.SetOp(ir.ODOTPTR)
+               types.CheckSize(t)
+       }
+
+       if n.Sel.IsBlank() {
+               base.Errorf("cannot refer to blank field or method")
+               n.SetType(nil)
+               return n
+       }
+
+       if lookdot(n, t, 0) == nil {
+               // Legitimate field or method lookup failed, try to explain the error
+               switch {
+               case t.IsEmptyInterface():
+                       base.Errorf("%v undefined (type %v is interface with no methods)", n, n.X.Type())
+
+               case t.IsPtr() && t.Elem().IsInterface():
+                       // Pointer to interface is almost always a mistake.
+                       base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.X.Type())
+
+               case lookdot(n, t, 1) != nil:
+                       // Field or method matches by name, but it is not exported.
+                       base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sel)
+
+               default:
+                       if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
+                               base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.X.Type(), n.Sel, mt.Sym)
+                       } else {
+                               base.Errorf("%v undefined (type %v has no field or method %v)", n, n.X.Type(), n.Sel)
+                       }
+               }
+               n.SetType(nil)
+               return n
+       }
+
+       if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
+               n.SetOp(ir.OCALLPART)
+               n.SetType(MethodValueWrapper(n).Type())
+       }
+       return n
+}
+
+// tcDotType typechecks an ODOTTYPE node.
+func tcDotType(n *ir.TypeAssertExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !t.IsInterface() {
+               base.Errorf("invalid type assertion: %v (non-interface type %v on left)", n, t)
+               n.SetType(nil)
+               return n
+       }
+
+       if n.Ntype != nil {
+               n.Ntype = typecheckNtype(n.Ntype)
+               n.SetType(n.Ntype.Type())
+               n.Ntype = nil
+               if n.Type() == nil {
+                       return n
+               }
+       }
+
+       if n.Type() != nil && !n.Type().IsInterface() {
+               var missing, have *types.Field
+               var ptr int
+               if !implements(n.Type(), t, &missing, &have, &ptr) {
+                       if have != nil && have.Sym == missing.Sym {
+                               base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
+                                       "\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+                       } else if ptr != 0 {
+                               base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type(), t, missing.Sym)
+                       } else if have != nil {
+                               base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
+                                       "\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+                       } else {
+                               base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type(), t, missing.Sym)
+                       }
+                       n.SetType(nil)
+                       return n
+               }
+       }
+       return n
+}
+
+// tcITab typechecks an OITAB node.
+func tcITab(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       t := n.X.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !t.IsInterface() {
+               base.Fatalf("OITAB of %v", t)
+       }
+       n.SetType(types.NewPtr(types.Types[types.TUINTPTR]))
+       return n
+}
+
+// tcIndex typechecks an OINDEX node.
+func tcIndex(n *ir.IndexExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       n.X = implicitstar(n.X)
+       l := n.X
+       n.Index = Expr(n.Index)
+       r := n.Index
+       t := l.Type()
+       if t == nil || r.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       switch t.Kind() {
+       default:
+               base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
+               n.SetType(nil)
+               return n
+
+       case types.TSTRING, types.TARRAY, types.TSLICE:
+               n.Index = indexlit(n.Index)
+               if t.IsString() {
+                       n.SetType(types.ByteType)
+               } else {
+                       n.SetType(t.Elem())
+               }
+               why := "string"
+               if t.IsArray() {
+                       why = "array"
+               } else if t.IsSlice() {
+                       why = "slice"
+               }
+
+               if n.Index.Type() != nil && !n.Index.Type().IsInteger() {
+                       base.Errorf("non-integer %s index %v", why, n.Index)
+                       return n
+               }
+
+               if !n.Bounded() && ir.IsConst(n.Index, constant.Int) {
+                       x := n.Index.Val()
+                       if constant.Sign(x) < 0 {
+                               base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Index)
+                       } else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
+                               base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
+                       } else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
+                               base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
+                       } else if ir.ConstOverflow(x, types.Types[types.TINT]) {
+                               base.Errorf("invalid %s index %v (index too large)", why, n.Index)
+                       }
+               }
+
+       case types.TMAP:
+               n.Index = AssignConv(n.Index, t.Key(), "map index")
+               n.SetType(t.Elem())
+               n.SetOp(ir.OINDEXMAP)
+               n.Assigned = false
+       }
+       return n
+}
+
+// tcLenCap typechecks an OLEN or OCAP node.
+func tcLenCap(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       n.X = implicitstar(n.X)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       var ok bool
+       if n.Op() == ir.OLEN {
+               ok = okforlen[t.Kind()]
+       } else {
+               ok = okforcap[t.Kind()]
+       }
+       if !ok {
+               base.Errorf("invalid argument %L for %v", l, n.Op())
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetType(types.Types[types.TINT])
+       return n
+}
+
+// tcRecv typechecks an ORECV node.
+func tcRecv(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !t.IsChan() {
+               base.Errorf("invalid operation: %v (receive from non-chan type %v)", n, t)
+               n.SetType(nil)
+               return n
+       }
+
+       if !t.ChanDir().CanRecv() {
+               base.Errorf("invalid operation: %v (receive from send-only type %v)", n, t)
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetType(t.Elem())
+       return n
+}
+
+// tcSPtr typechecks an OSPTR node.
+func tcSPtr(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       t := n.X.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !t.IsSlice() && !t.IsString() {
+               base.Fatalf("OSPTR of %v", t)
+       }
+       if t.IsString() {
+               n.SetType(types.NewPtr(types.Types[types.TUINT8]))
+       } else {
+               n.SetType(types.NewPtr(t.Elem()))
+       }
+       return n
+}
+
+// tcSlice typechecks an OSLICE or OSLICE3 node.
+func tcSlice(n *ir.SliceExpr) ir.Node {
+       n.X = DefaultLit(Expr(n.X), nil)
+       n.Low = indexlit(Expr(n.Low))
+       n.High = indexlit(Expr(n.High))
+       n.Max = indexlit(Expr(n.Max))
+       hasmax := n.Op().IsSlice3()
+       l := n.X
+       if l.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       if l.Type().IsArray() {
+               if !ir.IsAddressable(n.X) {
+                       base.Errorf("invalid operation %v (slice of unaddressable value)", n)
+                       n.SetType(nil)
+                       return n
+               }
+
+               addr := NodAddr(n.X)
+               addr.SetImplicit(true)
+               n.X = Expr(addr)
+               l = n.X
+       }
+       t := l.Type()
+       var tp *types.Type
+       if t.IsString() {
+               if hasmax {
+                       base.Errorf("invalid operation %v (3-index slice of string)", n)
+                       n.SetType(nil)
+                       return n
+               }
+               n.SetType(t)
+               n.SetOp(ir.OSLICESTR)
+       } else if t.IsPtr() && t.Elem().IsArray() {
+               tp = t.Elem()
+               n.SetType(types.NewSlice(tp.Elem()))
+               types.CalcSize(n.Type())
+               if hasmax {
+                       n.SetOp(ir.OSLICE3ARR)
+               } else {
+                       n.SetOp(ir.OSLICEARR)
+               }
+       } else if t.IsSlice() {
+               n.SetType(t)
+       } else {
+               base.Errorf("cannot slice %v (type %v)", l, t)
+               n.SetType(nil)
+               return n
+       }
+
+       if n.Low != nil && !checksliceindex(l, n.Low, tp) {
+               n.SetType(nil)
+               return n
+       }
+       if n.High != nil && !checksliceindex(l, n.High, tp) {
+               n.SetType(nil)
+               return n
+       }
+       if n.Max != nil && !checksliceindex(l, n.Max, tp) {
+               n.SetType(nil)
+               return n
+       }
+       if !checksliceconst(n.Low, n.High) || !checksliceconst(n.Low, n.Max) || !checksliceconst(n.High, n.Max) {
+               n.SetType(nil)
+               return n
+       }
+       return n
+}
+
+// tcSliceHeader typechecks an OSLICEHEADER node.
+func tcSliceHeader(n *ir.SliceHeaderExpr) ir.Node {
+       // Errors here are Fatalf instead of Errorf because only the compiler
+       // can construct an OSLICEHEADER node.
+       // Components used in OSLICEHEADER that are supplied by parsed source code
+       // have already been typechecked in e.g. OMAKESLICE earlier.
+       t := n.Type()
+       if t == nil {
+               base.Fatalf("no type specified for OSLICEHEADER")
+       }
+
+       if !t.IsSlice() {
+               base.Fatalf("invalid type %v for OSLICEHEADER", n.Type())
+       }
+
+       if n.Ptr == nil || n.Ptr.Type() == nil || !n.Ptr.Type().IsUnsafePtr() {
+               base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
+       }
+
+       n.Ptr = Expr(n.Ptr)
+       n.Len = DefaultLit(Expr(n.Len), types.Types[types.TINT])
+       n.Cap = DefaultLit(Expr(n.Cap), types.Types[types.TINT])
+
+       if ir.IsConst(n.Len, constant.Int) && ir.Int64Val(n.Len) < 0 {
+               base.Fatalf("len for OSLICEHEADER must be non-negative")
+       }
+
+       if ir.IsConst(n.Cap, constant.Int) && ir.Int64Val(n.Cap) < 0 {
+               base.Fatalf("cap for OSLICEHEADER must be non-negative")
+       }
+
+       if ir.IsConst(n.Len, constant.Int) && ir.IsConst(n.Cap, constant.Int) && constant.Compare(n.Len.Val(), token.GTR, n.Cap.Val()) {
+               base.Fatalf("len larger than cap for OSLICEHEADER")
+       }
+
+       return n
+}
+
+// tcStar typechecks an ODEREF node, which may be an expression or a type.
+func tcStar(n *ir.StarExpr, top int) ir.Node {
+       n.X = typecheck(n.X, ctxExpr|ctxType)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if l.Op() == ir.OTYPE {
+               n.SetOTYPE(types.NewPtr(l.Type()))
+               // Ensure l.Type gets CalcSize'd for the backend. Issue 20174.
+               types.CheckSize(l.Type())
+               return n
+       }
+
+       if !t.IsPtr() {
+               if top&(ctxExpr|ctxStmt) != 0 {
+                       base.Errorf("invalid indirect of %L", n.X)
+                       n.SetType(nil)
+                       return n
+               }
+               base.Errorf("%v is not a type", l)
+               return n
+       }
+
+       n.SetType(t.Elem())
+       return n
+}
+
+// tcUnaryArith typechecks a unary arithmetic expression.
+func tcUnaryArith(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !okfor[n.Op()][defaultType(t).Kind()] {
+               base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(t))
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetType(t)
+       return n
+}

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
new file mode 100644 (file)
index 0000000..7ab5f68
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -0,0 +1,972 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+
+       "fmt"
+       "go/constant"
+       "go/token"
+)
+
+// package all the arguments that match a ... T parameter into a []T.
+func MakeDotArgs(typ *types.Type, args []ir.Node) ir.Node {
+       var n ir.Node
+       if len(args) == 0 {
+               n = NodNil()
+               n.SetType(typ)
+       } else {
+               lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
+               lit.List.Append(args...)
+               lit.SetImplicit(true)
+               n = lit
+       }
+
+       n = Expr(n)
+       if n.Type() == nil {
+               base.Fatalf("mkdotargslice: typecheck failed")
+       }
+       return n
+}
+
+// FixVariadicCall rewrites calls to variadic functions to use an
+// explicit ... argument if one is not already present.
+func FixVariadicCall(call *ir.CallExpr) {
+       fntype := call.X.Type()
+       if !fntype.IsVariadic() || call.IsDDD {
+               return
+       }
+
+       vi := fntype.NumParams() - 1
+       vt := fntype.Params().Field(vi).Type
+
+       args := call.Args
+       extra := args[vi:]
+       slice := MakeDotArgs(vt, extra)
+       for i := range extra {
+               extra[i] = nil // allow GC
+       }
+
+       call.Args = append(args[:vi], slice)
+       call.IsDDD = true
+}
+
+// ClosureType returns the struct type used to hold all the information
+// needed in the closure for clo (clo must be a OCLOSURE node).
+// The address of a variable of the returned type can be cast to a func.
+func ClosureType(clo *ir.ClosureExpr) *types.Type {
+       // Create closure in the form of a composite literal.
+       // supposing the closure captures an int i and a string s
+       // and has one float64 argument and no results,
+       // the generated code looks like:
+       //
+       //      clos = &struct{.F uintptr; i *int; s *string}{func.1, &i, &s}
+       //
+       // The use of the struct provides type information to the garbage
+       // collector so that it can walk the closure. We could use (in this case)
+       // [3]unsafe.Pointer instead, but that would leave the gc in the dark.
+       // The information appears in the binary in the form of type descriptors;
+       // the struct is unnamed so that closures in multiple packages with the
+       // same struct type can share the descriptor.
+       fields := []*types.Field{
+               types.NewField(base.Pos, Lookup(".F"), types.Types[types.TUINTPTR]),
+       }
+       for _, v := range clo.Func.ClosureVars {
+               typ := v.Type()
+               if !v.Byval() {
+                       typ = types.NewPtr(typ)
+               }
+               fields = append(fields, types.NewField(base.Pos, v.Sym(), typ))
+       }
+       typ := types.NewStruct(types.NoPkg, fields)
+       typ.SetNoalg(true)
+       return typ
+}
+
+// PartialCallType returns the struct type used to hold all the information
+// needed in the closure for n (n must be a OCALLPART node).
+// The address of a variable of the returned type can be cast to a func.
+func PartialCallType(n *ir.SelectorExpr) *types.Type {
+       t := types.NewStruct(types.NoPkg, []*types.Field{
+               types.NewField(base.Pos, Lookup("F"), types.Types[types.TUINTPTR]),
+               types.NewField(base.Pos, Lookup("R"), n.X.Type()),
+       })
+       t.SetNoalg(true)
+       return t
+}
+
+// Lazy typechecking of imported bodies. For local functions, CanInline will set ->typecheck
+// because they're a copy of an already checked body.
+func ImportedBody(fn *ir.Func) {
+       lno := ir.SetPos(fn.Nname)
+
+       // When we load an inlined body, we need to allow OADDR
+       // operations on untyped expressions. We will fix the
+       // addrtaken flags on all the arguments of the OADDR with the
+       // computeAddrtaken call below (after we typecheck the body).
+       // TODO: export/import types and addrtaken marks along with inlined bodies,
+       // so this will be unnecessary.
+       IncrementalAddrtaken = false
+       defer func() {
+               if DirtyAddrtaken {
+                       ComputeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
+                       DirtyAddrtaken = false
+               }
+               IncrementalAddrtaken = true
+       }()
+
+       ImportBody(fn)
+
+       // Stmts(fn.Inl.Body) below is only for imported functions;
+       // their bodies may refer to unsafe as long as the package
+       // was marked safe during import (which was checked then).
+       // the ->inl of a local function has been typechecked before CanInline copied it.
+       pkg := fnpkg(fn.Nname)
+
+       if pkg == types.LocalPkg || pkg == nil {
+               return // ImportedBody on local function
+       }
+
+       if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
+               fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
+       }
+
+       savefn := ir.CurFunc
+       ir.CurFunc = fn
+       Stmts(fn.Inl.Body)
+       ir.CurFunc = savefn
+
+       // During ImportBody (which imports fn.Func.Inl.Body),
+       // declarations are added to fn.Func.Dcl by funcBody(). Move them
+       // to fn.Func.Inl.Dcl for consistency with how local functions
+       // behave. (Append because ImportedBody may be called multiple
+       // times on same fn.)
+       fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
+       fn.Dcl = nil
+
+       base.Pos = lno
+}
+
+// Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
+// the ->sym can be re-used in the local package, so peel it off the receiver's type.
+func fnpkg(fn *ir.Name) *types.Pkg {
+       if ir.IsMethod(fn) {
+               // method
+               rcvr := fn.Type().Recv().Type
+
+               if rcvr.IsPtr() {
+                       rcvr = rcvr.Elem()
+               }
+               if rcvr.Sym() == nil {
+                       base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym(), fn, rcvr)
+               }
+               return rcvr.Sym().Pkg
+       }
+
+       // non-method
+       return fn.Sym().Pkg
+}
+
+// closurename generates a new unique name for a closure within
+// outerfunc.
+func ClosureName(outerfunc *ir.Func) *types.Sym {
+       outer := "glob."
+       prefix := "func"
+       gen := &globClosgen
+
+       if outerfunc != nil {
+               if outerfunc.OClosure != nil {
+                       prefix = ""
+               }
+
+               outer = ir.FuncName(outerfunc)
+
+               // There may be multiple functions named "_". In those
+               // cases, we can't use their individual Closgens as it
+               // would lead to name clashes.
+               if !ir.IsBlank(outerfunc.Nname) {
+                       gen = &outerfunc.Closgen
+               }
+       }
+
+       *gen++
+       return Lookup(fmt.Sprintf("%s.%s%d", outer, prefix, *gen))
+}
+
+// globClosgen is like Func.Closgen, but for the global scope.
+var globClosgen int32
+
+// MethodValueWrapper returns the DCLFUNC node representing the
+// wrapper function (*-fm) needed for the given method value. If the
+// wrapper function hasn't already been created yet, it's created and
+// added to Target.Decls.
+//
+// TODO(mdempsky): Move into walk. This isn't part of type checking.
+func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
+       if dot.Op() != ir.OCALLPART {
+               base.Fatalf("MethodValueWrapper: unexpected %v (%v)", dot, dot.Op())
+       }
+
+       t0 := dot.Type()
+       meth := dot.Sel
+       rcvrtype := dot.X.Type()
+       sym := ir.MethodSymSuffix(rcvrtype, meth, "-fm")
+
+       if sym.Uniq() {
+               return sym.Def.(*ir.Func)
+       }
+       sym.SetUniq(true)
+
+       savecurfn := ir.CurFunc
+       saveLineNo := base.Pos
+       ir.CurFunc = nil
+
+       // Set line number equal to the line number where the method is declared.
+       if pos := dot.Selection.Pos; pos.IsKnown() {
+               base.Pos = pos
+       }
+       // Note: !dot.Selection.Pos.IsKnown() happens for method expressions where
+       // the method is implicitly declared. The Error method of the
+       // built-in error type is one such method.  We leave the line
+       // number at the use of the method expression in this
+       // case. See issue 29389.
+
+       tfn := ir.NewFuncType(base.Pos, nil,
+               NewFuncParams(t0.Params(), true),
+               NewFuncParams(t0.Results(), false))
+
+       fn := DeclFunc(sym, tfn)
+       fn.SetDupok(true)
+       fn.SetNeedctxt(true)
+       fn.SetWrapper(true)
+
+       // Declare and initialize variable holding receiver.
+       ptr := ir.NewNameAt(base.Pos, Lookup(".this"))
+       ptr.Class = ir.PAUTOHEAP
+       ptr.SetType(rcvrtype)
+       ptr.Curfn = fn
+       ptr.SetIsClosureVar(true)
+       ptr.SetByval(true)
+       fn.ClosureVars = append(fn.ClosureVars, ptr)
+
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
+       call.Args = ir.ParamNames(tfn.Type())
+       call.IsDDD = tfn.Type().IsVariadic()
+
+       var body ir.Node = call
+       if t0.NumResults() != 0 {
+               ret := ir.NewReturnStmt(base.Pos, nil)
+               ret.Results = []ir.Node{call}
+               body = ret
+       }
+
+       fn.Body = []ir.Node{body}
+       FinishFuncBody()
+
+       Func(fn)
+       // Need to typecheck the body of the just-generated wrapper.
+       // typecheckslice() requires that Curfn is set when processing an ORETURN.
+       ir.CurFunc = fn
+       Stmts(fn.Body)
+       sym.Def = fn
+       Target.Decls = append(Target.Decls, fn)
+       ir.CurFunc = savecurfn
+       base.Pos = saveLineNo
+
+       return fn
+}
+
+// tcClosure typechecks an OCLOSURE node. It also creates the named
+// function associated with the closure.
+// TODO: This creation of the named function should probably really be done in a
+// separate pass from type-checking.
+func tcClosure(clo *ir.ClosureExpr, top int) {
+       fn := clo.Func
+       // Set current associated iota value, so iota can be used inside
+       // function in ConstSpec, see issue #22344
+       if x := getIotaValue(); x >= 0 {
+               fn.Iota = x
+       }
+
+       fn.SetClosureCalled(top&ctxCallee != 0)
+
+       // Do not typecheck fn twice, otherwise, we will end up pushing
+       // fn to Target.Decls multiple times, causing InitLSym called twice.
+       // See #30709
+       if fn.Typecheck() == 1 {
+               clo.SetType(fn.Type())
+               return
+       }
+
+       // Don't give a name and add to xtop if we are typechecking an inlined
+       // body in ImportedBody(), since we only want to create the named function
+       // when the closure is actually inlined (and then we force a typecheck
+       // explicitly in (*inlsubst).node()).
+       inTypeCheckInl := ir.CurFunc != nil && ir.CurFunc.Body == nil
+       if !inTypeCheckInl {
+               fn.Nname.SetSym(ClosureName(ir.CurFunc))
+               ir.MarkFunc(fn.Nname)
+       }
+       Func(fn)
+       clo.SetType(fn.Type())
+
+       // Type check the body now, but only if we're inside a function.
+       // At top level (in a variable initialization: curfn==nil) we're not
+       // ready to type check code yet; we'll check it later, because the
+       // underlying closure function we create is added to Target.Decls.
+       if ir.CurFunc != nil && clo.Type() != nil {
+               oldfn := ir.CurFunc
+               ir.CurFunc = fn
+               Stmts(fn.Body)
+               ir.CurFunc = oldfn
+       }
+
+       out := 0
+       for _, v := range fn.ClosureVars {
+               if v.Type() == nil {
+                       // If v.Type is nil, it means v looked like it was going to be
+                       // used in the closure, but isn't. This happens in struct
+                       // literals like s{f: x} where we can't distinguish whether f is
+                       // a field identifier or expression until resolving s.
+                       continue
+               }
+
+               // type check closed variables outside the closure, so that the
+               // outer frame also captures them.
+               Expr(v.Outer)
+
+               fn.ClosureVars[out] = v
+               out++
+       }
+       fn.ClosureVars = fn.ClosureVars[:out]
+
+       if base.Flag.W > 1 {
+               s := fmt.Sprintf("New closure func: %s", ir.FuncName(fn))
+               ir.Dump(s, fn)
+       }
+       if !inTypeCheckInl {
+               // Add function to xtop once only when we give it a name
+               Target.Decls = append(Target.Decls, fn)
+       }
+}
+
+// type check function definition
+// To be called by typecheck, not directly.
+// (Call typecheck.Func instead.)
+func tcFunc(n *ir.Func) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("tcFunc", n)(nil)
+       }
+
+       n.Nname = AssignExpr(n.Nname).(*ir.Name)
+       t := n.Nname.Type()
+       if t == nil {
+               return
+       }
+       rcvr := t.Recv()
+       if rcvr != nil && n.Shortname != nil {
+               m := addmethod(n, n.Shortname, t, true, n.Pragma&ir.Nointerface != 0)
+               if m == nil {
+                       return
+               }
+
+               n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
+               Declare(n.Nname, ir.PFUNC)
+       }
+}
+
+// tcCall typechecks an OCALL node.
+func tcCall(n *ir.CallExpr, top int) ir.Node {
+       n.Use = ir.CallUseExpr
+       if top == ctxStmt {
+               n.Use = ir.CallUseStmt
+       }
+       Stmts(n.Init()) // imported rewritten f(g()) calls (#30907)
+       n.X = typecheck(n.X, ctxExpr|ctxType|ctxCallee)
+       if n.X.Diag() {
+               n.SetDiag(true)
+       }
+
+       l := n.X
+
+       if l.Op() == ir.ONAME && l.(*ir.Name).BuiltinOp != 0 {
+               l := l.(*ir.Name)
+               if n.IsDDD && l.BuiltinOp != ir.OAPPEND {
+                       base.Errorf("invalid use of ... with builtin %v", l)
+               }
+
+               // builtin: OLEN, OCAP, etc.
+               switch l.BuiltinOp {
+               default:
+                       base.Fatalf("unknown builtin %v", l)
+
+               case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+                       n.SetOp(l.BuiltinOp)
+                       n.X = nil
+                       n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
+                       return typecheck(n, top)
+
+               case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
+                       typecheckargs(n)
+                       fallthrough
+               case ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+                       arg, ok := needOneArg(n, "%v", n.Op())
+                       if !ok {
+                               n.SetType(nil)
+                               return n
+                       }
+                       u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
+                       return typecheck(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
+
+               case ir.OCOMPLEX, ir.OCOPY:
+                       typecheckargs(n)
+                       arg1, arg2, ok := needTwoArgs(n)
+                       if !ok {
+                               n.SetType(nil)
+                               return n
+                       }
+                       b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
+                       return typecheck(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
+               }
+               panic("unreachable")
+       }
+
+       n.X = DefaultLit(n.X, nil)
+       l = n.X
+       if l.Op() == ir.OTYPE {
+               if n.IsDDD {
+                       if !l.Type().Broke() {
+                               base.Errorf("invalid use of ... in type conversion to %v", l.Type())
+                       }
+                       n.SetDiag(true)
+               }
+
+               // pick off before type-checking arguments
+               arg, ok := needOneArg(n, "conversion to %v", l.Type())
+               if !ok {
+                       n.SetType(nil)
+                       return n
+               }
+
+               n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
+               n.SetType(l.Type())
+               return typecheck1(n, top)
+       }
+
+       typecheckargs(n)
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       types.CheckSize(t)
+
+       switch l.Op() {
+       case ir.ODOTINTER:
+               n.SetOp(ir.OCALLINTER)
+
+       case ir.ODOTMETH:
+               l := l.(*ir.SelectorExpr)
+               n.SetOp(ir.OCALLMETH)
+
+               // typecheckaste was used here but there wasn't enough
+               // information further down the call chain to know if we
+               // were testing a method receiver for unexported fields.
+               // It isn't necessary, so just do a sanity check.
+               tp := t.Recv().Type
+
+               if l.X == nil || !types.Identical(l.X.Type(), tp) {
+                       base.Fatalf("method receiver")
+               }
+
+       default:
+               n.SetOp(ir.OCALLFUNC)
+               if t.Kind() != types.TFUNC {
+                       if o := ir.Orig(l); o.Name() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
+                               // be more specific when the non-function
+                               // name matches a predeclared function
+                               base.Errorf("cannot call non-function %L, declared at %s",
+                                       l, base.FmtPos(o.Name().Pos()))
+                       } else {
+                               base.Errorf("cannot call non-function %L", l)
+                       }
+                       n.SetType(nil)
+                       return n
+               }
+       }
+
+       typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args, func() string { return fmt.Sprintf("argument to %v", n.X) })
+       if t.NumResults() == 0 {
+               return n
+       }
+       if t.NumResults() == 1 {
+               n.SetType(l.Type().Results().Field(0).Type)
+
+               if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
+                       if sym := n.X.(*ir.Name).Sym(); types.IsRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+                               // Emit code for runtime.getg() directly instead of calling function.
+                               // Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
+                               // so that the ordering pass can make sure to preserve the semantics of the original code
+                               // (in particular, the exact time of the function call) by introducing temporaries.
+                               // In this case, we know getg() always returns the same result within a given function
+                               // and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
+                               n.SetOp(ir.OGETG)
+                       }
+               }
+               return n
+       }
+
+       // multiple return
+       if top&(ctxMultiOK|ctxStmt) == 0 {
+               base.Errorf("multiple-value %v() in single-value context", l)
+               return n
+       }
+
+       n.SetType(l.Type().Results())
+       return n
+}
+
+// tcAppend typechecks an OAPPEND node.
+func tcAppend(n *ir.CallExpr) ir.Node {
+       typecheckargs(n)
+       args := n.Args
+       if len(args) == 0 {
+               base.Errorf("missing arguments to append")
+               n.SetType(nil)
+               return n
+       }
+
+       t := args[0].Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetType(t)
+       if !t.IsSlice() {
+               if ir.IsNil(args[0]) {
+                       base.Errorf("first argument to append must be typed slice; have untyped nil")
+                       n.SetType(nil)
+                       return n
+               }
+
+               base.Errorf("first argument to append must be slice; have %L", t)
+               n.SetType(nil)
+               return n
+       }
+
+       if n.IsDDD {
+               if len(args) == 1 {
+                       base.Errorf("cannot use ... on first argument to append")
+                       n.SetType(nil)
+                       return n
+               }
+
+               if len(args) != 2 {
+                       base.Errorf("too many arguments to append")
+                       n.SetType(nil)
+                       return n
+               }
+
+               if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
+                       args[1] = DefaultLit(args[1], types.Types[types.TSTRING])
+                       return n
+               }
+
+               args[1] = AssignConv(args[1], t.Underlying(), "append")
+               return n
+       }
+
+       as := args[1:]
+       for i, n := range as {
+               if n.Type() == nil {
+                       continue
+               }
+               as[i] = AssignConv(n, t.Elem(), "append")
+               types.CheckSize(as[i].Type()) // ensure width is calculated for backend
+       }
+       return n
+}
+
+// tcClose typechecks an OCLOSE node.
+func tcClose(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       if !t.IsChan() {
+               base.Errorf("invalid operation: %v (non-chan type %v)", n, t)
+               n.SetType(nil)
+               return n
+       }
+
+       if !t.ChanDir().CanSend() {
+               base.Errorf("invalid operation: %v (cannot close receive-only channel)", n)
+               n.SetType(nil)
+               return n
+       }
+       return n
+}
+
+// tcComplex typechecks an OCOMPLEX node.
+func tcComplex(n *ir.BinaryExpr) ir.Node {
+       l := Expr(n.X)
+       r := Expr(n.Y)
+       if l.Type() == nil || r.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       l, r = defaultlit2(l, r, false)
+       if l.Type() == nil || r.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       n.X = l
+       n.Y = r
+
+       if !types.Identical(l.Type(), r.Type()) {
+               base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+               n.SetType(nil)
+               return n
+       }
+
+       var t *types.Type
+       switch l.Type().Kind() {
+       default:
+               base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type())
+               n.SetType(nil)
+               return n
+
+       case types.TIDEAL:
+               t = types.UntypedComplex
+
+       case types.TFLOAT32:
+               t = types.Types[types.TCOMPLEX64]
+
+       case types.TFLOAT64:
+               t = types.Types[types.TCOMPLEX128]
+       }
+       n.SetType(t)
+       return n
+}
+
+// tcCopy typechecks an OCOPY node.
+func tcCopy(n *ir.BinaryExpr) ir.Node {
+       n.SetType(types.Types[types.TINT])
+       n.X = Expr(n.X)
+       n.X = DefaultLit(n.X, nil)
+       n.Y = Expr(n.Y)
+       n.Y = DefaultLit(n.Y, nil)
+       if n.X.Type() == nil || n.Y.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       // copy([]byte, string)
+       if n.X.Type().IsSlice() && n.Y.Type().IsString() {
+               if types.Identical(n.X.Type().Elem(), types.ByteType) {
+                       return n
+               }
+               base.Errorf("arguments to copy have different element types: %L and string", n.X.Type())
+               n.SetType(nil)
+               return n
+       }
+
+       if !n.X.Type().IsSlice() || !n.Y.Type().IsSlice() {
+               if !n.X.Type().IsSlice() && !n.Y.Type().IsSlice() {
+                       base.Errorf("arguments to copy must be slices; have %L, %L", n.X.Type(), n.Y.Type())
+               } else if !n.X.Type().IsSlice() {
+                       base.Errorf("first argument to copy should be slice; have %L", n.X.Type())
+               } else {
+                       base.Errorf("second argument to copy should be slice or string; have %L", n.Y.Type())
+               }
+               n.SetType(nil)
+               return n
+       }
+
+       if !types.Identical(n.X.Type().Elem(), n.Y.Type().Elem()) {
+               base.Errorf("arguments to copy have different element types: %L and %L", n.X.Type(), n.Y.Type())
+               n.SetType(nil)
+               return n
+       }
+       return n
+}
+
+// tcDelete typechecks an ODELETE node.
+func tcDelete(n *ir.CallExpr) ir.Node {
+       typecheckargs(n)
+       args := n.Args
+       if len(args) == 0 {
+               base.Errorf("missing arguments to delete")
+               n.SetType(nil)
+               return n
+       }
+
+       if len(args) == 1 {
+               base.Errorf("missing second (key) argument to delete")
+               n.SetType(nil)
+               return n
+       }
+
+       if len(args) != 2 {
+               base.Errorf("too many arguments to delete")
+               n.SetType(nil)
+               return n
+       }
+
+       l := args[0]
+       r := args[1]
+       if l.Type() != nil && !l.Type().IsMap() {
+               base.Errorf("first argument to delete must be map; have %L", l.Type())
+               n.SetType(nil)
+               return n
+       }
+
+       args[1] = AssignConv(r, l.Type().Key(), "delete")
+       return n
+}
+
+// tcMake typechecks an OMAKE node.
+func tcMake(n *ir.CallExpr) ir.Node {
+       args := n.Args
+       if len(args) == 0 {
+               base.Errorf("missing argument to make")
+               n.SetType(nil)
+               return n
+       }
+
+       n.Args = nil
+       l := args[0]
+       l = typecheck(l, ctxType)
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       i := 1
+       var nn ir.Node
+       switch t.Kind() {
+       default:
+               base.Errorf("cannot make type %v", t)
+               n.SetType(nil)
+               return n
+
+       case types.TSLICE:
+               if i >= len(args) {
+                       base.Errorf("missing len argument to make(%v)", t)
+                       n.SetType(nil)
+                       return n
+               }
+
+               l = args[i]
+               i++
+               l = Expr(l)
+               var r ir.Node
+               if i < len(args) {
+                       r = args[i]
+                       i++
+                       r = Expr(r)
+               }
+
+               if l.Type() == nil || (r != nil && r.Type() == nil) {
+                       n.SetType(nil)
+                       return n
+               }
+               if !checkmake(t, "len", &l) || r != nil && !checkmake(t, "cap", &r) {
+                       n.SetType(nil)
+                       return n
+               }
+               if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
+                       base.Errorf("len larger than cap in make(%v)", t)
+                       n.SetType(nil)
+                       return n
+               }
+               nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
+
+       case types.TMAP:
+               if i < len(args) {
+                       l = args[i]
+                       i++
+                       l = Expr(l)
+                       l = DefaultLit(l, types.Types[types.TINT])
+                       if l.Type() == nil {
+                               n.SetType(nil)
+                               return n
+                       }
+                       if !checkmake(t, "size", &l) {
+                               n.SetType(nil)
+                               return n
+                       }
+               } else {
+                       l = ir.NewInt(0)
+               }
+               nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
+               nn.SetEsc(n.Esc())
+
+       case types.TCHAN:
+               l = nil
+               if i < len(args) {
+                       l = args[i]
+                       i++
+                       l = Expr(l)
+                       l = DefaultLit(l, types.Types[types.TINT])
+                       if l.Type() == nil {
+                               n.SetType(nil)
+                               return n
+                       }
+                       if !checkmake(t, "buffer", &l) {
+                               n.SetType(nil)
+                               return n
+                       }
+               } else {
+                       l = ir.NewInt(0)
+               }
+               nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
+       }
+
+       if i < len(args) {
+               base.Errorf("too many arguments to make(%v)", t)
+               n.SetType(nil)
+               return n
+       }
+
+       nn.SetType(t)
+       return nn
+}
+
+// tcMakeSliceCopy typechecks an OMAKESLICECOPY node.
+func tcMakeSliceCopy(n *ir.MakeExpr) ir.Node {
+       // Errors here are Fatalf instead of Errorf because only the compiler
+       // can construct an OMAKESLICECOPY node.
+       // Components used in OMAKESCLICECOPY that are supplied by parsed source code
+       // have already been typechecked in OMAKE and OCOPY earlier.
+       t := n.Type()
+
+       if t == nil {
+               base.Fatalf("no type specified for OMAKESLICECOPY")
+       }
+
+       if !t.IsSlice() {
+               base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type())
+       }
+
+       if n.Len == nil {
+               base.Fatalf("missing len argument for OMAKESLICECOPY")
+       }
+
+       if n.Cap == nil {
+               base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
+       }
+
+       n.Len = Expr(n.Len)
+       n.Cap = Expr(n.Cap)
+
+       n.Len = DefaultLit(n.Len, types.Types[types.TINT])
+
+       if !n.Len.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+               base.Errorf("non-integer len argument in OMAKESLICECOPY")
+       }
+
+       if ir.IsConst(n.Len, constant.Int) {
+               if ir.ConstOverflow(n.Len.Val(), types.Types[types.TINT]) {
+                       base.Fatalf("len for OMAKESLICECOPY too large")
+               }
+               if constant.Sign(n.Len.Val()) < 0 {
+                       base.Fatalf("len for OMAKESLICECOPY must be non-negative")
+               }
+       }
+       return n
+}
+
+// tcNew typechecks an ONEW node.
+func tcNew(n *ir.UnaryExpr) ir.Node {
+       if n.X == nil {
+               // Fatalf because the OCALL above checked for us,
+               // so this must be an internally-generated mistake.
+               base.Fatalf("missing argument to new")
+       }
+       l := n.X
+       l = typecheck(l, ctxType)
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+       n.X = l
+       n.SetType(types.NewPtr(t))
+       return n
+}
+
+// tcPanic typechecks an OPANIC node.
+func tcPanic(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       n.X = AssignConv(n.X, types.Types[types.TINTER], "argument to panic")
+       if n.X.Type() == nil {
+               n.SetType(nil)
+               return n
+       }
+       return n
+}
+
+// tcPrint typechecks an OPRINT or OPRINTN node.
+func tcPrint(n *ir.CallExpr) ir.Node {
+       typecheckargs(n)
+       ls := n.Args
+       for i1, n1 := range ls {
+               // Special case for print: int constant is int64, not int.
+               if ir.IsConst(n1, constant.Int) {
+                       ls[i1] = DefaultLit(ls[i1], types.Types[types.TINT64])
+               } else {
+                       ls[i1] = DefaultLit(ls[i1], nil)
+               }
+       }
+       return n
+}
+
+// tcRealImag typechecks an OREAL or OIMAG node.
+func tcRealImag(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       l := n.X
+       t := l.Type()
+       if t == nil {
+               n.SetType(nil)
+               return n
+       }
+
+       // Determine result type.
+       switch t.Kind() {
+       case types.TIDEAL:
+               n.SetType(types.UntypedFloat)
+       case types.TCOMPLEX64:
+               n.SetType(types.Types[types.TFLOAT32])
+       case types.TCOMPLEX128:
+               n.SetType(types.Types[types.TFLOAT64])
+       default:
+               base.Errorf("invalid argument %L for %v", l, n.Op())
+               n.SetType(nil)
+               return n
+       }
+       return n
+}
+
+// tcRecover typechecks an ORECOVER node.
+func tcRecover(n *ir.CallExpr) ir.Node {
+       if len(n.Args) != 0 {
+               base.Errorf("too many arguments to recover")
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetType(types.Types[types.TINTER])
+       return n
+}

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
similarity index 53%
rename from src/cmd/compile/internal/gc/iexport.go
rename to src/cmd/compile/internal/typecheck/iexport.go
index 1f53d8ca7dc195bc26d5d68a5e7bf10d729b5f1d..6fab74e61fe7762c0ef842f00753db63d5ad586c 100644 (file)
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -199,21 +199,25 @@
 // they're expected to change much more rapidly, so they're omitted
 // here. See exportWriter's varExt/funcExt/etc methods for details.
 
-package gc
+package typecheck
 
 import (
        "bufio"
        "bytes"
-       "cmd/compile/internal/types"
-       "cmd/internal/goobj"
-       "cmd/internal/src"
        "crypto/md5"
        "encoding/binary"
        "fmt"
+       "go/constant"
        "io"
        "math/big"
        "sort"
        "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/goobj"
+       "cmd/internal/src"
 )
 
 // Current indexed export format version. Increase with each format change.
@@ -242,23 +246,12 @@ const (
        interfaceType
 )
 
-func iexport(out *bufio.Writer) {
-       // Mark inline bodies that are reachable through exported types.
-       // (Phase 0 of bexport.go.)
-       {
-               // TODO(mdempsky): Separate from bexport logic.
-               p := &exporter{marked: make(map[*types.Type]bool)}
-               for _, n := range exportlist {
-                       sym := n.Sym
-                       p.markType(asNode(sym.Def).Type)
-               }
-       }
-
+func WriteExports(out *bufio.Writer) {
        p := iexporter{
                allPkgs:     map[*types.Pkg]bool{},
                stringIndex: map[string]uint64{},
-               declIndex:   map[*Node]uint64{},
-               inlineIndex: map[*Node]uint64{},
+               declIndex:   map[*types.Sym]uint64{},
+               inlineIndex: map[*types.Sym]uint64{},
                typIndex:    map[*types.Type]uint64{},
        }
 
@@ -266,19 +259,19 @@ func iexport(out *bufio.Writer) {
                p.typIndex[pt] = uint64(i)
        }
        if len(p.typIndex) > predeclReserved {
-               Fatalf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved)
+               base.Fatalf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved)
        }
 
        // Initialize work queue with exported declarations.
-       for _, n := range exportlist {
+       for _, n := range Target.Exports {
                p.pushDecl(n)
        }
 
        // Loop until no more work. We use a queue because while
        // writing out inline bodies, we may discover additional
        // declarations that are needed.
-       for !p.declTodo.empty() {
-               p.doDecl(p.declTodo.popLeft())
+       for !p.declTodo.Empty() {
+               p.doDecl(p.declTodo.PopLeft())
        }
 
        // Append indices to data0 section.
@@ -288,6 +281,10 @@ func iexport(out *bufio.Writer) {
        w.writeIndex(p.inlineIndex, false)
        w.flush()
 
+       if *base.Flag.LowerV {
+               fmt.Printf("export: hdr strings %v, data %v, index %v\n", p.strings.Len(), dataLen, p.data0.Len())
+       }
+
        // Assemble header.
        var hdr intWriter
        hdr.WriteByte('i')
@@ -304,41 +301,38 @@ func iexport(out *bufio.Writer) {
 
        // Add fingerprint (used by linker object file).
        // Attach this to the end, so tools (e.g. gcimporter) don't care.
-       copy(Ctxt.Fingerprint[:], h.Sum(nil)[:])
-       out.Write(Ctxt.Fingerprint[:])
+       copy(base.Ctxt.Fingerprint[:], h.Sum(nil)[:])
+       out.Write(base.Ctxt.Fingerprint[:])
 }
 
-// writeIndex writes out an object index. mainIndex indicates whether
+// writeIndex writes out a symbol index. mainIndex indicates whether
 // we're writing out the main index, which is also read by
 // non-compiler tools and includes a complete package description
 // (i.e., name and height).
-func (w *exportWriter) writeIndex(index map[*Node]uint64, mainIndex bool) {
-       // Build a map from packages to objects from that package.
-       pkgObjs := map[*types.Pkg][]*Node{}
+func (w *exportWriter) writeIndex(index map[*types.Sym]uint64, mainIndex bool) {
+       // Build a map from packages to symbols from that package.
+       pkgSyms := map[*types.Pkg][]*types.Sym{}
 
        // For the main index, make sure to include every package that
        // we reference, even if we're not exporting (or reexporting)
        // any symbols from it.
        if mainIndex {
-               pkgObjs[localpkg] = nil
+               pkgSyms[types.LocalPkg] = nil
                for pkg := range w.p.allPkgs {
-                       pkgObjs[pkg] = nil
+                       pkgSyms[pkg] = nil
                }
        }
 
-       for n := range index {
-               pkgObjs[n.Sym.Pkg] = append(pkgObjs[n.Sym.Pkg], n)
+       // Group symbols by package.
+       for sym := range index {
+               pkgSyms[sym.Pkg] = append(pkgSyms[sym.Pkg], sym)
        }
 
+       // Sort packages by path.
        var pkgs []*types.Pkg
-       for pkg, objs := range pkgObjs {
+       for pkg := range pkgSyms {
                pkgs = append(pkgs, pkg)
-
-               sort.Slice(objs, func(i, j int) bool {
-                       return objs[i].Sym.Name < objs[j].Sym.Name
-               })
        }
-
        sort.Slice(pkgs, func(i, j int) bool {
                return pkgs[i].Path < pkgs[j].Path
        })
@@ -351,11 +345,16 @@ func (w *exportWriter) writeIndex(index map[*Node]uint64, mainIndex bool) {
                        w.uint64(uint64(pkg.Height))
                }
 
-               objs := pkgObjs[pkg]
-               w.uint64(uint64(len(objs)))
-               for _, n := range objs {
-                       w.string(n.Sym.Name)
-                       w.uint64(index[n])
+               // Sort symbols within a package by name.
+               syms := pkgSyms[pkg]
+               sort.Slice(syms, func(i, j int) bool {
+                       return syms[i].Name < syms[j].Name
+               })
+
+               w.uint64(uint64(len(syms)))
+               for _, sym := range syms {
+                       w.string(sym.Name)
+                       w.uint64(index[sym])
                }
        }
 }
@@ -366,14 +365,14 @@ type iexporter struct {
        // main index.
        allPkgs map[*types.Pkg]bool
 
-       declTodo nodeQueue
+       declTodo ir.NameQueue
 
        strings     intWriter
        stringIndex map[string]uint64
 
        data0       intWriter
-       declIndex   map[*Node]uint64
-       inlineIndex map[*Node]uint64
+       declIndex   map[*types.Sym]uint64
+       inlineIndex map[*types.Sym]uint64
        typIndex    map[*types.Type]uint64
 }
 
@@ -385,6 +384,10 @@ func (p *iexporter) stringOff(s string) uint64 {
                off = uint64(p.strings.Len())
                p.stringIndex[s] = off
 
+               if *base.Flag.LowerV {
+                       fmt.Printf("export: str %v %.40q\n", off, s)
+               }
+
                p.strings.uint64(uint64(len(s)))
                p.strings.WriteString(s)
        }
@@ -392,22 +395,22 @@ func (p *iexporter) stringOff(s string) uint64 {
 }
 
 // pushDecl adds n to the declaration work queue, if not already present.
-func (p *iexporter) pushDecl(n *Node) {
-       if n.Sym == nil || asNode(n.Sym.Def) != n && n.Op != OTYPE {
-               Fatalf("weird Sym: %v, %v", n, n.Sym)
+func (p *iexporter) pushDecl(n *ir.Name) {
+       if n.Sym() == nil || n.Sym().Def != n && n.Op() != ir.OTYPE {
+               base.Fatalf("weird Sym: %v, %v", n, n.Sym())
        }
 
        // Don't export predeclared declarations.
-       if n.Sym.Pkg == builtinpkg || n.Sym.Pkg == unsafepkg {
+       if n.Sym().Pkg == types.BuiltinPkg || n.Sym().Pkg == ir.Pkgs.Unsafe {
                return
        }
 
-       if _, ok := p.declIndex[n]; ok {
+       if _, ok := p.declIndex[n.Sym()]; ok {
                return
        }
 
-       p.declIndex[n] = ^uint64(0) // mark n present in work queue
-       p.declTodo.pushRight(n)
+       p.declIndex[n.Sym()] = ^uint64(0) // mark n present in work queue
+       p.declTodo.PushRight(n)
 }
 
 // exportWriter handles writing out individual data section chunks.
@@ -419,70 +422,83 @@ type exportWriter struct {
        prevFile   string
        prevLine   int64
        prevColumn int64
+
+       // dclIndex maps function-scoped declarations to an int used to refer to
+       // them later in the function. For local variables/params, the int is
+       // non-negative and in order of the appearance in the Func's Dcl list. For
+       // closure variables, the index is negative starting at -2.
+       dclIndex           map[*ir.Name]int
+       maxDclIndex        int
+       maxClosureVarIndex int
 }
 
-func (p *iexporter) doDecl(n *Node) {
+func (p *iexporter) doDecl(n *ir.Name) {
        w := p.newWriter()
-       w.setPkg(n.Sym.Pkg, false)
+       w.setPkg(n.Sym().Pkg, false)
 
-       switch n.Op {
-       case ONAME:
-               switch n.Class() {
-               case PEXTERN:
+       switch n.Op() {
+       case ir.ONAME:
+               switch n.Class {
+               case ir.PEXTERN:
                        // Variable.
                        w.tag('V')
-                       w.pos(n.Pos)
-                       w.typ(n.Type)
+                       w.pos(n.Pos())
+                       w.typ(n.Type())
                        w.varExt(n)
 
-               case PFUNC:
-                       if n.IsMethod() {
-                               Fatalf("unexpected method: %v", n)
+               case ir.PFUNC:
+                       if ir.IsMethod(n) {
+                               base.Fatalf("unexpected method: %v", n)
                        }
 
                        // Function.
                        w.tag('F')
-                       w.pos(n.Pos)
-                       w.signature(n.Type)
+                       w.pos(n.Pos())
+                       w.signature(n.Type())
                        w.funcExt(n)
 
                default:
-                       Fatalf("unexpected class: %v, %v", n, n.Class())
+                       base.Fatalf("unexpected class: %v, %v", n, n.Class)
+               }
+
+       case ir.OLITERAL:
+               // TODO(mdempsky): Extend check to all declarations.
+               if n.Typecheck() == 0 {
+                       base.FatalfAt(n.Pos(), "missed typecheck: %v", n)
                }
 
-       case OLITERAL:
                // Constant.
-               n = typecheck(n, ctxExpr)
                w.tag('C')
-               w.pos(n.Pos)
-               w.value(n.Type, n.Val())
+               w.pos(n.Pos())
+               w.value(n.Type(), n.Val())
+               w.constExt(n)
 
-       case OTYPE:
-               if IsAlias(n.Sym) {
+       case ir.OTYPE:
+               if types.IsDotAlias(n.Sym()) {
                        // Alias.
                        w.tag('A')
-                       w.pos(n.Pos)
-                       w.typ(n.Type)
+                       w.pos(n.Pos())
+                       w.typ(n.Type())
                        break
                }
 
                // Defined type.
                w.tag('T')
-               w.pos(n.Pos)
+               w.pos(n.Pos())
 
-               underlying := n.Type.Orig
-               if underlying == types.Errortype.Orig {
+               underlying := n.Type().Underlying()
+               if underlying == types.ErrorType.Underlying() {
                        // For "type T error", use error as the
                        // underlying type instead of error's own
                        // underlying anonymous interface. This
                        // ensures consistency with how importers may
                        // declare error (e.g., go/types uses nil Pkg
                        // for predeclared objects).
-                       underlying = types.Errortype
+                       underlying = types.ErrorType
                }
                w.typ(underlying)
 
-               t := n.Type
+               t := n.Type()
                if t.IsInterface() {
                        w.typeExt(t)
                        break
@@ -503,27 +519,36 @@ func (p *iexporter) doDecl(n *Node) {
                }
 
        default:
-               Fatalf("unexpected node: %v", n)
+               base.Fatalf("unexpected node: %v", n)
        }
 
-       p.declIndex[n] = w.flush()
+       w.finish("dcl", p.declIndex, n.Sym())
 }
 
 func (w *exportWriter) tag(tag byte) {
        w.data.WriteByte(tag)
 }
 
-func (p *iexporter) doInline(f *Node) {
+func (w *exportWriter) finish(what string, index map[*types.Sym]uint64, sym *types.Sym) {
+       off := w.flush()
+       if *base.Flag.LowerV {
+               fmt.Printf("export: %v %v %v\n", what, off, sym)
+       }
+       index[sym] = off
+}
+
+func (p *iexporter) doInline(f *ir.Name) {
        w := p.newWriter()
        w.setPkg(fnpkg(f), false)
 
-       w.stmtList(asNodes(f.Func.Inl.Body))
+       w.dclIndex = make(map[*ir.Name]int, len(f.Func.Inl.Dcl))
+       w.funcBody(f.Func)
 
-       p.inlineIndex[f] = w.flush()
+       w.finish("inl", p.inlineIndex, f.Sym())
 }
 
 func (w *exportWriter) pos(pos src.XPos) {
-       p := Ctxt.PosTable.Pos(pos)
+       p := base.Ctxt.PosTable.Pos(pos)
        file := p.Base().AbsFilename()
        line := int64(p.RelLine())
        column := int64(p.RelCol())
@@ -562,43 +587,40 @@ func (w *exportWriter) pos(pos src.XPos) {
 }
 
 func (w *exportWriter) pkg(pkg *types.Pkg) {
+       // TODO(mdempsky): Add flag to types.Pkg to mark pseudo-packages.
+       if pkg == ir.Pkgs.Go {
+               base.Fatalf("export of pseudo-package: %q", pkg.Path)
+       }
+
        // Ensure any referenced packages are declared in the main index.
        w.p.allPkgs[pkg] = true
 
        w.string(pkg.Path)
 }
 
-func (w *exportWriter) qualifiedIdent(n *Node) {
+func (w *exportWriter) qualifiedIdent(n ir.Node) {
        // Ensure any referenced declarations are written out too.
-       w.p.pushDecl(n)
+       w.p.pushDecl(n.Name())
 
-       s := n.Sym
+       s := n.Sym()
        w.string(s.Name)
        w.pkg(s.Pkg)
 }
 
 func (w *exportWriter) selector(s *types.Sym) {
        if w.currPkg == nil {
-               Fatalf("missing currPkg")
+               base.Fatalf("missing currPkg")
        }
 
-       // Method selectors are rewritten into method symbols (of the
-       // form T.M) during typechecking, but we want to write out
-       // just the bare method name.
-       name := s.Name
-       if i := strings.LastIndex(name, "."); i >= 0 {
-               name = name[i+1:]
-       } else {
-               pkg := w.currPkg
-               if types.IsExported(name) {
-                       pkg = localpkg
-               }
-               if s.Pkg != pkg {
-                       Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
-               }
+       pkg := w.currPkg
+       if types.IsExported(s.Name) {
+               pkg = types.LocalPkg
+       }
+       if s.Pkg != pkg {
+               base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
        }
 
-       w.string(name)
+       w.string(s.Name)
 }
 
 func (w *exportWriter) typ(t *types.Type) {
@@ -620,7 +642,11 @@ func (p *iexporter) typOff(t *types.Type) uint64 {
        if !ok {
                w := p.newWriter()
                w.doTyp(t)
-               off = predeclReserved + w.flush()
+               rawOff := w.flush()
+               if *base.Flag.LowerV {
+                       fmt.Printf("export: typ %v %v\n", rawOff, t)
+               }
+               off = predeclReserved + rawOff
                p.typIndex[t] = off
        }
        return off
@@ -631,46 +657,46 @@ func (w *exportWriter) startType(k itag) {
 }
 
 func (w *exportWriter) doTyp(t *types.Type) {
-       if t.Sym != nil {
-               if t.Sym.Pkg == builtinpkg || t.Sym.Pkg == unsafepkg {
-                       Fatalf("builtin type missing from typIndex: %v", t)
+       if t.Sym() != nil {
+               if t.Sym().Pkg == types.BuiltinPkg || t.Sym().Pkg == ir.Pkgs.Unsafe {
+                       base.Fatalf("builtin type missing from typIndex: %v", t)
                }
 
                w.startType(definedType)
-               w.qualifiedIdent(typenod(t))
+               w.qualifiedIdent(t.Obj().(*ir.Name))
                return
        }
 
-       switch t.Etype {
-       case TPTR:
+       switch t.Kind() {
+       case types.TPTR:
                w.startType(pointerType)
                w.typ(t.Elem())
 
-       case TSLICE:
+       case types.TSLICE:
                w.startType(sliceType)
                w.typ(t.Elem())
 
-       case TARRAY:
+       case types.TARRAY:
                w.startType(arrayType)
                w.uint64(uint64(t.NumElem()))
                w.typ(t.Elem())
 
-       case TCHAN:
+       case types.TCHAN:
                w.startType(chanType)
                w.uint64(uint64(t.ChanDir()))
                w.typ(t.Elem())
 
-       case TMAP:
+       case types.TMAP:
                w.startType(mapType)
                w.typ(t.Key())
                w.typ(t.Elem())
 
-       case TFUNC:
+       case types.TFUNC:
                w.startType(signatureType)
                w.setPkg(t.Pkg(), true)
                w.signature(t)
 
-       case TSTRUCT:
+       case types.TSTRUCT:
                w.startType(structType)
                w.setPkg(t.Pkg(), true)
 
@@ -683,7 +709,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
                        w.string(f.Note)
                }
 
-       case TINTER:
+       case types.TINTER:
                var embeddeds, methods []*types.Field
                for _, m := range t.Methods().Slice() {
                        if m.Sym != nil {
@@ -710,15 +736,13 @@ func (w *exportWriter) doTyp(t *types.Type) {
                }
 
        default:
-               Fatalf("unexpected type: %v", t)
+               base.Fatalf("unexpected type: %v", t)
        }
 }
 
 func (w *exportWriter) setPkg(pkg *types.Pkg, write bool) {
-       if pkg == nil {
-               // TODO(mdempsky): Proactively set Pkg for types and
-               // remove this fallback logic.
-               pkg = localpkg
+       if pkg == types.NoPkg {
+               base.Fatalf("missing pkg")
        }
 
        if write {
@@ -745,44 +769,40 @@ func (w *exportWriter) paramList(fs []*types.Field) {
 
 func (w *exportWriter) param(f *types.Field) {
        w.pos(f.Pos)
-       w.localIdent(origSym(f.Sym), 0)
+       w.localIdent(types.OrigSym(f.Sym))
        w.typ(f.Type)
 }
 
-func constTypeOf(typ *types.Type) Ctype {
+func constTypeOf(typ *types.Type) constant.Kind {
        switch typ {
        case types.UntypedInt, types.UntypedRune:
-               return CTINT
+               return constant.Int
        case types.UntypedFloat:
-               return CTFLT
+               return constant.Float
        case types.UntypedComplex:
-               return CTCPLX
-       }
-
-       switch typ.Etype {
-       case TCHAN, TFUNC, TMAP, TNIL, TINTER, TPTR, TSLICE, TUNSAFEPTR:
-               return CTNIL
-       case TBOOL:
-               return CTBOOL
-       case TSTRING:
-               return CTSTR
-       case TINT, TINT8, TINT16, TINT32, TINT64,
-               TUINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINTPTR:
-               return CTINT
-       case TFLOAT32, TFLOAT64:
-               return CTFLT
-       case TCOMPLEX64, TCOMPLEX128:
-               return CTCPLX
-       }
-
-       Fatalf("unexpected constant type: %v", typ)
+               return constant.Complex
+       }
+
+       switch typ.Kind() {
+       case types.TBOOL:
+               return constant.Bool
+       case types.TSTRING:
+               return constant.String
+       case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64,
+               types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
+               return constant.Int
+       case types.TFLOAT32, types.TFLOAT64:
+               return constant.Float
+       case types.TCOMPLEX64, types.TCOMPLEX128:
+               return constant.Complex
+       }
+
+       base.Fatalf("unexpected constant type: %v", typ)
        return 0
 }
 
-func (w *exportWriter) value(typ *types.Type, v Val) {
-       if vt := idealType(v.Ctype()); typ.IsUntyped() && typ != vt {
-               Fatalf("exporter: untyped type mismatch, have: %v, want: %v", typ, vt)
-       }
+func (w *exportWriter) value(typ *types.Type, v constant.Value) {
+       ir.AssertValidTypeForConst(typ, v)
        w.typ(typ)
 
        // Each type has only one admissible constant representation,
@@ -791,33 +811,29 @@ func (w *exportWriter) value(typ *types.Type, v Val) {
        // and provides a useful consistency check.
 
        switch constTypeOf(typ) {
-       case CTNIL:
-               // Only one value; nothing to encode.
-               _ = v.U.(*NilVal)
-       case CTBOOL:
-               w.bool(v.U.(bool))
-       case CTSTR:
-               w.string(v.U.(string))
-       case CTINT:
-               w.mpint(&v.U.(*Mpint).Val, typ)
-       case CTFLT:
-               w.mpfloat(&v.U.(*Mpflt).Val, typ)
-       case CTCPLX:
-               x := v.U.(*Mpcplx)
-               w.mpfloat(&x.Real.Val, typ)
-               w.mpfloat(&x.Imag.Val, typ)
+       case constant.Bool:
+               w.bool(constant.BoolVal(v))
+       case constant.String:
+               w.string(constant.StringVal(v))
+       case constant.Int:
+               w.mpint(v, typ)
+       case constant.Float:
+               w.mpfloat(v, typ)
+       case constant.Complex:
+               w.mpfloat(constant.Real(v), typ)
+               w.mpfloat(constant.Imag(v), typ)
        }
 }
 
 func intSize(typ *types.Type) (signed bool, maxBytes uint) {
        if typ.IsUntyped() {
-               return true, Mpprec / 8
+               return true, ir.ConstPrec / 8
        }
 
-       switch typ.Etype {
-       case TFLOAT32, TCOMPLEX64:
+       switch typ.Kind() {
+       case types.TFLOAT32, types.TCOMPLEX64:
                return true, 3
-       case TFLOAT64, TCOMPLEX128:
+       case types.TFLOAT64, types.TCOMPLEX128:
                return true, 7
        }
 
@@ -826,8 +842,8 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 
        // The go/types API doesn't expose sizes to importers, so they
        // don't know how big these types are.
-       switch typ.Etype {
-       case TINT, TUINT, TUINTPTR:
+       switch typ.Kind() {
+       case types.TINT, types.TUINT, types.TUINTPTR:
                maxBytes = 8
        }
 
@@ -852,22 +868,24 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 // according to the maximum number of bytes needed to encode a value
 // of type typ. As a special case, 8-bit types are always encoded as a
 // single byte.
-//
-// TODO(mdempsky): Is this level of complexity really worthwhile?
-func (w *exportWriter) mpint(x *big.Int, typ *types.Type) {
+func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
        signed, maxBytes := intSize(typ)
 
-       negative := x.Sign() < 0
+       negative := constant.Sign(x) < 0
        if !signed && negative {
-               Fatalf("negative unsigned integer; type %v, value %v", typ, x)
+               base.Fatalf("negative unsigned integer; type %v, value %v", typ, x)
+       }
+
+       b := constant.Bytes(x) // little endian
+       for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
+               b[i], b[j] = b[j], b[i]
        }
 
-       b := x.Bytes()
        if len(b) > 0 && b[0] == 0 {
-               Fatalf("leading zeros")
+               base.Fatalf("leading zeros")
        }
        if uint(len(b)) > maxBytes {
-               Fatalf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x)
+               base.Fatalf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x)
        }
 
        maxSmall := 256 - maxBytes
@@ -904,7 +922,7 @@ func (w *exportWriter) mpint(x *big.Int, typ *types.Type) {
                }
        }
        if n < maxSmall || n >= 256 {
-               Fatalf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n)
+               base.Fatalf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n)
        }
 
        w.data.WriteByte(byte(n))
@@ -917,9 +935,10 @@ func (w *exportWriter) mpint(x *big.Int, typ *types.Type) {
 // mantissa is an integer. The value is written out as mantissa (as a
 // multi-precision integer) and then the exponent, except exponent is
 // omitted if mantissa is zero.
-func (w *exportWriter) mpfloat(f *big.Float, typ *types.Type) {
+func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
+       f := ir.BigFloat(v)
        if f.IsInf() {
-               Fatalf("infinite constant")
+               base.Fatalf("infinite constant")
        }
 
        // Break into f = mant × 2**exp, with 0.5 <= mant < 1.
@@ -933,14 +952,25 @@ func (w *exportWriter) mpfloat(f *big.Float, typ *types.Type) {
 
        manti, acc := mant.Int(nil)
        if acc != big.Exact {
-               Fatalf("mantissa scaling failed for %f (%s)", f, acc)
+               base.Fatalf("mantissa scaling failed for %f (%s)", f, acc)
        }
-       w.mpint(manti, typ)
+       w.mpint(constant.Make(manti), typ)
        if manti.Sign() != 0 {
                w.int64(exp)
        }
 }
 
+func (w *exportWriter) mprat(v constant.Value) {
+       r, ok := constant.Val(v).(*big.Rat)
+       if !w.bool(ok) {
+               return
+       }
+       // TODO(mdempsky): Come up with a more efficient binary
+       // encoding before bumping iexportVersion to expose to
+       // gcimporter.
+       w.string(r.String())
+}
+
 func (w *exportWriter) bool(b bool) bool {
        var x uint64
        if b {
@@ -956,18 +986,51 @@ func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
 
 // Compiler-specific extensions.
 
-func (w *exportWriter) varExt(n *Node) {
-       w.linkname(n.Sym)
-       w.symIdx(n.Sym)
+func (w *exportWriter) constExt(n *ir.Name) {
+       // Internally, we now represent untyped float and complex
+       // constants with infinite-precision rational numbers using
+       // go/constant, but the "public" export data format known to
+       // gcimporter only supports 512-bit floating point constants.
+       // In case rationals turn out to be a bad idea and we want to
+       // switch back to fixed-precision constants, for now we
+       // continue writing out the 512-bit truncation in the public
+       // data section, and write the exact, rational constant in the
+       // compiler's extension data. Also, we only need to worry
+       // about exporting rationals for declared constants, because
+       // constants that appear in an expression will already have
+       // been coerced to a concrete, fixed-precision type.
+       //
+       // Eventually, assuming we stick with using rationals, we
+       // should bump iexportVersion to support rationals, and do the
+       // whole gcimporter update song-and-dance.
+       //
+       // TODO(mdempsky): Prepare vocals for that.
+
+       switch n.Type() {
+       case types.UntypedFloat:
+               w.mprat(n.Val())
+       case types.UntypedComplex:
+               v := n.Val()
+               w.mprat(constant.Real(v))
+               w.mprat(constant.Imag(v))
+       }
+}
+
+func (w *exportWriter) varExt(n *ir.Name) {
+       w.linkname(n.Sym())
+       w.symIdx(n.Sym())
 }
 
-func (w *exportWriter) funcExt(n *Node) {
-       w.linkname(n.Sym)
-       w.symIdx(n.Sym)
+func (w *exportWriter) funcExt(n *ir.Name) {
+       w.linkname(n.Sym())
+       w.symIdx(n.Sym())
+
+       // TODO remove after register abi is working.
+       w.uint64(uint64(n.Func.Pragma))
 
        // Escape analysis.
        for _, fs := range &types.RecvsParams {
-               for _, f := range fs(n.Type).FieldSlice() {
+               for _, f := range fs(n.Type()).FieldSlice() {
                        w.string(f.Note)
                }
        }
@@ -980,14 +1043,7 @@ func (w *exportWriter) funcExt(n *Node) {
                }
 
                // Endlineno for inlined function.
-               if n.Name.Defn != nil {
-                       w.pos(n.Name.Defn.Func.Endlineno)
-               } else {
-                       // When the exported node was defined externally,
-                       // e.g. io exports atomic.(*Value).Load or bytes exports errors.New.
-                       // Keep it as we don't distinguish this case in iimport.go.
-                       w.pos(n.Func.Endlineno)
-               }
+               w.pos(n.Func.Endlineno)
        } else {
                w.uint64(0)
        }
@@ -995,7 +1051,7 @@ func (w *exportWriter) funcExt(n *Node) {
 
 func (w *exportWriter) methExt(m *types.Field) {
        w.bool(m.Nointerface())
-       w.funcExt(asNode(m.Type.Nname()))
+       w.funcExt(m.Nname.(*ir.Name))
 }
 
 func (w *exportWriter) linkname(s *types.Sym) {
@@ -1025,21 +1081,38 @@ func (w *exportWriter) typeExt(t *types.Type) {
                w.int64(i[1])
                return
        }
-       w.symIdx(typesym(t))
-       w.symIdx(typesym(t.PtrTo()))
+       w.symIdx(types.TypeSym(t))
+       w.symIdx(types.TypeSym(t.PtrTo()))
 }
 
 // Inline bodies.
 
-func (w *exportWriter) stmtList(list Nodes) {
-       for _, n := range list.Slice() {
+func (w *exportWriter) writeNames(dcl []*ir.Name) {
+       w.int64(int64(len(dcl)))
+       for i, n := range dcl {
+               w.pos(n.Pos())
+               w.localIdent(n.Sym())
+               w.typ(n.Type())
+               w.dclIndex[n] = w.maxDclIndex + i
+       }
+       w.maxDclIndex += len(dcl)
+}
+
+func (w *exportWriter) funcBody(fn *ir.Func) {
+       w.writeNames(fn.Inl.Dcl)
+
+       w.stmtList(fn.Inl.Body)
+}
+
+func (w *exportWriter) stmtList(list []ir.Node) {
+       for _, n := range list {
                w.node(n)
        }
-       w.op(OEND)
+       w.op(ir.OEND)
 }
 
-func (w *exportWriter) node(n *Node) {
-       if opprec[n.Op] < 0 {
+func (w *exportWriter) node(n ir.Node) {
+       if ir.OpPrec[n.Op()] < 0 {
                w.stmt(n)
        } else {
                w.expr(n)
@@ -1048,384 +1121,473 @@ func (w *exportWriter) node(n *Node) {
 
 // Caution: stmt will emit more than one node for statement nodes n that have a non-empty
 // n.Ninit and where n cannot have a natural init section (such as in "if", "for", etc.).
-func (w *exportWriter) stmt(n *Node) {
-       if n.Ninit.Len() > 0 && !stmtwithinit(n.Op) {
+func (w *exportWriter) stmt(n ir.Node) {
+       if len(n.Init()) > 0 && !ir.StmtWithInit(n.Op()) {
                // can't use stmtList here since we don't want the final OEND
-               for _, n := range n.Ninit.Slice() {
+               for _, n := range n.Init() {
                        w.stmt(n)
                }
        }
 
-       switch op := n.Op; op {
-       case ODCL:
-               w.op(ODCL)
-               w.pos(n.Left.Pos)
-               w.localName(n.Left)
-               w.typ(n.Left.Type)
+       switch n.Op() {
+       case ir.OBLOCK:
+               // No OBLOCK in export data.
+               // Inline content into this statement list,
+               // like the init list above.
+               // (At the moment neither the parser nor the typechecker
+               // generate OBLOCK nodes except to denote an empty
+               // function body, although that may change.)
+               n := n.(*ir.BlockStmt)
+               for _, n := range n.List {
+                       w.stmt(n)
+               }
 
-       // case ODCLFIELD:
-       //      unimplemented - handled by default case
+       case ir.ODCL:
+               n := n.(*ir.Decl)
+               if ir.IsBlank(n.X) {
+                       return // blank declarations not useful to importers
+               }
+               w.op(ir.ODCL)
+               w.localName(n.X)
 
-       case OAS:
+       case ir.OAS:
                // Don't export "v = <N>" initializing statements, hope they're always
                // preceded by the DCL which will be re-parsed and typecheck to reproduce
                // the "v = <N>" again.
-               if n.Right != nil {
-                       w.op(OAS)
-                       w.pos(n.Pos)
-                       w.expr(n.Left)
-                       w.expr(n.Right)
+               n := n.(*ir.AssignStmt)
+               if n.Y != nil {
+                       w.op(ir.OAS)
+                       w.pos(n.Pos())
+                       w.expr(n.X)
+                       w.expr(n.Y)
                }
 
-       case OASOP:
-               w.op(OASOP)
-               w.pos(n.Pos)
-               w.op(n.SubOp())
-               w.expr(n.Left)
-               if w.bool(!n.Implicit()) {
-                       w.expr(n.Right)
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               w.op(ir.OASOP)
+               w.pos(n.Pos())
+               w.op(n.AsOp)
+               w.expr(n.X)
+               if w.bool(!n.IncDec) {
+                       w.expr(n.Y)
                }
 
-       case OAS2:
-               w.op(OAS2)
-               w.pos(n.Pos)
-               w.exprList(n.List)
-               w.exprList(n.Rlist)
+       case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+               n := n.(*ir.AssignListStmt)
+               w.op(ir.OAS2)
+               w.pos(n.Pos())
+               w.exprList(n.Lhs)
+               w.exprList(n.Rhs)
 
-       case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-               w.op(OAS2)
-               w.pos(n.Pos)
-               w.exprList(n.List)
-               w.exprList(asNodes([]*Node{n.Right}))
-
-       case ORETURN:
-               w.op(ORETURN)
-               w.pos(n.Pos)
-               w.exprList(n.List)
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               w.op(ir.ORETURN)
+               w.pos(n.Pos())
+               w.exprList(n.Results)
 
        // case ORETJMP:
        //      unreachable - generated by compiler for trampolin routines
 
-       case OGO, ODEFER:
-               w.op(op)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-
-       case OIF:
-               w.op(OIF)
-               w.pos(n.Pos)
-               w.stmtList(n.Ninit)
-               w.expr(n.Left)
-               w.stmtList(n.Nbody)
-               w.stmtList(n.Rlist)
-
-       case OFOR:
-               w.op(OFOR)
-               w.pos(n.Pos)
-               w.stmtList(n.Ninit)
-               w.exprsOrNil(n.Left, n.Right)
-               w.stmtList(n.Nbody)
-
-       case ORANGE:
-               w.op(ORANGE)
-               w.pos(n.Pos)
-               w.stmtList(n.List)
-               w.expr(n.Right)
-               w.stmtList(n.Nbody)
-
-       case OSELECT, OSWITCH:
-               w.op(op)
-               w.pos(n.Pos)
-               w.stmtList(n.Ninit)
-               w.exprsOrNil(n.Left, nil)
-               w.caseList(n)
+       case ir.OGO, ir.ODEFER:
+               n := n.(*ir.GoDeferStmt)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.Call)
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               w.op(ir.OIF)
+               w.pos(n.Pos())
+               w.stmtList(n.Init())
+               w.expr(n.Cond)
+               w.stmtList(n.Body)
+               w.stmtList(n.Else)
+
+       case ir.OFOR:
+               n := n.(*ir.ForStmt)
+               w.op(ir.OFOR)
+               w.pos(n.Pos())
+               w.stmtList(n.Init())
+               w.exprsOrNil(n.Cond, n.Post)
+               w.stmtList(n.Body)
+
+       case ir.ORANGE:
+               n := n.(*ir.RangeStmt)
+               w.op(ir.ORANGE)
+               w.pos(n.Pos())
+               w.exprsOrNil(n.Key, n.Value)
+               w.expr(n.X)
+               w.stmtList(n.Body)
+
+       case ir.OSELECT:
+               n := n.(*ir.SelectStmt)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.stmtList(n.Init())
+               w.commList(n.Cases)
+
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.stmtList(n.Init())
+               w.exprsOrNil(n.Tag, nil)
+               w.caseList(n.Cases, isNamedTypeSwitch(n.Tag))
 
        // case OCASE:
        //      handled by caseList
 
-       case OFALL:
-               w.op(OFALL)
-               w.pos(n.Pos)
-
-       case OBREAK, OCONTINUE:
-               w.op(op)
-               w.pos(n.Pos)
-               w.exprsOrNil(n.Left, nil)
-
-       case OEMPTY:
-               // nothing to emit
-
-       case OGOTO, OLABEL:
-               w.op(op)
-               w.pos(n.Pos)
-               w.string(n.Sym.Name)
+       case ir.OFALL:
+               n := n.(*ir.BranchStmt)
+               w.op(ir.OFALL)
+               w.pos(n.Pos())
+
+       case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
+               w.op(n.Op())
+               w.pos(n.Pos())
+               label := ""
+               if sym := n.Sym(); sym != nil {
+                       label = sym.Name
+               }
+               w.string(label)
 
        default:
-               Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op)
+               base.Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op())
        }
 }
 
-func (w *exportWriter) caseList(sw *Node) {
-       namedTypeSwitch := sw.Op == OSWITCH && sw.Left != nil && sw.Left.Op == OTYPESW && sw.Left.Left != nil
+func isNamedTypeSwitch(x ir.Node) bool {
+       guard, ok := x.(*ir.TypeSwitchGuard)
+       return ok && guard.Tag != nil
+}
 
-       cases := sw.List.Slice()
+func (w *exportWriter) caseList(cases []*ir.CaseClause, namedTypeSwitch bool) {
        w.uint64(uint64(len(cases)))
        for _, cas := range cases {
-               if cas.Op != OCASE {
-                       Fatalf("expected OCASE, got %v", cas)
-               }
-               w.pos(cas.Pos)
+               w.pos(cas.Pos())
                w.stmtList(cas.List)
                if namedTypeSwitch {
-                       w.localName(cas.Rlist.First())
+                       w.localName(cas.Var)
                }
-               w.stmtList(cas.Nbody)
+               w.stmtList(cas.Body)
        }
 }
 
-func (w *exportWriter) exprList(list Nodes) {
-       for _, n := range list.Slice() {
-               w.expr(n)
+func (w *exportWriter) commList(cases []*ir.CommClause) {
+       w.uint64(uint64(len(cases)))
+       for _, cas := range cases {
+               w.pos(cas.Pos())
+               w.node(cas.Comm)
+               w.stmtList(cas.Body)
        }
-       w.op(OEND)
 }
 
-func (w *exportWriter) expr(n *Node) {
-       // from nodefmt (fmt.go)
-       //
-       // nodefmt reverts nodes back to their original - we don't need to do
-       // it because we are not bound to produce valid Go syntax when exporting
-       //
-       // if (fmtmode != FExp || n.Op != OLITERAL) && n.Orig != nil {
-       //      n = n.Orig
-       // }
+func (w *exportWriter) exprList(list ir.Nodes) {
+       for _, n := range list {
+               w.expr(n)
+       }
+       w.op(ir.OEND)
+}
 
-       // from exprfmt (fmt.go)
-       for n.Op == OPAREN || n.Implicit() && (n.Op == ODEREF || n.Op == OADDR || n.Op == ODOT || n.Op == ODOTPTR) {
-               n = n.Left
+func simplifyForExport(n ir.Node) ir.Node {
+       switch n.Op() {
+       case ir.OPAREN:
+               n := n.(*ir.ParenExpr)
+               return simplifyForExport(n.X)
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               if n.Implicit() {
+                       return simplifyForExport(n.X)
+               }
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               if n.Implicit() {
+                       return simplifyForExport(n.X)
+               }
+       case ir.ODOT, ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               if n.Implicit() {
+                       return simplifyForExport(n.X)
+               }
        }
+       return n
+}
 
-       switch op := n.Op; op {
+func (w *exportWriter) expr(n ir.Node) {
+       n = simplifyForExport(n)
+       switch n.Op() {
        // expressions
        // (somewhat closely following the structure of exprfmt in fmt.go)
-       case OLITERAL:
-               if n.Val().Ctype() == CTNIL && n.Orig != nil && n.Orig != n {
-                       w.expr(n.Orig)
-                       break
-               }
-               w.op(OLITERAL)
-               w.pos(n.Pos)
-               w.value(n.Type, n.Val())
-
-       case ONAME:
-               // Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
-               // but for export, this should be rendered as (*pkg.T).meth.
-               // These nodes have the special property that they are names with a left OTYPE and a right ONAME.
-               if n.isMethodExpression() {
-                       w.op(OXDOT)
-                       w.pos(n.Pos)
-                       w.expr(n.Left) // n.Left.Op == OTYPE
-                       w.selector(n.Right.Sym)
-                       break
+       case ir.ONIL:
+               n := n.(*ir.NilExpr)
+               if !n.Type().HasNil() {
+                       base.Fatalf("unexpected type for nil: %v", n.Type())
                }
+               w.op(ir.ONIL)
+               w.pos(n.Pos())
+               w.typ(n.Type())
+
+       case ir.OLITERAL:
+               w.op(ir.OLITERAL)
+               w.pos(n.Pos())
+               w.value(n.Type(), n.Val())
 
+       case ir.ONAME:
                // Package scope name.
-               if (n.Class() == PEXTERN || n.Class() == PFUNC) && !n.isBlank() {
-                       w.op(ONONAME)
+               n := n.(*ir.Name)
+               if (n.Class == ir.PEXTERN || n.Class == ir.PFUNC) && !ir.IsBlank(n) {
+                       w.op(ir.ONONAME)
                        w.qualifiedIdent(n)
                        break
                }
 
                // Function scope name.
-               w.op(ONAME)
+               w.op(ir.ONAME)
                w.localName(n)
 
        // case OPACK, ONONAME:
        //      should have been resolved by typechecking - handled by default case
 
-       case OTYPE:
-               w.op(OTYPE)
-               w.typ(n.Type)
+       case ir.OTYPE:
+               w.op(ir.OTYPE)
+               w.typ(n.Type())
 
-       case OTYPESW:
-               w.op(OTYPESW)
-               w.pos(n.Pos)
+       case ir.OTYPESW:
+               n := n.(*ir.TypeSwitchGuard)
+               w.op(ir.OTYPESW)
+               w.pos(n.Pos())
                var s *types.Sym
-               if n.Left != nil {
-                       if n.Left.Op != ONONAME {
-                               Fatalf("expected ONONAME, got %v", n.Left)
+               if n.Tag != nil {
+                       if n.Tag.Op() != ir.ONONAME {
+                               base.Fatalf("expected ONONAME, got %v", n.Tag)
                        }
-                       s = n.Left.Sym
+                       s = n.Tag.Sym()
                }
-               w.localIdent(s, 0) // declared pseudo-variable, if any
-               w.exprsOrNil(n.Right, nil)
+               w.localIdent(s) // declared pseudo-variable, if any
+               w.expr(n.X)
 
        // case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
        //      should have been resolved by typechecking - handled by default case
 
-       // case OCLOSURE:
-       //      unimplemented - handled by default case
+       case ir.OCLOSURE:
+               n := n.(*ir.ClosureExpr)
+               w.op(ir.OCLOSURE)
+               w.pos(n.Pos())
+               w.signature(n.Type())
+
+               // Write out id for the Outer of each conditional variable. The
+               // conditional variable itself for this closure will be re-created
+               // during import.
+               w.int64(int64(len(n.Func.ClosureVars)))
+               for i, cv := range n.Func.ClosureVars {
+                       w.pos(cv.Pos())
+                       w.localName(cv.Outer)
+                       // Closure variable (which will be re-created during
+                       // import) is given via a negative id, starting at -2,
+                       // which is used to refer to it later in the function
+                       // during export. -1 represents blanks.
+                       w.dclIndex[cv] = -(i + 2) - w.maxClosureVarIndex
+               }
+               w.maxClosureVarIndex += len(n.Func.ClosureVars)
+
+               // like w.funcBody(n.Func), but not for .Inl
+               w.writeNames(n.Func.Dcl)
+               w.stmtList(n.Func.Body)
 
        // case OCOMPLIT:
        //      should have been resolved by typechecking - handled by default case
 
-       case OPTRLIT:
-               w.op(OADDR)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-
-       case OSTRUCTLIT:
-               w.op(OSTRUCTLIT)
-               w.pos(n.Pos)
-               w.typ(n.Type)
-               w.elemList(n.List) // special handling of field names
-
-       case OARRAYLIT, OSLICELIT, OMAPLIT:
-               w.op(OCOMPLIT)
-               w.pos(n.Pos)
-               w.typ(n.Type)
+       case ir.OPTRLIT:
+               n := n.(*ir.AddrExpr)
+               w.op(ir.OADDR)
+               w.pos(n.Pos())
+               w.expr(n.X)
+
+       case ir.OSTRUCTLIT:
+               n := n.(*ir.CompLitExpr)
+               w.op(ir.OSTRUCTLIT)
+               w.pos(n.Pos())
+               w.typ(n.Type())
+               w.fieldList(n.List) // special handling of field names
+
+       case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
+               n := n.(*ir.CompLitExpr)
+               w.op(ir.OCOMPLIT)
+               w.pos(n.Pos())
+               w.typ(n.Type())
                w.exprList(n.List)
 
-       case OKEY:
-               w.op(OKEY)
-               w.pos(n.Pos)
-               w.exprsOrNil(n.Left, n.Right)
+       case ir.OKEY:
+               n := n.(*ir.KeyExpr)
+               w.op(ir.OKEY)
+               w.pos(n.Pos())
+               w.expr(n.Key)
+               w.expr(n.Value)
 
        // case OSTRUCTKEY:
        //      unreachable - handled in case OSTRUCTLIT by elemList
 
-       case OCALLPART:
-               // An OCALLPART is an OXDOT before type checking.
-               w.op(OXDOT)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               // Right node should be ONAME
-               w.selector(n.Right.Sym)
-
-       case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-               w.op(OXDOT)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.selector(n.Sym)
-
-       case ODOTTYPE, ODOTTYPE2:
-               w.op(ODOTTYPE)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.typ(n.Type)
-
-       case OINDEX, OINDEXMAP:
-               w.op(OINDEX)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.expr(n.Right)
-
-       case OSLICE, OSLICESTR, OSLICEARR:
-               w.op(OSLICE)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               low, high, _ := n.SliceBounds()
-               w.exprsOrNil(low, high)
-
-       case OSLICE3, OSLICE3ARR:
-               w.op(OSLICE3)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               low, high, max := n.SliceBounds()
-               w.exprsOrNil(low, high)
-               w.expr(max)
-
-       case OCOPY, OCOMPLEX:
+       case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
+               n := n.(*ir.SelectorExpr)
+               w.op(ir.OXDOT)
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.selector(n.Sel)
+
+       case ir.ODOTTYPE, ir.ODOTTYPE2:
+               n := n.(*ir.TypeAssertExpr)
+               w.op(ir.ODOTTYPE)
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.typ(n.Type())
+
+       case ir.OINDEX, ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               w.op(ir.OINDEX)
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.expr(n.Index)
+
+       case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
+               n := n.(*ir.SliceExpr)
+               w.op(ir.OSLICE)
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.exprsOrNil(n.Low, n.High)
+
+       case ir.OSLICE3, ir.OSLICE3ARR:
+               n := n.(*ir.SliceExpr)
+               w.op(ir.OSLICE3)
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.exprsOrNil(n.Low, n.High)
+               w.expr(n.Max)
+
+       case ir.OCOPY, ir.OCOMPLEX:
                // treated like other builtin calls (see e.g., OREAL)
-               w.op(op)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.expr(n.Right)
-               w.op(OEND)
-
-       case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
-               w.op(OCONV)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.typ(n.Type)
-
-       case OREAL, OIMAG, OAPPEND, OCAP, OCLOSE, ODELETE, OLEN, OMAKE, ONEW, OPANIC, ORECOVER, OPRINT, OPRINTN:
-               w.op(op)
-               w.pos(n.Pos)
-               if n.Left != nil {
-                       w.expr(n.Left)
-                       w.op(OEND)
-               } else {
-                       w.exprList(n.List) // emits terminating OEND
-               }
+               n := n.(*ir.BinaryExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.expr(n.Y)
+               w.op(ir.OEND)
+
+       case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+               n := n.(*ir.ConvExpr)
+               w.op(ir.OCONV)
+               w.pos(n.Pos())
+               w.typ(n.Type())
+               w.expr(n.X)
+
+       case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
+               n := n.(*ir.UnaryExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.op(ir.OEND)
+
+       case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+               n := n.(*ir.CallExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.exprList(n.Args) // emits terminating OEND
                // only append() calls may contain '...' arguments
-               if op == OAPPEND {
-                       w.bool(n.IsDDD())
-               } else if n.IsDDD() {
-                       Fatalf("exporter: unexpected '...' with %v call", op)
+               if n.Op() == ir.OAPPEND {
+                       w.bool(n.IsDDD)
+               } else if n.IsDDD {
+                       base.Fatalf("exporter: unexpected '...' with %v call", n.Op())
                }
 
-       case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
-               w.op(OCALL)
-               w.pos(n.Pos)
-               w.stmtList(n.Ninit)
-               w.expr(n.Left)
-               w.exprList(n.List)
-               w.bool(n.IsDDD())
-
-       case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-               w.op(op) // must keep separate from OMAKE for importer
-               w.pos(n.Pos)
-               w.typ(n.Type)
+       case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
+               n := n.(*ir.CallExpr)
+               w.op(ir.OCALL)
+               w.pos(n.Pos())
+               w.stmtList(n.Init())
+               w.expr(n.X)
+               w.exprList(n.Args)
+               w.bool(n.IsDDD)
+
+       case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
+               n := n.(*ir.MakeExpr)
+               w.op(n.Op()) // must keep separate from OMAKE for importer
+               w.pos(n.Pos())
+               w.typ(n.Type())
                switch {
                default:
                        // empty list
-                       w.op(OEND)
-               case n.List.Len() != 0: // pre-typecheck
-                       w.exprList(n.List) // emits terminating OEND
-               case n.Right != nil:
-                       w.expr(n.Left)
-                       w.expr(n.Right)
-                       w.op(OEND)
-               case n.Left != nil && (n.Op == OMAKESLICE || !n.Left.Type.IsUntyped()):
-                       w.expr(n.Left)
-                       w.op(OEND)
+                       w.op(ir.OEND)
+               case n.Cap != nil:
+                       w.expr(n.Len)
+                       w.expr(n.Cap)
+                       w.op(ir.OEND)
+               case n.Len != nil && (n.Op() == ir.OMAKESLICE || !n.Len.Type().IsUntyped()):
+                       w.expr(n.Len)
+                       w.op(ir.OEND)
                }
 
        // unary expressions
-       case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
-               w.op(op)
-               w.pos(n.Pos)
-               w.expr(n.Left)
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+
+       case ir.OSEND:
+               n := n.(*ir.SendStmt)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.Chan)
+               w.expr(n.Value)
 
        // binary expressions
-       case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE, OLT,
-               OLSH, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSEND, OSUB, OXOR:
-               w.op(op)
-               w.pos(n.Pos)
-               w.expr(n.Left)
-               w.expr(n.Right)
-
-       case OADDSTR:
-               w.op(OADDSTR)
-               w.pos(n.Pos)
+       case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+               ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
+               n := n.(*ir.BinaryExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.expr(n.Y)
+
+       case ir.OANDAND, ir.OOROR:
+               n := n.(*ir.LogicalExpr)
+               w.op(n.Op())
+               w.pos(n.Pos())
+               w.expr(n.X)
+               w.expr(n.Y)
+
+       case ir.OADDSTR:
+               n := n.(*ir.AddStringExpr)
+               w.op(ir.OADDSTR)
+               w.pos(n.Pos())
                w.exprList(n.List)
 
-       case ODCLCONST:
+       case ir.ODCLCONST:
                // if exporting, DCLCONST should just be removed as its usage
                // has already been replaced with literals
 
        default:
-               Fatalf("cannot export %v (%d) node\n"+
-                       "\t==> please file an issue and assign to gri@", n.Op, int(n.Op))
+               base.Fatalf("cannot export %v (%d) node\n"+
+                       "\t==> please file an issue and assign to gri@", n.Op(), int(n.Op()))
        }
 }
 
-func (w *exportWriter) op(op Op) {
+func (w *exportWriter) op(op ir.Op) {
        w.uint64(uint64(op))
 }
 
-func (w *exportWriter) exprsOrNil(a, b *Node) {
+func (w *exportWriter) exprsOrNil(a, b ir.Node) {
        ab := 0
        if a != nil {
                ab |= 1
@@ -1442,31 +1604,34 @@ func (w *exportWriter) exprsOrNil(a, b *Node) {
        }
 }
 
-func (w *exportWriter) elemList(list Nodes) {
-       w.uint64(uint64(list.Len()))
-       for _, n := range list.Slice() {
-               w.selector(n.Sym)
-               w.expr(n.Left)
+func (w *exportWriter) fieldList(list ir.Nodes) {
+       w.uint64(uint64(len(list)))
+       for _, n := range list {
+               n := n.(*ir.StructKeyExpr)
+               w.pos(n.Pos())
+               w.selector(n.Field)
+               w.expr(n.Value)
        }
 }
 
-func (w *exportWriter) localName(n *Node) {
-       // Escape analysis happens after inline bodies are saved, but
-       // we're using the same ONAME nodes, so we might still see
-       // PAUTOHEAP here.
-       //
-       // Check for Stackcopy to identify PAUTOHEAP that came from
-       // PPARAM/PPARAMOUT, because we only want to include vargen in
-       // non-param names.
-       var v int32
-       if n.Class() == PAUTO || (n.Class() == PAUTOHEAP && n.Name.Param.Stackcopy == nil) {
-               v = n.Name.Vargen
+func (w *exportWriter) localName(n *ir.Name) {
+       if ir.IsBlank(n) {
+               w.int64(-1)
+               return
        }
 
-       w.localIdent(n.Sym, v)
+       i, ok := w.dclIndex[n]
+       if !ok {
+               base.FatalfAt(n.Pos(), "missing from dclIndex: %+v", n)
+       }
+       w.int64(int64(i))
 }
 
-func (w *exportWriter) localIdent(s *types.Sym, v int32) {
+func (w *exportWriter) localIdent(s *types.Sym) {
+       if w.currPkg == nil {
+               base.Fatalf("missing currPkg")
+       }
+
        // Anonymous parameters.
        if s == nil {
                w.string("")
@@ -1481,18 +1646,11 @@ func (w *exportWriter) localIdent(s *types.Sym, v int32) {
 
        // TODO(mdempsky): Fix autotmp hack.
        if i := strings.LastIndex(name, "."); i >= 0 && !strings.HasPrefix(name, ".autotmp_") {
-               Fatalf("unexpected dot in identifier: %v", name)
-       }
-
-       if v > 0 {
-               if strings.Contains(name, "·") {
-                       Fatalf("exporter: unexpected · in symbol name")
-               }
-               name = fmt.Sprintf("%s·%d", name, v)
+               base.Fatalf("unexpected dot in identifier: %v", name)
        }
 
-       if !types.IsExported(name) && s.Pkg != w.currPkg {
-               Fatalf("weird package in name: %v => %v, not %q", s, name, w.currPkg.Path)
+       if s.Pkg != w.currPkg {
+               base.Fatalf("weird package in name: %v => %v from %q, not %q", s, name, s.Pkg.Path, w.currPkg.Path)
        }
 
        w.string(name)

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
new file mode 100644 (file)
index 0000000..b73ef51
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -0,0 +1,1240 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed package import.
+// See iexport.go for the export data format.
+
+package typecheck
+
+import (
+       "encoding/binary"
+       "fmt"
+       "go/constant"
+       "io"
+       "math/big"
+       "os"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/bio"
+       "cmd/internal/goobj"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+// An iimporterAndOffset identifies an importer and an offset within
+// its data section.
+type iimporterAndOffset struct {
+       p   *iimporter
+       off uint64
+}
+
+var (
+       // DeclImporter maps from imported identifiers to an importer
+       // and offset where that identifier's declaration can be read.
+       DeclImporter = map[*types.Sym]iimporterAndOffset{}
+
+       // inlineImporter is like DeclImporter, but for inline bodies
+       // for function and method symbols.
+       inlineImporter = map[*types.Sym]iimporterAndOffset{}
+)
+
+func expandDecl(n ir.Node) ir.Node {
+       if n, ok := n.(*ir.Name); ok {
+               return n
+       }
+
+       id := n.(*ir.Ident)
+       if n := id.Sym().PkgDef(); n != nil {
+               return n.(*ir.Name)
+       }
+
+       r := importReaderFor(id.Sym(), DeclImporter)
+       if r == nil {
+               // Can happen if user tries to reference an undeclared name.
+               return n
+       }
+
+       return r.doDecl(n.Sym())
+}
+
+func ImportBody(fn *ir.Func) {
+       if fn.Inl.Body != nil {
+               return
+       }
+
+       r := importReaderFor(fn.Nname.Sym(), inlineImporter)
+       if r == nil {
+               base.Fatalf("missing import reader for %v", fn)
+       }
+
+       if inimport {
+               base.Fatalf("recursive inimport")
+       }
+       inimport = true
+       r.doInline(fn)
+       inimport = false
+}
+
+func importReaderFor(sym *types.Sym, importers map[*types.Sym]iimporterAndOffset) *importReader {
+       x, ok := importers[sym]
+       if !ok {
+               return nil
+       }
+
+       return x.p.newReader(x.off, sym.Pkg)
+}
+
+type intReader struct {
+       *bio.Reader
+       pkg *types.Pkg
+}
+
+func (r *intReader) int64() int64 {
+       i, err := binary.ReadVarint(r.Reader)
+       if err != nil {
+               base.Errorf("import %q: read error: %v", r.pkg.Path, err)
+               base.ErrorExit()
+       }
+       return i
+}
+
+func (r *intReader) uint64() uint64 {
+       i, err := binary.ReadUvarint(r.Reader)
+       if err != nil {
+               base.Errorf("import %q: read error: %v", r.pkg.Path, err)
+               base.ErrorExit()
+       }
+       return i
+}
+
+func ReadImports(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType) {
+       ird := &intReader{in, pkg}
+
+       version := ird.uint64()
+       if version != iexportVersion {
+               base.Errorf("import %q: unknown export format version %d", pkg.Path, version)
+               base.ErrorExit()
+       }
+
+       sLen := ird.uint64()
+       dLen := ird.uint64()
+
+       // Map string (and data) section into memory as a single large
+       // string. This reduces heap fragmentation and allows
+       // returning individual substrings very efficiently.
+       data, err := mapFile(in.File(), in.Offset(), int64(sLen+dLen))
+       if err != nil {
+               base.Errorf("import %q: mapping input: %v", pkg.Path, err)
+               base.ErrorExit()
+       }
+       stringData := data[:sLen]
+       declData := data[sLen:]
+
+       in.MustSeek(int64(sLen+dLen), os.SEEK_CUR)
+
+       p := &iimporter{
+               ipkg: pkg,
+
+               pkgCache:     map[uint64]*types.Pkg{},
+               posBaseCache: map[uint64]*src.PosBase{},
+               typCache:     map[uint64]*types.Type{},
+
+               stringData: stringData,
+               declData:   declData,
+       }
+
+       for i, pt := range predeclared() {
+               p.typCache[uint64(i)] = pt
+       }
+
+       // Declaration index.
+       for nPkgs := ird.uint64(); nPkgs > 0; nPkgs-- {
+               pkg := p.pkgAt(ird.uint64())
+               pkgName := p.stringAt(ird.uint64())
+               pkgHeight := int(ird.uint64())
+               if pkg.Name == "" {
+                       pkg.Name = pkgName
+                       pkg.Height = pkgHeight
+                       types.NumImport[pkgName]++
+
+                       // TODO(mdempsky): This belongs somewhere else.
+                       pkg.Lookup("_").Def = ir.BlankNode
+               } else {
+                       if pkg.Name != pkgName {
+                               base.Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
+                       }
+                       if pkg.Height != pkgHeight {
+                               base.Fatalf("conflicting package heights %v and %v for path %q", pkg.Height, pkgHeight, pkg.Path)
+                       }
+               }
+
+               for nSyms := ird.uint64(); nSyms > 0; nSyms-- {
+                       s := pkg.Lookup(p.stringAt(ird.uint64()))
+                       off := ird.uint64()
+
+                       if _, ok := DeclImporter[s]; !ok {
+                               DeclImporter[s] = iimporterAndOffset{p, off}
+                       }
+               }
+       }
+
+       // Inline body index.
+       for nPkgs := ird.uint64(); nPkgs > 0; nPkgs-- {
+               pkg := p.pkgAt(ird.uint64())
+
+               for nSyms := ird.uint64(); nSyms > 0; nSyms-- {
+                       s := pkg.Lookup(p.stringAt(ird.uint64()))
+                       off := ird.uint64()
+
+                       if _, ok := inlineImporter[s]; !ok {
+                               inlineImporter[s] = iimporterAndOffset{p, off}
+                       }
+               }
+       }
+
+       // Fingerprint.
+       _, err = io.ReadFull(in, fingerprint[:])
+       if err != nil {
+               base.Errorf("import %s: error reading fingerprint", pkg.Path)
+               base.ErrorExit()
+       }
+       return fingerprint
+}
+
+type iimporter struct {
+       ipkg *types.Pkg
+
+       pkgCache     map[uint64]*types.Pkg
+       posBaseCache map[uint64]*src.PosBase
+       typCache     map[uint64]*types.Type
+
+       stringData string
+       declData   string
+}
+
+func (p *iimporter) stringAt(off uint64) string {
+       var x [binary.MaxVarintLen64]byte
+       n := copy(x[:], p.stringData[off:])
+
+       slen, n := binary.Uvarint(x[:n])
+       if n <= 0 {
+               base.Fatalf("varint failed")
+       }
+       spos := off + uint64(n)
+       return p.stringData[spos : spos+slen]
+}
+
+func (p *iimporter) posBaseAt(off uint64) *src.PosBase {
+       if posBase, ok := p.posBaseCache[off]; ok {
+               return posBase
+       }
+
+       file := p.stringAt(off)
+       posBase := src.NewFileBase(file, file)
+       p.posBaseCache[off] = posBase
+       return posBase
+}
+
+func (p *iimporter) pkgAt(off uint64) *types.Pkg {
+       if pkg, ok := p.pkgCache[off]; ok {
+               return pkg
+       }
+
+       pkg := p.ipkg
+       if pkgPath := p.stringAt(off); pkgPath != "" {
+               pkg = types.NewPkg(pkgPath, "")
+       }
+       p.pkgCache[off] = pkg
+       return pkg
+}
+
+// An importReader keeps state for reading an individual imported
+// object (declaration or inline body).
+type importReader struct {
+       strings.Reader
+       p *iimporter
+
+       currPkg    *types.Pkg
+       prevBase   *src.PosBase
+       prevLine   int64
+       prevColumn int64
+
+       // curfn is the current function we're importing into.
+       curfn *ir.Func
+       // Slice of all dcls for function, including any interior closures
+       allDcls        []*ir.Name
+       allClosureVars []*ir.Name
+}
+
+func (p *iimporter) newReader(off uint64, pkg *types.Pkg) *importReader {
+       r := &importReader{
+               p:       p,
+               currPkg: pkg,
+       }
+       // (*strings.Reader).Reset wasn't added until Go 1.7, and we
+       // need to build with Go 1.4.
+       r.Reader = *strings.NewReader(p.declData[off:])
+       return r
+}
+
+func (r *importReader) string() string        { return r.p.stringAt(r.uint64()) }
+func (r *importReader) posBase() *src.PosBase { return r.p.posBaseAt(r.uint64()) }
+func (r *importReader) pkg() *types.Pkg       { return r.p.pkgAt(r.uint64()) }
+
+func (r *importReader) setPkg() {
+       r.currPkg = r.pkg()
+}
+
+func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
+       tag := r.byte()
+       pos := r.pos()
+
+       switch tag {
+       case 'A':
+               typ := r.typ()
+
+               return importalias(r.p.ipkg, pos, sym, typ)
+
+       case 'C':
+               typ := r.typ()
+               val := r.value(typ)
+
+               n := importconst(r.p.ipkg, pos, sym, typ, val)
+               r.constExt(n)
+               return n
+
+       case 'F':
+               typ := r.signature(nil)
+
+               n := importfunc(r.p.ipkg, pos, sym, typ)
+               r.funcExt(n)
+               return n
+
+       case 'T':
+               // Types can be recursive. We need to setup a stub
+               // declaration before recursing.
+               n := importtype(r.p.ipkg, pos, sym)
+               t := n.Type()
+
+               // We also need to defer width calculations until
+               // after the underlying type has been assigned.
+               types.DeferCheckSize()
+               underlying := r.typ()
+               t.SetUnderlying(underlying)
+               types.ResumeCheckSize()
+
+               if underlying.IsInterface() {
+                       r.typeExt(t)
+                       return n
+               }
+
+               ms := make([]*types.Field, r.uint64())
+               for i := range ms {
+                       mpos := r.pos()
+                       msym := r.selector()
+                       recv := r.param()
+                       mtyp := r.signature(recv)
+
+                       // MethodSym already marked m.Sym as a function.
+                       m := ir.NewNameAt(mpos, ir.MethodSym(recv.Type, msym))
+                       m.Class = ir.PFUNC
+                       m.SetType(mtyp)
+
+                       m.Func = ir.NewFunc(mpos)
+                       m.Func.Nname = m
+
+                       f := types.NewField(mpos, msym, mtyp)
+                       f.Nname = m
+                       ms[i] = f
+               }
+               t.Methods().Set(ms)
+
+               r.typeExt(t)
+               for _, m := range ms {
+                       r.methExt(m)
+               }
+               return n
+
+       case 'V':
+               typ := r.typ()
+
+               n := importvar(r.p.ipkg, pos, sym, typ)
+               r.varExt(n)
+               return n
+
+       default:
+               base.Fatalf("unexpected tag: %v", tag)
+               panic("unreachable")
+       }
+}
+
+func (p *importReader) value(typ *types.Type) constant.Value {
+       switch constTypeOf(typ) {
+       case constant.Bool:
+               return constant.MakeBool(p.bool())
+       case constant.String:
+               return constant.MakeString(p.string())
+       case constant.Int:
+               var i big.Int
+               p.mpint(&i, typ)
+               return constant.Make(&i)
+       case constant.Float:
+               return p.float(typ)
+       case constant.Complex:
+               return makeComplex(p.float(typ), p.float(typ))
+       }
+
+       base.Fatalf("unexpected value type: %v", typ)
+       panic("unreachable")
+}
+
+func (p *importReader) mpint(x *big.Int, typ *types.Type) {
+       signed, maxBytes := intSize(typ)
+
+       maxSmall := 256 - maxBytes
+       if signed {
+               maxSmall = 256 - 2*maxBytes
+       }
+       if maxBytes == 1 {
+               maxSmall = 256
+       }
+
+       n, _ := p.ReadByte()
+       if uint(n) < maxSmall {
+               v := int64(n)
+               if signed {
+                       v >>= 1
+                       if n&1 != 0 {
+                               v = ^v
+                       }
+               }
+               x.SetInt64(v)
+               return
+       }
+
+       v := -n
+       if signed {
+               v = -(n &^ 1) >> 1
+       }
+       if v < 1 || uint(v) > maxBytes {
+               base.Fatalf("weird decoding: %v, %v => %v", n, signed, v)
+       }
+       b := make([]byte, v)
+       p.Read(b)
+       x.SetBytes(b)
+       if signed && n&1 != 0 {
+               x.Neg(x)
+       }
+}
+
+func (p *importReader) float(typ *types.Type) constant.Value {
+       var mant big.Int
+       p.mpint(&mant, typ)
+       var f big.Float
+       f.SetInt(&mant)
+       if f.Sign() != 0 {
+               f.SetMantExp(&f, int(p.int64()))
+       }
+       return constant.Make(&f)
+}
+
+func (p *importReader) mprat(orig constant.Value) constant.Value {
+       if !p.bool() {
+               return orig
+       }
+       var rat big.Rat
+       rat.SetString(p.string())
+       return constant.Make(&rat)
+}
+
+func (r *importReader) ident(selector bool) *types.Sym {
+       name := r.string()
+       if name == "" {
+               return nil
+       }
+       pkg := r.currPkg
+       if selector && types.IsExported(name) {
+               pkg = types.LocalPkg
+       }
+       return pkg.Lookup(name)
+}
+
+func (r *importReader) localIdent() *types.Sym { return r.ident(false) }
+func (r *importReader) selector() *types.Sym   { return r.ident(true) }
+
+func (r *importReader) qualifiedIdent() *ir.Ident {
+       name := r.string()
+       pkg := r.pkg()
+       sym := pkg.Lookup(name)
+       return ir.NewIdent(src.NoXPos, sym)
+}
+
+func (r *importReader) pos() src.XPos {
+       delta := r.int64()
+       r.prevColumn += delta >> 1
+       if delta&1 != 0 {
+               delta = r.int64()
+               r.prevLine += delta >> 1
+               if delta&1 != 0 {
+                       r.prevBase = r.posBase()
+               }
+       }
+
+       if (r.prevBase == nil || r.prevBase.AbsFilename() == "") && r.prevLine == 0 && r.prevColumn == 0 {
+               // TODO(mdempsky): Remove once we reliably write
+               // position information for all nodes.
+               return src.NoXPos
+       }
+
+       if r.prevBase == nil {
+               base.Fatalf("missing posbase")
+       }
+       pos := src.MakePos(r.prevBase, uint(r.prevLine), uint(r.prevColumn))
+       return base.Ctxt.PosTable.XPos(pos)
+}
+
+func (r *importReader) typ() *types.Type {
+       return r.p.typAt(r.uint64())
+}
+
+func (p *iimporter) typAt(off uint64) *types.Type {
+       t, ok := p.typCache[off]
+       if !ok {
+               if off < predeclReserved {
+                       base.Fatalf("predeclared type missing from cache: %d", off)
+               }
+               t = p.newReader(off-predeclReserved, nil).typ1()
+               p.typCache[off] = t
+       }
+       return t
+}
+
+func (r *importReader) typ1() *types.Type {
+       switch k := r.kind(); k {
+       default:
+               base.Fatalf("unexpected kind tag in %q: %v", r.p.ipkg.Path, k)
+               return nil
+
+       case definedType:
+               // We might be called from within doInline, in which
+               // case Sym.Def can point to declared parameters
+               // instead of the top-level types. Also, we don't
+               // support inlining functions with local defined
+               // types. Therefore, this must be a package-scope
+               // type.
+               n := expandDecl(r.qualifiedIdent())
+               if n.Op() != ir.OTYPE {
+                       base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op(), n.Sym(), n)
+               }
+               return n.Type()
+       case pointerType:
+               return types.NewPtr(r.typ())
+       case sliceType:
+               return types.NewSlice(r.typ())
+       case arrayType:
+               n := r.uint64()
+               return types.NewArray(r.typ(), int64(n))
+       case chanType:
+               dir := types.ChanDir(r.uint64())
+               return types.NewChan(r.typ(), dir)
+       case mapType:
+               return types.NewMap(r.typ(), r.typ())
+
+       case signatureType:
+               r.setPkg()
+               return r.signature(nil)
+
+       case structType:
+               r.setPkg()
+
+               fs := make([]*types.Field, r.uint64())
+               for i := range fs {
+                       pos := r.pos()
+                       sym := r.selector()
+                       typ := r.typ()
+                       emb := r.bool()
+                       note := r.string()
+
+                       f := types.NewField(pos, sym, typ)
+                       if emb {
+                               f.Embedded = 1
+                       }
+                       f.Note = note
+                       fs[i] = f
+               }
+
+               return types.NewStruct(r.currPkg, fs)
+
+       case interfaceType:
+               r.setPkg()
+
+               embeddeds := make([]*types.Field, r.uint64())
+               for i := range embeddeds {
+                       pos := r.pos()
+                       typ := r.typ()
+
+                       embeddeds[i] = types.NewField(pos, nil, typ)
+               }
+
+               methods := make([]*types.Field, r.uint64())
+               for i := range methods {
+                       pos := r.pos()
+                       sym := r.selector()
+                       typ := r.signature(fakeRecvField())
+
+                       methods[i] = types.NewField(pos, sym, typ)
+               }
+
+               t := types.NewInterface(r.currPkg, append(embeddeds, methods...))
+
+               // Ensure we expand the interface in the frontend (#25055).
+               types.CheckSize(t)
+               return t
+       }
+}
+
+func (r *importReader) kind() itag {
+       return itag(r.uint64())
+}
+
+func (r *importReader) signature(recv *types.Field) *types.Type {
+       params := r.paramList()
+       results := r.paramList()
+       if n := len(params); n > 0 {
+               params[n-1].SetIsDDD(r.bool())
+       }
+       return types.NewSignature(r.currPkg, recv, params, results)
+}
+
+func (r *importReader) paramList() []*types.Field {
+       fs := make([]*types.Field, r.uint64())
+       for i := range fs {
+               fs[i] = r.param()
+       }
+       return fs
+}
+
+func (r *importReader) param() *types.Field {
+       return types.NewField(r.pos(), r.localIdent(), r.typ())
+}
+
+func (r *importReader) bool() bool {
+       return r.uint64() != 0
+}
+
+func (r *importReader) int64() int64 {
+       n, err := binary.ReadVarint(r)
+       if err != nil {
+               base.Fatalf("readVarint: %v", err)
+       }
+       return n
+}
+
+func (r *importReader) uint64() uint64 {
+       n, err := binary.ReadUvarint(r)
+       if err != nil {
+               base.Fatalf("readVarint: %v", err)
+       }
+       return n
+}
+
+func (r *importReader) byte() byte {
+       x, err := r.ReadByte()
+       if err != nil {
+               base.Fatalf("declReader.ReadByte: %v", err)
+       }
+       return x
+}
+
+// Compiler-specific extensions.
+
+func (r *importReader) constExt(n *ir.Name) {
+       switch n.Type() {
+       case types.UntypedFloat:
+               n.SetVal(r.mprat(n.Val()))
+       case types.UntypedComplex:
+               v := n.Val()
+               re := r.mprat(constant.Real(v))
+               im := r.mprat(constant.Imag(v))
+               n.SetVal(makeComplex(re, im))
+       }
+}
+
+func (r *importReader) varExt(n *ir.Name) {
+       r.linkname(n.Sym())
+       r.symIdx(n.Sym())
+}
+
+func (r *importReader) funcExt(n *ir.Name) {
+       r.linkname(n.Sym())
+       r.symIdx(n.Sym())
+
+       // TODO remove after register abi is working
+       n.SetPragma(ir.PragmaFlag(r.uint64()))
+
+       // Escape analysis.
+       for _, fs := range &types.RecvsParams {
+               for _, f := range fs(n.Type()).FieldSlice() {
+                       f.Note = r.string()
+               }
+       }
+
+       // Inline body.
+       if u := r.uint64(); u > 0 {
+               n.Func.Inl = &ir.Inline{
+                       Cost: int32(u - 1),
+               }
+               n.Func.Endlineno = r.pos()
+       }
+}
+
+func (r *importReader) methExt(m *types.Field) {
+       if r.bool() {
+               m.SetNointerface(true)
+       }
+       r.funcExt(m.Nname.(*ir.Name))
+}
+
+func (r *importReader) linkname(s *types.Sym) {
+       s.Linkname = r.string()
+}
+
+func (r *importReader) symIdx(s *types.Sym) {
+       lsym := s.Linksym()
+       idx := int32(r.int64())
+       if idx != -1 {
+               if s.Linkname != "" {
+                       base.Fatalf("bad index for linknamed symbol: %v %d\n", lsym, idx)
+               }
+               lsym.SymIdx = idx
+               lsym.Set(obj.AttrIndexed, true)
+       }
+}
+
+func (r *importReader) typeExt(t *types.Type) {
+       t.SetNotInHeap(r.bool())
+       i, pi := r.int64(), r.int64()
+       if i != -1 && pi != -1 {
+               typeSymIdx[t] = [2]int64{i, pi}
+       }
+}
+
+// Map imported type T to the index of type descriptor symbols of T and *T,
+// so we can use index to reference the symbol.
+var typeSymIdx = make(map[*types.Type][2]int64)
+
+func BaseTypeIndex(t *types.Type) int64 {
+       tbase := t
+       if t.IsPtr() && t.Sym() == nil && t.Elem().Sym() != nil {
+               tbase = t.Elem()
+       }
+       i, ok := typeSymIdx[tbase]
+       if !ok {
+               return -1
+       }
+       if t != tbase {
+               return i[1]
+       }
+       return i[0]
+}
+
+func (r *importReader) doInline(fn *ir.Func) {
+       if len(fn.Inl.Body) != 0 {
+               base.Fatalf("%v already has inline body", fn)
+       }
+
+       //fmt.Printf("Importing %v\n", n)
+       r.funcBody(fn)
+
+       importlist = append(importlist, fn)
+
+       if base.Flag.E > 0 && base.Flag.LowerM > 2 {
+               if base.Flag.LowerM > 3 {
+                       fmt.Printf("inl body for %v %v: %+v\n", fn, fn.Type(), ir.Nodes(fn.Inl.Body))
+               } else {
+                       fmt.Printf("inl body for %v %v: %v\n", fn, fn.Type(), ir.Nodes(fn.Inl.Body))
+               }
+       }
+}
+
+// ----------------------------------------------------------------------------
+// Inlined function bodies
+
+// Approach: Read nodes and use them to create/declare the same data structures
+// as done originally by the (hidden) parser by closely following the parser's
+// original code. In other words, "parsing" the import data (which happens to
+// be encoded in binary rather textual form) is the best way at the moment to
+// re-establish the syntax tree's invariants. At some future point we might be
+// able to avoid this round-about way and create the rewritten nodes directly,
+// possibly avoiding a lot of duplicate work (name resolution, type checking).
+//
+// Refined nodes (e.g., ODOTPTR as a refinement of OXDOT) are exported as their
+// unrefined nodes (since this is what the importer uses). The respective case
+// entries are unreachable in the importer.
+
+func (r *importReader) funcBody(fn *ir.Func) {
+       outerfn := r.curfn
+       r.curfn = fn
+
+       // Import local declarations.
+       fn.Inl.Dcl = r.readFuncDcls(fn)
+
+       // Import function body.
+       body := r.stmtList()
+       if body == nil {
+               // Make sure empty body is not interpreted as
+               // no inlineable body (see also parser.fnbody)
+               // (not doing so can cause significant performance
+               // degradation due to unnecessary calls to empty
+               // functions).
+               body = []ir.Node{}
+       }
+       fn.Inl.Body = body
+
+       r.curfn = outerfn
+}
+
+func (r *importReader) readNames(fn *ir.Func) []*ir.Name {
+       dcls := make([]*ir.Name, r.int64())
+       for i := range dcls {
+               n := ir.NewDeclNameAt(r.pos(), ir.ONAME, r.localIdent())
+               n.Class = ir.PAUTO // overwritten below for parameters/results
+               n.Curfn = fn
+               n.SetType(r.typ())
+               dcls[i] = n
+       }
+       r.allDcls = append(r.allDcls, dcls...)
+       return dcls
+}
+
+func (r *importReader) readFuncDcls(fn *ir.Func) []*ir.Name {
+       dcls := r.readNames(fn)
+
+       // Fixup parameter classes and associate with their
+       // signature's type fields.
+       i := 0
+       fix := func(f *types.Field, class ir.Class) {
+               if class == ir.PPARAM && (f.Sym == nil || f.Sym.Name == "_") {
+                       return
+               }
+               n := dcls[i]
+               n.Class = class
+               f.Nname = n
+               i++
+       }
+
+       typ := fn.Type()
+       if recv := typ.Recv(); recv != nil {
+               fix(recv, ir.PPARAM)
+       }
+       for _, f := range typ.Params().FieldSlice() {
+               fix(f, ir.PPARAM)
+       }
+       for _, f := range typ.Results().FieldSlice() {
+               fix(f, ir.PPARAMOUT)
+       }
+       return dcls
+}
+
+func (r *importReader) localName() *ir.Name {
+       i := r.int64()
+       if i == -1 {
+               return ir.BlankNode.(*ir.Name)
+       }
+       if i < 0 {
+               return r.allClosureVars[-i-2]
+       }
+       return r.allDcls[i]
+}
+
+func (r *importReader) stmtList() []ir.Node {
+       var list []ir.Node
+       for {
+               n := r.node()
+               if n == nil {
+                       break
+               }
+               // OBLOCK nodes are not written to the import data directly,
+               // but the handling of ODCL calls liststmt, which creates one.
+               // Inline them into the statement list.
+               if n.Op() == ir.OBLOCK {
+                       n := n.(*ir.BlockStmt)
+                       list = append(list, n.List...)
+               } else {
+                       list = append(list, n)
+               }
+
+       }
+       return list
+}
+
+func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
+       namedTypeSwitch := isNamedTypeSwitch(switchExpr)
+
+       cases := make([]*ir.CaseClause, r.uint64())
+       for i := range cases {
+               cas := ir.NewCaseStmt(r.pos(), nil, nil)
+               cas.List = r.stmtList()
+               if namedTypeSwitch {
+                       cas.Var = r.localName()
+                       cas.Var.Defn = switchExpr
+               }
+               cas.Body = r.stmtList()
+               cases[i] = cas
+       }
+       return cases
+}
+
+func (r *importReader) commList() []*ir.CommClause {
+       cases := make([]*ir.CommClause, r.uint64())
+       for i := range cases {
+               cases[i] = ir.NewCommStmt(r.pos(), r.node(), r.stmtList())
+       }
+       return cases
+}
+
+func (r *importReader) exprList() []ir.Node {
+       var list []ir.Node
+       for {
+               n := r.expr()
+               if n == nil {
+                       break
+               }
+               list = append(list, n)
+       }
+       return list
+}
+
+func (r *importReader) expr() ir.Node {
+       n := r.node()
+       if n != nil && n.Op() == ir.OBLOCK {
+               n := n.(*ir.BlockStmt)
+               base.Fatalf("unexpected block node: %v", n)
+       }
+       return n
+}
+
+// TODO(gri) split into expr and stmt
+func (r *importReader) node() ir.Node {
+       switch op := r.op(); op {
+       // expressions
+       // case OPAREN:
+       //      unreachable - unpacked by exporter
+
+       case ir.ONIL:
+               pos := r.pos()
+               typ := r.typ()
+
+               n := ir.NewNilExpr(pos)
+               n.SetType(typ)
+               return n
+
+       case ir.OLITERAL:
+               pos := r.pos()
+               typ := r.typ()
+
+               n := ir.NewBasicLit(pos, r.value(typ))
+               n.SetType(typ)
+               return n
+
+       case ir.ONONAME:
+               return r.qualifiedIdent()
+
+       case ir.ONAME:
+               return r.localName()
+
+       // case OPACK, ONONAME:
+       //      unreachable - should have been resolved by typechecking
+
+       case ir.OTYPE:
+               return ir.TypeNode(r.typ())
+
+       case ir.OTYPESW:
+               pos := r.pos()
+               var tag *ir.Ident
+               if s := r.localIdent(); s != nil {
+                       tag = ir.NewIdent(pos, s)
+               }
+               return ir.NewTypeSwitchGuard(pos, tag, r.expr())
+
+       // case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
+       //      unreachable - should have been resolved by typechecking
+
+       case ir.OCLOSURE:
+               //println("Importing CLOSURE")
+               pos := r.pos()
+               typ := r.signature(nil)
+
+               // All the remaining code below is similar to (*noder).funcLit(), but
+               // with Dcls and ClosureVars lists already set up
+               fn := ir.NewFunc(pos)
+               fn.SetIsHiddenClosure(true)
+               fn.Nname = ir.NewNameAt(pos, ir.BlankNode.Sym())
+               fn.Nname.Func = fn
+               fn.Nname.Ntype = ir.TypeNode(typ)
+               fn.Nname.Defn = fn
+               fn.Nname.SetType(typ)
+
+               cvars := make([]*ir.Name, r.int64())
+               for i := range cvars {
+                       cvars[i] = ir.CaptureName(r.pos(), fn, r.localName().Canonical())
+               }
+               fn.ClosureVars = cvars
+               r.allClosureVars = append(r.allClosureVars, cvars...)
+
+               fn.Dcl = r.readFuncDcls(fn)
+               body := r.stmtList()
+               ir.FinishCaptureNames(pos, r.curfn, fn)
+
+               clo := ir.NewClosureExpr(pos, fn)
+               fn.OClosure = clo
+
+               fn.Body = body
+
+               return clo
+
+       // case OPTRLIT:
+       //      unreachable - mapped to case OADDR below by exporter
+
+       case ir.OSTRUCTLIT:
+               return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.fieldList())
+
+       // case OARRAYLIT, OSLICELIT, OMAPLIT:
+       //      unreachable - mapped to case OCOMPLIT below by exporter
+
+       case ir.OCOMPLIT:
+               return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.exprList())
+
+       case ir.OKEY:
+               return ir.NewKeyExpr(r.pos(), r.expr(), r.expr())
+
+       // case OSTRUCTKEY:
+       //      unreachable - handled in case OSTRUCTLIT by elemList
+
+       // case OCALLPART:
+       //      unreachable - mapped to case OXDOT below by exporter
+
+       // case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
+       //      unreachable - mapped to case OXDOT below by exporter
+
+       case ir.OXDOT:
+               // see parser.new_dotname
+               return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.selector())
+
+       // case ODOTTYPE, ODOTTYPE2:
+       //      unreachable - mapped to case ODOTTYPE below by exporter
+
+       case ir.ODOTTYPE:
+               n := ir.NewTypeAssertExpr(r.pos(), r.expr(), nil)
+               n.SetType(r.typ())
+               return n
+
+       // case OINDEX, OINDEXMAP, OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
+       //      unreachable - mapped to cases below by exporter
+
+       case ir.OINDEX:
+               return ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
+
+       case ir.OSLICE, ir.OSLICE3:
+               pos, x := r.pos(), r.expr()
+               low, high := r.exprsOrNil()
+               var max ir.Node
+               if op.IsSlice3() {
+                       max = r.expr()
+               }
+               return ir.NewSliceExpr(pos, op, x, low, high, max)
+
+       // case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
+       //      unreachable - mapped to OCONV case below by exporter
+
+       case ir.OCONV:
+               return ir.NewConvExpr(r.pos(), ir.OCONV, r.typ(), r.expr())
+
+       case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+               n := builtinCall(r.pos(), op)
+               n.Args = r.exprList()
+               if op == ir.OAPPEND {
+                       n.IsDDD = r.bool()
+               }
+               return n
+
+       // case OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
+       //      unreachable - mapped to OCALL case below by exporter
+
+       case ir.OCALL:
+               pos := r.pos()
+               init := r.stmtList()
+               n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
+               *n.PtrInit() = init
+               n.IsDDD = r.bool()
+               return n
+
+       case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
+               n := builtinCall(r.pos(), ir.OMAKE)
+               n.Args.Append(ir.TypeNode(r.typ()))
+               n.Args.Append(r.exprList()...)
+               return n
+
+       // unary expressions
+       case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
+               return ir.NewUnaryExpr(r.pos(), op, r.expr())
+
+       case ir.OADDR:
+               return NodAddrAt(r.pos(), r.expr())
+
+       case ir.ODEREF:
+               return ir.NewStarExpr(r.pos(), r.expr())
+
+       // binary expressions
+       case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+               ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
+               return ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
+
+       case ir.OANDAND, ir.OOROR:
+               return ir.NewLogicalExpr(r.pos(), op, r.expr(), r.expr())
+
+       case ir.OSEND:
+               return ir.NewSendStmt(r.pos(), r.expr(), r.expr())
+
+       case ir.OADDSTR:
+               pos := r.pos()
+               list := r.exprList()
+               x := list[0]
+               for _, y := range list[1:] {
+                       x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
+               }
+               return x
+
+       // --------------------------------------------------------------------
+       // statements
+       case ir.ODCL:
+               var stmts ir.Nodes
+               n := r.localName()
+               stmts.Append(ir.NewDecl(n.Pos(), ir.ODCL, n))
+               stmts.Append(ir.NewAssignStmt(n.Pos(), n, nil))
+               return ir.NewBlockStmt(n.Pos(), stmts)
+
+       // case OAS, OASWB:
+       //      unreachable - mapped to OAS case below by exporter
+
+       case ir.OAS:
+               return ir.NewAssignStmt(r.pos(), r.expr(), r.expr())
+
+       case ir.OASOP:
+               n := ir.NewAssignOpStmt(r.pos(), r.op(), r.expr(), nil)
+               if !r.bool() {
+                       n.Y = ir.NewInt(1)
+                       n.IncDec = true
+               } else {
+                       n.Y = r.expr()
+               }
+               return n
+
+       // case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+       //      unreachable - mapped to OAS2 case below by exporter
+
+       case ir.OAS2:
+               return ir.NewAssignListStmt(r.pos(), ir.OAS2, r.exprList(), r.exprList())
+
+       case ir.ORETURN:
+               return ir.NewReturnStmt(r.pos(), r.exprList())
+
+       // case ORETJMP:
+       //      unreachable - generated by compiler for trampolin routines (not exported)
+
+       case ir.OGO, ir.ODEFER:
+               return ir.NewGoDeferStmt(r.pos(), op, r.expr())
+
+       case ir.OIF:
+               pos, init := r.pos(), r.stmtList()
+               n := ir.NewIfStmt(pos, r.expr(), r.stmtList(), r.stmtList())
+               *n.PtrInit() = init
+               return n
+
+       case ir.OFOR:
+               pos, init := r.pos(), r.stmtList()
+               cond, post := r.exprsOrNil()
+               n := ir.NewForStmt(pos, nil, cond, post, r.stmtList())
+               *n.PtrInit() = init
+               return n
+
+       case ir.ORANGE:
+               pos := r.pos()
+               k, v := r.exprsOrNil()
+               return ir.NewRangeStmt(pos, k, v, r.expr(), r.stmtList())
+
+       case ir.OSELECT:
+               pos := r.pos()
+               init := r.stmtList()
+               n := ir.NewSelectStmt(pos, r.commList())
+               *n.PtrInit() = init
+               return n
+
+       case ir.OSWITCH:
+               pos := r.pos()
+               init := r.stmtList()
+               x, _ := r.exprsOrNil()
+               n := ir.NewSwitchStmt(pos, x, r.caseList(x))
+               *n.PtrInit() = init
+               return n
+
+       // case OCASE:
+       //      handled by caseList
+
+       case ir.OFALL:
+               return ir.NewBranchStmt(r.pos(), ir.OFALL, nil)
+
+       // case OEMPTY:
+       //      unreachable - not emitted by exporter
+
+       case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
+               pos := r.pos()
+               var sym *types.Sym
+               if label := r.string(); label != "" {
+                       sym = Lookup(label)
+               }
+               return ir.NewBranchStmt(pos, op, sym)
+
+       case ir.OLABEL:
+               return ir.NewLabelStmt(r.pos(), Lookup(r.string()))
+
+       case ir.OEND:
+               return nil
+
+       default:
+               base.Fatalf("cannot import %v (%d) node\n"+
+                       "\t==> please file an issue and assign to gri@", op, int(op))
+               panic("unreachable") // satisfy compiler
+       }
+}
+
+func (r *importReader) op() ir.Op {
+       return ir.Op(r.uint64())
+}
+
+func (r *importReader) fieldList() []ir.Node {
+       list := make([]ir.Node, r.uint64())
+       for i := range list {
+               list[i] = ir.NewStructKeyExpr(r.pos(), r.selector(), r.expr())
+       }
+       return list
+}
+
+func (r *importReader) exprsOrNil() (a, b ir.Node) {
+       ab := r.uint64()
+       if ab&1 != 0 {
+               a = r.expr()
+       }
+       if ab&2 != 0 {
+               b = r.node()
+       }
+       return
+}
+
+func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
+       return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
+}

diff --git a/src/cmd/compile/internal/gc/mapfile_mmap.go b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
similarity index 98%
rename from src/cmd/compile/internal/gc/mapfile_mmap.go
rename to src/cmd/compile/internal/typecheck/mapfile_mmap.go
index 9483688d68034d254ff250c6c75ba1df02a2b949..2f3aa16decfaa6ef297678dffd4c04422bb016b3 100644 (file)
--- a/src/cmd/compile/internal/gc/mapfile_mmap.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
@@ -4,7 +4,7 @@
 
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
-package gc
+package typecheck
 
 import (
        "os"

diff --git a/src/cmd/compile/internal/gc/mapfile_read.go b/src/cmd/compile/internal/typecheck/mapfile_read.go
similarity index 96%
rename from src/cmd/compile/internal/gc/mapfile_read.go
rename to src/cmd/compile/internal/typecheck/mapfile_read.go
index c6f68ed5df7a771939c164f67f7d130a5c1f043d..4059f261d4932a3b7646b298420f5eb88bd0620b 100644 (file)
--- a/src/cmd/compile/internal/gc/mapfile_read.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_read.go
@@ -4,7 +4,7 @@
 
 // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
 
-package gc
+package typecheck
 
 import (
        "io"

diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
similarity index 83%
rename from src/cmd/compile/internal/gc/mkbuiltin.go
rename to src/cmd/compile/internal/typecheck/mkbuiltin.go
index 63d2a12c079d6a3cd850406de94fedf696e63956..07f4b767e8f8de2c19ef7979f21af6940b1e4f77 100644 (file)
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -33,9 +33,12 @@ func main() {
        var b bytes.Buffer
        fmt.Fprintln(&b, "// Code generated by mkbuiltin.go. DO NOT EDIT.")
        fmt.Fprintln(&b)
-       fmt.Fprintln(&b, "package gc")
+       fmt.Fprintln(&b, "package typecheck")
        fmt.Fprintln(&b)
-       fmt.Fprintln(&b, `import "cmd/compile/internal/types"`)
+       fmt.Fprintln(&b, `import (`)
+       fmt.Fprintln(&b, `      "cmd/compile/internal/types"`)
+       fmt.Fprintln(&b, `      "cmd/internal/src"`)
+       fmt.Fprintln(&b, `)`)
 
        mkbuiltin(&b, "runtime")
 
@@ -140,16 +143,16 @@ func (i *typeInterner) mktype(t ast.Expr) string {
        case *ast.Ident:
                switch t.Name {
                case "byte":
-                       return "types.Bytetype"
+                       return "types.ByteType"
                case "rune":
-                       return "types.Runetype"
+                       return "types.RuneType"
                }
-               return fmt.Sprintf("types.Types[T%s]", strings.ToUpper(t.Name))
+               return fmt.Sprintf("types.Types[types.T%s]", strings.ToUpper(t.Name))
        case *ast.SelectorExpr:
                if t.X.(*ast.Ident).Name != "unsafe" || t.Sel.Name != "Pointer" {
                        log.Fatalf("unhandled type: %#v", t)
                }
-               return "types.Types[TUNSAFEPTR]"
+               return "types.Types[types.TUNSAFEPTR]"
 
        case *ast.ArrayType:
                if t.Len == nil {
@@ -166,18 +169,18 @@ func (i *typeInterner) mktype(t ast.Expr) string {
                }
                return fmt.Sprintf("types.NewChan(%s, %s)", i.subtype(t.Value), dir)
        case *ast.FuncType:
-               return fmt.Sprintf("functype(nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
+               return fmt.Sprintf("types.NewSignature(types.NoPkg, nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
        case *ast.InterfaceType:
                if len(t.Methods.List) != 0 {
                        log.Fatal("non-empty interfaces unsupported")
                }
-               return "types.Types[TINTER]"
+               return "types.Types[types.TINTER]"
        case *ast.MapType:
                return fmt.Sprintf("types.NewMap(%s, %s)", i.subtype(t.Key), i.subtype(t.Value))
        case *ast.StarExpr:
                return fmt.Sprintf("types.NewPtr(%s)", i.subtype(t.X))
        case *ast.StructType:
-               return fmt.Sprintf("tostruct(%s)", i.fields(t.Fields, true))
+               return fmt.Sprintf("types.NewStruct(types.NoPkg, %s)", i.fields(t.Fields, true))
 
        default:
                log.Fatalf("unhandled type: %#v", t)
@@ -193,18 +196,18 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
        for _, f := range fl.List {
                typ := i.subtype(f.Type)
                if len(f.Names) == 0 {
-                       res = append(res, fmt.Sprintf("anonfield(%s)", typ))
+                       res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
                } else {
                        for _, name := range f.Names {
                                if keepNames {
-                                       res = append(res, fmt.Sprintf("namedfield(%q, %s)", name.Name, typ))
+                                       res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, Lookup(%q), %s)", name.Name, typ))
                                } else {
-                                       res = append(res, fmt.Sprintf("anonfield(%s)", typ))
+                                       res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
                                }
                        }
                }
        }
-       return fmt.Sprintf("[]*Node{%s}", strings.Join(res, ", "))
+       return fmt.Sprintf("[]*types.Field{%s}", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {

diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
new file mode 100644 (file)
index 0000000..14ed175
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -0,0 +1,669 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+func RangeExprType(t *types.Type) *types.Type {
+       if t.IsPtr() && t.Elem().IsArray() {
+               return t.Elem()
+       }
+       return t
+}
+
+func typecheckrangeExpr(n *ir.RangeStmt) {
+       n.X = Expr(n.X)
+       if n.X.Type() == nil {
+               return
+       }
+
+       t := RangeExprType(n.X.Type())
+       // delicate little dance.  see tcAssignList
+       if n.Key != nil && !ir.DeclaredBy(n.Key, n) {
+               n.Key = AssignExpr(n.Key)
+       }
+       if n.Value != nil && !ir.DeclaredBy(n.Value, n) {
+               n.Value = AssignExpr(n.Value)
+       }
+
+       var tk, tv *types.Type
+       toomany := false
+       switch t.Kind() {
+       default:
+               base.ErrorfAt(n.Pos(), "cannot range over %L", n.X)
+               return
+
+       case types.TARRAY, types.TSLICE:
+               tk = types.Types[types.TINT]
+               tv = t.Elem()
+
+       case types.TMAP:
+               tk = t.Key()
+               tv = t.Elem()
+
+       case types.TCHAN:
+               if !t.ChanDir().CanRecv() {
+                       base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.X, n.X.Type())
+                       return
+               }
+
+               tk = t.Elem()
+               tv = nil
+               if n.Value != nil {
+                       toomany = true
+               }
+
+       case types.TSTRING:
+               tk = types.Types[types.TINT]
+               tv = types.RuneType
+       }
+
+       if toomany {
+               base.ErrorfAt(n.Pos(), "too many variables in range")
+       }
+
+       do := func(nn ir.Node, t *types.Type) {
+               if nn != nil {
+                       if ir.DeclaredBy(nn, n) {
+                               nn.SetType(t)
+                       } else if nn.Type() != nil {
+                               if op, why := assignop(t, nn.Type()); op == ir.OXXX {
+                                       base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t, nn, why)
+                               }
+                       }
+                       checkassign(n, nn)
+               }
+       }
+       do(n.Key, tk)
+       do(n.Value, tv)
+}
+
+// type check assignment.
+// if this assignment is the definition of a var on the left side,
+// fill in the var's type.
+func tcAssign(n *ir.AssignStmt) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("tcAssign", n)(nil)
+       }
+
+       if n.Y == nil {
+               n.X = AssignExpr(n.X)
+               return
+       }
+
+       lhs, rhs := []ir.Node{n.X}, []ir.Node{n.Y}
+       assign(n, lhs, rhs)
+       n.X, n.Y = lhs[0], rhs[0]
+
+       // TODO(mdempsky): This seems out of place.
+       if !ir.IsBlank(n.X) {
+               types.CheckSize(n.X.Type()) // ensure width is calculated for backend
+       }
+}
+
+func tcAssignList(n *ir.AssignListStmt) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("tcAssignList", n)(nil)
+       }
+
+       assign(n, n.Lhs, n.Rhs)
+}
+
+func assign(stmt ir.Node, lhs, rhs []ir.Node) {
+       // delicate little dance.
+       // the definition of lhs may refer to this assignment
+       // as its definition, in which case it will call tcAssign.
+       // in that case, do not call typecheck back, or it will cycle.
+       // if the variable has a type (ntype) then typechecking
+       // will not look at defn, so it is okay (and desirable,
+       // so that the conversion below happens).
+
+       checkLHS := func(i int, typ *types.Type) {
+               lhs[i] = Resolve(lhs[i])
+               if n := lhs[i]; typ != nil && ir.DeclaredBy(n, stmt) && n.Name().Ntype == nil {
+                       if typ.Kind() != types.TNIL {
+                               n.SetType(defaultType(typ))
+                       } else {
+                               base.Errorf("use of untyped nil")
+                       }
+               }
+               if lhs[i].Typecheck() == 0 {
+                       lhs[i] = AssignExpr(lhs[i])
+               }
+               checkassign(stmt, lhs[i])
+       }
+
+       assignType := func(i int, typ *types.Type) {
+               checkLHS(i, typ)
+               if typ != nil {
+                       checkassignto(typ, lhs[i])
+               }
+       }
+
+       cr := len(rhs)
+       if len(rhs) == 1 {
+               rhs[0] = typecheck(rhs[0], ctxExpr|ctxMultiOK)
+               if rtyp := rhs[0].Type(); rtyp != nil && rtyp.IsFuncArgStruct() {
+                       cr = rtyp.NumFields()
+               }
+       } else {
+               Exprs(rhs)
+       }
+
+       // x, ok = y
+assignOK:
+       for len(lhs) == 2 && cr == 1 {
+               stmt := stmt.(*ir.AssignListStmt)
+               r := rhs[0]
+
+               switch r.Op() {
+               case ir.OINDEXMAP:
+                       stmt.SetOp(ir.OAS2MAPR)
+               case ir.ORECV:
+                       stmt.SetOp(ir.OAS2RECV)
+               case ir.ODOTTYPE:
+                       r := r.(*ir.TypeAssertExpr)
+                       stmt.SetOp(ir.OAS2DOTTYPE)
+                       r.SetOp(ir.ODOTTYPE2)
+               default:
+                       break assignOK
+               }
+
+               assignType(0, r.Type())
+               assignType(1, types.UntypedBool)
+               return
+       }
+
+       if len(lhs) != cr {
+               if r, ok := rhs[0].(*ir.CallExpr); ok && len(rhs) == 1 {
+                       if r.Type() != nil {
+                               base.ErrorfAt(stmt.Pos(), "assignment mismatch: %d variable%s but %v returns %d value%s", len(lhs), plural(len(lhs)), r.X, cr, plural(cr))
+                       }
+               } else {
+                       base.ErrorfAt(stmt.Pos(), "assignment mismatch: %d variable%s but %v value%s", len(lhs), plural(len(lhs)), len(rhs), plural(len(rhs)))
+               }
+
+               for i := range lhs {
+                       checkLHS(i, nil)
+               }
+               return
+       }
+
+       // x,y,z = f()
+       if cr > len(rhs) {
+               stmt := stmt.(*ir.AssignListStmt)
+               stmt.SetOp(ir.OAS2FUNC)
+               r := rhs[0].(*ir.CallExpr)
+               r.Use = ir.CallUseList
+               rtyp := r.Type()
+
+               for i := range lhs {
+                       assignType(i, rtyp.Field(i).Type)
+               }
+               return
+       }
+
+       for i, r := range rhs {
+               checkLHS(i, r.Type())
+               if lhs[i].Type() != nil {
+                       rhs[i] = AssignConv(r, lhs[i].Type(), "assignment")
+               }
+       }
+}
+
+func plural(n int) string {
+       if n == 1 {
+               return ""
+       }
+       return "s"
+}
+
+// tcFor typechecks an OFOR node.
+func tcFor(n *ir.ForStmt) ir.Node {
+       Stmts(n.Init())
+       n.Cond = Expr(n.Cond)
+       n.Cond = DefaultLit(n.Cond, nil)
+       if n.Cond != nil {
+               t := n.Cond.Type()
+               if t != nil && !t.IsBoolean() {
+                       base.Errorf("non-bool %L used as for condition", n.Cond)
+               }
+       }
+       n.Post = Stmt(n.Post)
+       if n.Op() == ir.OFORUNTIL {
+               Stmts(n.Late)
+       }
+       Stmts(n.Body)
+       return n
+}
+
+func tcGoDefer(n *ir.GoDeferStmt) {
+       what := "defer"
+       if n.Op() == ir.OGO {
+               what = "go"
+       }
+
+       switch n.Call.Op() {
+       // ok
+       case ir.OCALLINTER,
+               ir.OCALLMETH,
+               ir.OCALLFUNC,
+               ir.OCLOSE,
+               ir.OCOPY,
+               ir.ODELETE,
+               ir.OPANIC,
+               ir.OPRINT,
+               ir.OPRINTN,
+               ir.ORECOVER:
+               return
+
+       case ir.OAPPEND,
+               ir.OCAP,
+               ir.OCOMPLEX,
+               ir.OIMAG,
+               ir.OLEN,
+               ir.OMAKE,
+               ir.OMAKESLICE,
+               ir.OMAKECHAN,
+               ir.OMAKEMAP,
+               ir.ONEW,
+               ir.OREAL,
+               ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
+               if orig := ir.Orig(n.Call); orig.Op() == ir.OCONV {
+                       break
+               }
+               base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Call)
+               return
+       }
+
+       // type is broken or missing, most likely a method call on a broken type
+       // we will warn about the broken type elsewhere. no need to emit a potentially confusing error
+       if n.Call.Type() == nil || n.Call.Type().Broke() {
+               return
+       }
+
+       if !n.Diag() {
+               // The syntax made sure it was a call, so this must be
+               // a conversion.
+               n.SetDiag(true)
+               base.ErrorfAt(n.Pos(), "%s requires function call, not conversion", what)
+       }
+}
+
+// tcIf typechecks an OIF node.
+func tcIf(n *ir.IfStmt) ir.Node {
+       Stmts(n.Init())
+       n.Cond = Expr(n.Cond)
+       n.Cond = DefaultLit(n.Cond, nil)
+       if n.Cond != nil {
+               t := n.Cond.Type()
+               if t != nil && !t.IsBoolean() {
+                       base.Errorf("non-bool %L used as if condition", n.Cond)
+               }
+       }
+       Stmts(n.Body)
+       Stmts(n.Else)
+       return n
+}
+
+// range
+func tcRange(n *ir.RangeStmt) {
+       // Typechecking order is important here:
+       // 0. first typecheck range expression (slice/map/chan),
+       //      it is evaluated only once and so logically it is not part of the loop.
+       // 1. typecheck produced values,
+       //      this part can declare new vars and so it must be typechecked before body,
+       //      because body can contain a closure that captures the vars.
+       // 2. decldepth++ to denote loop body.
+       // 3. typecheck body.
+       // 4. decldepth--.
+       typecheckrangeExpr(n)
+
+       // second half of dance, the first half being typecheckrangeExpr
+       n.SetTypecheck(1)
+       if n.Key != nil && n.Key.Typecheck() == 0 {
+               n.Key = AssignExpr(n.Key)
+       }
+       if n.Value != nil && n.Value.Typecheck() == 0 {
+               n.Value = AssignExpr(n.Value)
+       }
+
+       Stmts(n.Body)
+}
+
+// tcReturn typechecks an ORETURN node.
+func tcReturn(n *ir.ReturnStmt) ir.Node {
+       typecheckargs(n)
+       if ir.CurFunc == nil {
+               base.Errorf("return outside function")
+               n.SetType(nil)
+               return n
+       }
+
+       if ir.HasNamedResults(ir.CurFunc) && len(n.Results) == 0 {
+               return n
+       }
+       typecheckaste(ir.ORETURN, nil, false, ir.CurFunc.Type().Results(), n.Results, func() string { return "return argument" })
+       return n
+}
+
+// select
+func tcSelect(sel *ir.SelectStmt) {
+       var def *ir.CommClause
+       lno := ir.SetPos(sel)
+       Stmts(sel.Init())
+       for _, ncase := range sel.Cases {
+               if ncase.Comm == nil {
+                       // default
+                       if def != nil {
+                               base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
+                       } else {
+                               def = ncase
+                       }
+               } else {
+                       n := Stmt(ncase.Comm)
+                       ncase.Comm = n
+                       oselrecv2 := func(dst, recv ir.Node, def bool) {
+                               n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, []ir.Node{dst, ir.BlankNode}, []ir.Node{recv})
+                               n.Def = def
+                               n.SetTypecheck(1)
+                               ncase.Comm = n
+                       }
+                       switch n.Op() {
+                       default:
+                               pos := n.Pos()
+                               if n.Op() == ir.ONAME {
+                                       // We don't have the right position for ONAME nodes (see #15459 and
+                                       // others). Using ncase.Pos for now as it will provide the correct
+                                       // line number (assuming the expression follows the "case" keyword
+                                       // on the same line). This matches the approach before 1.10.
+                                       pos = ncase.Pos()
+                               }
+                               base.ErrorfAt(pos, "select case must be receive, send or assign recv")
+
+                       case ir.OAS:
+                               // convert x = <-c into x, _ = <-c
+                               // remove implicit conversions; the eventual assignment
+                               // will reintroduce them.
+                               n := n.(*ir.AssignStmt)
+                               if r := n.Y; r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+                                       r := r.(*ir.ConvExpr)
+                                       if r.Implicit() {
+                                               n.Y = r.X
+                                       }
+                               }
+                               if n.Y.Op() != ir.ORECV {
+                                       base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
+                                       break
+                               }
+                               oselrecv2(n.X, n.Y, n.Def)
+
+                       case ir.OAS2RECV:
+                               n := n.(*ir.AssignListStmt)
+                               if n.Rhs[0].Op() != ir.ORECV {
+                                       base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
+                                       break
+                               }
+                               n.SetOp(ir.OSELRECV2)
+
+                       case ir.ORECV:
+                               // convert <-c into _, _ = <-c
+                               n := n.(*ir.UnaryExpr)
+                               oselrecv2(ir.BlankNode, n, false)
+
+                       case ir.OSEND:
+                               break
+                       }
+               }
+
+               Stmts(ncase.Body)
+       }
+
+       base.Pos = lno
+}
+
+// tcSend typechecks an OSEND node.
+func tcSend(n *ir.SendStmt) ir.Node {
+       n.Chan = Expr(n.Chan)
+       n.Value = Expr(n.Value)
+       n.Chan = DefaultLit(n.Chan, nil)
+       t := n.Chan.Type()
+       if t == nil {
+               return n
+       }
+       if !t.IsChan() {
+               base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
+               return n
+       }
+
+       if !t.ChanDir().CanSend() {
+               base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
+               return n
+       }
+
+       n.Value = AssignConv(n.Value, t.Elem(), "send")
+       if n.Value.Type() == nil {
+               return n
+       }
+       return n
+}
+
+// tcSwitch typechecks a switch statement.
+func tcSwitch(n *ir.SwitchStmt) {
+       Stmts(n.Init())
+       if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
+               tcSwitchType(n)
+       } else {
+               tcSwitchExpr(n)
+       }
+}
+
+func tcSwitchExpr(n *ir.SwitchStmt) {
+       t := types.Types[types.TBOOL]
+       if n.Tag != nil {
+               n.Tag = Expr(n.Tag)
+               n.Tag = DefaultLit(n.Tag, nil)
+               t = n.Tag.Type()
+       }
+
+       var nilonly string
+       if t != nil {
+               switch {
+               case t.IsMap():
+                       nilonly = "map"
+               case t.Kind() == types.TFUNC:
+                       nilonly = "func"
+               case t.IsSlice():
+                       nilonly = "slice"
+
+               case !types.IsComparable(t):
+                       if t.IsStruct() {
+                               base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, types.IncomparableField(t).Type)
+                       } else {
+                               base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Tag)
+                       }
+                       t = nil
+               }
+       }
+
+       var defCase ir.Node
+       var cs constSet
+       for _, ncase := range n.Cases {
+               ls := ncase.List
+               if len(ls) == 0 { // default:
+                       if defCase != nil {
+                               base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
+                       } else {
+                               defCase = ncase
+                       }
+               }
+
+               for i := range ls {
+                       ir.SetPos(ncase)
+                       ls[i] = Expr(ls[i])
+                       ls[i] = DefaultLit(ls[i], t)
+                       n1 := ls[i]
+                       if t == nil || n1.Type() == nil {
+                               continue
+                       }
+
+                       if nilonly != "" && !ir.IsNil(n1) {
+                               base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Tag)
+                       } else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
+                               base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
+                       } else {
+                               op1, _ := assignop(n1.Type(), t)
+                               op2, _ := assignop(t, n1.Type())
+                               if op1 == ir.OXXX && op2 == ir.OXXX {
+                                       if n.Tag != nil {
+                                               base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
+                                       } else {
+                                               base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type())
+                                       }
+                               }
+                       }
+
+                       // Don't check for duplicate bools. Although the spec allows it,
+                       // (1) the compiler hasn't checked it in the past, so compatibility mandates it, and
+                       // (2) it would disallow useful things like
+                       //       case GOARCH == "arm" && GOARM == "5":
+                       //       case GOARCH == "arm":
+                       //     which would both evaluate to false for non-ARM compiles.
+                       if !n1.Type().IsBoolean() {
+                               cs.add(ncase.Pos(), n1, "case", "switch")
+                       }
+               }
+
+               Stmts(ncase.Body)
+       }
+}
+
+func tcSwitchType(n *ir.SwitchStmt) {
+       guard := n.Tag.(*ir.TypeSwitchGuard)
+       guard.X = Expr(guard.X)
+       t := guard.X.Type()
+       if t != nil && !t.IsInterface() {
+               base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.X)
+               t = nil
+       }
+
+       // We don't actually declare the type switch's guarded
+       // declaration itself. So if there are no cases, we won't
+       // notice that it went unused.
+       if v := guard.Tag; v != nil && !ir.IsBlank(v) && len(n.Cases) == 0 {
+               base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
+       }
+
+       var defCase, nilCase ir.Node
+       var ts typeSet
+       for _, ncase := range n.Cases {
+               ls := ncase.List
+               if len(ls) == 0 { // default:
+                       if defCase != nil {
+                               base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
+                       } else {
+                               defCase = ncase
+                       }
+               }
+
+               for i := range ls {
+                       ls[i] = typecheck(ls[i], ctxExpr|ctxType)
+                       n1 := ls[i]
+                       if t == nil || n1.Type() == nil {
+                               continue
+                       }
+
+                       var missing, have *types.Field
+                       var ptr int
+                       if ir.IsNil(n1) { // case nil:
+                               if nilCase != nil {
+                                       base.ErrorfAt(ncase.Pos(), "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
+                               } else {
+                                       nilCase = ncase
+                               }
+                               continue
+                       }
+                       if n1.Op() != ir.OTYPE {
+                               base.ErrorfAt(ncase.Pos(), "%L is not a type", n1)
+                               continue
+                       }
+                       if !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke() {
+                               if have != nil && !have.Broke() {
+                                       base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+                                               " (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.X, n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+                               } else if ptr != 0 {
+                                       base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+                                               " (%v method has pointer receiver)", guard.X, n1.Type(), missing.Sym)
+                               } else {
+                                       base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+                                               " (missing %v method)", guard.X, n1.Type(), missing.Sym)
+                               }
+                               continue
+                       }
+
+                       ts.add(ncase.Pos(), n1.Type())
+               }
+
+               if ncase.Var != nil {
+                       // Assign the clause variable's type.
+                       vt := t
+                       if len(ls) == 1 {
+                               if ls[0].Op() == ir.OTYPE {
+                                       vt = ls[0].Type()
+                               } else if !ir.IsNil(ls[0]) {
+                                       // Invalid single-type case;
+                                       // mark variable as broken.
+                                       vt = nil
+                               }
+                       }
+
+                       nvar := ncase.Var
+                       nvar.SetType(vt)
+                       if vt != nil {
+                               nvar = AssignExpr(nvar).(*ir.Name)
+                       } else {
+                               // Clause variable is broken; prevent typechecking.
+                               nvar.SetTypecheck(1)
+                               nvar.SetWalkdef(1)
+                       }
+                       ncase.Var = nvar
+               }
+
+               Stmts(ncase.Body)
+       }
+}
+
+type typeSet struct {
+       m map[string][]typeSetEntry
+}
+
+type typeSetEntry struct {
+       pos src.XPos
+       typ *types.Type
+}
+
+func (s *typeSet) add(pos src.XPos, typ *types.Type) {
+       if s.m == nil {
+               s.m = make(map[string][]typeSetEntry)
+       }
+
+       // LongString does not uniquely identify types, so we need to
+       // disambiguate collisions with types.Identical.
+       // TODO(mdempsky): Add a method that *is* unique.
+       ls := typ.LongString()
+       prevs := s.m[ls]
+       for _, prev := range prevs {
+               if types.Identical(typ, prev.typ) {
+                       base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
+                       return
+               }
+       }
+       s.m[ls] = append(prevs, typeSetEntry{pos, typ})
+}

diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
new file mode 100644 (file)
index 0000000..b88a9f2
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -0,0 +1,843 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "fmt"
+       "sort"
+       "strconv"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+func AssignConv(n ir.Node, t *types.Type, context string) ir.Node {
+       return assignconvfn(n, t, func() string { return context })
+}
+
+// DotImportRefs maps idents introduced by importDot back to the
+// ir.PkgName they were dot-imported through.
+var DotImportRefs map[*ir.Ident]*ir.PkgName
+
+// LookupNum looks up the symbol starting with prefix and ending with
+// the decimal n. If prefix is too long, LookupNum panics.
+func LookupNum(prefix string, n int) *types.Sym {
+       var buf [20]byte // plenty long enough for all current users
+       copy(buf[:], prefix)
+       b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
+       return types.LocalPkg.LookupBytes(b)
+}
+
+// Given funarg struct list, return list of fn args.
+func NewFuncParams(tl *types.Type, mustname bool) []*ir.Field {
+       var args []*ir.Field
+       gen := 0
+       for _, t := range tl.Fields().Slice() {
+               s := t.Sym
+               if mustname && (s == nil || s.Name == "_") {
+                       // invent a name so that we can refer to it in the trampoline
+                       s = LookupNum(".anon", gen)
+                       gen++
+               } else if s != nil && s.Pkg != types.LocalPkg {
+                       // TODO(mdempsky): Preserve original position, name, and package.
+                       s = Lookup(s.Name)
+               }
+               a := ir.NewField(base.Pos, s, nil, t.Type)
+               a.Pos = t.Pos
+               a.IsDDD = t.IsDDD()
+               args = append(args, a)
+       }
+
+       return args
+}
+
+// newname returns a new ONAME Node associated with symbol s.
+func NewName(s *types.Sym) *ir.Name {
+       n := ir.NewNameAt(base.Pos, s)
+       n.Curfn = ir.CurFunc
+       return n
+}
+
+// NodAddr returns a node representing &n at base.Pos.
+func NodAddr(n ir.Node) *ir.AddrExpr {
+       return NodAddrAt(base.Pos, n)
+}
+
+// nodAddrPos returns a node representing &n at position pos.
+func NodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
+       n = markAddrOf(n)
+       return ir.NewAddrExpr(pos, n)
+}
+
+func markAddrOf(n ir.Node) ir.Node {
+       if IncrementalAddrtaken {
+               // We can only do incremental addrtaken computation when it is ok
+               // to typecheck the argument of the OADDR. That's only safe after the
+               // main typecheck has completed.
+               // The argument to OADDR needs to be typechecked because &x[i] takes
+               // the address of x if x is an array, but not if x is a slice.
+               // Note: OuterValue doesn't work correctly until n is typechecked.
+               n = typecheck(n, ctxExpr)
+               if x := ir.OuterValue(n); x.Op() == ir.ONAME {
+                       x.Name().SetAddrtaken(true)
+               }
+       } else {
+               // Remember that we built an OADDR without computing the Addrtaken bit for
+               // its argument. We'll do that later in bulk using computeAddrtaken.
+               DirtyAddrtaken = true
+       }
+       return n
+}
+
+// If IncrementalAddrtaken is false, we do not compute Addrtaken for an OADDR Node
+// when it is built. The Addrtaken bits are set in bulk by computeAddrtaken.
+// If IncrementalAddrtaken is true, then when an OADDR Node is built the Addrtaken
+// field of its argument is updated immediately.
+var IncrementalAddrtaken = false
+
+// If DirtyAddrtaken is true, then there are OADDR whose corresponding arguments
+// have not yet been marked as Addrtaken.
+var DirtyAddrtaken = false
+
+func ComputeAddrtaken(top []ir.Node) {
+       for _, n := range top {
+               ir.Visit(n, func(n ir.Node) {
+                       if n.Op() == ir.OADDR {
+                               if x := ir.OuterValue(n.(*ir.AddrExpr).X); x.Op() == ir.ONAME {
+                                       x.Name().SetAddrtaken(true)
+                                       if x.Name().IsClosureVar() {
+                                               // Mark the original variable as Addrtaken so that capturevars
+                                               // knows not to pass it by value.
+                                               x.Name().Defn.Name().SetAddrtaken(true)
+                                       }
+                               }
+                       }
+               })
+       }
+}
+
+func NodNil() ir.Node {
+       n := ir.NewNilExpr(base.Pos)
+       n.SetType(types.Types[types.TNIL])
+       return n
+}
+
+// AddImplicitDots finds missing fields in obj.field that
+// will give the shortest unique addressing and
+// modifies the tree with missing field names.
+func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr {
+       n.X = typecheck(n.X, ctxType|ctxExpr)
+       if n.X.Diag() {
+               n.SetDiag(true)
+       }
+       t := n.X.Type()
+       if t == nil {
+               return n
+       }
+
+       if n.X.Op() == ir.OTYPE {
+               return n
+       }
+
+       s := n.Sel
+       if s == nil {
+               return n
+       }
+
+       switch path, ambig := dotpath(s, t, nil, false); {
+       case path != nil:
+               // rebuild elided dots
+               for c := len(path) - 1; c >= 0; c-- {
+                       dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.X, path[c].field.Sym)
+                       dot.SetImplicit(true)
+                       dot.SetType(path[c].field.Type)
+                       n.X = dot
+               }
+       case ambig:
+               base.Errorf("ambiguous selector %v", n)
+               n.X = nil
+       }
+
+       return n
+}
+
+func CalcMethods(t *types.Type) {
+       if t == nil || t.AllMethods().Len() != 0 {
+               return
+       }
+
+       // mark top-level method symbols
+       // so that expand1 doesn't consider them.
+       for _, f := range t.Methods().Slice() {
+               f.Sym.SetUniq(true)
+       }
+
+       // generate all reachable methods
+       slist = slist[:0]
+       expand1(t, true)
+
+       // check each method to be uniquely reachable
+       var ms []*types.Field
+       for i, sl := range slist {
+               slist[i].field = nil
+               sl.field.Sym.SetUniq(false)
+
+               var f *types.Field
+               path, _ := dotpath(sl.field.Sym, t, &f, false)
+               if path == nil {
+                       continue
+               }
+
+               // dotpath may have dug out arbitrary fields, we only want methods.
+               if !f.IsMethod() {
+                       continue
+               }
+
+               // add it to the base type method list
+               f = f.Copy()
+               f.Embedded = 1 // needs a trampoline
+               for _, d := range path {
+                       if d.field.Type.IsPtr() {
+                               f.Embedded = 2
+                               break
+                       }
+               }
+               ms = append(ms, f)
+       }
+
+       for _, f := range t.Methods().Slice() {
+               f.Sym.SetUniq(false)
+       }
+
+       ms = append(ms, t.Methods().Slice()...)
+       sort.Sort(types.MethodsByName(ms))
+       t.AllMethods().Set(ms)
+}
+
+// adddot1 returns the number of fields or methods named s at depth d in Type t.
+// If exactly one exists, it will be returned in *save (if save is not nil),
+// and dotlist will contain the path of embedded fields traversed to find it,
+// in reverse order. If none exist, more will indicate whether t contains any
+// embedded fields at depth d, so callers can decide whether to retry at
+// a greater depth.
+func adddot1(s *types.Sym, t *types.Type, d int, save **types.Field, ignorecase bool) (c int, more bool) {
+       if t.Recur() {
+               return
+       }
+       t.SetRecur(true)
+       defer t.SetRecur(false)
+
+       var u *types.Type
+       d--
+       if d < 0 {
+               // We've reached our target depth. If t has any fields/methods
+               // named s, then we're done. Otherwise, we still need to check
+               // below for embedded fields.
+               c = lookdot0(s, t, save, ignorecase)
+               if c != 0 {
+                       return c, false
+               }
+       }
+
+       u = t
+       if u.IsPtr() {
+               u = u.Elem()
+       }
+       if !u.IsStruct() && !u.IsInterface() {
+               return c, false
+       }
+
+       for _, f := range u.Fields().Slice() {
+               if f.Embedded == 0 || f.Sym == nil {
+                       continue
+               }
+               if d < 0 {
+                       // Found an embedded field at target depth.
+                       return c, true
+               }
+               a, more1 := adddot1(s, f.Type, d, save, ignorecase)
+               if a != 0 && c == 0 {
+                       dotlist[d].field = f
+               }
+               c += a
+               if more1 {
+                       more = true
+               }
+       }
+
+       return c, more
+}
+
+// dotlist is used by adddot1 to record the path of embedded fields
+// used to access a target field or method.
+// Must be non-nil so that dotpath returns a non-nil slice even if d is zero.
+var dotlist = make([]dlist, 10)
+
+// Convert node n for assignment to type t.
+func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
+       if n == nil || n.Type() == nil || n.Type().Broke() {
+               return n
+       }
+
+       if t.Kind() == types.TBLANK && n.Type().Kind() == types.TNIL {
+               base.Errorf("use of untyped nil")
+       }
+
+       n = convlit1(n, t, false, context)
+       if n.Type() == nil {
+               return n
+       }
+       if t.Kind() == types.TBLANK {
+               return n
+       }
+
+       // Convert ideal bool from comparison to plain bool
+       // if the next step is non-bool (like interface{}).
+       if n.Type() == types.UntypedBool && !t.IsBoolean() {
+               if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
+                       r := ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
+                       r.SetType(types.Types[types.TBOOL])
+                       r.SetTypecheck(1)
+                       r.SetImplicit(true)
+                       n = r
+               }
+       }
+
+       if types.Identical(n.Type(), t) {
+               return n
+       }
+
+       op, why := assignop(n.Type(), t)
+       if op == ir.OXXX {
+               base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
+               op = ir.OCONV
+       }
+
+       r := ir.NewConvExpr(base.Pos, op, t, n)
+       r.SetTypecheck(1)
+       r.SetImplicit(true)
+       return r
+}
+
+// Is type src assignment compatible to type dst?
+// If so, return op code to use in conversion.
+// If not, return OXXX. In this case, the string return parameter may
+// hold a reason why. In all other cases, it'll be the empty string.
+func assignop(src, dst *types.Type) (ir.Op, string) {
+       if src == dst {
+               return ir.OCONVNOP, ""
+       }
+       if src == nil || dst == nil || src.Kind() == types.TFORW || dst.Kind() == types.TFORW || src.Underlying() == nil || dst.Underlying() == nil {
+               return ir.OXXX, ""
+       }
+
+       // 1. src type is identical to dst.
+       if types.Identical(src, dst) {
+               return ir.OCONVNOP, ""
+       }
+
+       // 2. src and dst have identical underlying types
+       // and either src or dst is not a named type or
+       // both are empty interface types.
+       // For assignable but different non-empty interface types,
+       // we want to recompute the itab. Recomputing the itab ensures
+       // that itabs are unique (thus an interface with a compile-time
+       // type I has an itab with interface type I).
+       if types.Identical(src.Underlying(), dst.Underlying()) {
+               if src.IsEmptyInterface() {
+                       // Conversion between two empty interfaces
+                       // requires no code.
+                       return ir.OCONVNOP, ""
+               }
+               if (src.Sym() == nil || dst.Sym() == nil) && !src.IsInterface() {
+                       // Conversion between two types, at least one unnamed,
+                       // needs no conversion. The exception is nonempty interfaces
+                       // which need to have their itab updated.
+                       return ir.OCONVNOP, ""
+               }
+       }
+
+       // 3. dst is an interface type and src implements dst.
+       if dst.IsInterface() && src.Kind() != types.TNIL {
+               var missing, have *types.Field
+               var ptr int
+               if implements(src, dst, &missing, &have, &ptr) {
+                       // Call NeedITab/ITabAddr so that (src, dst)
+                       // gets added to itabs early, which allows
+                       // us to de-virtualize calls through this
+                       // type/interface pair later. See CompileITabs in reflect.go
+                       if types.IsDirectIface(src) && !dst.IsEmptyInterface() {
+                               NeedITab(src, dst)
+                       }
+
+                       return ir.OCONVIFACE, ""
+               }
+
+               // we'll have complained about this method anyway, suppress spurious messages.
+               if have != nil && have.Sym == missing.Sym && (have.Type.Broke() || missing.Type.Broke()) {
+                       return ir.OCONVIFACE, ""
+               }
+
+               var why string
+               if isptrto(src, types.TINTER) {
+                       why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", src)
+               } else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
+                       why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
+               } else if have != nil && have.Sym == missing.Sym {
+                       why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+
+                               "\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+               } else if ptr != 0 {
+                       why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", src, dst, missing.Sym)
+               } else if have != nil {
+                       why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+
+                               "\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+               } else {
+                       why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
+               }
+
+               return ir.OXXX, why
+       }
+
+       if isptrto(dst, types.TINTER) {
+               why := fmt.Sprintf(":\n\t%v is pointer to interface, not interface", dst)
+               return ir.OXXX, why
+       }
+
+       if src.IsInterface() && dst.Kind() != types.TBLANK {
+               var missing, have *types.Field
+               var ptr int
+               var why string
+               if implements(dst, src, &missing, &have, &ptr) {
+                       why = ": need type assertion"
+               }
+               return ir.OXXX, why
+       }
+
+       // 4. src is a bidirectional channel value, dst is a channel type,
+       // src and dst have identical element types, and
+       // either src or dst is not a named type.
+       if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
+               if types.Identical(src.Elem(), dst.Elem()) && (src.Sym() == nil || dst.Sym() == nil) {
+                       return ir.OCONVNOP, ""
+               }
+       }
+
+       // 5. src is the predeclared identifier nil and dst is a nillable type.
+       if src.Kind() == types.TNIL {
+               switch dst.Kind() {
+               case types.TPTR,
+                       types.TFUNC,
+                       types.TMAP,
+                       types.TCHAN,
+                       types.TINTER,
+                       types.TSLICE:
+                       return ir.OCONVNOP, ""
+               }
+       }
+
+       // 6. rule about untyped constants - already converted by DefaultLit.
+
+       // 7. Any typed value can be assigned to the blank identifier.
+       if dst.Kind() == types.TBLANK {
+               return ir.OCONVNOP, ""
+       }
+
+       return ir.OXXX, ""
+}
+
+// Can we convert a value of type src to a value of type dst?
+// If so, return op code to use in conversion (maybe OCONVNOP).
+// If not, return OXXX. In this case, the string return parameter may
+// hold a reason why. In all other cases, it'll be the empty string.
+// srcConstant indicates whether the value of type src is a constant.
+func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
+       if src == dst {
+               return ir.OCONVNOP, ""
+       }
+       if src == nil || dst == nil {
+               return ir.OXXX, ""
+       }
+
+       // Conversions from regular to go:notinheap are not allowed
+       // (unless it's unsafe.Pointer). These are runtime-specific
+       // rules.
+       // (a) Disallow (*T) to (*U) where T is go:notinheap but U isn't.
+       if src.IsPtr() && dst.IsPtr() && dst.Elem().NotInHeap() && !src.Elem().NotInHeap() {
+               why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable), but %v is not", dst.Elem(), src.Elem())
+               return ir.OXXX, why
+       }
+       // (b) Disallow string to []T where T is go:notinheap.
+       if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Kind() == types.ByteType.Kind() || dst.Elem().Kind() == types.RuneType.Kind()) {
+               why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
+               return ir.OXXX, why
+       }
+
+       // 1. src can be assigned to dst.
+       op, why := assignop(src, dst)
+       if op != ir.OXXX {
+               return op, why
+       }
+
+       // The rules for interfaces are no different in conversions
+       // than assignments. If interfaces are involved, stop now
+       // with the good message from assignop.
+       // Otherwise clear the error.
+       if src.IsInterface() || dst.IsInterface() {
+               return ir.OXXX, why
+       }
+
+       // 2. Ignoring struct tags, src and dst have identical underlying types.
+       if types.IdenticalIgnoreTags(src.Underlying(), dst.Underlying()) {
+               return ir.OCONVNOP, ""
+       }
+
+       // 3. src and dst are unnamed pointer types and, ignoring struct tags,
+       // their base types have identical underlying types.
+       if src.IsPtr() && dst.IsPtr() && src.Sym() == nil && dst.Sym() == nil {
+               if types.IdenticalIgnoreTags(src.Elem().Underlying(), dst.Elem().Underlying()) {
+                       return ir.OCONVNOP, ""
+               }
+       }
+
+       // 4. src and dst are both integer or floating point types.
+       if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
+               if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
+                       return ir.OCONVNOP, ""
+               }
+               return ir.OCONV, ""
+       }
+
+       // 5. src and dst are both complex types.
+       if src.IsComplex() && dst.IsComplex() {
+               if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
+                       return ir.OCONVNOP, ""
+               }
+               return ir.OCONV, ""
+       }
+
+       // Special case for constant conversions: any numeric
+       // conversion is potentially okay. We'll validate further
+       // within evconst. See #38117.
+       if srcConstant && (src.IsInteger() || src.IsFloat() || src.IsComplex()) && (dst.IsInteger() || dst.IsFloat() || dst.IsComplex()) {
+               return ir.OCONV, ""
+       }
+
+       // 6. src is an integer or has type []byte or []rune
+       // and dst is a string type.
+       if src.IsInteger() && dst.IsString() {
+               return ir.ORUNESTR, ""
+       }
+
+       if src.IsSlice() && dst.IsString() {
+               if src.Elem().Kind() == types.ByteType.Kind() {
+                       return ir.OBYTES2STR, ""
+               }
+               if src.Elem().Kind() == types.RuneType.Kind() {
+                       return ir.ORUNES2STR, ""
+               }
+       }
+
+       // 7. src is a string and dst is []byte or []rune.
+       // String to slice.
+       if src.IsString() && dst.IsSlice() {
+               if dst.Elem().Kind() == types.ByteType.Kind() {
+                       return ir.OSTR2BYTES, ""
+               }
+               if dst.Elem().Kind() == types.RuneType.Kind() {
+                       return ir.OSTR2RUNES, ""
+               }
+       }
+
+       // 8. src is a pointer or uintptr and dst is unsafe.Pointer.
+       if (src.IsPtr() || src.IsUintptr()) && dst.IsUnsafePtr() {
+               return ir.OCONVNOP, ""
+       }
+
+       // 9. src is unsafe.Pointer and dst is a pointer or uintptr.
+       if src.IsUnsafePtr() && (dst.IsPtr() || dst.IsUintptr()) {
+               return ir.OCONVNOP, ""
+       }
+
+       // src is map and dst is a pointer to corresponding hmap.
+       // This rule is needed for the implementation detail that
+       // go gc maps are implemented as a pointer to a hmap struct.
+       if src.Kind() == types.TMAP && dst.IsPtr() &&
+               src.MapType().Hmap == dst.Elem() {
+               return ir.OCONVNOP, ""
+       }
+
+       return ir.OXXX, ""
+}
+
+// Code to resolve elided DOTs in embedded types.
+
+// A dlist stores a pointer to a TFIELD Type embedded within
+// a TSTRUCT or TINTER Type.
+type dlist struct {
+       field *types.Field
+}
+
+// dotpath computes the unique shortest explicit selector path to fully qualify
+// a selection expression x.f, where x is of type t and f is the symbol s.
+// If no such path exists, dotpath returns nil.
+// If there are multiple shortest paths to the same depth, ambig is true.
+func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (path []dlist, ambig bool) {
+       // The embedding of types within structs imposes a tree structure onto
+       // types: structs parent the types they embed, and types parent their
+       // fields or methods. Our goal here is to find the shortest path to
+       // a field or method named s in the subtree rooted at t. To accomplish
+       // that, we iteratively perform depth-first searches of increasing depth
+       // until we either find the named field/method or exhaust the tree.
+       for d := 0; ; d++ {
+               if d > len(dotlist) {
+                       dotlist = append(dotlist, dlist{})
+               }
+               if c, more := adddot1(s, t, d, save, ignorecase); c == 1 {
+                       return dotlist[:d], false
+               } else if c > 1 {
+                       return nil, true
+               } else if !more {
+                       return nil, false
+               }
+       }
+}
+
+func expand0(t *types.Type) {
+       u := t
+       if u.IsPtr() {
+               u = u.Elem()
+       }
+
+       if u.IsInterface() {
+               for _, f := range u.Fields().Slice() {
+                       if f.Sym.Uniq() {
+                               continue
+                       }
+                       f.Sym.SetUniq(true)
+                       slist = append(slist, symlink{field: f})
+               }
+
+               return
+       }
+
+       u = types.ReceiverBaseType(t)
+       if u != nil {
+               for _, f := range u.Methods().Slice() {
+                       if f.Sym.Uniq() {
+                               continue
+                       }
+                       f.Sym.SetUniq(true)
+                       slist = append(slist, symlink{field: f})
+               }
+       }
+}
+
+func expand1(t *types.Type, top bool) {
+       if t.Recur() {
+               return
+       }
+       t.SetRecur(true)
+
+       if !top {
+               expand0(t)
+       }
+
+       u := t
+       if u.IsPtr() {
+               u = u.Elem()
+       }
+
+       if u.IsStruct() || u.IsInterface() {
+               for _, f := range u.Fields().Slice() {
+                       if f.Embedded == 0 {
+                               continue
+                       }
+                       if f.Sym == nil {
+                               continue
+                       }
+                       expand1(f.Type, false)
+               }
+       }
+
+       t.SetRecur(false)
+}
+
+func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field, followptr bool) {
+       if t == nil {
+               return nil, false
+       }
+
+       path, ambig := dotpath(s, t, &m, ignorecase)
+       if path == nil {
+               if ambig {
+                       base.Errorf("%v.%v is ambiguous", t, s)
+               }
+               return nil, false
+       }
+
+       for _, d := range path {
+               if d.field.Type.IsPtr() {
+                       followptr = true
+                       break
+               }
+       }
+
+       if !m.IsMethod() {
+               base.Errorf("%v.%v is a field, not a method", t, s)
+               return nil, followptr
+       }
+
+       return m, followptr
+}
+
+func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool {
+       t0 := t
+       if t == nil {
+               return false
+       }
+
+       if t.IsInterface() {
+               i := 0
+               tms := t.Fields().Slice()
+               for _, im := range iface.Fields().Slice() {
+                       for i < len(tms) && tms[i].Sym != im.Sym {
+                               i++
+                       }
+                       if i == len(tms) {
+                               *m = im
+                               *samename = nil
+                               *ptr = 0
+                               return false
+                       }
+                       tm := tms[i]
+                       if !types.Identical(tm.Type, im.Type) {
+                               *m = im
+                               *samename = tm
+                               *ptr = 0
+                               return false
+                       }
+               }
+
+               return true
+       }
+
+       t = types.ReceiverBaseType(t)
+       var tms []*types.Field
+       if t != nil {
+               CalcMethods(t)
+               tms = t.AllMethods().Slice()
+       }
+       i := 0
+       for _, im := range iface.Fields().Slice() {
+               if im.Broke() {
+                       continue
+               }
+               for i < len(tms) && tms[i].Sym != im.Sym {
+                       i++
+               }
+               if i == len(tms) {
+                       *m = im
+                       *samename, _ = ifacelookdot(im.Sym, t, true)
+                       *ptr = 0
+                       return false
+               }
+               tm := tms[i]
+               if tm.Nointerface() || !types.Identical(tm.Type, im.Type) {
+                       *m = im
+                       *samename = tm
+                       *ptr = 0
+                       return false
+               }
+               followptr := tm.Embedded == 2
+
+               // if pointer receiver in method,
+               // the method does not exist for value types.
+               rcvr := tm.Type.Recv().Type
+               if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !types.IsInterfaceMethod(tm.Type) {
+                       if false && base.Flag.LowerR != 0 {
+                               base.Errorf("interface pointer mismatch")
+                       }
+
+                       *m = im
+                       *samename = nil
+                       *ptr = 1
+                       return false
+               }
+       }
+
+       return true
+}
+
+func isptrto(t *types.Type, et types.Kind) bool {
+       if t == nil {
+               return false
+       }
+       if !t.IsPtr() {
+               return false
+       }
+       t = t.Elem()
+       if t == nil {
+               return false
+       }
+       if t.Kind() != et {
+               return false
+       }
+       return true
+}
+
+// lookdot0 returns the number of fields or methods named s associated
+// with Type t. If exactly one exists, it will be returned in *save
+// (if save is not nil).
+func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) int {
+       u := t
+       if u.IsPtr() {
+               u = u.Elem()
+       }
+
+       c := 0
+       if u.IsStruct() || u.IsInterface() {
+               for _, f := range u.Fields().Slice() {
+                       if f.Sym == s || (ignorecase && f.IsMethod() && strings.EqualFold(f.Sym.Name, s.Name)) {
+                               if save != nil {
+                                       *save = f
+                               }
+                               c++
+                       }
+               }
+       }
+
+       u = t
+       if t.Sym() != nil && t.IsPtr() && !t.Elem().IsPtr() {
+               // If t is a defined pointer type, then x.m is shorthand for (*x).m.
+               u = t.Elem()
+       }
+       u = types.ReceiverBaseType(u)
+       if u != nil {
+               for _, f := range u.Methods().Slice() {
+                       if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
+                               if save != nil {
+                                       *save = f
+                               }
+                               c++
+                       }
+               }
+       }
+
+       return c
+}
+
+var slist []symlink
+
+// Code to help generate trampoline functions for methods on embedded
+// types. These are approx the same as the corresponding AddImplicitDots
+// routines except that they expect to be called with unique tasks and
+// they return the actual methods.
+
+type symlink struct {
+       field *types.Field
+}

diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
new file mode 100644 (file)
index 0000000..202a932
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -0,0 +1,102 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/src"
+)
+
+func LookupRuntime(name string) *ir.Name {
+       s := ir.Pkgs.Runtime.Lookup(name)
+       if s == nil || s.Def == nil {
+               base.Fatalf("LookupRuntime: can't find runtime.%s", name)
+       }
+       return ir.AsNode(s.Def).(*ir.Name)
+}
+
+// SubstArgTypes substitutes the given list of types for
+// successive occurrences of the "any" placeholder in the
+// type syntax expression n.Type.
+// The result of SubstArgTypes MUST be assigned back to old, e.g.
+//     n.Left = SubstArgTypes(n.Left, t1, t2)
+func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
+       for _, t := range types_ {
+               types.CalcSize(t)
+       }
+       n := ir.NewNameAt(old.Pos(), old.Sym())
+       n.Class = old.Class
+       n.SetType(types.SubstAny(old.Type(), &types_))
+       if len(types_) > 0 {
+               base.Fatalf("SubstArgTypes: too many argument types")
+       }
+       return n
+}
+
+// AutoLabel generates a new Name node for use with
+// an automatically generated label.
+// prefix is a short mnemonic (e.g. ".s" for switch)
+// to help with debugging.
+// It should begin with "." to avoid conflicts with
+// user labels.
+func AutoLabel(prefix string) *types.Sym {
+       if prefix[0] != '.' {
+               base.Fatalf("autolabel prefix must start with '.', have %q", prefix)
+       }
+       fn := ir.CurFunc
+       if ir.CurFunc == nil {
+               base.Fatalf("autolabel outside function")
+       }
+       n := fn.Label
+       fn.Label++
+       return LookupNum(prefix, int(n))
+}
+
+func Lookup(name string) *types.Sym {
+       return types.LocalPkg.Lookup(name)
+}
+
+// InitRuntime loads the definitions for the low-level runtime functions,
+// so that the compiler can generate calls to them,
+// but does not make them visible to user code.
+func InitRuntime() {
+       base.Timer.Start("fe", "loadsys")
+       types.Block = 1
+
+       typs := runtimeTypes()
+       for _, d := range &runtimeDecls {
+               sym := ir.Pkgs.Runtime.Lookup(d.name)
+               typ := typs[d.typ]
+               switch d.tag {
+               case funcTag:
+                       importfunc(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+               case varTag:
+                       importvar(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+               default:
+                       base.Fatalf("unhandled declaration tag %v", d.tag)
+               }
+       }
+}
+
+// LookupRuntimeFunc looks up Go function name in package runtime. This function
+// must follow the internal calling convention.
+func LookupRuntimeFunc(name string) *obj.LSym {
+       return LookupRuntimeABI(name, obj.ABIInternal)
+}
+
+// LookupRuntimeVar looks up a variable (or assembly function) name in package
+// runtime. If this is a function, it may have a special calling
+// convention.
+func LookupRuntimeVar(name string) *obj.LSym {
+       return LookupRuntimeABI(name, obj.ABI0)
+}
+
+// LookupRuntimeABI looks up a name in package runtime using the given ABI.
+func LookupRuntimeABI(name string, abi obj.ABI) *obj.LSym {
+       return base.PkgLinksym("runtime", name, abi)
+}

diff --git a/src/cmd/compile/internal/typecheck/target.go b/src/cmd/compile/internal/typecheck/target.go
new file mode 100644 (file)
index 0000000..018614d
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/target.go
@@ -0,0 +1,12 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run mkbuiltin.go
+
+package typecheck
+
+import "cmd/compile/internal/ir"
+
+// Target is the package being compiled.
+var Target *ir.Package

diff --git a/src/cmd/compile/internal/typecheck/type.go b/src/cmd/compile/internal/typecheck/type.go
new file mode 100644 (file)
index 0000000..6fdafef
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/type.go
@@ -0,0 +1,188 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+)
+
+// tcArrayType typechecks an OTARRAY node.
+func tcArrayType(n *ir.ArrayType) ir.Node {
+       n.Elem = typecheckNtype(n.Elem)
+       if n.Elem.Type() == nil {
+               return n
+       }
+       if n.Len == nil { // [...]T
+               if !n.Diag() {
+                       n.SetDiag(true)
+                       base.Errorf("use of [...] array outside of array literal")
+               }
+               return n
+       }
+       n.Len = indexlit(Expr(n.Len))
+       size := n.Len
+       if ir.ConstType(size) != constant.Int {
+               switch {
+               case size.Type() == nil:
+                       // Error already reported elsewhere.
+               case size.Type().IsInteger() && size.Op() != ir.OLITERAL:
+                       base.Errorf("non-constant array bound %v", size)
+               default:
+                       base.Errorf("invalid array bound %v", size)
+               }
+               return n
+       }
+
+       v := size.Val()
+       if ir.ConstOverflow(v, types.Types[types.TINT]) {
+               base.Errorf("array bound is too large")
+               return n
+       }
+
+       if constant.Sign(v) < 0 {
+               base.Errorf("array bound must be non-negative")
+               return n
+       }
+
+       bound, _ := constant.Int64Val(v)
+       t := types.NewArray(n.Elem.Type(), bound)
+       n.SetOTYPE(t)
+       types.CheckSize(t)
+       return n
+}
+
+// tcChanType typechecks an OTCHAN node.
+func tcChanType(n *ir.ChanType) ir.Node {
+       n.Elem = typecheckNtype(n.Elem)
+       l := n.Elem
+       if l.Type() == nil {
+               return n
+       }
+       if l.Type().NotInHeap() {
+               base.Errorf("chan of incomplete (or unallocatable) type not allowed")
+       }
+       n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
+       return n
+}
+
+// tcFuncType typechecks an OTFUNC node.
+func tcFuncType(n *ir.FuncType) ir.Node {
+       misc := func(f *types.Field, nf *ir.Field) {
+               f.SetIsDDD(nf.IsDDD)
+               if nf.Decl != nil {
+                       nf.Decl.SetType(f.Type)
+                       f.Nname = nf.Decl
+               }
+       }
+
+       lno := base.Pos
+
+       var recv *types.Field
+       if n.Recv != nil {
+               recv = tcField(n.Recv, misc)
+       }
+
+       t := types.NewSignature(types.LocalPkg, recv, tcFields(n.Params, misc), tcFields(n.Results, misc))
+       checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
+
+       base.Pos = lno
+
+       n.SetOTYPE(t)
+       return n
+}
+
+// tcInterfaceType typechecks an OTINTER node.
+func tcInterfaceType(n *ir.InterfaceType) ir.Node {
+       if len(n.Methods) == 0 {
+               n.SetOTYPE(types.Types[types.TINTER])
+               return n
+       }
+
+       lno := base.Pos
+       methods := tcFields(n.Methods, nil)
+       base.Pos = lno
+
+       n.SetOTYPE(types.NewInterface(types.LocalPkg, methods))
+       return n
+}
+
+// tcMapType typechecks an OTMAP node.
+func tcMapType(n *ir.MapType) ir.Node {
+       n.Key = typecheckNtype(n.Key)
+       n.Elem = typecheckNtype(n.Elem)
+       l := n.Key
+       r := n.Elem
+       if l.Type() == nil || r.Type() == nil {
+               return n
+       }
+       if l.Type().NotInHeap() {
+               base.Errorf("incomplete (or unallocatable) map key not allowed")
+       }
+       if r.Type().NotInHeap() {
+               base.Errorf("incomplete (or unallocatable) map value not allowed")
+       }
+       n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
+       mapqueue = append(mapqueue, n) // check map keys when all types are settled
+       return n
+}
+
+// tcSliceType typechecks an OTSLICE node.
+func tcSliceType(n *ir.SliceType) ir.Node {
+       n.Elem = typecheckNtype(n.Elem)
+       if n.Elem.Type() == nil {
+               return n
+       }
+       t := types.NewSlice(n.Elem.Type())
+       n.SetOTYPE(t)
+       types.CheckSize(t)
+       return n
+}
+
+// tcStructType typechecks an OTSTRUCT node.
+func tcStructType(n *ir.StructType) ir.Node {
+       lno := base.Pos
+
+       fields := tcFields(n.Fields, func(f *types.Field, nf *ir.Field) {
+               if nf.Embedded {
+                       checkembeddedtype(f.Type)
+                       f.Embedded = 1
+               }
+               f.Note = nf.Note
+       })
+       checkdupfields("field", fields)
+
+       base.Pos = lno
+       n.SetOTYPE(types.NewStruct(types.LocalPkg, fields))
+       return n
+}
+
+// tcField typechecks a generic Field.
+// misc can be provided to handle specialized typechecking.
+func tcField(n *ir.Field, misc func(*types.Field, *ir.Field)) *types.Field {
+       base.Pos = n.Pos
+       if n.Ntype != nil {
+               n.Type = typecheckNtype(n.Ntype).Type()
+               n.Ntype = nil
+       }
+       f := types.NewField(n.Pos, n.Sym, n.Type)
+       if misc != nil {
+               misc(f, n)
+       }
+       return f
+}
+
+// tcFields typechecks a slice of generic Fields.
+// misc can be provided to handle specialized typechecking.
+func tcFields(l []*ir.Field, misc func(*types.Field, *ir.Field)) []*types.Field {
+       fields := make([]*types.Field, len(l))
+       for i, n := range l {
+               fields[i] = tcField(n, misc)
+       }
+       return fields
+}

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
new file mode 100644 (file)
index 0000000..cb43457
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -0,0 +1,2164 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "fmt"
+       "go/constant"
+       "go/token"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+)
+
+// Function collecting autotmps generated during typechecking,
+// to be included in the package-level init function.
+var InitTodoFunc = ir.NewFunc(base.Pos)
+
+var inimport bool // set during import
+
+var TypecheckAllowed bool
+
+var (
+       NeedITab        = func(t, itype *types.Type) {}
+       NeedRuntimeType = func(*types.Type) {}
+)
+
+func AssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
+func Expr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
+func Stmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
+
+func Exprs(exprs []ir.Node) { typecheckslice(exprs, ctxExpr) }
+func Stmts(stmts []ir.Node) { typecheckslice(stmts, ctxStmt) }
+
+func Call(call *ir.CallExpr) {
+       t := call.X.Type()
+       if t == nil {
+               panic("misuse of Call")
+       }
+       ctx := ctxStmt
+       if t.NumResults() > 0 {
+               ctx = ctxExpr | ctxMultiOK
+       }
+       if typecheck(call, ctx) != call {
+               panic("bad typecheck")
+       }
+}
+
+func Callee(n ir.Node) ir.Node {
+       return typecheck(n, ctxExpr|ctxCallee)
+}
+
+func FuncBody(n *ir.Func) {
+       ir.CurFunc = n
+       errorsBefore := base.Errors()
+       Stmts(n.Body)
+       CheckUnused(n)
+       CheckReturn(n)
+       if base.Errors() > errorsBefore {
+               n.Body = nil // type errors; do not compile
+       }
+}
+
+var importlist []*ir.Func
+
+func AllImportedBodies() {
+       for _, n := range importlist {
+               if n.Inl != nil {
+                       ImportedBody(n)
+               }
+       }
+}
+
+var traceIndent []byte
+
+func tracePrint(title string, n ir.Node) func(np *ir.Node) {
+       indent := traceIndent
+
+       // guard against nil
+       var pos, op string
+       var tc uint8
+       if n != nil {
+               pos = base.FmtPos(n.Pos())
+               op = n.Op().String()
+               tc = n.Typecheck()
+       }
+
+       types.SkipSizeForTracing = true
+       defer func() { types.SkipSizeForTracing = false }()
+       fmt.Printf("%s: %s%s %p %s %v tc=%d\n", pos, indent, title, n, op, n, tc)
+       traceIndent = append(traceIndent, ". "...)
+
+       return func(np *ir.Node) {
+               traceIndent = traceIndent[:len(traceIndent)-2]
+
+               // if we have a result, use that
+               if np != nil {
+                       n = *np
+               }
+
+               // guard against nil
+               // use outer pos, op so we don't get empty pos/op if n == nil (nicer output)
+               var tc uint8
+               var typ *types.Type
+               if n != nil {
+                       pos = base.FmtPos(n.Pos())
+                       op = n.Op().String()
+                       tc = n.Typecheck()
+                       typ = n.Type()
+               }
+
+               types.SkipSizeForTracing = true
+               defer func() { types.SkipSizeForTracing = false }()
+               fmt.Printf("%s: %s=> %p %s %v tc=%d type=%L\n", pos, indent, n, op, n, tc, typ)
+       }
+}
+
+const (
+       ctxStmt    = 1 << iota // evaluated at statement level
+       ctxExpr                // evaluated in value context
+       ctxType                // evaluated in type context
+       ctxCallee              // call-only expressions are ok
+       ctxMultiOK             // multivalue function returns are ok
+       ctxAssign              // assigning to expression
+)
+
+// type checks the whole tree of an expression.
+// calculates expression types.
+// evaluates compile time constants.
+// marks variables that escape the local frame.
+// rewrites n.Op to be more specific in some cases.
+
+var typecheckdefstack []*ir.Name
+
+// Resolve ONONAME to definition, if any.
+func Resolve(n ir.Node) (res ir.Node) {
+       if n == nil || n.Op() != ir.ONONAME {
+               return n
+       }
+
+       // only trace if there's work to do
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("resolve", n)(&res)
+       }
+
+       if sym := n.Sym(); sym.Pkg != types.LocalPkg {
+               // We might have an ir.Ident from oldname or importDot.
+               if id, ok := n.(*ir.Ident); ok {
+                       if pkgName := DotImportRefs[id]; pkgName != nil {
+                               pkgName.Used = true
+                       }
+               }
+
+               return expandDecl(n)
+       }
+
+       r := ir.AsNode(n.Sym().Def)
+       if r == nil {
+               return n
+       }
+
+       if r.Op() == ir.OIOTA {
+               if x := getIotaValue(); x >= 0 {
+                       return ir.NewInt(x)
+               }
+               return n
+       }
+
+       return r
+}
+
+func typecheckslice(l []ir.Node, top int) {
+       for i := range l {
+               l[i] = typecheck(l[i], top)
+       }
+}
+
+var _typekind = []string{
+       types.TINT:        "int",
+       types.TUINT:       "uint",
+       types.TINT8:       "int8",
+       types.TUINT8:      "uint8",
+       types.TINT16:      "int16",
+       types.TUINT16:     "uint16",
+       types.TINT32:      "int32",
+       types.TUINT32:     "uint32",
+       types.TINT64:      "int64",
+       types.TUINT64:     "uint64",
+       types.TUINTPTR:    "uintptr",
+       types.TCOMPLEX64:  "complex64",
+       types.TCOMPLEX128: "complex128",
+       types.TFLOAT32:    "float32",
+       types.TFLOAT64:    "float64",
+       types.TBOOL:       "bool",
+       types.TSTRING:     "string",
+       types.TPTR:        "pointer",
+       types.TUNSAFEPTR:  "unsafe.Pointer",
+       types.TSTRUCT:     "struct",
+       types.TINTER:      "interface",
+       types.TCHAN:       "chan",
+       types.TMAP:        "map",
+       types.TARRAY:      "array",
+       types.TSLICE:      "slice",
+       types.TFUNC:       "func",
+       types.TNIL:        "nil",
+       types.TIDEAL:      "untyped number",
+}
+
+func typekind(t *types.Type) string {
+       if t.IsUntyped() {
+               return fmt.Sprintf("%v", t)
+       }
+       et := t.Kind()
+       if int(et) < len(_typekind) {
+               s := _typekind[et]
+               if s != "" {
+                       return s
+               }
+       }
+       return fmt.Sprintf("etype=%d", et)
+}
+
+func cycleFor(start ir.Node) []ir.Node {
+       // Find the start node in typecheck_tcstack.
+       // We know that it must exist because each time we mark
+       // a node with n.SetTypecheck(2) we push it on the stack,
+       // and each time we mark a node with n.SetTypecheck(2) we
+       // pop it from the stack. We hit a cycle when we encounter
+       // a node marked 2 in which case is must be on the stack.
+       i := len(typecheck_tcstack) - 1
+       for i > 0 && typecheck_tcstack[i] != start {
+               i--
+       }
+
+       // collect all nodes with same Op
+       var cycle []ir.Node
+       for _, n := range typecheck_tcstack[i:] {
+               if n.Op() == start.Op() {
+                       cycle = append(cycle, n)
+               }
+       }
+
+       return cycle
+}
+
+func cycleTrace(cycle []ir.Node) string {
+       var s string
+       for i, n := range cycle {
+               s += fmt.Sprintf("\n\t%v: %v uses %v", ir.Line(n), n, cycle[(i+1)%len(cycle)])
+       }
+       return s
+}
+
+var typecheck_tcstack []ir.Node
+
+func Func(fn *ir.Func) {
+       new := Stmt(fn)
+       if new != fn {
+               base.Fatalf("typecheck changed func")
+       }
+}
+
+func typecheckNtype(n ir.Ntype) ir.Ntype {
+       return typecheck(n, ctxType).(ir.Ntype)
+}
+
+// typecheck type checks node n.
+// The result of typecheck MUST be assigned back to n, e.g.
+//     n.Left = typecheck(n.Left, top)
+func typecheck(n ir.Node, top int) (res ir.Node) {
+       // cannot type check until all the source has been parsed
+       if !TypecheckAllowed {
+               base.Fatalf("early typecheck")
+       }
+
+       if n == nil {
+               return nil
+       }
+
+       // only trace if there's work to do
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("typecheck", n)(&res)
+       }
+
+       lno := ir.SetPos(n)
+
+       // Skip over parens.
+       for n.Op() == ir.OPAREN {
+               n = n.(*ir.ParenExpr).X
+       }
+
+       // Resolve definition of name and value of iota lazily.
+       n = Resolve(n)
+
+       // Skip typecheck if already done.
+       // But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
+       if n.Typecheck() == 1 {
+               switch n.Op() {
+               case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
+                       break
+
+               default:
+                       base.Pos = lno
+                       return n
+               }
+       }
+
+       if n.Typecheck() == 2 {
+               // Typechecking loop. Trying printing a meaningful message,
+               // otherwise a stack trace of typechecking.
+               switch n.Op() {
+               // We can already diagnose variables used as types.
+               case ir.ONAME:
+                       n := n.(*ir.Name)
+                       if top&(ctxExpr|ctxType) == ctxType {
+                               base.Errorf("%v is not a type", n)
+                       }
+
+               case ir.OTYPE:
+                       // Only report a type cycle if we are expecting a type.
+                       // Otherwise let other code report an error.
+                       if top&ctxType == ctxType {
+                               // A cycle containing only alias types is an error
+                               // since it would expand indefinitely when aliases
+                               // are substituted.
+                               cycle := cycleFor(n)
+                               for _, n1 := range cycle {
+                                       if n1.Name() != nil && !n1.Name().Alias() {
+                                               // Cycle is ok. But if n is an alias type and doesn't
+                                               // have a type yet, we have a recursive type declaration
+                                               // with aliases that we can't handle properly yet.
+                                               // Report an error rather than crashing later.
+                                               if n.Name() != nil && n.Name().Alias() && n.Type() == nil {
+                                                       base.Pos = n.Pos()
+                                                       base.Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
+                                               }
+                                               base.Pos = lno
+                                               return n
+                                       }
+                               }
+                               base.ErrorfAt(n.Pos(), "invalid recursive type alias %v%s", n, cycleTrace(cycle))
+                       }
+
+               case ir.OLITERAL:
+                       if top&(ctxExpr|ctxType) == ctxType {
+                               base.Errorf("%v is not a type", n)
+                               break
+                       }
+                       base.ErrorfAt(n.Pos(), "constant definition loop%s", cycleTrace(cycleFor(n)))
+               }
+
+               if base.Errors() == 0 {
+                       var trace string
+                       for i := len(typecheck_tcstack) - 1; i >= 0; i-- {
+                               x := typecheck_tcstack[i]
+                               trace += fmt.Sprintf("\n\t%v %v", ir.Line(x), x)
+                       }
+                       base.Errorf("typechecking loop involving %v%s", n, trace)
+               }
+
+               base.Pos = lno
+               return n
+       }
+
+       typecheck_tcstack = append(typecheck_tcstack, n)
+
+       n.SetTypecheck(2)
+       n = typecheck1(n, top)
+       n.SetTypecheck(1)
+
+       last := len(typecheck_tcstack) - 1
+       typecheck_tcstack[last] = nil
+       typecheck_tcstack = typecheck_tcstack[:last]
+
+       _, isExpr := n.(ir.Expr)
+       _, isStmt := n.(ir.Stmt)
+       isMulti := false
+       switch n.Op() {
+       case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
+               if t := n.X.Type(); t != nil && t.Kind() == types.TFUNC {
+                       nr := t.NumResults()
+                       isMulti = nr > 1
+                       if nr == 0 {
+                               isExpr = false
+                       }
+               }
+       case ir.OAPPEND:
+               // Must be used (and not BinaryExpr/UnaryExpr).
+               isStmt = false
+       case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.OVARKILL, ir.OVARLIVE:
+               // Must not be used.
+               isExpr = false
+               isStmt = true
+       case ir.OCOPY, ir.ORECOVER, ir.ORECV:
+               // Can be used or not.
+               isStmt = true
+       }
+
+       t := n.Type()
+       if t != nil && !t.IsFuncArgStruct() && n.Op() != ir.OTYPE {
+               switch t.Kind() {
+               case types.TFUNC, // might have TANY; wait until it's called
+                       types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
+                       break
+
+               default:
+                       types.CheckSize(t)
+               }
+       }
+       if t != nil {
+               n = EvalConst(n)
+               t = n.Type()
+       }
+
+       // TODO(rsc): Lots of the complexity here is because typecheck can
+       // see OTYPE, ONAME, and OLITERAL nodes multiple times.
+       // Once we make the IR a proper tree, we should be able to simplify
+       // this code a bit, especially the final case.
+       switch {
+       case top&(ctxStmt|ctxExpr) == ctxExpr && !isExpr && n.Op() != ir.OTYPE && !isMulti:
+               if !n.Diag() {
+                       base.Errorf("%v used as value", n)
+                       n.SetDiag(true)
+               }
+               if t != nil {
+                       n.SetType(nil)
+               }
+
+       case top&ctxType == 0 && n.Op() == ir.OTYPE && t != nil:
+               if !n.Type().Broke() {
+                       base.Errorf("type %v is not an expression", n.Type())
+               }
+               n.SetType(nil)
+
+       case top&(ctxStmt|ctxExpr) == ctxStmt && !isStmt && t != nil:
+               if !n.Diag() {
+                       base.Errorf("%v evaluated but not used", n)
+                       n.SetDiag(true)
+               }
+               n.SetType(nil)
+
+       case top&(ctxType|ctxExpr) == ctxType && n.Op() != ir.OTYPE && n.Op() != ir.ONONAME && (t != nil || n.Op() == ir.ONAME):
+               base.Errorf("%v is not a type", n)
+               if t != nil {
+                       n.SetType(nil)
+               }
+
+       }
+
+       base.Pos = lno
+       return n
+}
+
+// indexlit implements typechecking of untyped values as
+// array/slice indexes. It is almost equivalent to DefaultLit
+// but also accepts untyped numeric values representable as
+// value of type int (see also checkmake for comparison).
+// The result of indexlit MUST be assigned back to n, e.g.
+//     n.Left = indexlit(n.Left)
+func indexlit(n ir.Node) ir.Node {
+       if n != nil && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
+               return DefaultLit(n, types.Types[types.TINT])
+       }
+       return n
+}
+
+// typecheck1 should ONLY be called from typecheck.
+func typecheck1(n ir.Node, top int) ir.Node {
+       if n, ok := n.(*ir.Name); ok {
+               typecheckdef(n)
+       }
+
+       switch n.Op() {
+       default:
+               ir.Dump("typecheck", n)
+               base.Fatalf("typecheck %v", n.Op())
+               panic("unreachable")
+
+       case ir.OLITERAL:
+               if n.Sym() == nil && n.Type() == nil {
+                       base.Fatalf("literal missing type: %v", n)
+               }
+               return n
+
+       case ir.ONIL:
+               return n
+
+       // names
+       case ir.ONONAME:
+               if !n.Diag() {
+                       // Note: adderrorname looks for this string and
+                       // adds context about the outer expression
+                       base.ErrorfAt(n.Pos(), "undefined: %v", n.Sym())
+                       n.SetDiag(true)
+               }
+               n.SetType(nil)
+               return n
+
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.BuiltinOp != 0 {
+                       if top&ctxCallee == 0 {
+                               base.Errorf("use of builtin %v not in function call", n.Sym())
+                               n.SetType(nil)
+                               return n
+                       }
+                       return n
+               }
+               if top&ctxAssign == 0 {
+                       // not a write to the variable
+                       if ir.IsBlank(n) {
+                               base.Errorf("cannot use _ as value")
+                               n.SetType(nil)
+                               return n
+                       }
+                       n.SetUsed(true)
+               }
+               return n
+
+       case ir.OLINKSYMOFFSET:
+               // type already set
+               return n
+
+       case ir.OPACK:
+               n := n.(*ir.PkgName)
+               base.Errorf("use of package %v without selector", n.Sym())
+               n.SetType(nil)
+               return n
+
+       // types (ODEREF is with exprs)
+       case ir.OTYPE:
+               return n
+
+       case ir.OTSLICE:
+               n := n.(*ir.SliceType)
+               return tcSliceType(n)
+
+       case ir.OTARRAY:
+               n := n.(*ir.ArrayType)
+               return tcArrayType(n)
+
+       case ir.OTMAP:
+               n := n.(*ir.MapType)
+               return tcMapType(n)
+
+       case ir.OTCHAN:
+               n := n.(*ir.ChanType)
+               return tcChanType(n)
+
+       case ir.OTSTRUCT:
+               n := n.(*ir.StructType)
+               return tcStructType(n)
+
+       case ir.OTINTER:
+               n := n.(*ir.InterfaceType)
+               return tcInterfaceType(n)
+
+       case ir.OTFUNC:
+               n := n.(*ir.FuncType)
+               return tcFuncType(n)
+       // type or expr
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               return tcStar(n, top)
+
+       // x op= y
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               n.X, n.Y = Expr(n.X), Expr(n.Y)
+               checkassign(n, n.X)
+               if n.IncDec && !okforarith[n.X.Type().Kind()] {
+                       base.Errorf("invalid operation: %v (non-numeric type %v)", n, n.X.Type())
+                       return n
+               }
+               switch n.AsOp {
+               case ir.OLSH, ir.ORSH:
+                       n.X, n.Y, _ = tcShift(n, n.X, n.Y)
+               case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD, ir.OMUL, ir.OOR, ir.OSUB, ir.OXOR:
+                       n.X, n.Y, _ = tcArith(n, n.AsOp, n.X, n.Y)
+               default:
+                       base.Fatalf("invalid assign op: %v", n.AsOp)
+               }
+               return n
+
+       // logical operators
+       case ir.OANDAND, ir.OOROR:
+               n := n.(*ir.LogicalExpr)
+               n.X, n.Y = Expr(n.X), Expr(n.Y)
+               // For "x == x && len(s)", it's better to report that "len(s)" (type int)
+               // can't be used with "&&" than to report that "x == x" (type untyped bool)
+               // can't be converted to int (see issue #41500).
+               if !n.X.Type().IsBoolean() {
+                       base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
+                       n.SetType(nil)
+                       return n
+               }
+               if !n.Y.Type().IsBoolean() {
+                       base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
+                       n.SetType(nil)
+                       return n
+               }
+               l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+               n.X, n.Y = l, r
+               n.SetType(t)
+               return n
+
+       // shift operators
+       case ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               n.X, n.Y = Expr(n.X), Expr(n.Y)
+               l, r, t := tcShift(n, n.X, n.Y)
+               n.X, n.Y = l, r
+               n.SetType(t)
+               return n
+
+       // comparison operators
+       case ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT, ir.ONE:
+               n := n.(*ir.BinaryExpr)
+               n.X, n.Y = Expr(n.X), Expr(n.Y)
+               l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+               if t != nil {
+                       n.X, n.Y = l, r
+                       n.SetType(types.UntypedBool)
+                       if con := EvalConst(n); con.Op() == ir.OLITERAL {
+                               return con
+                       }
+                       n.X, n.Y = defaultlit2(l, r, true)
+               }
+               return n
+
+       // binary operators
+       case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD, ir.OMUL, ir.OOR, ir.OSUB, ir.OXOR:
+               n := n.(*ir.BinaryExpr)
+               n.X, n.Y = Expr(n.X), Expr(n.Y)
+               l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+               if t != nil && t.Kind() == types.TSTRING && n.Op() == ir.OADD {
+                       // create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
+                       var add *ir.AddStringExpr
+                       if l.Op() == ir.OADDSTR {
+                               add = l.(*ir.AddStringExpr)
+                               add.SetPos(n.Pos())
+                       } else {
+                               add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+                       }
+                       if r.Op() == ir.OADDSTR {
+                               r := r.(*ir.AddStringExpr)
+                               add.List.Append(r.List.Take()...)
+                       } else {
+                               add.List.Append(r)
+                       }
+                       add.SetType(t)
+                       return add
+               }
+               n.X, n.Y = l, r
+               n.SetType(t)
+               return n
+
+       case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
+               n := n.(*ir.UnaryExpr)
+               return tcUnaryArith(n)
+
+       // exprs
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               return tcAddr(n)
+
+       case ir.OCOMPLIT:
+               return tcCompLit(n.(*ir.CompLitExpr))
+
+       case ir.OXDOT, ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               return tcDot(n, top)
+
+       case ir.ODOTTYPE:
+               n := n.(*ir.TypeAssertExpr)
+               return tcDotType(n)
+
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               return tcIndex(n)
+
+       case ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               return tcRecv(n)
+
+       case ir.OSEND:
+               n := n.(*ir.SendStmt)
+               return tcSend(n)
+
+       case ir.OSLICEHEADER:
+               n := n.(*ir.SliceHeaderExpr)
+               return tcSliceHeader(n)
+
+       case ir.OMAKESLICECOPY:
+               n := n.(*ir.MakeExpr)
+               return tcMakeSliceCopy(n)
+
+       case ir.OSLICE, ir.OSLICE3:
+               n := n.(*ir.SliceExpr)
+               return tcSlice(n)
+
+       // call and call like
+       case ir.OCALL:
+               n := n.(*ir.CallExpr)
+               return tcCall(n, top)
+
+       case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+               n := n.(*ir.UnaryExpr)
+               n.SetType(types.Types[types.TUINTPTR])
+               return n
+
+       case ir.OCAP, ir.OLEN:
+               n := n.(*ir.UnaryExpr)
+               return tcLenCap(n)
+
+       case ir.OREAL, ir.OIMAG:
+               n := n.(*ir.UnaryExpr)
+               return tcRealImag(n)
+
+       case ir.OCOMPLEX:
+               n := n.(*ir.BinaryExpr)
+               return tcComplex(n)
+
+       case ir.OCLOSE:
+               n := n.(*ir.UnaryExpr)
+               return tcClose(n)
+
+       case ir.ODELETE:
+               n := n.(*ir.CallExpr)
+               return tcDelete(n)
+
+       case ir.OAPPEND:
+               n := n.(*ir.CallExpr)
+               return tcAppend(n)
+
+       case ir.OCOPY:
+               n := n.(*ir.BinaryExpr)
+               return tcCopy(n)
+
+       case ir.OCONV:
+               n := n.(*ir.ConvExpr)
+               return tcConv(n)
+
+       case ir.OMAKE:
+               n := n.(*ir.CallExpr)
+               return tcMake(n)
+
+       case ir.ONEW:
+               n := n.(*ir.UnaryExpr)
+               return tcNew(n)
+
+       case ir.OPRINT, ir.OPRINTN:
+               n := n.(*ir.CallExpr)
+               return tcPrint(n)
+
+       case ir.OPANIC:
+               n := n.(*ir.UnaryExpr)
+               return tcPanic(n)
+
+       case ir.ORECOVER:
+               n := n.(*ir.CallExpr)
+               return tcRecover(n)
+
+       case ir.OCLOSURE:
+               n := n.(*ir.ClosureExpr)
+               tcClosure(n, top)
+               if n.Type() == nil {
+                       return n
+               }
+               return n
+
+       case ir.OITAB:
+               n := n.(*ir.UnaryExpr)
+               return tcITab(n)
+
+       case ir.OIDATA:
+               // Whoever creates the OIDATA node must know a priori the concrete type at that moment,
+               // usually by just having checked the OITAB.
+               n := n.(*ir.UnaryExpr)
+               base.Fatalf("cannot typecheck interface data %v", n)
+               panic("unreachable")
+
+       case ir.OSPTR:
+               n := n.(*ir.UnaryExpr)
+               return tcSPtr(n)
+
+       case ir.OCFUNC:
+               n := n.(*ir.UnaryExpr)
+               n.X = Expr(n.X)
+               n.SetType(types.Types[types.TUINTPTR])
+               return n
+
+       case ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               n.X = Expr(n.X)
+               return n
+
+       // statements
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               tcAssign(n)
+
+               // Code that creates temps does not bother to set defn, so do it here.
+               if n.X.Op() == ir.ONAME && ir.IsAutoTmp(n.X) {
+                       n.X.Name().Defn = n
+               }
+               return n
+
+       case ir.OAS2:
+               tcAssignList(n.(*ir.AssignListStmt))
+               return n
+
+       case ir.OBREAK,
+               ir.OCONTINUE,
+               ir.ODCL,
+               ir.OGOTO,
+               ir.OFALL,
+               ir.OVARKILL,
+               ir.OVARLIVE:
+               return n
+
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
+               Stmts(n.List)
+               return n
+
+       case ir.OLABEL:
+               if n.Sym().IsBlank() {
+                       // Empty identifier is valid but useless.
+                       // Eliminate now to simplify life later.
+                       // See issues 7538, 11589, 11593.
+                       n = ir.NewBlockStmt(n.Pos(), nil)
+               }
+               return n
+
+       case ir.ODEFER, ir.OGO:
+               n := n.(*ir.GoDeferStmt)
+               n.Call = typecheck(n.Call, ctxStmt|ctxExpr)
+               if !n.Call.Diag() {
+                       tcGoDefer(n)
+               }
+               return n
+
+       case ir.OFOR, ir.OFORUNTIL:
+               n := n.(*ir.ForStmt)
+               return tcFor(n)
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               return tcIf(n)
+
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               return tcReturn(n)
+
+       case ir.OTAILCALL:
+               n := n.(*ir.TailCallStmt)
+               return n
+
+       case ir.OSELECT:
+               tcSelect(n.(*ir.SelectStmt))
+               return n
+
+       case ir.OSWITCH:
+               tcSwitch(n.(*ir.SwitchStmt))
+               return n
+
+       case ir.ORANGE:
+               tcRange(n.(*ir.RangeStmt))
+               return n
+
+       case ir.OTYPESW:
+               n := n.(*ir.TypeSwitchGuard)
+               base.Errorf("use of .(type) outside type switch")
+               n.SetType(nil)
+               return n
+
+       case ir.ODCLFUNC:
+               tcFunc(n.(*ir.Func))
+               return n
+
+       case ir.ODCLCONST:
+               n := n.(*ir.Decl)
+               n.X = Expr(n.X).(*ir.Name)
+               return n
+
+       case ir.ODCLTYPE:
+               n := n.(*ir.Decl)
+               n.X = typecheck(n.X, ctxType).(*ir.Name)
+               types.CheckSize(n.X.Type())
+               return n
+       }
+
+       // No return n here!
+       // Individual cases can type-assert n, introducing a new one.
+       // Each must execute its own return n.
+}
+
+func typecheckargs(n ir.InitNode) {
+       var list []ir.Node
+       switch n := n.(type) {
+       default:
+               base.Fatalf("typecheckargs %+v", n.Op())
+       case *ir.CallExpr:
+               list = n.Args
+               if n.IsDDD {
+                       Exprs(list)
+                       return
+               }
+       case *ir.ReturnStmt:
+               list = n.Results
+       }
+       if len(list) != 1 {
+               Exprs(list)
+               return
+       }
+
+       typecheckslice(list, ctxExpr|ctxMultiOK)
+       t := list[0].Type()
+       if t == nil || !t.IsFuncArgStruct() {
+               return
+       }
+
+       // Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
+
+       // Save n as n.Orig for fmt.go.
+       if ir.Orig(n) == n {
+               n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
+       }
+
+       as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+       as.Rhs.Append(list...)
+
+       // If we're outside of function context, then this call will
+       // be executed during the generated init function. However,
+       // init.go hasn't yet created it. Instead, associate the
+       // temporary variables with  InitTodoFunc for now, and init.go
+       // will reassociate them later when it's appropriate.
+       static := ir.CurFunc == nil
+       if static {
+               ir.CurFunc = InitTodoFunc
+       }
+       list = nil
+       for _, f := range t.FieldSlice() {
+               t := Temp(f.Type)
+               as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
+               as.Lhs.Append(t)
+               list = append(list, t)
+       }
+       if static {
+               ir.CurFunc = nil
+       }
+
+       switch n := n.(type) {
+       case *ir.CallExpr:
+               n.Args = list
+       case *ir.ReturnStmt:
+               n.Results = list
+       }
+
+       n.PtrInit().Append(Stmt(as))
+}
+
+func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
+       t := r.Type()
+       if t == nil {
+               return false
+       }
+       if !t.IsInteger() {
+               base.Errorf("invalid slice index %v (type %v)", r, t)
+               return false
+       }
+
+       if r.Op() == ir.OLITERAL {
+               x := r.Val()
+               if constant.Sign(x) < 0 {
+                       base.Errorf("invalid slice index %v (index must be non-negative)", r)
+                       return false
+               } else if tp != nil && tp.NumElem() >= 0 && constant.Compare(x, token.GTR, constant.MakeInt64(tp.NumElem())) {
+                       base.Errorf("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
+                       return false
+               } else if ir.IsConst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(ir.StringVal(l))))) {
+                       base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(ir.StringVal(l)))
+                       return false
+               } else if ir.ConstOverflow(x, types.Types[types.TINT]) {
+                       base.Errorf("invalid slice index %v (index too large)", r)
+                       return false
+               }
+       }
+
+       return true
+}
+
+func checksliceconst(lo ir.Node, hi ir.Node) bool {
+       if lo != nil && hi != nil && lo.Op() == ir.OLITERAL && hi.Op() == ir.OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
+               base.Errorf("invalid slice index: %v > %v", lo, hi)
+               return false
+       }
+
+       return true
+}
+
+// The result of implicitstar MUST be assigned back to n, e.g.
+//     n.Left = implicitstar(n.Left)
+func implicitstar(n ir.Node) ir.Node {
+       // insert implicit * if needed for fixed array
+       t := n.Type()
+       if t == nil || !t.IsPtr() {
+               return n
+       }
+       t = t.Elem()
+       if t == nil {
+               return n
+       }
+       if !t.IsArray() {
+               return n
+       }
+       star := ir.NewStarExpr(base.Pos, n)
+       star.SetImplicit(true)
+       return Expr(star)
+}
+
+func needOneArg(n *ir.CallExpr, f string, args ...interface{}) (ir.Node, bool) {
+       if len(n.Args) == 0 {
+               p := fmt.Sprintf(f, args...)
+               base.Errorf("missing argument to %s: %v", p, n)
+               return nil, false
+       }
+
+       if len(n.Args) > 1 {
+               p := fmt.Sprintf(f, args...)
+               base.Errorf("too many arguments to %s: %v", p, n)
+               return n.Args[0], false
+       }
+
+       return n.Args[0], true
+}
+
+func needTwoArgs(n *ir.CallExpr) (ir.Node, ir.Node, bool) {
+       if len(n.Args) != 2 {
+               if len(n.Args) < 2 {
+                       base.Errorf("not enough arguments in call to %v", n)
+               } else {
+                       base.Errorf("too many arguments in call to %v", n)
+               }
+               return nil, nil, false
+       }
+       return n.Args[0], n.Args[1], true
+}
+
+func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
+       var r *types.Field
+       for _, f := range fs.Slice() {
+               if dostrcmp != 0 && f.Sym.Name == s.Name {
+                       return f
+               }
+               if dostrcmp == 2 && strings.EqualFold(f.Sym.Name, s.Name) {
+                       return f
+               }
+               if f.Sym != s {
+                       continue
+               }
+               if r != nil {
+                       if errnode != nil {
+                               base.Errorf("ambiguous selector %v", errnode)
+                       } else if t.IsPtr() {
+                               base.Errorf("ambiguous selector (%v).%v", t, s)
+                       } else {
+                               base.Errorf("ambiguous selector %v.%v", t, s)
+                       }
+                       break
+               }
+
+               r = f
+       }
+
+       return r
+}
+
+// typecheckMethodExpr checks selector expressions (ODOT) where the
+// base expression is a type expression (OTYPE).
+func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("typecheckMethodExpr", n)(&res)
+       }
+
+       t := n.X.Type()
+
+       // Compute the method set for t.
+       var ms *types.Fields
+       if t.IsInterface() {
+               ms = t.Fields()
+       } else {
+               mt := types.ReceiverBaseType(t)
+               if mt == nil {
+                       base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sel)
+                       n.SetType(nil)
+                       return n
+               }
+               CalcMethods(mt)
+               ms = mt.AllMethods()
+
+               // The method expression T.m requires a wrapper when T
+               // is different from m's declared receiver type. We
+               // normally generate these wrappers while writing out
+               // runtime type descriptors, which is always done for
+               // types declared at package scope. However, we need
+               // to make sure to generate wrappers for anonymous
+               // receiver types too.
+               if mt.Sym() == nil {
+                       NeedRuntimeType(t)
+               }
+       }
+
+       s := n.Sel
+       m := lookdot1(n, s, t, ms, 0)
+       if m == nil {
+               if lookdot1(n, s, t, ms, 1) != nil {
+                       base.Errorf("%v undefined (cannot refer to unexported method %v)", n, s)
+               } else if _, ambig := dotpath(s, t, nil, false); ambig {
+                       base.Errorf("%v undefined (ambiguous selector)", n) // method or field
+               } else {
+                       base.Errorf("%v undefined (type %v has no method %v)", n, t, s)
+               }
+               n.SetType(nil)
+               return n
+       }
+
+       if !types.IsMethodApplicable(t, m) {
+               base.Errorf("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
+               n.SetType(nil)
+               return n
+       }
+
+       n.SetOp(ir.OMETHEXPR)
+       n.Selection = m
+       n.SetType(NewMethodType(m.Type, n.X.Type()))
+       return n
+}
+
+func derefall(t *types.Type) *types.Type {
+       for t != nil && t.IsPtr() {
+               t = t.Elem()
+       }
+       return t
+}
+
+func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
+       s := n.Sel
+
+       types.CalcSize(t)
+       var f1 *types.Field
+       if t.IsStruct() || t.IsInterface() {
+               f1 = lookdot1(n, s, t, t.Fields(), dostrcmp)
+       }
+
+       var f2 *types.Field
+       if n.X.Type() == t || n.X.Type().Sym() == nil {
+               mt := types.ReceiverBaseType(t)
+               if mt != nil {
+                       f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
+               }
+       }
+
+       if f1 != nil {
+               if dostrcmp > 1 || f1.Broke() {
+                       // Already in the process of diagnosing an error.
+                       return f1
+               }
+               if f2 != nil {
+                       base.Errorf("%v is both field and method", n.Sel)
+               }
+               if f1.Offset == types.BADWIDTH {
+                       base.Fatalf("lookdot badwidth %v %p", f1, f1)
+               }
+               n.Selection = f1
+               n.SetType(f1.Type)
+               if t.IsInterface() {
+                       if n.X.Type().IsPtr() {
+                               star := ir.NewStarExpr(base.Pos, n.X)
+                               star.SetImplicit(true)
+                               n.X = Expr(star)
+                       }
+
+                       n.SetOp(ir.ODOTINTER)
+               }
+               return f1
+       }
+
+       if f2 != nil {
+               if dostrcmp > 1 {
+                       // Already in the process of diagnosing an error.
+                       return f2
+               }
+               orig := n.X
+               tt := n.X.Type()
+               types.CalcSize(tt)
+               rcvr := f2.Type.Recv().Type
+               if !types.Identical(rcvr, tt) {
+                       if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
+                               checklvalue(n.X, "call pointer method on")
+                               addr := NodAddr(n.X)
+                               addr.SetImplicit(true)
+                               n.X = typecheck(addr, ctxType|ctxExpr)
+                       } else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
+                               star := ir.NewStarExpr(base.Pos, n.X)
+                               star.SetImplicit(true)
+                               n.X = typecheck(star, ctxType|ctxExpr)
+                       } else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
+                               base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sel, n.X)
+                               for tt.IsPtr() {
+                                       // Stop one level early for method with pointer receiver.
+                                       if rcvr.IsPtr() && !tt.Elem().IsPtr() {
+                                               break
+                                       }
+                                       star := ir.NewStarExpr(base.Pos, n.X)
+                                       star.SetImplicit(true)
+                                       n.X = typecheck(star, ctxType|ctxExpr)
+                                       tt = tt.Elem()
+                               }
+                       } else {
+                               base.Fatalf("method mismatch: %v for %v", rcvr, tt)
+                       }
+               }
+
+               // Check that we haven't implicitly dereferenced any defined pointer types.
+               for x := n.X; ; {
+                       var inner ir.Node
+                       implicit := false
+                       switch x := x.(type) {
+                       case *ir.AddrExpr:
+                               inner, implicit = x.X, x.Implicit()
+                       case *ir.SelectorExpr:
+                               inner, implicit = x.X, x.Implicit()
+                       case *ir.StarExpr:
+                               inner, implicit = x.X, x.Implicit()
+                       }
+                       if !implicit {
+                               break
+                       }
+                       if inner.Type().Sym() != nil && (x.Op() == ir.ODEREF || x.Op() == ir.ODOTPTR) {
+                               // Found an implicit dereference of a defined pointer type.
+                               // Restore n.X for better error message.
+                               n.X = orig
+                               return nil
+                       }
+                       x = inner
+               }
+
+               n.Selection = f2
+               n.SetType(f2.Type)
+               n.SetOp(ir.ODOTMETH)
+
+               return f2
+       }
+
+       return nil
+}
+
+func nokeys(l ir.Nodes) bool {
+       for _, n := range l {
+               if n.Op() == ir.OKEY || n.Op() == ir.OSTRUCTKEY {
+                       return false
+               }
+       }
+       return true
+}
+
+func hasddd(t *types.Type) bool {
+       for _, tl := range t.Fields().Slice() {
+               if tl.IsDDD() {
+                       return true
+               }
+       }
+
+       return false
+}
+
+// typecheck assignment: type list = expression list
+func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl ir.Nodes, desc func() string) {
+       var t *types.Type
+       var i int
+
+       lno := base.Pos
+       defer func() { base.Pos = lno }()
+
+       if tstruct.Broke() {
+               return
+       }
+
+       var n ir.Node
+       if len(nl) == 1 {
+               n = nl[0]
+       }
+
+       n1 := tstruct.NumFields()
+       n2 := len(nl)
+       if !hasddd(tstruct) {
+               if n2 > n1 {
+                       goto toomany
+               }
+               if n2 < n1 {
+                       goto notenough
+               }
+       } else {
+               if !isddd {
+                       if n2 < n1-1 {
+                               goto notenough
+                       }
+               } else {
+                       if n2 > n1 {
+                               goto toomany
+                       }
+                       if n2 < n1 {
+                               goto notenough
+                       }
+               }
+       }
+
+       i = 0
+       for _, tl := range tstruct.Fields().Slice() {
+               t = tl.Type
+               if tl.IsDDD() {
+                       if isddd {
+                               if i >= len(nl) {
+                                       goto notenough
+                               }
+                               if len(nl)-i > 1 {
+                                       goto toomany
+                               }
+                               n = nl[i]
+                               ir.SetPos(n)
+                               if n.Type() != nil {
+                                       nl[i] = assignconvfn(n, t, desc)
+                               }
+                               return
+                       }
+
+                       // TODO(mdempsky): Make into ... call with implicit slice.
+                       for ; i < len(nl); i++ {
+                               n = nl[i]
+                               ir.SetPos(n)
+                               if n.Type() != nil {
+                                       nl[i] = assignconvfn(n, t.Elem(), desc)
+                               }
+                       }
+                       return
+               }
+
+               if i >= len(nl) {
+                       goto notenough
+               }
+               n = nl[i]
+               ir.SetPos(n)
+               if n.Type() != nil {
+                       nl[i] = assignconvfn(n, t, desc)
+               }
+               i++
+       }
+
+       if i < len(nl) {
+               goto toomany
+       }
+       if isddd {
+               if call != nil {
+                       base.Errorf("invalid use of ... in call to %v", call)
+               } else {
+                       base.Errorf("invalid use of ... in %v", op)
+               }
+       }
+       return
+
+notenough:
+       if n == nil || (!n.Diag() && n.Type() != nil) {
+               details := errorDetails(nl, tstruct, isddd)
+               if call != nil {
+                       // call is the expression being called, not the overall call.
+                       // Method expressions have the form T.M, and the compiler has
+                       // rewritten those to ONAME nodes but left T in Left.
+                       if call.Op() == ir.OMETHEXPR {
+                               call := call.(*ir.SelectorExpr)
+                               base.Errorf("not enough arguments in call to method expression %v%s", call, details)
+                       } else {
+                               base.Errorf("not enough arguments in call to %v%s", call, details)
+                       }
+               } else {
+                       base.Errorf("not enough arguments to %v%s", op, details)
+               }
+               if n != nil {
+                       n.SetDiag(true)
+               }
+       }
+       return
+
+toomany:
+       details := errorDetails(nl, tstruct, isddd)
+       if call != nil {
+               base.Errorf("too many arguments in call to %v%s", call, details)
+       } else {
+               base.Errorf("too many arguments to %v%s", op, details)
+       }
+}
+
+func errorDetails(nl ir.Nodes, tstruct *types.Type, isddd bool) string {
+       // If we don't know any type at a call site, let's suppress any return
+       // message signatures. See Issue https://golang.org/issues/19012.
+       if tstruct == nil {
+               return ""
+       }
+       // If any node has an unknown type, suppress it as well
+       for _, n := range nl {
+               if n.Type() == nil {
+                       return ""
+               }
+       }
+       return fmt.Sprintf("\n\thave %s\n\twant %v", fmtSignature(nl, isddd), tstruct)
+}
+
+// sigrepr is a type's representation to the outside world,
+// in string representations of return signatures
+// e.g in error messages about wrong arguments to return.
+func sigrepr(t *types.Type, isddd bool) string {
+       switch t {
+       case types.UntypedString:
+               return "string"
+       case types.UntypedBool:
+               return "bool"
+       }
+
+       if t.Kind() == types.TIDEAL {
+               // "untyped number" is not commonly used
+               // outside of the compiler, so let's use "number".
+               // TODO(mdempsky): Revisit this.
+               return "number"
+       }
+
+       // Turn []T... argument to ...T for clearer error message.
+       if isddd {
+               if !t.IsSlice() {
+                       base.Fatalf("bad type for ... argument: %v", t)
+               }
+               return "..." + t.Elem().String()
+       }
+       return t.String()
+}
+
+// sigerr returns the signature of the types at the call or return.
+func fmtSignature(nl ir.Nodes, isddd bool) string {
+       if len(nl) < 1 {
+               return "()"
+       }
+
+       var typeStrings []string
+       for i, n := range nl {
+               isdddArg := isddd && i == len(nl)-1
+               typeStrings = append(typeStrings, sigrepr(n.Type(), isdddArg))
+       }
+
+       return fmt.Sprintf("(%s)", strings.Join(typeStrings, ", "))
+}
+
+// type check composite
+func fielddup(name string, hash map[string]bool) {
+       if hash[name] {
+               base.Errorf("duplicate field name in struct literal: %s", name)
+               return
+       }
+       hash[name] = true
+}
+
+// iscomptype reports whether type t is a composite literal type.
+func iscomptype(t *types.Type) bool {
+       switch t.Kind() {
+       case types.TARRAY, types.TSLICE, types.TSTRUCT, types.TMAP:
+               return true
+       default:
+               return false
+       }
+}
+
+// pushtype adds elided type information for composite literals if
+// appropriate, and returns the resulting expression.
+func pushtype(nn ir.Node, t *types.Type) ir.Node {
+       if nn == nil || nn.Op() != ir.OCOMPLIT {
+               return nn
+       }
+       n := nn.(*ir.CompLitExpr)
+       if n.Ntype != nil {
+               return n
+       }
+
+       switch {
+       case iscomptype(t):
+               // For T, return T{...}.
+               n.Ntype = ir.TypeNode(t)
+
+       case t.IsPtr() && iscomptype(t.Elem()):
+               // For *T, return &T{...}.
+               n.Ntype = ir.TypeNode(t.Elem())
+
+               addr := NodAddrAt(n.Pos(), n)
+               addr.SetImplicit(true)
+               return addr
+       }
+       return n
+}
+
+// typecheckarraylit type-checks a sequence of slice/array literal elements.
+func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx string) int64 {
+       // If there are key/value pairs, create a map to keep seen
+       // keys so we can check for duplicate indices.
+       var indices map[int64]bool
+       for _, elt := range elts {
+               if elt.Op() == ir.OKEY {
+                       indices = make(map[int64]bool)
+                       break
+               }
+       }
+
+       var key, length int64
+       for i, elt := range elts {
+               ir.SetPos(elt)
+               r := elts[i]
+               var kv *ir.KeyExpr
+               if elt.Op() == ir.OKEY {
+                       elt := elt.(*ir.KeyExpr)
+                       elt.Key = Expr(elt.Key)
+                       key = IndexConst(elt.Key)
+                       if key < 0 {
+                               if !elt.Key.Diag() {
+                                       if key == -2 {
+                                               base.Errorf("index too large")
+                                       } else {
+                                               base.Errorf("index must be non-negative integer constant")
+                                       }
+                                       elt.Key.SetDiag(true)
+                               }
+                               key = -(1 << 30) // stay negative for a while
+                       }
+                       kv = elt
+                       r = elt.Value
+               }
+
+               r = pushtype(r, elemType)
+               r = Expr(r)
+               r = AssignConv(r, elemType, ctx)
+               if kv != nil {
+                       kv.Value = r
+               } else {
+                       elts[i] = r
+               }
+
+               if key >= 0 {
+                       if indices != nil {
+                               if indices[key] {
+                                       base.Errorf("duplicate index in %s: %d", ctx, key)
+                               } else {
+                                       indices[key] = true
+                               }
+                       }
+
+                       if bound >= 0 && key >= bound {
+                               base.Errorf("array index %d out of bounds [0:%d]", key, bound)
+                               bound = -1
+                       }
+               }
+
+               key++
+               if key > length {
+                       length = key
+               }
+       }
+
+       return length
+}
+
+// visible reports whether sym is exported or locally defined.
+func visible(sym *types.Sym) bool {
+       return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == types.LocalPkg)
+}
+
+// nonexported reports whether sym is an unexported field.
+func nonexported(sym *types.Sym) bool {
+       return sym != nil && !types.IsExported(sym.Name)
+}
+
+func checklvalue(n ir.Node, verb string) {
+       if !ir.IsAddressable(n) {
+               base.Errorf("cannot %s %v", verb, n)
+       }
+}
+
+func checkassign(stmt ir.Node, n ir.Node) {
+       // have already complained about n being invalid
+       if n.Type() == nil {
+               if base.Errors() == 0 {
+                       base.Fatalf("expected an error about %v", n)
+               }
+               return
+       }
+
+       if ir.IsAddressable(n) {
+               return
+       }
+       if n.Op() == ir.OINDEXMAP {
+               n := n.(*ir.IndexExpr)
+               n.Assigned = true
+               return
+       }
+
+       switch {
+       case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).X.Op() == ir.OINDEXMAP:
+               base.Errorf("cannot assign to struct field %v in map", n)
+       case (n.Op() == ir.OINDEX && n.(*ir.IndexExpr).X.Type().IsString()) || n.Op() == ir.OSLICESTR:
+               base.Errorf("cannot assign to %v (strings are immutable)", n)
+       case n.Op() == ir.OLITERAL && n.Sym() != nil && ir.IsConstNode(n):
+               base.Errorf("cannot assign to %v (declared const)", n)
+       default:
+               base.Errorf("cannot assign to %v", n)
+       }
+       n.SetType(nil)
+}
+
+func checkassignlist(stmt ir.Node, l ir.Nodes) {
+       for _, n := range l {
+               checkassign(stmt, n)
+       }
+}
+
+func checkassignto(src *types.Type, dst ir.Node) {
+       // TODO(mdempsky): Handle all untyped types correctly.
+       if src == types.UntypedBool && dst.Type().IsBoolean() {
+               return
+       }
+
+       if op, why := assignop(src, dst.Type()); op == ir.OXXX {
+               base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
+               return
+       }
+}
+
+// The result of stringtoruneslit MUST be assigned back to n, e.g.
+//     n.Left = stringtoruneslit(n.Left)
+func stringtoruneslit(n *ir.ConvExpr) ir.Node {
+       if n.X.Op() != ir.OLITERAL || n.X.Val().Kind() != constant.String {
+               base.Fatalf("stringtoarraylit %v", n)
+       }
+
+       var l []ir.Node
+       i := 0
+       for _, r := range ir.StringVal(n.X) {
+               l = append(l, ir.NewKeyExpr(base.Pos, ir.NewInt(int64(i)), ir.NewInt(int64(r))))
+               i++
+       }
+
+       nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()), nil)
+       nn.List = l
+       return Expr(nn)
+}
+
+var mapqueue []*ir.MapType
+
+func CheckMapKeys() {
+       for _, n := range mapqueue {
+               k := n.Type().MapType().Key
+               if !k.Broke() && !types.IsComparable(k) {
+                       base.ErrorfAt(n.Pos(), "invalid map key type %v", k)
+               }
+       }
+       mapqueue = nil
+}
+
+// TypeGen tracks the number of function-scoped defined types that
+// have been declared. It's used to generate unique linker symbols for
+// their runtime type descriptors.
+var TypeGen int32
+
+func typecheckdeftype(n *ir.Name) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("typecheckdeftype", n)(nil)
+       }
+
+       t := types.NewNamed(n)
+       if n.Curfn != nil {
+               TypeGen++
+               t.Vargen = TypeGen
+       }
+
+       if n.Pragma()&ir.NotInHeap != 0 {
+               t.SetNotInHeap(true)
+       }
+
+       n.SetType(t)
+       n.SetTypecheck(1)
+       n.SetWalkdef(1)
+
+       types.DeferCheckSize()
+       errorsBefore := base.Errors()
+       n.Ntype = typecheckNtype(n.Ntype)
+       if underlying := n.Ntype.Type(); underlying != nil {
+               t.SetUnderlying(underlying)
+       } else {
+               n.SetDiag(true)
+               n.SetType(nil)
+       }
+       if t.Kind() == types.TFORW && base.Errors() > errorsBefore {
+               // Something went wrong during type-checking,
+               // but it was reported. Silence future errors.
+               t.SetBroke(true)
+       }
+       types.ResumeCheckSize()
+}
+
+func typecheckdef(n *ir.Name) {
+       if base.EnableTrace && base.Flag.LowerT {
+               defer tracePrint("typecheckdef", n)(nil)
+       }
+
+       if n.Walkdef() == 1 {
+               return
+       }
+
+       if n.Type() != nil { // builtin
+               // Mark as Walkdef so that if n.SetType(nil) is called later, we
+               // won't try walking again.
+               if got := n.Walkdef(); got != 0 {
+                       base.Fatalf("unexpected walkdef: %v", got)
+               }
+               n.SetWalkdef(1)
+               return
+       }
+
+       lno := ir.SetPos(n)
+       typecheckdefstack = append(typecheckdefstack, n)
+       if n.Walkdef() == 2 {
+               base.FlushErrors()
+               fmt.Printf("typecheckdef loop:")
+               for i := len(typecheckdefstack) - 1; i >= 0; i-- {
+                       n := typecheckdefstack[i]
+                       fmt.Printf(" %v", n.Sym())
+               }
+               fmt.Printf("\n")
+               base.Fatalf("typecheckdef loop")
+       }
+
+       n.SetWalkdef(2)
+
+       switch n.Op() {
+       default:
+               base.Fatalf("typecheckdef %v", n.Op())
+
+       case ir.OLITERAL:
+               if n.Ntype != nil {
+                       n.Ntype = typecheckNtype(n.Ntype)
+                       n.SetType(n.Ntype.Type())
+                       n.Ntype = nil
+                       if n.Type() == nil {
+                               n.SetDiag(true)
+                               goto ret
+                       }
+               }
+
+               e := n.Defn
+               n.Defn = nil
+               if e == nil {
+                       ir.Dump("typecheckdef nil defn", n)
+                       base.ErrorfAt(n.Pos(), "xxx")
+               }
+
+               e = Expr(e)
+               if e.Type() == nil {
+                       goto ret
+               }
+               if !ir.IsConstNode(e) {
+                       if !e.Diag() {
+                               if e.Op() == ir.ONIL {
+                                       base.ErrorfAt(n.Pos(), "const initializer cannot be nil")
+                               } else {
+                                       base.ErrorfAt(n.Pos(), "const initializer %v is not a constant", e)
+                               }
+                               e.SetDiag(true)
+                       }
+                       goto ret
+               }
+
+               t := n.Type()
+               if t != nil {
+                       if !ir.OKForConst[t.Kind()] {
+                               base.ErrorfAt(n.Pos(), "invalid constant type %v", t)
+                               goto ret
+                       }
+
+                       if !e.Type().IsUntyped() && !types.Identical(t, e.Type()) {
+                               base.ErrorfAt(n.Pos(), "cannot use %L as type %v in const initializer", e, t)
+                               goto ret
+                       }
+
+                       e = convlit(e, t)
+               }
+
+               n.SetType(e.Type())
+               if n.Type() != nil {
+                       n.SetVal(e.Val())
+               }
+
+       case ir.ONAME:
+               if n.Ntype != nil {
+                       n.Ntype = typecheckNtype(n.Ntype)
+                       n.SetType(n.Ntype.Type())
+                       if n.Type() == nil {
+                               n.SetDiag(true)
+                               goto ret
+                       }
+               }
+
+               if n.Type() != nil {
+                       break
+               }
+               if n.Defn == nil {
+                       if n.BuiltinOp != 0 { // like OPRINTN
+                               break
+                       }
+                       if base.Errors() > 0 {
+                               // Can have undefined variables in x := foo
+                               // that make x have an n.name.Defn == nil.
+                               // If there are other errors anyway, don't
+                               // bother adding to the noise.
+                               break
+                       }
+
+                       base.Fatalf("var without type, init: %v", n.Sym())
+               }
+
+               if n.Defn.Op() == ir.ONAME {
+                       n.Defn = Expr(n.Defn)
+                       n.SetType(n.Defn.Type())
+                       break
+               }
+
+               n.Defn = Stmt(n.Defn) // fills in n.Type
+
+       case ir.OTYPE:
+               if n.Alias() {
+                       // Type alias declaration: Simply use the rhs type - no need
+                       // to create a new type.
+                       // If we have a syntax error, name.Ntype may be nil.
+                       if n.Ntype != nil {
+                               n.Ntype = typecheckNtype(n.Ntype)
+                               n.SetType(n.Ntype.Type())
+                               if n.Type() == nil {
+                                       n.SetDiag(true)
+                                       goto ret
+                               }
+                               // For package-level type aliases, set n.Sym.Def so we can identify
+                               // it as a type alias during export. See also #31959.
+                               if n.Curfn == nil {
+                                       n.Sym().Def = n.Ntype
+                               }
+                       }
+                       break
+               }
+
+               // regular type declaration
+               typecheckdeftype(n)
+       }
+
+ret:
+       if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().IsUntyped() {
+               base.Fatalf("got %v for %v", n.Type(), n)
+       }
+       last := len(typecheckdefstack) - 1
+       if typecheckdefstack[last] != n {
+               base.Fatalf("typecheckdefstack mismatch")
+       }
+       typecheckdefstack[last] = nil
+       typecheckdefstack = typecheckdefstack[:last]
+
+       base.Pos = lno
+       n.SetWalkdef(1)
+}
+
+func checkmake(t *types.Type, arg string, np *ir.Node) bool {
+       n := *np
+       if !n.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+               base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type())
+               return false
+       }
+
+       // Do range checks for constants before DefaultLit
+       // to avoid redundant "constant NNN overflows int" errors.
+       if n.Op() == ir.OLITERAL {
+               v := toint(n.Val())
+               if constant.Sign(v) < 0 {
+                       base.Errorf("negative %s argument in make(%v)", arg, t)
+                       return false
+               }
+               if ir.ConstOverflow(v, types.Types[types.TINT]) {
+                       base.Errorf("%s argument too large in make(%v)", arg, t)
+                       return false
+               }
+       }
+
+       // DefaultLit is necessary for non-constants too: n might be 1.1<<k.
+       // TODO(gri) The length argument requirements for (array/slice) make
+       // are the same as for index expressions. Factor the code better;
+       // for instance, indexlit might be called here and incorporate some
+       // of the bounds checks done for make.
+       n = DefaultLit(n, types.Types[types.TINT])
+       *np = n
+
+       return true
+}
+
+// markBreak marks control statements containing break statements with SetHasBreak(true).
+func markBreak(fn *ir.Func) {
+       var labels map[*types.Sym]ir.Node
+       var implicit ir.Node
+
+       var mark func(ir.Node) bool
+       mark = func(n ir.Node) bool {
+               switch n.Op() {
+               default:
+                       ir.DoChildren(n, mark)
+
+               case ir.OBREAK:
+                       n := n.(*ir.BranchStmt)
+                       if n.Label == nil {
+                               setHasBreak(implicit)
+                       } else {
+                               setHasBreak(labels[n.Label])
+                       }
+
+               case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT, ir.ORANGE:
+                       old := implicit
+                       implicit = n
+                       var sym *types.Sym
+                       switch n := n.(type) {
+                       case *ir.ForStmt:
+                               sym = n.Label
+                       case *ir.RangeStmt:
+                               sym = n.Label
+                       case *ir.SelectStmt:
+                               sym = n.Label
+                       case *ir.SwitchStmt:
+                               sym = n.Label
+                       }
+                       if sym != nil {
+                               if labels == nil {
+                                       // Map creation delayed until we need it - most functions don't.
+                                       labels = make(map[*types.Sym]ir.Node)
+                               }
+                               labels[sym] = n
+                       }
+                       ir.DoChildren(n, mark)
+                       if sym != nil {
+                               delete(labels, sym)
+                       }
+                       implicit = old
+               }
+               return false
+       }
+
+       mark(fn)
+}
+
+func controlLabel(n ir.Node) *types.Sym {
+       switch n := n.(type) {
+       default:
+               base.Fatalf("controlLabel %+v", n.Op())
+               return nil
+       case *ir.ForStmt:
+               return n.Label
+       case *ir.RangeStmt:
+               return n.Label
+       case *ir.SelectStmt:
+               return n.Label
+       case *ir.SwitchStmt:
+               return n.Label
+       }
+}
+
+func setHasBreak(n ir.Node) {
+       switch n := n.(type) {
+       default:
+               base.Fatalf("setHasBreak %+v", n.Op())
+       case nil:
+               // ignore
+       case *ir.ForStmt:
+               n.HasBreak = true
+       case *ir.RangeStmt:
+               n.HasBreak = true
+       case *ir.SelectStmt:
+               n.HasBreak = true
+       case *ir.SwitchStmt:
+               n.HasBreak = true
+       }
+}
+
+// isTermNodes reports whether the Nodes list ends with a terminating statement.
+func isTermNodes(l ir.Nodes) bool {
+       s := l
+       c := len(s)
+       if c == 0 {
+               return false
+       }
+       return isTermNode(s[c-1])
+}
+
+// isTermNode reports whether the node n, the last one in a
+// statement list, is a terminating statement.
+func isTermNode(n ir.Node) bool {
+       switch n.Op() {
+       // NOTE: OLABEL is treated as a separate statement,
+       // not a separate prefix, so skipping to the last statement
+       // in the block handles the labeled statement case by
+       // skipping over the label. No case OLABEL here.
+
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
+               return isTermNodes(n.List)
+
+       case ir.OGOTO, ir.ORETURN, ir.OTAILCALL, ir.OPANIC, ir.OFALL:
+               return true
+
+       case ir.OFOR, ir.OFORUNTIL:
+               n := n.(*ir.ForStmt)
+               if n.Cond != nil {
+                       return false
+               }
+               if n.HasBreak {
+                       return false
+               }
+               return true
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               return isTermNodes(n.Body) && isTermNodes(n.Else)
+
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+               if n.HasBreak {
+                       return false
+               }
+               def := false
+               for _, cas := range n.Cases {
+                       if !isTermNodes(cas.Body) {
+                               return false
+                       }
+                       if len(cas.List) == 0 { // default
+                               def = true
+                       }
+               }
+               return def
+
+       case ir.OSELECT:
+               n := n.(*ir.SelectStmt)
+               if n.HasBreak {
+                       return false
+               }
+               for _, cas := range n.Cases {
+                       if !isTermNodes(cas.Body) {
+                               return false
+                       }
+               }
+               return true
+       }
+
+       return false
+}
+
+// CheckUnused checks for any declared variables that weren't used.
+func CheckUnused(fn *ir.Func) {
+       // Only report unused variables if we haven't seen any type-checking
+       // errors yet.
+       if base.Errors() != 0 {
+               return
+       }
+
+       // Propagate the used flag for typeswitch variables up to the NONAME in its definition.
+       for _, ln := range fn.Dcl {
+               if ln.Op() == ir.ONAME && ln.Class == ir.PAUTO && ln.Used() {
+                       if guard, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
+                               guard.Used = true
+                       }
+               }
+       }
+
+       for _, ln := range fn.Dcl {
+               if ln.Op() != ir.ONAME || ln.Class != ir.PAUTO || ln.Used() {
+                       continue
+               }
+               if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
+                       if defn.Used {
+                               continue
+                       }
+                       base.ErrorfAt(defn.Tag.Pos(), "%v declared but not used", ln.Sym())
+                       defn.Used = true // suppress repeats
+               } else {
+                       base.ErrorfAt(ln.Pos(), "%v declared but not used", ln.Sym())
+               }
+       }
+}
+
+// CheckReturn makes sure that fn terminates appropriately.
+func CheckReturn(fn *ir.Func) {
+       if fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
+               markBreak(fn)
+               if !isTermNodes(fn.Body) {
+                       base.ErrorfAt(fn.Endlineno, "missing return at end of function")
+               }
+       }
+}
+
+// getIotaValue returns the current value for "iota",
+// or -1 if not within a ConstSpec.
+func getIotaValue() int64 {
+       if i := len(typecheckdefstack); i > 0 {
+               if x := typecheckdefstack[i-1]; x.Op() == ir.OLITERAL {
+                       return x.Iota()
+               }
+       }
+
+       if ir.CurFunc != nil && ir.CurFunc.Iota >= 0 {
+               return ir.CurFunc.Iota
+       }
+
+       return -1
+}
+
+// curpkg returns the current package, based on Curfn.
+func curpkg() *types.Pkg {
+       fn := ir.CurFunc
+       if fn == nil {
+               // Initialization expressions for package-scope variables.
+               return types.LocalPkg
+       }
+       return fnpkg(fn.Nname)
+}
+
+func Conv(n ir.Node, t *types.Type) ir.Node {
+       if types.Identical(n.Type(), t) {
+               return n
+       }
+       n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+       n.SetType(t)
+       n = Expr(n)
+       return n
+}
+
+// ConvNop converts node n to type t using the OCONVNOP op
+// and typechecks the result with ctxExpr.
+func ConvNop(n ir.Node, t *types.Type) ir.Node {
+       if types.Identical(n.Type(), t) {
+               return n
+       }
+       n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
+       n.SetType(t)
+       n = Expr(n)
+       return n
+}

diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
new file mode 100644 (file)
index 0000000..402b8de
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -0,0 +1,362 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typecheck
+
+import (
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+var (
+       okfor [ir.OEND][]bool
+       iscmp [ir.OEND]bool
+)
+
+var (
+       okforeq    [types.NTYPE]bool
+       okforadd   [types.NTYPE]bool
+       okforand   [types.NTYPE]bool
+       okfornone  [types.NTYPE]bool
+       okforbool  [types.NTYPE]bool
+       okforcap   [types.NTYPE]bool
+       okforlen   [types.NTYPE]bool
+       okforarith [types.NTYPE]bool
+)
+
+var basicTypes = [...]struct {
+       name  string
+       etype types.Kind
+}{
+       {"int8", types.TINT8},
+       {"int16", types.TINT16},
+       {"int32", types.TINT32},
+       {"int64", types.TINT64},
+       {"uint8", types.TUINT8},
+       {"uint16", types.TUINT16},
+       {"uint32", types.TUINT32},
+       {"uint64", types.TUINT64},
+       {"float32", types.TFLOAT32},
+       {"float64", types.TFLOAT64},
+       {"complex64", types.TCOMPLEX64},
+       {"complex128", types.TCOMPLEX128},
+       {"bool", types.TBOOL},
+       {"string", types.TSTRING},
+}
+
+var typedefs = [...]struct {
+       name     string
+       etype    types.Kind
+       sameas32 types.Kind
+       sameas64 types.Kind
+}{
+       {"int", types.TINT, types.TINT32, types.TINT64},
+       {"uint", types.TUINT, types.TUINT32, types.TUINT64},
+       {"uintptr", types.TUINTPTR, types.TUINT32, types.TUINT64},
+}
+
+var builtinFuncs = [...]struct {
+       name string
+       op   ir.Op
+}{
+       {"append", ir.OAPPEND},
+       {"cap", ir.OCAP},
+       {"close", ir.OCLOSE},
+       {"complex", ir.OCOMPLEX},
+       {"copy", ir.OCOPY},
+       {"delete", ir.ODELETE},
+       {"imag", ir.OIMAG},
+       {"len", ir.OLEN},
+       {"make", ir.OMAKE},
+       {"new", ir.ONEW},
+       {"panic", ir.OPANIC},
+       {"print", ir.OPRINT},
+       {"println", ir.OPRINTN},
+       {"real", ir.OREAL},
+       {"recover", ir.ORECOVER},
+}
+
+var unsafeFuncs = [...]struct {
+       name string
+       op   ir.Op
+}{
+       {"Alignof", ir.OALIGNOF},
+       {"Offsetof", ir.OOFFSETOF},
+       {"Sizeof", ir.OSIZEOF},
+}
+
+// InitUniverse initializes the universe block.
+func InitUniverse() {
+       if types.PtrSize == 0 {
+               base.Fatalf("typeinit before betypeinit")
+       }
+
+       types.SlicePtrOffset = 0
+       types.SliceLenOffset = types.Rnd(types.SlicePtrOffset+int64(types.PtrSize), int64(types.PtrSize))
+       types.SliceCapOffset = types.Rnd(types.SliceLenOffset+int64(types.PtrSize), int64(types.PtrSize))
+       types.SliceSize = types.Rnd(types.SliceCapOffset+int64(types.PtrSize), int64(types.PtrSize))
+
+       // string is same as slice wo the cap
+       types.StringSize = types.Rnd(types.SliceLenOffset+int64(types.PtrSize), int64(types.PtrSize))
+
+       for et := types.Kind(0); et < types.NTYPE; et++ {
+               types.SimType[et] = et
+       }
+
+       types.Types[types.TANY] = types.New(types.TANY)
+       types.Types[types.TINTER] = types.NewInterface(types.LocalPkg, nil)
+
+       defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
+               sym := pkg.Lookup(name)
+               n := ir.NewDeclNameAt(src.NoXPos, ir.OTYPE, sym)
+               t := types.NewBasic(kind, n)
+               n.SetType(t)
+               sym.Def = n
+               if kind != types.TANY {
+                       types.CalcSize(t)
+               }
+               return t
+       }
+
+       for _, s := range &basicTypes {
+               types.Types[s.etype] = defBasic(s.etype, types.BuiltinPkg, s.name)
+       }
+
+       for _, s := range &typedefs {
+               sameas := s.sameas32
+               if types.PtrSize == 8 {
+                       sameas = s.sameas64
+               }
+               types.SimType[s.etype] = sameas
+
+               types.Types[s.etype] = defBasic(s.etype, types.BuiltinPkg, s.name)
+       }
+
+       // We create separate byte and rune types for better error messages
+       // rather than just creating type alias *types.Sym's for the uint8 and
+       // int32 types. Hence, (bytetype|runtype).Sym.isAlias() is false.
+       // TODO(gri) Should we get rid of this special case (at the cost
+       // of less informative error messages involving bytes and runes)?
+       // (Alternatively, we could introduce an OTALIAS node representing
+       // type aliases, albeit at the cost of having to deal with it everywhere).
+       types.ByteType = defBasic(types.TUINT8, types.BuiltinPkg, "byte")
+       types.RuneType = defBasic(types.TINT32, types.BuiltinPkg, "rune")
+
+       // error type
+       s := types.BuiltinPkg.Lookup("error")
+       n := ir.NewDeclNameAt(src.NoXPos, ir.OTYPE, s)
+       types.ErrorType = types.NewNamed(n)
+       types.ErrorType.SetUnderlying(makeErrorInterface())
+       n.SetType(types.ErrorType)
+       s.Def = n
+       types.CalcSize(types.ErrorType)
+
+       types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, ir.Pkgs.Unsafe, "Pointer")
+
+       // simple aliases
+       types.SimType[types.TMAP] = types.TPTR
+       types.SimType[types.TCHAN] = types.TPTR
+       types.SimType[types.TFUNC] = types.TPTR
+       types.SimType[types.TUNSAFEPTR] = types.TPTR
+
+       for _, s := range &builtinFuncs {
+               s2 := types.BuiltinPkg.Lookup(s.name)
+               def := NewName(s2)
+               def.BuiltinOp = s.op
+               s2.Def = def
+       }
+
+       for _, s := range &unsafeFuncs {
+               s2 := ir.Pkgs.Unsafe.Lookup(s.name)
+               def := NewName(s2)
+               def.BuiltinOp = s.op
+               s2.Def = def
+       }
+
+       s = types.BuiltinPkg.Lookup("true")
+       s.Def = ir.NewConstAt(src.NoXPos, s, types.UntypedBool, constant.MakeBool(true))
+
+       s = types.BuiltinPkg.Lookup("false")
+       s.Def = ir.NewConstAt(src.NoXPos, s, types.UntypedBool, constant.MakeBool(false))
+
+       s = Lookup("_")
+       types.BlankSym = s
+       s.Block = -100
+       s.Def = NewName(s)
+       types.Types[types.TBLANK] = types.New(types.TBLANK)
+       ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
+       ir.BlankNode = ir.AsNode(s.Def)
+       ir.BlankNode.SetTypecheck(1)
+
+       s = types.BuiltinPkg.Lookup("_")
+       s.Block = -100
+       s.Def = NewName(s)
+       types.Types[types.TBLANK] = types.New(types.TBLANK)
+       ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
+
+       types.Types[types.TNIL] = types.New(types.TNIL)
+       s = types.BuiltinPkg.Lookup("nil")
+       nnil := NodNil()
+       nnil.(*ir.NilExpr).SetSym(s)
+       s.Def = nnil
+
+       s = types.BuiltinPkg.Lookup("iota")
+       s.Def = ir.NewIota(base.Pos, s)
+
+       for et := types.TINT8; et <= types.TUINT64; et++ {
+               types.IsInt[et] = true
+       }
+       types.IsInt[types.TINT] = true
+       types.IsInt[types.TUINT] = true
+       types.IsInt[types.TUINTPTR] = true
+
+       types.IsFloat[types.TFLOAT32] = true
+       types.IsFloat[types.TFLOAT64] = true
+
+       types.IsComplex[types.TCOMPLEX64] = true
+       types.IsComplex[types.TCOMPLEX128] = true
+
+       // initialize okfor
+       for et := types.Kind(0); et < types.NTYPE; et++ {
+               if types.IsInt[et] || et == types.TIDEAL {
+                       okforeq[et] = true
+                       types.IsOrdered[et] = true
+                       okforarith[et] = true
+                       okforadd[et] = true
+                       okforand[et] = true
+                       ir.OKForConst[et] = true
+                       types.IsSimple[et] = true
+               }
+
+               if types.IsFloat[et] {
+                       okforeq[et] = true
+                       types.IsOrdered[et] = true
+                       okforadd[et] = true
+                       okforarith[et] = true
+                       ir.OKForConst[et] = true
+                       types.IsSimple[et] = true
+               }
+
+               if types.IsComplex[et] {
+                       okforeq[et] = true
+                       okforadd[et] = true
+                       okforarith[et] = true
+                       ir.OKForConst[et] = true
+                       types.IsSimple[et] = true
+               }
+       }
+
+       types.IsSimple[types.TBOOL] = true
+
+       okforadd[types.TSTRING] = true
+
+       okforbool[types.TBOOL] = true
+
+       okforcap[types.TARRAY] = true
+       okforcap[types.TCHAN] = true
+       okforcap[types.TSLICE] = true
+
+       ir.OKForConst[types.TBOOL] = true
+       ir.OKForConst[types.TSTRING] = true
+
+       okforlen[types.TARRAY] = true
+       okforlen[types.TCHAN] = true
+       okforlen[types.TMAP] = true
+       okforlen[types.TSLICE] = true
+       okforlen[types.TSTRING] = true
+
+       okforeq[types.TPTR] = true
+       okforeq[types.TUNSAFEPTR] = true
+       okforeq[types.TINTER] = true
+       okforeq[types.TCHAN] = true
+       okforeq[types.TSTRING] = true
+       okforeq[types.TBOOL] = true
+       okforeq[types.TMAP] = true    // nil only; refined in typecheck
+       okforeq[types.TFUNC] = true   // nil only; refined in typecheck
+       okforeq[types.TSLICE] = true  // nil only; refined in typecheck
+       okforeq[types.TARRAY] = true  // only if element type is comparable; refined in typecheck
+       okforeq[types.TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
+
+       types.IsOrdered[types.TSTRING] = true
+
+       for i := range okfor {
+               okfor[i] = okfornone[:]
+       }
+
+       // binary
+       okfor[ir.OADD] = okforadd[:]
+       okfor[ir.OAND] = okforand[:]
+       okfor[ir.OANDAND] = okforbool[:]
+       okfor[ir.OANDNOT] = okforand[:]
+       okfor[ir.ODIV] = okforarith[:]
+       okfor[ir.OEQ] = okforeq[:]
+       okfor[ir.OGE] = types.IsOrdered[:]
+       okfor[ir.OGT] = types.IsOrdered[:]
+       okfor[ir.OLE] = types.IsOrdered[:]
+       okfor[ir.OLT] = types.IsOrdered[:]
+       okfor[ir.OMOD] = okforand[:]
+       okfor[ir.OMUL] = okforarith[:]
+       okfor[ir.ONE] = okforeq[:]
+       okfor[ir.OOR] = okforand[:]
+       okfor[ir.OOROR] = okforbool[:]
+       okfor[ir.OSUB] = okforarith[:]
+       okfor[ir.OXOR] = okforand[:]
+       okfor[ir.OLSH] = okforand[:]
+       okfor[ir.ORSH] = okforand[:]
+
+       // unary
+       okfor[ir.OBITNOT] = okforand[:]
+       okfor[ir.ONEG] = okforarith[:]
+       okfor[ir.ONOT] = okforbool[:]
+       okfor[ir.OPLUS] = okforarith[:]
+
+       // special
+       okfor[ir.OCAP] = okforcap[:]
+       okfor[ir.OLEN] = okforlen[:]
+
+       // comparison
+       iscmp[ir.OLT] = true
+       iscmp[ir.OGT] = true
+       iscmp[ir.OGE] = true
+       iscmp[ir.OLE] = true
+       iscmp[ir.OEQ] = true
+       iscmp[ir.ONE] = true
+}
+
+func makeErrorInterface() *types.Type {
+       sig := types.NewSignature(types.NoPkg, fakeRecvField(), nil, []*types.Field{
+               types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
+       })
+       method := types.NewField(src.NoXPos, Lookup("Error"), sig)
+       return types.NewInterface(types.NoPkg, []*types.Field{method})
+}
+
+// DeclareUniverse makes the universe block visible within the current package.
+func DeclareUniverse() {
+       // Operationally, this is similar to a dot import of builtinpkg, except
+       // that we silently skip symbols that are already declared in the
+       // package block rather than emitting a redeclared symbol error.
+
+       for _, s := range types.BuiltinPkg.Syms {
+               if s.Def == nil {
+                       continue
+               }
+               s1 := Lookup(s.Name)
+               if s1.Def != nil {
+                       continue
+               }
+
+               s1.Def = s.Def
+               s1.Block = s.Block
+       }
+
+       ir.RegFP = NewName(Lookup(".fp"))
+       ir.RegFP.SetType(types.Types[types.TINT32])
+       ir.RegFP.Class = ir.PPARAM
+       ir.RegFP.SetUsed(true)
+}

diff --git a/src/cmd/compile/internal/types/alg.go b/src/cmd/compile/internal/types/alg.go
new file mode 100644 (file)
index 0000000..2c2700f
--- /dev/null
+++ b/src/cmd/compile/internal/types/alg.go
@@ -0,0 +1,173 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import "cmd/compile/internal/base"
+
+// AlgKind describes the kind of algorithms used for comparing and
+// hashing a Type.
+type AlgKind int
+
+//go:generate stringer -type AlgKind -trimprefix A alg.go
+
+const (
+       // These values are known by runtime.
+       ANOEQ AlgKind = iota
+       AMEM0
+       AMEM8
+       AMEM16
+       AMEM32
+       AMEM64
+       AMEM128
+       ASTRING
+       AINTER
+       ANILINTER
+       AFLOAT32
+       AFLOAT64
+       ACPLX64
+       ACPLX128
+
+       // Type can be compared/hashed as regular memory.
+       AMEM AlgKind = 100
+
+       // Type needs special comparison/hashing functions.
+       ASPECIAL AlgKind = -1
+)
+
+// AlgType returns the AlgKind used for comparing and hashing Type t.
+// If it returns ANOEQ, it also returns the component type of t that
+// makes it incomparable.
+func AlgType(t *Type) (AlgKind, *Type) {
+       if t.Broke() {
+               return AMEM, nil
+       }
+       if t.Noalg() {
+               return ANOEQ, t
+       }
+
+       switch t.Kind() {
+       case TANY, TFORW:
+               // will be defined later.
+               return ANOEQ, t
+
+       case TINT8, TUINT8, TINT16, TUINT16,
+               TINT32, TUINT32, TINT64, TUINT64,
+               TINT, TUINT, TUINTPTR,
+               TBOOL, TPTR,
+               TCHAN, TUNSAFEPTR:
+               return AMEM, nil
+
+       case TFUNC, TMAP:
+               return ANOEQ, t
+
+       case TFLOAT32:
+               return AFLOAT32, nil
+
+       case TFLOAT64:
+               return AFLOAT64, nil
+
+       case TCOMPLEX64:
+               return ACPLX64, nil
+
+       case TCOMPLEX128:
+               return ACPLX128, nil
+
+       case TSTRING:
+               return ASTRING, nil
+
+       case TINTER:
+               if t.IsEmptyInterface() {
+                       return ANILINTER, nil
+               }
+               return AINTER, nil
+
+       case TSLICE:
+               return ANOEQ, t
+
+       case TARRAY:
+               a, bad := AlgType(t.Elem())
+               switch a {
+               case AMEM:
+                       return AMEM, nil
+               case ANOEQ:
+                       return ANOEQ, bad
+               }
+
+               switch t.NumElem() {
+               case 0:
+                       // We checked above that the element type is comparable.
+                       return AMEM, nil
+               case 1:
+                       // Single-element array is same as its lone element.
+                       return a, nil
+               }
+
+               return ASPECIAL, nil
+
+       case TSTRUCT:
+               fields := t.FieldSlice()
+
+               // One-field struct is same as that one field alone.
+               if len(fields) == 1 && !fields[0].Sym.IsBlank() {
+                       return AlgType(fields[0].Type)
+               }
+
+               ret := AMEM
+               for i, f := range fields {
+                       // All fields must be comparable.
+                       a, bad := AlgType(f.Type)
+                       if a == ANOEQ {
+                               return ANOEQ, bad
+                       }
+
+                       // Blank fields, padded fields, fields with non-memory
+                       // equality need special compare.
+                       if a != AMEM || f.Sym.IsBlank() || IsPaddedField(t, i) {
+                               ret = ASPECIAL
+                       }
+               }
+
+               return ret, nil
+       }
+
+       base.Fatalf("AlgType: unexpected type %v", t)
+       return 0, nil
+}
+
+// TypeHasNoAlg reports whether t does not have any associated hash/eq
+// algorithms because t, or some component of t, is marked Noalg.
+func TypeHasNoAlg(t *Type) bool {
+       a, bad := AlgType(t)
+       return a == ANOEQ && bad.Noalg()
+}
+
+// IsComparable reports whether t is a comparable type.
+func IsComparable(t *Type) bool {
+       a, _ := AlgType(t)
+       return a != ANOEQ
+}
+
+// IncomparableField returns an incomparable Field of struct Type t, if any.
+func IncomparableField(t *Type) *Field {
+       for _, f := range t.FieldSlice() {
+               if !IsComparable(f.Type) {
+                       return f
+               }
+       }
+       return nil
+}
+
+// IsPaddedField reports whether the i'th field of struct type t is followed
+// by padding.
+func IsPaddedField(t *Type, i int) bool {
+       if !t.IsStruct() {
+               base.Fatalf("IsPaddedField called non-struct %v", t)
+       }
+       end := t.Width
+       if i+1 < t.NumFields() {
+               end = t.Field(i + 1).Offset
+       }
+       return t.Field(i).End() != end
+}

diff --git a/src/cmd/compile/internal/gc/algkind_string.go b/src/cmd/compile/internal/types/algkind_string.go
similarity index 91%
rename from src/cmd/compile/internal/gc/algkind_string.go
rename to src/cmd/compile/internal/types/algkind_string.go
index 52b53999561704cfa86869efdf922ef4876ed803..a1b518e4dde260d08c5fa36aeeb72c599ed5e7e5 100644 (file)
--- a/src/cmd/compile/internal/gc/algkind_string.go
+++ b/src/cmd/compile/internal/types/algkind_string.go
@@ -1,6 +1,6 @@
-// Code generated by "stringer -type AlgKind -trimprefix A"; DO NOT EDIT.
+// Code generated by "stringer -type AlgKind -trimprefix A alg.go"; DO NOT EDIT.
 
-package gc
+package types
 
 import "strconv"
 

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
new file mode 100644 (file)
index 0000000..da224d4
--- /dev/null
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -0,0 +1,666 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import (
+       "bytes"
+       "crypto/md5"
+       "encoding/binary"
+       "fmt"
+       "go/constant"
+       "strconv"
+       "strings"
+       "sync"
+
+       "cmd/compile/internal/base"
+)
+
+// BuiltinPkg is a fake package that declares the universe block.
+var BuiltinPkg *Pkg
+
+// LocalPkg is the package being compiled.
+var LocalPkg *Pkg
+
+// BlankSym is the blank (_) symbol.
+var BlankSym *Sym
+
+// OrigSym returns the original symbol written by the user.
+func OrigSym(s *Sym) *Sym {
+       if s == nil {
+               return nil
+       }
+
+       if len(s.Name) > 1 && s.Name[0] == '~' {
+               switch s.Name[1] {
+               case 'r': // originally an unnamed result
+                       return nil
+               case 'b': // originally the blank identifier _
+                       // TODO(mdempsky): Does s.Pkg matter here?
+                       return BlankSym
+               }
+               return s
+       }
+
+       if strings.HasPrefix(s.Name, ".anon") {
+               // originally an unnamed or _ name (see subr.go: NewFuncParams)
+               return nil
+       }
+
+       return s
+}
+
+// numImport tracks how often a package with a given name is imported.
+// It is used to provide a better error message (by using the package
+// path to disambiguate) if a package that appears multiple times with
+// the same name appears in an error message.
+var NumImport = make(map[string]int)
+
+// fmtMode represents the kind of printing being done.
+// The default is regular Go syntax (fmtGo).
+// fmtDebug is like fmtGo but for debugging dumps and prints the type kind too.
+// fmtTypeID and fmtTypeIDName are for generating various unique representations
+// of types used in hashes and the linker.
+type fmtMode int
+
+const (
+       fmtGo fmtMode = iota
+       fmtDebug
+       fmtTypeID
+       fmtTypeIDName
+)
+
+// Sym
+
+// Format implements formatting for a Sym.
+// The valid formats are:
+//
+//     %v      Go syntax: Name for symbols in the local package, PkgName.Name for imported symbols.
+//     %+v     Debug syntax: always include PkgName. prefix even for local names.
+//     %S      Short syntax: Name only, no matter what.
+//
+func (s *Sym) Format(f fmt.State, verb rune) {
+       mode := fmtGo
+       switch verb {
+       case 'v', 'S':
+               if verb == 'v' && f.Flag('+') {
+                       mode = fmtDebug
+               }
+               fmt.Fprint(f, sconv(s, verb, mode))
+
+       default:
+               fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
+       }
+}
+
+func (s *Sym) String() string {
+       return sconv(s, 0, fmtGo)
+}
+
+// See #16897 for details about performance implications
+// before changing the implementation of sconv.
+func sconv(s *Sym, verb rune, mode fmtMode) string {
+       if verb == 'L' {
+               panic("linksymfmt")
+       }
+
+       if s == nil {
+               return "<S>"
+       }
+
+       if s.Name == "_" {
+               return "_"
+       }
+       buf := fmtBufferPool.Get().(*bytes.Buffer)
+       buf.Reset()
+       defer fmtBufferPool.Put(buf)
+
+       symfmt(buf, s, verb, mode)
+       return InternString(buf.Bytes())
+}
+
+func sconv2(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+       if verb == 'L' {
+               panic("linksymfmt")
+       }
+       if s == nil {
+               b.WriteString("<S>")
+               return
+       }
+       if s.Name == "_" {
+               b.WriteString("_")
+               return
+       }
+
+       symfmt(b, s, verb, mode)
+}
+
+func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+       if verb != 'S' {
+               switch mode {
+               case fmtGo: // This is for the user
+                       if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
+                               b.WriteString(s.Name)
+                               return
+                       }
+
+                       // If the name was used by multiple packages, display the full path,
+                       if s.Pkg.Name != "" && NumImport[s.Pkg.Name] > 1 {
+                               fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
+                               return
+                       }
+                       b.WriteString(s.Pkg.Name)
+                       b.WriteByte('.')
+                       b.WriteString(s.Name)
+                       return
+
+               case fmtDebug:
+                       b.WriteString(s.Pkg.Name)
+                       b.WriteByte('.')
+                       b.WriteString(s.Name)
+                       return
+
+               case fmtTypeIDName:
+                       // dcommontype, typehash
+                       b.WriteString(s.Pkg.Name)
+                       b.WriteByte('.')
+                       b.WriteString(s.Name)
+                       return
+
+               case fmtTypeID:
+                       // (methodsym), typesym, weaksym
+                       b.WriteString(s.Pkg.Prefix)
+                       b.WriteByte('.')
+                       b.WriteString(s.Name)
+                       return
+               }
+       }
+
+       b.WriteString(s.Name)
+}
+
+// Type
+
+var BasicTypeNames = []string{
+       TINT:        "int",
+       TUINT:       "uint",
+       TINT8:       "int8",
+       TUINT8:      "uint8",
+       TINT16:      "int16",
+       TUINT16:     "uint16",
+       TINT32:      "int32",
+       TUINT32:     "uint32",
+       TINT64:      "int64",
+       TUINT64:     "uint64",
+       TUINTPTR:    "uintptr",
+       TFLOAT32:    "float32",
+       TFLOAT64:    "float64",
+       TCOMPLEX64:  "complex64",
+       TCOMPLEX128: "complex128",
+       TBOOL:       "bool",
+       TANY:        "any",
+       TSTRING:     "string",
+       TNIL:        "nil",
+       TIDEAL:      "untyped number",
+       TBLANK:      "blank",
+}
+
+var fmtBufferPool = sync.Pool{
+       New: func() interface{} {
+               return new(bytes.Buffer)
+       },
+}
+
+// Format implements formatting for a Type.
+// The valid formats are:
+//
+//     %v      Go syntax
+//     %+v     Debug syntax: Go syntax with a KIND- prefix for all but builtins.
+//     %L      Go syntax for underlying type if t is named
+//     %S      short Go syntax: drop leading "func" in function type
+//     %-S     special case for method receiver symbol
+//
+func (t *Type) Format(s fmt.State, verb rune) {
+       mode := fmtGo
+       switch verb {
+       case 'v', 'S', 'L':
+               if verb == 'v' && s.Flag('+') { // %+v is debug format
+                       mode = fmtDebug
+               }
+               if verb == 'S' && s.Flag('-') { // %-S is special case for receiver - short typeid format
+                       mode = fmtTypeID
+               }
+               fmt.Fprint(s, tconv(t, verb, mode))
+       default:
+               fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
+       }
+}
+
+// String returns the Go syntax for the type t.
+func (t *Type) String() string {
+       return tconv(t, 0, fmtGo)
+}
+
+// ShortString generates a short description of t.
+// It is used in autogenerated method names, reflection,
+// and itab names.
+func (t *Type) ShortString() string {
+       return tconv(t, 0, fmtTypeID)
+}
+
+// LongString generates a complete description of t.
+// It is useful for reflection,
+// or when a unique fingerprint or hash of a type is required.
+func (t *Type) LongString() string {
+       return tconv(t, 0, fmtTypeIDName)
+}
+
+func tconv(t *Type, verb rune, mode fmtMode) string {
+       buf := fmtBufferPool.Get().(*bytes.Buffer)
+       buf.Reset()
+       defer fmtBufferPool.Put(buf)
+
+       tconv2(buf, t, verb, mode, nil)
+       return InternString(buf.Bytes())
+}
+
+// tconv2 writes a string representation of t to b.
+// flag and mode control exactly what is printed.
+// Any types x that are already in the visited map get printed as @%d where %d=visited[x].
+// See #16897 before changing the implementation of tconv.
+func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type]int) {
+       if off, ok := visited[t]; ok {
+               // We've seen this type before, so we're trying to print it recursively.
+               // Print a reference to it instead.
+               fmt.Fprintf(b, "@%d", off)
+               return
+       }
+       if t == nil {
+               b.WriteString("<T>")
+               return
+       }
+       if t.Kind() == TSSA {
+               b.WriteString(t.Extra.(string))
+               return
+       }
+       if t.Kind() == TTUPLE {
+               b.WriteString(t.FieldType(0).String())
+               b.WriteByte(',')
+               b.WriteString(t.FieldType(1).String())
+               return
+       }
+
+       if t.Kind() == TRESULTS {
+               tys := t.Extra.(*Results).Types
+               for i, et := range tys {
+                       if i > 0 {
+                               b.WriteByte(',')
+                       }
+                       b.WriteString(et.String())
+               }
+               return
+       }
+
+       if t == ByteType || t == RuneType {
+               // in %-T mode collapse rune and byte with their originals.
+               switch mode {
+               case fmtTypeIDName, fmtTypeID:
+                       t = Types[t.Kind()]
+               default:
+                       sconv2(b, t.Sym(), 'S', mode)
+                       return
+               }
+       }
+       if t == ErrorType {
+               b.WriteString("error")
+               return
+       }
+
+       // Unless the 'L' flag was specified, if the type has a name, just print that name.
+       if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] {
+               switch mode {
+               case fmtTypeID, fmtTypeIDName:
+                       if verb == 'S' {
+                               if t.Vargen != 0 {
+                                       sconv2(b, t.Sym(), 'S', mode)
+                                       fmt.Fprintf(b, "·%d", t.Vargen)
+                                       return
+                               }
+                               sconv2(b, t.Sym(), 'S', mode)
+                               return
+                       }
+
+                       if mode == fmtTypeIDName {
+                               sconv2(b, t.Sym(), 'v', fmtTypeIDName)
+                               return
+                       }
+
+                       if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
+                               sconv2(b, t.Sym(), 'v', mode)
+                               fmt.Fprintf(b, "·%d", t.Vargen)
+                               return
+                       }
+               }
+
+               sconv2(b, t.Sym(), 'v', mode)
+               return
+       }
+
+       if int(t.Kind()) < len(BasicTypeNames) && BasicTypeNames[t.Kind()] != "" {
+               var name string
+               switch t {
+               case UntypedBool:
+                       name = "untyped bool"
+               case UntypedString:
+                       name = "untyped string"
+               case UntypedInt:
+                       name = "untyped int"
+               case UntypedRune:
+                       name = "untyped rune"
+               case UntypedFloat:
+                       name = "untyped float"
+               case UntypedComplex:
+                       name = "untyped complex"
+               default:
+                       name = BasicTypeNames[t.Kind()]
+               }
+               b.WriteString(name)
+               return
+       }
+
+       if mode == fmtDebug {
+               b.WriteString(t.Kind().String())
+               b.WriteByte('-')
+               tconv2(b, t, 'v', fmtGo, visited)
+               return
+       }
+
+       // At this point, we might call tconv2 recursively. Add the current type to the visited list so we don't
+       // try to print it recursively.
+       // We record the offset in the result buffer where the type's text starts. This offset serves as a reference
+       // point for any later references to the same type.
+       // Note that we remove the type from the visited map as soon as the recursive call is done.
+       // This prevents encoding types like map[*int]*int as map[*int]@4. (That encoding would work,
+       // but I'd like to use the @ notation only when strictly necessary.)
+       if visited == nil {
+               visited = map[*Type]int{}
+       }
+       visited[t] = b.Len()
+       defer delete(visited, t)
+
+       switch t.Kind() {
+       case TPTR:
+               b.WriteByte('*')
+               switch mode {
+               case fmtTypeID, fmtTypeIDName:
+                       if verb == 'S' {
+                               tconv2(b, t.Elem(), 'S', mode, visited)
+                               return
+                       }
+               }
+               tconv2(b, t.Elem(), 'v', mode, visited)
+
+       case TARRAY:
+               b.WriteByte('[')
+               b.WriteString(strconv.FormatInt(t.NumElem(), 10))
+               b.WriteByte(']')
+               tconv2(b, t.Elem(), 0, mode, visited)
+
+       case TSLICE:
+               b.WriteString("[]")
+               tconv2(b, t.Elem(), 0, mode, visited)
+
+       case TCHAN:
+               switch t.ChanDir() {
+               case Crecv:
+                       b.WriteString("<-chan ")
+                       tconv2(b, t.Elem(), 0, mode, visited)
+               case Csend:
+                       b.WriteString("chan<- ")
+                       tconv2(b, t.Elem(), 0, mode, visited)
+               default:
+                       b.WriteString("chan ")
+                       if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym() == nil && t.Elem().ChanDir() == Crecv {
+                               b.WriteByte('(')
+                               tconv2(b, t.Elem(), 0, mode, visited)
+                               b.WriteByte(')')
+                       } else {
+                               tconv2(b, t.Elem(), 0, mode, visited)
+                       }
+               }
+
+       case TMAP:
+               b.WriteString("map[")
+               tconv2(b, t.Key(), 0, mode, visited)
+               b.WriteByte(']')
+               tconv2(b, t.Elem(), 0, mode, visited)
+
+       case TINTER:
+               if t.IsEmptyInterface() {
+                       b.WriteString("interface {}")
+                       break
+               }
+               b.WriteString("interface {")
+               for i, f := range t.Fields().Slice() {
+                       if i != 0 {
+                               b.WriteByte(';')
+                       }
+                       b.WriteByte(' ')
+                       switch {
+                       case f.Sym == nil:
+                               // Check first that a symbol is defined for this type.
+                               // Wrong interface definitions may have types lacking a symbol.
+                               break
+                       case IsExported(f.Sym.Name):
+                               sconv2(b, f.Sym, 'S', mode)
+                       default:
+                               if mode != fmtTypeIDName {
+                                       mode = fmtTypeID
+                               }
+                               sconv2(b, f.Sym, 'v', mode)
+                       }
+                       tconv2(b, f.Type, 'S', mode, visited)
+               }
+               if t.NumFields() != 0 {
+                       b.WriteByte(' ')
+               }
+               b.WriteByte('}')
+
+       case TFUNC:
+               if verb == 'S' {
+                       // no leading func
+               } else {
+                       if t.Recv() != nil {
+                               b.WriteString("method")
+                               tconv2(b, t.Recvs(), 0, mode, visited)
+                               b.WriteByte(' ')
+                       }
+                       b.WriteString("func")
+               }
+               tconv2(b, t.Params(), 0, mode, visited)
+
+               switch t.NumResults() {
+               case 0:
+                       // nothing to do
+
+               case 1:
+                       b.WriteByte(' ')
+                       tconv2(b, t.Results().Field(0).Type, 0, mode, visited) // struct->field->field's type
+
+               default:
+                       b.WriteByte(' ')
+                       tconv2(b, t.Results(), 0, mode, visited)
+               }
+
+       case TSTRUCT:
+               if m := t.StructType().Map; m != nil {
+                       mt := m.MapType()
+                       // Format the bucket struct for map[x]y as map.bucket[x]y.
+                       // This avoids a recursive print that generates very long names.
+                       switch t {
+                       case mt.Bucket:
+                               b.WriteString("map.bucket[")
+                       case mt.Hmap:
+                               b.WriteString("map.hdr[")
+                       case mt.Hiter:
+                               b.WriteString("map.iter[")
+                       default:
+                               base.Fatalf("unknown internal map type")
+                       }
+                       tconv2(b, m.Key(), 0, mode, visited)
+                       b.WriteByte(']')
+                       tconv2(b, m.Elem(), 0, mode, visited)
+                       break
+               }
+
+               if funarg := t.StructType().Funarg; funarg != FunargNone {
+                       b.WriteByte('(')
+                       fieldVerb := 'v'
+                       switch mode {
+                       case fmtTypeID, fmtTypeIDName, fmtGo:
+                               // no argument names on function signature, and no "noescape"/"nosplit" tags
+                               fieldVerb = 'S'
+                       }
+                       for i, f := range t.Fields().Slice() {
+                               if i != 0 {
+                                       b.WriteString(", ")
+                               }
+                               fldconv(b, f, fieldVerb, mode, visited, funarg)
+                       }
+                       b.WriteByte(')')
+               } else {
+                       b.WriteString("struct {")
+                       for i, f := range t.Fields().Slice() {
+                               if i != 0 {
+                                       b.WriteByte(';')
+                               }
+                               b.WriteByte(' ')
+                               fldconv(b, f, 'L', mode, visited, funarg)
+                       }
+                       if t.NumFields() != 0 {
+                               b.WriteByte(' ')
+                       }
+                       b.WriteByte('}')
+               }
+
+       case TFORW:
+               b.WriteString("undefined")
+               if t.Sym() != nil {
+                       b.WriteByte(' ')
+                       sconv2(b, t.Sym(), 'v', mode)
+               }
+
+       case TUNSAFEPTR:
+               b.WriteString("unsafe.Pointer")
+
+       case Txxx:
+               b.WriteString("Txxx")
+
+       default:
+               // Don't know how to handle - fall back to detailed prints
+               b.WriteString(t.Kind().String())
+               b.WriteString(" <")
+               sconv2(b, t.Sym(), 'v', mode)
+               b.WriteString(">")
+
+       }
+}
+
+func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Type]int, funarg Funarg) {
+       if f == nil {
+               b.WriteString("<T>")
+               return
+       }
+
+       var name string
+       if verb != 'S' {
+               s := f.Sym
+
+               // Take the name from the original.
+               if mode == fmtGo {
+                       s = OrigSym(s)
+               }
+
+               if s != nil && f.Embedded == 0 {
+                       if funarg != FunargNone {
+                               name = fmt.Sprint(f.Nname)
+                       } else if verb == 'L' {
+                               name = s.Name
+                               if name == ".F" {
+                                       name = "F" // Hack for toolstash -cmp.
+                               }
+                               if !IsExported(name) && mode != fmtTypeIDName {
+                                       name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
+                               }
+                       } else {
+                               name = sconv(s, 0, mode)
+                       }
+               }
+       }
+
+       if name != "" {
+               b.WriteString(name)
+               b.WriteString(" ")
+       }
+
+       if f.IsDDD() {
+               var et *Type
+               if f.Type != nil {
+                       et = f.Type.Elem()
+               }
+               b.WriteString("...")
+               tconv2(b, et, 0, mode, visited)
+       } else {
+               tconv2(b, f.Type, 0, mode, visited)
+       }
+
+       if verb != 'S' && funarg == FunargNone && f.Note != "" {
+               b.WriteString(" ")
+               b.WriteString(strconv.Quote(f.Note))
+       }
+}
+
+// Val
+
+func FmtConst(v constant.Value, sharp bool) string {
+       if !sharp && v.Kind() == constant.Complex {
+               real, imag := constant.Real(v), constant.Imag(v)
+
+               var re string
+               sre := constant.Sign(real)
+               if sre != 0 {
+                       re = real.String()
+               }
+
+               var im string
+               sim := constant.Sign(imag)
+               if sim != 0 {
+                       im = imag.String()
+               }
+
+               switch {
+               case sre == 0 && sim == 0:
+                       return "0"
+               case sre == 0:
+                       return im + "i"
+               case sim == 0:
+                       return re
+               case sim < 0:
+                       return fmt.Sprintf("(%s%si)", re, im)
+               default:
+                       return fmt.Sprintf("(%s+%si)", re, im)
+               }
+       }
+
+       return v.String()
+}
+
+// TypeHash computes a hash value for type t to use in type switch statements.
+func TypeHash(t *Type) uint32 {
+       p := t.LongString()
+
+       // Using MD5 is overkill, but reduces accidental collisions.
+       h := md5.Sum([]byte(p))
+       return binary.LittleEndian.Uint32(h[:4])
+}

diff --git a/src/cmd/compile/internal/types/goversion.go b/src/cmd/compile/internal/types/goversion.go
new file mode 100644 (file)
index 0000000..1a324aa
--- /dev/null
+++ b/src/cmd/compile/internal/types/goversion.go
@@ -0,0 +1,94 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import (
+       "fmt"
+       "internal/goversion"
+       "log"
+       "regexp"
+       "strconv"
+
+       "cmd/compile/internal/base"
+)
+
+// A lang is a language version broken into major and minor numbers.
+type lang struct {
+       major, minor int
+}
+
+// langWant is the desired language version set by the -lang flag.
+// If the -lang flag is not set, this is the zero value, meaning that
+// any language version is supported.
+var langWant lang
+
+// AllowsGoVersion reports whether a particular package
+// is allowed to use Go version major.minor.
+// We assume the imported packages have all been checked,
+// so we only have to check the local package against the -lang flag.
+func AllowsGoVersion(pkg *Pkg, major, minor int) bool {
+       if pkg == nil {
+               // TODO(mdempsky): Set Pkg for local types earlier.
+               pkg = LocalPkg
+       }
+       if pkg != LocalPkg {
+               // Assume imported packages passed type-checking.
+               return true
+       }
+       if langWant.major == 0 && langWant.minor == 0 {
+               return true
+       }
+       return langWant.major > major || (langWant.major == major && langWant.minor >= minor)
+}
+
+// ParseLangFlag verifies that the -lang flag holds a valid value, and
+// exits if not. It initializes data used by langSupported.
+func ParseLangFlag() {
+       if base.Flag.Lang == "" {
+               return
+       }
+
+       var err error
+       langWant, err = parseLang(base.Flag.Lang)
+       if err != nil {
+               log.Fatalf("invalid value %q for -lang: %v", base.Flag.Lang, err)
+       }
+
+       if def := currentLang(); base.Flag.Lang != def {
+               defVers, err := parseLang(def)
+               if err != nil {
+                       log.Fatalf("internal error parsing default lang %q: %v", def, err)
+               }
+               if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
+                       log.Fatalf("invalid value %q for -lang: max known version is %q", base.Flag.Lang, def)
+               }
+       }
+}
+
+// parseLang parses a -lang option into a langVer.
+func parseLang(s string) (lang, error) {
+       matches := goVersionRE.FindStringSubmatch(s)
+       if matches == nil {
+               return lang{}, fmt.Errorf(`should be something like "go1.12"`)
+       }
+       major, err := strconv.Atoi(matches[1])
+       if err != nil {
+               return lang{}, err
+       }
+       minor, err := strconv.Atoi(matches[2])
+       if err != nil {
+               return lang{}, err
+       }
+       return lang{major: major, minor: minor}, nil
+}
+
+// currentLang returns the current language version.
+func currentLang() string {
+       return fmt.Sprintf("go1.%d", goversion.Version)
+}
+
+// goVersionRE is a regular expression that matches the valid
+// arguments to the -lang flag.
+var goVersionRE = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)

diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go
index a77f514df96bef11730a806da97d251435135e44..9bc636d7ffe41b84c49e8f56833bf5ead52f5d87 100644 (file)
--- a/src/cmd/compile/internal/types/identity.go
+++ b/src/cmd/compile/internal/types/identity.go
@@ -25,17 +25,17 @@ func identical(t1, t2 *Type, cmpTags bool, assumedEqual map[typePair]struct{}) b
        if t1 == t2 {
                return true
        }
-       if t1 == nil || t2 == nil || t1.Etype != t2.Etype || t1.Broke() || t2.Broke() {
+       if t1 == nil || t2 == nil || t1.kind != t2.kind || t1.Broke() || t2.Broke() {
                return false
        }
-       if t1.Sym != nil || t2.Sym != nil {
+       if t1.sym != nil || t2.sym != nil {
                // Special case: we keep byte/uint8 and rune/int32
                // separate for error messages. Treat them as equal.
-               switch t1.Etype {
+               switch t1.kind {
                case TUINT8:
-                       return (t1 == Types[TUINT8] || t1 == Bytetype) && (t2 == Types[TUINT8] || t2 == Bytetype)
+                       return (t1 == Types[TUINT8] || t1 == ByteType) && (t2 == Types[TUINT8] || t2 == ByteType)
                case TINT32:
-                       return (t1 == Types[TINT32] || t1 == Runetype) && (t2 == Types[TINT32] || t2 == Runetype)
+                       return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType)
                default:
                        return false
                }
@@ -52,7 +52,7 @@ func identical(t1, t2 *Type, cmpTags bool, assumedEqual map[typePair]struct{}) b
        }
        assumedEqual[typePair{t1, t2}] = struct{}{}
 
-       switch t1.Etype {
+       switch t1.kind {
        case TIDEAL:
                // Historically, cmd/compile used a single "untyped
                // number" type, so all untyped number types were

diff --git a/src/cmd/compile/internal/types/etype_string.go b/src/cmd/compile/internal/types/kind_string.go
similarity index 57%
rename from src/cmd/compile/internal/types/etype_string.go
rename to src/cmd/compile/internal/types/kind_string.go
index 14fd5b71df801ef27ef8a2b0be2ea4f4bbd0a750..1e1e84624080b08e614821c3e936c5c58daa4f01 100644 (file)
--- a/src/cmd/compile/internal/types/etype_string.go
+++ b/src/cmd/compile/internal/types/kind_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -type EType -trimprefix T"; DO NOT EDIT.
+// Code generated by "stringer -type Kind -trimprefix T type.go"; DO NOT EDIT.
 
 package types
 
@@ -48,13 +48,13 @@ func _() {
        _ = x[NTYPE-37]
 }
 
-const _EType_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
+const _Kind_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
 
-var _EType_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
+var _Kind_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
 
-func (i EType) String() string {
-       if i >= EType(len(_EType_index)-1) {
-               return "EType(" + strconv.FormatInt(int64(i), 10) + ")"
+func (i Kind) String() string {
+       if i >= Kind(len(_Kind_index)-1) {
+               return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
        }
-       return _EType_name[_EType_index[i]:_EType_index[i+1]]
+       return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
 }

diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index bcc67895095812f79dd3482684f3c80bb0c28894..a6d2e2007b0424d4927ef5cda15fb67d94d27186 100644 (file)
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -31,8 +31,7 @@ type Pkg struct {
        // height of their imported packages.
        Height int
 
-       Imported bool // export data of this package was parsed
-       Direct   bool // imported directly
+       Direct bool // imported directly
 }
 
 // NewPkg returns a new Pkg for the given package path and name.
@@ -84,9 +83,6 @@ func (pkg *Pkg) Lookup(name string) *Sym {
        return s
 }
 
-// List of .inittask entries in imported packages, in source code order.
-var InitSyms []*Sym
-
 // LookupOK looks up name in pkg and reports whether it previously existed.
 func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
        // TODO(gri) remove this check in favor of specialized lookup
@@ -101,9 +97,6 @@ func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
                Name: name,
                Pkg:  pkg,
        }
-       if name == ".inittask" {
-               InitSyms = append(InitSyms, s)
-       }
        pkg.Syms[name] = s
        return s, false
 }
@@ -144,3 +137,7 @@ func CleanroomDo(f func()) {
        f()
        pkgMap = saved
 }
+
+func IsDotAlias(sym *Sym) bool {
+       return sym.Def != nil && sym.Def.Sym() != sym
+}

diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 40d3d86ef11a4168db0f5f7c0221a1e94353ed88..d7c454f3795e416ce1af5049cfb029f1e5b2a687 100644 (file)
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -4,18 +4,21 @@
 
 package types
 
-import "cmd/internal/src"
+import (
+       "cmd/compile/internal/base"
+       "cmd/internal/src"
+)
 
 // Declaration stack & operations
 
 var blockgen int32 = 1 // max block number
-var Block int32        // current block number
+var Block int32 = 1    // current block number
 
 // A dsym stores a symbol's shadowed declaration so that it can be
 // restored once the block scope ends.
 type dsym struct {
        sym        *Sym // sym == nil indicates stack mark
-       def        *Node
+       def        Object
        block      int32
        lastlineno src.XPos // last declaration for diagnostic
 }
@@ -56,7 +59,7 @@ func Popdcl() {
                d.sym = nil
                d.def = nil
        }
-       Fatalf("popdcl: no stack mark")
+       base.Fatalf("popdcl: no stack mark")
 }
 
 // Markdcl records the start of a new block scope for declarations.
@@ -69,7 +72,7 @@ func Markdcl() {
        Block = blockgen
 }
 
-func IsDclstackValid() bool {
+func isDclstackValid() bool {
        for _, d := range dclstack {
                if d.sym == nil {
                        return false
@@ -79,19 +82,20 @@ func IsDclstackValid() bool {
 }
 
 // PkgDef returns the definition associated with s at package scope.
-func (s *Sym) PkgDef() *Node {
+func (s *Sym) PkgDef() Object {
        return *s.pkgDefPtr()
 }
 
 // SetPkgDef sets the definition associated with s at package scope.
-func (s *Sym) SetPkgDef(n *Node) {
+func (s *Sym) SetPkgDef(n Object) {
        *s.pkgDefPtr() = n
 }
 
-func (s *Sym) pkgDefPtr() **Node {
+func (s *Sym) pkgDefPtr() *Object {
        // Look for outermost saved declaration, which must be the
        // package scope definition, if present.
-       for _, d := range dclstack {
+       for i := range dclstack {
+               d := &dclstack[i]
                if s == d.sym {
                        return &d.def
                }
@@ -101,3 +105,9 @@ func (s *Sym) pkgDefPtr() **Node {
        // function scope.
        return &s.Def
 }
+
+func CheckDclstack() {
+       if !isDclstackValid() {
+               base.Fatalf("mark left on the dclstack")
+       }
+}

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/types/size.go
similarity index 52%
rename from src/cmd/compile/internal/gc/align.go
rename to src/cmd/compile/internal/types/size.go
index a3a0c8fce822e43226bbaa70a17d5d2e5ee42ccd..98540eefb651daf647142d563dcf45e5e68fb763 100644 (file)
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -2,18 +2,64 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package types
 
 import (
        "bytes"
-       "cmd/compile/internal/types"
        "fmt"
        "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/internal/src"
+)
+
+var PtrSize int
+
+var RegSize int
+
+// Slices in the runtime are represented by three components:
+//
+// type slice struct {
+//     ptr unsafe.Pointer
+//     len int
+//     cap int
+// }
+//
+// Strings in the runtime are represented by two components:
+//
+// type string struct {
+//     ptr unsafe.Pointer
+//     len int
+// }
+//
+// These variables are the offsets of fields and sizes of these structs.
+var (
+       SlicePtrOffset int64
+       SliceLenOffset int64
+       SliceCapOffset int64
+
+       SliceSize  int64
+       StringSize int64
 )
 
-// sizeCalculationDisabled indicates whether it is safe
-// to calculate Types' widths and alignments. See dowidth.
-var sizeCalculationDisabled bool
+var SkipSizeForTracing bool
+
+// typePos returns the position associated with t.
+// This is where t was declared or where it appeared as a type expression.
+func typePos(t *Type) src.XPos {
+       if pos := t.Pos(); pos.IsKnown() {
+               return pos
+       }
+       base.Fatalf("bad type: %v", t)
+       panic("unreachable")
+}
+
+// MaxWidth is the maximum size of a value on the target architecture.
+var MaxWidth int64
+
+// CalcSizeDisabled indicates whether it is safe
+// to calculate Types' widths and alignments. See CalcSize.
+var CalcSizeDisabled bool
 
 // machine size and rounding alignment is dictated around
 // the size of a pointer, set in betypeinit (see ../amd64/galign.go).
@@ -21,25 +67,25 @@ var defercalc int
 
 func Rnd(o int64, r int64) int64 {
        if r < 1 || r > 8 || r&(r-1) != 0 {
-               Fatalf("rnd %d", r)
+               base.Fatalf("rnd %d", r)
        }
        return (o + r - 1) &^ (r - 1)
 }
 
 // expandiface computes the method set for interface type t by
 // expanding embedded interfaces.
-func expandiface(t *types.Type) {
-       seen := make(map[*types.Sym]*types.Field)
-       var methods []*types.Field
+func expandiface(t *Type) {
+       seen := make(map[*Sym]*Field)
+       var methods []*Field
 
-       addMethod := func(m *types.Field, explicit bool) {
+       addMethod := func(m *Field, explicit bool) {
                switch prev := seen[m.Sym]; {
                case prev == nil:
                        seen[m.Sym] = m
-               case langSupported(1, 14, t.Pkg()) && !explicit && types.Identical(m.Type, prev.Type):
+               case AllowsGoVersion(t.Pkg(), 1, 14) && !explicit && Identical(m.Type, prev.Type):
                        return
                default:
-                       yyerrorl(m.Pos, "duplicate method %s", m.Sym.Name)
+                       base.ErrorfAt(m.Pos, "duplicate method %s", m.Sym.Name)
                }
                methods = append(methods, m)
        }
@@ -49,7 +95,7 @@ func expandiface(t *types.Type) {
                        continue
                }
 
-               checkwidth(m.Type)
+               CheckSize(m.Type)
                addMethod(m, true)
        }
 
@@ -59,7 +105,7 @@ func expandiface(t *types.Type) {
                }
 
                if !m.Type.IsInterface() {
-                       yyerrorl(m.Pos, "interface contains embedded non-interface %v", m.Type)
+                       base.ErrorfAt(m.Pos, "interface contains embedded non-interface %v", m.Type)
                        m.SetBroke(true)
                        t.SetBroke(true)
                        // Add to fields so that error messages
@@ -74,30 +120,27 @@ func expandiface(t *types.Type) {
                // (including broken ones, if any) and add to t's
                // method set.
                for _, t1 := range m.Type.Fields().Slice() {
-                       f := types.NewField()
-                       f.Pos = m.Pos // preserve embedding position
-                       f.Sym = t1.Sym
-                       f.Type = t1.Type
-                       f.SetBroke(t1.Broke())
+                       // Use m.Pos rather than t1.Pos to preserve embedding position.
+                       f := NewField(m.Pos, t1.Sym, t1.Type)
                        addMethod(f, false)
                }
        }
 
-       sort.Sort(methcmp(methods))
+       sort.Sort(MethodsByName(methods))
 
-       if int64(len(methods)) >= thearch.MAXWIDTH/int64(Widthptr) {
-               yyerrorl(typePos(t), "interface too large")
+       if int64(len(methods)) >= MaxWidth/int64(PtrSize) {
+               base.ErrorfAt(typePos(t), "interface too large")
        }
        for i, m := range methods {
-               m.Offset = int64(i) * int64(Widthptr)
+               m.Offset = int64(i) * int64(PtrSize)
        }
 
-       // Access fields directly to avoid recursively calling dowidth
+       // Access fields directly to avoid recursively calling CalcSize
        // within Type.Fields().
-       t.Extra.(*types.Interface).Fields.Set(methods)
+       t.Extra.(*Interface).Fields.Set(methods)
 }
 
-func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
+func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
        starto := o
        maxalign := int32(flag)
        if maxalign < 1 {
@@ -111,7 +154,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
                        continue
                }
 
-               dowidth(f.Type)
+               CalcSize(f.Type)
                if int32(f.Type.Align) > maxalign {
                        maxalign = int32(f.Type.Align)
                }
@@ -119,38 +162,33 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
                        o = Rnd(o, int64(f.Type.Align))
                }
                f.Offset = o
-               if n := asNode(f.Nname); n != nil {
+               if f.Nname != nil {
                        // addrescapes has similar code to update these offsets.
-                       // Usually addrescapes runs after widstruct,
+                       // Usually addrescapes runs after calcStructOffset,
                        // in which case we could drop this,
                        // but function closure functions are the exception.
                        // NOTE(rsc): This comment may be stale.
                        // It's possible the ordering has changed and this is
                        // now the common case. I'm not sure.
-                       if n.Name.Param.Stackcopy != nil {
-                               n.Name.Param.Stackcopy.Xoffset = o
-                               n.Xoffset = 0
-                       } else {
-                               n.Xoffset = o
-                       }
+                       f.Nname.(VarObject).RecordFrameOffset(o)
                }
 
                w := f.Type.Width
                if w < 0 {
-                       Fatalf("invalid width %d", f.Type.Width)
+                       base.Fatalf("invalid width %d", f.Type.Width)
                }
                if w == 0 {
                        lastzero = o
                }
                o += w
-               maxwidth := thearch.MAXWIDTH
+               maxwidth := MaxWidth
                // On 32-bit systems, reflect tables impose an additional constraint
                // that each field start offset must fit in 31 bits.
                if maxwidth < 1<<32 {
                        maxwidth = 1<<31 - 1
                }
                if o >= maxwidth {
-                       yyerrorl(typePos(errtype), "type %L too large", errtype)
+                       base.ErrorfAt(typePos(errtype), "type %L too large", errtype)
                        o = 8 // small but nonzero
                }
        }
@@ -182,15 +220,22 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 // path points to a slice used for tracking the sequence of types
 // visited. Using a pointer to a slice allows the slice capacity to
 // grow and limit reallocations.
-func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
+func findTypeLoop(t *Type, path *[]*Type) bool {
        // We implement a simple DFS loop-finding algorithm. This
        // could be faster, but type cycles are rare.
 
-       if t.Sym != nil {
+       if t.Sym() != nil {
                // Declared type. Check for loops and otherwise
                // recurse on the type expression used in the type
                // declaration.
 
+               // Type imported from package, so it can't be part of
+               // a type loop (otherwise that package should have
+               // failed to compile).
+               if t.Sym().Pkg != LocalPkg {
+                       return false
+               }
+
                for i, x := range *path {
                        if x == t {
                                *path = (*path)[i:]
@@ -199,14 +244,14 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
                }
 
                *path = append(*path, t)
-               if p := asNode(t.Nod).Name.Param; p != nil && findTypeLoop(p.Ntype.Type, path) {
+               if findTypeLoop(t.Obj().(TypeObject).TypeDefn(), path) {
                        return true
                }
                *path = (*path)[:len(*path)-1]
        } else {
                // Anonymous type. Recurse on contained types.
 
-               switch t.Etype {
+               switch t.Kind() {
                case TARRAY:
                        if findTypeLoop(t.Elem(), path) {
                                return true
@@ -231,14 +276,14 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
        return false
 }
 
-func reportTypeLoop(t *types.Type) {
+func reportTypeLoop(t *Type) {
        if t.Broke() {
                return
        }
 
-       var l []*types.Type
+       var l []*Type
        if !findTypeLoop(t, &l) {
-               Fatalf("failed to find type loop for: %v", t)
+               base.Fatalf("failed to find type loop for: %v", t)
        }
 
        // Rotate loop so that the earliest type declaration is first.
@@ -253,25 +298,26 @@ func reportTypeLoop(t *types.Type) {
        var msg bytes.Buffer
        fmt.Fprintf(&msg, "invalid recursive type %v\n", l[0])
        for _, t := range l {
-               fmt.Fprintf(&msg, "\t%v: %v refers to\n", linestr(typePos(t)), t)
+               fmt.Fprintf(&msg, "\t%v: %v refers to\n", base.FmtPos(typePos(t)), t)
                t.SetBroke(true)
        }
-       fmt.Fprintf(&msg, "\t%v: %v", linestr(typePos(l[0])), l[0])
-       yyerrorl(typePos(l[0]), msg.String())
+       fmt.Fprintf(&msg, "\t%v: %v", base.FmtPos(typePos(l[0])), l[0])
+       base.ErrorfAt(typePos(l[0]), msg.String())
 }
 
-// dowidth calculates and stores the size and alignment for t.
-// If sizeCalculationDisabled is set, and the size/alignment
+// CalcSize calculates and stores the size and alignment for t.
+// If CalcSizeDisabled is set, and the size/alignment
 // have not already been calculated, it calls Fatal.
 // This is used to prevent data races in the back end.
-func dowidth(t *types.Type) {
-       // Calling dowidth when typecheck tracing enabled is not safe.
+func CalcSize(t *Type) {
+       // Calling CalcSize when typecheck tracing enabled is not safe.
        // See issue #33658.
-       if enableTrace && skipDowidthForTracing {
+       if base.EnableTrace && SkipSizeForTracing {
                return
        }
-       if Widthptr == 0 {
-               Fatalf("dowidth without betypeinit")
+       if PtrSize == 0 {
+               // Assume this is a test.
+               return
        }
 
        if t == nil {
@@ -289,13 +335,13 @@ func dowidth(t *types.Type) {
                return
        }
 
-       if sizeCalculationDisabled {
+       if CalcSizeDisabled {
                if t.Broke() {
                        // break infinite recursion from Fatal call below
                        return
                }
                t.SetBroke(true)
-               Fatalf("width not calculated: %v", t)
+               base.Fatalf("width not calculated: %v", t)
        }
 
        // break infinite recursion if the broken recursive type
@@ -304,33 +350,33 @@ func dowidth(t *types.Type) {
                return
        }
 
-       // defer checkwidth calls until after we're done
-       defercheckwidth()
+       // defer CheckSize calls until after we're done
+       DeferCheckSize()
 
-       lno := lineno
-       if asNode(t.Nod) != nil {
-               lineno = asNode(t.Nod).Pos
+       lno := base.Pos
+       if pos := t.Pos(); pos.IsKnown() {
+               base.Pos = pos
        }
 
        t.Width = -2
        t.Align = 0 // 0 means use t.Width, below
 
-       et := t.Etype
+       et := t.Kind()
        switch et {
        case TFUNC, TCHAN, TMAP, TSTRING:
                break
 
-       // simtype == 0 during bootstrap
+       // SimType == 0 during bootstrap
        default:
-               if simtype[t.Etype] != 0 {
-                       et = simtype[t.Etype]
+               if SimType[t.Kind()] != 0 {
+                       et = SimType[t.Kind()]
                }
        }
 
        var w int64
        switch et {
        default:
-               Fatalf("dowidth: unknown type: %v", t)
+               base.Fatalf("CalcSize: unknown type: %v", t)
 
        // compiler-specific stuff
        case TINT8, TUINT8, TBOOL:
@@ -345,7 +391,7 @@ func dowidth(t *types.Type) {
 
        case TINT64, TUINT64, TFLOAT64:
                w = 8
-               t.Align = uint8(Widthreg)
+               t.Align = uint8(RegSize)
 
        case TCOMPLEX64:
                w = 8
@@ -353,68 +399,68 @@ func dowidth(t *types.Type) {
 
        case TCOMPLEX128:
                w = 16
-               t.Align = uint8(Widthreg)
+               t.Align = uint8(RegSize)
 
        case TPTR:
-               w = int64(Widthptr)
-               checkwidth(t.Elem())
+               w = int64(PtrSize)
+               CheckSize(t.Elem())
 
        case TUNSAFEPTR:
-               w = int64(Widthptr)
+               w = int64(PtrSize)
 
        case TINTER: // implemented as 2 pointers
-               w = 2 * int64(Widthptr)
-               t.Align = uint8(Widthptr)
+               w = 2 * int64(PtrSize)
+               t.Align = uint8(PtrSize)
                expandiface(t)
 
        case TCHAN: // implemented as pointer
-               w = int64(Widthptr)
+               w = int64(PtrSize)
 
-               checkwidth(t.Elem())
+               CheckSize(t.Elem())
 
                // make fake type to check later to
                // trigger channel argument check.
-               t1 := types.NewChanArgs(t)
-               checkwidth(t1)
+               t1 := NewChanArgs(t)
+               CheckSize(t1)
 
        case TCHANARGS:
                t1 := t.ChanArgs()
-               dowidth(t1) // just in case
+               CalcSize(t1) // just in case
                if t1.Elem().Width >= 1<<16 {
-                       yyerrorl(typePos(t1), "channel element type too large (>64kB)")
+                       base.ErrorfAt(typePos(t1), "channel element type too large (>64kB)")
                }
                w = 1 // anything will do
 
        case TMAP: // implemented as pointer
-               w = int64(Widthptr)
-               checkwidth(t.Elem())
-               checkwidth(t.Key())
+               w = int64(PtrSize)
+               CheckSize(t.Elem())
+               CheckSize(t.Key())
 
        case TFORW: // should have been filled in
                reportTypeLoop(t)
                w = 1 // anything will do
 
        case TANY:
-               // dummy type; should be replaced before use.
-               Fatalf("dowidth any")
+               // not a real type; should be replaced before use.
+               base.Fatalf("CalcSize any")
 
        case TSTRING:
-               if sizeofString == 0 {
-                       Fatalf("early dowidth string")
+               if StringSize == 0 {
+                       base.Fatalf("early CalcSize string")
                }
-               w = sizeofString
-               t.Align = uint8(Widthptr)
+               w = StringSize
+               t.Align = uint8(PtrSize)
 
        case TARRAY:
                if t.Elem() == nil {
                        break
                }
 
-               dowidth(t.Elem())
+               CalcSize(t.Elem())
                if t.Elem().Width != 0 {
-                       cap := (uint64(thearch.MAXWIDTH) - 1) / uint64(t.Elem().Width)
+                       cap := (uint64(MaxWidth) - 1) / uint64(t.Elem().Width)
                        if uint64(t.NumElem()) > cap {
-                               yyerrorl(typePos(t), "type %L larger than address space", t)
+                               base.ErrorfAt(typePos(t), "type %L larger than address space", t)
                        }
                }
                w = t.NumElem() * t.Elem().Width
@@ -424,55 +470,62 @@ func dowidth(t *types.Type) {
                if t.Elem() == nil {
                        break
                }
-               w = sizeofSlice
-               checkwidth(t.Elem())
-               t.Align = uint8(Widthptr)
+               w = SliceSize
+               CheckSize(t.Elem())
+               t.Align = uint8(PtrSize)
 
        case TSTRUCT:
                if t.IsFuncArgStruct() {
-                       Fatalf("dowidth fn struct %v", t)
+                       base.Fatalf("CalcSize fn struct %v", t)
                }
-               w = widstruct(t, t, 0, 1)
+               w = calcStructOffset(t, t, 0, 1)
 
        // make fake type to check later to
        // trigger function argument computation.
        case TFUNC:
-               t1 := types.NewFuncArgs(t)
-               checkwidth(t1)
-               w = int64(Widthptr) // width of func type is pointer
+               t1 := NewFuncArgs(t)
+               CheckSize(t1)
+               w = int64(PtrSize) // width of func type is pointer
 
        // function is 3 cated structures;
        // compute their widths as side-effect.
        case TFUNCARGS:
                t1 := t.FuncArgs()
-               w = widstruct(t1, t1.Recvs(), 0, 0)
-               w = widstruct(t1, t1.Params(), w, Widthreg)
-               w = widstruct(t1, t1.Results(), w, Widthreg)
-               t1.Extra.(*types.Func).Argwid = w
-               if w%int64(Widthreg) != 0 {
-                       Warn("bad type %v %d\n", t1, w)
+               w = calcStructOffset(t1, t1.Recvs(), 0, 0)
+               w = calcStructOffset(t1, t1.Params(), w, RegSize)
+               w = calcStructOffset(t1, t1.Results(), w, RegSize)
+               t1.Extra.(*Func).Argwid = w
+               if w%int64(RegSize) != 0 {
+                       base.Warn("bad type %v %d\n", t1, w)
                }
                t.Align = 1
        }
 
-       if Widthptr == 4 && w != int64(int32(w)) {
-               yyerrorl(typePos(t), "type %v too large", t)
+       if PtrSize == 4 && w != int64(int32(w)) {
+               base.ErrorfAt(typePos(t), "type %v too large", t)
        }
 
        t.Width = w
        if t.Align == 0 {
                if w == 0 || w > 8 || w&(w-1) != 0 {
-                       Fatalf("invalid alignment for %v", t)
+                       base.Fatalf("invalid alignment for %v", t)
                }
                t.Align = uint8(w)
        }
 
-       lineno = lno
+       base.Pos = lno
+
+       ResumeCheckSize()
+}
 
-       resumecheckwidth()
+// CalcStructSize calculates the size of s,
+// filling in s.Width and s.Align,
+// even if size calculation is otherwise disabled.
+func CalcStructSize(s *Type) {
+       s.Width = calcStructOffset(s, s, 0, 1) // sets align
 }
 
-// when a type's width should be known, we call checkwidth
+// when a type's width should be known, we call CheckSize
 // to compute it.  during a declaration like
 //
 //     type T *struct { next T }
@@ -481,16 +534,16 @@ func dowidth(t *types.Type) {
 // until after T has been initialized to be a pointer to that struct.
 // similarly, during import processing structs may be used
 // before their definition.  in those situations, calling
-// defercheckwidth() stops width calculations until
-// resumecheckwidth() is called, at which point all the
-// checkwidths that were deferred are executed.
-// dowidth should only be called when the type's size
-// is needed immediately.  checkwidth makes sure the
+// DeferCheckSize() stops width calculations until
+// ResumeCheckSize() is called, at which point all the
+// CalcSizes that were deferred are executed.
+// CalcSize should only be called when the type's size
+// is needed immediately.  CheckSize makes sure the
 // size is evaluated eventually.
 
-var deferredTypeStack []*types.Type
+var deferredTypeStack []*Type
 
-func checkwidth(t *types.Type) {
+func CheckSize(t *Type) {
        if t == nil {
                return
        }
@@ -498,11 +551,11 @@ func checkwidth(t *types.Type) {
        // function arg structs should not be checked
        // outside of the enclosing function.
        if t.IsFuncArgStruct() {
-               Fatalf("checkwidth %v", t)
+               base.Fatalf("CheckSize %v", t)
        }
 
        if defercalc == 0 {
-               dowidth(t)
+               CalcSize(t)
                return
        }
 
@@ -513,19 +566,68 @@ func checkwidth(t *types.Type) {
        }
 }
 
-func defercheckwidth() {
+func DeferCheckSize() {
        defercalc++
 }
 
-func resumecheckwidth() {
+func ResumeCheckSize() {
        if defercalc == 1 {
                for len(deferredTypeStack) > 0 {
                        t := deferredTypeStack[len(deferredTypeStack)-1]
                        deferredTypeStack = deferredTypeStack[:len(deferredTypeStack)-1]
                        t.SetDeferwidth(false)
-                       dowidth(t)
+                       CalcSize(t)
                }
        }
 
        defercalc--
 }
+
+// PtrDataSize returns the length in bytes of the prefix of t
+// containing pointer data. Anything after this offset is scalar data.
+func PtrDataSize(t *Type) int64 {
+       if !t.HasPointers() {
+               return 0
+       }
+
+       switch t.Kind() {
+       case TPTR,
+               TUNSAFEPTR,
+               TFUNC,
+               TCHAN,
+               TMAP:
+               return int64(PtrSize)
+
+       case TSTRING:
+               // struct { byte *str; intgo len; }
+               return int64(PtrSize)
+
+       case TINTER:
+               // struct { Itab *tab;  void *data; } or
+               // struct { Type *type; void *data; }
+               // Note: see comment in typebits.Set
+               return 2 * int64(PtrSize)
+
+       case TSLICE:
+               // struct { byte *array; uintgo len; uintgo cap; }
+               return int64(PtrSize)
+
+       case TARRAY:
+               // haspointers already eliminated t.NumElem() == 0.
+               return (t.NumElem()-1)*t.Elem().Width + PtrDataSize(t.Elem())
+
+       case TSTRUCT:
+               // Find the last field that has pointers.
+               var lastPtrField *Field
+               for _, t1 := range t.Fields().Slice() {
+                       if t1.Type.HasPointers() {
+                               lastPtrField = t1
+                       }
+               }
+               return lastPtrField.Offset + PtrDataSize(lastPtrField.Type)
+
+       default:
+               base.Fatalf("PtrDataSize: unexpected type, %v", t)
+               return 0
+       }
+}

diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index ea947d8f417c5f08fb5150144330a083521f7145..675739f7f63681361becfa063e18520fba795705 100644 (file)
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,11 +20,11 @@ func TestSizeof(t *testing.T) {
                _32bit uintptr     // size on 32bit platforms
                _64bit uintptr     // size on 64bit platforms
        }{
-               {Sym{}, 52, 88},
-               {Type{}, 52, 88},
+               {Sym{}, 44, 72},
+               {Type{}, 56, 96},
                {Map{}, 20, 40},
                {Forward{}, 20, 32},
-               {Func{}, 32, 56},
+               {Func{}, 24, 40},
                {Struct{}, 16, 32},
                {Interface{}, 8, 16},
                {Chan{}, 8, 16},

diff --git a/src/cmd/compile/internal/types/sort.go b/src/cmd/compile/internal/types/sort.go
new file mode 100644 (file)
index 0000000..dc59b06
--- /dev/null
+++ b/src/cmd/compile/internal/types/sort.go
@@ -0,0 +1,14 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+// MethodsByName sorts methods by symbol.
+type MethodsByName []*Field
+
+func (x MethodsByName) Len() int { return len(x) }
+
+func (x MethodsByName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x MethodsByName) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }

diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 07bce4d5cdbb81a3d4a18c0f4b135c54d4ea1610..0e66ed348bfcf09e070996406a893bae56a338a8 100644 (file)
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -5,6 +5,7 @@
 package types
 
 import (
+       "cmd/compile/internal/base"
        "cmd/internal/obj"
        "cmd/internal/src"
        "unicode"
@@ -26,20 +27,17 @@ import (
 // NOTE: In practice, things can be messier than the description above
 // for various reasons (historical, convenience).
 type Sym struct {
-       Importdef *Pkg   // where imported definition was found
-       Linkname  string // link name
+       Linkname string // link name
 
        Pkg  *Pkg
        Name string // object name
 
        // saved and restored by dcopy
-       Def        *Node    // definition: ONAME OTYPE OPACK or OLITERAL
+       Def        Object   // definition: ONAME OTYPE OPACK or OLITERAL
        Block      int32    // blocknumber to catch redeclaration
        Lastlineno src.XPos // last declaration for diagnostic
 
-       flags   bitset8
-       Label   *Node // corresponding label (ephemeral)
-       Origpkg *Pkg  // original package for . import
+       flags bitset8
 }
 
 const (
@@ -66,32 +64,30 @@ func (sym *Sym) IsBlank() bool {
        return sym != nil && sym.Name == "_"
 }
 
-func (sym *Sym) LinksymName() string {
-       if sym.IsBlank() {
-               return "_"
-       }
-       if sym.Linkname != "" {
-               return sym.Linkname
+// Deprecated: This method should not be used directly. Instead, use a
+// higher-level abstraction that directly returns the linker symbol
+// for a named object. For example, reflectdata.TypeLinksym(t) instead
+// of reflectdata.TypeSym(t).Linksym().
+func (sym *Sym) Linksym() *obj.LSym {
+       abi := obj.ABI0
+       if sym.Func() {
+               abi = obj.ABIInternal
        }
-       return sym.Pkg.Prefix + "." + sym.Name
+       return sym.LinksymABI(abi)
 }
 
-func (sym *Sym) Linksym() *obj.LSym {
+// Deprecated: This method should not be used directly. Instead, use a
+// higher-level abstraction that directly returns the linker symbol
+// for a named object. For example, (*ir.Name).LinksymABI(abi) instead
+// of (*ir.Name).Sym().LinksymABI(abi).
+func (sym *Sym) LinksymABI(abi obj.ABI) *obj.LSym {
        if sym == nil {
-               return nil
+               base.Fatalf("nil symbol")
        }
-       initPkg := func(r *obj.LSym) {
-               if sym.Linkname != "" {
-                       r.Pkg = "_"
-               } else {
-                       r.Pkg = sym.Pkg.Prefix
-               }
-       }
-       if sym.Func() {
-               // This is a function symbol. Mark it as "internal ABI".
-               return Ctxt.LookupABIInit(sym.LinksymName(), obj.ABIInternal, initPkg)
+       if sym.Linkname != "" {
+               return base.Linkname(sym.Linkname, abi)
        }
-       return Ctxt.LookupInit(sym.LinksymName(), initPkg)
+       return base.PkgLinksym(sym.Pkg.Prefix, sym.Name, abi)
 }
 
 // Less reports whether symbol a is ordered before symbol b.

diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 023ab9af88aee048f29fd88b5596e515360f0fd2..0dfbef8af1d6254f7291e2fb9a47853bb385830a 100644 (file)
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -5,23 +5,40 @@
 package types
 
 import (
-       "cmd/internal/obj"
+       "cmd/compile/internal/base"
        "cmd/internal/src"
        "fmt"
+       "sync"
 )
 
-// Dummy Node so we can refer to *Node without actually
-// having a gc.Node. Necessary to break import cycles.
-// TODO(gri) try to eliminate soon
-type Node struct{ _ int }
+// IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
+// which would cause an import cycle. The uses in other packages must type assert
+// values of type IRNode to ir.Node or a more specific type.
+type Object interface {
+       Pos() src.XPos
+       Sym() *Sym
+       Type() *Type
+}
+
+// A TypeObject is an Object representing a named type.
+type TypeObject interface {
+       Object
+       TypeDefn() *Type // for "type T Defn", returns Defn
+}
 
-//go:generate stringer -type EType -trimprefix T
+// A VarObject is an Object representing a function argument, variable, or struct field.
+type VarObject interface {
+       Object
+       RecordFrameOffset(int64) // save frame offset
+}
+
+//go:generate stringer -type Kind -trimprefix T type.go
 
-// EType describes a kind of type.
-type EType uint8
+// Kind describes a kind of type.
+type Kind uint8
 
 const (
-       Txxx EType = iota
+       Txxx Kind = iota
 
        TINT8
        TUINT8
@@ -90,7 +107,7 @@ const (
 // Types stores pointers to predeclared named types.
 //
 // It also stores pointers to several special types:
-//   - Types[TANY] is the placeholder "any" type recognized by substArgTypes.
+//   - Types[TANY] is the placeholder "any" type recognized by SubstArgTypes.
 //   - Types[TBLANK] represents the blank variable's type.
 //   - Types[TNIL] represents the predeclared "nil" value's type.
 //   - Types[TUNSAFEPTR] is package unsafe's Pointer type.
@@ -98,15 +115,15 @@ var Types [NTYPE]*Type
 
 var (
        // Predeclared alias types. Kept separate for better error messages.
-       Bytetype *Type
-       Runetype *Type
+       ByteType *Type
+       RuneType *Type
 
        // Predeclared error interface type.
-       Errortype *Type
+       ErrorType *Type
 
        // Types to represent untyped string and boolean constants.
-       UntypedString *Type
-       UntypedBool   *Type
+       UntypedString = New(TSTRING)
+       UntypedBool   = New(TBOOL)
 
        // Types to represent untyped numeric constants.
        UntypedInt     = New(TIDEAL)
@@ -141,24 +158,26 @@ type Type struct {
        methods    Fields
        allMethods Fields
 
-       Nod  *Node // canonical OTYPE node
-       Orig *Type // original type (type literal or predefined type)
+       nod        Object // canonical OTYPE node
+       underlying *Type  // original type (type literal or predefined type)
 
        // Cache of composite types, with this type being the element type.
-       Cache struct {
+       cache struct {
                ptr   *Type // *T, or nil
                slice *Type // []T, or nil
        }
 
-       Sym    *Sym  // symbol containing name, for named types
+       sym    *Sym  // symbol containing name, for named types
        Vargen int32 // unique name for OTYPE/ONAME
 
-       Etype EType // kind of type
+       kind  Kind  // kind of type
        Align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)
 
        flags bitset8
 }
 
+func (*Type) CanBeAnSSAAux() {}
+
 const (
        typeNotInHeap  = 1 << iota // type cannot be heap allocated
        typeBroke                  // broken type definition
@@ -179,6 +198,38 @@ func (t *Type) SetNoalg(b bool)      { t.flags.set(typeNoalg, b) }
 func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) }
 func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 
+// Kind returns the kind of type t.
+func (t *Type) Kind() Kind { return t.kind }
+
+// Sym returns the name of type t.
+func (t *Type) Sym() *Sym { return t.sym }
+
+// Underlying returns the underlying type of type t.
+func (t *Type) Underlying() *Type { return t.underlying }
+
+// SetNod associates t with syntax node n.
+func (t *Type) SetNod(n Object) {
+       // t.nod can be non-nil already
+       // in the case of shared *Types, like []byte or interface{}.
+       if t.nod == nil {
+               t.nod = n
+       }
+}
+
+// Pos returns a position associated with t, if any.
+// This should only be used for diagnostics.
+func (t *Type) Pos() src.XPos {
+       if t.nod != nil {
+               return t.nod.Pos()
+       }
+       return src.NoXPos
+}
+
+// NoPkg is a nil *Pkg value for clarity.
+// It's intended for use when constructing types that aren't exported
+// and thus don't need to be associated with any package.
+var NoPkg *Pkg = nil
+
 // Pkg returns the package that t appeared in.
 //
 // Pkg is only defined for function, struct, and interface types
@@ -186,7 +237,7 @@ func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 // cmd/compile itself, but we need to track it because it's exposed by
 // the go/types API.
 func (t *Type) Pkg() *Pkg {
-       switch t.Etype {
+       switch t.kind {
        case TFUNC:
                return t.Extra.(*Func).pkg
        case TSTRUCT:
@@ -194,25 +245,11 @@ func (t *Type) Pkg() *Pkg {
        case TINTER:
                return t.Extra.(*Interface).pkg
        default:
-               Fatalf("Pkg: unexpected kind: %v", t)
+               base.Fatalf("Pkg: unexpected kind: %v", t)
                return nil
        }
 }
 
-// SetPkg sets the package that t appeared in.
-func (t *Type) SetPkg(pkg *Pkg) {
-       switch t.Etype {
-       case TFUNC:
-               t.Extra.(*Func).pkg = pkg
-       case TSTRUCT:
-               t.Extra.(*Struct).pkg = pkg
-       case TINTER:
-               t.Extra.(*Interface).pkg = pkg
-       default:
-               Fatalf("Pkg: unexpected kind: %v", t)
-       }
-}
-
 // Map contains Type fields specific to maps.
 type Map struct {
        Key  *Type // Key type
@@ -247,15 +284,12 @@ type Func struct {
        Results  *Type // function results
        Params   *Type // function params
 
-       Nname *Node
-       pkg   *Pkg
+       pkg *Pkg
 
        // Argwid is the total width of the function receiver, params, and results.
        // It gets calculated via a temporary TFUNCARGS type.
        // Note that TFUNC's Width is Widthptr.
        Argwid int64
-
-       Outnamed bool
 }
 
 // FuncType returns t's extra func-specific fields.
@@ -361,7 +395,7 @@ type Field struct {
 
        // For fields that represent function parameters, Nname points
        // to the associated ONAME Node.
-       Nname *Node
+       Nname Object
 
        // Offset in bytes of this field or method within its enclosing struct
        // or interface Type.
@@ -389,7 +423,7 @@ func (f *Field) End() int64 {
 
 // IsMethod reports whether f represents a method rather than a struct field.
 func (f *Field) IsMethod() bool {
-       return f.Type.Etype == TFUNC && f.Type.Recv() != nil
+       return f.Type.kind == TFUNC && f.Type.Recv() != nil
 }
 
 // Fields is a pointer to a slice of *Field.
@@ -444,14 +478,14 @@ func (f *Fields) Append(s ...*Field) {
 }
 
 // New returns a new Type of the specified kind.
-func New(et EType) *Type {
+func New(et Kind) *Type {
        t := &Type{
-               Etype: et,
+               kind:  et,
                Width: BADWIDTH,
        }
-       t.Orig = t
+       t.underlying = t
        // TODO(josharian): lazily initialize some of these?
-       switch t.Etype {
+       switch t.kind {
        case TMAP:
                t.Extra = new(Map)
        case TFORW:
@@ -481,7 +515,7 @@ func New(et EType) *Type {
 // NewArray returns a new fixed-length array Type.
 func NewArray(elem *Type, bound int64) *Type {
        if bound < 0 {
-               Fatalf("NewArray: invalid bound %v", bound)
+               base.Fatalf("NewArray: invalid bound %v", bound)
        }
        t := New(TARRAY)
        t.Extra = &Array{Elem: elem, Bound: bound}
@@ -491,16 +525,16 @@ func NewArray(elem *Type, bound int64) *Type {
 
 // NewSlice returns the slice Type with element type elem.
 func NewSlice(elem *Type) *Type {
-       if t := elem.Cache.slice; t != nil {
+       if t := elem.cache.slice; t != nil {
                if t.Elem() != elem {
-                       Fatalf("elem mismatch")
+                       base.Fatalf("elem mismatch")
                }
                return t
        }
 
        t := New(TSLICE)
        t.Extra = Slice{Elem: elem}
-       elem.Cache.slice = t
+       elem.cache.slice = t
        return t
 }
 
@@ -549,22 +583,22 @@ var NewPtrCacheEnabled = true
 // NewPtr returns the pointer type pointing to t.
 func NewPtr(elem *Type) *Type {
        if elem == nil {
-               Fatalf("NewPtr: pointer to elem Type is nil")
+               base.Fatalf("NewPtr: pointer to elem Type is nil")
        }
 
-       if t := elem.Cache.ptr; t != nil {
+       if t := elem.cache.ptr; t != nil {
                if t.Elem() != elem {
-                       Fatalf("NewPtr: elem mismatch")
+                       base.Fatalf("NewPtr: elem mismatch")
                }
                return t
        }
 
        t := New(TPTR)
        t.Extra = Ptr{Elem: elem}
-       t.Width = int64(Widthptr)
-       t.Align = uint8(Widthptr)
+       t.Width = int64(PtrSize)
+       t.Align = uint8(PtrSize)
        if NewPtrCacheEnabled {
-               elem.Cache.ptr = t
+               elem.cache.ptr = t
        }
        return t
 }
@@ -583,10 +617,17 @@ func NewFuncArgs(f *Type) *Type {
        return t
 }
 
-func NewField() *Field {
-       return &Field{
+func NewField(pos src.XPos, sym *Sym, typ *Type) *Field {
+       f := &Field{
+               Pos:    pos,
+               Sym:    sym,
+               Type:   typ,
                Offset: BADWIDTH,
        }
+       if typ == nil {
+               f.SetBroke(true)
+       }
+       return f
 }
 
 // SubstAny walks t, replacing instances of "any" with successive
@@ -596,13 +637,13 @@ func SubstAny(t *Type, types *[]*Type) *Type {
                return nil
        }
 
-       switch t.Etype {
+       switch t.kind {
        default:
                // Leave the type unchanged.
 
        case TANY:
                if len(*types) == 0 {
-                       Fatalf("substArgTypes: not enough argument types")
+                       base.Fatalf("SubstArgTypes: not enough argument types")
                }
                t = (*types)[0]
                *types = (*types)[1:]
@@ -680,7 +721,7 @@ func (t *Type) copy() *Type {
        }
        nt := *t
        // copy any *T Extra fields, to avoid aliasing
-       switch t.Etype {
+       switch t.kind {
        case TMAP:
                x := *t.Extra.(*Map)
                nt.Extra = &x
@@ -703,11 +744,11 @@ func (t *Type) copy() *Type {
                x := *t.Extra.(*Array)
                nt.Extra = &x
        case TTUPLE, TSSA, TRESULTS:
-               Fatalf("ssa types cannot be copied")
+               base.Fatalf("ssa types cannot be copied")
        }
        // TODO(mdempsky): Find out why this is necessary and explain.
-       if t.Orig == t {
-               nt.Orig = &nt
+       if t.underlying == t {
+               nt.underlying = &nt
        }
        return &nt
 }
@@ -717,9 +758,9 @@ func (f *Field) Copy() *Field {
        return &nf
 }
 
-func (t *Type) wantEtype(et EType) {
-       if t.Etype != et {
-               Fatalf("want %v, but have %v", et, t)
+func (t *Type) wantEtype(et Kind) {
+       if t.kind != et {
+               base.Fatalf("want %v, but have %v", et, t)
        }
 }
 
@@ -772,7 +813,7 @@ func (t *Type) Key() *Type {
 // Elem returns the type of elements of t.
 // Usable with pointers, channels, arrays, slices, and maps.
 func (t *Type) Elem() *Type {
-       switch t.Etype {
+       switch t.kind {
        case TPTR:
                return t.Extra.(Ptr).Elem
        case TARRAY:
@@ -784,7 +825,7 @@ func (t *Type) Elem() *Type {
        case TMAP:
                return t.Extra.(*Map).Elem
        }
-       Fatalf("Type.Elem %s", t.Etype)
+       base.Fatalf("Type.Elem %s", t.kind)
        return nil
 }
 
@@ -800,29 +841,9 @@ func (t *Type) FuncArgs() *Type {
        return t.Extra.(FuncArgs).T
 }
 
-// Nname returns the associated function's nname.
-func (t *Type) Nname() *Node {
-       switch t.Etype {
-       case TFUNC:
-               return t.Extra.(*Func).Nname
-       }
-       Fatalf("Type.Nname %v %v", t.Etype, t)
-       return nil
-}
-
-// Nname sets the associated function's nname.
-func (t *Type) SetNname(n *Node) {
-       switch t.Etype {
-       case TFUNC:
-               t.Extra.(*Func).Nname = n
-       default:
-               Fatalf("Type.SetNname %v %v", t.Etype, t)
-       }
-}
-
 // IsFuncArgStruct reports whether t is a struct representing function parameters.
 func (t *Type) IsFuncArgStruct() bool {
-       return t.Etype == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
+       return t.kind == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
 }
 
 func (t *Type) Methods() *Fields {
@@ -836,14 +857,14 @@ func (t *Type) AllMethods() *Fields {
 }
 
 func (t *Type) Fields() *Fields {
-       switch t.Etype {
+       switch t.kind {
        case TSTRUCT:
                return &t.Extra.(*Struct).fields
        case TINTER:
-               Dowidth(t)
+               CalcSize(t)
                return &t.Extra.(*Interface).Fields
        }
-       Fatalf("Fields: type %v does not have fields", t)
+       base.Fatalf("Fields: type %v does not have fields", t)
        return nil
 }
 
@@ -867,7 +888,7 @@ func (t *Type) SetFields(fields []*Field) {
        // enforce that SetFields cannot be called once
        // t's width has been calculated.
        if t.WidthCalculated() {
-               Fatalf("SetFields of %v: width previously calculated", t)
+               base.Fatalf("SetFields of %v: width previously calculated", t)
        }
        t.wantEtype(TSTRUCT)
        for _, f := range fields {
@@ -901,23 +922,23 @@ func (t *Type) ArgWidth() int64 {
 }
 
 func (t *Type) Size() int64 {
-       if t.Etype == TSSA {
+       if t.kind == TSSA {
                if t == TypeInt128 {
                        return 16
                }
                return 0
        }
-       Dowidth(t)
+       CalcSize(t)
        return t.Width
 }
 
 func (t *Type) Alignment() int64 {
-       Dowidth(t)
+       CalcSize(t)
        return int64(t.Align)
 }
 
 func (t *Type) SimpleString() string {
-       return t.Etype.String()
+       return t.kind.String()
 }
 
 // Cmp is a comparison between values a and b.
@@ -1001,31 +1022,31 @@ func (t *Type) cmp(x *Type) Cmp {
                return CMPgt
        }
 
-       if t.Etype != x.Etype {
-               return cmpForNe(t.Etype < x.Etype)
+       if t.kind != x.kind {
+               return cmpForNe(t.kind < x.kind)
        }
 
-       if t.Sym != nil || x.Sym != nil {
+       if t.sym != nil || x.sym != nil {
                // Special case: we keep byte and uint8 separate
                // for error messages. Treat them as equal.
-               switch t.Etype {
+               switch t.kind {
                case TUINT8:
-                       if (t == Types[TUINT8] || t == Bytetype) && (x == Types[TUINT8] || x == Bytetype) {
+                       if (t == Types[TUINT8] || t == ByteType) && (x == Types[TUINT8] || x == ByteType) {
                                return CMPeq
                        }
 
                case TINT32:
-                       if (t == Types[Runetype.Etype] || t == Runetype) && (x == Types[Runetype.Etype] || x == Runetype) {
+                       if (t == Types[RuneType.kind] || t == RuneType) && (x == Types[RuneType.kind] || x == RuneType) {
                                return CMPeq
                        }
                }
        }
 
-       if c := t.Sym.cmpsym(x.Sym); c != CMPeq {
+       if c := t.sym.cmpsym(x.sym); c != CMPeq {
                return c
        }
 
-       if x.Sym != nil {
+       if x.sym != nil {
                // Syms non-nil, if vargens match then equal.
                if t.Vargen != x.Vargen {
                        return cmpForNe(t.Vargen < x.Vargen)
@@ -1034,7 +1055,7 @@ func (t *Type) cmp(x *Type) Cmp {
        }
        // both syms nil, look at structure below.
 
-       switch t.Etype {
+       switch t.kind {
        case TBOOL, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TUNSAFEPTR, TUINTPTR,
                TINT8, TINT16, TINT32, TINT64, TINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINT:
                return CMPeq
@@ -1191,15 +1212,15 @@ func (t *Type) cmp(x *Type) Cmp {
 }
 
 // IsKind reports whether t is a Type of the specified kind.
-func (t *Type) IsKind(et EType) bool {
-       return t != nil && t.Etype == et
+func (t *Type) IsKind(et Kind) bool {
+       return t != nil && t.kind == et
 }
 
 func (t *Type) IsBoolean() bool {
-       return t.Etype == TBOOL
+       return t.kind == TBOOL
 }
 
-var unsignedEType = [...]EType{
+var unsignedEType = [...]Kind{
        TINT8:    TUINT8,
        TUINT8:   TUINT8,
        TINT16:   TUINT16,
@@ -1216,54 +1237,62 @@ var unsignedEType = [...]EType{
 // ToUnsigned returns the unsigned equivalent of integer type t.
 func (t *Type) ToUnsigned() *Type {
        if !t.IsInteger() {
-               Fatalf("unsignedType(%v)", t)
+               base.Fatalf("unsignedType(%v)", t)
        }
-       return Types[unsignedEType[t.Etype]]
+       return Types[unsignedEType[t.kind]]
 }
 
 func (t *Type) IsInteger() bool {
-       switch t.Etype {
+       switch t.kind {
        case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR:
                return true
        }
-       return false
+       return t == UntypedInt || t == UntypedRune
 }
 
 func (t *Type) IsSigned() bool {
-       switch t.Etype {
+       switch t.kind {
        case TINT8, TINT16, TINT32, TINT64, TINT:
                return true
        }
        return false
 }
 
+func (t *Type) IsUnsigned() bool {
+       switch t.kind {
+       case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR:
+               return true
+       }
+       return false
+}
+
 func (t *Type) IsFloat() bool {
-       return t.Etype == TFLOAT32 || t.Etype == TFLOAT64
+       return t.kind == TFLOAT32 || t.kind == TFLOAT64 || t == UntypedFloat
 }
 
 func (t *Type) IsComplex() bool {
-       return t.Etype == TCOMPLEX64 || t.Etype == TCOMPLEX128
+       return t.kind == TCOMPLEX64 || t.kind == TCOMPLEX128 || t == UntypedComplex
 }
 
 // IsPtr reports whether t is a regular Go pointer type.
 // This does not include unsafe.Pointer.
 func (t *Type) IsPtr() bool {
-       return t.Etype == TPTR
+       return t.kind == TPTR
 }
 
 // IsPtrElem reports whether t is the element of a pointer (to t).
 func (t *Type) IsPtrElem() bool {
-       return t.Cache.ptr != nil
+       return t.cache.ptr != nil
 }
 
 // IsUnsafePtr reports whether t is an unsafe pointer.
 func (t *Type) IsUnsafePtr() bool {
-       return t.Etype == TUNSAFEPTR
+       return t.kind == TUNSAFEPTR
 }
 
 // IsUintptr reports whether t is an uintptr.
 func (t *Type) IsUintptr() bool {
-       return t.Etype == TUINTPTR
+       return t.kind == TUINTPTR
 }
 
 // IsPtrShaped reports whether t is represented by a single machine pointer.
@@ -1272,45 +1301,45 @@ func (t *Type) IsUintptr() bool {
 // that consist of a single pointer shaped type.
 // TODO(mdempsky): Should it? See golang.org/issue/15028.
 func (t *Type) IsPtrShaped() bool {
-       return t.Etype == TPTR || t.Etype == TUNSAFEPTR ||
-               t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC
+       return t.kind == TPTR || t.kind == TUNSAFEPTR ||
+               t.kind == TMAP || t.kind == TCHAN || t.kind == TFUNC
 }
 
 // HasNil reports whether the set of values determined by t includes nil.
 func (t *Type) HasNil() bool {
-       switch t.Etype {
-       case TCHAN, TFUNC, TINTER, TMAP, TPTR, TSLICE, TUNSAFEPTR:
+       switch t.kind {
+       case TCHAN, TFUNC, TINTER, TMAP, TNIL, TPTR, TSLICE, TUNSAFEPTR:
                return true
        }
        return false
 }
 
 func (t *Type) IsString() bool {
-       return t.Etype == TSTRING
+       return t.kind == TSTRING
 }
 
 func (t *Type) IsMap() bool {
-       return t.Etype == TMAP
+       return t.kind == TMAP
 }
 
 func (t *Type) IsChan() bool {
-       return t.Etype == TCHAN
+       return t.kind == TCHAN
 }
 
 func (t *Type) IsSlice() bool {
-       return t.Etype == TSLICE
+       return t.kind == TSLICE
 }
 
 func (t *Type) IsArray() bool {
-       return t.Etype == TARRAY
+       return t.kind == TARRAY
 }
 
 func (t *Type) IsStruct() bool {
-       return t.Etype == TSTRUCT
+       return t.kind == TSTRUCT
 }
 
 func (t *Type) IsInterface() bool {
-       return t.Etype == TINTER
+       return t.kind == TINTER
 }
 
 // IsEmptyInterface reports whether t is an empty interface type.
@@ -1318,6 +1347,20 @@ func (t *Type) IsEmptyInterface() bool {
        return t.IsInterface() && t.NumFields() == 0
 }
 
+// IsScalar reports whether 't' is a scalar Go type, e.g.
+// bool/int/float/complex. Note that struct and array types consisting
+// of a single scalar element are not considered scalar, likewise
+// pointer types are also not considered scalar.
+func (t *Type) IsScalar() bool {
+       switch t.kind {
+       case TBOOL, TINT8, TUINT8, TINT16, TUINT16, TINT32,
+               TUINT32, TINT64, TUINT64, TINT, TUINT,
+               TUINTPTR, TCOMPLEX64, TCOMPLEX128, TFLOAT32, TFLOAT64:
+               return true
+       }
+       return false
+}
+
 func (t *Type) PtrTo() *Type {
        return NewPtr(t)
 }
@@ -1326,7 +1369,7 @@ func (t *Type) NumFields() int {
        return t.Fields().Len()
 }
 func (t *Type) FieldType(i int) *Type {
-       if t.Etype == TTUPLE {
+       if t.kind == TTUPLE {
                switch i {
                case 0:
                        return t.Extra.(*Tuple).first
@@ -1336,7 +1379,7 @@ func (t *Type) FieldType(i int) *Type {
                        panic("bad tuple index")
                }
        }
-       if t.Etype == TRESULTS {
+       if t.kind == TRESULTS {
                return t.Extra.(*Results).Types[i]
        }
        return t.Field(i).Type
@@ -1367,10 +1410,10 @@ const (
 // (and their comprised elements) are excluded from the count.
 // struct { x, y [3]int } has six components; [10]struct{ x, y string } has twenty.
 func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
-       switch t.Etype {
+       switch t.kind {
        case TSTRUCT:
                if t.IsFuncArgStruct() {
-                       Fatalf("NumComponents func arg struct")
+                       base.Fatalf("NumComponents func arg struct")
                }
                var n int64
                for _, f := range t.FieldSlice() {
@@ -1390,10 +1433,10 @@ func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
 // if there is exactly one. Otherwise, it returns nil.
 // Components are counted as in NumComponents, including blank fields.
 func (t *Type) SoleComponent() *Type {
-       switch t.Etype {
+       switch t.kind {
        case TSTRUCT:
                if t.IsFuncArgStruct() {
-                       Fatalf("SoleComponent func arg struct")
+                       base.Fatalf("SoleComponent func arg struct")
                }
                if t.NumFields() != 1 {
                        return nil
@@ -1416,10 +1459,10 @@ func (t *Type) ChanDir() ChanDir {
 }
 
 func (t *Type) IsMemory() bool {
-       if t == TypeMem || t.Etype == TTUPLE && t.Extra.(*Tuple).second == TypeMem {
+       if t == TypeMem || t.kind == TTUPLE && t.Extra.(*Tuple).second == TypeMem {
                return true
        }
-       if t.Etype == TRESULTS {
+       if t.kind == TRESULTS {
                if types := t.Extra.(*Results).Types; len(types) > 0 && types[len(types)-1] == TypeMem {
                        return true
                }
@@ -1428,8 +1471,8 @@ func (t *Type) IsMemory() bool {
 }
 func (t *Type) IsFlags() bool   { return t == TypeFlags }
 func (t *Type) IsVoid() bool    { return t == TypeVoid }
-func (t *Type) IsTuple() bool   { return t.Etype == TTUPLE }
-func (t *Type) IsResults() bool { return t.Etype == TRESULTS }
+func (t *Type) IsTuple() bool   { return t.kind == TTUPLE }
+func (t *Type) IsResults() bool { return t.kind == TRESULTS }
 
 // IsUntyped reports whether t is an untyped type.
 func (t *Type) IsUntyped() bool {
@@ -1439,7 +1482,7 @@ func (t *Type) IsUntyped() bool {
        if t == UntypedString || t == UntypedBool {
                return true
        }
-       switch t.Etype {
+       switch t.kind {
        case TNIL, TIDEAL:
                return true
        }
@@ -1449,7 +1492,7 @@ func (t *Type) IsUntyped() bool {
 // HasPointers reports whether t contains a heap pointer.
 // Note that this function ignores pointers to go:notinheap types.
 func (t *Type) HasPointers() bool {
-       switch t.Etype {
+       switch t.kind {
        case TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64,
                TUINT64, TUINTPTR, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TBOOL, TSSA:
                return false
@@ -1488,10 +1531,6 @@ func (t *Type) HasPointers() bool {
        return true
 }
 
-func (t *Type) Symbol() *obj.LSym {
-       return TypeLinkSym(t)
-}
-
 // Tie returns 'T' if t is a concrete type,
 // 'I' if t is an interface type, and 'E' if t is an empty interface type.
 // It is used to build calls to the conv* and assert* runtime routines.
@@ -1523,3 +1562,333 @@ var (
        TypeVoid    = newSSA("void")
        TypeInt128  = newSSA("int128")
 )
+
+// NewNamed returns a new named type for the given type name.
+func NewNamed(obj Object) *Type {
+       t := New(TFORW)
+       t.sym = obj.Sym()
+       t.nod = obj
+       return t
+}
+
+// Obj returns the type name for the named type t.
+func (t *Type) Obj() Object {
+       if t.sym != nil {
+               return t.nod
+       }
+       return nil
+}
+
+// SetUnderlying sets the underlying type.
+func (t *Type) SetUnderlying(underlying *Type) {
+       if underlying.kind == TFORW {
+               // This type isn't computed yet; when it is, update n.
+               underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
+               return
+       }
+
+       ft := t.ForwardType()
+
+       // TODO(mdempsky): Fix Type rekinding.
+       t.kind = underlying.kind
+       t.Extra = underlying.Extra
+       t.Width = underlying.Width
+       t.Align = underlying.Align
+       t.underlying = underlying.underlying
+
+       if underlying.NotInHeap() {
+               t.SetNotInHeap(true)
+       }
+       if underlying.Broke() {
+               t.SetBroke(true)
+       }
+
+       // spec: "The declared type does not inherit any methods bound
+       // to the existing type, but the method set of an interface
+       // type [...] remains unchanged."
+       if t.IsInterface() {
+               t.methods = underlying.methods
+               t.allMethods = underlying.allMethods
+       }
+
+       // Update types waiting on this type.
+       for _, w := range ft.Copyto {
+               w.SetUnderlying(t)
+       }
+
+       // Double-check use of type as embedded type.
+       if ft.Embedlineno.IsKnown() {
+               if t.IsPtr() || t.IsUnsafePtr() {
+                       base.ErrorfAt(ft.Embedlineno, "embedded type cannot be a pointer")
+               }
+       }
+}
+
+// NewBasic returns a new basic type of the given kind.
+func NewBasic(kind Kind, obj Object) *Type {
+       t := New(kind)
+       t.sym = obj.Sym()
+       t.nod = obj
+       return t
+}
+
+// NewInterface returns a new interface for the given methods and
+// embedded types. Embedded types are specified as fields with no Sym.
+func NewInterface(pkg *Pkg, methods []*Field) *Type {
+       t := New(TINTER)
+       t.SetInterface(methods)
+       if anyBroke(methods) {
+               t.SetBroke(true)
+       }
+       t.Extra.(*Interface).pkg = pkg
+       return t
+}
+
+// NewSignature returns a new function type for the given receiver,
+// parameters, and results, any of which may be nil.
+func NewSignature(pkg *Pkg, recv *Field, params, results []*Field) *Type {
+       var recvs []*Field
+       if recv != nil {
+               recvs = []*Field{recv}
+       }
+
+       t := New(TFUNC)
+       ft := t.FuncType()
+
+       funargs := func(fields []*Field, funarg Funarg) *Type {
+               s := NewStruct(NoPkg, fields)
+               s.StructType().Funarg = funarg
+               if s.Broke() {
+                       t.SetBroke(true)
+               }
+               return s
+       }
+
+       ft.Receiver = funargs(recvs, FunargRcvr)
+       ft.Params = funargs(params, FunargParams)
+       ft.Results = funargs(results, FunargResults)
+       ft.pkg = pkg
+
+       return t
+}
+
+// NewStruct returns a new struct with the given fields.
+func NewStruct(pkg *Pkg, fields []*Field) *Type {
+       t := New(TSTRUCT)
+       t.SetFields(fields)
+       if anyBroke(fields) {
+               t.SetBroke(true)
+       }
+       t.Extra.(*Struct).pkg = pkg
+       return t
+}
+
+func anyBroke(fields []*Field) bool {
+       for _, f := range fields {
+               if f.Broke() {
+                       return true
+               }
+       }
+       return false
+}
+
+var (
+       IsInt     [NTYPE]bool
+       IsFloat   [NTYPE]bool
+       IsComplex [NTYPE]bool
+       IsSimple  [NTYPE]bool
+)
+
+var IsOrdered [NTYPE]bool
+
+// IsReflexive reports whether t has a reflexive equality operator.
+// That is, if x==x for all x of type t.
+func IsReflexive(t *Type) bool {
+       switch t.Kind() {
+       case TBOOL,
+               TINT,
+               TUINT,
+               TINT8,
+               TUINT8,
+               TINT16,
+               TUINT16,
+               TINT32,
+               TUINT32,
+               TINT64,
+               TUINT64,
+               TUINTPTR,
+               TPTR,
+               TUNSAFEPTR,
+               TSTRING,
+               TCHAN:
+               return true
+
+       case TFLOAT32,
+               TFLOAT64,
+               TCOMPLEX64,
+               TCOMPLEX128,
+               TINTER:
+               return false
+
+       case TARRAY:
+               return IsReflexive(t.Elem())
+
+       case TSTRUCT:
+               for _, t1 := range t.Fields().Slice() {
+                       if !IsReflexive(t1.Type) {
+                               return false
+                       }
+               }
+               return true
+
+       default:
+               base.Fatalf("bad type for map key: %v", t)
+               return false
+       }
+}
+
+// Can this type be stored directly in an interface word?
+// Yes, if the representation is a single pointer.
+func IsDirectIface(t *Type) bool {
+       if t.Broke() {
+               return false
+       }
+
+       switch t.Kind() {
+       case TPTR:
+               // Pointers to notinheap types must be stored indirectly. See issue 42076.
+               return !t.Elem().NotInHeap()
+       case TCHAN,
+               TMAP,
+               TFUNC,
+               TUNSAFEPTR:
+               return true
+
+       case TARRAY:
+               // Array of 1 direct iface type can be direct.
+               return t.NumElem() == 1 && IsDirectIface(t.Elem())
+
+       case TSTRUCT:
+               // Struct with 1 field of direct iface type can be direct.
+               return t.NumFields() == 1 && IsDirectIface(t.Field(0).Type)
+       }
+
+       return false
+}
+
+// IsInterfaceMethod reports whether (field) m is
+// an interface method. Such methods have the
+// special receiver type types.FakeRecvType().
+func IsInterfaceMethod(f *Type) bool {
+       return f.Recv().Type == FakeRecvType()
+}
+
+// IsMethodApplicable reports whether method m can be called on a
+// value of type t. This is necessary because we compute a single
+// method set for both T and *T, but some *T methods are not
+// applicable to T receivers.
+func IsMethodApplicable(t *Type, m *Field) bool {
+       return t.IsPtr() || !m.Type.Recv().Type.IsPtr() || IsInterfaceMethod(m.Type) || m.Embedded == 2
+}
+
+// IsRuntimePkg reports whether p is package runtime.
+func IsRuntimePkg(p *Pkg) bool {
+       if base.Flag.CompilingRuntime && p == LocalPkg {
+               return true
+       }
+       return p.Path == "runtime"
+}
+
+// IsReflectPkg reports whether p is package reflect.
+func IsReflectPkg(p *Pkg) bool {
+       if p == LocalPkg {
+               return base.Ctxt.Pkgpath == "reflect"
+       }
+       return p.Path == "reflect"
+}
+
+// ReceiverBaseType returns the underlying type, if any,
+// that owns methods with receiver parameter t.
+// The result is either a named type or an anonymous struct.
+func ReceiverBaseType(t *Type) *Type {
+       if t == nil {
+               return nil
+       }
+
+       // Strip away pointer if it's there.
+       if t.IsPtr() {
+               if t.Sym() != nil {
+                       return nil
+               }
+               t = t.Elem()
+               if t == nil {
+                       return nil
+               }
+       }
+
+       // Must be a named type or anonymous struct.
+       if t.Sym() == nil && !t.IsStruct() {
+               return nil
+       }
+
+       // Check types.
+       if IsSimple[t.Kind()] {
+               return t
+       }
+       switch t.Kind() {
+       case TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRING, TSTRUCT:
+               return t
+       }
+       return nil
+}
+
+func FloatForComplex(t *Type) *Type {
+       switch t.Kind() {
+       case TCOMPLEX64:
+               return Types[TFLOAT32]
+       case TCOMPLEX128:
+               return Types[TFLOAT64]
+       }
+       base.Fatalf("unexpected type: %v", t)
+       return nil
+}
+
+func ComplexForFloat(t *Type) *Type {
+       switch t.Kind() {
+       case TFLOAT32:
+               return Types[TCOMPLEX64]
+       case TFLOAT64:
+               return Types[TCOMPLEX128]
+       }
+       base.Fatalf("unexpected type: %v", t)
+       return nil
+}
+
+func TypeSym(t *Type) *Sym {
+       return TypeSymLookup(TypeSymName(t))
+}
+
+func TypeSymLookup(name string) *Sym {
+       typepkgmu.Lock()
+       s := typepkg.Lookup(name)
+       typepkgmu.Unlock()
+       return s
+}
+
+func TypeSymName(t *Type) string {
+       name := t.ShortString()
+       // Use a separate symbol name for Noalg types for #17752.
+       if TypeHasNoAlg(t) {
+               name = "noalg." + name
+       }
+       return name
+}
+
+// Fake package for runtime type info (headers)
+// Don't access directly, use typeLookup below.
+var (
+       typepkgmu sync.Mutex // protects typepkg lookups
+       typepkg   = NewPkg("type", "type")
+)
+
+var SimType [NTYPE]Kind

diff --git a/src/cmd/compile/internal/types/utils.go b/src/cmd/compile/internal/types/utils.go
index e8b107381805450e39c2d9d5d71db65381b1649b..f9f629ca3ea6cf5bd878387b6cab1a7892e1685b 100644 (file)
--- a/src/cmd/compile/internal/types/utils.go
+++ b/src/cmd/compile/internal/types/utils.go
@@ -4,64 +4,8 @@
 
 package types
 
-import (
-       "cmd/internal/obj"
-       "fmt"
-)
-
 const BADWIDTH = -1000000000
 
-// The following variables must be initialized early by the frontend.
-// They are here to break import cycles.
-// TODO(gri) eliminate these dependencies.
-var (
-       Widthptr    int
-       Dowidth     func(*Type)
-       Fatalf      func(string, ...interface{})
-       Sconv       func(*Sym, int, int) string       // orig: func sconv(s *Sym, flag FmtFlag, mode fmtMode) string
-       Tconv       func(*Type, int, int) string      // orig: func tconv(t *Type, flag FmtFlag, mode fmtMode) string
-       FormatSym   func(*Sym, fmt.State, rune, int)  // orig: func symFormat(sym *Sym, s fmt.State, verb rune, mode fmtMode)
-       FormatType  func(*Type, fmt.State, rune, int) // orig: func typeFormat(t *Type, s fmt.State, verb rune, mode fmtMode)
-       TypeLinkSym func(*Type) *obj.LSym
-       Ctxt        *obj.Link
-
-       FmtLeft     int
-       FmtUnsigned int
-       FErr        int
-)
-
-func (s *Sym) String() string {
-       return Sconv(s, 0, FErr)
-}
-
-func (sym *Sym) Format(s fmt.State, verb rune) {
-       FormatSym(sym, s, verb, FErr)
-}
-
-func (t *Type) String() string {
-       // The implementation of tconv (including typefmt and fldconv)
-       // must handle recursive types correctly.
-       return Tconv(t, 0, FErr)
-}
-
-// ShortString generates a short description of t.
-// It is used in autogenerated method names, reflection,
-// and itab names.
-func (t *Type) ShortString() string {
-       return Tconv(t, FmtLeft, FErr)
-}
-
-// LongString generates a complete description of t.
-// It is useful for reflection,
-// or when a unique fingerprint or hash of a type is required.
-func (t *Type) LongString() string {
-       return Tconv(t, FmtLeft|FmtUnsigned, FErr)
-}
-
-func (t *Type) Format(s fmt.State, verb rune) {
-       FormatType(t, s, verb, FErr)
-}
-
 type bitset8 uint8
 
 func (f *bitset8) set(mask uint8, b bool) {

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
new file mode 100644 (file)
index 0000000..230b544
--- /dev/null
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -0,0 +1,719 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// walkAssign walks an OAS (AssignExpr) or OASOP (AssignOpExpr) node.
+func walkAssign(init *ir.Nodes, n ir.Node) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+
+       var left, right ir.Node
+       switch n.Op() {
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               left, right = n.X, n.Y
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               left, right = n.X, n.Y
+       }
+
+       // Recognize m[k] = append(m[k], ...) so we can reuse
+       // the mapassign call.
+       var mapAppend *ir.CallExpr
+       if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
+               left := left.(*ir.IndexExpr)
+               mapAppend = right.(*ir.CallExpr)
+               if !ir.SameSafeExpr(left, mapAppend.Args[0]) {
+                       base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args[0])
+               }
+       }
+
+       left = walkExpr(left, init)
+       left = safeExpr(left, init)
+       if mapAppend != nil {
+               mapAppend.Args[0] = left
+       }
+
+       if n.Op() == ir.OASOP {
+               // Rewrite x op= y into x = x op y.
+               n = ir.NewAssignStmt(base.Pos, left, typecheck.Expr(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right)))
+       } else {
+               n.(*ir.AssignStmt).X = left
+       }
+       as := n.(*ir.AssignStmt)
+
+       if oaslit(as, init) {
+               return ir.NewBlockStmt(as.Pos(), nil)
+       }
+
+       if as.Y == nil {
+               // TODO(austin): Check all "implicit zeroing"
+               return as
+       }
+
+       if !base.Flag.Cfg.Instrumenting && ir.IsZero(as.Y) {
+               return as
+       }
+
+       switch as.Y.Op() {
+       default:
+               as.Y = walkExpr(as.Y, init)
+
+       case ir.ORECV:
+               // x = <-c; as.Left is x, as.Right.Left is c.
+               // order.stmt made sure x is addressable.
+               recv := as.Y.(*ir.UnaryExpr)
+               recv.X = walkExpr(recv.X, init)
+
+               n1 := typecheck.NodAddr(as.X)
+               r := recv.X // the channel
+               return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
+
+       case ir.OAPPEND:
+               // x = append(...)
+               call := as.Y.(*ir.CallExpr)
+               if call.Type().Elem().NotInHeap() {
+                       base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
+               }
+               var r ir.Node
+               switch {
+               case isAppendOfMake(call):
+                       // x = append(y, make([]T, y)...)
+                       r = extendSlice(call, init)
+               case call.IsDDD:
+                       r = appendSlice(call, init) // also works for append(slice, string).
+               default:
+                       r = walkAppend(call, init, as)
+               }
+               as.Y = r
+               if r.Op() == ir.OAPPEND {
+                       // Left in place for back end.
+                       // Do not add a new write barrier.
+                       // Set up address of type for back end.
+                       r.(*ir.CallExpr).X = reflectdata.TypePtr(r.Type().Elem())
+                       return as
+               }
+               // Otherwise, lowered for race detector.
+               // Treat as ordinary assignment.
+       }
+
+       if as.X != nil && as.Y != nil {
+               return convas(as, init)
+       }
+       return as
+}
+
+// walkAssignDotType walks an OAS2DOTTYPE node.
+func walkAssignDotType(n *ir.AssignListStmt, init *ir.Nodes) ir.Node {
+       walkExprListSafe(n.Lhs, init)
+       n.Rhs[0] = walkExpr(n.Rhs[0], init)
+       return n
+}
+
+// walkAssignFunc walks an OAS2FUNC node.
+func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+
+       r := n.Rhs[0]
+       walkExprListSafe(n.Lhs, init)
+       r = walkExpr(r, init)
+
+       if ir.IsIntrinsicCall(r.(*ir.CallExpr)) {
+               n.Rhs = []ir.Node{r}
+               return n
+       }
+       init.Append(r)
+
+       ll := ascompatet(n.Lhs, r.Type())
+       return ir.NewBlockStmt(src.NoXPos, ll)
+}
+
+// walkAssignList walks an OAS2 node.
+func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+       return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs))
+}
+
+// walkAssignMapRead walks an OAS2MAPR node.
+func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+
+       r := n.Rhs[0].(*ir.IndexExpr)
+       walkExprListSafe(n.Lhs, init)
+       r.X = walkExpr(r.X, init)
+       r.Index = walkExpr(r.Index, init)
+       t := r.X.Type()
+
+       fast := mapfast(t)
+       var key ir.Node
+       if fast != mapslow {
+               // fast versions take key by value
+               key = r.Index
+       } else {
+               // standard version takes key by reference
+               // order.expr made sure key is addressable.
+               key = typecheck.NodAddr(r.Index)
+       }
+
+       // from:
+       //   a,b = m[i]
+       // to:
+       //   var,b = mapaccess2*(t, m, i)
+       //   a = *var
+       a := n.Lhs[0]
+
+       var call *ir.CallExpr
+       if w := t.Elem().Width; w <= zeroValSize {
+               fn := mapfn(mapaccess2[fast], t)
+               call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
+       } else {
+               fn := mapfn("mapaccess2_fat", t)
+               z := reflectdata.ZeroAddr(w)
+               call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
+       }
+
+       // mapaccess2* returns a typed bool, but due to spec changes,
+       // the boolean result of i.(T) is now untyped so we make it the
+       // same type as the variable on the lhs.
+       if ok := n.Lhs[1]; !ir.IsBlank(ok) && ok.Type().IsBoolean() {
+               call.Type().Field(1).Type = ok.Type()
+       }
+       n.Rhs = []ir.Node{call}
+       n.SetOp(ir.OAS2FUNC)
+
+       // don't generate a = *var if a is _
+       if ir.IsBlank(a) {
+               return walkExpr(typecheck.Stmt(n), init)
+       }
+
+       var_ := typecheck.Temp(types.NewPtr(t.Elem()))
+       var_.SetTypecheck(1)
+       var_.MarkNonNil() // mapaccess always returns a non-nil pointer
+
+       n.Lhs[0] = var_
+       init.Append(walkExpr(n, init))
+
+       as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
+       return walkExpr(typecheck.Stmt(as), init)
+}
+
+// walkAssignRecv walks an OAS2RECV node.
+func walkAssignRecv(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+
+       r := n.Rhs[0].(*ir.UnaryExpr) // recv
+       walkExprListSafe(n.Lhs, init)
+       r.X = walkExpr(r.X, init)
+       var n1 ir.Node
+       if ir.IsBlank(n.Lhs[0]) {
+               n1 = typecheck.NodNil()
+       } else {
+               n1 = typecheck.NodAddr(n.Lhs[0])
+       }
+       fn := chanfn("chanrecv2", 2, r.X.Type())
+       ok := n.Lhs[1]
+       call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
+       return typecheck.Stmt(ir.NewAssignStmt(base.Pos, ok, call))
+}
+
+// walkReturn walks an ORETURN node.
+func walkReturn(n *ir.ReturnStmt) ir.Node {
+       fn := ir.CurFunc
+
+       fn.NumReturns++
+       if len(n.Results) == 0 {
+               return n
+       }
+
+       results := fn.Type().Results().FieldSlice()
+       dsts := make([]ir.Node, len(results))
+       for i, v := range results {
+               // TODO(mdempsky): typecheck should have already checked the result variables.
+               dsts[i] = typecheck.AssignExpr(v.Nname.(*ir.Name))
+       }
+
+       n.Results = ascompatee(n.Op(), dsts, n.Results)
+       return n
+}
+
+// check assign type list to
+// an expression list. called in
+//     expr-list = func()
+func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
+       if len(nl) != nr.NumFields() {
+               base.Fatalf("ascompatet: assignment count mismatch: %d = %d", len(nl), nr.NumFields())
+       }
+
+       var nn ir.Nodes
+       for i, l := range nl {
+               if ir.IsBlank(l) {
+                       continue
+               }
+               r := nr.Field(i)
+
+               // Order should have created autotemps of the appropriate type for
+               // us to store results into.
+               if tmp, ok := l.(*ir.Name); !ok || !tmp.AutoTemp() || !types.Identical(tmp.Type(), r.Type) {
+                       base.FatalfAt(l.Pos(), "assigning %v to %+v", r.Type, l)
+               }
+
+               res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
+               res.Offset = base.Ctxt.FixedFrameSize() + r.Offset
+               res.SetType(r.Type)
+               res.SetTypecheck(1)
+
+               nn.Append(ir.NewAssignStmt(base.Pos, l, res))
+       }
+       return nn
+}
+
+// check assign expression list to
+// an expression list. called in
+//     expr-list = expr-list
+func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
+       // cannot happen: should have been rejected during type checking
+       if len(nl) != len(nr) {
+               base.Fatalf("assignment operands mismatch: %+v / %+v", ir.Nodes(nl), ir.Nodes(nr))
+       }
+
+       var assigned ir.NameSet
+       var memWrite, deferResultWrite bool
+
+       // affected reports whether expression n could be affected by
+       // the assignments applied so far.
+       affected := func(n ir.Node) bool {
+               if deferResultWrite {
+                       return true
+               }
+               return ir.Any(n, func(n ir.Node) bool {
+                       if n.Op() == ir.ONAME && assigned.Has(n.(*ir.Name)) {
+                               return true
+                       }
+                       if memWrite && readsMemory(n) {
+                               return true
+                       }
+                       return false
+               })
+       }
+
+       // If a needed expression may be affected by an
+       // earlier assignment, make an early copy of that
+       // expression and use the copy instead.
+       var early ir.Nodes
+       save := func(np *ir.Node) {
+               if n := *np; affected(n) {
+                       *np = copyExpr(n, n.Type(), &early)
+               }
+       }
+
+       var late ir.Nodes
+       for i, lorig := range nl {
+               l, r := lorig, nr[i]
+
+               // Do not generate 'x = x' during return. See issue 4014.
+               if op == ir.ORETURN && ir.SameSafeExpr(l, r) {
+                       continue
+               }
+
+               // Save subexpressions needed on left side.
+               // Drill through non-dereferences.
+               for {
+                       switch ll := l.(type) {
+                       case *ir.IndexExpr:
+                               if ll.X.Type().IsArray() {
+                                       save(&ll.Index)
+                                       l = ll.X
+                                       continue
+                               }
+                       case *ir.ParenExpr:
+                               l = ll.X
+                               continue
+                       case *ir.SelectorExpr:
+                               if ll.Op() == ir.ODOT {
+                                       l = ll.X
+                                       continue
+                               }
+                       }
+                       break
+               }
+
+               var name *ir.Name
+               switch l.Op() {
+               default:
+                       base.Fatalf("unexpected lvalue %v", l.Op())
+               case ir.ONAME:
+                       name = l.(*ir.Name)
+               case ir.OINDEX, ir.OINDEXMAP:
+                       l := l.(*ir.IndexExpr)
+                       save(&l.X)
+                       save(&l.Index)
+               case ir.ODEREF:
+                       l := l.(*ir.StarExpr)
+                       save(&l.X)
+               case ir.ODOTPTR:
+                       l := l.(*ir.SelectorExpr)
+                       save(&l.X)
+               }
+
+               // Save expression on right side.
+               save(&r)
+
+               appendWalkStmt(&late, convas(ir.NewAssignStmt(base.Pos, lorig, r), &late))
+
+               // Check for reasons why we may need to compute later expressions
+               // before this assignment happens.
+
+               if name == nil {
+                       // Not a direct assignment to a declared variable.
+                       // Conservatively assume any memory access might alias.
+                       memWrite = true
+                       continue
+               }
+
+               if name.Class == ir.PPARAMOUT && ir.CurFunc.HasDefer() {
+                       // Assignments to a result parameter in a function with defers
+                       // becomes visible early if evaluation of any later expression
+                       // panics (#43835).
+                       deferResultWrite = true
+                       continue
+               }
+
+               if sym := types.OrigSym(name.Sym()); sym == nil || sym.IsBlank() {
+                       // We can ignore assignments to blank or anonymous result parameters.
+                       // These can't appear in expressions anyway.
+                       continue
+               }
+
+               if name.Addrtaken() || !name.OnStack() {
+                       // Global variable, heap escaped, or just addrtaken.
+                       // Conservatively assume any memory access might alias.
+                       memWrite = true
+                       continue
+               }
+
+               // Local, non-addrtaken variable.
+               // Assignments can only alias with direct uses of this variable.
+               assigned.Add(name)
+       }
+
+       early.Append(late.Take()...)
+       return early
+}
+
+// readsMemory reports whether the evaluation n directly reads from
+// memory that might be written to indirectly.
+func readsMemory(n ir.Node) bool {
+       switch n.Op() {
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               if n.Class == ir.PFUNC {
+                       return false
+               }
+               return n.Addrtaken() || !n.OnStack()
+
+       case ir.OADD,
+               ir.OAND,
+               ir.OANDAND,
+               ir.OANDNOT,
+               ir.OBITNOT,
+               ir.OCONV,
+               ir.OCONVIFACE,
+               ir.OCONVNOP,
+               ir.ODIV,
+               ir.ODOT,
+               ir.ODOTTYPE,
+               ir.OLITERAL,
+               ir.OLSH,
+               ir.OMOD,
+               ir.OMUL,
+               ir.ONEG,
+               ir.ONIL,
+               ir.OOR,
+               ir.OOROR,
+               ir.OPAREN,
+               ir.OPLUS,
+               ir.ORSH,
+               ir.OSUB,
+               ir.OXOR:
+               return false
+       }
+
+       // Be conservative.
+       return true
+}
+
+// expand append(l1, l2...) to
+//   init {
+//     s := l1
+//     n := len(s) + len(l2)
+//     // Compare as uint so growslice can panic on overflow.
+//     if uint(n) > uint(cap(s)) {
+//       s = growslice(s, n)
+//     }
+//     s = s[:n]
+//     memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+//   }
+//   s
+//
+// l2 is allowed to be a string.
+func appendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+       walkAppendArgs(n, init)
+
+       l1 := n.Args[0]
+       l2 := n.Args[1]
+       l2 = cheapExpr(l2, init)
+       n.Args[1] = l2
+
+       var nodes ir.Nodes
+
+       // var s []T
+       s := typecheck.Temp(l1.Type())
+       nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
+
+       elemtype := s.Type().Elem()
+
+       // n := len(s) + len(l2)
+       nn := typecheck.Temp(types.Types[types.TINT])
+       nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
+
+       // if uint(n) > uint(cap(s))
+       nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+       nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+       scapuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+       nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint)
+
+       // instantiate growslice(typ *type, []any, int) []any
+       fn := typecheck.LookupRuntime("growslice")
+       fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+
+       // s = growslice(T, s, n)
+       nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
+       nodes.Append(nif)
+
+       // s = s[:n]
+       nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, nil, nn, nil)
+       nt.SetBounded(true)
+       nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
+
+       var ncopy ir.Node
+       if elemtype.HasPointers() {
+               // copy(s[len(l1):], l2)
+               slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
+               slice.SetType(s.Type())
+
+               ir.CurFunc.SetWBPos(n.Pos())
+
+               // instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
+               fn := typecheck.LookupRuntime("typedslicecopy")
+               fn = typecheck.SubstArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
+               ptr1, len1 := backingArrayPtrLen(cheapExpr(slice, &nodes))
+               ptr2, len2 := backingArrayPtrLen(l2)
+               ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, reflectdata.TypePtr(elemtype), ptr1, len1, ptr2, len2)
+       } else if base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime {
+               // rely on runtime to instrument:
+               //  copy(s[len(l1):], l2)
+               // l2 can be a slice or string.
+               slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
+               slice.SetType(s.Type())
+
+               ptr1, len1 := backingArrayPtrLen(cheapExpr(slice, &nodes))
+               ptr2, len2 := backingArrayPtrLen(l2)
+
+               fn := typecheck.LookupRuntime("slicecopy")
+               fn = typecheck.SubstArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
+               ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, ir.NewInt(elemtype.Width))
+       } else {
+               // memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+               ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
+               ix.SetBounded(true)
+               addr := typecheck.NodAddr(ix)
+
+               sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
+
+               nwid := cheapExpr(typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
+               nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(elemtype.Width))
+
+               // instantiate func memmove(to *any, frm *any, length uintptr)
+               fn := typecheck.LookupRuntime("memmove")
+               fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+               ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
+       }
+       ln := append(nodes, ncopy)
+
+       typecheck.Stmts(ln)
+       walkStmtList(ln)
+       init.Append(ln...)
+       return s
+}
+
+// isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
+// isAppendOfMake assumes n has already been typechecked.
+func isAppendOfMake(n ir.Node) bool {
+       if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
+               return false
+       }
+
+       if n.Typecheck() == 0 {
+               base.Fatalf("missing typecheck: %+v", n)
+       }
+
+       if n.Op() != ir.OAPPEND {
+               return false
+       }
+       call := n.(*ir.CallExpr)
+       if !call.IsDDD || len(call.Args) != 2 || call.Args[1].Op() != ir.OMAKESLICE {
+               return false
+       }
+
+       mk := call.Args[1].(*ir.MakeExpr)
+       if mk.Cap != nil {
+               return false
+       }
+
+       // y must be either an integer constant or the largest possible positive value
+       // of variable y needs to fit into an uint.
+
+       // typecheck made sure that constant arguments to make are not negative and fit into an int.
+
+       // The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
+       y := mk.Len
+       if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
+               return false
+       }
+
+       return true
+}
+
+// extendSlice rewrites append(l1, make([]T, l2)...) to
+//   init {
+//     if l2 >= 0 { // Empty if block here for more meaningful node.SetLikely(true)
+//     } else {
+//       panicmakeslicelen()
+//     }
+//     s := l1
+//     n := len(s) + l2
+//     // Compare n and s as uint so growslice can panic on overflow of len(s) + l2.
+//     // cap is a positive int and n can become negative when len(s) + l2
+//     // overflows int. Interpreting n when negative as uint makes it larger
+//     // than cap(s). growslice will check the int n arg and panic if n is
+//     // negative. This prevents the overflow from being undetected.
+//     if uint(n) > uint(cap(s)) {
+//       s = growslice(T, s, n)
+//     }
+//     s = s[:n]
+//     lptr := &l1[0]
+//     sptr := &s[0]
+//     if lptr == sptr || !T.HasPointers() {
+//       // growslice did not clear the whole underlying array (or did not get called)
+//       hp := &s[len(l1)]
+//       hn := l2 * sizeof(T)
+//       memclr(hp, hn)
+//     }
+//   }
+//   s
+func extendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+       // isAppendOfMake made sure all possible positive values of l2 fit into an uint.
+       // The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
+       // check of l2 < 0 at runtime which is generated below.
+       l2 := typecheck.Conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
+       l2 = typecheck.Expr(l2)
+       n.Args[1] = l2 // walkAppendArgs expects l2 in n.List.Second().
+
+       walkAppendArgs(n, init)
+
+       l1 := n.Args[0]
+       l2 = n.Args[1] // re-read l2, as it may have been updated by walkAppendArgs
+
+       var nodes []ir.Node
+
+       // if l2 >= 0 (likely happens), do nothing
+       nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, ir.NewInt(0)), nil, nil)
+       nifneg.Likely = true
+
+       // else panicmakeslicelen()
+       nifneg.Else = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
+       nodes = append(nodes, nifneg)
+
+       // s := l1
+       s := typecheck.Temp(l1.Type())
+       nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
+
+       elemtype := s.Type().Elem()
+
+       // n := len(s) + l2
+       nn := typecheck.Temp(types.Types[types.TINT])
+       nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
+
+       // if uint(n) > uint(cap(s))
+       nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+       capuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+       nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
+
+       // instantiate growslice(typ *type, old []any, newcap int) []any
+       fn := typecheck.LookupRuntime("growslice")
+       fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+
+       // s = growslice(T, s, n)
+       nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
+       nodes = append(nodes, nif)
+
+       // s = s[:n]
+       nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, nil, nn, nil)
+       nt.SetBounded(true)
+       nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
+
+       // lptr := &l1[0]
+       l1ptr := typecheck.Temp(l1.Type().Elem().PtrTo())
+       tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
+       nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
+
+       // sptr := &s[0]
+       sptr := typecheck.Temp(elemtype.PtrTo())
+       tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+       nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
+
+       // hp := &s[len(l1)]
+       ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
+       ix.SetBounded(true)
+       hp := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
+
+       // hn := l2 * sizeof(elem(s))
+       hn := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
+
+       clrname := "memclrNoHeapPointers"
+       hasPointers := elemtype.HasPointers()
+       if hasPointers {
+               clrname = "memclrHasPointers"
+               ir.CurFunc.SetWBPos(n.Pos())
+       }
+
+       var clr ir.Nodes
+       clrfn := mkcall(clrname, nil, &clr, hp, hn)
+       clr.Append(clrfn)
+
+       if hasPointers {
+               // if l1ptr == sptr
+               nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
+               nifclr.Body = clr
+               nodes = append(nodes, nifclr)
+       } else {
+               nodes = append(nodes, clr...)
+       }
+
+       typecheck.Stmts(nodes)
+       walkStmtList(nodes)
+       init.Append(nodes...)
+       return s
+}

diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
new file mode 100644 (file)
index 0000000..97f9de9
--- /dev/null
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -0,0 +1,687 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "fmt"
+       "go/constant"
+       "go/token"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/escape"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+)
+
+// Rewrite append(src, x, y, z) so that any side effects in
+// x, y, z (including runtime panics) are evaluated in
+// initialization statements before the append.
+// For normal code generation, stop there and leave the
+// rest to cgen_append.
+//
+// For race detector, expand append(src, a [, b]* ) to
+//
+//   init {
+//     s := src
+//     const argc = len(args) - 1
+//     if cap(s) - len(s) < argc {
+//         s = growslice(s, len(s)+argc)
+//     }
+//     n := len(s)
+//     s = s[:n+argc]
+//     s[n] = a
+//     s[n+1] = b
+//     ...
+//   }
+//   s
+func walkAppend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
+       if !ir.SameSafeExpr(dst, n.Args[0]) {
+               n.Args[0] = safeExpr(n.Args[0], init)
+               n.Args[0] = walkExpr(n.Args[0], init)
+       }
+       walkExprListSafe(n.Args[1:], init)
+
+       nsrc := n.Args[0]
+
+       // walkExprListSafe will leave OINDEX (s[n]) alone if both s
+       // and n are name or literal, but those may index the slice we're
+       // modifying here. Fix explicitly.
+       // Using cheapExpr also makes sure that the evaluation
+       // of all arguments (and especially any panics) happen
+       // before we begin to modify the slice in a visible way.
+       ls := n.Args[1:]
+       for i, n := range ls {
+               n = cheapExpr(n, init)
+               if !types.Identical(n.Type(), nsrc.Type().Elem()) {
+                       n = typecheck.AssignConv(n, nsrc.Type().Elem(), "append")
+                       n = walkExpr(n, init)
+               }
+               ls[i] = n
+       }
+
+       argc := len(n.Args) - 1
+       if argc < 1 {
+               return nsrc
+       }
+
+       // General case, with no function calls left as arguments.
+       // Leave for gen, except that instrumentation requires old form.
+       if !base.Flag.Cfg.Instrumenting || base.Flag.CompilingRuntime {
+               return n
+       }
+
+       var l []ir.Node
+
+       ns := typecheck.Temp(nsrc.Type())
+       l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
+
+       na := ir.NewInt(int64(argc))                 // const argc
+       nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
+       nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
+
+       fn := typecheck.LookupRuntime("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
+       fn = typecheck.SubstArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
+
+       nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), reflectdata.TypePtr(ns.Type().Elem()), ns,
+               ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
+
+       l = append(l, nif)
+
+       nn := typecheck.Temp(types.Types[types.TINT])
+       l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
+
+       slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns, nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil) // ...s[:n+argc]
+       slice.SetBounded(true)
+       l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
+
+       ls = n.Args[1:]
+       for i, n := range ls {
+               ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
+               ix.SetBounded(true)
+               l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
+               if i+1 < len(ls) {
+                       l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, ir.NewInt(1)))) // n = n + 1
+               }
+       }
+
+       typecheck.Stmts(l)
+       walkStmtList(l)
+       init.Append(l...)
+       return ns
+}
+
+// walkClose walks an OCLOSE node.
+func walkClose(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+       // cannot use chanfn - closechan takes any, not chan any
+       fn := typecheck.LookupRuntime("closechan")
+       fn = typecheck.SubstArgTypes(fn, n.X.Type())
+       return mkcall1(fn, nil, init, n.X)
+}
+
+// Lower copy(a, b) to a memmove call or a runtime call.
+//
+// init {
+//   n := len(a)
+//   if n > len(b) { n = len(b) }
+//   if a.ptr != b.ptr { memmove(a.ptr, b.ptr, n*sizeof(elem(a))) }
+// }
+// n;
+//
+// Also works if b is a string.
+//
+func walkCopy(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
+       if n.X.Type().Elem().HasPointers() {
+               ir.CurFunc.SetWBPos(n.Pos())
+               fn := writebarrierfn("typedslicecopy", n.X.Type().Elem(), n.Y.Type().Elem())
+               n.X = cheapExpr(n.X, init)
+               ptrL, lenL := backingArrayPtrLen(n.X)
+               n.Y = cheapExpr(n.Y, init)
+               ptrR, lenR := backingArrayPtrLen(n.Y)
+               return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
+       }
+
+       if runtimecall {
+               // rely on runtime to instrument:
+               //  copy(n.Left, n.Right)
+               // n.Right can be a slice or string.
+
+               n.X = cheapExpr(n.X, init)
+               ptrL, lenL := backingArrayPtrLen(n.X)
+               n.Y = cheapExpr(n.Y, init)
+               ptrR, lenR := backingArrayPtrLen(n.Y)
+
+               fn := typecheck.LookupRuntime("slicecopy")
+               fn = typecheck.SubstArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
+
+               return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, ir.NewInt(n.X.Type().Elem().Width))
+       }
+
+       n.X = walkExpr(n.X, init)
+       n.Y = walkExpr(n.Y, init)
+       nl := typecheck.Temp(n.X.Type())
+       nr := typecheck.Temp(n.Y.Type())
+       var l []ir.Node
+       l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
+       l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))
+
+       nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
+       nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
+
+       nlen := typecheck.Temp(types.Types[types.TINT])
+
+       // n = len(to)
+       l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
+
+       // if n > len(frm) { n = len(frm) }
+       nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+
+       nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr))
+       nif.Body.Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
+       l = append(l, nif)
+
+       // if to.ptr != frm.ptr { memmove( ... ) }
+       ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
+       ne.Likely = true
+       l = append(l, ne)
+
+       fn := typecheck.LookupRuntime("memmove")
+       fn = typecheck.SubstArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
+       nwid := ir.Node(typecheck.Temp(types.Types[types.TUINTPTR]))
+       setwid := ir.NewAssignStmt(base.Pos, nwid, typecheck.Conv(nlen, types.Types[types.TUINTPTR]))
+       ne.Body.Append(setwid)
+       nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(nl.Type().Elem().Width))
+       call := mkcall1(fn, nil, init, nto, nfrm, nwid)
+       ne.Body.Append(call)
+
+       typecheck.Stmts(l)
+       walkStmtList(l)
+       init.Append(l...)
+       return nlen
+}
+
+// walkDelete walks an ODELETE node.
+func walkDelete(init *ir.Nodes, n *ir.CallExpr) ir.Node {
+       init.Append(ir.TakeInit(n)...)
+       map_ := n.Args[0]
+       key := n.Args[1]
+       map_ = walkExpr(map_, init)
+       key = walkExpr(key, init)
+
+       t := map_.Type()
+       fast := mapfast(t)
+       if fast == mapslow {
+               // order.stmt made sure key is addressable.
+               key = typecheck.NodAddr(key)
+       }
+       return mkcall1(mapfndel(mapdelete[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+}
+
+// walkLenCap walks an OLEN or OCAP node.
+func walkLenCap(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+       if isRuneCount(n) {
+               // Replace len([]rune(string)) with runtime.countrunes(string).
+               return mkcall("countrunes", n.Type(), init, typecheck.Conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
+       }
+
+       n.X = walkExpr(n.X, init)
+
+       // replace len(*[10]int) with 10.
+       // delayed until now to preserve side effects.
+       t := n.X.Type()
+
+       if t.IsPtr() {
+               t = t.Elem()
+       }
+       if t.IsArray() {
+               safeExpr(n.X, init)
+               con := typecheck.OrigInt(n, t.NumElem())
+               con.SetTypecheck(1)
+               return con
+       }
+       return n
+}
+
+// walkMakeChan walks an OMAKECHAN node.
+func walkMakeChan(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+       // When size fits into int, use makechan instead of
+       // makechan64, which is faster and shorter on 32 bit platforms.
+       size := n.Len
+       fnname := "makechan64"
+       argtype := types.Types[types.TINT64]
+
+       // Type checking guarantees that TIDEAL size is positive and fits in an int.
+       // The case of size overflow when converting TUINT or TUINTPTR to TINT
+       // will be handled by the negative range checks in makechan during runtime.
+       if size.Type().IsKind(types.TIDEAL) || size.Type().Size() <= types.Types[types.TUINT].Size() {
+               fnname = "makechan"
+               argtype = types.Types[types.TINT]
+       }
+
+       return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(size, argtype))
+}
+
+// walkMakeMap walks an OMAKEMAP node.
+func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+       t := n.Type()
+       hmapType := reflectdata.MapType(t)
+       hint := n.Len
+
+       // var h *hmap
+       var h ir.Node
+       if n.Esc() == ir.EscNone {
+               // Allocate hmap on stack.
+
+               // var hv hmap
+               // h = &hv
+               h = stackTempAddr(init, hmapType)
+
+               // Allocate one bucket pointed to by hmap.buckets on stack if hint
+               // is not larger than BUCKETSIZE. In case hint is larger than
+               // BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
+               // Maximum key and elem size is 128 bytes, larger objects
+               // are stored with an indirection. So max bucket size is 2048+eps.
+               if !ir.IsConst(hint, constant.Int) ||
+                       constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
+
+                       // In case hint is larger than BUCKETSIZE runtime.makemap
+                       // will allocate the buckets on the heap, see #20184
+                       //
+                       // if hint <= BUCKETSIZE {
+                       //     var bv bmap
+                       //     b = &bv
+                       //     h.buckets = b
+                       // }
+
+                       nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(reflectdata.BUCKETSIZE)), nil, nil)
+                       nif.Likely = true
+
+                       // var bv bmap
+                       // b = &bv
+                       b := stackTempAddr(&nif.Body, reflectdata.MapBucketType(t))
+
+                       // h.buckets = b
+                       bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
+                       na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
+                       nif.Body.Append(na)
+                       appendWalkStmt(init, nif)
+               }
+       }
+
+       if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
+               // Handling make(map[any]any) and
+               // make(map[any]any, hint) where hint <= BUCKETSIZE
+               // special allows for faster map initialization and
+               // improves binary size by using calls with fewer arguments.
+               // For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
+               // and no buckets will be allocated by makemap. Therefore,
+               // no buckets need to be allocated in this code path.
+               if n.Esc() == ir.EscNone {
+                       // Only need to initialize h.hash0 since
+                       // hmap h has been allocated on the stack already.
+                       // h.hash0 = fastrand()
+                       rand := mkcall("fastrand", types.Types[types.TUINT32], init)
+                       hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
+                       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
+                       return typecheck.ConvNop(h, t)
+               }
+               // Call runtime.makehmap to allocate an
+               // hmap on the heap and initialize hmap's hash0 field.
+               fn := typecheck.LookupRuntime("makemap_small")
+               fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
+               return mkcall1(fn, n.Type(), init)
+       }
+
+       if n.Esc() != ir.EscNone {
+               h = typecheck.NodNil()
+       }
+       // Map initialization with a variable or large hint is
+       // more complicated. We therefore generate a call to
+       // runtime.makemap to initialize hmap and allocate the
+       // map buckets.
+
+       // When hint fits into int, use makemap instead of
+       // makemap64, which is faster and shorter on 32 bit platforms.
+       fnname := "makemap64"
+       argtype := types.Types[types.TINT64]
+
+       // Type checking guarantees that TIDEAL hint is positive and fits in an int.
+       // See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
+       // The case of hint overflow when converting TUINT or TUINTPTR to TINT
+       // will be handled by the negative range checks in makemap during runtime.
+       if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
+               fnname = "makemap"
+               argtype = types.Types[types.TINT]
+       }
+
+       fn := typecheck.LookupRuntime(fnname)
+       fn = typecheck.SubstArgTypes(fn, hmapType, t.Key(), t.Elem())
+       return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(hint, argtype), h)
+}
+
+// walkMakeSlice walks an OMAKESLICE node.
+func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+       l := n.Len
+       r := n.Cap
+       if r == nil {
+               r = safeExpr(l, init)
+               l = r
+       }
+       t := n.Type()
+       if t.Elem().NotInHeap() {
+               base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+       }
+       if n.Esc() == ir.EscNone {
+               if why := escape.HeapAllocReason(n); why != "" {
+                       base.Fatalf("%v has EscNone, but %v", n, why)
+               }
+               // var arr [r]T
+               // n = arr[:l]
+               i := typecheck.IndexConst(r)
+               if i < 0 {
+                       base.Fatalf("walkExpr: invalid index %v", r)
+               }
+
+               // cap is constrained to [0,2^31) or [0,2^63) depending on whether
+               // we're in 32-bit or 64-bit systems. So it's safe to do:
+               //
+               // if uint64(len) > cap {
+               //     if len < 0 { panicmakeslicelen() }
+               //     panicmakeslicecap()
+               // }
+               nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, typecheck.Conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
+               niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
+               niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
+               nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
+               init.Append(typecheck.Stmt(nif))
+
+               t = types.NewArray(t.Elem(), i) // [r]T
+               var_ := typecheck.Temp(t)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))  // zero temp
+               r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_, nil, l, nil) // arr[:l]
+               // The conv is necessary in case n.Type is named.
+               return walkExpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
+       }
+
+       // n escapes; set up a call to makeslice.
+       // When len and cap can fit into int, use makeslice instead of
+       // makeslice64, which is faster and shorter on 32 bit platforms.
+
+       len, cap := l, r
+
+       fnname := "makeslice64"
+       argtype := types.Types[types.TINT64]
+
+       // Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
+       // The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
+       // will be handled by the negative range checks in makeslice during runtime.
+       if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
+               (cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
+               fnname = "makeslice"
+               argtype = types.Types[types.TINT]
+       }
+
+       m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+       m.SetType(t)
+
+       fn := typecheck.LookupRuntime(fnname)
+       m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
+       m.Ptr.MarkNonNil()
+       m.Len = typecheck.Conv(len, types.Types[types.TINT])
+       m.Cap = typecheck.Conv(cap, types.Types[types.TINT])
+       return walkExpr(typecheck.Expr(m), init)
+}
+
+// walkMakeSliceCopy walks an OMAKESLICECOPY node.
+func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+       if n.Esc() == ir.EscNone {
+               base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
+       }
+
+       t := n.Type()
+       if t.Elem().NotInHeap() {
+               base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+       }
+
+       length := typecheck.Conv(n.Len, types.Types[types.TINT])
+       copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Cap)
+       copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Cap)
+
+       if !t.Elem().HasPointers() && n.Bounded() {
+               // When len(to)==len(from) and elements have no pointers:
+               // replace make+copy with runtime.mallocgc+runtime.memmove.
+
+               // We do not check for overflow of len(to)*elem.Width here
+               // since len(from) is an existing checked slice capacity
+               // with same elem.Width for the from slice.
+               size := ir.NewBinaryExpr(base.Pos, ir.OMUL, typecheck.Conv(length, types.Types[types.TUINTPTR]), typecheck.Conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
+
+               // instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
+               fn := typecheck.LookupRuntime("mallocgc")
+               sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+               sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
+               sh.Ptr.MarkNonNil()
+               sh.Len = length
+               sh.Cap = length
+               sh.SetType(t)
+
+               s := typecheck.Temp(t)
+               r := typecheck.Stmt(ir.NewAssignStmt(base.Pos, s, sh))
+               r = walkExpr(r, init)
+               init.Append(r)
+
+               // instantiate memmove(to *any, frm *any, size uintptr)
+               fn = typecheck.LookupRuntime("memmove")
+               fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
+               ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
+               init.Append(walkExpr(typecheck.Stmt(ncopy), init))
+
+               return s
+       }
+       // Replace make+copy with runtime.makeslicecopy.
+       // instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
+       fn := typecheck.LookupRuntime("makeslicecopy")
+       s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+       s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
+       s.Ptr.MarkNonNil()
+       s.Len = length
+       s.Cap = length
+       s.SetType(t)
+       return walkExpr(typecheck.Expr(s), init)
+}
+
+// walkNew walks an ONEW node.
+func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+       t := n.Type().Elem()
+       if t.NotInHeap() {
+               base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
+       }
+       if n.Esc() == ir.EscNone {
+               if t.Size() >= ir.MaxImplicitStackVarSize {
+                       base.Fatalf("large ONEW with EscNone: %v", n)
+               }
+               return stackTempAddr(init, t)
+       }
+       types.CalcSize(t)
+       n.MarkNonNil()
+       return n
+}
+
+// generate code for print
+func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
+       // Hoist all the argument evaluation up before the lock.
+       walkExprListCheap(nn.Args, init)
+
+       // For println, add " " between elements and "\n" at the end.
+       if nn.Op() == ir.OPRINTN {
+               s := nn.Args
+               t := make([]ir.Node, 0, len(s)*2)
+               for i, n := range s {
+                       if i != 0 {
+                               t = append(t, ir.NewString(" "))
+                       }
+                       t = append(t, n)
+               }
+               t = append(t, ir.NewString("\n"))
+               nn.Args = t
+       }
+
+       // Collapse runs of constant strings.
+       s := nn.Args
+       t := make([]ir.Node, 0, len(s))
+       for i := 0; i < len(s); {
+               var strs []string
+               for i < len(s) && ir.IsConst(s[i], constant.String) {
+                       strs = append(strs, ir.StringVal(s[i]))
+                       i++
+               }
+               if len(strs) > 0 {
+                       t = append(t, ir.NewString(strings.Join(strs, "")))
+               }
+               if i < len(s) {
+                       t = append(t, s[i])
+                       i++
+               }
+       }
+       nn.Args = t
+
+       calls := []ir.Node{mkcall("printlock", nil, init)}
+       for i, n := range nn.Args {
+               if n.Op() == ir.OLITERAL {
+                       if n.Type() == types.UntypedRune {
+                               n = typecheck.DefaultLit(n, types.RuneType)
+                       }
+
+                       switch n.Val().Kind() {
+                       case constant.Int:
+                               n = typecheck.DefaultLit(n, types.Types[types.TINT64])
+
+                       case constant.Float:
+                               n = typecheck.DefaultLit(n, types.Types[types.TFLOAT64])
+                       }
+               }
+
+               if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
+                       n = typecheck.DefaultLit(n, types.Types[types.TINT64])
+               }
+               n = typecheck.DefaultLit(n, nil)
+               nn.Args[i] = n
+               if n.Type() == nil || n.Type().Kind() == types.TFORW {
+                       continue
+               }
+
+               var on *ir.Name
+               switch n.Type().Kind() {
+               case types.TINTER:
+                       if n.Type().IsEmptyInterface() {
+                               on = typecheck.LookupRuntime("printeface")
+                       } else {
+                               on = typecheck.LookupRuntime("printiface")
+                       }
+                       on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+               case types.TPTR:
+                       if n.Type().Elem().NotInHeap() {
+                               on = typecheck.LookupRuntime("printuintptr")
+                               n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+                               n.SetType(types.Types[types.TUNSAFEPTR])
+                               n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+                               n.SetType(types.Types[types.TUINTPTR])
+                               break
+                       }
+                       fallthrough
+               case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
+                       on = typecheck.LookupRuntime("printpointer")
+                       on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+               case types.TSLICE:
+                       on = typecheck.LookupRuntime("printslice")
+                       on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+               case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
+                       if types.IsRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
+                               on = typecheck.LookupRuntime("printhex")
+                       } else {
+                               on = typecheck.LookupRuntime("printuint")
+                       }
+               case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
+                       on = typecheck.LookupRuntime("printint")
+               case types.TFLOAT32, types.TFLOAT64:
+                       on = typecheck.LookupRuntime("printfloat")
+               case types.TCOMPLEX64, types.TCOMPLEX128:
+                       on = typecheck.LookupRuntime("printcomplex")
+               case types.TBOOL:
+                       on = typecheck.LookupRuntime("printbool")
+               case types.TSTRING:
+                       cs := ""
+                       if ir.IsConst(n, constant.String) {
+                               cs = ir.StringVal(n)
+                       }
+                       switch cs {
+                       case " ":
+                               on = typecheck.LookupRuntime("printsp")
+                       case "\n":
+                               on = typecheck.LookupRuntime("printnl")
+                       default:
+                               on = typecheck.LookupRuntime("printstring")
+                       }
+               default:
+                       badtype(ir.OPRINT, n.Type(), nil)
+                       continue
+               }
+
+               r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
+               if params := on.Type().Params().FieldSlice(); len(params) > 0 {
+                       t := params[0].Type
+                       if !types.Identical(t, n.Type()) {
+                               n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+                               n.SetType(t)
+                       }
+                       r.Args.Append(n)
+               }
+               calls = append(calls, r)
+       }
+
+       calls = append(calls, mkcall("printunlock", nil, init))
+
+       typecheck.Stmts(calls)
+       walkExprList(calls, init)
+
+       r := ir.NewBlockStmt(base.Pos, nil)
+       r.List = calls
+       return walkStmt(typecheck.Stmt(r))
+}
+
+func badtype(op ir.Op, tl, tr *types.Type) {
+       var s string
+       if tl != nil {
+               s += fmt.Sprintf("\n\t%v", tl)
+       }
+       if tr != nil {
+               s += fmt.Sprintf("\n\t%v", tr)
+       }
+
+       // common mistake: *struct and *interface.
+       if tl != nil && tr != nil && tl.IsPtr() && tr.IsPtr() {
+               if tl.Elem().IsStruct() && tr.Elem().IsInterface() {
+                       s += "\n\t(*struct vs *interface)"
+               } else if tl.Elem().IsInterface() && tr.Elem().IsStruct() {
+                       s += "\n\t(*interface vs *struct)"
+               }
+       }
+
+       base.Errorf("illegal types for operand: %v%s", op, s)
+}
+
+func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
+       fn := typecheck.LookupRuntime(name)
+       fn = typecheck.SubstArgTypes(fn, l, r)
+       return fn
+}
+
+// isRuneCount reports whether n is of the form len([]rune(string)).
+// These are optimized into a call to runtime.countrunes.
+func isRuneCount(n ir.Node) bool {
+       return base.Flag.N == 0 && !base.Flag.Cfg.Instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
+}

diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
new file mode 100644 (file)
index 0000000..1d1cbc2
--- /dev/null
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -0,0 +1,199 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// directClosureCall rewrites a direct call of a function literal into
+// a normal function call with closure variables passed as arguments.
+// This avoids allocation of a closure object.
+//
+// For illustration, the following call:
+//
+//     func(a int) {
+//             println(byval)
+//             byref++
+//     }(42)
+//
+// becomes:
+//
+//     func(byval int, &byref *int, a int) {
+//             println(byval)
+//             (*&byref)++
+//     }(byval, &byref, 42)
+func directClosureCall(n *ir.CallExpr) {
+       clo := n.X.(*ir.ClosureExpr)
+       clofn := clo.Func
+
+       if ir.IsTrivialClosure(clo) {
+               return // leave for walkClosure to handle
+       }
+
+       // We are going to insert captured variables before input args.
+       var params []*types.Field
+       var decls []*ir.Name
+       for _, v := range clofn.ClosureVars {
+               if !v.Byval() {
+                       // If v of type T is captured by reference,
+                       // we introduce function param &v *T
+                       // and v remains PAUTOHEAP with &v heapaddr
+                       // (accesses will implicitly deref &v).
+
+                       addr := ir.NewNameAt(clofn.Pos(), typecheck.Lookup("&"+v.Sym().Name))
+                       addr.Curfn = clofn
+                       addr.SetType(types.NewPtr(v.Type()))
+                       v.Heapaddr = addr
+                       v = addr
+               }
+
+               v.Class = ir.PPARAM
+               decls = append(decls, v)
+
+               fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
+               fld.Nname = v
+               params = append(params, fld)
+       }
+
+       // f is ONAME of the actual function.
+       f := clofn.Nname
+       typ := f.Type()
+
+       // Create new function type with parameters prepended, and
+       // then update type and declarations.
+       typ = types.NewSignature(typ.Pkg(), nil, append(params, typ.Params().FieldSlice()...), typ.Results().FieldSlice())
+       f.SetType(typ)
+       clofn.Dcl = append(decls, clofn.Dcl...)
+
+       // Rewrite call.
+       n.X = f
+       n.Args.Prepend(closureArgs(clo)...)
+
+       // Update the call expression's type. We need to do this
+       // because typecheck gave it the result type of the OCLOSURE
+       // node, but we only rewrote the ONAME node's type. Logically,
+       // they're the same, but the stack offsets probably changed.
+       if typ.NumResults() == 1 {
+               n.SetType(typ.Results().Field(0).Type)
+       } else {
+               n.SetType(typ.Results())
+       }
+
+       // Add to Closures for enqueueFunc. It's no longer a proper
+       // closure, but we may have already skipped over it in the
+       // functions list as a non-trivial closure, so this just
+       // ensures it's compiled.
+       ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)
+}
+
+func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
+       clofn := clo.Func
+
+       // If no closure vars, don't bother wrapping.
+       if ir.IsTrivialClosure(clo) {
+               if base.Debug.Closure > 0 {
+                       base.WarnfAt(clo.Pos(), "closure converted to global")
+               }
+               return clofn.Nname
+       }
+
+       // The closure is not trivial or directly called, so it's going to stay a closure.
+       ir.ClosureDebugRuntimeCheck(clo)
+       clofn.SetNeedctxt(true)
+       ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)
+
+       typ := typecheck.ClosureType(clo)
+
+       clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
+       clos.SetEsc(clo.Esc())
+       clos.List = append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, clofn.Nname)}, closureArgs(clo)...)
+
+       addr := typecheck.NodAddr(clos)
+       addr.SetEsc(clo.Esc())
+
+       // Force type conversion from *struct to the func type.
+       cfn := typecheck.ConvNop(addr, clo.Type())
+
+       // non-escaping temp to use, if any.
+       if x := clo.Prealloc; x != nil {
+               if !types.Identical(typ, x.Type()) {
+                       panic("closure type does not match order's assigned type")
+               }
+               addr.Prealloc = x
+               clo.Prealloc = nil
+       }
+
+       return walkExpr(cfn, init)
+}
+
+// closureArgs returns a slice of expressions that an be used to
+// initialize the given closure's free variables. These correspond
+// one-to-one with the variables in clo.Func.ClosureVars, and will be
+// either an ONAME node (if the variable is captured by value) or an
+// OADDR-of-ONAME node (if not).
+func closureArgs(clo *ir.ClosureExpr) []ir.Node {
+       fn := clo.Func
+
+       args := make([]ir.Node, len(fn.ClosureVars))
+       for i, v := range fn.ClosureVars {
+               var outer ir.Node
+               outer = v.Outer
+               if !v.Byval() {
+                       outer = typecheck.NodAddrAt(fn.Pos(), outer)
+               }
+               args[i] = typecheck.Expr(outer)
+       }
+       return args
+}
+
+func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
+       // Create closure in the form of a composite literal.
+       // For x.M with receiver (x) type T, the generated code looks like:
+       //
+       //      clos = &struct{F uintptr; R T}{T.M·f, x}
+       //
+       // Like walkClosure above.
+
+       if n.X.Type().IsInterface() {
+               // Trigger panic for method on nil interface now.
+               // Otherwise it happens in the wrapper and is confusing.
+               n.X = cheapExpr(n.X, init)
+               n.X = walkExpr(n.X, nil)
+
+               tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
+
+               c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
+               c.SetTypecheck(1)
+               init.Append(c)
+       }
+
+       typ := typecheck.PartialCallType(n)
+
+       clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
+       clos.SetEsc(n.Esc())
+       clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, typecheck.MethodValueWrapper(n).Nname), n.X}
+
+       addr := typecheck.NodAddr(clos)
+       addr.SetEsc(n.Esc())
+
+       // Force type conversion from *struct to the func type.
+       cfn := typecheck.ConvNop(addr, n.Type())
+
+       // non-escaping temp to use, if any.
+       if x := n.Prealloc; x != nil {
+               if !types.Identical(typ, x.Type()) {
+                       panic("partial call type does not match order's assigned type")
+               }
+               addr.Prealloc = x
+               n.Prealloc = nil
+       }
+
+       return walkExpr(cfn, init)
+}

diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
new file mode 100644 (file)
index 0000000..7c385c0
--- /dev/null
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -0,0 +1,507 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "encoding/binary"
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/sys"
+)
+
+// The result of walkCompare MUST be assigned back to n, e.g.
+//     n.Left = walkCompare(n.Left, init)
+func walkCompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+       if n.X.Type().IsInterface() && n.Y.Type().IsInterface() && n.X.Op() != ir.ONIL && n.Y.Op() != ir.ONIL {
+               return walkCompareInterface(n, init)
+       }
+
+       if n.X.Type().IsString() && n.Y.Type().IsString() {
+               return walkCompareString(n, init)
+       }
+
+       n.X = walkExpr(n.X, init)
+       n.Y = walkExpr(n.Y, init)
+
+       // Given mixed interface/concrete comparison,
+       // rewrite into types-equal && data-equal.
+       // This is efficient, avoids allocations, and avoids runtime calls.
+       if n.X.Type().IsInterface() != n.Y.Type().IsInterface() {
+               // Preserve side-effects in case of short-circuiting; see #32187.
+               l := cheapExpr(n.X, init)
+               r := cheapExpr(n.Y, init)
+               // Swap so that l is the interface value and r is the concrete value.
+               if n.Y.Type().IsInterface() {
+                       l, r = r, l
+               }
+
+               // Handle both == and !=.
+               eq := n.Op()
+               andor := ir.OOROR
+               if eq == ir.OEQ {
+                       andor = ir.OANDAND
+               }
+               // Check for types equal.
+               // For empty interface, this is:
+               //   l.tab == type(r)
+               // For non-empty interface, this is:
+               //   l.tab != nil && l.tab._type == type(r)
+               var eqtype ir.Node
+               tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
+               rtyp := reflectdata.TypePtr(r.Type())
+               if l.Type().IsEmptyInterface() {
+                       tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
+                       tab.SetTypecheck(1)
+                       eqtype = ir.NewBinaryExpr(base.Pos, eq, tab, rtyp)
+               } else {
+                       nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), typecheck.NodNil(), tab)
+                       match := ir.NewBinaryExpr(base.Pos, eq, itabType(tab), rtyp)
+                       eqtype = ir.NewLogicalExpr(base.Pos, andor, nonnil, match)
+               }
+               // Check for data equal.
+               eqdata := ir.NewBinaryExpr(base.Pos, eq, ifaceData(n.Pos(), l, r.Type()), r)
+               // Put it all together.
+               expr := ir.NewLogicalExpr(base.Pos, andor, eqtype, eqdata)
+               return finishCompare(n, expr, init)
+       }
+
+       // Must be comparison of array or struct.
+       // Otherwise back end handles it.
+       // While we're here, decide whether to
+       // inline or call an eq alg.
+       t := n.X.Type()
+       var inline bool
+
+       maxcmpsize := int64(4)
+       unalignedLoad := canMergeLoads()
+       if unalignedLoad {
+               // Keep this low enough to generate less code than a function call.
+               maxcmpsize = 2 * int64(ssagen.Arch.LinkArch.RegSize)
+       }
+
+       switch t.Kind() {
+       default:
+               if base.Debug.Libfuzzer != 0 && t.IsInteger() {
+                       n.X = cheapExpr(n.X, init)
+                       n.Y = cheapExpr(n.Y, init)
+
+                       // If exactly one comparison operand is
+                       // constant, invoke the constcmp functions
+                       // instead, and arrange for the constant
+                       // operand to be the first argument.
+                       l, r := n.X, n.Y
+                       if r.Op() == ir.OLITERAL {
+                               l, r = r, l
+                       }
+                       constcmp := l.Op() == ir.OLITERAL && r.Op() != ir.OLITERAL
+
+                       var fn string
+                       var paramType *types.Type
+                       switch t.Size() {
+                       case 1:
+                               fn = "libfuzzerTraceCmp1"
+                               if constcmp {
+                                       fn = "libfuzzerTraceConstCmp1"
+                               }
+                               paramType = types.Types[types.TUINT8]
+                       case 2:
+                               fn = "libfuzzerTraceCmp2"
+                               if constcmp {
+                                       fn = "libfuzzerTraceConstCmp2"
+                               }
+                               paramType = types.Types[types.TUINT16]
+                       case 4:
+                               fn = "libfuzzerTraceCmp4"
+                               if constcmp {
+                                       fn = "libfuzzerTraceConstCmp4"
+                               }
+                               paramType = types.Types[types.TUINT32]
+                       case 8:
+                               fn = "libfuzzerTraceCmp8"
+                               if constcmp {
+                                       fn = "libfuzzerTraceConstCmp8"
+                               }
+                               paramType = types.Types[types.TUINT64]
+                       default:
+                               base.Fatalf("unexpected integer size %d for %v", t.Size(), t)
+                       }
+                       init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
+               }
+               return n
+       case types.TARRAY:
+               // We can compare several elements at once with 2/4/8 byte integer compares
+               inline = t.NumElem() <= 1 || (types.IsSimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
+       case types.TSTRUCT:
+               inline = t.NumComponents(types.IgnoreBlankFields) <= 4
+       }
+
+       cmpl := n.X
+       for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
+               cmpl = cmpl.(*ir.ConvExpr).X
+       }
+       cmpr := n.Y
+       for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
+               cmpr = cmpr.(*ir.ConvExpr).X
+       }
+
+       // Chose not to inline. Call equality function directly.
+       if !inline {
+               // eq algs take pointers; cmpl and cmpr must be addressable
+               if !ir.IsAddressable(cmpl) || !ir.IsAddressable(cmpr) {
+                       base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
+               }
+
+               fn, needsize := eqFor(t)
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+               call.Args.Append(typecheck.NodAddr(cmpl))
+               call.Args.Append(typecheck.NodAddr(cmpr))
+               if needsize {
+                       call.Args.Append(ir.NewInt(t.Width))
+               }
+               res := ir.Node(call)
+               if n.Op() != ir.OEQ {
+                       res = ir.NewUnaryExpr(base.Pos, ir.ONOT, res)
+               }
+               return finishCompare(n, res, init)
+       }
+
+       // inline: build boolean expression comparing element by element
+       andor := ir.OANDAND
+       if n.Op() == ir.ONE {
+               andor = ir.OOROR
+       }
+       var expr ir.Node
+       compare := func(el, er ir.Node) {
+               a := ir.NewBinaryExpr(base.Pos, n.Op(), el, er)
+               if expr == nil {
+                       expr = a
+               } else {
+                       expr = ir.NewLogicalExpr(base.Pos, andor, expr, a)
+               }
+       }
+       cmpl = safeExpr(cmpl, init)
+       cmpr = safeExpr(cmpr, init)
+       if t.IsStruct() {
+               for _, f := range t.Fields().Slice() {
+                       sym := f.Sym
+                       if sym.IsBlank() {
+                               continue
+                       }
+                       compare(
+                               ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpl, sym),
+                               ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpr, sym),
+                       )
+               }
+       } else {
+               step := int64(1)
+               remains := t.NumElem() * t.Elem().Width
+               combine64bit := unalignedLoad && types.RegSize == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
+               combine32bit := unalignedLoad && t.Elem().Width <= 2 && t.Elem().IsInteger()
+               combine16bit := unalignedLoad && t.Elem().Width == 1 && t.Elem().IsInteger()
+               for i := int64(0); remains > 0; {
+                       var convType *types.Type
+                       switch {
+                       case remains >= 8 && combine64bit:
+                               convType = types.Types[types.TINT64]
+                               step = 8 / t.Elem().Width
+                       case remains >= 4 && combine32bit:
+                               convType = types.Types[types.TUINT32]
+                               step = 4 / t.Elem().Width
+                       case remains >= 2 && combine16bit:
+                               convType = types.Types[types.TUINT16]
+                               step = 2 / t.Elem().Width
+                       default:
+                               step = 1
+                       }
+                       if step == 1 {
+                               compare(
+                                       ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)),
+                                       ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)),
+                               )
+                               i++
+                               remains -= t.Elem().Width
+                       } else {
+                               elemType := t.Elem().ToUnsigned()
+                               cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)))
+                               cmplw = typecheck.Conv(cmplw, elemType) // convert to unsigned
+                               cmplw = typecheck.Conv(cmplw, convType) // widen
+                               cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)))
+                               cmprw = typecheck.Conv(cmprw, elemType)
+                               cmprw = typecheck.Conv(cmprw, convType)
+                               // For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
+                               // ssa will generate a single large load.
+                               for offset := int64(1); offset < step; offset++ {
+                                       lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i+offset)))
+                                       lb = typecheck.Conv(lb, elemType)
+                                       lb = typecheck.Conv(lb, convType)
+                                       lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, ir.NewInt(8*t.Elem().Width*offset))
+                                       cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
+                                       rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i+offset)))
+                                       rb = typecheck.Conv(rb, elemType)
+                                       rb = typecheck.Conv(rb, convType)
+                                       rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, ir.NewInt(8*t.Elem().Width*offset))
+                                       cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
+                               }
+                               compare(cmplw, cmprw)
+                               i += step
+                               remains -= step * t.Elem().Width
+                       }
+               }
+       }
+       if expr == nil {
+               expr = ir.NewBool(n.Op() == ir.OEQ)
+               // We still need to use cmpl and cmpr, in case they contain
+               // an expression which might panic. See issue 23837.
+               t := typecheck.Temp(cmpl.Type())
+               a1 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpl))
+               a2 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpr))
+               init.Append(a1, a2)
+       }
+       return finishCompare(n, expr, init)
+}
+
+func walkCompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+       n.Y = cheapExpr(n.Y, init)
+       n.X = cheapExpr(n.X, init)
+       eqtab, eqdata := reflectdata.EqInterface(n.X, n.Y)
+       var cmp ir.Node
+       if n.Op() == ir.OEQ {
+               cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
+       } else {
+               eqtab.SetOp(ir.ONE)
+               cmp = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqtab, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqdata))
+       }
+       return finishCompare(n, cmp, init)
+}
+
+func walkCompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+       // Rewrite comparisons to short constant strings as length+byte-wise comparisons.
+       var cs, ncs ir.Node // const string, non-const string
+       switch {
+       case ir.IsConst(n.X, constant.String) && ir.IsConst(n.Y, constant.String):
+               // ignore; will be constant evaluated
+       case ir.IsConst(n.X, constant.String):
+               cs = n.X
+               ncs = n.Y
+       case ir.IsConst(n.Y, constant.String):
+               cs = n.Y
+               ncs = n.X
+       }
+       if cs != nil {
+               cmp := n.Op()
+               // Our comparison below assumes that the non-constant string
+               // is on the left hand side, so rewrite "" cmp x to x cmp "".
+               // See issue 24817.
+               if ir.IsConst(n.X, constant.String) {
+                       cmp = brrev(cmp)
+               }
+
+               // maxRewriteLen was chosen empirically.
+               // It is the value that minimizes cmd/go file size
+               // across most architectures.
+               // See the commit description for CL 26758 for details.
+               maxRewriteLen := 6
+               // Some architectures can load unaligned byte sequence as 1 word.
+               // So we can cover longer strings with the same amount of code.
+               canCombineLoads := canMergeLoads()
+               combine64bit := false
+               if canCombineLoads {
+                       // Keep this low enough to generate less code than a function call.
+                       maxRewriteLen = 2 * ssagen.Arch.LinkArch.RegSize
+                       combine64bit = ssagen.Arch.LinkArch.RegSize >= 8
+               }
+
+               var and ir.Op
+               switch cmp {
+               case ir.OEQ:
+                       and = ir.OANDAND
+               case ir.ONE:
+                       and = ir.OOROR
+               default:
+                       // Don't do byte-wise comparisons for <, <=, etc.
+                       // They're fairly complicated.
+                       // Length-only checks are ok, though.
+                       maxRewriteLen = 0
+               }
+               if s := ir.StringVal(cs); len(s) <= maxRewriteLen {
+                       if len(s) > 0 {
+                               ncs = safeExpr(ncs, init)
+                       }
+                       r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), ir.NewInt(int64(len(s)))))
+                       remains := len(s)
+                       for i := 0; remains > 0; {
+                               if remains == 1 || !canCombineLoads {
+                                       cb := ir.NewInt(int64(s[i]))
+                                       ncb := ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i)))
+                                       r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
+                                       remains--
+                                       i++
+                                       continue
+                               }
+                               var step int
+                               var convType *types.Type
+                               switch {
+                               case remains >= 8 && combine64bit:
+                                       convType = types.Types[types.TINT64]
+                                       step = 8
+                               case remains >= 4:
+                                       convType = types.Types[types.TUINT32]
+                                       step = 4
+                               case remains >= 2:
+                                       convType = types.Types[types.TUINT16]
+                                       step = 2
+                               }
+                               ncsubstr := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
+                               csubstr := int64(s[i])
+                               // Calculate large constant from bytes as sequence of shifts and ors.
+                               // Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
+                               // ssa will combine this into a single large load.
+                               for offset := 1; offset < step; offset++ {
+                                       b := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
+                                       b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, ir.NewInt(int64(8*offset)))
+                                       ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
+                                       csubstr |= int64(s[i+offset]) << uint8(8*offset)
+                               }
+                               csubstrPart := ir.NewInt(csubstr)
+                               // Compare "step" bytes as once
+                               r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, csubstrPart, ncsubstr))
+                               remains -= step
+                               i += step
+                       }
+                       return finishCompare(n, r, init)
+               }
+       }
+
+       var r ir.Node
+       if n.Op() == ir.OEQ || n.Op() == ir.ONE {
+               // prepare for rewrite below
+               n.X = cheapExpr(n.X, init)
+               n.Y = cheapExpr(n.Y, init)
+               eqlen, eqmem := reflectdata.EqString(n.X, n.Y)
+               // quick check of len before full compare for == or !=.
+               // memequal then tests equality up to length len.
+               if n.Op() == ir.OEQ {
+                       // len(left) == len(right) && memequal(left, right, len)
+                       r = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqlen, eqmem)
+               } else {
+                       // len(left) != len(right) || !memequal(left, right, len)
+                       eqlen.SetOp(ir.ONE)
+                       r = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqlen, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqmem))
+               }
+       } else {
+               // sys_cmpstring(s1, s2) :: 0
+               r = mkcall("cmpstring", types.Types[types.TINT], init, typecheck.Conv(n.X, types.Types[types.TSTRING]), typecheck.Conv(n.Y, types.Types[types.TSTRING]))
+               r = ir.NewBinaryExpr(base.Pos, n.Op(), r, ir.NewInt(0))
+       }
+
+       return finishCompare(n, r, init)
+}
+
+// The result of finishCompare MUST be assigned back to n, e.g.
+//     n.Left = finishCompare(n.Left, x, r, init)
+func finishCompare(n *ir.BinaryExpr, r ir.Node, init *ir.Nodes) ir.Node {
+       r = typecheck.Expr(r)
+       r = typecheck.Conv(r, n.Type())
+       r = walkExpr(r, init)
+       return r
+}
+
+func eqFor(t *types.Type) (n ir.Node, needsize bool) {
+       // Should only arrive here with large memory or
+       // a struct/array containing a non-memory field/element.
+       // Small memory is handled inline, and single non-memory
+       // is handled by walkCompare.
+       switch a, _ := types.AlgType(t); a {
+       case types.AMEM:
+               n := typecheck.LookupRuntime("memequal")
+               n = typecheck.SubstArgTypes(n, t, t)
+               return n, true
+       case types.ASPECIAL:
+               sym := reflectdata.TypeSymPrefix(".eq", t)
+               n := typecheck.NewName(sym)
+               ir.MarkFunc(n)
+               n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+                       types.NewField(base.Pos, nil, types.NewPtr(t)),
+                       types.NewField(base.Pos, nil, types.NewPtr(t)),
+               }, []*types.Field{
+                       types.NewField(base.Pos, nil, types.Types[types.TBOOL]),
+               }))
+               return n, false
+       }
+       base.Fatalf("eqFor %v", t)
+       return nil, false
+}
+
+// brcom returns !(op).
+// For example, brcom(==) is !=.
+func brcom(op ir.Op) ir.Op {
+       switch op {
+       case ir.OEQ:
+               return ir.ONE
+       case ir.ONE:
+               return ir.OEQ
+       case ir.OLT:
+               return ir.OGE
+       case ir.OGT:
+               return ir.OLE
+       case ir.OLE:
+               return ir.OGT
+       case ir.OGE:
+               return ir.OLT
+       }
+       base.Fatalf("brcom: no com for %v\n", op)
+       return op
+}
+
+// brrev returns reverse(op).
+// For example, Brrev(<) is >.
+func brrev(op ir.Op) ir.Op {
+       switch op {
+       case ir.OEQ:
+               return ir.OEQ
+       case ir.ONE:
+               return ir.ONE
+       case ir.OLT:
+               return ir.OGT
+       case ir.OGT:
+               return ir.OLT
+       case ir.OLE:
+               return ir.OGE
+       case ir.OGE:
+               return ir.OLE
+       }
+       base.Fatalf("brrev: no rev for %v\n", op)
+       return op
+}
+
+func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
+       // Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
+       if n.Op() == ir.OLITERAL && n.Type().IsSigned() && ir.Int64Val(n) < 0 {
+               n = copyExpr(n, n.Type(), init)
+       }
+
+       return typecheck.Conv(n, t)
+}
+
+// canMergeLoads reports whether the backend optimization passes for
+// the current architecture can combine adjacent loads into a single
+// larger, possibly unaligned, load. Note that currently the
+// optimizations must be able to handle little endian byte order.
+func canMergeLoads() bool {
+       switch ssagen.Arch.LinkArch.Family {
+       case sys.ARM64, sys.AMD64, sys.I386, sys.S390X:
+               return true
+       case sys.PPC64:
+               // Load combining only supported on ppc64le.
+               return ssagen.Arch.LinkArch.ByteOrder == binary.LittleEndian
+       }
+       return false
+}

diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
new file mode 100644 (file)
index 0000000..73442dc
--- /dev/null
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -0,0 +1,663 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/staticinit"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+)
+
+// walkCompLit walks a composite literal node:
+// OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT (all CompLitExpr), or OPTRLIT (AddrExpr).
+func walkCompLit(n ir.Node, init *ir.Nodes) ir.Node {
+       if isStaticCompositeLiteral(n) && !ssagen.TypeOK(n.Type()) {
+               n := n.(*ir.CompLitExpr) // not OPTRLIT
+               // n can be directly represented in the read-only data section.
+               // Make direct reference to the static data. See issue 12841.
+               vstat := readonlystaticname(n.Type())
+               fixedlit(inInitFunction, initKindStatic, n, vstat, init)
+               return typecheck.Expr(vstat)
+       }
+       var_ := typecheck.Temp(n.Type())
+       anylit(n, var_, init)
+       return var_
+}
+
+// initContext is the context in which static data is populated.
+// It is either in an init function or in any other function.
+// Static data populated in an init function will be written either
+// zero times (as a readonly, static data symbol) or
+// one time (during init function execution).
+// Either way, there is no opportunity for races or further modification,
+// so the data can be written to a (possibly readonly) data symbol.
+// Static data populated in any other function needs to be local to
+// that function to allow multiple instances of that function
+// to execute concurrently without clobbering each others' data.
+type initContext uint8
+
+const (
+       inInitFunction initContext = iota
+       inNonInitFunction
+)
+
+func (c initContext) String() string {
+       if c == inInitFunction {
+               return "inInitFunction"
+       }
+       return "inNonInitFunction"
+}
+
+// readonlystaticname returns a name backed by a (writable) static data symbol.
+func readonlystaticname(t *types.Type) *ir.Name {
+       n := staticinit.StaticName(t)
+       n.MarkReadonly()
+       n.Linksym().Set(obj.AttrContentAddressable, true)
+       return n
+}
+
+func isSimpleName(nn ir.Node) bool {
+       if nn.Op() != ir.ONAME || ir.IsBlank(nn) {
+               return false
+       }
+       n := nn.(*ir.Name)
+       return n.OnStack()
+}
+
+func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
+       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, r))
+}
+
+// initGenType is a bitmap indicating the types of generation that will occur for a static value.
+type initGenType uint8
+
+const (
+       initDynamic initGenType = 1 << iota // contains some dynamic values, for which init code will be generated
+       initConst                           // contains some constant values, which may be written into data symbols
+)
+
+// getdyn calculates the initGenType for n.
+// If top is false, getdyn is recursing.
+func getdyn(n ir.Node, top bool) initGenType {
+       switch n.Op() {
+       default:
+               if ir.IsConstNode(n) {
+                       return initConst
+               }
+               return initDynamic
+
+       case ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               if !top {
+                       return initDynamic
+               }
+               if n.Len/4 > int64(len(n.List)) {
+                       // <25% of entries have explicit values.
+                       // Very rough estimation, it takes 4 bytes of instructions
+                       // to initialize 1 byte of result. So don't use a static
+                       // initializer if the dynamic initialization code would be
+                       // smaller than the static value.
+                       // See issue 23780.
+                       return initDynamic
+               }
+
+       case ir.OARRAYLIT, ir.OSTRUCTLIT:
+       }
+       lit := n.(*ir.CompLitExpr)
+
+       var mode initGenType
+       for _, n1 := range lit.List {
+               switch n1.Op() {
+               case ir.OKEY:
+                       n1 = n1.(*ir.KeyExpr).Value
+               case ir.OSTRUCTKEY:
+                       n1 = n1.(*ir.StructKeyExpr).Value
+               }
+               mode |= getdyn(n1, false)
+               if mode == initDynamic|initConst {
+                       break
+               }
+       }
+       return mode
+}
+
+// isStaticCompositeLiteral reports whether n is a compile-time constant.
+func isStaticCompositeLiteral(n ir.Node) bool {
+       switch n.Op() {
+       case ir.OSLICELIT:
+               return false
+       case ir.OARRAYLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, r := range n.List {
+                       if r.Op() == ir.OKEY {
+                               r = r.(*ir.KeyExpr).Value
+                       }
+                       if !isStaticCompositeLiteral(r) {
+                               return false
+                       }
+               }
+               return true
+       case ir.OSTRUCTLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, r := range n.List {
+                       r := r.(*ir.StructKeyExpr)
+                       if !isStaticCompositeLiteral(r.Value) {
+                               return false
+                       }
+               }
+               return true
+       case ir.OLITERAL, ir.ONIL:
+               return true
+       case ir.OCONVIFACE:
+               // See staticassign's OCONVIFACE case for comments.
+               n := n.(*ir.ConvExpr)
+               val := ir.Node(n)
+               for val.Op() == ir.OCONVIFACE {
+                       val = val.(*ir.ConvExpr).X
+               }
+               if val.Type().IsInterface() {
+                       return val.Op() == ir.ONIL
+               }
+               if types.IsDirectIface(val.Type()) && val.Op() == ir.ONIL {
+                       return true
+               }
+               return isStaticCompositeLiteral(val)
+       }
+       return false
+}
+
+// initKind is a kind of static initialization: static, dynamic, or local.
+// Static initialization represents literals and
+// literal components of composite literals.
+// Dynamic initialization represents non-literals and
+// non-literal components of composite literals.
+// LocalCode initialization represents initialization
+// that occurs purely in generated code local to the function of use.
+// Initialization code is sometimes generated in passes,
+// first static then dynamic.
+type initKind uint8
+
+const (
+       initKindStatic initKind = iota + 1
+       initKindDynamic
+       initKindLocalCode
+)
+
+// fixedlit handles struct, array, and slice literals.
+// TODO: expand documentation.
+func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
+       isBlank := var_ == ir.BlankNode
+       var splitnode func(ir.Node) (a ir.Node, value ir.Node)
+       switch n.Op() {
+       case ir.OARRAYLIT, ir.OSLICELIT:
+               var k int64
+               splitnode = func(r ir.Node) (ir.Node, ir.Node) {
+                       if r.Op() == ir.OKEY {
+                               kv := r.(*ir.KeyExpr)
+                               k = typecheck.IndexConst(kv.Key)
+                               if k < 0 {
+                                       base.Fatalf("fixedlit: invalid index %v", kv.Key)
+                               }
+                               r = kv.Value
+                       }
+                       a := ir.NewIndexExpr(base.Pos, var_, ir.NewInt(k))
+                       k++
+                       if isBlank {
+                               return ir.BlankNode, r
+                       }
+                       return a, r
+               }
+       case ir.OSTRUCTLIT:
+               splitnode = func(rn ir.Node) (ir.Node, ir.Node) {
+                       r := rn.(*ir.StructKeyExpr)
+                       if r.Field.IsBlank() || isBlank {
+                               return ir.BlankNode, r.Value
+                       }
+                       ir.SetPos(r)
+                       return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Field), r.Value
+               }
+       default:
+               base.Fatalf("fixedlit bad op: %v", n.Op())
+       }
+
+       for _, r := range n.List {
+               a, value := splitnode(r)
+               if a == ir.BlankNode && !staticinit.AnySideEffects(value) {
+                       // Discard.
+                       continue
+               }
+
+               switch value.Op() {
+               case ir.OSLICELIT:
+                       value := value.(*ir.CompLitExpr)
+                       if (kind == initKindStatic && ctxt == inNonInitFunction) || (kind == initKindDynamic && ctxt == inInitFunction) {
+                               slicelit(ctxt, value, a, init)
+                               continue
+                       }
+
+               case ir.OARRAYLIT, ir.OSTRUCTLIT:
+                       value := value.(*ir.CompLitExpr)
+                       fixedlit(ctxt, kind, value, a, init)
+                       continue
+               }
+
+               islit := ir.IsConstNode(value)
+               if (kind == initKindStatic && !islit) || (kind == initKindDynamic && islit) {
+                       continue
+               }
+
+               // build list of assignments: var[index] = expr
+               ir.SetPos(a)
+               as := ir.NewAssignStmt(base.Pos, a, value)
+               as = typecheck.Stmt(as).(*ir.AssignStmt)
+               switch kind {
+               case initKindStatic:
+                       genAsStatic(as)
+               case initKindDynamic, initKindLocalCode:
+                       a = orderStmtInPlace(as, map[string][]*ir.Name{})
+                       a = walkStmt(a)
+                       init.Append(a)
+               default:
+                       base.Fatalf("fixedlit: bad kind %d", kind)
+               }
+
+       }
+}
+
+func isSmallSliceLit(n *ir.CompLitExpr) bool {
+       if n.Op() != ir.OSLICELIT {
+               return false
+       }
+
+       return n.Type().Elem().Width == 0 || n.Len <= ir.MaxSmallArraySize/n.Type().Elem().Width
+}
+
+func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
+       // make an array type corresponding the number of elements we have
+       t := types.NewArray(n.Type().Elem(), n.Len)
+       types.CalcSize(t)
+
+       if ctxt == inNonInitFunction {
+               // put everything into static array
+               vstat := staticinit.StaticName(t)
+
+               fixedlit(ctxt, initKindStatic, n, vstat, init)
+               fixedlit(ctxt, initKindDynamic, n, vstat, init)
+
+               // copy static to slice
+               var_ = typecheck.AssignExpr(var_)
+               name, offset, ok := staticinit.StaticLoc(var_)
+               if !ok || name.Class != ir.PEXTERN {
+                       base.Fatalf("slicelit: %v", var_)
+               }
+               staticdata.InitSlice(name, offset, vstat.Linksym(), t.NumElem())
+               return
+       }
+
+       // recipe for var = []t{...}
+       // 1. make a static array
+       //      var vstat [...]t
+       // 2. assign (data statements) the constant part
+       //      vstat = constpart{}
+       // 3. make an auto pointer to array and allocate heap to it
+       //      var vauto *[...]t = new([...]t)
+       // 4. copy the static array to the auto array
+       //      *vauto = vstat
+       // 5. for each dynamic part assign to the array
+       //      vauto[i] = dynamic part
+       // 6. assign slice of allocated heap to var
+       //      var = vauto[:]
+       //
+       // an optimization is done if there is no constant part
+       //      3. var vauto *[...]t = new([...]t)
+       //      5. vauto[i] = dynamic part
+       //      6. var = vauto[:]
+
+       // if the literal contains constants,
+       // make static initialized array (1),(2)
+       var vstat ir.Node
+
+       mode := getdyn(n, true)
+       if mode&initConst != 0 && !isSmallSliceLit(n) {
+               if ctxt == inInitFunction {
+                       vstat = readonlystaticname(t)
+               } else {
+                       vstat = staticinit.StaticName(t)
+               }
+               fixedlit(ctxt, initKindStatic, n, vstat, init)
+       }
+
+       // make new auto *array (3 declare)
+       vauto := typecheck.Temp(types.NewPtr(t))
+
+       // set auto to point at new temp or heap (3 assign)
+       var a ir.Node
+       if x := n.Prealloc; x != nil {
+               // temp allocated during order.go for dddarg
+               if !types.Identical(t, x.Type()) {
+                       panic("dotdotdot base type does not match order's assigned type")
+               }
+               a = initStackTemp(init, x, vstat)
+       } else if n.Esc() == ir.EscNone {
+               a = initStackTemp(init, typecheck.Temp(t), vstat)
+       } else {
+               a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
+       }
+       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, vauto, a))
+
+       if vstat != nil && n.Prealloc == nil && n.Esc() != ir.EscNone {
+               // If we allocated on the heap with ONEW, copy the static to the
+               // heap (4). We skip this for stack temporaries, because
+               // initStackTemp already handled the copy.
+               a = ir.NewStarExpr(base.Pos, vauto)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, a, vstat))
+       }
+
+       // put dynamics into array (5)
+       var index int64
+       for _, value := range n.List {
+               if value.Op() == ir.OKEY {
+                       kv := value.(*ir.KeyExpr)
+                       index = typecheck.IndexConst(kv.Key)
+                       if index < 0 {
+                               base.Fatalf("slicelit: invalid index %v", kv.Key)
+                       }
+                       value = kv.Value
+               }
+               a := ir.NewIndexExpr(base.Pos, vauto, ir.NewInt(index))
+               a.SetBounded(true)
+               index++
+
+               // TODO need to check bounds?
+
+               switch value.Op() {
+               case ir.OSLICELIT:
+                       break
+
+               case ir.OARRAYLIT, ir.OSTRUCTLIT:
+                       value := value.(*ir.CompLitExpr)
+                       k := initKindDynamic
+                       if vstat == nil {
+                               // Generate both static and dynamic initializations.
+                               // See issue #31987.
+                               k = initKindLocalCode
+                       }
+                       fixedlit(ctxt, k, value, a, init)
+                       continue
+               }
+
+               if vstat != nil && ir.IsConstNode(value) { // already set by copy from static value
+                       continue
+               }
+
+               // build list of vauto[c] = expr
+               ir.SetPos(value)
+               as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, a, value))
+               as = orderStmtInPlace(as, map[string][]*ir.Name{})
+               as = walkStmt(as)
+               init.Append(as)
+       }
+
+       // make slice out of heap (6)
+       a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto, nil, nil, nil))
+
+       a = typecheck.Stmt(a)
+       a = orderStmtInPlace(a, map[string][]*ir.Name{})
+       a = walkStmt(a)
+       init.Append(a)
+}
+
+func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
+       // make the map var
+       a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
+       a.SetEsc(n.Esc())
+       a.Args = []ir.Node{ir.TypeNode(n.Type()), ir.NewInt(int64(len(n.List)))}
+       litas(m, a, init)
+
+       entries := n.List
+
+       // The order pass already removed any dynamic (runtime-computed) entries.
+       // All remaining entries are static. Double-check that.
+       for _, r := range entries {
+               r := r.(*ir.KeyExpr)
+               if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
+                       base.Fatalf("maplit: entry is not a literal: %v", r)
+               }
+       }
+
+       if len(entries) > 25 {
+               // For a large number of entries, put them in an array and loop.
+
+               // build types [count]Tindex and [count]Tvalue
+               tk := types.NewArray(n.Type().Key(), int64(len(entries)))
+               te := types.NewArray(n.Type().Elem(), int64(len(entries)))
+
+               tk.SetNoalg(true)
+               te.SetNoalg(true)
+
+               types.CalcSize(tk)
+               types.CalcSize(te)
+
+               // make and initialize static arrays
+               vstatk := readonlystaticname(tk)
+               vstate := readonlystaticname(te)
+
+               datak := ir.NewCompLitExpr(base.Pos, ir.OARRAYLIT, nil, nil)
+               datae := ir.NewCompLitExpr(base.Pos, ir.OARRAYLIT, nil, nil)
+               for _, r := range entries {
+                       r := r.(*ir.KeyExpr)
+                       datak.List.Append(r.Key)
+                       datae.List.Append(r.Value)
+               }
+               fixedlit(inInitFunction, initKindStatic, datak, vstatk, init)
+               fixedlit(inInitFunction, initKindStatic, datae, vstate, init)
+
+               // loop adding structure elements to map
+               // for i = 0; i < len(vstatk); i++ {
+               //      map[vstatk[i]] = vstate[i]
+               // }
+               i := typecheck.Temp(types.Types[types.TINT])
+               rhs := ir.NewIndexExpr(base.Pos, vstate, i)
+               rhs.SetBounded(true)
+
+               kidx := ir.NewIndexExpr(base.Pos, vstatk, i)
+               kidx.SetBounded(true)
+               lhs := ir.NewIndexExpr(base.Pos, m, kidx)
+
+               zero := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
+               cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(tk.NumElem()))
+               incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
+               body := ir.NewAssignStmt(base.Pos, lhs, rhs)
+
+               loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
+               loop.Body = []ir.Node{body}
+               *loop.PtrInit() = []ir.Node{zero}
+
+               appendWalkStmt(init, loop)
+               return
+       }
+       // For a small number of entries, just add them directly.
+
+       // Build list of var[c] = expr.
+       // Use temporaries so that mapassign1 can have addressable key, elem.
+       // TODO(josharian): avoid map key temporaries for mapfast_* assignments with literal keys.
+       tmpkey := typecheck.Temp(m.Type().Key())
+       tmpelem := typecheck.Temp(m.Type().Elem())
+
+       for _, r := range entries {
+               r := r.(*ir.KeyExpr)
+               index, elem := r.Key, r.Value
+
+               ir.SetPos(index)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpkey, index))
+
+               ir.SetPos(elem)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
+
+               ir.SetPos(tmpelem)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
+       }
+
+       appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpkey))
+       appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpelem))
+}
+
+func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
+       t := n.Type()
+       switch n.Op() {
+       default:
+               base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)
+
+       case ir.ONAME:
+               n := n.(*ir.Name)
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, n))
+
+       case ir.OMETHEXPR:
+               n := n.(*ir.SelectorExpr)
+               anylit(n.FuncName(), var_, init)
+
+       case ir.OPTRLIT:
+               n := n.(*ir.AddrExpr)
+               if !t.IsPtr() {
+                       base.Fatalf("anylit: not ptr")
+               }
+
+               var r ir.Node
+               if n.Prealloc != nil {
+                       // n.Prealloc is stack temporary used as backing store.
+                       r = initStackTemp(init, n.Prealloc, nil)
+               } else {
+                       r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
+                       r.SetEsc(n.Esc())
+               }
+               appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, r))
+
+               var_ = ir.NewStarExpr(base.Pos, var_)
+               var_ = typecheck.AssignExpr(var_)
+               anylit(n.X, var_, init)
+
+       case ir.OSTRUCTLIT, ir.OARRAYLIT:
+               n := n.(*ir.CompLitExpr)
+               if !t.IsStruct() && !t.IsArray() {
+                       base.Fatalf("anylit: not struct/array")
+               }
+
+               if isSimpleName(var_) && len(n.List) > 4 {
+                       // lay out static data
+                       vstat := readonlystaticname(t)
+
+                       ctxt := inInitFunction
+                       if n.Op() == ir.OARRAYLIT {
+                               ctxt = inNonInitFunction
+                       }
+                       fixedlit(ctxt, initKindStatic, n, vstat, init)
+
+                       // copy static to var
+                       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, vstat))
+
+                       // add expressions to automatic
+                       fixedlit(inInitFunction, initKindDynamic, n, var_, init)
+                       break
+               }
+
+               var components int64
+               if n.Op() == ir.OARRAYLIT {
+                       components = t.NumElem()
+               } else {
+                       components = int64(t.NumFields())
+               }
+               // initialization of an array or struct with unspecified components (missing fields or arrays)
+               if isSimpleName(var_) || int64(len(n.List)) < components {
+                       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))
+               }
+
+               fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
+
+       case ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               slicelit(inInitFunction, n, var_, init)
+
+       case ir.OMAPLIT:
+               n := n.(*ir.CompLitExpr)
+               if !t.IsMap() {
+                       base.Fatalf("anylit: not map")
+               }
+               maplit(n, var_, init)
+       }
+}
+
+// oaslit handles special composite literal assignments.
+// It returns true if n's effects have been added to init,
+// in which case n should be dropped from the program by the caller.
+func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
+       if n.X == nil || n.Y == nil {
+               // not a special composite literal assignment
+               return false
+       }
+       if n.X.Type() == nil || n.Y.Type() == nil {
+               // not a special composite literal assignment
+               return false
+       }
+       if !isSimpleName(n.X) {
+               // not a special composite literal assignment
+               return false
+       }
+       x := n.X.(*ir.Name)
+       if !types.Identical(n.X.Type(), n.Y.Type()) {
+               // not a special composite literal assignment
+               return false
+       }
+
+       switch n.Y.Op() {
+       default:
+               // not a special composite literal assignment
+               return false
+
+       case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
+               if ir.Any(n.Y, func(y ir.Node) bool { return ir.Uses(y, x) }) {
+                       // not a special composite literal assignment
+                       return false
+               }
+               anylit(n.Y, n.X, init)
+       }
+
+       return true
+}
+
+func genAsStatic(as *ir.AssignStmt) {
+       if as.X.Type() == nil {
+               base.Fatalf("genAsStatic as.Left not typechecked")
+       }
+
+       name, offset, ok := staticinit.StaticLoc(as.X)
+       if !ok || (name.Class != ir.PEXTERN && as.X != ir.BlankNode) {
+               base.Fatalf("genAsStatic: lhs %v", as.X)
+       }
+
+       switch r := as.Y; r.Op() {
+       case ir.OLITERAL:
+               staticdata.InitConst(name, offset, r, int(r.Type().Width))
+               return
+       case ir.OMETHEXPR:
+               r := r.(*ir.SelectorExpr)
+               staticdata.InitAddr(name, offset, staticdata.FuncLinksym(r.FuncName()))
+               return
+       case ir.ONAME:
+               r := r.(*ir.Name)
+               if r.Offset_ != 0 {
+                       base.Fatalf("genAsStatic %+v", as)
+               }
+               if r.Class == ir.PFUNC {
+                       staticdata.InitAddr(name, offset, staticdata.FuncLinksym(r))
+                       return
+               }
+       }
+       base.Fatalf("genAsStatic: rhs %v", as.Y)
+}

diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
new file mode 100644 (file)
index 0000000..fa8e2c0
--- /dev/null
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -0,0 +1,490 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "encoding/binary"
+       "go/constant"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/sys"
+)
+
+// walkConv walks an OCONV or OCONVNOP (but not OCONVIFACE) node.
+func walkConv(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+       if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
+               return n.X
+       }
+       if n.Op() == ir.OCONVNOP && ir.ShouldCheckPtr(ir.CurFunc, 1) {
+               if n.Type().IsPtr() && n.X.Type().IsUnsafePtr() { // unsafe.Pointer to *T
+                       return walkCheckPtrAlignment(n, init, nil)
+               }
+               if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() { // uintptr to unsafe.Pointer
+                       return walkCheckPtrArithmetic(n, init)
+               }
+       }
+       param, result := rtconvfn(n.X.Type(), n.Type())
+       if param == types.Txxx {
+               return n
+       }
+       fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
+       return typecheck.Conv(mkcall(fn, types.Types[result], init, typecheck.Conv(n.X, types.Types[param])), n.Type())
+}
+
+// walkConvInterface walks an OCONVIFACE node.
+func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+
+       fromType := n.X.Type()
+       toType := n.Type()
+
+       if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) { // skip unnamed functions (func _())
+               reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
+       }
+
+       // typeword generates the type word of the interface value.
+       typeword := func() ir.Node {
+               if toType.IsEmptyInterface() {
+                       return reflectdata.TypePtr(fromType)
+               }
+               return reflectdata.ITabAddr(fromType, toType)
+       }
+
+       // Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
+       if types.IsDirectIface(fromType) {
+               l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.X)
+               l.SetType(toType)
+               l.SetTypecheck(n.Typecheck())
+               return l
+       }
+
+       // Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
+       // by using an existing addressable value identical to n.Left
+       // or creating one on the stack.
+       var value ir.Node
+       switch {
+       case fromType.Size() == 0:
+               // n.Left is zero-sized. Use zerobase.
+               cheapExpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
+               value = ir.NewLinksymExpr(base.Pos, ir.Syms.Zerobase, types.Types[types.TUINTPTR])
+       case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
+               // n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
+               // and staticuint64s[n.Left * 8 + 7] on big-endian.
+               n.X = cheapExpr(n.X, init)
+               // byteindex widens n.Left so that the multiplication doesn't overflow.
+               index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), ir.NewInt(3))
+               if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
+                       index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
+               }
+               // The actual type is [256]uint64, but we use [256*8]uint8 so we can address
+               // individual bytes.
+               staticuint64s := ir.NewLinksymExpr(base.Pos, ir.Syms.Staticuint64s, types.NewArray(types.Types[types.TUINT8], 256*8))
+               xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
+               xe.SetBounded(true)
+               value = xe
+       case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class == ir.PEXTERN && n.X.(*ir.Name).Readonly():
+               // n.Left is a readonly global; use it directly.
+               value = n.X
+       case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
+               // n.Left does not escape. Use a stack temporary initialized to n.Left.
+               value = typecheck.Temp(fromType)
+               init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, value, n.X)))
+       }
+
+       if value != nil {
+               // Value is identical to n.Left.
+               // Construct the interface directly: {type/itab, &value}.
+               l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck.Expr(typecheck.NodAddr(value)))
+               l.SetType(toType)
+               l.SetTypecheck(n.Typecheck())
+               return l
+       }
+
+       // Implement interface to empty interface conversion.
+       // tmp = i.itab
+       // if tmp != nil {
+       //    tmp = tmp.type
+       // }
+       // e = iface{tmp, i.data}
+       if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
+               // Evaluate the input interface.
+               c := typecheck.Temp(fromType)
+               init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
+
+               // Get the itab out of the interface.
+               tmp := typecheck.Temp(types.NewPtr(types.Types[types.TUINT8]))
+               init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, c))))
+
+               // Get the type out of the itab.
+               nif := ir.NewIfStmt(base.Pos, typecheck.Expr(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, typecheck.NodNil())), nil, nil)
+               nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, tmp, itabType(tmp))}
+               init.Append(nif)
+
+               // Build the result.
+               e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
+               e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
+               e.SetTypecheck(1)
+               return e
+       }
+
+       fnname, needsaddr := convFuncName(fromType, toType)
+
+       if !needsaddr && !fromType.IsInterface() {
+               // Use a specialized conversion routine that only returns a data pointer.
+               // ptr = convT2X(val)
+               // e = iface{typ/tab, ptr}
+               fn := typecheck.LookupRuntime(fnname)
+               types.CalcSize(fromType)
+               fn = typecheck.SubstArgTypes(fn, fromType)
+               types.CalcSize(fn.Type())
+               call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+               call.Args = []ir.Node{n.X}
+               e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeExpr(walkExpr(typecheck.Expr(call), init), init))
+               e.SetType(toType)
+               e.SetTypecheck(1)
+               return e
+       }
+
+       var tab ir.Node
+       if fromType.IsInterface() {
+               // convI2I
+               tab = reflectdata.TypePtr(toType)
+       } else {
+               // convT2x
+               tab = typeword()
+       }
+
+       v := n.X
+       if needsaddr {
+               // Types of large or unknown size are passed by reference.
+               // Orderexpr arranged for n.Left to be a temporary for all
+               // the conversions it could see. Comparison of an interface
+               // with a non-interface, especially in a switch on interface value
+               // with non-interface cases, is not visible to order.stmt, so we
+               // have to fall back on allocating a temp here.
+               if !ir.IsAddressable(v) {
+                       v = copyExpr(v, v.Type(), init)
+               }
+               v = typecheck.NodAddr(v)
+       }
+
+       types.CalcSize(fromType)
+       fn := typecheck.LookupRuntime(fnname)
+       fn = typecheck.SubstArgTypes(fn, fromType, toType)
+       types.CalcSize(fn.Type())
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+       call.Args = []ir.Node{tab, v}
+       return walkExpr(typecheck.Expr(call), init)
+}
+
+// walkBytesRunesToString walks an OBYTES2STR or ORUNES2STR node.
+func walkBytesRunesToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       a := typecheck.NodNil()
+       if n.Esc() == ir.EscNone {
+               // Create temporary buffer for string on stack.
+               a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
+       }
+       if n.Op() == ir.ORUNES2STR {
+               // slicerunetostring(*[32]byte, []rune) string
+               return mkcall("slicerunetostring", n.Type(), init, a, n.X)
+       }
+       // slicebytetostring(*[32]byte, ptr *byte, n int) string
+       n.X = cheapExpr(n.X, init)
+       ptr, len := backingArrayPtrLen(n.X)
+       return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
+}
+
+// walkBytesToStringTemp walks an OBYTES2STRTMP node.
+func walkBytesToStringTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+       if !base.Flag.Cfg.Instrumenting {
+               // Let the backend handle OBYTES2STRTMP directly
+               // to avoid a function call to slicebytetostringtmp.
+               return n
+       }
+       // slicebytetostringtmp(ptr *byte, n int) string
+       n.X = cheapExpr(n.X, init)
+       ptr, len := backingArrayPtrLen(n.X)
+       return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
+}
+
+// walkRuneToString walks an ORUNESTR node.
+func walkRuneToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       a := typecheck.NodNil()
+       if n.Esc() == ir.EscNone {
+               a = stackBufAddr(4, types.Types[types.TUINT8])
+       }
+       // intstring(*[4]byte, rune)
+       return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
+}
+
+// walkStringToBytes walks an OSTR2BYTES node.
+func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       s := n.X
+       if ir.IsConst(s, constant.String) {
+               sc := ir.StringVal(s)
+
+               // Allocate a [n]byte of the right size.
+               t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
+               var a ir.Node
+               if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
+                       a = stackBufAddr(t.NumElem(), t.Elem())
+               } else {
+                       types.CalcSize(t)
+                       a = ir.NewUnaryExpr(base.Pos, ir.ONEW, nil)
+                       a.SetType(types.NewPtr(t))
+                       a.SetTypecheck(1)
+                       a.MarkNonNil()
+               }
+               p := typecheck.Temp(t.PtrTo()) // *[n]byte
+               init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
+
+               // Copy from the static string data to the [n]byte.
+               if len(sc) > 0 {
+                       as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
+                       appendWalkStmt(init, as)
+               }
+
+               // Slice the [n]byte to a []byte.
+               slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p, nil, nil, nil)
+               slice.SetType(n.Type())
+               slice.SetTypecheck(1)
+               return walkExpr(slice, init)
+       }
+
+       a := typecheck.NodNil()
+       if n.Esc() == ir.EscNone {
+               // Create temporary buffer for slice on stack.
+               a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
+       }
+       // stringtoslicebyte(*32[byte], string) []byte
+       return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
+}
+
+// walkStringToBytesTemp walks an OSTR2BYTESTMP node.
+func walkStringToBytesTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       // []byte(string) conversion that creates a slice
+       // referring to the actual string bytes.
+       // This conversion is handled later by the backend and
+       // is only for use by internal compiler optimizations
+       // that know that the slice won't be mutated.
+       // The only such case today is:
+       // for i, c := range []byte(string)
+       n.X = walkExpr(n.X, init)
+       return n
+}
+
+// walkStringToRunes walks an OSTR2RUNES node.
+func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       a := typecheck.NodNil()
+       if n.Esc() == ir.EscNone {
+               // Create temporary buffer for slice on stack.
+               a = stackBufAddr(tmpstringbufsize, types.Types[types.TINT32])
+       }
+       // stringtoslicerune(*[32]rune, string) []rune
+       return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
+}
+
+// convFuncName builds the runtime function name for interface conversion.
+// It also reports whether the function expects the data by address.
+// Not all names are possible. For example, we never generate convE2E or convE2I.
+func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
+       tkind := to.Tie()
+       switch from.Tie() {
+       case 'I':
+               if tkind == 'I' {
+                       return "convI2I", false
+               }
+       case 'T':
+               switch {
+               case from.Size() == 2 && from.Align == 2:
+                       return "convT16", false
+               case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
+                       return "convT32", false
+               case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
+                       return "convT64", false
+               }
+               if sc := from.SoleComponent(); sc != nil {
+                       switch {
+                       case sc.IsString():
+                               return "convTstring", false
+                       case sc.IsSlice():
+                               return "convTslice", false
+                       }
+               }
+
+               switch tkind {
+               case 'E':
+                       if !from.HasPointers() {
+                               return "convT2Enoptr", true
+                       }
+                       return "convT2E", true
+               case 'I':
+                       if !from.HasPointers() {
+                               return "convT2Inoptr", true
+                       }
+                       return "convT2I", true
+               }
+       }
+       base.Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
+       panic("unreachable")
+}
+
+// rtconvfn returns the parameter and result types that will be used by a
+// runtime function to convert from type src to type dst. The runtime function
+// name can be derived from the names of the returned types.
+//
+// If no such function is necessary, it returns (Txxx, Txxx).
+func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
+       if ssagen.Arch.SoftFloat {
+               return types.Txxx, types.Txxx
+       }
+
+       switch ssagen.Arch.LinkArch.Family {
+       case sys.ARM, sys.MIPS:
+               if src.IsFloat() {
+                       switch dst.Kind() {
+                       case types.TINT64, types.TUINT64:
+                               return types.TFLOAT64, dst.Kind()
+                       }
+               }
+               if dst.IsFloat() {
+                       switch src.Kind() {
+                       case types.TINT64, types.TUINT64:
+                               return src.Kind(), types.TFLOAT64
+                       }
+               }
+
+       case sys.I386:
+               if src.IsFloat() {
+                       switch dst.Kind() {
+                       case types.TINT64, types.TUINT64:
+                               return types.TFLOAT64, dst.Kind()
+                       case types.TUINT32, types.TUINT, types.TUINTPTR:
+                               return types.TFLOAT64, types.TUINT32
+                       }
+               }
+               if dst.IsFloat() {
+                       switch src.Kind() {
+                       case types.TINT64, types.TUINT64:
+                               return src.Kind(), types.TFLOAT64
+                       case types.TUINT32, types.TUINT, types.TUINTPTR:
+                               return types.TUINT32, types.TFLOAT64
+                       }
+               }
+       }
+       return types.Txxx, types.Txxx
+}
+
+// byteindex converts n, which is byte-sized, to an int used to index into an array.
+// We cannot use conv, because we allow converting bool to int here,
+// which is forbidden in user code.
+func byteindex(n ir.Node) ir.Node {
+       // We cannot convert from bool to int directly.
+       // While converting from int8 to int is possible, it would yield
+       // the wrong result for negative values.
+       // Reinterpreting the value as an unsigned byte solves both cases.
+       if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
+               n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+               n.SetType(types.Types[types.TUINT8])
+               n.SetTypecheck(1)
+       }
+       n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+       n.SetType(types.Types[types.TINT])
+       n.SetTypecheck(1)
+       return n
+}
+
+func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
+       if !n.Type().IsPtr() {
+               base.Fatalf("expected pointer type: %v", n.Type())
+       }
+       elem := n.Type().Elem()
+       if count != nil {
+               if !elem.IsArray() {
+                       base.Fatalf("expected array type: %v", elem)
+               }
+               elem = elem.Elem()
+       }
+
+       size := elem.Size()
+       if elem.Alignment() == 1 && (size == 0 || size == 1 && count == nil) {
+               return n
+       }
+
+       if count == nil {
+               count = ir.NewInt(1)
+       }
+
+       n.X = cheapExpr(n.X, init)
+       init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), reflectdata.TypePtr(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
+       return n
+}
+
+func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+       // Calling cheapExpr(n, init) below leads to a recursive call to
+       // walkExpr, which leads us back here again. Use n.Checkptr to
+       // prevent infinite loops.
+       if n.CheckPtr() {
+               return n
+       }
+       n.SetCheckPtr(true)
+       defer n.SetCheckPtr(false)
+
+       // TODO(mdempsky): Make stricter. We only need to exempt
+       // reflect.Value.Pointer and reflect.Value.UnsafeAddr.
+       switch n.X.Op() {
+       case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+               return n
+       }
+
+       if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
+               return n
+       }
+
+       // Find original unsafe.Pointer operands involved in this
+       // arithmetic expression.
+       //
+       // "It is valid both to add and to subtract offsets from a
+       // pointer in this way. It is also valid to use &^ to round
+       // pointers, usually for alignment."
+       var originals []ir.Node
+       var walk func(n ir.Node)
+       walk = func(n ir.Node) {
+               switch n.Op() {
+               case ir.OADD:
+                       n := n.(*ir.BinaryExpr)
+                       walk(n.X)
+                       walk(n.Y)
+               case ir.OSUB, ir.OANDNOT:
+                       n := n.(*ir.BinaryExpr)
+                       walk(n.X)
+               case ir.OCONVNOP:
+                       n := n.(*ir.ConvExpr)
+                       if n.X.Type().IsUnsafePtr() {
+                               n.X = cheapExpr(n.X, init)
+                               originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
+                       }
+               }
+       }
+       walk(n.X)
+
+       cheap := cheapExpr(n, init)
+
+       slice := typecheck.MakeDotArgs(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
+       slice.SetEsc(ir.EscNone)
+
+       init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
+       // TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
+       // the backing store for multiple calls to checkptrArithmetic.
+
+       return cheap
+}

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
new file mode 100644 (file)
index 0000000..7b65db5
--- /dev/null
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -0,0 +1,966 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "fmt"
+       "go/constant"
+       "strings"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/staticdata"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/obj"
+       "cmd/internal/objabi"
+)
+
+// The result of walkExpr MUST be assigned back to n, e.g.
+//     n.Left = walkExpr(n.Left, init)
+func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
+       if n == nil {
+               return n
+       }
+
+       if n, ok := n.(ir.InitNode); ok && init == n.PtrInit() {
+               // not okay to use n->ninit when walking n,
+               // because we might replace n with some other node
+               // and would lose the init list.
+               base.Fatalf("walkExpr init == &n->ninit")
+       }
+
+       if len(n.Init()) != 0 {
+               walkStmtList(n.Init())
+               init.Append(ir.TakeInit(n)...)
+       }
+
+       lno := ir.SetPos(n)
+
+       if base.Flag.LowerW > 1 {
+               ir.Dump("before walk expr", n)
+       }
+
+       if n.Typecheck() != 1 {
+               base.Fatalf("missed typecheck: %+v", n)
+       }
+
+       if n.Type().IsUntyped() {
+               base.Fatalf("expression has untyped type: %+v", n)
+       }
+
+       n = walkExpr1(n, init)
+
+       // Eagerly compute sizes of all expressions for the back end.
+       if typ := n.Type(); typ != nil && typ.Kind() != types.TBLANK && !typ.IsFuncArgStruct() {
+               types.CheckSize(typ)
+       }
+       if n, ok := n.(*ir.Name); ok && n.Heapaddr != nil {
+               types.CheckSize(n.Heapaddr.Type())
+       }
+       if ir.IsConst(n, constant.String) {
+               // Emit string symbol now to avoid emitting
+               // any concurrently during the backend.
+               _ = staticdata.StringSym(n.Pos(), constant.StringVal(n.Val()))
+       }
+
+       if base.Flag.LowerW != 0 && n != nil {
+               ir.Dump("after walk expr", n)
+       }
+
+       base.Pos = lno
+       return n
+}
+
+func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
+       switch n.Op() {
+       default:
+               ir.Dump("walk", n)
+               base.Fatalf("walkExpr: switch 1 unknown op %+v", n.Op())
+               panic("unreachable")
+
+       case ir.ONONAME, ir.OGETG:
+               return n
+
+       case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.OLINKSYMOFFSET:
+               // TODO(mdempsky): Just return n; see discussion on CL 38655.
+               // Perhaps refactor to use Node.mayBeShared for these instead.
+               // If these return early, make sure to still call
+               // StringSym for constant strings.
+               return n
+
+       case ir.OMETHEXPR:
+               // TODO(mdempsky): Do this right after type checking.
+               n := n.(*ir.SelectorExpr)
+               return n.FuncName()
+
+       case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
+               n := n.(*ir.UnaryExpr)
+               n.X = walkExpr(n.X, init)
+               return n
+
+       case ir.ODOTMETH, ir.ODOTINTER:
+               n := n.(*ir.SelectorExpr)
+               n.X = walkExpr(n.X, init)
+               return n
+
+       case ir.OADDR:
+               n := n.(*ir.AddrExpr)
+               n.X = walkExpr(n.X, init)
+               return n
+
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               n.X = walkExpr(n.X, init)
+               return n
+
+       case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               n.X = walkExpr(n.X, init)
+               n.Y = walkExpr(n.Y, init)
+               return n
+
+       case ir.ODOT, ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               return walkDot(n, init)
+
+       case ir.ODOTTYPE, ir.ODOTTYPE2:
+               n := n.(*ir.TypeAssertExpr)
+               return walkDotType(n, init)
+
+       case ir.OLEN, ir.OCAP:
+               n := n.(*ir.UnaryExpr)
+               return walkLenCap(n, init)
+
+       case ir.OCOMPLEX:
+               n := n.(*ir.BinaryExpr)
+               n.X = walkExpr(n.X, init)
+               n.Y = walkExpr(n.Y, init)
+               return n
+
+       case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+               n := n.(*ir.BinaryExpr)
+               return walkCompare(n, init)
+
+       case ir.OANDAND, ir.OOROR:
+               n := n.(*ir.LogicalExpr)
+               return walkLogical(n, init)
+
+       case ir.OPRINT, ir.OPRINTN:
+               return walkPrint(n.(*ir.CallExpr), init)
+
+       case ir.OPANIC:
+               n := n.(*ir.UnaryExpr)
+               return mkcall("gopanic", nil, init, n.X)
+
+       case ir.ORECOVER:
+               n := n.(*ir.CallExpr)
+               return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
+
+       case ir.OCFUNC:
+               return n
+
+       case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
+               return walkCall(n, init)
+
+       case ir.OAS, ir.OASOP:
+               return walkAssign(init, n)
+
+       case ir.OAS2:
+               n := n.(*ir.AssignListStmt)
+               return walkAssignList(init, n)
+
+       // a,b,... = fn()
+       case ir.OAS2FUNC:
+               n := n.(*ir.AssignListStmt)
+               return walkAssignFunc(init, n)
+
+       // x, y = <-c
+       // order.stmt made sure x is addressable or blank.
+       case ir.OAS2RECV:
+               n := n.(*ir.AssignListStmt)
+               return walkAssignRecv(init, n)
+
+       // a,b = m[i]
+       case ir.OAS2MAPR:
+               n := n.(*ir.AssignListStmt)
+               return walkAssignMapRead(init, n)
+
+       case ir.ODELETE:
+               n := n.(*ir.CallExpr)
+               return walkDelete(init, n)
+
+       case ir.OAS2DOTTYPE:
+               n := n.(*ir.AssignListStmt)
+               return walkAssignDotType(n, init)
+
+       case ir.OCONVIFACE:
+               n := n.(*ir.ConvExpr)
+               return walkConvInterface(n, init)
+
+       case ir.OCONV, ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               return walkConv(n, init)
+
+       case ir.ODIV, ir.OMOD:
+               n := n.(*ir.BinaryExpr)
+               return walkDivMod(n, init)
+
+       case ir.OINDEX:
+               n := n.(*ir.IndexExpr)
+               return walkIndex(n, init)
+
+       case ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               return walkIndexMap(n, init)
+
+       case ir.ORECV:
+               base.Fatalf("walkExpr ORECV") // should see inside OAS only
+               panic("unreachable")
+
+       case ir.OSLICEHEADER:
+               n := n.(*ir.SliceHeaderExpr)
+               return walkSliceHeader(n, init)
+
+       case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
+               n := n.(*ir.SliceExpr)
+               return walkSlice(n, init)
+
+       case ir.ONEW:
+               n := n.(*ir.UnaryExpr)
+               return walkNew(n, init)
+
+       case ir.OADDSTR:
+               return walkAddString(n.(*ir.AddStringExpr), init)
+
+       case ir.OAPPEND:
+               // order should make sure we only see OAS(node, OAPPEND), which we handle above.
+               base.Fatalf("append outside assignment")
+               panic("unreachable")
+
+       case ir.OCOPY:
+               return walkCopy(n.(*ir.BinaryExpr), init, base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime)
+
+       case ir.OCLOSE:
+               n := n.(*ir.UnaryExpr)
+               return walkClose(n, init)
+
+       case ir.OMAKECHAN:
+               n := n.(*ir.MakeExpr)
+               return walkMakeChan(n, init)
+
+       case ir.OMAKEMAP:
+               n := n.(*ir.MakeExpr)
+               return walkMakeMap(n, init)
+
+       case ir.OMAKESLICE:
+               n := n.(*ir.MakeExpr)
+               return walkMakeSlice(n, init)
+
+       case ir.OMAKESLICECOPY:
+               n := n.(*ir.MakeExpr)
+               return walkMakeSliceCopy(n, init)
+
+       case ir.ORUNESTR:
+               n := n.(*ir.ConvExpr)
+               return walkRuneToString(n, init)
+
+       case ir.OBYTES2STR, ir.ORUNES2STR:
+               n := n.(*ir.ConvExpr)
+               return walkBytesRunesToString(n, init)
+
+       case ir.OBYTES2STRTMP:
+               n := n.(*ir.ConvExpr)
+               return walkBytesToStringTemp(n, init)
+
+       case ir.OSTR2BYTES:
+               n := n.(*ir.ConvExpr)
+               return walkStringToBytes(n, init)
+
+       case ir.OSTR2BYTESTMP:
+               n := n.(*ir.ConvExpr)
+               return walkStringToBytesTemp(n, init)
+
+       case ir.OSTR2RUNES:
+               n := n.(*ir.ConvExpr)
+               return walkStringToRunes(n, init)
+
+       case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
+               return walkCompLit(n, init)
+
+       case ir.OSEND:
+               n := n.(*ir.SendStmt)
+               return walkSend(n, init)
+
+       case ir.OCLOSURE:
+               return walkClosure(n.(*ir.ClosureExpr), init)
+
+       case ir.OCALLPART:
+               return walkCallPart(n.(*ir.SelectorExpr), init)
+       }
+
+       // No return! Each case must return (or panic),
+       // to avoid confusion about what gets returned
+       // in the presence of type assertions.
+}
+
+// walk the whole tree of the body of an
+// expression or simple statement.
+// the types expressions are calculated.
+// compile-time constants are evaluated.
+// complex side effects like statements are appended to init
+func walkExprList(s []ir.Node, init *ir.Nodes) {
+       for i := range s {
+               s[i] = walkExpr(s[i], init)
+       }
+}
+
+func walkExprListCheap(s []ir.Node, init *ir.Nodes) {
+       for i, n := range s {
+               s[i] = cheapExpr(n, init)
+               s[i] = walkExpr(s[i], init)
+       }
+}
+
+func walkExprListSafe(s []ir.Node, init *ir.Nodes) {
+       for i, n := range s {
+               s[i] = safeExpr(n, init)
+               s[i] = walkExpr(s[i], init)
+       }
+}
+
+// return side-effect free and cheap n, appending side effects to init.
+// result may not be assignable.
+func cheapExpr(n ir.Node, init *ir.Nodes) ir.Node {
+       switch n.Op() {
+       case ir.ONAME, ir.OLITERAL, ir.ONIL:
+               return n
+       }
+
+       return copyExpr(n, n.Type(), init)
+}
+
+// return side effect-free n, appending side effects to init.
+// result is assignable if n is.
+func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
+       if n == nil {
+               return nil
+       }
+
+       if len(n.Init()) != 0 {
+               walkStmtList(n.Init())
+               init.Append(ir.TakeInit(n)...)
+       }
+
+       switch n.Op() {
+       case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.OLINKSYMOFFSET:
+               return n
+
+       case ir.OLEN, ir.OCAP:
+               n := n.(*ir.UnaryExpr)
+               l := safeExpr(n.X, init)
+               if l == n.X {
+                       return n
+               }
+               a := ir.Copy(n).(*ir.UnaryExpr)
+               a.X = l
+               return walkExpr(typecheck.Expr(a), init)
+
+       case ir.ODOT, ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               l := safeExpr(n.X, init)
+               if l == n.X {
+                       return n
+               }
+               a := ir.Copy(n).(*ir.SelectorExpr)
+               a.X = l
+               return walkExpr(typecheck.Expr(a), init)
+
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               l := safeExpr(n.X, init)
+               if l == n.X {
+                       return n
+               }
+               a := ir.Copy(n).(*ir.StarExpr)
+               a.X = l
+               return walkExpr(typecheck.Expr(a), init)
+
+       case ir.OINDEX, ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               l := safeExpr(n.X, init)
+               r := safeExpr(n.Index, init)
+               if l == n.X && r == n.Index {
+                       return n
+               }
+               a := ir.Copy(n).(*ir.IndexExpr)
+               a.X = l
+               a.Index = r
+               return walkExpr(typecheck.Expr(a), init)
+
+       case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               if isStaticCompositeLiteral(n) {
+                       return n
+               }
+       }
+
+       // make a copy; must not be used as an lvalue
+       if ir.IsAddressable(n) {
+               base.Fatalf("missing lvalue case in safeExpr: %v", n)
+       }
+       return cheapExpr(n, init)
+}
+
+func copyExpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
+       l := typecheck.Temp(t)
+       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
+       return l
+}
+
+func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
+       c := len(n.List)
+
+       if c < 2 {
+               base.Fatalf("walkAddString count %d too small", c)
+       }
+
+       buf := typecheck.NodNil()
+       if n.Esc() == ir.EscNone {
+               sz := int64(0)
+               for _, n1 := range n.List {
+                       if n1.Op() == ir.OLITERAL {
+                               sz += int64(len(ir.StringVal(n1)))
+                       }
+               }
+
+               // Don't allocate the buffer if the result won't fit.
+               if sz < tmpstringbufsize {
+                       // Create temporary buffer for result string on stack.
+                       buf = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
+               }
+       }
+
+       // build list of string arguments
+       args := []ir.Node{buf}
+       for _, n2 := range n.List {
+               args = append(args, typecheck.Conv(n2, types.Types[types.TSTRING]))
+       }
+
+       var fn string
+       if c <= 5 {
+               // small numbers of strings use direct runtime helpers.
+               // note: order.expr knows this cutoff too.
+               fn = fmt.Sprintf("concatstring%d", c)
+       } else {
+               // large numbers of strings are passed to the runtime as a slice.
+               fn = "concatstrings"
+
+               t := types.NewSlice(types.Types[types.TSTRING])
+               // args[1:] to skip buf arg
+               slice := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(t), args[1:])
+               slice.Prealloc = n.Prealloc
+               args = []ir.Node{buf, slice}
+               slice.SetEsc(ir.EscNone)
+       }
+
+       cat := typecheck.LookupRuntime(fn)
+       r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
+       r.Args = args
+       r1 := typecheck.Expr(r)
+       r1 = walkExpr(r1, init)
+       r1.SetType(n.Type())
+
+       return r1
+}
+
+// walkCall walks an OCALLFUNC, OCALLINTER, or OCALLMETH node.
+func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+       if n.Op() == ir.OCALLINTER || n.Op() == ir.OCALLMETH {
+               // We expect both interface call reflect.Type.Method and concrete
+               // call reflect.(*rtype).Method.
+               usemethod(n)
+       }
+       if n.Op() == ir.OCALLINTER {
+               reflectdata.MarkUsedIfaceMethod(n)
+       }
+
+       if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
+               directClosureCall(n)
+       }
+
+       walkCall1(n, init)
+       return n
+}
+
+func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
+       if n.Walked() {
+               return // already walked
+       }
+       n.SetWalked(true)
+
+       // If this is a method call t.M(...),
+       // rewrite into a function call T.M(t, ...).
+       // TODO(mdempsky): Do this right after type checking.
+       if n.Op() == ir.OCALLMETH {
+               withRecv := make([]ir.Node, len(n.Args)+1)
+               dot := n.X.(*ir.SelectorExpr)
+               withRecv[0] = dot.X
+               copy(withRecv[1:], n.Args)
+               n.Args = withRecv
+
+               dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
+
+               n.SetOp(ir.OCALLFUNC)
+               n.X = typecheck.Expr(dot)
+       }
+
+       args := n.Args
+       params := n.X.Type().Params()
+
+       n.X = walkExpr(n.X, init)
+       walkExprList(args, init)
+
+       for i, arg := range args {
+               // Validate argument and parameter types match.
+               param := params.Field(i)
+               if !types.Identical(arg.Type(), param.Type) {
+                       base.FatalfAt(n.Pos(), "assigning %L to parameter %v (type %v)", arg, param.Sym, param.Type)
+               }
+
+               // For any argument whose evaluation might require a function call,
+               // store that argument into a temporary variable,
+               // to prevent that calls from clobbering arguments already on the stack.
+               if mayCall(arg) {
+                       // assignment of arg to Temp
+                       tmp := typecheck.Temp(param.Type)
+                       init.Append(convas(typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, arg)).(*ir.AssignStmt), init))
+                       // replace arg with temp
+                       args[i] = tmp
+               }
+       }
+
+       n.Args = args
+}
+
+// walkDivMod walks an ODIV or OMOD node.
+func walkDivMod(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+       n.Y = walkExpr(n.Y, init)
+
+       // rewrite complex div into function call.
+       et := n.X.Type().Kind()
+
+       if types.IsComplex[et] && n.Op() == ir.ODIV {
+               t := n.Type()
+               call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, typecheck.Conv(n.X, types.Types[types.TCOMPLEX128]), typecheck.Conv(n.Y, types.Types[types.TCOMPLEX128]))
+               return typecheck.Conv(call, t)
+       }
+
+       // Nothing to do for float divisions.
+       if types.IsFloat[et] {
+               return n
+       }
+
+       // rewrite 64-bit div and mod on 32-bit architectures.
+       // TODO: Remove this code once we can introduce
+       // runtime calls late in SSA processing.
+       if types.RegSize < 8 && (et == types.TINT64 || et == types.TUINT64) {
+               if n.Y.Op() == ir.OLITERAL {
+                       // Leave div/mod by constant powers of 2 or small 16-bit constants.
+                       // The SSA backend will handle those.
+                       switch et {
+                       case types.TINT64:
+                               c := ir.Int64Val(n.Y)
+                               if c < 0 {
+                                       c = -c
+                               }
+                               if c != 0 && c&(c-1) == 0 {
+                                       return n
+                               }
+                       case types.TUINT64:
+                               c := ir.Uint64Val(n.Y)
+                               if c < 1<<16 {
+                                       return n
+                               }
+                               if c != 0 && c&(c-1) == 0 {
+                                       return n
+                               }
+                       }
+               }
+               var fn string
+               if et == types.TINT64 {
+                       fn = "int64"
+               } else {
+                       fn = "uint64"
+               }
+               if n.Op() == ir.ODIV {
+                       fn += "div"
+               } else {
+                       fn += "mod"
+               }
+               return mkcall(fn, n.Type(), init, typecheck.Conv(n.X, types.Types[et]), typecheck.Conv(n.Y, types.Types[et]))
+       }
+       return n
+}
+
+// walkDot walks an ODOT or ODOTPTR node.
+func walkDot(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
+       usefield(n)
+       n.X = walkExpr(n.X, init)
+       return n
+}
+
+// walkDotType walks an ODOTTYPE or ODOTTYPE2 node.
+func walkDotType(n *ir.TypeAssertExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+       // Set up interface type addresses for back end.
+       if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
+               n.Itab = reflectdata.ITabAddr(n.Type(), n.X.Type())
+       }
+       return n
+}
+
+// walkIndex walks an OINDEX node.
+func walkIndex(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+
+       // save the original node for bounds checking elision.
+       // If it was a ODIV/OMOD walk might rewrite it.
+       r := n.Index
+
+       n.Index = walkExpr(n.Index, init)
+
+       // if range of type cannot exceed static array bound,
+       // disable bounds check.
+       if n.Bounded() {
+               return n
+       }
+       t := n.X.Type()
+       if t != nil && t.IsPtr() {
+               t = t.Elem()
+       }
+       if t.IsArray() {
+               n.SetBounded(bounded(r, t.NumElem()))
+               if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
+                       base.Warn("index bounds check elided")
+               }
+               if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
+                       base.Errorf("index out of bounds")
+               }
+       } else if ir.IsConst(n.X, constant.String) {
+               n.SetBounded(bounded(r, int64(len(ir.StringVal(n.X)))))
+               if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
+                       base.Warn("index bounds check elided")
+               }
+               if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
+                       base.Errorf("index out of bounds")
+               }
+       }
+
+       if ir.IsConst(n.Index, constant.Int) {
+               if v := n.Index.Val(); constant.Sign(v) < 0 || ir.ConstOverflow(v, types.Types[types.TINT]) {
+                       base.Errorf("index out of bounds")
+               }
+       }
+       return n
+}
+
+// walkIndexMap walks an OINDEXMAP node.
+func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
+       // Replace m[k] with *map{access1,assign}(maptype, m, &k)
+       n.X = walkExpr(n.X, init)
+       n.Index = walkExpr(n.Index, init)
+       map_ := n.X
+       key := n.Index
+       t := map_.Type()
+       var call *ir.CallExpr
+       if n.Assigned {
+               // This m[k] expression is on the left-hand side of an assignment.
+               fast := mapfast(t)
+               if fast == mapslow {
+                       // standard version takes key by reference.
+                       // order.expr made sure key is addressable.
+                       key = typecheck.NodAddr(key)
+               }
+               call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+       } else {
+               // m[k] is not the target of an assignment.
+               fast := mapfast(t)
+               if fast == mapslow {
+                       // standard version takes key by reference.
+                       // order.expr made sure key is addressable.
+                       key = typecheck.NodAddr(key)
+               }
+
+               if w := t.Elem().Width; w <= zeroValSize {
+                       call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
+               } else {
+                       z := reflectdata.ZeroAddr(w)
+                       call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
+               }
+       }
+       call.SetType(types.NewPtr(t.Elem()))
+       call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
+       star := ir.NewStarExpr(base.Pos, call)
+       star.SetType(t.Elem())
+       star.SetTypecheck(1)
+       return star
+}
+
+// walkLogical walks an OANDAND or OOROR node.
+func walkLogical(n *ir.LogicalExpr, init *ir.Nodes) ir.Node {
+       n.X = walkExpr(n.X, init)
+
+       // cannot put side effects from n.Right on init,
+       // because they cannot run before n.Left is checked.
+       // save elsewhere and store on the eventual n.Right.
+       var ll ir.Nodes
+
+       n.Y = walkExpr(n.Y, &ll)
+       n.Y = ir.InitExpr(ll, n.Y)
+       return n
+}
+
+// walkSend walks an OSEND node.
+func walkSend(n *ir.SendStmt, init *ir.Nodes) ir.Node {
+       n1 := n.Value
+       n1 = typecheck.AssignConv(n1, n.Chan.Type().Elem(), "chan send")
+       n1 = walkExpr(n1, init)
+       n1 = typecheck.NodAddr(n1)
+       return mkcall1(chanfn("chansend1", 2, n.Chan.Type()), nil, init, n.Chan, n1)
+}
+
+// walkSlice walks an OSLICE, OSLICEARR, OSLICESTR, OSLICE3, or OSLICE3ARR node.
+func walkSlice(n *ir.SliceExpr, init *ir.Nodes) ir.Node {
+
+       checkSlice := ir.ShouldCheckPtr(ir.CurFunc, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
+       if checkSlice {
+               conv := n.X.(*ir.ConvExpr)
+               conv.X = walkExpr(conv.X, init)
+       } else {
+               n.X = walkExpr(n.X, init)
+       }
+
+       n.Low = walkExpr(n.Low, init)
+       if n.Low != nil && ir.IsZero(n.Low) {
+               // Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
+               n.Low = nil
+       }
+       n.High = walkExpr(n.High, init)
+       n.Max = walkExpr(n.Max, init)
+       if checkSlice {
+               n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, n.Max)
+       }
+
+       if n.Op().IsSlice3() {
+               if n.Max != nil && n.Max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, n.Max.(*ir.UnaryExpr).X) {
+                       // Reduce x[i:j:cap(x)] to x[i:j].
+                       if n.Op() == ir.OSLICE3 {
+                               n.SetOp(ir.OSLICE)
+                       } else {
+                               n.SetOp(ir.OSLICEARR)
+                       }
+                       return reduceSlice(n)
+               }
+               return n
+       }
+       return reduceSlice(n)
+}
+
+// walkSliceHeader walks an OSLICEHEADER node.
+func walkSliceHeader(n *ir.SliceHeaderExpr, init *ir.Nodes) ir.Node {
+       n.Ptr = walkExpr(n.Ptr, init)
+       n.Len = walkExpr(n.Len, init)
+       n.Cap = walkExpr(n.Cap, init)
+       return n
+}
+
+// TODO(josharian): combine this with its caller and simplify
+func reduceSlice(n *ir.SliceExpr) ir.Node {
+       if n.High != nil && n.High.Op() == ir.OLEN && ir.SameSafeExpr(n.X, n.High.(*ir.UnaryExpr).X) {
+               // Reduce x[i:len(x)] to x[i:].
+               n.High = nil
+       }
+       if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && n.Low == nil && n.High == nil {
+               // Reduce x[:] to x.
+               if base.Debug.Slice > 0 {
+                       base.Warn("slice: omit slice operation")
+               }
+               return n.X
+       }
+       return n
+}
+
+// return 1 if integer n must be in range [0, max), 0 otherwise
+func bounded(n ir.Node, max int64) bool {
+       if n.Type() == nil || !n.Type().IsInteger() {
+               return false
+       }
+
+       sign := n.Type().IsSigned()
+       bits := int32(8 * n.Type().Width)
+
+       if ir.IsSmallIntConst(n) {
+               v := ir.Int64Val(n)
+               return 0 <= v && v < max
+       }
+
+       switch n.Op() {
+       case ir.OAND, ir.OANDNOT:
+               n := n.(*ir.BinaryExpr)
+               v := int64(-1)
+               switch {
+               case ir.IsSmallIntConst(n.X):
+                       v = ir.Int64Val(n.X)
+               case ir.IsSmallIntConst(n.Y):
+                       v = ir.Int64Val(n.Y)
+                       if n.Op() == ir.OANDNOT {
+                               v = ^v
+                               if !sign {
+                                       v &= 1<<uint(bits) - 1
+                               }
+                       }
+               }
+               if 0 <= v && v < max {
+                       return true
+               }
+
+       case ir.OMOD:
+               n := n.(*ir.BinaryExpr)
+               if !sign && ir.IsSmallIntConst(n.Y) {
+                       v := ir.Int64Val(n.Y)
+                       if 0 <= v && v <= max {
+                               return true
+                       }
+               }
+
+       case ir.ODIV:
+               n := n.(*ir.BinaryExpr)
+               if !sign && ir.IsSmallIntConst(n.Y) {
+                       v := ir.Int64Val(n.Y)
+                       for bits > 0 && v >= 2 {
+                               bits--
+                               v >>= 1
+                       }
+               }
+
+       case ir.ORSH:
+               n := n.(*ir.BinaryExpr)
+               if !sign && ir.IsSmallIntConst(n.Y) {
+                       v := ir.Int64Val(n.Y)
+                       if v > int64(bits) {
+                               return true
+                       }
+                       bits -= int32(v)
+               }
+       }
+
+       if !sign && bits <= 62 && 1<<uint(bits) <= max {
+               return true
+       }
+
+       return false
+}
+
+// usemethod checks interface method calls for uses of reflect.Type.Method.
+func usemethod(n *ir.CallExpr) {
+       t := n.X.Type()
+
+       // Looking for either of:
+       //      Method(int) reflect.Method
+       //      MethodByName(string) (reflect.Method, bool)
+       //
+       // TODO(crawshaw): improve precision of match by working out
+       //                 how to check the method name.
+       if n := t.NumParams(); n != 1 {
+               return
+       }
+       if n := t.NumResults(); n != 1 && n != 2 {
+               return
+       }
+       p0 := t.Params().Field(0)
+       res0 := t.Results().Field(0)
+       var res1 *types.Field
+       if t.NumResults() == 2 {
+               res1 = t.Results().Field(1)
+       }
+
+       if res1 == nil {
+               if p0.Type.Kind() != types.TINT {
+                       return
+               }
+       } else {
+               if !p0.Type.IsString() {
+                       return
+               }
+               if !res1.Type.IsBoolean() {
+                       return
+               }
+       }
+
+       // Don't mark reflect.(*rtype).Method, etc. themselves in the reflect package.
+       // Those functions may be alive via the itab, which should not cause all methods
+       // alive. We only want to mark their callers.
+       if base.Ctxt.Pkgpath == "reflect" {
+               switch ir.CurFunc.Nname.Sym().Name { // TODO: is there a better way than hardcoding the names?
+               case "(*rtype).Method", "(*rtype).MethodByName", "(*interfaceType).Method", "(*interfaceType).MethodByName":
+                       return
+               }
+       }
+
+       // Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
+       //       (including global variables such as numImports - was issue #19028).
+       // Also need to check for reflect package itself (see Issue #38515).
+       if s := res0.Type.Sym(); s != nil && s.Name == "Method" && types.IsReflectPkg(s.Pkg) {
+               ir.CurFunc.SetReflectMethod(true)
+               // The LSym is initialized at this point. We need to set the attribute on the LSym.
+               ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
+       }
+}
+
+func usefield(n *ir.SelectorExpr) {
+       if objabi.Fieldtrack_enabled == 0 {
+               return
+       }
+
+       switch n.Op() {
+       default:
+               base.Fatalf("usefield %v", n.Op())
+
+       case ir.ODOT, ir.ODOTPTR:
+               break
+       }
+
+       field := n.Selection
+       if field == nil {
+               base.Fatalf("usefield %v %v without paramfld", n.X.Type(), n.Sel)
+       }
+       if field.Sym != n.Sel {
+               base.Fatalf("field inconsistency: %v != %v", field.Sym, n.Sel)
+       }
+       if !strings.Contains(field.Note, "go:\"track\"") {
+               return
+       }
+
+       outer := n.X.Type()
+       if outer.IsPtr() {
+               outer = outer.Elem()
+       }
+       if outer.Sym() == nil {
+               base.Errorf("tracked field must be in named struct type")
+       }
+       if !types.IsExported(field.Sym.Name) {
+               base.Errorf("tracked field must be exported (upper case)")
+       }
+
+       sym := reflectdata.TrackSym(outer, field)
+       if ir.CurFunc.FieldTrack == nil {
+               ir.CurFunc.FieldTrack = make(map[*obj.LSym]struct{})
+       }
+       ir.CurFunc.FieldTrack[sym] = struct{}{}
+}

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
new file mode 100644 (file)
index 0000000..fe0b6a0
--- /dev/null
+++ b/src/cmd/compile/internal/walk/order.go
@@ -0,0 +1,1437 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "fmt"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/escape"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/staticinit"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// Rewrite tree to use separate statements to enforce
+// order of evaluation. Makes walk easier, because it
+// can (after this runs) reorder at will within an expression.
+//
+// Rewrite m[k] op= r into m[k] = m[k] op r if op is / or %.
+//
+// Introduce temporaries as needed by runtime routines.
+// For example, the map runtime routines take the map key
+// by reference, so make sure all map keys are addressable
+// by copying them to temporaries as needed.
+// The same is true for channel operations.
+//
+// Arrange that map index expressions only appear in direct
+// assignments x = m[k] or m[k] = x, never in larger expressions.
+//
+// Arrange that receive expressions only appear in direct assignments
+// x = <-c or as standalone statements <-c, never in larger expressions.
+
+// TODO(rsc): The temporary introduction during multiple assignments
+// should be moved into this file, so that the temporaries can be cleaned
+// and so that conversions implicit in the OAS2FUNC and OAS2RECV
+// nodes can be made explicit and then have their temporaries cleaned.
+
+// TODO(rsc): Goto and multilevel break/continue can jump over
+// inserted VARKILL annotations. Work out a way to handle these.
+// The current implementation is safe, in that it will execute correctly.
+// But it won't reuse temporaries as aggressively as it might, and
+// it can result in unnecessary zeroing of those variables in the function
+// prologue.
+
+// orderState holds state during the ordering process.
+type orderState struct {
+       out  []ir.Node             // list of generated statements
+       temp []*ir.Name            // stack of temporary variables
+       free map[string][]*ir.Name // free list of unused temporaries, by type.LongString().
+       edit func(ir.Node) ir.Node // cached closure of o.exprNoLHS
+}
+
+// Order rewrites fn.Nbody to apply the ordering constraints
+// described in the comment at the top of the file.
+func order(fn *ir.Func) {
+       if base.Flag.W > 1 {
+               s := fmt.Sprintf("\nbefore order %v", fn.Sym())
+               ir.DumpList(s, fn.Body)
+       }
+
+       orderBlock(&fn.Body, map[string][]*ir.Name{})
+}
+
+// append typechecks stmt and appends it to out.
+func (o *orderState) append(stmt ir.Node) {
+       o.out = append(o.out, typecheck.Stmt(stmt))
+}
+
+// newTemp allocates a new temporary with the given type,
+// pushes it onto the temp stack, and returns it.
+// If clear is true, newTemp emits code to zero the temporary.
+func (o *orderState) newTemp(t *types.Type, clear bool) *ir.Name {
+       var v *ir.Name
+       // Note: LongString is close to the type equality we want,
+       // but not exactly. We still need to double-check with types.Identical.
+       key := t.LongString()
+       a := o.free[key]
+       for i, n := range a {
+               if types.Identical(t, n.Type()) {
+                       v = a[i]
+                       a[i] = a[len(a)-1]
+                       a = a[:len(a)-1]
+                       o.free[key] = a
+                       break
+               }
+       }
+       if v == nil {
+               v = typecheck.Temp(t)
+       }
+       if clear {
+               o.append(ir.NewAssignStmt(base.Pos, v, nil))
+       }
+
+       o.temp = append(o.temp, v)
+       return v
+}
+
+// copyExpr behaves like newTemp but also emits
+// code to initialize the temporary to the value n.
+func (o *orderState) copyExpr(n ir.Node) *ir.Name {
+       return o.copyExpr1(n, false)
+}
+
+// copyExprClear is like copyExpr but clears the temp before assignment.
+// It is provided for use when the evaluation of tmp = n turns into
+// a function call that is passed a pointer to the temporary as the output space.
+// If the call blocks before tmp has been written,
+// the garbage collector will still treat the temporary as live,
+// so we must zero it before entering that call.
+// Today, this only happens for channel receive operations.
+// (The other candidate would be map access, but map access
+// returns a pointer to the result data instead of taking a pointer
+// to be filled in.)
+func (o *orderState) copyExprClear(n ir.Node) *ir.Name {
+       return o.copyExpr1(n, true)
+}
+
+func (o *orderState) copyExpr1(n ir.Node, clear bool) *ir.Name {
+       t := n.Type()
+       v := o.newTemp(t, clear)
+       o.append(ir.NewAssignStmt(base.Pos, v, n))
+       return v
+}
+
+// cheapExpr returns a cheap version of n.
+// The definition of cheap is that n is a variable or constant.
+// If not, cheapExpr allocates a new tmp, emits tmp = n,
+// and then returns tmp.
+func (o *orderState) cheapExpr(n ir.Node) ir.Node {
+       if n == nil {
+               return nil
+       }
+
+       switch n.Op() {
+       case ir.ONAME, ir.OLITERAL, ir.ONIL:
+               return n
+       case ir.OLEN, ir.OCAP:
+               n := n.(*ir.UnaryExpr)
+               l := o.cheapExpr(n.X)
+               if l == n.X {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.UnaryExpr)
+               a.X = l
+               return typecheck.Expr(a)
+       }
+
+       return o.copyExpr(n)
+}
+
+// safeExpr returns a safe version of n.
+// The definition of safe is that n can appear multiple times
+// without violating the semantics of the original program,
+// and that assigning to the safe version has the same effect
+// as assigning to the original n.
+//
+// The intended use is to apply to x when rewriting x += y into x = x + y.
+func (o *orderState) safeExpr(n ir.Node) ir.Node {
+       switch n.Op() {
+       case ir.ONAME, ir.OLITERAL, ir.ONIL:
+               return n
+
+       case ir.OLEN, ir.OCAP:
+               n := n.(*ir.UnaryExpr)
+               l := o.safeExpr(n.X)
+               if l == n.X {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.UnaryExpr)
+               a.X = l
+               return typecheck.Expr(a)
+
+       case ir.ODOT:
+               n := n.(*ir.SelectorExpr)
+               l := o.safeExpr(n.X)
+               if l == n.X {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.SelectorExpr)
+               a.X = l
+               return typecheck.Expr(a)
+
+       case ir.ODOTPTR:
+               n := n.(*ir.SelectorExpr)
+               l := o.cheapExpr(n.X)
+               if l == n.X {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.SelectorExpr)
+               a.X = l
+               return typecheck.Expr(a)
+
+       case ir.ODEREF:
+               n := n.(*ir.StarExpr)
+               l := o.cheapExpr(n.X)
+               if l == n.X {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.StarExpr)
+               a.X = l
+               return typecheck.Expr(a)
+
+       case ir.OINDEX, ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               var l ir.Node
+               if n.X.Type().IsArray() {
+                       l = o.safeExpr(n.X)
+               } else {
+                       l = o.cheapExpr(n.X)
+               }
+               r := o.cheapExpr(n.Index)
+               if l == n.X && r == n.Index {
+                       return n
+               }
+               a := ir.SepCopy(n).(*ir.IndexExpr)
+               a.X = l
+               a.Index = r
+               return typecheck.Expr(a)
+
+       default:
+               base.Fatalf("order.safeExpr %v", n.Op())
+               return nil // not reached
+       }
+}
+
+// isaddrokay reports whether it is okay to pass n's address to runtime routines.
+// Taking the address of a variable makes the liveness and optimization analyses
+// lose track of where the variable's lifetime ends. To avoid hurting the analyses
+// of ordinary stack variables, those are not 'isaddrokay'. Temporaries are okay,
+// because we emit explicit VARKILL instructions marking the end of those
+// temporaries' lifetimes.
+func isaddrokay(n ir.Node) bool {
+       return ir.IsAddressable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class == ir.PEXTERN || ir.IsAutoTmp(n))
+}
+
+// addrTemp ensures that n is okay to pass by address to runtime routines.
+// If the original argument n is not okay, addrTemp creates a tmp, emits
+// tmp = n, and then returns tmp.
+// The result of addrTemp MUST be assigned back to n, e.g.
+//     n.Left = o.addrTemp(n.Left)
+func (o *orderState) addrTemp(n ir.Node) ir.Node {
+       if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
+               // TODO: expand this to all static composite literal nodes?
+               n = typecheck.DefaultLit(n, nil)
+               types.CalcSize(n.Type())
+               vstat := readonlystaticname(n.Type())
+               var s staticinit.Schedule
+               s.StaticAssign(vstat, 0, n, n.Type())
+               if s.Out != nil {
+                       base.Fatalf("staticassign of const generated code: %+v", n)
+               }
+               vstat = typecheck.Expr(vstat).(*ir.Name)
+               return vstat
+       }
+       if isaddrokay(n) {
+               return n
+       }
+       return o.copyExpr(n)
+}
+
+// mapKeyTemp prepares n to be a key in a map runtime call and returns n.
+// It should only be used for map runtime calls which have *_fast* versions.
+func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
+       // Most map calls need to take the address of the key.
+       // Exception: map*_fast* calls. See golang.org/issue/19015.
+       if mapfast(t) == mapslow {
+               return o.addrTemp(n)
+       }
+       return n
+}
+
+// mapKeyReplaceStrConv replaces OBYTES2STR by OBYTES2STRTMP
+// in n to avoid string allocations for keys in map lookups.
+// Returns a bool that signals if a modification was made.
+//
+// For:
+//  x = m[string(k)]
+//  x = m[T1{... Tn{..., string(k), ...}]
+// where k is []byte, T1 to Tn is a nesting of struct and array literals,
+// the allocation of backing bytes for the string can be avoided
+// by reusing the []byte backing array. These are special cases
+// for avoiding allocations when converting byte slices to strings.
+// It would be nice to handle these generally, but because
+// []byte keys are not allowed in maps, the use of string(k)
+// comes up in important cases in practice. See issue 3512.
+func mapKeyReplaceStrConv(n ir.Node) bool {
+       var replaced bool
+       switch n.Op() {
+       case ir.OBYTES2STR:
+               n := n.(*ir.ConvExpr)
+               n.SetOp(ir.OBYTES2STRTMP)
+               replaced = true
+       case ir.OSTRUCTLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, elem := range n.List {
+                       elem := elem.(*ir.StructKeyExpr)
+                       if mapKeyReplaceStrConv(elem.Value) {
+                               replaced = true
+                       }
+               }
+       case ir.OARRAYLIT:
+               n := n.(*ir.CompLitExpr)
+               for _, elem := range n.List {
+                       if elem.Op() == ir.OKEY {
+                               elem = elem.(*ir.KeyExpr).Value
+                       }
+                       if mapKeyReplaceStrConv(elem) {
+                               replaced = true
+                       }
+               }
+       }
+       return replaced
+}
+
+type ordermarker int
+
+// markTemp returns the top of the temporary variable stack.
+func (o *orderState) markTemp() ordermarker {
+       return ordermarker(len(o.temp))
+}
+
+// popTemp pops temporaries off the stack until reaching the mark,
+// which must have been returned by markTemp.
+func (o *orderState) popTemp(mark ordermarker) {
+       for _, n := range o.temp[mark:] {
+               key := n.Type().LongString()
+               o.free[key] = append(o.free[key], n)
+       }
+       o.temp = o.temp[:mark]
+}
+
+// cleanTempNoPop emits VARKILL instructions to *out
+// for each temporary above the mark on the temporary stack.
+// It does not pop the temporaries from the stack.
+func (o *orderState) cleanTempNoPop(mark ordermarker) []ir.Node {
+       var out []ir.Node
+       for i := len(o.temp) - 1; i >= int(mark); i-- {
+               n := o.temp[i]
+               out = append(out, typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARKILL, n)))
+       }
+       return out
+}
+
+// cleanTemp emits VARKILL instructions for each temporary above the
+// mark on the temporary stack and removes them from the stack.
+func (o *orderState) cleanTemp(top ordermarker) {
+       o.out = append(o.out, o.cleanTempNoPop(top)...)
+       o.popTemp(top)
+}
+
+// stmtList orders each of the statements in the list.
+func (o *orderState) stmtList(l ir.Nodes) {
+       s := l
+       for i := range s {
+               orderMakeSliceCopy(s[i:])
+               o.stmt(s[i])
+       }
+}
+
+// orderMakeSliceCopy matches the pattern:
+//  m = OMAKESLICE([]T, x); OCOPY(m, s)
+// and rewrites it to:
+//  m = OMAKESLICECOPY([]T, x, s); nil
+func orderMakeSliceCopy(s []ir.Node) {
+       if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
+               return
+       }
+       if len(s) < 2 || s[0] == nil || s[0].Op() != ir.OAS || s[1] == nil || s[1].Op() != ir.OCOPY {
+               return
+       }
+
+       as := s[0].(*ir.AssignStmt)
+       cp := s[1].(*ir.BinaryExpr)
+       if as.Y == nil || as.Y.Op() != ir.OMAKESLICE || ir.IsBlank(as.X) ||
+               as.X.Op() != ir.ONAME || cp.X.Op() != ir.ONAME || cp.Y.Op() != ir.ONAME ||
+               as.X.Name() != cp.X.Name() || cp.X.Name() == cp.Y.Name() {
+               // The line above this one is correct with the differing equality operators:
+               // we want as.X and cp.X to be the same name,
+               // but we want the initial data to be coming from a different name.
+               return
+       }
+
+       mk := as.Y.(*ir.MakeExpr)
+       if mk.Esc() == ir.EscNone || mk.Len == nil || mk.Cap != nil {
+               return
+       }
+       mk.SetOp(ir.OMAKESLICECOPY)
+       mk.Cap = cp.Y
+       // Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
+       mk.SetBounded(mk.Len.Op() == ir.OLEN && ir.SameSafeExpr(mk.Len.(*ir.UnaryExpr).X, cp.Y))
+       as.Y = typecheck.Expr(mk)
+       s[1] = nil // remove separate copy call
+}
+
+// edge inserts coverage instrumentation for libfuzzer.
+func (o *orderState) edge() {
+       if base.Debug.Libfuzzer == 0 {
+               return
+       }
+
+       // Create a new uint8 counter to be allocated in section
+       // __libfuzzer_extra_counters.
+       counter := staticinit.StaticName(types.Types[types.TUINT8])
+       counter.SetLibfuzzerExtraCounter(true)
+
+       // counter += 1
+       incr := ir.NewAssignOpStmt(base.Pos, ir.OADD, counter, ir.NewInt(1))
+       o.append(incr)
+}
+
+// orderBlock orders the block of statements in n into a new slice,
+// and then replaces the old slice in n with the new slice.
+// free is a map that can be used to obtain temporary variables by type.
+func orderBlock(n *ir.Nodes, free map[string][]*ir.Name) {
+       var order orderState
+       order.free = free
+       mark := order.markTemp()
+       order.edge()
+       order.stmtList(*n)
+       order.cleanTemp(mark)
+       *n = order.out
+}
+
+// exprInPlace orders the side effects in *np and
+// leaves them as the init list of the final *np.
+// The result of exprInPlace MUST be assigned back to n, e.g.
+//     n.Left = o.exprInPlace(n.Left)
+func (o *orderState) exprInPlace(n ir.Node) ir.Node {
+       var order orderState
+       order.free = o.free
+       n = order.expr(n, nil)
+       n = ir.InitExpr(order.out, n)
+
+       // insert new temporaries from order
+       // at head of outer list.
+       o.temp = append(o.temp, order.temp...)
+       return n
+}
+
+// orderStmtInPlace orders the side effects of the single statement *np
+// and replaces it with the resulting statement list.
+// The result of orderStmtInPlace MUST be assigned back to n, e.g.
+//     n.Left = orderStmtInPlace(n.Left)
+// free is a map that can be used to obtain temporary variables by type.
+func orderStmtInPlace(n ir.Node, free map[string][]*ir.Name) ir.Node {
+       var order orderState
+       order.free = free
+       mark := order.markTemp()
+       order.stmt(n)
+       order.cleanTemp(mark)
+       return ir.NewBlockStmt(src.NoXPos, order.out)
+}
+
+// init moves n's init list to o.out.
+func (o *orderState) init(n ir.Node) {
+       if ir.MayBeShared(n) {
+               // For concurrency safety, don't mutate potentially shared nodes.
+               // First, ensure that no work is required here.
+               if len(n.Init()) > 0 {
+                       base.Fatalf("order.init shared node with ninit")
+               }
+               return
+       }
+       o.stmtList(ir.TakeInit(n))
+}
+
+// call orders the call expression n.
+// n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
+func (o *orderState) call(nn ir.Node) {
+       if len(nn.Init()) > 0 {
+               // Caller should have already called o.init(nn).
+               base.Fatalf("%v with unexpected ninit", nn.Op())
+       }
+
+       // Builtin functions.
+       if nn.Op() != ir.OCALLFUNC && nn.Op() != ir.OCALLMETH && nn.Op() != ir.OCALLINTER {
+               switch n := nn.(type) {
+               default:
+                       base.Fatalf("unexpected call: %+v", n)
+               case *ir.UnaryExpr:
+                       n.X = o.expr(n.X, nil)
+               case *ir.ConvExpr:
+                       n.X = o.expr(n.X, nil)
+               case *ir.BinaryExpr:
+                       n.X = o.expr(n.X, nil)
+                       n.Y = o.expr(n.Y, nil)
+               case *ir.MakeExpr:
+                       n.Len = o.expr(n.Len, nil)
+                       n.Cap = o.expr(n.Cap, nil)
+               case *ir.CallExpr:
+                       o.exprList(n.Args)
+               }
+               return
+       }
+
+       n := nn.(*ir.CallExpr)
+       typecheck.FixVariadicCall(n)
+       n.X = o.expr(n.X, nil)
+       o.exprList(n.Args)
+
+       if n.Op() == ir.OCALLINTER {
+               return
+       }
+       keepAlive := func(arg ir.Node) {
+               // If the argument is really a pointer being converted to uintptr,
+               // arrange for the pointer to be kept alive until the call returns,
+               // by copying it into a temp and marking that temp
+               // still alive when we pop the temp stack.
+               if arg.Op() == ir.OCONVNOP {
+                       arg := arg.(*ir.ConvExpr)
+                       if arg.X.Type().IsUnsafePtr() {
+                               x := o.copyExpr(arg.X)
+                               arg.X = x
+                               x.SetAddrtaken(true) // ensure SSA keeps the x variable
+                               n.KeepAlive = append(n.KeepAlive, x)
+                       }
+               }
+       }
+
+       // Check for "unsafe-uintptr" tag provided by escape analysis.
+       for i, param := range n.X.Type().Params().FieldSlice() {
+               if param.Note == escape.UnsafeUintptrNote || param.Note == escape.UintptrEscapesNote {
+                       if arg := n.Args[i]; arg.Op() == ir.OSLICELIT {
+                               arg := arg.(*ir.CompLitExpr)
+                               for _, elt := range arg.List {
+                                       keepAlive(elt)
+                               }
+                       } else {
+                               keepAlive(arg)
+                       }
+               }
+       }
+}
+
+// mapAssign appends n to o.out.
+func (o *orderState) mapAssign(n ir.Node) {
+       switch n.Op() {
+       default:
+               base.Fatalf("order.mapAssign %v", n.Op())
+
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               if n.X.Op() == ir.OINDEXMAP {
+                       n.Y = o.safeMapRHS(n.Y)
+               }
+               o.out = append(o.out, n)
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               if n.X.Op() == ir.OINDEXMAP {
+                       n.Y = o.safeMapRHS(n.Y)
+               }
+               o.out = append(o.out, n)
+       }
+}
+
+func (o *orderState) safeMapRHS(r ir.Node) ir.Node {
+       // Make sure we evaluate the RHS before starting the map insert.
+       // We need to make sure the RHS won't panic.  See issue 22881.
+       if r.Op() == ir.OAPPEND {
+               r := r.(*ir.CallExpr)
+               s := r.Args[1:]
+               for i, n := range s {
+                       s[i] = o.cheapExpr(n)
+               }
+               return r
+       }
+       return o.cheapExpr(r)
+}
+
+// stmt orders the statement n, appending to o.out.
+// Temporaries created during the statement are cleaned
+// up using VARKILL instructions as possible.
+func (o *orderState) stmt(n ir.Node) {
+       if n == nil {
+               return
+       }
+
+       lno := ir.SetPos(n)
+       o.init(n)
+
+       switch n.Op() {
+       default:
+               base.Fatalf("order.stmt %v", n.Op())
+
+       case ir.OVARKILL, ir.OVARLIVE, ir.OINLMARK:
+               o.out = append(o.out, n)
+
+       case ir.OAS:
+               n := n.(*ir.AssignStmt)
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+               n.Y = o.expr(n.Y, n.X)
+               o.mapAssign(n)
+               o.cleanTemp(t)
+
+       case ir.OASOP:
+               n := n.(*ir.AssignOpStmt)
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+               n.Y = o.expr(n.Y, nil)
+
+               if base.Flag.Cfg.Instrumenting || n.X.Op() == ir.OINDEXMAP && (n.AsOp == ir.ODIV || n.AsOp == ir.OMOD) {
+                       // Rewrite m[k] op= r into m[k] = m[k] op r so
+                       // that we can ensure that if op panics
+                       // because r is zero, the panic happens before
+                       // the map assignment.
+                       // DeepCopy is a big hammer here, but safeExpr
+                       // makes sure there is nothing too deep being copied.
+                       l1 := o.safeExpr(n.X)
+                       l2 := ir.DeepCopy(src.NoXPos, l1)
+                       if l2.Op() == ir.OINDEXMAP {
+                               l2 := l2.(*ir.IndexExpr)
+                               l2.Assigned = false
+                       }
+                       l2 = o.copyExpr(l2)
+                       r := o.expr(typecheck.Expr(ir.NewBinaryExpr(n.Pos(), n.AsOp, l2, n.Y)), nil)
+                       as := typecheck.Stmt(ir.NewAssignStmt(n.Pos(), l1, r))
+                       o.mapAssign(as)
+                       o.cleanTemp(t)
+                       return
+               }
+
+               o.mapAssign(n)
+               o.cleanTemp(t)
+
+       case ir.OAS2:
+               n := n.(*ir.AssignListStmt)
+               t := o.markTemp()
+               o.exprList(n.Lhs)
+               o.exprList(n.Rhs)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       // Special: avoid copy of func call n.Right
+       case ir.OAS2FUNC:
+               n := n.(*ir.AssignListStmt)
+               t := o.markTemp()
+               o.exprList(n.Lhs)
+               o.init(n.Rhs[0])
+               o.call(n.Rhs[0])
+               o.as2func(n)
+               o.cleanTemp(t)
+
+       // Special: use temporary variables to hold result,
+       // so that runtime can take address of temporary.
+       // No temporary for blank assignment.
+       //
+       // OAS2MAPR: make sure key is addressable if needed,
+       //           and make sure OINDEXMAP is not copied out.
+       case ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OAS2MAPR:
+               n := n.(*ir.AssignListStmt)
+               t := o.markTemp()
+               o.exprList(n.Lhs)
+
+               switch r := n.Rhs[0]; r.Op() {
+               case ir.ODOTTYPE2:
+                       r := r.(*ir.TypeAssertExpr)
+                       r.X = o.expr(r.X, nil)
+               case ir.ORECV:
+                       r := r.(*ir.UnaryExpr)
+                       r.X = o.expr(r.X, nil)
+               case ir.OINDEXMAP:
+                       r := r.(*ir.IndexExpr)
+                       r.X = o.expr(r.X, nil)
+                       r.Index = o.expr(r.Index, nil)
+                       // See similar conversion for OINDEXMAP below.
+                       _ = mapKeyReplaceStrConv(r.Index)
+                       r.Index = o.mapKeyTemp(r.X.Type(), r.Index)
+               default:
+                       base.Fatalf("order.stmt: %v", r.Op())
+               }
+
+               o.as2ok(n)
+               o.cleanTemp(t)
+
+       // Special: does not save n onto out.
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
+               o.stmtList(n.List)
+
+       // Special: n->left is not an expression; save as is.
+       case ir.OBREAK,
+               ir.OCONTINUE,
+               ir.ODCL,
+               ir.ODCLCONST,
+               ir.ODCLTYPE,
+               ir.OFALL,
+               ir.OGOTO,
+               ir.OLABEL,
+               ir.OTAILCALL:
+               o.out = append(o.out, n)
+
+       // Special: handle call arguments.
+       case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+               n := n.(*ir.CallExpr)
+               t := o.markTemp()
+               o.call(n)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.OCLOSE, ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.OCOPY:
+               n := n.(*ir.BinaryExpr)
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+               n.Y = o.expr(n.Y, nil)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+               n := n.(*ir.CallExpr)
+               t := o.markTemp()
+               o.exprList(n.Args)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       // Special: order arguments to inner call but not call itself.
+       case ir.ODEFER, ir.OGO:
+               n := n.(*ir.GoDeferStmt)
+               t := o.markTemp()
+               o.init(n.Call)
+               o.call(n.Call)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.ODELETE:
+               n := n.(*ir.CallExpr)
+               t := o.markTemp()
+               n.Args[0] = o.expr(n.Args[0], nil)
+               n.Args[1] = o.expr(n.Args[1], nil)
+               n.Args[1] = o.mapKeyTemp(n.Args[0].Type(), n.Args[1])
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       // Clean temporaries from condition evaluation at
+       // beginning of loop body and after for statement.
+       case ir.OFOR:
+               n := n.(*ir.ForStmt)
+               t := o.markTemp()
+               n.Cond = o.exprInPlace(n.Cond)
+               n.Body.Prepend(o.cleanTempNoPop(t)...)
+               orderBlock(&n.Body, o.free)
+               n.Post = orderStmtInPlace(n.Post, o.free)
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       // Clean temporaries from condition at
+       // beginning of both branches.
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               t := o.markTemp()
+               n.Cond = o.exprInPlace(n.Cond)
+               n.Body.Prepend(o.cleanTempNoPop(t)...)
+               n.Else.Prepend(o.cleanTempNoPop(t)...)
+               o.popTemp(t)
+               orderBlock(&n.Body, o.free)
+               orderBlock(&n.Else, o.free)
+               o.out = append(o.out, n)
+
+       case ir.OPANIC:
+               n := n.(*ir.UnaryExpr)
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+               if !n.X.Type().IsEmptyInterface() {
+                       base.FatalfAt(n.Pos(), "bad argument to panic: %L", n.X)
+               }
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.ORANGE:
+               // n.Right is the expression being ranged over.
+               // order it, and then make a copy if we need one.
+               // We almost always do, to ensure that we don't
+               // see any value changes made during the loop.
+               // Usually the copy is cheap (e.g., array pointer,
+               // chan, slice, string are all tiny).
+               // The exception is ranging over an array value
+               // (not a slice, not a pointer to array),
+               // which must make a copy to avoid seeing updates made during
+               // the range body. Ranging over an array value is uncommon though.
+
+               // Mark []byte(str) range expression to reuse string backing storage.
+               // It is safe because the storage cannot be mutated.
+               n := n.(*ir.RangeStmt)
+               if n.X.Op() == ir.OSTR2BYTES {
+                       n.X.(*ir.ConvExpr).SetOp(ir.OSTR2BYTESTMP)
+               }
+
+               t := o.markTemp()
+               n.X = o.expr(n.X, nil)
+
+               orderBody := true
+               xt := typecheck.RangeExprType(n.X.Type())
+               switch xt.Kind() {
+               default:
+                       base.Fatalf("order.stmt range %v", n.Type())
+
+               case types.TARRAY, types.TSLICE:
+                       if n.Value == nil || ir.IsBlank(n.Value) {
+                               // for i := range x will only use x once, to compute len(x).
+                               // No need to copy it.
+                               break
+                       }
+                       fallthrough
+
+               case types.TCHAN, types.TSTRING:
+                       // chan, string, slice, array ranges use value multiple times.
+                       // make copy.
+                       r := n.X
+
+                       if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
+                               r = ir.NewConvExpr(base.Pos, ir.OCONV, nil, r)
+                               r.SetType(types.Types[types.TSTRING])
+                               r = typecheck.Expr(r)
+                       }
+
+                       n.X = o.copyExpr(r)
+
+               case types.TMAP:
+                       if isMapClear(n) {
+                               // Preserve the body of the map clear pattern so it can
+                               // be detected during walk. The loop body will not be used
+                               // when optimizing away the range loop to a runtime call.
+                               orderBody = false
+                               break
+                       }
+
+                       // copy the map value in case it is a map literal.
+                       // TODO(rsc): Make tmp = literal expressions reuse tmp.
+                       // For maps tmp is just one word so it hardly matters.
+                       r := n.X
+                       n.X = o.copyExpr(r)
+
+                       // n.Prealloc is the temp for the iterator.
+                       // MapIterType contains pointers and needs to be zeroed.
+                       n.Prealloc = o.newTemp(reflectdata.MapIterType(xt), true)
+               }
+               n.Key = o.exprInPlace(n.Key)
+               n.Value = o.exprInPlace(n.Value)
+               if orderBody {
+                       orderBlock(&n.Body, o.free)
+               }
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               o.exprList(n.Results)
+               o.out = append(o.out, n)
+
+       // Special: clean case temporaries in each block entry.
+       // Select must enter one of its blocks, so there is no
+       // need for a cleaning at the end.
+       // Doubly special: evaluation order for select is stricter
+       // than ordinary expressions. Even something like p.c
+       // has to be hoisted into a temporary, so that it cannot be
+       // reordered after the channel evaluation for a different
+       // case (if p were nil, then the timing of the fault would
+       // give this away).
+       case ir.OSELECT:
+               n := n.(*ir.SelectStmt)
+               t := o.markTemp()
+               for _, ncas := range n.Cases {
+                       r := ncas.Comm
+                       ir.SetPos(ncas)
+
+                       // Append any new body prologue to ninit.
+                       // The next loop will insert ninit into nbody.
+                       if len(ncas.Init()) != 0 {
+                               base.Fatalf("order select ninit")
+                       }
+                       if r == nil {
+                               continue
+                       }
+                       switch r.Op() {
+                       default:
+                               ir.Dump("select case", r)
+                               base.Fatalf("unknown op in select %v", r.Op())
+
+                       case ir.OSELRECV2:
+                               // case x, ok = <-c
+                               r := r.(*ir.AssignListStmt)
+                               recv := r.Rhs[0].(*ir.UnaryExpr)
+                               recv.X = o.expr(recv.X, nil)
+                               if !ir.IsAutoTmp(recv.X) {
+                                       recv.X = o.copyExpr(recv.X)
+                               }
+                               init := ir.TakeInit(r)
+
+                               colas := r.Def
+                               do := func(i int, t *types.Type) {
+                                       n := r.Lhs[i]
+                                       if ir.IsBlank(n) {
+                                               return
+                                       }
+                                       // If this is case x := <-ch or case x, y := <-ch, the case has
+                                       // the ODCL nodes to declare x and y. We want to delay that
+                                       // declaration (and possible allocation) until inside the case body.
+                                       // Delete the ODCL nodes here and recreate them inside the body below.
+                                       if colas {
+                                               if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).X == n {
+                                                       init = init[1:]
+                                               }
+                                               dcl := typecheck.Stmt(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
+                                               ncas.PtrInit().Append(dcl)
+                                       }
+                                       tmp := o.newTemp(t, t.HasPointers())
+                                       as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, n, typecheck.Conv(tmp, n.Type())))
+                                       ncas.PtrInit().Append(as)
+                                       r.Lhs[i] = tmp
+                               }
+                               do(0, recv.X.Type().Elem())
+                               do(1, types.Types[types.TBOOL])
+                               if len(init) != 0 {
+                                       ir.DumpList("ninit", r.Init())
+                                       base.Fatalf("ninit on select recv")
+                               }
+                               orderBlock(ncas.PtrInit(), o.free)
+
+                       case ir.OSEND:
+                               r := r.(*ir.SendStmt)
+                               if len(r.Init()) != 0 {
+                                       ir.DumpList("ninit", r.Init())
+                                       base.Fatalf("ninit on select send")
+                               }
+
+                               // case c <- x
+                               // r->left is c, r->right is x, both are always evaluated.
+                               r.Chan = o.expr(r.Chan, nil)
+
+                               if !ir.IsAutoTmp(r.Chan) {
+                                       r.Chan = o.copyExpr(r.Chan)
+                               }
+                               r.Value = o.expr(r.Value, nil)
+                               if !ir.IsAutoTmp(r.Value) {
+                                       r.Value = o.copyExpr(r.Value)
+                               }
+                       }
+               }
+               // Now that we have accumulated all the temporaries, clean them.
+               // Also insert any ninit queued during the previous loop.
+               // (The temporary cleaning must follow that ninit work.)
+               for _, cas := range n.Cases {
+                       orderBlock(&cas.Body, o.free)
+                       cas.Body.Prepend(o.cleanTempNoPop(t)...)
+
+                       // TODO(mdempsky): Is this actually necessary?
+                       // walkSelect appears to walk Ninit.
+                       cas.Body.Prepend(ir.TakeInit(cas)...)
+               }
+
+               o.out = append(o.out, n)
+               o.popTemp(t)
+
+       // Special: value being sent is passed as a pointer; make it addressable.
+       case ir.OSEND:
+               n := n.(*ir.SendStmt)
+               t := o.markTemp()
+               n.Chan = o.expr(n.Chan, nil)
+               n.Value = o.expr(n.Value, nil)
+               if base.Flag.Cfg.Instrumenting {
+                       // Force copying to the stack so that (chan T)(nil) <- x
+                       // is still instrumented as a read of x.
+                       n.Value = o.copyExpr(n.Value)
+               } else {
+                       n.Value = o.addrTemp(n.Value)
+               }
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+
+       // TODO(rsc): Clean temporaries more aggressively.
+       // Note that because walkSwitch will rewrite some of the
+       // switch into a binary search, this is not as easy as it looks.
+       // (If we ran that code here we could invoke order.stmt on
+       // the if-else chain instead.)
+       // For now just clean all the temporaries at the end.
+       // In practice that's fine.
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+               if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
+                       // Add empty "default:" case for instrumentation.
+                       n.Cases = append(n.Cases, ir.NewCaseStmt(base.Pos, nil, nil))
+               }
+
+               t := o.markTemp()
+               n.Tag = o.expr(n.Tag, nil)
+               for _, ncas := range n.Cases {
+                       o.exprListInPlace(ncas.List)
+                       orderBlock(&ncas.Body, o.free)
+               }
+
+               o.out = append(o.out, n)
+               o.cleanTemp(t)
+       }
+
+       base.Pos = lno
+}
+
+func hasDefaultCase(n *ir.SwitchStmt) bool {
+       for _, ncas := range n.Cases {
+               if len(ncas.List) == 0 {
+                       return true
+               }
+       }
+       return false
+}
+
+// exprList orders the expression list l into o.
+func (o *orderState) exprList(l ir.Nodes) {
+       s := l
+       for i := range s {
+               s[i] = o.expr(s[i], nil)
+       }
+}
+
+// exprListInPlace orders the expression list l but saves
+// the side effects on the individual expression ninit lists.
+func (o *orderState) exprListInPlace(l ir.Nodes) {
+       s := l
+       for i := range s {
+               s[i] = o.exprInPlace(s[i])
+       }
+}
+
+func (o *orderState) exprNoLHS(n ir.Node) ir.Node {
+       return o.expr(n, nil)
+}
+
+// expr orders a single expression, appending side
+// effects to o.out as needed.
+// If this is part of an assignment lhs = *np, lhs is given.
+// Otherwise lhs == nil. (When lhs != nil it may be possible
+// to avoid copying the result of the expression to a temporary.)
+// The result of expr MUST be assigned back to n, e.g.
+//     n.Left = o.expr(n.Left, lhs)
+func (o *orderState) expr(n, lhs ir.Node) ir.Node {
+       if n == nil {
+               return n
+       }
+       lno := ir.SetPos(n)
+       n = o.expr1(n, lhs)
+       base.Pos = lno
+       return n
+}
+
+func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
+       o.init(n)
+
+       switch n.Op() {
+       default:
+               if o.edit == nil {
+                       o.edit = o.exprNoLHS // create closure once
+               }
+               ir.EditChildren(n, o.edit)
+               return n
+
+       // Addition of strings turns into a function call.
+       // Allocate a temporary to hold the strings.
+       // Fewer than 5 strings use direct runtime helpers.
+       case ir.OADDSTR:
+               n := n.(*ir.AddStringExpr)
+               o.exprList(n.List)
+
+               if len(n.List) > 5 {
+                       t := types.NewArray(types.Types[types.TSTRING], int64(len(n.List)))
+                       n.Prealloc = o.newTemp(t, false)
+               }
+
+               // Mark string(byteSlice) arguments to reuse byteSlice backing
+               // buffer during conversion. String concatenation does not
+               // memorize the strings for later use, so it is safe.
+               // However, we can do it only if there is at least one non-empty string literal.
+               // Otherwise if all other arguments are empty strings,
+               // concatstrings will return the reference to the temp string
+               // to the caller.
+               hasbyte := false
+
+               haslit := false
+               for _, n1 := range n.List {
+                       hasbyte = hasbyte || n1.Op() == ir.OBYTES2STR
+                       haslit = haslit || n1.Op() == ir.OLITERAL && len(ir.StringVal(n1)) != 0
+               }
+
+               if haslit && hasbyte {
+                       for _, n2 := range n.List {
+                               if n2.Op() == ir.OBYTES2STR {
+                                       n2 := n2.(*ir.ConvExpr)
+                                       n2.SetOp(ir.OBYTES2STRTMP)
+                               }
+                       }
+               }
+               return n
+
+       case ir.OINDEXMAP:
+               n := n.(*ir.IndexExpr)
+               n.X = o.expr(n.X, nil)
+               n.Index = o.expr(n.Index, nil)
+               needCopy := false
+
+               if !n.Assigned {
+                       // Enforce that any []byte slices we are not copying
+                       // can not be changed before the map index by forcing
+                       // the map index to happen immediately following the
+                       // conversions. See copyExpr a few lines below.
+                       needCopy = mapKeyReplaceStrConv(n.Index)
+
+                       if base.Flag.Cfg.Instrumenting {
+                               // Race detector needs the copy.
+                               needCopy = true
+                       }
+               }
+
+               // key must be addressable
+               n.Index = o.mapKeyTemp(n.X.Type(), n.Index)
+               if needCopy {
+                       return o.copyExpr(n)
+               }
+               return n
+
+       // concrete type (not interface) argument might need an addressable
+       // temporary to pass to the runtime conversion routine.
+       case ir.OCONVIFACE:
+               n := n.(*ir.ConvExpr)
+               n.X = o.expr(n.X, nil)
+               if n.X.Type().IsInterface() {
+                       return n
+               }
+               if _, needsaddr := convFuncName(n.X.Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.X) {
+                       // Need a temp if we need to pass the address to the conversion function.
+                       // We also process static composite literal node here, making a named static global
+                       // whose address we can put directly in an interface (see OCONVIFACE case in walk).
+                       n.X = o.addrTemp(n.X)
+               }
+               return n
+
+       case ir.OCONVNOP:
+               n := n.(*ir.ConvExpr)
+               if n.Type().IsKind(types.TUNSAFEPTR) && n.X.Type().IsKind(types.TUINTPTR) && (n.X.Op() == ir.OCALLFUNC || n.X.Op() == ir.OCALLINTER || n.X.Op() == ir.OCALLMETH) {
+                       call := n.X.(*ir.CallExpr)
+                       // When reordering unsafe.Pointer(f()) into a separate
+                       // statement, the conversion and function call must stay
+                       // together. See golang.org/issue/15329.
+                       o.init(call)
+                       o.call(call)
+                       if lhs == nil || lhs.Op() != ir.ONAME || base.Flag.Cfg.Instrumenting {
+                               return o.copyExpr(n)
+                       }
+               } else {
+                       n.X = o.expr(n.X, nil)
+               }
+               return n
+
+       case ir.OANDAND, ir.OOROR:
+               // ... = LHS && RHS
+               //
+               // var r bool
+               // r = LHS
+               // if r {       // or !r, for OROR
+               //     r = RHS
+               // }
+               // ... = r
+
+               n := n.(*ir.LogicalExpr)
+               r := o.newTemp(n.Type(), false)
+
+               // Evaluate left-hand side.
+               lhs := o.expr(n.X, nil)
+               o.out = append(o.out, typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, lhs)))
+
+               // Evaluate right-hand side, save generated code.
+               saveout := o.out
+               o.out = nil
+               t := o.markTemp()
+               o.edge()
+               rhs := o.expr(n.Y, nil)
+               o.out = append(o.out, typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, rhs)))
+               o.cleanTemp(t)
+               gen := o.out
+               o.out = saveout
+
+               // If left-hand side doesn't cause a short-circuit, issue right-hand side.
+               nif := ir.NewIfStmt(base.Pos, r, nil, nil)
+               if n.Op() == ir.OANDAND {
+                       nif.Body = gen
+               } else {
+                       nif.Else = gen
+               }
+               o.out = append(o.out, nif)
+               return r
+
+       case ir.OCALLFUNC,
+               ir.OCALLINTER,
+               ir.OCALLMETH,
+               ir.OCAP,
+               ir.OCOMPLEX,
+               ir.OCOPY,
+               ir.OIMAG,
+               ir.OLEN,
+               ir.OMAKECHAN,
+               ir.OMAKEMAP,
+               ir.OMAKESLICE,
+               ir.OMAKESLICECOPY,
+               ir.ONEW,
+               ir.OREAL,
+               ir.ORECOVER,
+               ir.OSTR2BYTES,
+               ir.OSTR2BYTESTMP,
+               ir.OSTR2RUNES:
+
+               if isRuneCount(n) {
+                       // len([]rune(s)) is rewritten to runtime.countrunes(s) later.
+                       conv := n.(*ir.UnaryExpr).X.(*ir.ConvExpr)
+                       conv.X = o.expr(conv.X, nil)
+               } else {
+                       o.call(n)
+               }
+
+               if lhs == nil || lhs.Op() != ir.ONAME || base.Flag.Cfg.Instrumenting {
+                       return o.copyExpr(n)
+               }
+               return n
+
+       case ir.OAPPEND:
+               // Check for append(x, make([]T, y)...) .
+               n := n.(*ir.CallExpr)
+               if isAppendOfMake(n) {
+                       n.Args[0] = o.expr(n.Args[0], nil) // order x
+                       mk := n.Args[1].(*ir.MakeExpr)
+                       mk.Len = o.expr(mk.Len, nil) // order y
+               } else {
+                       o.exprList(n.Args)
+               }
+
+               if lhs == nil || lhs.Op() != ir.ONAME && !ir.SameSafeExpr(lhs, n.Args[0]) {
+                       return o.copyExpr(n)
+               }
+               return n
+
+       case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
+               n := n.(*ir.SliceExpr)
+               n.X = o.expr(n.X, nil)
+               n.Low = o.cheapExpr(o.expr(n.Low, nil))
+               n.High = o.cheapExpr(o.expr(n.High, nil))
+               n.Max = o.cheapExpr(o.expr(n.Max, nil))
+               if lhs == nil || lhs.Op() != ir.ONAME && !ir.SameSafeExpr(lhs, n.X) {
+                       return o.copyExpr(n)
+               }
+               return n
+
+       case ir.OCLOSURE:
+               n := n.(*ir.ClosureExpr)
+               if n.Transient() && len(n.Func.ClosureVars) > 0 {
+                       n.Prealloc = o.newTemp(typecheck.ClosureType(n), false)
+               }
+               return n
+
+       case ir.OCALLPART:
+               n := n.(*ir.SelectorExpr)
+               n.X = o.expr(n.X, nil)
+               if n.Transient() {
+                       t := typecheck.PartialCallType(n)
+                       n.Prealloc = o.newTemp(t, false)
+               }
+               return n
+
+       case ir.OSLICELIT:
+               n := n.(*ir.CompLitExpr)
+               o.exprList(n.List)
+               if n.Transient() {
+                       t := types.NewArray(n.Type().Elem(), n.Len)
+                       n.Prealloc = o.newTemp(t, false)
+               }
+               return n
+
+       case ir.ODOTTYPE, ir.ODOTTYPE2:
+               n := n.(*ir.TypeAssertExpr)
+               n.X = o.expr(n.X, nil)
+               if !types.IsDirectIface(n.Type()) || base.Flag.Cfg.Instrumenting {
+                       return o.copyExprClear(n)
+               }
+               return n
+
+       case ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               n.X = o.expr(n.X, nil)
+               return o.copyExprClear(n)
+
+       case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+               n := n.(*ir.BinaryExpr)
+               n.X = o.expr(n.X, nil)
+               n.Y = o.expr(n.Y, nil)
+
+               t := n.X.Type()
+               switch {
+               case t.IsString():
+                       // Mark string(byteSlice) arguments to reuse byteSlice backing
+                       // buffer during conversion. String comparison does not
+                       // memorize the strings for later use, so it is safe.
+                       if n.X.Op() == ir.OBYTES2STR {
+                               n.X.(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
+                       }
+                       if n.Y.Op() == ir.OBYTES2STR {
+                               n.Y.(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
+                       }
+
+               case t.IsStruct() || t.IsArray():
+                       // for complex comparisons, we need both args to be
+                       // addressable so we can pass them to the runtime.
+                       n.X = o.addrTemp(n.X)
+                       n.Y = o.addrTemp(n.Y)
+               }
+               return n
+
+       case ir.OMAPLIT:
+               // Order map by converting:
+               //   map[int]int{
+               //     a(): b(),
+               //     c(): d(),
+               //     e(): f(),
+               //   }
+               // to
+               //   m := map[int]int{}
+               //   m[a()] = b()
+               //   m[c()] = d()
+               //   m[e()] = f()
+               // Then order the result.
+               // Without this special case, order would otherwise compute all
+               // the keys and values before storing any of them to the map.
+               // See issue 26552.
+               n := n.(*ir.CompLitExpr)
+               entries := n.List
+               statics := entries[:0]
+               var dynamics []*ir.KeyExpr
+               for _, r := range entries {
+                       r := r.(*ir.KeyExpr)
+
+                       if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
+                               dynamics = append(dynamics, r)
+                               continue
+                       }
+
+                       // Recursively ordering some static entries can change them to dynamic;
+                       // e.g., OCONVIFACE nodes. See #31777.
+                       r = o.expr(r, nil).(*ir.KeyExpr)
+                       if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
+                               dynamics = append(dynamics, r)
+                               continue
+                       }
+
+                       statics = append(statics, r)
+               }
+               n.List = statics
+
+               if len(dynamics) == 0 {
+                       return n
+               }
+
+               // Emit the creation of the map (with all its static entries).
+               m := o.newTemp(n.Type(), false)
+               as := ir.NewAssignStmt(base.Pos, m, n)
+               typecheck.Stmt(as)
+               o.stmt(as)
+
+               // Emit eval+insert of dynamic entries, one at a time.
+               for _, r := range dynamics {
+                       as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Key), r.Value)
+                       typecheck.Stmt(as) // Note: this converts the OINDEX to an OINDEXMAP
+                       o.stmt(as)
+               }
+               return m
+       }
+
+       // No return - type-assertions above. Each case must return for itself.
+}
+
+// as2func orders OAS2FUNC nodes. It creates temporaries to ensure left-to-right assignment.
+// The caller should order the right-hand side of the assignment before calling order.as2func.
+// It rewrites,
+//     a, b, a = ...
+// as
+//     tmp1, tmp2, tmp3 = ...
+//     a, b, a = tmp1, tmp2, tmp3
+// This is necessary to ensure left to right assignment order.
+func (o *orderState) as2func(n *ir.AssignListStmt) {
+       results := n.Rhs[0].Type()
+       as := ir.NewAssignListStmt(n.Pos(), ir.OAS2, nil, nil)
+       for i, nl := range n.Lhs {
+               if !ir.IsBlank(nl) {
+                       typ := results.Field(i).Type
+                       tmp := o.newTemp(typ, typ.HasPointers())
+                       n.Lhs[i] = tmp
+                       as.Lhs = append(as.Lhs, nl)
+                       as.Rhs = append(as.Rhs, tmp)
+               }
+       }
+
+       o.out = append(o.out, n)
+       o.stmt(typecheck.Stmt(as))
+}
+
+// as2ok orders OAS2XXX with ok.
+// Just like as2func, this also adds temporaries to ensure left-to-right assignment.
+func (o *orderState) as2ok(n *ir.AssignListStmt) {
+       as := ir.NewAssignListStmt(n.Pos(), ir.OAS2, nil, nil)
+
+       do := func(i int, typ *types.Type) {
+               if nl := n.Lhs[i]; !ir.IsBlank(nl) {
+                       var tmp ir.Node = o.newTemp(typ, typ.HasPointers())
+                       n.Lhs[i] = tmp
+                       as.Lhs = append(as.Lhs, nl)
+                       if i == 1 {
+                               // The "ok" result is an untyped boolean according to the Go
+                               // spec. We need to explicitly convert it to the LHS type in
+                               // case the latter is a defined boolean type (#8475).
+                               tmp = typecheck.Conv(tmp, nl.Type())
+                       }
+                       as.Rhs = append(as.Rhs, tmp)
+               }
+       }
+
+       do(0, n.Rhs[0].Type())
+       do(1, types.Types[types.TBOOL])
+
+       o.out = append(o.out, n)
+       o.stmt(typecheck.Stmt(as))
+}

diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
new file mode 100644 (file)
index 0000000..47cd2fd
--- /dev/null
+++ b/src/cmd/compile/internal/walk/race.go
@@ -0,0 +1,51 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+       "cmd/internal/sys"
+)
+
+func instrument(fn *ir.Func) {
+       if fn.Pragma&ir.Norace != 0 || (fn.Linksym() != nil && fn.Linksym().ABIWrapper()) {
+               return
+       }
+
+       if !base.Flag.Race || !base.Compiling(base.NoRacePkgs) {
+               fn.SetInstrumentBody(true)
+       }
+
+       if base.Flag.Race {
+               lno := base.Pos
+               base.Pos = src.NoXPos
+               if ssagen.Arch.LinkArch.Arch.Family != sys.AMD64 {
+                       fn.Enter.Prepend(mkcallstmt("racefuncenterfp"))
+                       fn.Exit.Append(mkcallstmt("racefuncexit"))
+               } else {
+
+                       // nodpc is the PC of the caller as extracted by
+                       // getcallerpc. We use -widthptr(FP) for x86.
+                       // This only works for amd64. This will not
+                       // work on arm or others that might support
+                       // race in the future.
+
+                       nodpc := ir.NewNameAt(src.NoXPos, typecheck.Lookup(".fp"))
+                       nodpc.Class = ir.PPARAM
+                       nodpc.SetUsed(true)
+                       nodpc.SetType(types.Types[types.TUINTPTR])
+                       nodpc.SetFrameOffset(int64(-types.PtrSize))
+                       fn.Dcl = append(fn.Dcl, nodpc)
+                       fn.Enter.Prepend(mkcallstmt("racefuncenter", nodpc))
+                       fn.Exit.Append(mkcallstmt("racefuncexit"))
+               }
+               base.Pos = lno
+       }
+}

diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
new file mode 100644 (file)
index 0000000..5ab24b2
--- /dev/null
+++ b/src/cmd/compile/internal/walk/range.go
@@ -0,0 +1,486 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "unicode/utf8"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/sys"
+)
+
+func cheapComputableIndex(width int64) bool {
+       switch ssagen.Arch.LinkArch.Family {
+       // MIPS does not have R+R addressing
+       // Arm64 may lack ability to generate this code in our assembler,
+       // but the architecture supports it.
+       case sys.PPC64, sys.S390X:
+               return width == 1
+       case sys.AMD64, sys.I386, sys.ARM64, sys.ARM:
+               switch width {
+               case 1, 2, 4, 8:
+                       return true
+               }
+       }
+       return false
+}
+
+// walkRange transforms various forms of ORANGE into
+// simpler forms.  The result must be assigned back to n.
+// Node n may also be modified in place, and may also be
+// the returned node.
+func walkRange(nrange *ir.RangeStmt) ir.Node {
+       if isMapClear(nrange) {
+               m := nrange.X
+               lno := ir.SetPos(m)
+               n := mapClear(m)
+               base.Pos = lno
+               return n
+       }
+
+       nfor := ir.NewForStmt(nrange.Pos(), nil, nil, nil, nil)
+       nfor.SetInit(nrange.Init())
+       nfor.Label = nrange.Label
+
+       // variable name conventions:
+       //      ohv1, hv1, hv2: hidden (old) val 1, 2
+       //      ha, hit: hidden aggregate, iterator
+       //      hn, hp: hidden len, pointer
+       //      hb: hidden bool
+       //      a, v1, v2: not hidden aggregate, val 1, 2
+
+       a := nrange.X
+       t := typecheck.RangeExprType(a.Type())
+       lno := ir.SetPos(a)
+
+       v1, v2 := nrange.Key, nrange.Value
+
+       if ir.IsBlank(v2) {
+               v2 = nil
+       }
+
+       if ir.IsBlank(v1) && v2 == nil {
+               v1 = nil
+       }
+
+       if v1 == nil && v2 != nil {
+               base.Fatalf("walkRange: v2 != nil while v1 == nil")
+       }
+
+       var ifGuard *ir.IfStmt
+
+       var body []ir.Node
+       var init []ir.Node
+       switch t.Kind() {
+       default:
+               base.Fatalf("walkRange")
+
+       case types.TARRAY, types.TSLICE:
+               if nn := arrayClear(nrange, v1, v2, a); nn != nil {
+                       base.Pos = lno
+                       return nn
+               }
+
+               // order.stmt arranged for a copy of the array/slice variable if needed.
+               ha := a
+
+               hv1 := typecheck.Temp(types.Types[types.TINT])
+               hn := typecheck.Temp(types.Types[types.TINT])
+
+               init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
+               init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
+
+               nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
+               nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(1)))
+
+               // for range ha { body }
+               if v1 == nil {
+                       break
+               }
+
+               // for v1 := range ha { body }
+               if v2 == nil {
+                       body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
+                       break
+               }
+
+               // for v1, v2 := range ha { body }
+               if cheapComputableIndex(t.Elem().Width) {
+                       // v1, v2 = hv1, ha[hv1]
+                       tmp := ir.NewIndexExpr(base.Pos, ha, hv1)
+                       tmp.SetBounded(true)
+                       // Use OAS2 to correctly handle assignments
+                       // of the form "v1, a[v1] := range".
+                       a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+                       a.Lhs = []ir.Node{v1, v2}
+                       a.Rhs = []ir.Node{hv1, tmp}
+                       body = []ir.Node{a}
+                       break
+               }
+
+               // TODO(austin): OFORUNTIL is a strange beast, but is
+               // necessary for expressing the control flow we need
+               // while also making "break" and "continue" work. It
+               // would be nice to just lower ORANGE during SSA, but
+               // racewalk needs to see many of the operations
+               // involved in ORANGE's implementation. If racewalk
+               // moves into SSA, consider moving ORANGE into SSA and
+               // eliminating OFORUNTIL.
+
+               // TODO(austin): OFORUNTIL inhibits bounds-check
+               // elimination on the index variable (see #20711).
+               // Enhance the prove pass to understand this.
+               ifGuard = ir.NewIfStmt(base.Pos, nil, nil, nil)
+               ifGuard.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
+               nfor.SetOp(ir.OFORUNTIL)
+
+               hp := typecheck.Temp(types.NewPtr(t.Elem()))
+               tmp := ir.NewIndexExpr(base.Pos, ha, ir.NewInt(0))
+               tmp.SetBounded(true)
+               init = append(init, ir.NewAssignStmt(base.Pos, hp, typecheck.NodAddr(tmp)))
+
+               // Use OAS2 to correctly handle assignments
+               // of the form "v1, a[v1] := range".
+               a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+               a.Lhs = []ir.Node{v1, v2}
+               a.Rhs = []ir.Node{hv1, ir.NewStarExpr(base.Pos, hp)}
+               body = append(body, a)
+
+               // Advance pointer as part of the late increment.
+               //
+               // This runs *after* the condition check, so we know
+               // advancing the pointer is safe and won't go past the
+               // end of the allocation.
+               as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
+               nfor.Late = []ir.Node{typecheck.Stmt(as)}
+
+       case types.TMAP:
+               // order.stmt allocated the iterator for us.
+               // we only use a once, so no copy needed.
+               ha := a
+
+               hit := nrange.Prealloc
+               th := hit.Type()
+               keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:MapIterType
+               elemsym := th.Field(1).Sym // ditto
+
+               fn := typecheck.LookupRuntime("mapiterinit")
+
+               fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), th)
+               init = append(init, mkcallstmt1(fn, reflectdata.TypePtr(t), ha, typecheck.NodAddr(hit)))
+               nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), typecheck.NodNil())
+
+               fn = typecheck.LookupRuntime("mapiternext")
+               fn = typecheck.SubstArgTypes(fn, th)
+               nfor.Post = mkcallstmt1(fn, typecheck.NodAddr(hit))
+
+               key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
+               if v1 == nil {
+                       body = nil
+               } else if v2 == nil {
+                       body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, key)}
+               } else {
+                       elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
+                       a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+                       a.Lhs = []ir.Node{v1, v2}
+                       a.Rhs = []ir.Node{key, elem}
+                       body = []ir.Node{a}
+               }
+
+       case types.TCHAN:
+               // order.stmt arranged for a copy of the channel variable.
+               ha := a
+
+               hv1 := typecheck.Temp(t.Elem())
+               hv1.SetTypecheck(1)
+               if t.Elem().HasPointers() {
+                       init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
+               }
+               hb := typecheck.Temp(types.Types[types.TBOOL])
+
+               nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, ir.NewBool(false))
+               a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
+               a.SetTypecheck(1)
+               a.Lhs = []ir.Node{hv1, hb}
+               a.Rhs = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
+               nfor.Cond = ir.InitExpr([]ir.Node{a}, nfor.Cond)
+               if v1 == nil {
+                       body = nil
+               } else {
+                       body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
+               }
+               // Zero hv1. This prevents hv1 from being the sole, inaccessible
+               // reference to an otherwise GC-able value during the next channel receive.
+               // See issue 15281.
+               body = append(body, ir.NewAssignStmt(base.Pos, hv1, nil))
+
+       case types.TSTRING:
+               // Transform string range statements like "for v1, v2 = range a" into
+               //
+               // ha := a
+               // for hv1 := 0; hv1 < len(ha); {
+               //   hv1t := hv1
+               //   hv2 := rune(ha[hv1])
+               //   if hv2 < utf8.RuneSelf {
+               //      hv1++
+               //   } else {
+               //      hv2, hv1 = decoderune(ha, hv1)
+               //   }
+               //   v1, v2 = hv1t, hv2
+               //   // original body
+               // }
+
+               // order.stmt arranged for a copy of the string variable.
+               ha := a
+
+               hv1 := typecheck.Temp(types.Types[types.TINT])
+               hv1t := typecheck.Temp(types.Types[types.TINT])
+               hv2 := typecheck.Temp(types.RuneType)
+
+               // hv1 := 0
+               init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
+
+               // hv1 < len(ha)
+               nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha))
+
+               if v1 != nil {
+                       // hv1t = hv1
+                       body = append(body, ir.NewAssignStmt(base.Pos, hv1t, hv1))
+               }
+
+               // hv2 := rune(ha[hv1])
+               nind := ir.NewIndexExpr(base.Pos, ha, hv1)
+               nind.SetBounded(true)
+               body = append(body, ir.NewAssignStmt(base.Pos, hv2, typecheck.Conv(nind, types.RuneType)))
+
+               // if hv2 < utf8.RuneSelf
+               nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+               nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, ir.NewInt(utf8.RuneSelf))
+
+               // hv1++
+               nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(1)))}
+
+               // } else {
+               eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+
+               // hv2, hv1 = decoderune(ha, hv1)
+               eif.Lhs = []ir.Node{hv2, hv1}
+               fn := typecheck.LookupRuntime("decoderune")
+               var fnInit ir.Nodes
+               eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), &fnInit, ha, hv1)}
+               fnInit.Append(eif)
+               nif.Else = fnInit
+
+               body = append(body, nif)
+
+               if v1 != nil {
+                       if v2 != nil {
+                               // v1, v2 = hv1t, hv2
+                               a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+                               a.Lhs = []ir.Node{v1, v2}
+                               a.Rhs = []ir.Node{hv1t, hv2}
+                               body = append(body, a)
+                       } else {
+                               // v1 = hv1t
+                               body = append(body, ir.NewAssignStmt(base.Pos, v1, hv1t))
+                       }
+               }
+       }
+
+       typecheck.Stmts(init)
+
+       if ifGuard != nil {
+               ifGuard.PtrInit().Append(init...)
+               ifGuard = typecheck.Stmt(ifGuard).(*ir.IfStmt)
+       } else {
+               nfor.PtrInit().Append(init...)
+       }
+
+       typecheck.Stmts(nfor.Cond.Init())
+
+       nfor.Cond = typecheck.Expr(nfor.Cond)
+       nfor.Cond = typecheck.DefaultLit(nfor.Cond, nil)
+       nfor.Post = typecheck.Stmt(nfor.Post)
+       typecheck.Stmts(body)
+       nfor.Body.Append(body...)
+       nfor.Body.Append(nrange.Body...)
+
+       var n ir.Node = nfor
+       if ifGuard != nil {
+               ifGuard.Body = []ir.Node{n}
+               n = ifGuard
+       }
+
+       n = walkStmt(n)
+
+       base.Pos = lno
+       return n
+}
+
+// isMapClear checks if n is of the form:
+//
+// for k := range m {
+//   delete(m, k)
+// }
+//
+// where == for keys of map m is reflexive.
+func isMapClear(n *ir.RangeStmt) bool {
+       if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
+               return false
+       }
+
+       t := n.X.Type()
+       if n.Op() != ir.ORANGE || t.Kind() != types.TMAP || n.Key == nil || n.Value != nil {
+               return false
+       }
+
+       k := n.Key
+       // Require k to be a new variable name.
+       if !ir.DeclaredBy(k, n) {
+               return false
+       }
+
+       if len(n.Body) != 1 {
+               return false
+       }
+
+       stmt := n.Body[0] // only stmt in body
+       if stmt == nil || stmt.Op() != ir.ODELETE {
+               return false
+       }
+
+       m := n.X
+       if delete := stmt.(*ir.CallExpr); !ir.SameSafeExpr(delete.Args[0], m) || !ir.SameSafeExpr(delete.Args[1], k) {
+               return false
+       }
+
+       // Keys where equality is not reflexive can not be deleted from maps.
+       if !types.IsReflexive(t.Key()) {
+               return false
+       }
+
+       return true
+}
+
+// mapClear constructs a call to runtime.mapclear for the map m.
+func mapClear(m ir.Node) ir.Node {
+       t := m.Type()
+
+       // instantiate mapclear(typ *type, hmap map[any]any)
+       fn := typecheck.LookupRuntime("mapclear")
+       fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
+       n := mkcallstmt1(fn, reflectdata.TypePtr(t), m)
+       return walkStmt(typecheck.Stmt(n))
+}
+
+// Lower n into runtime·memclr if possible, for
+// fast zeroing of slices and arrays (issue 5373).
+// Look for instances of
+//
+// for i := range a {
+//     a[i] = zero
+// }
+//
+// in which the evaluation of a is side-effect-free.
+//
+// Parameters are as in walkRange: "for v1, v2 = range a".
+func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
+       if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
+               return nil
+       }
+
+       if v1 == nil || v2 != nil {
+               return nil
+       }
+
+       if len(loop.Body) != 1 || loop.Body[0] == nil {
+               return nil
+       }
+
+       stmt1 := loop.Body[0] // only stmt in body
+       if stmt1.Op() != ir.OAS {
+               return nil
+       }
+       stmt := stmt1.(*ir.AssignStmt)
+       if stmt.X.Op() != ir.OINDEX {
+               return nil
+       }
+       lhs := stmt.X.(*ir.IndexExpr)
+
+       if !ir.SameSafeExpr(lhs.X, a) || !ir.SameSafeExpr(lhs.Index, v1) {
+               return nil
+       }
+
+       elemsize := typecheck.RangeExprType(loop.X.Type()).Elem().Width
+       if elemsize <= 0 || !ir.IsZero(stmt.Y) {
+               return nil
+       }
+
+       // Convert to
+       // if len(a) != 0 {
+       //      hp = &a[0]
+       //      hn = len(a)*sizeof(elem(a))
+       //      memclr{NoHeap,Has}Pointers(hp, hn)
+       //      i = len(a) - 1
+       // }
+       n := ir.NewIfStmt(base.Pos, nil, nil, nil)
+       n.Body = nil
+       n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(0))
+
+       // hp = &a[0]
+       hp := typecheck.Temp(types.Types[types.TUNSAFEPTR])
+
+       ix := ir.NewIndexExpr(base.Pos, a, ir.NewInt(0))
+       ix.SetBounded(true)
+       addr := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
+       n.Body.Append(ir.NewAssignStmt(base.Pos, hp, addr))
+
+       // hn = len(a) * sizeof(elem(a))
+       hn := typecheck.Temp(types.Types[types.TUINTPTR])
+       mul := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(elemsize)), types.Types[types.TUINTPTR])
+       n.Body.Append(ir.NewAssignStmt(base.Pos, hn, mul))
+
+       var fn ir.Node
+       if a.Type().Elem().HasPointers() {
+               // memclrHasPointers(hp, hn)
+               ir.CurFunc.SetWBPos(stmt.Pos())
+               fn = mkcallstmt("memclrHasPointers", hp, hn)
+       } else {
+               // memclrNoHeapPointers(hp, hn)
+               fn = mkcallstmt("memclrNoHeapPointers", hp, hn)
+       }
+
+       n.Body.Append(fn)
+
+       // i = len(a) - 1
+       v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(1)))
+
+       n.Body.Append(v1)
+
+       n.Cond = typecheck.Expr(n.Cond)
+       n.Cond = typecheck.DefaultLit(n.Cond, nil)
+       typecheck.Stmts(n.Body)
+       return walkStmt(n)
+}
+
+// addptr returns (*T)(uintptr(p) + n).
+func addptr(p ir.Node, n int64) ir.Node {
+       t := p.Type()
+
+       p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
+       p.SetType(types.Types[types.TUINTPTR])
+
+       p = ir.NewBinaryExpr(base.Pos, ir.OADD, p, ir.NewInt(n))
+
+       p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
+       p.SetType(t)
+
+       return p
+}

diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
new file mode 100644 (file)
index 0000000..873be28
--- /dev/null
+++ b/src/cmd/compile/internal/walk/select.go
@@ -0,0 +1,295 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+)
+
+func walkSelect(sel *ir.SelectStmt) {
+       lno := ir.SetPos(sel)
+       if sel.Walked() {
+               base.Fatalf("double walkSelect")
+       }
+       sel.SetWalked(true)
+
+       init := ir.TakeInit(sel)
+
+       init = append(init, walkSelectCases(sel.Cases)...)
+       sel.Cases = nil
+
+       sel.Compiled = init
+       walkStmtList(sel.Compiled)
+
+       base.Pos = lno
+}
+
+func walkSelectCases(cases []*ir.CommClause) []ir.Node {
+       ncas := len(cases)
+       sellineno := base.Pos
+
+       // optimization: zero-case select
+       if ncas == 0 {
+               return []ir.Node{mkcallstmt("block")}
+       }
+
+       // optimization: one-case select: single op.
+       if ncas == 1 {
+               cas := cases[0]
+               ir.SetPos(cas)
+               l := cas.Init()
+               if cas.Comm != nil { // not default:
+                       n := cas.Comm
+                       l = append(l, ir.TakeInit(n)...)
+                       switch n.Op() {
+                       default:
+                               base.Fatalf("select %v", n.Op())
+
+                       case ir.OSEND:
+                               // already ok
+
+                       case ir.OSELRECV2:
+                               r := n.(*ir.AssignListStmt)
+                               if ir.IsBlank(r.Lhs[0]) && ir.IsBlank(r.Lhs[1]) {
+                                       n = r.Rhs[0]
+                                       break
+                               }
+                               r.SetOp(ir.OAS2RECV)
+                       }
+
+                       l = append(l, n)
+               }
+
+               l = append(l, cas.Body...)
+               l = append(l, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
+               return l
+       }
+
+       // convert case value arguments to addresses.
+       // this rewrite is used by both the general code and the next optimization.
+       var dflt *ir.CommClause
+       for _, cas := range cases {
+               ir.SetPos(cas)
+               n := cas.Comm
+               if n == nil {
+                       dflt = cas
+                       continue
+               }
+               switch n.Op() {
+               case ir.OSEND:
+                       n := n.(*ir.SendStmt)
+                       n.Value = typecheck.NodAddr(n.Value)
+                       n.Value = typecheck.Expr(n.Value)
+
+               case ir.OSELRECV2:
+                       n := n.(*ir.AssignListStmt)
+                       if !ir.IsBlank(n.Lhs[0]) {
+                               n.Lhs[0] = typecheck.NodAddr(n.Lhs[0])
+                               n.Lhs[0] = typecheck.Expr(n.Lhs[0])
+                       }
+               }
+       }
+
+       // optimization: two-case select but one is default: single non-blocking op.
+       if ncas == 2 && dflt != nil {
+               cas := cases[0]
+               if cas == dflt {
+                       cas = cases[1]
+               }
+
+               n := cas.Comm
+               ir.SetPos(n)
+               r := ir.NewIfStmt(base.Pos, nil, nil, nil)
+               *r.PtrInit() = cas.Init()
+               var call ir.Node
+               switch n.Op() {
+               default:
+                       base.Fatalf("select %v", n.Op())
+
+               case ir.OSEND:
+                       // if selectnbsend(c, v) { body } else { default body }
+                       n := n.(*ir.SendStmt)
+                       ch := n.Chan
+                       call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Value)
+
+               case ir.OSELRECV2:
+                       n := n.(*ir.AssignListStmt)
+                       recv := n.Rhs[0].(*ir.UnaryExpr)
+                       ch := recv.X
+                       elem := n.Lhs[0]
+                       if ir.IsBlank(elem) {
+                               elem = typecheck.NodNil()
+                       }
+                       if ir.IsBlank(n.Lhs[1]) {
+                               // if selectnbrecv(&v, c) { body } else { default body }
+                               call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
+                       } else {
+                               // TODO(cuonglm): make this use selectnbrecv()
+                               // if selectnbrecv2(&v, &received, c) { body } else { default body }
+                               receivedp := typecheck.Expr(typecheck.NodAddr(n.Lhs[1]))
+                               call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
+                       }
+               }
+
+               r.Cond = typecheck.Expr(call)
+               r.Body = cas.Body
+               r.Else = append(dflt.Init(), dflt.Body...)
+               return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
+       }
+
+       if dflt != nil {
+               ncas--
+       }
+       casorder := make([]*ir.CommClause, ncas)
+       nsends, nrecvs := 0, 0
+
+       var init []ir.Node
+
+       // generate sel-struct
+       base.Pos = sellineno
+       selv := typecheck.Temp(types.NewArray(scasetype(), int64(ncas)))
+       init = append(init, typecheck.Stmt(ir.NewAssignStmt(base.Pos, selv, nil)))
+
+       // No initialization for order; runtime.selectgo is responsible for that.
+       order := typecheck.Temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
+
+       var pc0, pcs ir.Node
+       if base.Flag.Race {
+               pcs = typecheck.Temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
+               pc0 = typecheck.Expr(typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(0))))
+       } else {
+               pc0 = typecheck.NodNil()
+       }
+
+       // register cases
+       for _, cas := range cases {
+               ir.SetPos(cas)
+
+               init = append(init, ir.TakeInit(cas)...)
+
+               n := cas.Comm
+               if n == nil { // default:
+                       continue
+               }
+
+               var i int
+               var c, elem ir.Node
+               switch n.Op() {
+               default:
+                       base.Fatalf("select %v", n.Op())
+               case ir.OSEND:
+                       n := n.(*ir.SendStmt)
+                       i = nsends
+                       nsends++
+                       c = n.Chan
+                       elem = n.Value
+               case ir.OSELRECV2:
+                       n := n.(*ir.AssignListStmt)
+                       nrecvs++
+                       i = ncas - nrecvs
+                       recv := n.Rhs[0].(*ir.UnaryExpr)
+                       c = recv.X
+                       elem = n.Lhs[0]
+               }
+
+               casorder[i] = cas
+
+               setField := func(f string, val ir.Node) {
+                       r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, ir.NewInt(int64(i))), typecheck.Lookup(f)), val)
+                       init = append(init, typecheck.Stmt(r))
+               }
+
+               c = typecheck.ConvNop(c, types.Types[types.TUNSAFEPTR])
+               setField("c", c)
+               if !ir.IsBlank(elem) {
+                       elem = typecheck.ConvNop(elem, types.Types[types.TUNSAFEPTR])
+                       setField("elem", elem)
+               }
+
+               // TODO(mdempsky): There should be a cleaner way to
+               // handle this.
+               if base.Flag.Race {
+                       r := mkcallstmt("selectsetpc", typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
+                       init = append(init, r)
+               }
+       }
+       if nsends+nrecvs != ncas {
+               base.Fatalf("walkSelectCases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
+       }
+
+       // run the select
+       base.Pos = sellineno
+       chosen := typecheck.Temp(types.Types[types.TINT])
+       recvOK := typecheck.Temp(types.Types[types.TBOOL])
+       r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+       r.Lhs = []ir.Node{chosen, recvOK}
+       fn := typecheck.LookupRuntime("selectgo")
+       var fnInit ir.Nodes
+       r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), &fnInit, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, ir.NewInt(int64(nsends)), ir.NewInt(int64(nrecvs)), ir.NewBool(dflt == nil))}
+       init = append(init, fnInit...)
+       init = append(init, typecheck.Stmt(r))
+
+       // selv and order are no longer alive after selectgo.
+       init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, selv))
+       init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, order))
+       if base.Flag.Race {
+               init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, pcs))
+       }
+
+       // dispatch cases
+       dispatch := func(cond ir.Node, cas *ir.CommClause) {
+               cond = typecheck.Expr(cond)
+               cond = typecheck.DefaultLit(cond, nil)
+
+               r := ir.NewIfStmt(base.Pos, cond, nil, nil)
+
+               if n := cas.Comm; n != nil && n.Op() == ir.OSELRECV2 {
+                       n := n.(*ir.AssignListStmt)
+                       if !ir.IsBlank(n.Lhs[1]) {
+                               x := ir.NewAssignStmt(base.Pos, n.Lhs[1], recvOK)
+                               r.Body.Append(typecheck.Stmt(x))
+                       }
+               }
+
+               r.Body.Append(cas.Body.Take()...)
+               r.Body.Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
+               init = append(init, r)
+       }
+
+       if dflt != nil {
+               ir.SetPos(dflt)
+               dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, ir.NewInt(0)), dflt)
+       }
+       for i, cas := range casorder {
+               ir.SetPos(cas)
+               dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, ir.NewInt(int64(i))), cas)
+       }
+
+       return init
+}
+
+// bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
+func bytePtrToIndex(n ir.Node, i int64) ir.Node {
+       s := typecheck.NodAddr(ir.NewIndexExpr(base.Pos, n, ir.NewInt(i)))
+       t := types.NewPtr(types.Types[types.TUINT8])
+       return typecheck.ConvNop(s, t)
+}
+
+var scase *types.Type
+
+// Keep in sync with src/runtime/select.go.
+func scasetype() *types.Type {
+       if scase == nil {
+               scase = types.NewStruct(types.NoPkg, []*types.Field{
+                       types.NewField(base.Pos, typecheck.Lookup("c"), types.Types[types.TUNSAFEPTR]),
+                       types.NewField(base.Pos, typecheck.Lookup("elem"), types.Types[types.TUNSAFEPTR]),
+               })
+               scase.SetNoalg(true)
+       }
+       return scase
+}

diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
new file mode 100644 (file)
index 0000000..46a621c
--- /dev/null
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -0,0 +1,296 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+)
+
+// The result of walkStmt MUST be assigned back to n, e.g.
+//     n.Left = walkStmt(n.Left)
+func walkStmt(n ir.Node) ir.Node {
+       if n == nil {
+               return n
+       }
+
+       ir.SetPos(n)
+
+       walkStmtList(n.Init())
+
+       switch n.Op() {
+       default:
+               if n.Op() == ir.ONAME {
+                       n := n.(*ir.Name)
+                       base.Errorf("%v is not a top level statement", n.Sym())
+               } else {
+                       base.Errorf("%v is not a top level statement", n.Op())
+               }
+               ir.Dump("nottop", n)
+               return n
+
+       case ir.OAS,
+               ir.OASOP,
+               ir.OAS2,
+               ir.OAS2DOTTYPE,
+               ir.OAS2RECV,
+               ir.OAS2FUNC,
+               ir.OAS2MAPR,
+               ir.OCLOSE,
+               ir.OCOPY,
+               ir.OCALLMETH,
+               ir.OCALLINTER,
+               ir.OCALL,
+               ir.OCALLFUNC,
+               ir.ODELETE,
+               ir.OSEND,
+               ir.OPRINT,
+               ir.OPRINTN,
+               ir.OPANIC,
+               ir.ORECOVER,
+               ir.OGETG:
+               if n.Typecheck() == 0 {
+                       base.Fatalf("missing typecheck: %+v", n)
+               }
+               init := ir.TakeInit(n)
+               n = walkExpr(n, &init)
+               if n.Op() == ir.ONAME {
+                       // copy rewrote to a statement list and a temp for the length.
+                       // Throw away the temp to avoid plain values as statements.
+                       n = ir.NewBlockStmt(n.Pos(), init)
+                       init = nil
+               }
+               if len(init) > 0 {
+                       switch n.Op() {
+                       case ir.OAS, ir.OAS2, ir.OBLOCK:
+                               n.(ir.InitNode).PtrInit().Prepend(init...)
+
+                       default:
+                               init.Append(n)
+                               n = ir.NewBlockStmt(n.Pos(), init)
+                       }
+               }
+               return n
+
+       // special case for a receive where we throw away
+       // the value received.
+       case ir.ORECV:
+               n := n.(*ir.UnaryExpr)
+               return walkRecv(n)
+
+       case ir.OBREAK,
+               ir.OCONTINUE,
+               ir.OFALL,
+               ir.OGOTO,
+               ir.OLABEL,
+               ir.ODCL,
+               ir.ODCLCONST,
+               ir.ODCLTYPE,
+               ir.OCHECKNIL,
+               ir.OVARDEF,
+               ir.OVARKILL,
+               ir.OVARLIVE:
+               return n
+
+       case ir.OBLOCK:
+               n := n.(*ir.BlockStmt)
+               walkStmtList(n.List)
+               return n
+
+       case ir.OCASE:
+               base.Errorf("case statement out of place")
+               panic("unreachable")
+
+       case ir.ODEFER:
+               n := n.(*ir.GoDeferStmt)
+               ir.CurFunc.SetHasDefer(true)
+               ir.CurFunc.NumDefers++
+               if ir.CurFunc.NumDefers > maxOpenDefers {
+                       // Don't allow open-coded defers if there are more than
+                       // 8 defers in the function, since we use a single
+                       // byte to record active defers.
+                       ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+               }
+               if n.Esc() != ir.EscNever {
+                       // If n.Esc is not EscNever, then this defer occurs in a loop,
+                       // so open-coded defers cannot be used in this function.
+                       ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+               }
+               fallthrough
+       case ir.OGO:
+               n := n.(*ir.GoDeferStmt)
+               return walkGoDefer(n)
+
+       case ir.OFOR, ir.OFORUNTIL:
+               n := n.(*ir.ForStmt)
+               return walkFor(n)
+
+       case ir.OIF:
+               n := n.(*ir.IfStmt)
+               return walkIf(n)
+
+       case ir.ORETURN:
+               n := n.(*ir.ReturnStmt)
+               return walkReturn(n)
+
+       case ir.OTAILCALL:
+               n := n.(*ir.TailCallStmt)
+               return n
+
+       case ir.OINLMARK:
+               n := n.(*ir.InlineMarkStmt)
+               return n
+
+       case ir.OSELECT:
+               n := n.(*ir.SelectStmt)
+               walkSelect(n)
+               return n
+
+       case ir.OSWITCH:
+               n := n.(*ir.SwitchStmt)
+               walkSwitch(n)
+               return n
+
+       case ir.ORANGE:
+               n := n.(*ir.RangeStmt)
+               return walkRange(n)
+       }
+
+       // No return! Each case must return (or panic),
+       // to avoid confusion about what gets returned
+       // in the presence of type assertions.
+}
+
+func walkStmtList(s []ir.Node) {
+       for i := range s {
+               s[i] = walkStmt(s[i])
+       }
+}
+
+// walkFor walks an OFOR or OFORUNTIL node.
+func walkFor(n *ir.ForStmt) ir.Node {
+       if n.Cond != nil {
+               init := ir.TakeInit(n.Cond)
+               walkStmtList(init)
+               n.Cond = walkExpr(n.Cond, &init)
+               n.Cond = ir.InitExpr(init, n.Cond)
+       }
+
+       n.Post = walkStmt(n.Post)
+       if n.Op() == ir.OFORUNTIL {
+               walkStmtList(n.Late)
+       }
+       walkStmtList(n.Body)
+       return n
+}
+
+// walkGoDefer walks an OGO or ODEFER node.
+func walkGoDefer(n *ir.GoDeferStmt) ir.Node {
+       var init ir.Nodes
+       switch call := n.Call; call.Op() {
+       case ir.OPRINT, ir.OPRINTN:
+               call := call.(*ir.CallExpr)
+               n.Call = wrapCall(call, &init)
+
+       case ir.ODELETE:
+               call := call.(*ir.CallExpr)
+               if mapfast(call.Args[0].Type()) == mapslow {
+                       n.Call = wrapCall(call, &init)
+               } else {
+                       n.Call = walkExpr(call, &init)
+               }
+
+       case ir.OCOPY:
+               call := call.(*ir.BinaryExpr)
+               n.Call = walkCopy(call, &init, true)
+
+       case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+               call := call.(*ir.CallExpr)
+               if len(call.KeepAlive) > 0 {
+                       n.Call = wrapCall(call, &init)
+               } else {
+                       n.Call = walkExpr(call, &init)
+               }
+
+       default:
+               n.Call = walkExpr(call, &init)
+       }
+       if len(init) > 0 {
+               init.Append(n)
+               return ir.NewBlockStmt(n.Pos(), init)
+       }
+       return n
+}
+
+// walkIf walks an OIF node.
+func walkIf(n *ir.IfStmt) ir.Node {
+       n.Cond = walkExpr(n.Cond, n.PtrInit())
+       walkStmtList(n.Body)
+       walkStmtList(n.Else)
+       return n
+}
+
+// The result of wrapCall MUST be assigned back to n, e.g.
+//     n.Left = wrapCall(n.Left, init)
+func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+       if len(n.Init()) != 0 {
+               walkStmtList(n.Init())
+               init.Append(ir.TakeInit(n)...)
+       }
+
+       isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
+
+       // Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
+       if !isBuiltinCall && n.IsDDD {
+               last := len(n.Args) - 1
+               if va := n.Args[last]; va.Op() == ir.OSLICELIT {
+                       va := va.(*ir.CompLitExpr)
+                       n.Args = append(n.Args[:last], va.List...)
+                       n.IsDDD = false
+               }
+       }
+
+       // origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
+       origArgs := make([]ir.Node, len(n.Args))
+       var funcArgs []*ir.Field
+       for i, arg := range n.Args {
+               s := typecheck.LookupNum("a", i)
+               if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
+                       origArgs[i] = arg
+                       arg = arg.(*ir.ConvExpr).X
+                       n.Args[i] = arg
+               }
+               funcArgs = append(funcArgs, ir.NewField(base.Pos, s, nil, arg.Type()))
+       }
+       t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
+
+       wrapCall_prgen++
+       sym := typecheck.LookupNum("wrap·", wrapCall_prgen)
+       fn := typecheck.DeclFunc(sym, t)
+
+       args := ir.ParamNames(t.Type())
+       for i, origArg := range origArgs {
+               if origArg == nil {
+                       continue
+               }
+               args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
+       }
+       call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
+       if !isBuiltinCall {
+               call.SetOp(ir.OCALL)
+               call.IsDDD = n.IsDDD
+       }
+       fn.Body = []ir.Node{call}
+
+       typecheck.FinishFuncBody()
+
+       typecheck.Func(fn)
+       typecheck.Stmts(fn.Body)
+       typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+       call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
+       return walkExpr(typecheck.Stmt(call), init)
+}

diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
new file mode 100644 (file)
index 0000000..162de01
--- /dev/null
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -0,0 +1,568 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "go/constant"
+       "go/token"
+       "sort"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// walkSwitch walks a switch statement.
+func walkSwitch(sw *ir.SwitchStmt) {
+       // Guard against double walk, see #25776.
+       if sw.Walked() {
+               return // Was fatal, but eliminating every possible source of double-walking is hard
+       }
+       sw.SetWalked(true)
+
+       if sw.Tag != nil && sw.Tag.Op() == ir.OTYPESW {
+               walkSwitchType(sw)
+       } else {
+               walkSwitchExpr(sw)
+       }
+}
+
+// walkSwitchExpr generates an AST implementing sw.  sw is an
+// expression switch.
+func walkSwitchExpr(sw *ir.SwitchStmt) {
+       lno := ir.SetPos(sw)
+
+       cond := sw.Tag
+       sw.Tag = nil
+
+       // convert switch {...} to switch true {...}
+       if cond == nil {
+               cond = ir.NewBool(true)
+               cond = typecheck.Expr(cond)
+               cond = typecheck.DefaultLit(cond, nil)
+       }
+
+       // Given "switch string(byteslice)",
+       // with all cases being side-effect free,
+       // use a zero-cost alias of the byte slice.
+       // Do this before calling walkExpr on cond,
+       // because walkExpr will lower the string
+       // conversion into a runtime call.
+       // See issue 24937 for more discussion.
+       if cond.Op() == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
+               cond := cond.(*ir.ConvExpr)
+               cond.SetOp(ir.OBYTES2STRTMP)
+       }
+
+       cond = walkExpr(cond, sw.PtrInit())
+       if cond.Op() != ir.OLITERAL && cond.Op() != ir.ONIL {
+               cond = copyExpr(cond, cond.Type(), &sw.Compiled)
+       }
+
+       base.Pos = lno
+
+       s := exprSwitch{
+               exprname: cond,
+       }
+
+       var defaultGoto ir.Node
+       var body ir.Nodes
+       for _, ncase := range sw.Cases {
+               label := typecheck.AutoLabel(".s")
+               jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
+
+               // Process case dispatch.
+               if len(ncase.List) == 0 {
+                       if defaultGoto != nil {
+                               base.Fatalf("duplicate default case not detected during typechecking")
+                       }
+                       defaultGoto = jmp
+               }
+
+               for _, n1 := range ncase.List {
+                       s.Add(ncase.Pos(), n1, jmp)
+               }
+
+               // Process body.
+               body.Append(ir.NewLabelStmt(ncase.Pos(), label))
+               body.Append(ncase.Body...)
+               if fall, pos := endsInFallthrough(ncase.Body); !fall {
+                       br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
+                       br.SetPos(pos)
+                       body.Append(br)
+               }
+       }
+       sw.Cases = nil
+
+       if defaultGoto == nil {
+               br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
+               br.SetPos(br.Pos().WithNotStmt())
+               defaultGoto = br
+       }
+
+       s.Emit(&sw.Compiled)
+       sw.Compiled.Append(defaultGoto)
+       sw.Compiled.Append(body.Take()...)
+       walkStmtList(sw.Compiled)
+}
+
+// An exprSwitch walks an expression switch.
+type exprSwitch struct {
+       exprname ir.Node // value being switched on
+
+       done    ir.Nodes
+       clauses []exprClause
+}
+
+type exprClause struct {
+       pos    src.XPos
+       lo, hi ir.Node
+       jmp    ir.Node
+}
+
+func (s *exprSwitch) Add(pos src.XPos, expr, jmp ir.Node) {
+       c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
+       if types.IsOrdered[s.exprname.Type().Kind()] && expr.Op() == ir.OLITERAL {
+               s.clauses = append(s.clauses, c)
+               return
+       }
+
+       s.flush()
+       s.clauses = append(s.clauses, c)
+       s.flush()
+}
+
+func (s *exprSwitch) Emit(out *ir.Nodes) {
+       s.flush()
+       out.Append(s.done.Take()...)
+}
+
+func (s *exprSwitch) flush() {
+       cc := s.clauses
+       s.clauses = nil
+       if len(cc) == 0 {
+               return
+       }
+
+       // Caution: If len(cc) == 1, then cc[0] might not an OLITERAL.
+       // The code below is structured to implicitly handle this case
+       // (e.g., sort.Slice doesn't need to invoke the less function
+       // when there's only a single slice element).
+
+       if s.exprname.Type().IsString() && len(cc) >= 2 {
+               // Sort strings by length and then by value. It is
+               // much cheaper to compare lengths than values, and
+               // all we need here is consistency. We respect this
+               // sorting below.
+               sort.Slice(cc, func(i, j int) bool {
+                       si := ir.StringVal(cc[i].lo)
+                       sj := ir.StringVal(cc[j].lo)
+                       if len(si) != len(sj) {
+                               return len(si) < len(sj)
+                       }
+                       return si < sj
+               })
+
+               // runLen returns the string length associated with a
+               // particular run of exprClauses.
+               runLen := func(run []exprClause) int64 { return int64(len(ir.StringVal(run[0].lo))) }
+
+               // Collapse runs of consecutive strings with the same length.
+               var runs [][]exprClause
+               start := 0
+               for i := 1; i < len(cc); i++ {
+                       if runLen(cc[start:]) != runLen(cc[i:]) {
+                               runs = append(runs, cc[start:i])
+                               start = i
+                       }
+               }
+               runs = append(runs, cc[start:])
+
+               // Perform two-level binary search.
+               binarySearch(len(runs), &s.done,
+                       func(i int) ir.Node {
+                               return ir.NewBinaryExpr(base.Pos, ir.OLE, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), ir.NewInt(runLen(runs[i-1])))
+                       },
+                       func(i int, nif *ir.IfStmt) {
+                               run := runs[i]
+                               nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), ir.NewInt(runLen(run)))
+                               s.search(run, &nif.Body)
+                       },
+               )
+               return
+       }
+
+       sort.Slice(cc, func(i, j int) bool {
+               return constant.Compare(cc[i].lo.Val(), token.LSS, cc[j].lo.Val())
+       })
+
+       // Merge consecutive integer cases.
+       if s.exprname.Type().IsInteger() {
+               consecutive := func(last, next constant.Value) bool {
+                       delta := constant.BinaryOp(next, token.SUB, last)
+                       return constant.Compare(delta, token.EQL, constant.MakeInt64(1))
+               }
+
+               merged := cc[:1]
+               for _, c := range cc[1:] {
+                       last := &merged[len(merged)-1]
+                       if last.jmp == c.jmp && consecutive(last.hi.Val(), c.lo.Val()) {
+                               last.hi = c.lo
+                       } else {
+                               merged = append(merged, c)
+                       }
+               }
+               cc = merged
+       }
+
+       s.search(cc, &s.done)
+}
+
+func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
+       binarySearch(len(cc), out,
+               func(i int) ir.Node {
+                       return ir.NewBinaryExpr(base.Pos, ir.OLE, s.exprname, cc[i-1].hi)
+               },
+               func(i int, nif *ir.IfStmt) {
+                       c := &cc[i]
+                       nif.Cond = c.test(s.exprname)
+                       nif.Body = []ir.Node{c.jmp}
+               },
+       )
+}
+
+func (c *exprClause) test(exprname ir.Node) ir.Node {
+       // Integer range.
+       if c.hi != c.lo {
+               low := ir.NewBinaryExpr(c.pos, ir.OGE, exprname, c.lo)
+               high := ir.NewBinaryExpr(c.pos, ir.OLE, exprname, c.hi)
+               return ir.NewLogicalExpr(c.pos, ir.OANDAND, low, high)
+       }
+
+       // Optimize "switch true { ...}" and "switch false { ... }".
+       if ir.IsConst(exprname, constant.Bool) && !c.lo.Type().IsInterface() {
+               if ir.BoolVal(exprname) {
+                       return c.lo
+               } else {
+                       return ir.NewUnaryExpr(c.pos, ir.ONOT, c.lo)
+               }
+       }
+
+       return ir.NewBinaryExpr(c.pos, ir.OEQ, exprname, c.lo)
+}
+
+func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
+       // In theory, we could be more aggressive, allowing any
+       // side-effect-free expressions in cases, but it's a bit
+       // tricky because some of that information is unavailable due
+       // to the introduction of temporaries during order.
+       // Restricting to constants is simple and probably powerful
+       // enough.
+
+       for _, ncase := range sw.Cases {
+               for _, v := range ncase.List {
+                       if v.Op() != ir.OLITERAL {
+                               return false
+                       }
+               }
+       }
+       return true
+}
+
+// endsInFallthrough reports whether stmts ends with a "fallthrough" statement.
+func endsInFallthrough(stmts []ir.Node) (bool, src.XPos) {
+       // Search backwards for the index of the fallthrough
+       // statement. Do not assume it'll be in the last
+       // position, since in some cases (e.g. when the statement
+       // list contains autotmp_ variables), one or more OVARKILL
+       // nodes will be at the end of the list.
+
+       i := len(stmts) - 1
+       for i >= 0 && stmts[i].Op() == ir.OVARKILL {
+               i--
+       }
+       if i < 0 {
+               return false, src.NoXPos
+       }
+       return stmts[i].Op() == ir.OFALL, stmts[i].Pos()
+}
+
+// walkSwitchType generates an AST that implements sw, where sw is a
+// type switch.
+func walkSwitchType(sw *ir.SwitchStmt) {
+       var s typeSwitch
+       s.facename = sw.Tag.(*ir.TypeSwitchGuard).X
+       sw.Tag = nil
+
+       s.facename = walkExpr(s.facename, sw.PtrInit())
+       s.facename = copyExpr(s.facename, s.facename.Type(), &sw.Compiled)
+       s.okname = typecheck.Temp(types.Types[types.TBOOL])
+
+       // Get interface descriptor word.
+       // For empty interfaces this will be the type.
+       // For non-empty interfaces this will be the itab.
+       itab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s.facename)
+
+       // For empty interfaces, do:
+       //     if e._type == nil {
+       //         do nil case if it exists, otherwise default
+       //     }
+       //     h := e._type.hash
+       // Use a similar strategy for non-empty interfaces.
+       ifNil := ir.NewIfStmt(base.Pos, nil, nil, nil)
+       ifNil.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, typecheck.NodNil())
+       base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
+       ifNil.Cond = typecheck.Expr(ifNil.Cond)
+       ifNil.Cond = typecheck.DefaultLit(ifNil.Cond, nil)
+       // ifNil.Nbody assigned at end.
+       sw.Compiled.Append(ifNil)
+
+       // Load hash from type or itab.
+       dotHash := typeHashFieldOf(base.Pos, itab)
+       s.hashname = copyExpr(dotHash, dotHash.Type(), &sw.Compiled)
+
+       br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
+       var defaultGoto, nilGoto ir.Node
+       var body ir.Nodes
+       for _, ncase := range sw.Cases {
+               caseVar := ncase.Var
+
+               // For single-type cases with an interface type,
+               // we initialize the case variable as part of the type assertion.
+               // In other cases, we initialize it in the body.
+               var singleType *types.Type
+               if len(ncase.List) == 1 && ncase.List[0].Op() == ir.OTYPE {
+                       singleType = ncase.List[0].Type()
+               }
+               caseVarInitialized := false
+
+               label := typecheck.AutoLabel(".s")
+               jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
+
+               if len(ncase.List) == 0 { // default:
+                       if defaultGoto != nil {
+                               base.Fatalf("duplicate default case not detected during typechecking")
+                       }
+                       defaultGoto = jmp
+               }
+
+               for _, n1 := range ncase.List {
+                       if ir.IsNil(n1) { // case nil:
+                               if nilGoto != nil {
+                                       base.Fatalf("duplicate nil case not detected during typechecking")
+                               }
+                               nilGoto = jmp
+                               continue
+                       }
+
+                       if singleType != nil && singleType.IsInterface() {
+                               s.Add(ncase.Pos(), n1.Type(), caseVar, jmp)
+                               caseVarInitialized = true
+                       } else {
+                               s.Add(ncase.Pos(), n1.Type(), nil, jmp)
+                       }
+               }
+
+               body.Append(ir.NewLabelStmt(ncase.Pos(), label))
+               if caseVar != nil && !caseVarInitialized {
+                       val := s.facename
+                       if singleType != nil {
+                               // We have a single concrete type. Extract the data.
+                               if singleType.IsInterface() {
+                                       base.Fatalf("singleType interface should have been handled in Add")
+                               }
+                               val = ifaceData(ncase.Pos(), s.facename, singleType)
+                       }
+                       l := []ir.Node{
+                               ir.NewDecl(ncase.Pos(), ir.ODCL, caseVar),
+                               ir.NewAssignStmt(ncase.Pos(), caseVar, val),
+                       }
+                       typecheck.Stmts(l)
+                       body.Append(l...)
+               }
+               body.Append(ncase.Body...)
+               body.Append(br)
+       }
+       sw.Cases = nil
+
+       if defaultGoto == nil {
+               defaultGoto = br
+       }
+       if nilGoto == nil {
+               nilGoto = defaultGoto
+       }
+       ifNil.Body = []ir.Node{nilGoto}
+
+       s.Emit(&sw.Compiled)
+       sw.Compiled.Append(defaultGoto)
+       sw.Compiled.Append(body.Take()...)
+
+       walkStmtList(sw.Compiled)
+}
+
+// typeHashFieldOf returns an expression to select the type hash field
+// from an interface's descriptor word (whether a *runtime._type or
+// *runtime.itab pointer).
+func typeHashFieldOf(pos src.XPos, itab *ir.UnaryExpr) *ir.SelectorExpr {
+       if itab.Op() != ir.OITAB {
+               base.Fatalf("expected OITAB, got %v", itab.Op())
+       }
+       var hashField *types.Field
+       if itab.X.Type().IsEmptyInterface() {
+               // runtime._type's hash field
+               if rtypeHashField == nil {
+                       rtypeHashField = runtimeField("hash", int64(2*types.PtrSize), types.Types[types.TUINT32])
+               }
+               hashField = rtypeHashField
+       } else {
+               // runtime.itab's hash field
+               if itabHashField == nil {
+                       itabHashField = runtimeField("hash", int64(2*types.PtrSize), types.Types[types.TUINT32])
+               }
+               hashField = itabHashField
+       }
+       return boundedDotPtr(pos, itab, hashField)
+}
+
+var rtypeHashField, itabHashField *types.Field
+
+// A typeSwitch walks a type switch.
+type typeSwitch struct {
+       // Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
+       facename ir.Node // value being type-switched on
+       hashname ir.Node // type hash of the value being type-switched on
+       okname   ir.Node // boolean used for comma-ok type assertions
+
+       done    ir.Nodes
+       clauses []typeClause
+}
+
+type typeClause struct {
+       hash uint32
+       body ir.Nodes
+}
+
+func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar *ir.Name, jmp ir.Node) {
+       var body ir.Nodes
+       if caseVar != nil {
+               l := []ir.Node{
+                       ir.NewDecl(pos, ir.ODCL, caseVar),
+                       ir.NewAssignStmt(pos, caseVar, nil),
+               }
+               typecheck.Stmts(l)
+               body.Append(l...)
+       } else {
+               caseVar = ir.BlankNode.(*ir.Name)
+       }
+
+       // cv, ok = iface.(type)
+       as := ir.NewAssignListStmt(pos, ir.OAS2, nil, nil)
+       as.Lhs = []ir.Node{caseVar, s.okname} // cv, ok =
+       dot := ir.NewTypeAssertExpr(pos, s.facename, nil)
+       dot.SetType(typ) // iface.(type)
+       as.Rhs = []ir.Node{dot}
+       appendWalkStmt(&body, as)
+
+       // if ok { goto label }
+       nif := ir.NewIfStmt(pos, nil, nil, nil)
+       nif.Cond = s.okname
+       nif.Body = []ir.Node{jmp}
+       body.Append(nif)
+
+       if !typ.IsInterface() {
+               s.clauses = append(s.clauses, typeClause{
+                       hash: types.TypeHash(typ),
+                       body: body,
+               })
+               return
+       }
+
+       s.flush()
+       s.done.Append(body.Take()...)
+}
+
+func (s *typeSwitch) Emit(out *ir.Nodes) {
+       s.flush()
+       out.Append(s.done.Take()...)
+}
+
+func (s *typeSwitch) flush() {
+       cc := s.clauses
+       s.clauses = nil
+       if len(cc) == 0 {
+               return
+       }
+
+       sort.Slice(cc, func(i, j int) bool { return cc[i].hash < cc[j].hash })
+
+       // Combine adjacent cases with the same hash.
+       merged := cc[:1]
+       for _, c := range cc[1:] {
+               last := &merged[len(merged)-1]
+               if last.hash == c.hash {
+                       last.body.Append(c.body.Take()...)
+               } else {
+                       merged = append(merged, c)
+               }
+       }
+       cc = merged
+
+       binarySearch(len(cc), &s.done,
+               func(i int) ir.Node {
+                       return ir.NewBinaryExpr(base.Pos, ir.OLE, s.hashname, ir.NewInt(int64(cc[i-1].hash)))
+               },
+               func(i int, nif *ir.IfStmt) {
+                       // TODO(mdempsky): Omit hash equality check if
+                       // there's only one type.
+                       c := cc[i]
+                       nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, ir.NewInt(int64(c.hash)))
+                       nif.Body.Append(c.body.Take()...)
+               },
+       )
+}
+
+// binarySearch constructs a binary search tree for handling n cases,
+// and appends it to out. It's used for efficiently implementing
+// switch statements.
+//
+// less(i) should return a boolean expression. If it evaluates true,
+// then cases before i will be tested; otherwise, cases i and later.
+//
+// leaf(i, nif) should setup nif (an OIF node) to test case i. In
+// particular, it should set nif.Left and nif.Nbody.
+func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i int, nif *ir.IfStmt)) {
+       const binarySearchMin = 4 // minimum number of cases for binary search
+
+       var do func(lo, hi int, out *ir.Nodes)
+       do = func(lo, hi int, out *ir.Nodes) {
+               n := hi - lo
+               if n < binarySearchMin {
+                       for i := lo; i < hi; i++ {
+                               nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+                               leaf(i, nif)
+                               base.Pos = base.Pos.WithNotStmt()
+                               nif.Cond = typecheck.Expr(nif.Cond)
+                               nif.Cond = typecheck.DefaultLit(nif.Cond, nil)
+                               out.Append(nif)
+                               out = &nif.Else
+                       }
+                       return
+               }
+
+               half := lo + n/2
+               nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+               nif.Cond = less(half)
+               base.Pos = base.Pos.WithNotStmt()
+               nif.Cond = typecheck.Expr(nif.Cond)
+               nif.Cond = typecheck.DefaultLit(nif.Cond, nil)
+               do(lo, half, &nif.Body)
+               do(half, hi, &nif.Else)
+               out.Append(nif)
+       }
+
+       do(0, n, out)
+}

diff --git a/src/cmd/compile/internal/walk/temp.go b/src/cmd/compile/internal/walk/temp.go
new file mode 100644 (file)
index 0000000..9879a6c
--- /dev/null
+++ b/src/cmd/compile/internal/walk/temp.go
@@ -0,0 +1,40 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+)
+
+// initStackTemp appends statements to init to initialize the given
+// temporary variable to val, and then returns the expression &tmp.
+func initStackTemp(init *ir.Nodes, tmp *ir.Name, val ir.Node) *ir.AddrExpr {
+       if val != nil && !types.Identical(tmp.Type(), val.Type()) {
+               base.Fatalf("bad initial value for %L: %L", tmp, val)
+       }
+       appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, val))
+       return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
+}
+
+// stackTempAddr returns the expression &tmp, where tmp is a newly
+// allocated temporary variable of the given type. Statements to
+// zero-initialize tmp are appended to init.
+func stackTempAddr(init *ir.Nodes, typ *types.Type) *ir.AddrExpr {
+       return initStackTemp(init, typecheck.Temp(typ), nil)
+}
+
+// stackBufAddr returns thte expression &tmp, where tmp is a newly
+// allocated temporary variable of type [len]elem. This variable is
+// initialized, and elem must not contain pointers.
+func stackBufAddr(len int64, elem *types.Type) *ir.AddrExpr {
+       if elem.HasPointers() {
+               base.FatalfAt(base.Pos, "%v has pointers", elem)
+       }
+       tmp := typecheck.Temp(types.NewArray(elem, len))
+       return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
+}

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
new file mode 100644 (file)
index 0000000..b47d96d
--- /dev/null
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -0,0 +1,412 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package walk
+
+import (
+       "errors"
+       "fmt"
+
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/reflectdata"
+       "cmd/compile/internal/ssagen"
+       "cmd/compile/internal/typecheck"
+       "cmd/compile/internal/types"
+       "cmd/internal/src"
+)
+
+// The constant is known to runtime.
+const tmpstringbufsize = 32
+const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
+
+func Walk(fn *ir.Func) {
+       ir.CurFunc = fn
+       errorsBefore := base.Errors()
+       order(fn)
+       if base.Errors() > errorsBefore {
+               return
+       }
+
+       if base.Flag.W != 0 {
+               s := fmt.Sprintf("\nbefore walk %v", ir.CurFunc.Sym())
+               ir.DumpList(s, ir.CurFunc.Body)
+       }
+
+       lno := base.Pos
+
+       base.Pos = lno
+       if base.Errors() > errorsBefore {
+               return
+       }
+       walkStmtList(ir.CurFunc.Body)
+       if base.Flag.W != 0 {
+               s := fmt.Sprintf("after walk %v", ir.CurFunc.Sym())
+               ir.DumpList(s, ir.CurFunc.Body)
+       }
+
+       if base.Flag.Cfg.Instrumenting {
+               instrument(fn)
+       }
+
+       // Eagerly compute sizes of all variables for SSA.
+       for _, n := range fn.Dcl {
+               types.CalcSize(n.Type())
+       }
+}
+
+// walkRecv walks an ORECV node.
+func walkRecv(n *ir.UnaryExpr) ir.Node {
+       if n.Typecheck() == 0 {
+               base.Fatalf("missing typecheck: %+v", n)
+       }
+       init := ir.TakeInit(n)
+
+       n.X = walkExpr(n.X, &init)
+       call := walkExpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
+       return ir.InitExpr(init, call)
+}
+
+func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
+       if n.Op() != ir.OAS {
+               base.Fatalf("convas: not OAS %v", n.Op())
+       }
+       n.SetTypecheck(1)
+
+       if n.X == nil || n.Y == nil {
+               return n
+       }
+
+       lt := n.X.Type()
+       rt := n.Y.Type()
+       if lt == nil || rt == nil {
+               return n
+       }
+
+       if ir.IsBlank(n.X) {
+               n.Y = typecheck.DefaultLit(n.Y, nil)
+               return n
+       }
+
+       if !types.Identical(lt, rt) {
+               n.Y = typecheck.AssignConv(n.Y, lt, "assignment")
+               n.Y = walkExpr(n.Y, init)
+       }
+       types.CalcSize(n.Y.Type())
+
+       return n
+}
+
+var stop = errors.New("stop")
+
+func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
+       if init == nil {
+               base.Fatalf("mkcall with nil init: %v", fn)
+       }
+       if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
+               base.Fatalf("mkcall %v %v", fn, fn.Type())
+       }
+
+       n := fn.Type().NumParams()
+       if n != len(va) {
+               base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
+       }
+
+       call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
+       typecheck.Call(call)
+       call.SetType(t)
+       return walkExpr(call, init).(*ir.CallExpr)
+}
+
+func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
+       return vmkcall(typecheck.LookupRuntime(name), t, init, args)
+}
+
+func mkcallstmt(name string, args ...ir.Node) ir.Node {
+       return mkcallstmt1(typecheck.LookupRuntime(name), args...)
+}
+
+func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
+       return vmkcall(fn, t, init, args)
+}
+
+func mkcallstmt1(fn ir.Node, args ...ir.Node) ir.Node {
+       var init ir.Nodes
+       n := vmkcall(fn, nil, &init, args)
+       if len(init) == 0 {
+               return n
+       }
+       init.Append(n)
+       return ir.NewBlockStmt(n.Pos(), init)
+}
+
+func chanfn(name string, n int, t *types.Type) ir.Node {
+       if !t.IsChan() {
+               base.Fatalf("chanfn %v", t)
+       }
+       fn := typecheck.LookupRuntime(name)
+       switch n {
+       default:
+               base.Fatalf("chanfn %d", n)
+       case 1:
+               fn = typecheck.SubstArgTypes(fn, t.Elem())
+       case 2:
+               fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
+       }
+       return fn
+}
+
+func mapfn(name string, t *types.Type) ir.Node {
+       if !t.IsMap() {
+               base.Fatalf("mapfn %v", t)
+       }
+       fn := typecheck.LookupRuntime(name)
+       fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+       return fn
+}
+
+func mapfndel(name string, t *types.Type) ir.Node {
+       if !t.IsMap() {
+               base.Fatalf("mapfn %v", t)
+       }
+       fn := typecheck.LookupRuntime(name)
+       fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+       return fn
+}
+
+const (
+       mapslow = iota
+       mapfast32
+       mapfast32ptr
+       mapfast64
+       mapfast64ptr
+       mapfaststr
+       nmapfast
+)
+
+type mapnames [nmapfast]string
+
+func mkmapnames(base string, ptr string) mapnames {
+       return mapnames{base, base + "_fast32", base + "_fast32" + ptr, base + "_fast64", base + "_fast64" + ptr, base + "_faststr"}
+}
+
+var mapaccess1 = mkmapnames("mapaccess1", "")
+var mapaccess2 = mkmapnames("mapaccess2", "")
+var mapassign = mkmapnames("mapassign", "ptr")
+var mapdelete = mkmapnames("mapdelete", "")
+
+func mapfast(t *types.Type) int {
+       // Check runtime/map.go:maxElemSize before changing.
+       if t.Elem().Width > 128 {
+               return mapslow
+       }
+       switch reflectdata.AlgType(t.Key()) {
+       case types.AMEM32:
+               if !t.Key().HasPointers() {
+                       return mapfast32
+               }
+               if types.PtrSize == 4 {
+                       return mapfast32ptr
+               }
+               base.Fatalf("small pointer %v", t.Key())
+       case types.AMEM64:
+               if !t.Key().HasPointers() {
+                       return mapfast64
+               }
+               if types.PtrSize == 8 {
+                       return mapfast64ptr
+               }
+               // Two-word object, at least one of which is a pointer.
+               // Use the slow path.
+       case types.ASTRING:
+               return mapfaststr
+       }
+       return mapslow
+}
+
+func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
+       walkExprListSafe(n.Args, init)
+
+       // walkExprListSafe will leave OINDEX (s[n]) alone if both s
+       // and n are name or literal, but those may index the slice we're
+       // modifying here. Fix explicitly.
+       ls := n.Args
+       for i1, n1 := range ls {
+               ls[i1] = cheapExpr(n1, init)
+       }
+}
+
+// Rewrite
+//     go builtin(x, y, z)
+// into
+//     go func(a1, a2, a3) {
+//             builtin(a1, a2, a3)
+//     }(x, y, z)
+// for print, println, and delete.
+//
+// Rewrite
+//     go f(x, y, uintptr(unsafe.Pointer(z)))
+// into
+//     go func(a1, a2, a3) {
+//             builtin(a1, a2, uintptr(a3))
+//     }(x, y, unsafe.Pointer(z))
+// for function contains unsafe-uintptr arguments.
+
+var wrapCall_prgen int
+
+// appendWalkStmt typechecks and walks stmt and then appends it to init.
+func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
+       op := stmt.Op()
+       n := typecheck.Stmt(stmt)
+       if op == ir.OAS || op == ir.OAS2 {
+               // If the assignment has side effects, walkExpr will append them
+               // directly to init for us, while walkStmt will wrap it in an OBLOCK.
+               // We need to append them directly.
+               // TODO(rsc): Clean this up.
+               n = walkExpr(n, init)
+       } else {
+               n = walkStmt(n)
+       }
+       init.Append(n)
+}
+
+// The max number of defers in a function using open-coded defers. We enforce this
+// limit because the deferBits bitmask is currently a single byte (to minimize code size)
+const maxOpenDefers = 8
+
+// backingArrayPtrLen extracts the pointer and length from a slice or string.
+// This constructs two nodes referring to n, so n must be a cheapExpr.
+func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
+       var init ir.Nodes
+       c := cheapExpr(n, &init)
+       if c != n || len(init) != 0 {
+               base.Fatalf("backingArrayPtrLen not cheap: %v", n)
+       }
+       ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
+       if n.Type().IsString() {
+               ptr.SetType(types.Types[types.TUINT8].PtrTo())
+       } else {
+               ptr.SetType(n.Type().Elem().PtrTo())
+       }
+       length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
+       length.SetType(types.Types[types.TINT])
+       return ptr, length
+}
+
+// mayCall reports whether evaluating expression n may require
+// function calls, which could clobber function call arguments/results
+// currently on the stack.
+func mayCall(n ir.Node) bool {
+       // When instrumenting, any expression might require function calls.
+       if base.Flag.Cfg.Instrumenting {
+               return true
+       }
+
+       isSoftFloat := func(typ *types.Type) bool {
+               return types.IsFloat[typ.Kind()] || types.IsComplex[typ.Kind()]
+       }
+
+       return ir.Any(n, func(n ir.Node) bool {
+               // walk should have already moved any Init blocks off of
+               // expressions.
+               if len(n.Init()) != 0 {
+                       base.FatalfAt(n.Pos(), "mayCall %+v", n)
+               }
+
+               switch n.Op() {
+               default:
+                       base.FatalfAt(n.Pos(), "mayCall %+v", n)
+
+               case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+                       return true
+
+               case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
+                       ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
+                       // These ops might panic, make sure they are done
+                       // before we start marshaling args for a call. See issue 16760.
+                       return true
+
+               case ir.OANDAND, ir.OOROR:
+                       n := n.(*ir.LogicalExpr)
+                       // The RHS expression may have init statements that
+                       // should only execute conditionally, and so cannot be
+                       // pulled out to the top-level init list. We could try
+                       // to be more precise here.
+                       return len(n.Y.Init()) != 0
+
+               // When using soft-float, these ops might be rewritten to function calls
+               // so we ensure they are evaluated first.
+               case ir.OADD, ir.OSUB, ir.OMUL, ir.ONEG:
+                       return ssagen.Arch.SoftFloat && isSoftFloat(n.Type())
+               case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+                       n := n.(*ir.BinaryExpr)
+                       return ssagen.Arch.SoftFloat && isSoftFloat(n.X.Type())
+               case ir.OCONV:
+                       n := n.(*ir.ConvExpr)
+                       return ssagen.Arch.SoftFloat && (isSoftFloat(n.Type()) || isSoftFloat(n.X.Type()))
+
+               case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OLINKSYMOFFSET, ir.OMETHEXPR,
+                       ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOMPLEX, ir.OEFACE,
+                       ir.OADDR, ir.OBITNOT, ir.ONOT, ir.OPLUS,
+                       ir.OCAP, ir.OIMAG, ir.OLEN, ir.OREAL,
+                       ir.OCONVNOP, ir.ODOT,
+                       ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.OSPTR,
+                       ir.OBYTES2STRTMP, ir.OGETG, ir.OSLICEHEADER:
+                       // ok: operations that don't require function calls.
+                       // Expand as needed.
+               }
+
+               return false
+       })
+}
+
+// itabType loads the _type field from a runtime.itab struct.
+func itabType(itab ir.Node) ir.Node {
+       if itabTypeField == nil {
+               // runtime.itab's _type field
+               itabTypeField = runtimeField("_type", int64(types.PtrSize), types.NewPtr(types.Types[types.TUINT8]))
+       }
+       return boundedDotPtr(base.Pos, itab, itabTypeField)
+}
+
+var itabTypeField *types.Field
+
+// boundedDotPtr returns a selector expression representing ptr.field
+// and omits nil-pointer checks for ptr.
+func boundedDotPtr(pos src.XPos, ptr ir.Node, field *types.Field) *ir.SelectorExpr {
+       sel := ir.NewSelectorExpr(pos, ir.ODOTPTR, ptr, field.Sym)
+       sel.Selection = field
+       sel.SetType(field.Type)
+       sel.SetTypecheck(1)
+       sel.SetBounded(true) // guaranteed not to fault
+       return sel
+}
+
+func runtimeField(name string, offset int64, typ *types.Type) *types.Field {
+       f := types.NewField(src.NoXPos, ir.Pkgs.Runtime.Lookup(name), typ)
+       f.Offset = offset
+       return f
+}
+
+// ifaceData loads the data field from an interface.
+// The concrete type must be known to have type t.
+// It follows the pointer if !IsDirectIface(t).
+func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
+       if t.IsInterface() {
+               base.Fatalf("ifaceData interface: %v", t)
+       }
+       ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
+       if types.IsDirectIface(t) {
+               ptr.SetType(t)
+               ptr.SetTypecheck(1)
+               return ptr
+       }
+       ptr.SetType(types.NewPtr(t))
+       ptr.SetTypecheck(1)
+       ind := ir.NewStarExpr(pos, ptr)
+       ind.SetType(t)
+       ind.SetTypecheck(1)
+       ind.SetBounded(true)
+       return ind
+}

diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 9c9f6edc5f4912162af268f8f11318fbbdacbb01..e4ef9d7c6a8762e53fd92ff665d6f91a45f4655c 100644 (file)
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -5,16 +5,19 @@
 package wasm
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
+       "cmd/compile/internal/objw"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/wasm"
        "cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &wasm.Linkwasm
        arch.REGSP = wasm.REG_SP
        arch.MAXWIDTH = 1 << 50
@@ -28,31 +31,31 @@ func Init(arch *gc.Arch) {
        arch.SSAGenBlock = ssaGenBlock
 }
 
-func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
+func zeroRange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
        if cnt%8 != 0 {
-               gc.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
+               base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
        }
 
        for i := int64(0); i < cnt; i += 8 {
-               p = pp.Appendpp(p, wasm.AGet, obj.TYPE_REG, wasm.REG_SP, 0, 0, 0, 0)
-               p = pp.Appendpp(p, wasm.AI64Const, obj.TYPE_CONST, 0, 0, 0, 0, 0)
-               p = pp.Appendpp(p, wasm.AI64Store, 0, 0, 0, obj.TYPE_CONST, 0, off+i)
+               p = pp.Append(p, wasm.AGet, obj.TYPE_REG, wasm.REG_SP, 0, 0, 0, 0)
+               p = pp.Append(p, wasm.AI64Const, obj.TYPE_CONST, 0, 0, 0, 0, 0)
+               p = pp.Append(p, wasm.AI64Store, 0, 0, 0, obj.TYPE_CONST, 0, off+i)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        return pp.Prog(wasm.ANop)
 }
 
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if next != b.Succs[0].Block() {
@@ -118,11 +121,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
        }
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.OpWasmLoweredStaticCall, ssa.OpWasmLoweredClosureCall, ssa.OpWasmLoweredInterCall:
                s.PrepareCall(v)
-               if call, ok := v.Aux.(*ssa.AuxCall); ok && call.Fn == gc.Deferreturn {
+               if call, ok := v.Aux.(*ssa.AuxCall); ok && call.Fn == ir.Syms.Deferreturn {
                        // add a resume point before call to deferreturn so it can be called again via jmpdefer
                        s.Prog(wasm.ARESUMEPOINT)
                }
@@ -147,26 +150,26 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                getValue32(s, v.Args[1])
                i32Const(s, int32(v.AuxInt))
                p := s.Prog(wasm.ACall)
-               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmMove}
+               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmMove}
 
        case ssa.OpWasmLoweredZero:
                getValue32(s, v.Args[0])
                i32Const(s, int32(v.AuxInt))
                p := s.Prog(wasm.ACall)
-               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmZero}
+               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmZero}
 
        case ssa.OpWasmLoweredNilCheck:
                getValue64(s, v.Args[0])
                s.Prog(wasm.AI64Eqz)
                s.Prog(wasm.AIf)
                p := s.Prog(wasm.ACALLNORESUME)
-               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.SigPanic}
+               p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.SigPanic}
                s.Prog(wasm.AEnd)
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
 
        case ssa.OpWasmLoweredWB:
@@ -185,7 +188,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                getReg(s, wasm.REG_SP)
                getValue64(s, v.Args[0])
                p := s.Prog(storeOp(v.Type))
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
 
        default:
                if v.Type.IsMemory() {
@@ -205,7 +208,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        }
 }
 
-func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
+func ssaGenValueOnStack(s *ssagen.State, v *ssa.Value, extend bool) {
        switch v.Op {
        case ssa.OpWasmLoweredGetClosurePtr:
                getReg(s, wasm.REG_CTXT)
@@ -240,10 +243,10 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
                p.From.Type = obj.TYPE_ADDR
                switch v.Aux.(type) {
                case *obj.LSym:
-                       gc.AddAux(&p.From, v)
-               case *gc.Node:
+                       ssagen.AddAux(&p.From, v)
+               case *ir.Name:
                        p.From.Reg = v.Args[0].Reg()
-                       gc.AddAux(&p.From, v)
+                       ssagen.AddAux(&p.From, v)
                default:
                        panic("wasm: bad LoweredAddr")
                }
@@ -312,7 +315,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
                if v.Type.Size() == 8 {
                        // Division of int64 needs helper function wasmDiv to handle the MinInt64 / -1 case.
                        p := s.Prog(wasm.ACall)
-                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmDiv}
+                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmDiv}
                        break
                }
                s.Prog(wasm.AI64DivS)
@@ -326,7 +329,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
                                s.Prog(wasm.AF64PromoteF32)
                        }
                        p := s.Prog(wasm.ACall)
-                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncS}
+                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmTruncS}
                }
 
        case ssa.OpWasmI64TruncSatF32U, ssa.OpWasmI64TruncSatF64U:
@@ -338,7 +341,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
                                s.Prog(wasm.AF64PromoteF32)
                        }
                        p := s.Prog(wasm.ACall)
-                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncU}
+                       p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmTruncU}
                }
 
        case ssa.OpWasmF32DemoteF64:
@@ -360,7 +363,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 
        case ssa.OpLoadReg:
                p := s.Prog(loadOp(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
 
        case ssa.OpCopy:
                getValue64(s, v.Args[0])
@@ -382,7 +385,7 @@ func isCmp(v *ssa.Value) bool {
        }
 }
 
-func getValue32(s *gc.SSAGenState, v *ssa.Value) {
+func getValue32(s *ssagen.State, v *ssa.Value) {
        if v.OnWasmStack {
                s.OnWasmStackSkipped--
                ssaGenValueOnStack(s, v, false)
@@ -399,7 +402,7 @@ func getValue32(s *gc.SSAGenState, v *ssa.Value) {
        }
 }
 
-func getValue64(s *gc.SSAGenState, v *ssa.Value) {
+func getValue64(s *ssagen.State, v *ssa.Value) {
        if v.OnWasmStack {
                s.OnWasmStackSkipped--
                ssaGenValueOnStack(s, v, true)
@@ -413,32 +416,32 @@ func getValue64(s *gc.SSAGenState, v *ssa.Value) {
        }
 }
 
-func i32Const(s *gc.SSAGenState, val int32) {
+func i32Const(s *ssagen.State, val int32) {
        p := s.Prog(wasm.AI32Const)
        p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: int64(val)}
 }
 
-func i64Const(s *gc.SSAGenState, val int64) {
+func i64Const(s *ssagen.State, val int64) {
        p := s.Prog(wasm.AI64Const)
        p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: val}
 }
 
-func f32Const(s *gc.SSAGenState, val float64) {
+func f32Const(s *ssagen.State, val float64) {
        p := s.Prog(wasm.AF32Const)
        p.From = obj.Addr{Type: obj.TYPE_FCONST, Val: val}
 }
 
-func f64Const(s *gc.SSAGenState, val float64) {
+func f64Const(s *ssagen.State, val float64) {
        p := s.Prog(wasm.AF64Const)
        p.From = obj.Addr{Type: obj.TYPE_FCONST, Val: val}
 }
 
-func getReg(s *gc.SSAGenState, reg int16) {
+func getReg(s *ssagen.State, reg int16) {
        p := s.Prog(wasm.AGet)
        p.From = obj.Addr{Type: obj.TYPE_REG, Reg: reg}
 }
 
-func setReg(s *gc.SSAGenState, reg int16) {
+func setReg(s *ssagen.State, reg int16) {
        p := s.Prog(wasm.ASet)
        p.To = obj.Addr{Type: obj.TYPE_REG, Reg: reg}
 }

diff --git a/src/cmd/compile/internal/x86/galign.go b/src/cmd/compile/internal/x86/galign.go
index e137daa3fc590c3c749723d50dff357982a66cc5..fc806f91196df0da5f1fb3b93aa2b85d5e0be63e 100644 (file)
--- a/src/cmd/compile/internal/x86/galign.go
+++ b/src/cmd/compile/internal/x86/galign.go
@@ -5,14 +5,15 @@
 package x86
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ssagen"
        "cmd/internal/obj/x86"
        "cmd/internal/objabi"
        "fmt"
        "os"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
        arch.LinkArch = &x86.Link386
        arch.REGSP = x86.REGSP
        arch.SSAGenValue = ssaGenValue
@@ -24,10 +25,10 @@ func Init(arch *gc.Arch) {
                arch.SoftFloat = true
        case "387":
                fmt.Fprintf(os.Stderr, "unsupported setting GO386=387. Consider using GO386=softfloat instead.\n")
-               gc.Exit(1)
+               base.Exit(1)
        default:
                fmt.Fprintf(os.Stderr, "unsupported setting GO386=%s\n", v)
-               gc.Exit(1)
+               base.Exit(1)
 
        }
 

diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index a33ddc81e3dc00b5809405720db80409c1f7966b..3ca479763e63a21fb4ca852d1ac211cd41a34c67 100644 (file)
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -5,39 +5,41 @@
 package x86
 
 import (
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/ir"
+       "cmd/compile/internal/objw"
+       "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/x86"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog {
        if cnt == 0 {
                return p
        }
        if *ax == 0 {
-               p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+               p = pp.Append(p, x86.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
                *ax = 1
        }
 
-       if cnt <= int64(4*gc.Widthreg) {
-               for i := int64(0); i < cnt; i += int64(gc.Widthreg) {
-                       p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off+i)
+       if cnt <= int64(4*types.RegSize) {
+               for i := int64(0); i < cnt; i += int64(types.RegSize) {
+                       p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off+i)
                }
-       } else if cnt <= int64(128*gc.Widthreg) {
-               p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-               p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
-               p.To.Sym = gc.Duffzero
+       } else if cnt <= int64(128*types.RegSize) {
+               p = pp.Append(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+               p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(types.RegSize)))
+               p.To.Sym = ir.Syms.Duffzero
        } else {
-               p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
-               p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-               p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
-               p = pp.Appendpp(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
+               p = pp.Append(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+               p = pp.Append(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+               p = pp.Append(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
        }
 
        return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
        // See comment in ../amd64/ggen.go.
        p := pp.Prog(x86.AXCHGL)
        p.From.Type = obj.TYPE_REG

diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index fbf76d0c5efb979e37dab6666008708b26a36fcb..00dfa07bf78be1d72bb2858faa8bf7e4997c1ecf 100644 (file)
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -8,16 +8,18 @@ import (
        "fmt"
        "math"
 
-       "cmd/compile/internal/gc"
+       "cmd/compile/internal/base"
+       "cmd/compile/internal/ir"
        "cmd/compile/internal/logopt"
        "cmd/compile/internal/ssa"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/obj/x86"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
        flive := b.FlagsLiveAtEnd
        for _, c := range b.ControlValues() {
                flive = c.Type.IsFlags() || flive
@@ -107,7 +109,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
        p := s.Prog(op)
        p.From.Type = obj.TYPE_REG
        p.To.Type = obj.TYPE_REG
@@ -116,7 +118,7 @@ func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
        return p
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
        switch v.Op {
        case ssa.Op386ADDL:
                r := v.Reg()
@@ -404,14 +406,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = r
                p.From.Index = i
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.Op386LEAL:
                p := s.Prog(x86.ALEAL)
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.Op386CMPL, ssa.Op386CMPW, ssa.Op386CMPB,
@@ -437,7 +439,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Args[1].Reg()
        case ssa.Op386CMPLconstload, ssa.Op386CMPWconstload, ssa.Op386CMPBconstload:
@@ -445,7 +447,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.From, v, sc.Off())
+               ssagen.AddAux2(&p.From, v, sc.Off())
                p.To.Type = obj.TYPE_CONST
                p.To.Offset = sc.Val()
        case ssa.Op386MOVLconst:
@@ -480,9 +482,9 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Name = obj.NAME_EXTERN
                f := math.Float64frombits(uint64(v.AuxInt))
                if v.Op == ssa.Op386MOVSDconst1 {
-                       p.From.Sym = gc.Ctxt.Float64Sym(f)
+                       p.From.Sym = base.Ctxt.Float64Sym(f)
                } else {
-                       p.From.Sym = gc.Ctxt.Float32Sym(float32(f))
+                       p.From.Sym = base.Ctxt.Float32Sym(float32(f))
                }
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -497,7 +499,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.Op386MOVBloadidx1, ssa.Op386MOVWloadidx1, ssa.Op386MOVLloadidx1, ssa.Op386MOVSSloadidx1, ssa.Op386MOVSDloadidx1,
@@ -521,7 +523,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                p.From.Reg = r
                p.From.Index = i
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.Op386ADDLloadidx4, ssa.Op386SUBLloadidx4, ssa.Op386MULLloadidx4,
@@ -531,7 +533,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.From.Index = v.Args[2].Reg()
                p.From.Scale = 4
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
                if v.Reg() != v.Args[0].Reg() {
@@ -544,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_MEM
                p.From.Reg = v.Args[1].Reg()
-               gc.AddAux(&p.From, v)
+               ssagen.AddAux(&p.From, v)
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
                if v.Reg() != v.Args[0].Reg() {
@@ -557,7 +559,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = v.Args[1].Reg()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.Op386ADDLconstmodify:
                sc := v.AuxValAndOff()
                val := sc.Val()
@@ -571,7 +573,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        off := sc.Off()
                        p.To.Type = obj.TYPE_MEM
                        p.To.Reg = v.Args[0].Reg()
-                       gc.AddAux2(&p.To, v, off)
+                       ssagen.AddAux2(&p.To, v, off)
                        break
                }
                fallthrough
@@ -584,7 +586,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = val
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, off)
+               ssagen.AddAux2(&p.To, v, off)
        case ssa.Op386MOVBstoreidx1, ssa.Op386MOVWstoreidx1, ssa.Op386MOVLstoreidx1, ssa.Op386MOVSSstoreidx1, ssa.Op386MOVSDstoreidx1,
                ssa.Op386MOVSDstoreidx8, ssa.Op386MOVSSstoreidx4, ssa.Op386MOVLstoreidx4, ssa.Op386MOVWstoreidx2,
                ssa.Op386ADDLmodifyidx4, ssa.Op386SUBLmodifyidx4, ssa.Op386ANDLmodifyidx4, ssa.Op386ORLmodifyidx4, ssa.Op386XORLmodifyidx4:
@@ -610,7 +612,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                p.To.Reg = r
                p.To.Index = i
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        case ssa.Op386MOVLstoreconst, ssa.Op386MOVWstoreconst, ssa.Op386MOVBstoreconst:
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_CONST
@@ -618,7 +620,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = sc.Val()
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
        case ssa.Op386ADDLconstmodifyidx4:
                sc := v.AuxValAndOff()
                val := sc.Val()
@@ -634,7 +636,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        p.To.Reg = v.Args[0].Reg()
                        p.To.Scale = 4
                        p.To.Index = v.Args[1].Reg()
-                       gc.AddAux2(&p.To, v, off)
+                       ssagen.AddAux2(&p.To, v, off)
                        break
                }
                fallthrough
@@ -661,7 +663,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = r
                p.To.Index = i
-               gc.AddAux2(&p.To, v, sc.Off())
+               ssagen.AddAux2(&p.To, v, sc.Off())
        case ssa.Op386MOVWLSX, ssa.Op386MOVBLSX, ssa.Op386MOVWLZX, ssa.Op386MOVBLZX,
                ssa.Op386CVTSL2SS, ssa.Op386CVTSL2SD,
                ssa.Op386CVTTSS2SL, ssa.Op386CVTTSD2SL,
@@ -670,12 +672,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.Op386DUFFZERO:
                p := s.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Duffzero
+               p.To.Sym = ir.Syms.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.Op386DUFFCOPY:
                p := s.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Duffcopy
+               p.To.Sym = ir.Syms.Duffcopy
                p.To.Offset = v.AuxInt
 
        case ssa.OpCopy: // TODO: use MOVLreg for reg->reg copies instead of OpCopy?
@@ -693,7 +695,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                        return
                }
                p := s.Prog(loadByType(v.Type))
-               gc.AddrAuto(&p.From, v.Args[0])
+               ssagen.AddrAuto(&p.From, v.Args[0])
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
 
@@ -705,15 +707,15 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(storeByType(v.Type))
                p.From.Type = obj.TYPE_REG
                p.From.Reg = v.Args[0].Reg()
-               gc.AddrAuto(&p.To, v)
+               ssagen.AddrAuto(&p.To, v)
        case ssa.Op386LoweredGetClosurePtr:
                // Closure pointer is DX.
-               gc.CheckLoweredGetClosurePtr(v)
+               ssagen.CheckLoweredGetClosurePtr(v)
        case ssa.Op386LoweredGetG:
                r := v.Reg()
                // See the comments in cmd/internal/obj/x86/obj6.go
                // near CanUse1InsnTLS for a detailed explanation of these instructions.
-               if x86.CanUse1InsnTLS(gc.Ctxt) {
+               if x86.CanUse1InsnTLS(base.Ctxt) {
                        // MOVL (TLS), r
                        p := s.Prog(x86.AMOVL)
                        p.From.Type = obj.TYPE_MEM
@@ -749,7 +751,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                // caller's SP is the address of the first arg
                p := s.Prog(x86.AMOVL)
                p.From.Type = obj.TYPE_ADDR
-               p.From.Offset = -gc.Ctxt.FixedFrameSize() // 0 on 386, just to be consistent with other architectures
+               p.From.Offset = -base.Ctxt.FixedFrameSize() // 0 on 386, just to be consistent with other architectures
                p.From.Name = obj.NAME_PARAM
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
@@ -764,14 +766,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
                s.UseArgs(8) // space used in callee args area by assembly stubs
 
        case ssa.Op386LoweredPanicExtendA, ssa.Op386LoweredPanicExtendB, ssa.Op386LoweredPanicExtendC:
                p := s.Prog(obj.ACALL)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+               p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
                s.UseArgs(12) // space used in callee args area by assembly stubs
 
        case ssa.Op386CALLstatic, ssa.Op386CALLclosure, ssa.Op386CALLinter:
@@ -846,12 +848,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Reg = x86.REG_AX
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = v.Args[0].Reg()
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
                if logopt.Enabled() {
                        logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
                }
-               if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-                       gc.Warnl(v.Pos, "generated nil check")
+               if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+                       base.WarnfAt(v.Pos, "generated nil check")
                }
        case ssa.OpClobber:
                p := s.Prog(x86.AMOVL)
@@ -859,7 +861,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.From.Offset = 0xdeaddead
                p.To.Type = obj.TYPE_MEM
                p.To.Reg = x86.REG_SP
-               gc.AddAux(&p.To, v)
+               ssagen.AddAux(&p.To, v)
        default:
                v.Fatalf("genValue not implemented: %s", v.LongString())
        }
@@ -884,22 +886,22 @@ var blockJump = [...]struct {
        ssa.Block386NAN: {x86.AJPS, x86.AJPC},
 }
 
-var eqfJumps = [2][2]gc.IndexJump{
+var eqfJumps = [2][2]ssagen.IndexJump{
        {{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPS, Index: 1}}, // next == b.Succs[0]
        {{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPC, Index: 0}}, // next == b.Succs[1]
 }
-var nefJumps = [2][2]gc.IndexJump{
+var nefJumps = [2][2]ssagen.IndexJump{
        {{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPC, Index: 1}}, // next == b.Succs[0]
        {{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPS, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
        switch b.Kind {
        case ssa.BlockPlain:
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockDefer:
                // defer returns in rax:
@@ -912,11 +914,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
                p.To.Reg = x86.REG_AX
                p = s.Prog(x86.AJNE)
                p.To.Type = obj.TYPE_BRANCH
-               s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+               s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
                if b.Succs[0].Block() != next {
                        p := s.Prog(obj.AJMP)
                        p.To.Type = obj.TYPE_BRANCH
-                       s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+                       s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
                }
        case ssa.BlockExit:
        case ssa.BlockRet:

diff --git a/src/cmd/compile/main.go b/src/cmd/compile/main.go
index 3aa64a5ce251b6dd672864f91613f35f04011915..cb2f4e8cf475a74f263d07f2091e5c3ef184f0a9 100644 (file)
--- a/src/cmd/compile/main.go
+++ b/src/cmd/compile/main.go
@@ -8,12 +8,14 @@ import (
        "cmd/compile/internal/amd64"
        "cmd/compile/internal/arm"
        "cmd/compile/internal/arm64"
+       "cmd/compile/internal/base"
        "cmd/compile/internal/gc"
        "cmd/compile/internal/mips"
        "cmd/compile/internal/mips64"
        "cmd/compile/internal/ppc64"
        "cmd/compile/internal/riscv64"
        "cmd/compile/internal/s390x"
+       "cmd/compile/internal/ssagen"
        "cmd/compile/internal/wasm"
        "cmd/compile/internal/x86"
        "cmd/internal/objabi"
@@ -22,7 +24,7 @@ import (
        "os"
 )
 
-var archInits = map[string]func(*gc.Arch){
+var archInits = map[string]func(*ssagen.ArchInfo){
        "386":      x86.Init,
        "amd64":    amd64.Init,
        "arm":      arm.Init,
@@ -50,5 +52,5 @@ func main() {
        }
 
        gc.Main(archInit)
-       gc.Exit(0)
+       base.Exit(0)
 }

diff --git a/src/cmd/cover/func.go b/src/cmd/cover/func.go
index 988c4caebffe13dc11e6bffb304016abc5673723..ce7c771ac961971af670b00c1c79ea1c8b22153c 100644 (file)
--- a/src/cmd/cover/func.go
+++ b/src/cmd/cover/func.go
@@ -15,9 +15,9 @@ import (
        "go/ast"
        "go/parser"
        "go/token"
+       exec "internal/execabs"
        "io"
        "os"
-       "os/exec"
        "path"
        "path/filepath"
        "runtime"

diff --git a/src/cmd/cover/testdata/toolexec.go b/src/cmd/cover/testdata/toolexec.go
index 1769efedbeb678674045a9d6b9bbc08fb4e5ed30..386de79038a355c2de01fead816a1410479490f8 100644 (file)
--- a/src/cmd/cover/testdata/toolexec.go
+++ b/src/cmd/cover/testdata/toolexec.go
@@ -16,7 +16,7 @@ package main
 
 import (
        "os"
-       "os/exec"
+       exec "internal/execabs"
        "strings"
 )
 

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index c8c3212d1661f8eb835c20493bba15c35d84fdd4..c02b92818c2dae09f8fec90a344528ff15bd74f5 100644 (file)
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1575,6 +1575,7 @@ var cgoEnabled = map[string]bool{
        "windows/386":     true,
        "windows/amd64":   true,
        "windows/arm":     false,
+       "windows/arm64":   false,
 }
 
 // List of platforms which are supported but not complete yet. These get
@@ -1765,6 +1766,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
                rval = true
        case "syscall":
                rval = true
+       case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
+               rval = true
        default:
                rval = strings.HasPrefix(pkgpath, "runtime/internal")
        }

diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index e7bedfb84eec506061b2c3a7ba3733b8ac9fbe63..7520b0ef1864847d08286d6f8e0380c7129754f3 100644 (file)
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -23,80 +23,41 @@ import (
 // compiled with a Go 1.4 toolchain to produce the bootstrapTargets.
 // All directories in this list are relative to and must be below $GOROOT/src.
 //
-// The list has have two kinds of entries: names beginning with cmd/ with
+// The list has two kinds of entries: names beginning with cmd/ with
 // no other slashes, which are commands, and other paths, which are packages
 // supporting the commands. Packages in the standard library can be listed
 // if a newer copy needs to be substituted for the Go 1.4 copy when used
-// by the command packages.
+// by the command packages. Paths ending with /... automatically
+// include all packages within subdirectories as well.
 // These will be imported during bootstrap as bootstrap/name, like bootstrap/math/big.
 var bootstrapDirs = []string{
        "cmd/asm",
-       "cmd/asm/internal/arch",
-       "cmd/asm/internal/asm",
-       "cmd/asm/internal/flags",
-       "cmd/asm/internal/lex",
+       "cmd/asm/internal/...",
        "cmd/cgo",
        "cmd/compile",
-       "cmd/compile/internal/amd64",
-       "cmd/compile/internal/arm",
-       "cmd/compile/internal/arm64",
-       "cmd/compile/internal/gc",
-       "cmd/compile/internal/logopt",
-       "cmd/compile/internal/mips",
-       "cmd/compile/internal/mips64",
-       "cmd/compile/internal/ppc64",
-       "cmd/compile/internal/riscv64",
-       "cmd/compile/internal/s390x",
-       "cmd/compile/internal/ssa",
-       "cmd/compile/internal/syntax",
-       "cmd/compile/internal/types",
-       "cmd/compile/internal/x86",
-       "cmd/compile/internal/wasm",
+       "cmd/compile/internal/...",
+       "cmd/internal/archive",
        "cmd/internal/bio",
        "cmd/internal/codesign",
-       "cmd/internal/gcprog",
        "cmd/internal/dwarf",
        "cmd/internal/edit",
+       "cmd/internal/gcprog",
        "cmd/internal/goobj",
+       "cmd/internal/obj/...",
        "cmd/internal/objabi",
-       "cmd/internal/obj",
-       "cmd/internal/obj/arm",
-       "cmd/internal/obj/arm64",
-       "cmd/internal/obj/mips",
-       "cmd/internal/obj/ppc64",
-       "cmd/internal/obj/riscv",
-       "cmd/internal/obj/s390x",
-       "cmd/internal/obj/x86",
-       "cmd/internal/obj/wasm",
        "cmd/internal/pkgpath",
        "cmd/internal/src",
        "cmd/internal/sys",
        "cmd/link",
-       "cmd/link/internal/amd64",
-       "cmd/link/internal/arm",
-       "cmd/link/internal/arm64",
-       "cmd/link/internal/benchmark",
-       "cmd/link/internal/ld",
-       "cmd/link/internal/loadelf",
-       "cmd/link/internal/loader",
-       "cmd/link/internal/loadmacho",
-       "cmd/link/internal/loadpe",
-       "cmd/link/internal/loadxcoff",
-       "cmd/link/internal/mips",
-       "cmd/link/internal/mips64",
-       "cmd/link/internal/ppc64",
-       "cmd/link/internal/riscv64",
-       "cmd/link/internal/s390x",
-       "cmd/link/internal/sym",
-       "cmd/link/internal/x86",
+       "cmd/link/internal/...",
        "compress/flate",
        "compress/zlib",
-       "cmd/link/internal/wasm",
        "container/heap",
        "debug/dwarf",
        "debug/elf",
        "debug/macho",
        "debug/pe",
+       "go/constant",
        "internal/goversion",
        "internal/race",
        "internal/unsafeheader",
@@ -104,6 +65,7 @@ var bootstrapDirs = []string{
        "math/big",
        "math/bits",
        "sort",
+       "strconv",
 }
 
 // File prefixes that are ignored by go/build anyway, and cause
@@ -111,6 +73,7 @@ var bootstrapDirs = []string{
 var ignorePrefixes = []string{
        ".",
        "_",
+       "#",
 }
 
 // File suffixes that use build tags introduced since Go 1.4.
@@ -124,6 +87,7 @@ var ignoreSuffixes = []string{
        "_wasm.s",
        "_wasm.go",
        "_test.s",
+       "_test.go",
 }
 
 func bootstrapBuildTools() {
@@ -149,31 +113,47 @@ func bootstrapBuildTools() {
        // Copy source code into $GOROOT/pkg/bootstrap and rewrite import paths.
        writefile("module bootstrap\n", pathf("%s/%s", base, "go.mod"), 0)
        for _, dir := range bootstrapDirs {
-               src := pathf("%s/src/%s", goroot, dir)
-               dst := pathf("%s/%s", base, dir)
-               xmkdirall(dst)
-               if dir == "cmd/cgo" {
-                       // Write to src because we need the file both for bootstrap
-                       // and for later in the main build.
-                       mkzdefaultcc("", pathf("%s/zdefaultcc.go", src))
-               }
-       Dir:
-               for _, name := range xreaddirfiles(src) {
+               recurse := strings.HasSuffix(dir, "/...")
+               dir = strings.TrimSuffix(dir, "/...")
+               filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+                       if err != nil {
+                               fatalf("walking bootstrap dirs failed: %v: %v", path, err)
+                       }
+
+                       name := filepath.Base(path)
+                       src := pathf("%s/src/%s", goroot, path)
+                       dst := pathf("%s/%s", base, path)
+
+                       if info.IsDir() {
+                               if !recurse && path != dir || name == "testdata" {
+                                       return filepath.SkipDir
+                               }
+
+                               xmkdirall(dst)
+                               if path == "cmd/cgo" {
+                                       // Write to src because we need the file both for bootstrap
+                                       // and for later in the main build.
+                                       mkzdefaultcc("", pathf("%s/zdefaultcc.go", src))
+                                       mkzdefaultcc("", pathf("%s/zdefaultcc.go", dst))
+                               }
+                               return nil
+                       }
+
                        for _, pre := range ignorePrefixes {
                                if strings.HasPrefix(name, pre) {
-                                       continue Dir
+                                       return nil
                                }
                        }
                        for _, suf := range ignoreSuffixes {
                                if strings.HasSuffix(name, suf) {
-                                       continue Dir
+                                       return nil
                                }
                        }
-                       srcFile := pathf("%s/%s", src, name)
-                       dstFile := pathf("%s/%s", dst, name)
-                       text := bootstrapRewriteFile(srcFile)
-                       writefile(text, dstFile, 0)
-               }
+
+                       text := bootstrapRewriteFile(src)
+                       writefile(text, dst, 0)
+                       return nil
+               })
        }
 
        // Set up environment for invoking Go 1.4 go command.
@@ -305,8 +285,10 @@ func bootstrapFixImports(srcFile string) string {
                        continue
                }
                if strings.HasPrefix(line, `import "`) || strings.HasPrefix(line, `import . "`) ||
-                       inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"")) {
+                       inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"") || strings.HasPrefix(line, "\texec \"")) {
                        line = strings.Replace(line, `"cmd/`, `"bootstrap/cmd/`, -1)
+                       // During bootstrap, must use plain os/exec.
+                       line = strings.Replace(line, `exec "internal/execabs"`, `"os/exec"`, -1)
                        for _, dir := range bootstrapDirs {
                                if strings.HasPrefix(dir, "cmd/") {
                                        continue

diff --git a/src/cmd/dist/sys_windows.go b/src/cmd/dist/sys_windows.go
index 2f6a1b0dceb6fe29b5f5280173ec7f53037652d7..265f729d0fc345611f27e25037a955f9bc1fca17 100644 (file)
--- a/src/cmd/dist/sys_windows.go
+++ b/src/cmd/dist/sys_windows.go
@@ -29,10 +29,13 @@ type systeminfo struct {
        wProcessorRevision          uint16
 }
 
+// See https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info
 const (
        PROCESSOR_ARCHITECTURE_AMD64 = 9
        PROCESSOR_ARCHITECTURE_INTEL = 0
        PROCESSOR_ARCHITECTURE_ARM   = 5
+       PROCESSOR_ARCHITECTURE_ARM64 = 12
+       PROCESSOR_ARCHITECTURE_IA64  = 6
 )
 
 var sysinfo systeminfo
@@ -46,6 +49,8 @@ func sysinit() {
                gohostarch = "386"
        case PROCESSOR_ARCHITECTURE_ARM:
                gohostarch = "arm"
+       case PROCESSOR_ARCHITECTURE_ARM64:
+               gohostarch = "arm64"
        default:
                fatalf("unknown processor architecture")
        }

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 955ce2a063c83330efb7b8e2aef01c94f62d31b9..4f081c9f888987ca37e32ac1af5d46ef28533bf3 100644 (file)
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -727,14 +727,6 @@ func (t *tester) registerTests() {
                }
        }
 
-       // Doc tests only run on builders.
-       // They find problems approximately never.
-       if goos != "js" && goos != "android" && !t.iOS() && os.Getenv("GO_BUILDER_NAME") != "" {
-               t.registerTest("doc_progs", "../doc/progs", "go", "run", "run.go")
-               t.registerTest("wiki", "../doc/articles/wiki", t.goTest(), ".")
-               t.registerTest("codewalk", "../doc/codewalk", t.goTest(), "codewalk_test.go")
-       }
-
        if goos != "android" && !t.iOS() {
                // There are no tests in this directory, only benchmarks.
                // Check that the test binary builds but don't bother running it.

diff --git a/src/cmd/dist/util.go b/src/cmd/dist/util.go
index 0a419e465fe87a7f3b088611aa56c8d7c50e5d5d..e99375f5380d8dc32052872110135cd8147e7ca4 100644 (file)
--- a/src/cmd/dist/util.go
+++ b/src/cmd/dist/util.go
@@ -389,6 +389,10 @@ func xgetgoarm() string {
                // sense to auto-detect the setting.
                return "7"
        }
+       if goos == "windows" {
+               // windows/arm only works with ARMv7 executables.
+               return "7"
+       }
        if gohostarch != "arm" || goos != gohostos {
                // Conservative default for cross-compilation.
                return "5"

diff --git a/src/cmd/doc/dirs.go b/src/cmd/doc/dirs.go
index 38cbe7fa021973943c459461684f14b58220b7be..661624cfe4c168c793d582203de163f3169634e6 100644 (file)
--- a/src/cmd/doc/dirs.go
+++ b/src/cmd/doc/dirs.go
@@ -7,9 +7,9 @@ package main
 import (
        "bytes"
        "fmt"
+       exec "internal/execabs"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "strings"

diff --git a/src/cmd/fix/typecheck.go b/src/cmd/fix/typecheck.go
index 40b2287f26e9c9ce9dda9adae2afd8ed7a3293cf..39a53785b724d4105ccfd6d7bdd320a7f3428005 100644 (file)
--- a/src/cmd/fix/typecheck.go
+++ b/src/cmd/fix/typecheck.go
@@ -9,8 +9,8 @@ import (
        "go/ast"
        "go/parser"
        "go/token"
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "path/filepath"
        "reflect"
        "runtime"

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 031b8d4ab75b1c62687a0ebdd9b87a92be227cab..5414e5e688866576ef68b200649d127ac5e27c37 100644 (file)
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
        github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
        golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
        golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-       golang.org/x/mod v0.4.0
-       golang.org/x/sys v0.0.0-20201204225414-ed752295db88 // indirect
-       golang.org/x/tools v0.0.0-20201211025543-abf6a1d87e11
+       golang.org/x/mod v0.4.1
+       golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
+       golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff
 )

diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 2fde9445f6507f7063329bc02557776803fdb5e3..3dc0565f655f158f5a25441cd37594c7dc0e5a55 100644 (file)
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.0 h1:8pl+sMODzuvGJkmj2W4kZihvVb5mKm8pB/X44PIQHv8=
-golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.1 h1:Kvvh58BN8Y9/lBi7hTekvtMpm07eUZ0ck5pRHpsMWrY=
+golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
@@ -25,14 +25,14 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201211025543-abf6a1d87e11 h1:9j/upNXDRpADUw2RpUfJ7E7GHtfhDih62kX6JM8vs2c=
-golang.org/x/tools v0.0.0-20201211025543-abf6a1d87e11/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff h1:6EkB024TP1fu6cmQqeCNw685zYDVt5g8N1BXh755SQM=
+golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index da5909a04b24c9b2388f9ca16d5ce18496d13f55..26bc5e785b3d42da2aded81030c930579ced14e3 100644 (file)
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -111,7 +111,7 @@
 //     -p n
 //             the number of programs, such as build commands or
 //             test binaries, that can be run in parallel.
-//             The default is the number of CPUs available.
+//             The default is GOMAXPROCS, normally the number of CPUs available.
 //     -race
 //             enable data race detection.
 //             Supported only on linux/amd64, freebsd/amd64, darwin/amd64, windows/amd64,
@@ -153,7 +153,10 @@
 //             created with -buildmode=shared.
 //     -mod mode
 //             module download mode to use: readonly, vendor, or mod.
-//             See 'go help modules' for more.
+//             By default, if a vendor directory is present and the go version in go.mod
+//             is 1.14 or higher, the go command acts as if -mod=vendor were set.
+//             Otherwise, the go command acts as if -mod=readonly were set.
+//             See https://golang.org/ref/mod#build-commands for details.
 //     -modcacherw
 //             leave newly-created directories in the module cache read-write
 //             instead of making them read-only.
@@ -494,15 +497,6 @@
 // (gofmt), a fully qualified path (/usr/you/bin/mytool), or a
 // command alias, described below.
 //
-// To convey to humans and machine tools that code is generated,
-// generated source should have a line that matches the following
-// regular expression (in Go syntax):
-//
-//     ^// Code generated .* DO NOT EDIT\.$
-//
-// The line may appear anywhere in the file, but is typically
-// placed near the beginning so it is easy to find.
-//
 // Note that go generate does not parse the file, so lines that look
 // like directives in comments or multiline strings will be treated
 // as directives.
@@ -514,6 +508,15 @@
 // Quoted strings use Go syntax and are evaluated before execution; a
 // quoted string appears as a single argument to the generator.
 //
+// To convey to humans and machine tools that code is generated,
+// generated source should have a line that matches the following
+// regular expression (in Go syntax):
+//
+//     ^// Code generated .* DO NOT EDIT\.$
+//
+// This line must appear before the first non-comment, non-blank
+// text in the file.
+//
 // Go generate sets several variables when it runs the generator:
 //
 //     $GOARCH
@@ -597,85 +600,49 @@
 //
 //     go get [-d] [-t] [-u] [-v] [-insecure] [build flags] [packages]
 //
-// Get resolves and adds dependencies to the current development module
-// and then builds and installs them.
-//
-// The first step is to resolve which dependencies to add.
-//
-// For each named package or package pattern, get must decide which version of
-// the corresponding module to use. By default, get looks up the latest tagged
-// release version, such as v0.4.5 or v1.2.3. If there are no tagged release
-// versions, get looks up the latest tagged pre-release version, such as
-// v0.0.1-pre1. If there are no tagged versions at all, get looks up the latest
-// known commit. If the module is not already required at a later version
-// (for example, a pre-release newer than the latest release), get will use
-// the version it looked up. Otherwise, get will use the currently
-// required version.
-//
-// This default version selection can be overridden by adding an @version
-// suffix to the package argument, as in 'go get golang.org/x/text@v0.3.0'.
-// The version may be a prefix: @v1 denotes the latest available version starting
-// with v1. See 'go help modules' under the heading 'Module queries' for the
-// full query syntax.
-//
-// For modules stored in source control repositories, the version suffix can
-// also be a commit hash, branch identifier, or other syntax known to the
-// source control system, as in 'go get golang.org/x/text@master'. Note that
-// branches with names that overlap with other module query syntax cannot be
-// selected explicitly. For example, the suffix @v2 means the latest version
-// starting with v2, not the branch named v2.
-//
-// If a module under consideration is already a dependency of the current
-// development module, then get will update the required version.
-// Specifying a version earlier than the current required version is valid and
-// downgrades the dependency. The version suffix @none indicates that the
-// dependency should be removed entirely, downgrading or removing modules
-// depending on it as needed.
-//
-// The version suffix @latest explicitly requests the latest minor release of
-// the module named by the given path. The suffix @upgrade is like @latest but
-// will not downgrade a module if it is already required at a revision or
-// pre-release version newer than the latest released version. The suffix
-// @patch requests the latest patch release: the latest released version
-// with the same major and minor version numbers as the currently required
-// version. Like @upgrade, @patch will not downgrade a module already required
-// at a newer version. If the path is not already required, @upgrade is
-// equivalent to @latest, and @patch is disallowed.
-//
-// Although get defaults to using the latest version of the module containing
-// a named package, it does not use the latest version of that module's
-// dependencies. Instead it prefers to use the specific dependency versions
-// requested by that module. For example, if the latest A requires module
-// B v1.2.3, while B v1.2.4 and v1.3.1 are also available, then 'go get A'
-// will use the latest A but then use B v1.2.3, as requested by A. (If there
-// are competing requirements for a particular module, then 'go get' resolves
-// those requirements by taking the maximum requested version.)
+// Get resolves its command-line arguments to packages at specific module versions,
+// updates go.mod to require those versions, downloads source code into the
+// module cache, then builds and installs the named packages.
+//
+// To add a dependency for a package or upgrade it to its latest version:
+//
+//     go get example.com/pkg
+//
+// To upgrade or downgrade a package to a specific version:
+//
+//     go get example.com/pkg@v1.2.3
+//
+// To remove a dependency on a module and downgrade modules that require it:
+//
+//     go get example.com/mod@none
+//
+// See https://golang.org/ref/mod#go-get for details.
+//
+// The 'go install' command may be used to build and install packages. When a
+// version is specified, 'go install' runs in module-aware mode and ignores
+// the go.mod file in the current directory. For example:
+//
+//     go install example.com/pkg@v1.2.3
+//     go install example.com/pkg@latest
+//
+// See 'go help install' or https://golang.org/ref/mod#go-install for details.
+//
+// In addition to build flags (listed in 'go help build') 'go get' accepts the
+// following flags.
 //
 // The -t flag instructs get to consider modules needed to build tests of
 // packages specified on the command line.
 //
 // The -u flag instructs get to update modules providing dependencies
 // of packages named on the command line to use newer minor or patch
-// releases when available. Continuing the previous example, 'go get -u A'
-// will use the latest A with B v1.3.1 (not B v1.2.3). If B requires module C,
-// but C does not provide any packages needed to build packages in A
-// (not including tests), then C will not be updated.
+// releases when available.
 //
 // The -u=patch flag (not -u patch) also instructs get to update dependencies,
 // but changes the default to select patch releases.
-// Continuing the previous example,
-// 'go get -u=patch A@latest' will use the latest A with B v1.2.4 (not B v1.2.3),
-// while 'go get -u=patch A' will use a patch release of A instead.
 //
 // When the -t and -u flags are used together, get will update
 // test dependencies as well.
 //
-// In general, adding a new dependency may require upgrading
-// existing dependencies to keep a working build, and 'go get' does
-// this automatically. Similarly, downgrading one dependency may
-// require downgrading other dependencies, and 'go get' does
-// this automatically as well.
-//
 // The -insecure flag permits fetching from repositories and resolving
 // custom domains using insecure schemes such as HTTP, and also bypassess
 // module sum validation using the checksum database. Use with caution.
@@ -684,12 +651,8 @@
 // variable instead. To bypass module sum validation, use GOPRIVATE or
 // GONOSUMDB. See 'go help environment' for details.
 //
-// The second step is to download (if needed), build, and install
-// the named packages.
-//
-// The -d flag instructs get to skip this step, downloading source code
-// needed to build the named packages and their dependencies, but not
-// building or installing.
+// The -d flag instructs get not to build or install packages. get will only
+// update go.mod and download source code needed to build packages.
 //
 // Building and installing packages with get is deprecated. In a future release,
 // the -d flag will be enabled by default, and 'go get' will be only be used to
@@ -698,31 +661,14 @@
 // ignoring the current module, use 'go install' with an @version suffix like
 // "@latest" after each argument.
 //
-// If an argument names a module but not a package (because there is no
-// Go source code in the module's root directory), then the install step
-// is skipped for that argument, instead of causing a build failure.
-// For example 'go get golang.org/x/perf' succeeds even though there
-// is no code corresponding to that import path.
-//
-// Note that package patterns are allowed and are expanded after resolving
-// the module versions. For example, 'go get golang.org/x/perf/cmd/...'
-// adds the latest golang.org/x/perf and then installs the commands in that
-// latest version.
-//
-// With no package arguments, 'go get' applies to Go package in the
-// current directory, if any. In particular, 'go get -u' and
-// 'go get -u=patch' update all the dependencies of that package.
-// With no package arguments and also without -u, 'go get' is not much more
-// than 'go install', and 'go get -d' not much more than 'go list'.
-//
-// For more about modules, see 'go help modules'.
+// For more about modules, see https://golang.org/ref/mod.
 //
 // For more about specifying packages, see 'go help packages'.
 //
 // This text describes the behavior of get using modules to manage source
 // code and dependencies. If instead the go command is running in GOPATH
 // mode, the details of get's flags and effects change, as does 'go help get'.
-// See 'go help modules' and 'go help gopath-get'.
+// See 'go help gopath-get'.
 //
 // See also: go build, go install, go clean, go mod.
 //
@@ -842,6 +788,14 @@
 //         TestGoFiles     []string   // _test.go files in package
 //         XTestGoFiles    []string   // _test.go files outside package
 //
+//         // Embedded files
+//         EmbedPatterns      []string // //go:embed patterns
+//         EmbedFiles         []string // files matched by EmbedPatterns
+//         TestEmbedPatterns  []string // //go:embed patterns in TestGoFiles
+//         TestEmbedFiles     []string // files matched by TestEmbedPatterns
+//         XTestEmbedPatterns []string // //go:embed patterns in XTestGoFiles
+//         XTestEmbedFiles    []string // files matched by XTestEmbedPatterns
+//
 //         // Cgo directives
 //         CgoCFLAGS    []string // cgo: flags for C compiler
 //         CgoCPPFLAGS  []string // cgo: flags for C preprocessor
@@ -1053,7 +1007,7 @@
 //
 // For more about specifying packages, see 'go help packages'.
 //
-// For more about modules, see 'go help modules'.
+// For more about modules, see https://golang.org/ref/mod.
 //
 //
 // Module maintenance
@@ -1118,7 +1072,9 @@
 //
 // The -x flag causes download to print the commands download executes.
 //
-// See 'go help modules' for more about module queries.
+// See https://golang.org/ref/mod#go-mod-download for more about 'go mod download'.
+//
+// See https://golang.org/ref/mod#version-queries for more about version queries.
 //
 //
 // Edit go.mod from tools or scripts
@@ -1194,6 +1150,7 @@
 //             Require []Require
 //             Exclude []Module
 //             Replace []Replace
+//             Retract []Retract
 //     }
 //
 //     type Require struct {
@@ -1220,9 +1177,7 @@
 // referred to indirectly. For the full set of modules available to a build,
 // use 'go list -m -json all'.
 //
-// For example, a tool can obtain the go.mod as a data structure by
-// parsing the output of 'go mod edit -json' and can then make changes
-// by invoking 'go mod edit' with -require, -exclude, and so on.
+// See https://golang.org/ref/mod#go-mod-edit for more about 'go mod edit'.
 //
 //
 // Print module requirement graph
@@ -1236,6 +1191,8 @@
 // and one of its requirements. Each module is identified as a string of the form
 // path@version, except for the main module, which has no @version suffix.
 //
+// See https://golang.org/ref/mod#go-mod-graph for more about 'go mod graph'.
+//
 //
 // Initialize new module in current directory
 //
@@ -1255,6 +1212,8 @@
 // If a configuration file for a vendoring tool is present, init will attempt to
 // import module requirements from it.
 //
+// See https://golang.org/ref/mod#go-mod-init for more about 'go mod init'.
+//
 //
 // Add missing and remove unused modules
 //
@@ -1274,6 +1233,8 @@
 // The -e flag causes tidy to attempt to proceed despite errors
 // encountered while loading packages.
 //
+// See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
+//
 //
 // Make vendored copy of dependencies
 //
@@ -1291,6 +1252,8 @@
 // The -e flag causes vendor to attempt to proceed despite errors
 // encountered while loading packages.
 //
+// See https://golang.org/ref/mod#go-mod-vendor for more about 'go mod vendor'.
+//
 //
 // Verify dependencies have expected content
 //
@@ -1305,6 +1268,8 @@
 // modules have been changed and causes 'go mod' to exit with a
 // non-zero status.
 //
+// See https://golang.org/ref/mod#go-mod-verify for more about 'go mod verify'.
+//
 //
 // Explain why packages or modules are needed
 //
@@ -1341,6 +1306,8 @@
 //     (main module does not need package golang.org/x/text/encoding)
 //     $
 //
+// See https://golang.org/ref/mod#go-mod-why for more about 'go mod why'.
+//
 //
 // Compile and run Go program
 //
@@ -1785,6 +1752,10 @@
 //
 // General-purpose environment variables:
 //
+//     GO111MODULE
+//             Controls whether the go command runs in module-aware mode or GOPATH mode.
+//             May be "off", "on", or "auto".
+//             See https://golang.org/ref/mod#mod-commands.
 //     GCCGO
 //             The gccgo command to run for 'go build -compiler=gccgo'.
 //     GOARCH
@@ -1823,20 +1794,24 @@
 //     GOPATH
 //             For more details see: 'go help gopath'.
 //     GOPROXY
-//             URL of Go module proxy. See 'go help modules'.
+//             URL of Go module proxy. See https://golang.org/ref/mod#environment-variables
+//             and https://golang.org/ref/mod#module-proxy for details.
 //     GOPRIVATE, GONOPROXY, GONOSUMDB
 //             Comma-separated list of glob patterns (in the syntax of Go's path.Match)
 //             of module path prefixes that should always be fetched directly
 //             or that should not be compared against the checksum database.
-//             See 'go help private'.
+//             See https://golang.org/ref/mod#private-modules.
 //     GOROOT
 //             The root of the go tree.
 //     GOSUMDB
 //             The name of checksum database to use and optionally its public key and
-//             URL. See 'go help module-auth'.
+//             URL. See https://golang.org/ref/mod#authenticating.
 //     GOTMPDIR
 //             The directory where the go command will write
 //             temporary source files, packages, and binaries.
+//     GOVCS
+//             Lists version control commands that may be used with matching servers.
+//             See 'go help vcs'.
 //
 // Environment variables for use with cgo:
 //
@@ -1981,88 +1956,23 @@
 // directory and then successive parent directories to find the go.mod
 // marking the root of the main (current) module.
 //
-// The go.mod file itself is line-oriented, with // comments but
-// no /* */ comments. Each line holds a single directive, made up of a
-// verb followed by arguments. For example:
-//
-//     module my/thing
-//     go 1.12
-//     require other/thing v1.0.2
-//     require new/thing/v2 v2.3.4
-//     exclude old/thing v1.2.3
-//     replace bad/thing v1.4.5 => good/thing v1.4.5
-//     retract v1.5.6
-//
-// The verbs are
-//     module, to define the module path;
-//     go, to set the expected language version;
-//     require, to require a particular module at a given version or later;
-//     exclude, to exclude a particular module version from use;
-//     replace, to replace a module version with a different module version; and
-//     retract, to indicate a previously released version should not be used.
-// Exclude and replace apply only in the main module's go.mod and are ignored
-// in dependencies.  See https://golang.org/ref/mod for details.
-//
-// The leading verb can be factored out of adjacent lines to create a block,
-// like in Go imports:
-//
-//     require (
-//             new/thing/v2 v2.3.4
-//             old/thing v1.2.3
-//     )
-//
-// The go.mod file is designed both to be edited directly and to be
-// easily updated by tools. The 'go mod edit' command can be used to
-// parse and edit the go.mod file from programs and tools.
-// See 'go help mod edit'.
-//
-// The go command automatically updates go.mod each time it uses the
-// module graph, to make sure go.mod always accurately reflects reality
-// and is properly formatted. For example, consider this go.mod file:
-//
-//         module M
-//
-//         require (
-//                 A v1
-//                 B v1.0.0
-//                 C v1.0.0
-//                 D v1.2.3
-//                 E dev
-//         )
-//
-//         exclude D v1.2.3
-//
-// The update rewrites non-canonical version identifiers to semver form,
-// so A's v1 becomes v1.0.0 and E's dev becomes the pseudo-version for the
-// latest commit on the dev branch, perhaps v0.0.0-20180523231146-b3f5c0f6e5f1.
-//
-// The update modifies requirements to respect exclusions, so the
-// requirement on the excluded D v1.2.3 is updated to use the next
-// available version of D, perhaps D v1.2.4 or D v1.3.0.
-//
-// The update removes redundant or misleading requirements.
-// For example, if A v1.0.0 itself requires B v1.2.0 and C v1.0.0,
-// then go.mod's requirement of B v1.0.0 is misleading (superseded by
-// A's need for v1.2.0), and its requirement of C v1.0.0 is redundant
-// (implied by A's need for the same version), so both will be removed.
-// If module M contains packages that directly import packages from B or
-// C, then the requirements will be kept but updated to the actual
-// versions being used.
-//
-// Finally, the update reformats the go.mod in a canonical formatting, so
-// that future mechanical changes will result in minimal diffs.
-//
-// Because the module graph defines the meaning of import statements, any
-// commands that load packages also use and therefore update go.mod,
-// including go build, go get, go install, go list, go test, go mod graph,
-// go mod tidy, and go mod why.
-//
-// The expected language version, set by the go directive, determines
-// which language features are available when compiling the module.
-// Language features available in that version will be available for use.
-// Language features removed in earlier versions, or added in later versions,
-// will not be available. Note that the language version does not affect
-// build tags, which are determined by the Go release being used.
+// The go.mod file format is described in detail at
+// https://golang.org/ref/mod#go-mod-file.
+//
+// To create a new go.mod file, use 'go help init'. For details see
+// 'go help mod init' or https://golang.org/ref/mod#go-mod-init.
+//
+// To add missing module requirements or remove unneeded requirements,
+// use 'go mod tidy'. For details, see 'go help mod tidy' or
+// https://golang.org/ref/mod#go-mod-tidy.
+//
+// To add, upgrade, downgrade, or remove a specific module requirement, use
+// 'go get'. For details, see 'go help module-get' or
+// https://golang.org/ref/mod#go-get.
+//
+// To make other changes or to parse go.mod as JSON for use by other tools,
+// use 'go mod edit'. See 'go help mod edit' or
+// https://golang.org/ref/mod#go-mod-edit.
 //
 //
 // GOPATH environment variable
@@ -2297,65 +2207,8 @@
 // a site serving from a fixed file system (including a file:/// URL)
 // can be a module proxy.
 //
-// The GET requests sent to a Go module proxy are:
-//
-// GET $GOPROXY/<module>/@v/list returns a list of known versions of the given
-// module, one per line.
-//
-// GET $GOPROXY/<module>/@v/<version>.info returns JSON-formatted metadata
-// about that version of the given module.
-//
-// GET $GOPROXY/<module>/@v/<version>.mod returns the go.mod file
-// for that version of the given module.
-//
-// GET $GOPROXY/<module>/@v/<version>.zip returns the zip archive
-// for that version of the given module.
-//
-// GET $GOPROXY/<module>/@latest returns JSON-formatted metadata about the
-// latest known version of the given module in the same format as
-// <module>/@v/<version>.info. The latest version should be the version of
-// the module the go command may use if <module>/@v/list is empty or no
-// listed version is suitable. <module>/@latest is optional and may not
-// be implemented by a module proxy.
-//
-// When resolving the latest version of a module, the go command will request
-// <module>/@v/list, then, if no suitable versions are found, <module>/@latest.
-// The go command prefers, in order: the semantically highest release version,
-// the semantically highest pre-release version, and the chronologically
-// most recent pseudo-version. In Go 1.12 and earlier, the go command considered
-// pseudo-versions in <module>/@v/list to be pre-release versions, but this is
-// no longer true since Go 1.13.
-//
-// To avoid problems when serving from case-sensitive file systems,
-// the <module> and <version> elements are case-encoded, replacing every
-// uppercase letter with an exclamation mark followed by the corresponding
-// lower-case letter: github.com/Azure encodes as github.com/!azure.
-//
-// The JSON-formatted metadata about a given module corresponds to
-// this Go data structure, which may be expanded in the future:
-//
-//     type Info struct {
-//         Version string    // version string
-//         Time    time.Time // commit time
-//     }
-//
-// The zip archive for a specific version of a given module is a
-// standard zip file that contains the file tree corresponding
-// to the module's source code and related files. The archive uses
-// slash-separated paths, and every file path in the archive must
-// begin with <module>@<version>/, where the module and version are
-// substituted directly, not case-encoded. The root of the module
-// file tree corresponds to the <module>@<version>/ prefix in the
-// archive.
-//
-// Even when downloading directly from version control systems,
-// the go command synthesizes explicit info, mod, and zip files
-// and stores them in its local cache, $GOPATH/pkg/mod/cache/download,
-// the same as if it had downloaded them directly from a proxy.
-// The cache layout is the same as the proxy URL space, so
-// serving $GOPATH/pkg/mod/cache/download at (or copying it to)
-// https://example.com/proxy would let other users access those
-// cached module versions with GOPROXY=https://example.com/proxy.
+// For details on the GOPROXY protocol, see
+// https://golang.org/ref/mod#goproxy-protocol.
 //
 //
 // Import path syntax
@@ -2506,7 +2359,7 @@
 // (See 'go help gopath-get' and 'go help gopath'.)
 //
 // When using modules, downloaded packages are stored in the module cache.
-// (See 'go help module-get' and 'go help goproxy'.)
+// See https://golang.org/ref/mod#module-cache.
 //
 // When using modules, an additional variant of the go-import meta tag is
 // recognized and is preferred over those listing version control systems.
@@ -2516,7 +2369,8 @@
 //
 // This tag means to fetch modules with paths beginning with example.org
 // from the module proxy available at the URL https://code.org/moduleproxy.
-// See 'go help goproxy' for details about the proxy protocol.
+// See https://golang.org/ref/mod#goproxy-protocol for details about the
+// proxy protocol.
 //
 // Import path checking
 //
@@ -2547,483 +2401,39 @@
 //
 // Modules, module versions, and more
 //
-// A module is a collection of related Go packages.
-// Modules are the unit of source code interchange and versioning.
-// The go command has direct support for working with modules,
-// including recording and resolving dependencies on other modules.
-// Modules replace the old GOPATH-based approach to specifying
-// which source files are used in a given build.
-//
-// Module support
-//
-// The go command includes support for Go modules. Module-aware mode is active
-// by default whenever a go.mod file is found in the current directory or in
-// any parent directory.
-//
-// The quickest way to take advantage of module support is to check out your
-// repository, create a go.mod file (described in the next section) there, and run
-// go commands from within that file tree.
-//
-// For more fine-grained control, the go command continues to respect
-// a temporary environment variable, GO111MODULE, which can be set to one
-// of three string values: off, on, or auto (the default).
-// If GO111MODULE=on, then the go command requires the use of modules,
-// never consulting GOPATH. We refer to this as the command
-// being module-aware or running in "module-aware mode".
-// If GO111MODULE=off, then the go command never uses
-// module support. Instead it looks in vendor directories and GOPATH
-// to find dependencies; we now refer to this as "GOPATH mode."
-// If GO111MODULE=auto or is unset, then the go command enables or disables
-// module support based on the current directory.
-// Module support is enabled only when the current directory contains a
-// go.mod file or is below a directory containing a go.mod file.
-//
-// In module-aware mode, GOPATH no longer defines the meaning of imports
-// during a build, but it still stores downloaded dependencies (in GOPATH/pkg/mod)
-// and installed commands (in GOPATH/bin, unless GOBIN is set).
-//
-// Defining a module
-//
-// A module is defined by a tree of Go source files with a go.mod file
-// in the tree's root directory. The directory containing the go.mod file
-// is called the module root. Typically the module root will also correspond
-// to a source code repository root (but in general it need not).
-// The module is the set of all Go packages in the module root and its
-// subdirectories, but excluding subtrees with their own go.mod files.
-//
-// The "module path" is the import path prefix corresponding to the module root.
-// The go.mod file defines the module path and lists the specific versions
-// of other modules that should be used when resolving imports during a build,
-// by giving their module paths and versions.
-//
-// For example, this go.mod declares that the directory containing it is the root
-// of the module with path example.com/m, and it also declares that the module
-// depends on specific versions of golang.org/x/text and gopkg.in/yaml.v2:
-//
-//     module example.com/m
-//
-//     require (
-//             golang.org/x/text v0.3.0
-//             gopkg.in/yaml.v2 v2.1.0
-//     )
-//
-// The go.mod file can also specify replacements and excluded versions
-// that only apply when building the module directly; they are ignored
-// when the module is incorporated into a larger build.
-// For more about the go.mod file, see 'go help go.mod'.
-//
-// To start a new module, simply create a go.mod file in the root of the
-// module's directory tree, containing only a module statement.
-// The 'go mod init' command can be used to do this:
-//
-//     go mod init example.com/m
-//
-// In a project already using an existing dependency management tool like
-// godep, glide, or dep, 'go mod init' will also add require statements
-// matching the existing configuration.
-//
-// Once the go.mod file exists, no additional steps are required:
-// go commands like 'go build', 'go test', or even 'go list' will automatically
-// add new dependencies as needed to satisfy imports.
-//
-// The main module and the build list
-//
-// The "main module" is the module containing the directory where the go command
-// is run. The go command finds the module root by looking for a go.mod in the
-// current directory, or else the current directory's parent directory,
-// or else the parent's parent directory, and so on.
-//
-// The main module's go.mod file defines the precise set of packages available
-// for use by the go command, through require, replace, and exclude statements.
-// Dependency modules, found by following require statements, also contribute
-// to the definition of that set of packages, but only through their go.mod
-// files' require statements: any replace and exclude statements in dependency
-// modules are ignored. The replace and exclude statements therefore allow the
-// main module complete control over its own build, without also being subject
-// to complete control by dependencies.
-//
-// The set of modules providing packages to builds is called the "build list".
-// The build list initially contains only the main module. Then the go command
-// adds to the list the exact module versions required by modules already
-// on the list, recursively, until there is nothing left to add to the list.
-// If multiple versions of a particular module are added to the list,
-// then at the end only the latest version (according to semantic version
-// ordering) is kept for use in the build.
-//
-// The 'go list' command provides information about the main module
-// and the build list. For example:
-//
-//     go list -m              # print path of main module
-//     go list -m -f={{.Dir}}  # print root directory of main module
-//     go list -m all          # print build list
-//
-// Maintaining module requirements
-//
-// The go.mod file is meant to be readable and editable by both programmers and
-// tools. Most updates to dependencies can be performed using "go get" and
-// "go mod tidy". Other module-aware build commands may be invoked using the
-// -mod=mod flag to automatically add missing requirements and fix inconsistencies.
-//
-// The "go get" command updates go.mod to change the module versions used in a
-// build. An upgrade of one module may imply upgrading others, and similarly a
-// downgrade of one module may imply downgrading others. The "go get" command
-// makes these implied changes as well. See "go help module-get".
-//
-// The "go mod" command provides other functionality for use in maintaining
-// and understanding modules and go.mod files. See "go help mod", particularly
-// "go help mod tidy" and "go help mod edit".
-//
-// As part of maintaining the require statements in go.mod, the go command
-// tracks which ones provide packages imported directly by the current module
-// and which ones provide packages only used indirectly by other module
-// dependencies. Requirements needed only for indirect uses are marked with a
-// "// indirect" comment in the go.mod file. Indirect requirements may be
-// automatically removed from the go.mod file once they are implied by other
-// direct requirements. Indirect requirements only arise when using modules
-// that fail to state some of their own dependencies or when explicitly
-// upgrading a module's dependencies ahead of its own stated requirements.
-//
-// The -mod build flag provides additional control over the updating and use of
-// go.mod for commands that build packages like "go build" and "go test".
-//
-// If invoked with -mod=readonly (the default in most situations), the go command
-// reports an error if a package named on the command line or an imported package
-// is not provided by any module in the build list computed from the main module's
-// requirements. The go command also reports an error if a module's checksum is
-// missing from go.sum (see Module downloading and verification). Either go.mod or
-// go.sum must be updated in these situations.
-//
-// If invoked with -mod=mod, the go command automatically updates go.mod and
-// go.sum, fixing inconsistencies and adding missing requirements and checksums
-// as needed. If the go command finds an unfamiliar import, it looks up the
-// module containing that import and adds a requirement for the latest version
-// of that module to go.mod. In most cases, therefore, one may add an import to
-// source code and run "go build", "go test", or even "go list" with -mod=mod:
-// as part of analyzing the package, the go command will resolve the import and
-// update the go.mod file.
-//
-// If invoked with -mod=vendor, the go command loads packages from the main
-// module's vendor directory instead of downloading modules to and loading packages
-// from the module cache. The go command assumes the vendor directory holds
-// correct copies of dependencies, and it does not compute the set of required
-// module versions from go.mod files. However, the go command does check that
-// vendor/modules.txt (generated by "go mod vendor") contains metadata consistent
-// with go.mod.
-//
-// If the go command is not invoked with a -mod flag, and the vendor directory
-// is present, and the "go" version in go.mod is 1.14 or higher, the go command
-// will act as if it were invoked with -mod=vendor. Otherwise, the -mod flag
-// defaults to -mod=readonly.
-//
-// Note that neither "go get" nor the "go mod" subcommands accept the -mod flag.
-//
-// Pseudo-versions
-//
-// The go.mod file and the go command more generally use semantic versions as
-// the standard form for describing module versions, so that versions can be
-// compared to determine which should be considered earlier or later than another.
-// A module version like v1.2.3 is introduced by tagging a revision in the
-// underlying source repository. Untagged revisions can be referred to
-// using a "pseudo-version" like v0.0.0-yyyymmddhhmmss-abcdefabcdef,
-// where the time is the commit time in UTC and the final suffix is the prefix
-// of the commit hash. The time portion ensures that two pseudo-versions can
-// be compared to determine which happened later, the commit hash identifes
-// the underlying commit, and the prefix (v0.0.0- in this example) is derived from
-// the most recent tagged version in the commit graph before this commit.
-//
-// There are three pseudo-version forms:
-//
-// vX.0.0-yyyymmddhhmmss-abcdefabcdef is used when there is no earlier
-// versioned commit with an appropriate major version before the target commit.
-// (This was originally the only form, so some older go.mod files use this form
-// even for commits that do follow tags.)
-//
-// vX.Y.Z-pre.0.yyyymmddhhmmss-abcdefabcdef is used when the most
-// recent versioned commit before the target commit is vX.Y.Z-pre.
-//
-// vX.Y.(Z+1)-0.yyyymmddhhmmss-abcdefabcdef is used when the most
-// recent versioned commit before the target commit is vX.Y.Z.
-//
-// Pseudo-versions never need to be typed by hand: the go command will accept
-// the plain commit hash and translate it into a pseudo-version (or a tagged
-// version if available) automatically. This conversion is an example of a
-// module query.
-//
-// Module queries
-//
-// The go command accepts a "module query" in place of a module version
-// both on the command line and in the main module's go.mod file.
-// (After evaluating a query found in the main module's go.mod file,
-// the go command updates the file to replace the query with its result.)
-//
-// A fully-specified semantic version, such as "v1.2.3",
-// evaluates to that specific version.
-//
-// A semantic version prefix, such as "v1" or "v1.2",
-// evaluates to the latest available tagged version with that prefix.
-//
-// A semantic version comparison, such as "<v1.2.3" or ">=v1.5.6",
-// evaluates to the available tagged version nearest to the comparison target
-// (the latest version for < and <=, the earliest version for > and >=).
-//
-// The string "latest" matches the latest available tagged version,
-// or else the underlying source repository's latest untagged revision.
-//
-// The string "upgrade" is like "latest", but if the module is
-// currently required at a later version than the version "latest"
-// would select (for example, a newer pre-release version), "upgrade"
-// will select the later version instead.
-//
-// The string "patch" matches the latest available tagged version
-// of a module with the same major and minor version numbers as the
-// currently required version. If no version is currently required,
-// "patch" is equivalent to "latest".
-//
-// A revision identifier for the underlying source repository, such as
-// a commit hash prefix, revision tag, or branch name, selects that
-// specific code revision. If the revision is also tagged with a
-// semantic version, the query evaluates to that semantic version.
-// Otherwise the query evaluates to a pseudo-version for the commit.
-// Note that branches and tags with names that are matched by other
-// query syntax cannot be selected this way. For example, the query
-// "v2" means the latest version starting with "v2", not the branch
-// named "v2".
-//
-// All queries prefer release versions to pre-release versions.
-// For example, "<v1.2.3" will prefer to return "v1.2.2"
-// instead of "v1.2.3-pre1", even though "v1.2.3-pre1" is nearer
-// to the comparison target.
-//
-// Module versions disallowed by exclude statements in the
-// main module's go.mod are considered unavailable and cannot
-// be returned by queries.
-//
-// For example, these commands are all valid:
-//
-//     go get github.com/gorilla/mux@latest    # same (@latest is default for 'go get')
-//     go get github.com/gorilla/mux@v1.6.2    # records v1.6.2
-//     go get github.com/gorilla/mux@e3702bed2 # records v1.6.2
-//     go get github.com/gorilla/mux@c856192   # records v0.0.0-20180517173623-c85619274f5d
-//     go get github.com/gorilla/mux@master    # records current meaning of master
-//
-// Module compatibility and semantic versioning
-//
-// The go command requires that modules use semantic versions and expects that
-// the versions accurately describe compatibility: it assumes that v1.5.4 is a
-// backwards-compatible replacement for v1.5.3, v1.4.0, and even v1.0.0.
-// More generally the go command expects that packages follow the
-// "import compatibility rule", which says:
-//
-// "If an old package and a new package have the same import path,
-// the new package must be backwards compatible with the old package."
-//
-// Because the go command assumes the import compatibility rule,
-// a module definition can only set the minimum required version of one
-// of its dependencies: it cannot set a maximum or exclude selected versions.
-// Still, the import compatibility rule is not a guarantee: it may be that
-// v1.5.4 is buggy and not a backwards-compatible replacement for v1.5.3.
-// Because of this, the go command never updates from an older version
-// to a newer version of a module unasked.
-//
-// In semantic versioning, changing the major version number indicates a lack
-// of backwards compatibility with earlier versions. To preserve import
-// compatibility, the go command requires that modules with major version v2
-// or later use a module path with that major version as the final element.
-// For example, version v2.0.0 of example.com/m must instead use module path
-// example.com/m/v2, and packages in that module would use that path as
-// their import path prefix, as in example.com/m/v2/sub/pkg. Including the
-// major version number in the module path and import paths in this way is
-// called "semantic import versioning". Pseudo-versions for modules with major
-// version v2 and later begin with that major version instead of v0, as in
-// v2.0.0-20180326061214-4fc5987536ef.
-//
-// As a special case, module paths beginning with gopkg.in/ continue to use the
-// conventions established on that system: the major version is always present,
-// and it is preceded by a dot instead of a slash: gopkg.in/yaml.v1
-// and gopkg.in/yaml.v2, not gopkg.in/yaml and gopkg.in/yaml/v2.
-//
-// The go command treats modules with different module paths as unrelated:
-// it makes no connection between example.com/m and example.com/m/v2.
-// Modules with different major versions can be used together in a build
-// and are kept separate by the fact that their packages use different
-// import paths.
-//
-// In semantic versioning, major version v0 is for initial development,
-// indicating no expectations of stability or backwards compatibility.
-// Major version v0 does not appear in the module path, because those
-// versions are preparation for v1.0.0, and v1 does not appear in the
-// module path either.
-//
-// Code written before the semantic import versioning convention
-// was introduced may use major versions v2 and later to describe
-// the same set of unversioned import paths as used in v0 and v1.
-// To accommodate such code, if a source code repository has a
-// v2.0.0 or later tag for a file tree with no go.mod, the version is
-// considered to be part of the v1 module's available versions
-// and is given an +incompatible suffix when converted to a module
-// version, as in v2.0.0+incompatible. The +incompatible tag is also
-// applied to pseudo-versions derived from such versions, as in
-// v2.0.1-0.yyyymmddhhmmss-abcdefabcdef+incompatible.
-//
-// In general, having a dependency in the build list (as reported by 'go list -m all')
-// on a v0 version, pre-release version, pseudo-version, or +incompatible version
-// is an indication that problems are more likely when upgrading that
-// dependency, since there is no expectation of compatibility for those.
-//
-// See https://research.swtch.com/vgo-import for more information about
-// semantic import versioning, and see https://semver.org/ for more about
-// semantic versioning.
-//
-// Module code layout
-//
-// For now, see https://research.swtch.com/vgo-module for information
-// about how source code in version control systems is mapped to
-// module file trees.
-//
-// Module downloading and verification
-//
-// The go command can fetch modules from a proxy or connect to source control
-// servers directly, according to the setting of the GOPROXY environment
-// variable (see 'go help env'). The default setting for GOPROXY is
-// "https://proxy.golang.org,direct", which means to try the
-// Go module mirror run by Google and fall back to a direct connection
-// if the proxy reports that it does not have the module (HTTP error 404 or 410).
-// See https://proxy.golang.org/privacy for the service's privacy policy.
-//
-// If GOPROXY is set to the string "direct", downloads use a direct connection to
-// source control servers. Setting GOPROXY to "off" disallows downloading modules
-// from any source. Otherwise, GOPROXY is expected to be list of module proxy URLs
-// separated by either comma (,) or pipe (|) characters, which control error
-// fallback behavior. For each request, the go command tries each proxy in
-// sequence. If there is an error, the go command will try the next proxy in the
-// list if the error is a 404 or 410 HTTP response or if the current proxy is
-// followed by a pipe character, indicating it is safe to fall back on any error.
-//
-// The GOPRIVATE and GONOPROXY environment variables allow bypassing
-// the proxy for selected modules. See 'go help private' for details.
-//
-// No matter the source of the modules, the go command checks downloads against
-// known checksums, to detect unexpected changes in the content of any specific
-// module version from one day to the next. This check first consults the current
-// module's go.sum file but falls back to the Go checksum database, controlled by
-// the GOSUMDB and GONOSUMDB environment variables. See 'go help module-auth'
-// for details.
-//
-// See 'go help goproxy' for details about the proxy protocol and also
-// the format of the cached downloaded packages.
-//
-// Modules and vendoring
-//
-// When using modules, the go command typically satisfies dependencies by
-// downloading modules from their sources and using those downloaded copies
-// (after verification, as described in the previous section). Vendoring may
-// be used to allow interoperation with older versions of Go, or to ensure
-// that all files used for a build are stored together in a single file tree.
-//
-// The command 'go mod vendor' constructs a directory named vendor in the main
-// module's root directory that contains copies of all packages needed to support
-// builds and tests of packages in the main module. 'go mod vendor' also
-// creates the file vendor/modules.txt that contains metadata about vendored
-// packages and module versions. This file should be kept consistent with go.mod:
-// when vendoring is used, 'go mod vendor' should be run after go.mod is updated.
-//
-// If the vendor directory is present in the main module's root directory, it will
-// be used automatically if the "go" version in the main module's go.mod file is
-// 1.14 or higher. Build commands like 'go build' and 'go test' will load packages
-// from the vendor directory instead of accessing the network or the local module
-// cache. To explicitly enable vendoring, invoke the go command with the flag
-// -mod=vendor. To disable vendoring, use the flag -mod=mod.
-//
-// Unlike vendoring in GOPATH, the go command ignores vendor directories in
-// locations other than the main module's root directory.
+// Modules are how Go manages dependencies.
+//
+// A module is a collection of packages that are released, versioned, and
+// distributed together. Modules may be downloaded directly from version control
+// repositories or from module proxy servers.
+//
+// For a series of tutorials on modules, see
+// https://golang.org/doc/tutorial/create-module.
+//
+// For a detailed reference on modules, see https://golang.org/ref/mod.
+//
+// By default, the go command may download modules from https://proxy.golang.org.
+// It may authenticate modules using the checksum database at
+// https://sum.golang.org. Both services are operated by the Go team at Google.
+// The privacy policies for these services are available at
+// https://proxy.golang.org/privacy and https://sum.golang.org/privacy,
+// respectively.
+//
+// The go command's download behavior may be configured using GOPROXY, GOSUMDB,
+// GOPRIVATE, and other environment variables. See 'go help environment'
+// and https://golang.org/ref/mod#private-module-privacy for more information.
 //
 //
 // Module authentication using go.sum
 //
-// The go command tries to authenticate every downloaded module,
-// checking that the bits downloaded for a specific module version today
-// match bits downloaded yesterday. This ensures repeatable builds
-// and detects introduction of unexpected changes, malicious or not.
-//
-// In each module's root, alongside go.mod, the go command maintains
-// a file named go.sum containing the cryptographic checksums of the
-// module's dependencies.
-//
-// The form of each line in go.sum is three fields:
-//
-//     <module> <version>[/go.mod] <hash>
-//
-// Each known module version results in two lines in the go.sum file.
-// The first line gives the hash of the module version's file tree.
-// The second line appends "/go.mod" to the version and gives the hash
-// of only the module version's (possibly synthesized) go.mod file.
-// The go.mod-only hash allows downloading and authenticating a
-// module version's go.mod file, which is needed to compute the
-// dependency graph, without also downloading all the module's source code.
-//
-// The hash begins with an algorithm prefix of the form "h<N>:".
-// The only defined algorithm prefix is "h1:", which uses SHA-256.
-//
-// Module authentication failures
-//
-// The go command maintains a cache of downloaded packages and computes
-// and records the cryptographic checksum of each package at download time.
-// In normal operation, the go command checks the main module's go.sum file
-// against these precomputed checksums instead of recomputing them on
-// each command invocation. The 'go mod verify' command checks that
-// the cached copies of module downloads still match both their recorded
-// checksums and the entries in go.sum.
-//
-// In day-to-day development, the checksum of a given module version
-// should never change. Each time a dependency is used by a given main
-// module, the go command checks its local cached copy, freshly
-// downloaded or not, against the main module's go.sum. If the checksums
-// don't match, the go command reports the mismatch as a security error
-// and refuses to run the build. When this happens, proceed with caution:
-// code changing unexpectedly means today's build will not match
-// yesterday's, and the unexpected change may not be beneficial.
-//
-// If the go command reports a mismatch in go.sum, the downloaded code
-// for the reported module version does not match the one used in a
-// previous build of the main module. It is important at that point
-// to find out what the right checksum should be, to decide whether
-// go.sum is wrong or the downloaded code is wrong. Usually go.sum is right:
-// you want to use the same code you used yesterday.
-//
-// If a downloaded module is not yet included in go.sum and it is a publicly
-// available module, the go command consults the Go checksum database to fetch
-// the expected go.sum lines. If the downloaded code does not match those
-// lines, the go command reports the mismatch and exits. Note that the
-// database is not consulted for module versions already listed in go.sum.
-//
-// If a go.sum mismatch is reported, it is always worth investigating why
-// the code downloaded today differs from what was downloaded yesterday.
-//
-// The GOSUMDB environment variable identifies the name of checksum database
-// to use and optionally its public key and URL, as in:
-//
-//     GOSUMDB="sum.golang.org"
-//     GOSUMDB="sum.golang.org+<publickey>"
-//     GOSUMDB="sum.golang.org+<publickey> https://sum.golang.org"
-//
-// The go command knows the public key of sum.golang.org, and also that the name
-// sum.golang.google.cn (available inside mainland China) connects to the
-// sum.golang.org checksum database; use of any other database requires giving
-// the public key explicitly.
-// The URL defaults to "https://" followed by the database name.
-//
-// GOSUMDB defaults to "sum.golang.org", the Go checksum database run by Google.
-// See https://sum.golang.org/privacy for the service's privacy policy.
-//
-// If GOSUMDB is set to "off", or if "go get" is invoked with the -insecure flag,
-// the checksum database is not consulted, and all unrecognized modules are
-// accepted, at the cost of giving up the security guarantee of verified repeatable
-// downloads for all modules. A better way to bypass the checksum database
-// for specific modules is to use the GOPRIVATE or GONOSUMDB environment
-// variables. See 'go help private' for details.
+// When the go command downloads a module zip file or go.mod file into the
+// module cache, it computes a cryptographic hash and compares it with a known
+// value to verify the file hasn't changed since it was first downloaded. Known
+// hashes are stored in a file in the module root directory named go.sum. Hashes
+// may also be downloaded from the checksum database depending on the values of
+// GOSUMDB, GOPRIVATE, and GONOSUMDB.
 //
-// The 'go env -w' command (see 'go help env') can be used to set these variables
-// for future go command invocations.
+// For details, see https://golang.org/ref/mod#authenticating.
 //
 //
 // Package lists and patterns
@@ -3118,8 +2528,8 @@
 // These defaults work well for publicly available source code.
 //
 // The GOPRIVATE environment variable controls which modules the go command
-// considers to be private (not available publicly) and should therefore not use the
-// proxy or checksum database. The variable is a comma-separated list of
+// considers to be private (not available publicly) and should therefore not use
+// the proxy or checksum database. The variable is a comma-separated list of
 // glob patterns (in the syntax of Go's path.Match) of module path prefixes.
 // For example,
 //
@@ -3129,10 +2539,6 @@
 // matching either pattern, including git.corp.example.com/xyzzy, rsc.io/private,
 // and rsc.io/private/quux.
 //
-// The GOPRIVATE environment variable may be used by other tools as well to
-// identify non-public modules. For example, an editor could use GOPRIVATE
-// to decide whether to hyperlink a package import to a godoc.org page.
-//
 // For fine-grained control over module download and validation, the GONOPROXY
 // and GONOSUMDB environment variables accept the same kind of glob list
 // and override GOPRIVATE for the specific decision of whether to use the proxy
@@ -3145,12 +2551,6 @@
 //     GOPROXY=proxy.example.com
 //     GONOPROXY=none
 //
-// This would tell the go command and other tools that modules beginning with
-// a corp.example.com subdomain are private but that the company proxy should
-// be used for downloading both public and private modules, because
-// GONOPROXY has been set to a pattern that won't match any modules,
-// overriding GOPRIVATE.
-//
 // The GOPRIVATE variable is also used to define the "public" and "private"
 // patterns for the GOVCS variable; see 'go help vcs'. For that usage,
 // GOPRIVATE applies even in GOPATH mode. In that case, it matches import paths
@@ -3159,6 +2559,8 @@
 // The 'go env -w' command (see 'go help env') can be used to set these variables
 // for future go command invocations.
 //
+// For more details, see https://golang.org/ref/mod#private-modules.
+//
 //
 // Testing flags
 //
@@ -3479,20 +2881,23 @@
 // legal reasons). Therefore, clients can still access public code served from
 // Bazaar, Fossil, or Subversion repositories by default, because those downloads
 // use the Go module mirror, which takes on the security risk of running the
-// version control commands, using a custom sandbox.
+// version control commands using a custom sandbox.
 //
 // The GOVCS variable can be used to change the allowed version control systems
 // for specific packages (identified by a module or import path).
-// The GOVCS variable applies both when using modules and when using GOPATH.
-// When using modules, the patterns match against the module path.
-// When using GOPATH, the patterns match against the import path
-// corresponding to the root of the version control repository.
+// The GOVCS variable applies when building package in both module-aware mode
+// and GOPATH mode. When using modules, the patterns match against the module path.
+// When using GOPATH, the patterns match against the import path corresponding to
+// the root of the version control repository.
 //
 // The general form of the GOVCS setting is a comma-separated list of
 // pattern:vcslist rules. The pattern is a glob pattern that must match
 // one or more leading elements of the module or import path. The vcslist
 // is a pipe-separated list of allowed version control commands, or "all"
-// to allow use of any known command, or "off" to allow nothing.
+// to allow use of any known command, or "off" to disallow all commands.
+// Note that if a module matches a pattern with vcslist "off", it may still be
+// downloaded if the origin server uses the "mod" scheme, which instructs the
+// go command to download the module using the GOPROXY protocol.
 // The earliest matching pattern in the list applies, even if later patterns
 // might also match.
 //
@@ -3500,7 +2905,7 @@
 //
 //     GOVCS=github.com:git,evil.com:off,*:git|hg
 //
-// With this setting, code with an module or import path beginning with
+// With this setting, code with a module or import path beginning with
 // github.com/ can only use git; paths on evil.com cannot use any version
 // control command, and all other paths (* matches everything) can use
 // only git or hg.

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index c472620db2960008d1116215c5587b90b87802ef..d14b2328bfaa05ac950799eb39bec547e81e883a 100644 (file)
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -216,6 +216,7 @@ func TestMain(m *testing.M) {
        }
        // Don't let these environment variables confuse the test.
        os.Setenv("GOENV", "off")
+       os.Unsetenv("GOFLAGS")
        os.Unsetenv("GOBIN")
        os.Unsetenv("GOPATH")
        os.Unsetenv("GIT_ALLOW_PROTOCOL")
@@ -810,6 +811,7 @@ func TestNewReleaseRebuildsStalePackagesInGOPATH(t *testing.T) {
        // so that we can change files.
        for _, copydir := range []string{
                "src/runtime",
+               "src/internal/abi",
                "src/internal/bytealg",
                "src/internal/cpu",
                "src/math/bits",
@@ -2655,12 +2657,12 @@ func TestBadCommandLines(t *testing.T) {
        tg.tempFile("src/@x/x.go", "package x\n")
        tg.setenv("GOPATH", tg.path("."))
        tg.runFail("build", "@x")
-       tg.grepStderr("invalid input directory name \"@x\"|cannot use path@version syntax", "did not reject @x directory")
+       tg.grepStderr("invalid input directory name \"@x\"|can only use path@version syntax with 'go get' and 'go install' in module-aware mode", "did not reject @x directory")
 
        tg.tempFile("src/@x/y/y.go", "package y\n")
        tg.setenv("GOPATH", tg.path("."))
        tg.runFail("build", "@x/y")
-       tg.grepStderr("invalid import path \"@x/y\"|cannot use path@version syntax", "did not reject @x/y import path")
+       tg.grepStderr("invalid import path \"@x/y\"|can only use path@version syntax with 'go get' and 'go install' in module-aware mode", "did not reject @x/y import path")
 
        tg.tempFile("src/-x/x.go", "package x\n")
        tg.setenv("GOPATH", tg.path("."))

diff --git a/src/cmd/go/internal/base/base.go b/src/cmd/go/internal/base/base.go
index 004588c73204d6054c667e4949fbca94a641a4ac..954ce47a9899325014b4e99b5b6a1875a4120f30 100644 (file)
--- a/src/cmd/go/internal/base/base.go
+++ b/src/cmd/go/internal/base/base.go
@@ -10,9 +10,9 @@ import (
        "context"
        "flag"
        "fmt"
+       exec "internal/execabs"
        "log"
        "os"
-       "os/exec"
        "strings"
        "sync"
 

diff --git a/src/cmd/go/internal/bug/bug.go b/src/cmd/go/internal/bug/bug.go
index 1085feaaee83b44c60542f73720d2fd1a8ed5d47..4aa08b4ff6ea7ab988daa86f3243b12948f0b64f 100644 (file)
--- a/src/cmd/go/internal/bug/bug.go
+++ b/src/cmd/go/internal/bug/bug.go
@@ -9,10 +9,10 @@ import (
        "bytes"
        "context"
        "fmt"
+       exec "internal/execabs"
        "io"
        urlpkg "net/url"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "runtime"

diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index c48904eacceab90949bc12248ad82b91803a16ca..322247962f8951a12ea8d5fc3f617cf447dfe590 100644 (file)
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -28,18 +28,18 @@ var (
        BuildA                 bool   // -a flag
        BuildBuildmode         string // -buildmode flag
        BuildContext           = defaultContext()
-       BuildMod               string             // -mod flag
-       BuildModExplicit       bool               // whether -mod was set explicitly
-       BuildModReason         string             // reason -mod was set, if set by default
-       BuildI                 bool               // -i flag
-       BuildLinkshared        bool               // -linkshared flag
-       BuildMSan              bool               // -msan flag
-       BuildN                 bool               // -n flag
-       BuildO                 string             // -o flag
-       BuildP                 = runtime.NumCPU() // -p flag
-       BuildPkgdir            string             // -pkgdir flag
-       BuildRace              bool               // -race flag
-       BuildToolexec          []string           // -toolexec flag
+       BuildMod               string                  // -mod flag
+       BuildModExplicit       bool                    // whether -mod was set explicitly
+       BuildModReason         string                  // reason -mod was set, if set by default
+       BuildI                 bool                    // -i flag
+       BuildLinkshared        bool                    // -linkshared flag
+       BuildMSan              bool                    // -msan flag
+       BuildN                 bool                    // -n flag
+       BuildO                 string                  // -o flag
+       BuildP                 = runtime.GOMAXPROCS(0) // -p flag
+       BuildPkgdir            string                  // -pkgdir flag
+       BuildRace              bool                    // -race flag
+       BuildToolexec          []string                // -toolexec flag
        BuildToolchainName     string
        BuildToolchainCompiler func() string
        BuildToolchainLinker   func() string

diff --git a/src/cmd/go/internal/fix/fix.go b/src/cmd/go/internal/fix/fix.go
index 825624fcbb8b6a3eb8ee6b1db0c08f107dd6148c..c7588c66d3ebcc56bab6f83ad91c0f85e9c15d29 100644 (file)
--- a/src/cmd/go/internal/fix/fix.go
+++ b/src/cmd/go/internal/fix/fix.go
@@ -33,8 +33,20 @@ See also: go fmt, go vet.
 }
 
 func runFix(ctx context.Context, cmd *base.Command, args []string) {
+       pkgs := load.PackagesAndErrors(ctx, args)
+       w := 0
+       for _, pkg := range pkgs {
+               if pkg.Error != nil {
+                       base.Errorf("%v", pkg.Error)
+                       continue
+               }
+               pkgs[w] = pkg
+               w++
+       }
+       pkgs = pkgs[:w]
+
        printed := false
-       for _, pkg := range load.Packages(ctx, args) {
+       for _, pkg := range pkgs {
                if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
                        if !printed {
                                fmt.Fprintf(os.Stderr, "go: not fixing packages in dependency modules\n")

diff --git a/src/cmd/go/internal/fmtcmd/fmt.go b/src/cmd/go/internal/fmtcmd/fmt.go
index b0c1c59b40c58b4818f0317b6683ba10422eec6a..6b98f0ccd31865c937def4ac99b22597ca2b52e3 100644 (file)
--- a/src/cmd/go/internal/fmtcmd/fmt.go
+++ b/src/cmd/go/internal/fmtcmd/fmt.go
@@ -75,7 +75,8 @@ func runFmt(ctx context.Context, cmd *base.Command, args []string) {
                }
                if pkg.Error != nil {
                        var nogo *load.NoGoError
-                       if errors.As(pkg.Error, &nogo) && len(pkg.InternalAllGoFiles()) > 0 {
+                       var embed *load.EmbedError
+                       if (errors.As(pkg.Error, &nogo) || errors.As(pkg.Error, &embed)) && len(pkg.InternalAllGoFiles()) > 0 {
                                // Skip this error, as we will format
                                // all files regardless.
                        } else {

diff --git a/src/cmd/go/internal/generate/generate.go b/src/cmd/go/internal/generate/generate.go
index c7401948b8b314e8dab26576ed4c6940e4080d1d..a48311d51b09b7a2a356e1e567abfcaa1af60b7b 100644 (file)
--- a/src/cmd/go/internal/generate/generate.go
+++ b/src/cmd/go/internal/generate/generate.go
@@ -12,10 +12,10 @@ import (
        "fmt"
        "go/parser"
        "go/token"
+       exec "internal/execabs"
        "io"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "strconv"
@@ -52,15 +52,6 @@ that can be run locally. It must either be in the shell path
 (gofmt), a fully qualified path (/usr/you/bin/mytool), or a
 command alias, described below.
 
-To convey to humans and machine tools that code is generated,
-generated source should have a line that matches the following
-regular expression (in Go syntax):
-
-       ^// Code generated .* DO NOT EDIT\.$
-
-The line may appear anywhere in the file, but is typically
-placed near the beginning so it is easy to find.
-
 Note that go generate does not parse the file, so lines that look
 like directives in comments or multiline strings will be treated
 as directives.
@@ -72,6 +63,15 @@ arguments when it is run.
 Quoted strings use Go syntax and are evaluated before execution; a
 quoted string appears as a single argument to the generator.
 
+To convey to humans and machine tools that code is generated,
+generated source should have a line that matches the following
+regular expression (in Go syntax):
+
+       ^// Code generated .* DO NOT EDIT\.$
+
+This line must appear before the first non-comment, non-blank
+text in the file.
+
 Go generate sets several variables when it runs the generator:
 
        $GOARCH

diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index 268962eca8f69be07ad1bce918bef94cd85d2666..38ff3823f22b521f46682841e02564afd6de923d 100644 (file)
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -180,13 +180,14 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
        // everything.
        load.ClearPackageCache()
 
-       pkgs := load.PackagesForBuild(ctx, args)
+       pkgs := load.PackagesAndErrors(ctx, args)
+       load.CheckPackageErrors(pkgs)
 
        // Phase 3. Install.
        if *getD {
                // Download only.
-               // Check delayed until now so that importPaths
-               // and packagesForBuild have a chance to print errors.
+               // Check delayed until now so that downloadPaths
+               // and CheckPackageErrors have a chance to print errors.
                return
        }
 
@@ -201,7 +202,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 func downloadPaths(patterns []string) []string {
        for _, arg := range patterns {
                if strings.Contains(arg, "@") {
-                       base.Fatalf("go: cannot use path@version syntax in GOPATH mode")
+                       base.Fatalf("go: can only use path@version syntax with 'go get' and 'go install' in module-aware mode")
                        continue
                }
 

diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go
index 98f58441b4de605a75084887d3ea7c57232c8ee9..57cee4ff96c1acc42c01d69483bc630d86e8b750 100644 (file)
--- a/src/cmd/go/internal/help/helpdoc.go
+++ b/src/cmd/go/internal/help/helpdoc.go
@@ -266,7 +266,7 @@ listed in the GOPATH environment variable.
 (See 'go help gopath-get' and 'go help gopath'.)
 
 When using modules, downloaded packages are stored in the module cache.
-(See 'go help module-get' and 'go help goproxy'.)
+See https://golang.org/ref/mod#module-cache.
 
 When using modules, an additional variant of the go-import meta tag is
 recognized and is preferred over those listing version control systems.
@@ -276,7 +276,8 @@ That variant uses "mod" as the vcs in the content value, as in:
 
 This tag means to fetch modules with paths beginning with example.org
 from the module proxy available at the URL https://code.org/moduleproxy.
-See 'go help goproxy' for details about the proxy protocol.
+See https://golang.org/ref/mod#goproxy-protocol for details about the
+proxy protocol.
 
 Import path checking
 
@@ -483,6 +484,10 @@ See 'go help env' for details.
 
 General-purpose environment variables:
 
+       GO111MODULE
+               Controls whether the go command runs in module-aware mode or GOPATH mode.
+               May be "off", "on", or "auto".
+               See https://golang.org/ref/mod#mod-commands.
        GCCGO
                The gccgo command to run for 'go build -compiler=gccgo'.
        GOARCH
@@ -521,20 +526,24 @@ General-purpose environment variables:
        GOPATH
                For more details see: 'go help gopath'.
        GOPROXY
-               URL of Go module proxy. See 'go help modules'.
+               URL of Go module proxy. See https://golang.org/ref/mod#environment-variables
+               and https://golang.org/ref/mod#module-proxy for details.
        GOPRIVATE, GONOPROXY, GONOSUMDB
                Comma-separated list of glob patterns (in the syntax of Go's path.Match)
                of module path prefixes that should always be fetched directly
                or that should not be compared against the checksum database.
-               See 'go help private'.
+               See https://golang.org/ref/mod#private-modules.
        GOROOT
                The root of the go tree.
        GOSUMDB
                The name of checksum database to use and optionally its public key and
-               URL. See 'go help module-auth'.
+               URL. See https://golang.org/ref/mod#authenticating.
        GOTMPDIR
                The directory where the go command will write
                temporary source files, packages, and binaries.
+       GOVCS
+               Lists version control commands that may be used with matching servers.
+               See 'go help vcs'.
 
 Environment variables for use with cgo:
 

diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 9af9dbb8568b88e17b9fcc21ce0657ef686e9ab8..b4d82d9f8ccc97cb4e9400b15774958d4b4ce921 100644 (file)
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -89,6 +89,14 @@ to -f '{{.ImportPath}}'. The struct being passed to the template is:
         TestGoFiles     []string   // _test.go files in package
         XTestGoFiles    []string   // _test.go files outside package
 
+        // Embedded files
+        EmbedPatterns      []string // //go:embed patterns
+        EmbedFiles         []string // files matched by EmbedPatterns
+        TestEmbedPatterns  []string // //go:embed patterns in TestGoFiles
+        TestEmbedFiles     []string // files matched by TestEmbedPatterns
+        XTestEmbedPatterns []string // //go:embed patterns in XTestGoFiles
+        XTestEmbedFiles    []string // files matched by XTestEmbedPatterns
+
         // Cgo directives
         CgoCFLAGS    []string // cgo: flags for C compiler
         CgoCPPFLAGS  []string // cgo: flags for C preprocessor
@@ -300,7 +308,7 @@ For more about build flags, see 'go help build'.
 
 For more about specifying packages, see 'go help packages'.
 
-For more about modules, see 'go help modules'.
+For more about modules, see https://golang.org/ref/mod.
        `,
 }
 
@@ -471,11 +479,18 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
        }
 
        load.IgnoreImports = *listFind
-       var pkgs []*load.Package
-       if *listE {
-               pkgs = load.PackagesAndErrors(ctx, args)
-       } else {
-               pkgs = load.Packages(ctx, args)
+       pkgs := load.PackagesAndErrors(ctx, args)
+       if !*listE {
+               w := 0
+               for _, pkg := range pkgs {
+                       if pkg.Error != nil {
+                               base.Errorf("%v", pkg.Error)
+                               continue
+                       }
+                       pkgs[w] = pkg
+                       w++
+               }
+               pkgs = pkgs[:w]
                base.ExitIfErrors()
        }
 
@@ -570,8 +585,6 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
                // Show vendor-expanded paths in listing
                p.TestImports = p.Resolve(p.TestImports)
                p.XTestImports = p.Resolve(p.XTestImports)
-               p.TestEmbedFiles = p.ResolveEmbed(p.TestEmbedPatterns)
-               p.XTestEmbedFiles = p.ResolveEmbed(p.XTestEmbedPatterns)
                p.DepOnly = !cmdline[p]
 
                if *listCompiled {

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 6f95af4f7e8d69b5a047cd71bb7c3c238494fef8..8b12faf4cd2e51d8665a838c68275dce87cba018 100644 (file)
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -36,6 +36,8 @@ import (
        "cmd/go/internal/str"
        "cmd/go/internal/trace"
        "cmd/internal/sys"
+
+       "golang.org/x/mod/module"
 )
 
 var IgnoreImports bool // control whether we ignore imports in packages
@@ -96,7 +98,7 @@ type PackagePublic struct {
 
        // Embedded files
        EmbedPatterns []string `json:",omitempty"` // //go:embed patterns
-       EmbedFiles    []string `json:",omitempty"` // files and directories matched by EmbedPatterns
+       EmbedFiles    []string `json:",omitempty"` // files matched by EmbedPatterns
 
        // Cgo directives
        CgoCFLAGS    []string `json:",omitempty"` // cgo: flags for C compiler
@@ -122,11 +124,11 @@ type PackagePublic struct {
        TestGoFiles        []string `json:",omitempty"` // _test.go files in package
        TestImports        []string `json:",omitempty"` // imports from TestGoFiles
        TestEmbedPatterns  []string `json:",omitempty"` // //go:embed patterns
-       TestEmbedFiles     []string `json:",omitempty"` // //files matched by EmbedPatterns
+       TestEmbedFiles     []string `json:",omitempty"` // files matched by TestEmbedPatterns
        XTestGoFiles       []string `json:",omitempty"` // _test.go files outside package
        XTestImports       []string `json:",omitempty"` // imports from XTestGoFiles
        XTestEmbedPatterns []string `json:",omitempty"` // //go:embed patterns
-       XTestEmbedFiles    []string `json:",omitempty"` // //files matched by EmbedPatterns
+       XTestEmbedFiles    []string `json:",omitempty"` // files matched by XTestEmbedPatterns
 }
 
 // AllFiles returns the names of all the files considered for the package.
@@ -304,7 +306,7 @@ func (p *Package) setLoadPackageDataError(err error, path string, stk *ImportSta
        }
 
        if path != stk.Top() {
-               p = setErrorPos(p, importPos)
+               p.Error.setPos(importPos)
        }
 }
 
@@ -412,6 +414,9 @@ type PackageError struct {
 }
 
 func (p *PackageError) Error() string {
+       // TODO(#43696): decide when to print the stack or the position based on
+       // the error type and whether the package is in the main module.
+       // Document the rationale.
        if p.Pos != "" && (len(p.ImportStack) == 0 || !p.alwaysPrintStack) {
                // Omit import stack. The full path to the file where the error
                // is the most important thing.
@@ -447,6 +452,15 @@ func (p *PackageError) MarshalJSON() ([]byte, error) {
        return json.Marshal(perr)
 }
 
+func (p *PackageError) setPos(posList []token.Position) {
+       if len(posList) == 0 {
+               return
+       }
+       pos := posList[0]
+       pos.Filename = base.ShortPath(pos.Filename)
+       p.Pos = pos.String()
+}
+
 // ImportPathError is a type of error that prevents a package from being loaded
 // for a given import path. When such a package is loaded, a *Package is
 // returned with Err wrapping an ImportPathError: the error is attached to
@@ -695,17 +709,19 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
                                Err:         ImportErrorf(path, "non-canonical import path %q: should be %q", path, pathpkg.Clean(path)),
                        }
                        p.Incomplete = true
-                       setErrorPos(p, importPos)
+                       p.Error.setPos(importPos)
                }
        }
 
        // Checked on every import because the rules depend on the code doing the importing.
        if perr := disallowInternal(srcDir, parent, parentPath, p, stk); perr != p {
-               return setErrorPos(perr, importPos)
+               perr.Error.setPos(importPos)
+               return perr
        }
        if mode&ResolveImport != 0 {
                if perr := disallowVendor(srcDir, path, parentPath, p, stk); perr != p {
-                       return setErrorPos(perr, importPos)
+                       perr.Error.setPos(importPos)
+                       return perr
                }
        }
 
@@ -715,7 +731,8 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
                        ImportStack: stk.Copy(),
                        Err:         ImportErrorf(path, "import %q is a program, not an importable package", path),
                }
-               return setErrorPos(&perr, importPos)
+               perr.Error.setPos(importPos)
+               return &perr
        }
 
        if p.Internal.Local && parent != nil && !parent.Internal.Local {
@@ -730,21 +747,13 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
                        ImportStack: stk.Copy(),
                        Err:         err,
                }
-               return setErrorPos(&perr, importPos)
+               perr.Error.setPos(importPos)
+               return &perr
        }
 
        return p
 }
 
-func setErrorPos(p *Package, importPos []token.Position) *Package {
-       if len(importPos) > 0 {
-               pos := importPos[0]
-               pos.Filename = base.ShortPath(pos.Filename)
-               p.Error.Pos = pos.String()
-       }
-       return p
-}
-
 // loadPackageData loads information needed to construct a *Package. The result
 // is cached, and later calls to loadPackageData for the same package will return
 // the same data.
@@ -769,11 +778,7 @@ func loadPackageData(path, parentPath, parentDir, parentRoot string, parentIsStd
        }
 
        if strings.Contains(path, "@") {
-               if cfg.ModulesEnabled {
-                       return nil, false, errors.New("can only use path@version syntax with 'go get'")
-               } else {
-                       return nil, false, errors.New("cannot use path@version syntax in GOPATH mode")
-               }
+               return nil, false, errors.New("can only use path@version syntax with 'go get' and 'go install' in module-aware mode")
        }
 
        // Determine canonical package path and directory.
@@ -1653,7 +1658,7 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
                        // must be either in an explicit command-line argument,
                        // or on the importer side (indicated by a non-empty importPos).
                        if path != stk.Top() && len(importPos) > 0 {
-                               p = setErrorPos(p, importPos)
+                               p.Error.setPos(importPos)
                        }
                }
        }
@@ -1663,11 +1668,6 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
                p.setLoadPackageDataError(err, path, stk, importPos)
        }
 
-       p.EmbedFiles, p.Internal.Embed, err = p.resolveEmbed(p.EmbedPatterns)
-       if err != nil {
-               setError(err)
-       }
-
        useBindir := p.Name == "main"
        if !p.Standard {
                switch cfg.BuildBuildmode {
@@ -1803,9 +1803,20 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
                return
        }
 
+       // Errors after this point are caused by this package, not the importing
+       // package. Pushing the path here prevents us from reporting the error
+       // with the position of the import declaration.
        stk.Push(path)
        defer stk.Pop()
 
+       p.EmbedFiles, p.Internal.Embed, err = resolveEmbed(p.Dir, p.EmbedPatterns)
+       if err != nil {
+               p.Incomplete = true
+               setError(err)
+               embedErr := err.(*EmbedError)
+               p.Error.setPos(p.Internal.Build.EmbedPatternPos[embedErr.Pattern])
+       }
+
        // Check for case-insensitive collision of input files.
        // To avoid problems on case-insensitive files, we reject any package
        // where two different input files have equal names under a case-insensitive
@@ -1909,35 +1920,62 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
        }
 }
 
+// An EmbedError indicates a problem with a go:embed directive.
+type EmbedError struct {
+       Pattern string
+       Err     error
+}
+
+func (e *EmbedError) Error() string {
+       return fmt.Sprintf("pattern %s: %v", e.Pattern, e.Err)
+}
+
+func (e *EmbedError) Unwrap() error {
+       return e.Err
+}
+
 // ResolveEmbed resolves //go:embed patterns and returns only the file list.
-// For use by go list to compute p.TestEmbedFiles and p.XTestEmbedFiles.
-func (p *Package) ResolveEmbed(patterns []string) []string {
-       files, _, _ := p.resolveEmbed(patterns)
-       return files
+// For use by go mod vendor to find embedded files it should copy into the
+// vendor directory.
+// TODO(#42504): Once go mod vendor uses load.PackagesAndErrors, just
+// call (*Package).ResolveEmbed
+func ResolveEmbed(dir string, patterns []string) ([]string, error) {
+       files, _, err := resolveEmbed(dir, patterns)
+       return files, err
 }
 
 // resolveEmbed resolves //go:embed patterns to precise file lists.
 // It sets files to the list of unique files matched (for go list),
 // and it sets pmap to the more precise mapping from
 // patterns to files.
-// TODO(rsc): All these messages need position information for better error reports.
-func (p *Package) resolveEmbed(patterns []string) (files []string, pmap map[string][]string, err error) {
+func resolveEmbed(pkgdir string, patterns []string) (files []string, pmap map[string][]string, err error) {
+       var pattern string
+       defer func() {
+               if err != nil {
+                       err = &EmbedError{
+                               Pattern: pattern,
+                               Err:     err,
+                       }
+               }
+       }()
+
+       // TODO(rsc): All these messages need position information for better error reports.
        pmap = make(map[string][]string)
        have := make(map[string]int)
        dirOK := make(map[string]bool)
        pid := 0 // pattern ID, to allow reuse of have map
-       for _, pattern := range patterns {
+       for _, pattern = range patterns {
                pid++
 
                // Check pattern is valid for //go:embed.
                if _, err := path.Match(pattern, ""); err != nil || !validEmbedPattern(pattern) {
-                       return nil, nil, fmt.Errorf("pattern %s: invalid pattern syntax", pattern)
+                       return nil, nil, fmt.Errorf("invalid pattern syntax")
                }
 
                // Glob to find matches.
-               match, err := fsys.Glob(p.Dir + string(filepath.Separator) + filepath.FromSlash(pattern))
+               match, err := fsys.Glob(pkgdir + string(filepath.Separator) + filepath.FromSlash(pattern))
                if err != nil {
-                       return nil, nil, fmt.Errorf("pattern %s: %v", pattern, err)
+                       return nil, nil, err
                }
 
                // Filter list of matches down to the ones that will still exist when
@@ -1946,7 +1984,7 @@ func (p *Package) resolveEmbed(patterns []string) (files []string, pmap map[stri
                // then there may be other things lying around, like symbolic links or .git directories.)
                var list []string
                for _, file := range match {
-                       rel := filepath.ToSlash(file[len(p.Dir)+1:]) // file, relative to p.Dir
+                       rel := filepath.ToSlash(file[len(pkgdir)+1:]) // file, relative to p.Dir
 
                        what := "file"
                        info, err := fsys.Lstat(file)
@@ -1959,28 +1997,28 @@ func (p *Package) resolveEmbed(patterns []string) (files []string, pmap map[stri
 
                        // Check that directories along path do not begin a new module
                        // (do not contain a go.mod).
-                       for dir := file; len(dir) > len(p.Dir)+1 && !dirOK[dir]; dir = filepath.Dir(dir) {
+                       for dir := file; len(dir) > len(pkgdir)+1 && !dirOK[dir]; dir = filepath.Dir(dir) {
                                if _, err := fsys.Stat(filepath.Join(dir, "go.mod")); err == nil {
-                                       return nil, nil, fmt.Errorf("pattern %s: cannot embed %s %s: in different module", pattern, what, rel)
+                                       return nil, nil, fmt.Errorf("cannot embed %s %s: in different module", what, rel)
                                }
                                if dir != file {
                                        if info, err := fsys.Lstat(dir); err == nil && !info.IsDir() {
-                                               return nil, nil, fmt.Errorf("pattern %s: cannot embed %s %s: in non-directory %s", pattern, what, rel, dir[len(p.Dir)+1:])
+                                               return nil, nil, fmt.Errorf("cannot embed %s %s: in non-directory %s", what, rel, dir[len(pkgdir)+1:])
                                        }
                                }
                                dirOK[dir] = true
                                if elem := filepath.Base(dir); isBadEmbedName(elem) {
                                        if dir == file {
-                                               return nil, nil, fmt.Errorf("pattern %s: cannot embed %s %s: invalid name %s", pattern, what, rel, elem)
+                                               return nil, nil, fmt.Errorf("cannot embed %s %s: invalid name %s", what, rel, elem)
                                        } else {
-                                               return nil, nil, fmt.Errorf("pattern %s: cannot embed %s %s: in invalid directory %s", pattern, what, rel, elem)
+                                               return nil, nil, fmt.Errorf("cannot embed %s %s: in invalid directory %s", what, rel, elem)
                                        }
                                }
                        }
 
                        switch {
                        default:
-                               return nil, nil, fmt.Errorf("pattern %s: cannot embed irregular file %s", pattern, rel)
+                               return nil, nil, fmt.Errorf("cannot embed irregular file %s", rel)
 
                        case info.Mode().IsRegular():
                                if have[rel] != pid {
@@ -1996,7 +2034,7 @@ func (p *Package) resolveEmbed(patterns []string) (files []string, pmap map[stri
                                        if err != nil {
                                                return err
                                        }
-                                       rel := filepath.ToSlash(path[len(p.Dir)+1:])
+                                       rel := filepath.ToSlash(path[len(pkgdir)+1:])
                                        name := info.Name()
                                        if path != file && (isBadEmbedName(name) || name[0] == '.' || name[0] == '_') {
                                                // Ignore bad names, assuming they won't go into modules.
@@ -2027,13 +2065,13 @@ func (p *Package) resolveEmbed(patterns []string) (files []string, pmap map[stri
                                        return nil, nil, err
                                }
                                if count == 0 {
-                                       return nil, nil, fmt.Errorf("pattern %s: cannot embed directory %s: contains no embeddable files", pattern, rel)
+                                       return nil, nil, fmt.Errorf("cannot embed directory %s: contains no embeddable files", rel)
                                }
                        }
                }
 
                if len(list) == 0 {
-                       return nil, nil, fmt.Errorf("pattern %s: no matching files found", pattern)
+                       return nil, nil, fmt.Errorf("no matching files found")
                }
                sort.Strings(list)
                pmap[pattern] = list
@@ -2054,6 +2092,9 @@ func validEmbedPattern(pattern string) bool {
 // can't or won't be included in modules and therefore shouldn't be treated
 // as existing for embedding.
 func isBadEmbedName(name string) bool {
+       if err := module.CheckFilePath(name); err != nil {
+               return true
+       }
        switch name {
        // Empty string should be impossible but make it bad.
        case "":
@@ -2314,30 +2355,14 @@ func LoadImportWithFlags(path, srcDir string, parent *Package, stk *ImportStack,
 // argument where needed.
 var ModResolveTests bool
 
-// Packages returns the packages named by the
-// command line arguments 'args'. If a named package
-// cannot be loaded at all (for example, if the directory does not exist),
-// then packages prints an error and does not include that
-// package in the results. However, if errors occur trying
-// to load dependencies of a named package, the named
-// package is still returned, with p.Incomplete = true
-// and details in p.DepsErrors.
-func Packages(ctx context.Context, args []string) []*Package {
-       var pkgs []*Package
-       for _, pkg := range PackagesAndErrors(ctx, args) {
-               if pkg.Error != nil {
-                       base.Errorf("%v", pkg.Error)
-                       continue
-               }
-               pkgs = append(pkgs, pkg)
-       }
-       return pkgs
-}
-
-// PackagesAndErrors is like 'packages' but returns a
-// *Package for every argument, even the ones that
-// cannot be loaded at all.
-// The packages that fail to load will have p.Error != nil.
+// PackagesAndErrors returns the packages named by the command line arguments
+// 'patterns'. If a named package cannot be loaded, PackagesAndErrors returns
+// a *Package with the Error field describing the failure. If errors are found
+// loading imported packages, the DepsErrors field is set. The Incomplete field
+// may be set as well.
+//
+// To obtain a flat list of packages, use PackageList.
+// To report errors loading packages, use ReportPackageErrors.
 func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
        ctx, span := trace.StartSpan(ctx, "load.PackagesAndErrors")
        defer span.Done()
@@ -2427,20 +2452,9 @@ func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
        return pkgs
 }
 
-func setToolFlags(pkgs ...*Package) {
-       for _, p := range PackageList(pkgs) {
-               p.Internal.Asmflags = BuildAsmflags.For(p)
-               p.Internal.Gcflags = BuildGcflags.For(p)
-               p.Internal.Ldflags = BuildLdflags.For(p)
-               p.Internal.Gccgoflags = BuildGccgoflags.For(p)
-       }
-}
-
-// PackagesForBuild is like Packages but exits
-// if any of the packages or their dependencies have errors
-// (cannot be built).
-func PackagesForBuild(ctx context.Context, args []string) []*Package {
-       pkgs := PackagesAndErrors(ctx, args)
+// CheckPackageErrors prints errors encountered loading pkgs and their
+// dependencies, then exits with a non-zero status if any errors were found.
+func CheckPackageErrors(pkgs []*Package) {
        printed := map[*PackageError]bool{}
        for _, pkg := range pkgs {
                if pkg.Error != nil {
@@ -2475,8 +2489,15 @@ func PackagesForBuild(ctx context.Context, args []string) []*Package {
                seen[pkg.ImportPath] = true
        }
        base.ExitIfErrors()
+}
 
-       return pkgs
+func setToolFlags(pkgs ...*Package) {
+       for _, p := range PackageList(pkgs) {
+               p.Internal.Asmflags = BuildAsmflags.For(p)
+               p.Internal.Gcflags = BuildGcflags.For(p)
+               p.Internal.Ldflags = BuildLdflags.For(p)
+               p.Internal.Gccgoflags = BuildGccgoflags.For(p)
+       }
 }
 
 // GoFilesPackage creates a package for building a collection of Go files

diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 5053ad767bc4b63d36c7088156be05a3b55f19c3..f5d66290922ac977eac93305250013b3f9f839f8 100644 (file)
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -124,12 +124,14 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
                imports = append(imports, p1)
        }
        var err error
-       p.TestEmbedFiles, testEmbed, err = p.resolveEmbed(p.TestEmbedPatterns)
+       p.TestEmbedFiles, testEmbed, err = resolveEmbed(p.Dir, p.TestEmbedPatterns)
        if err != nil && ptestErr == nil {
                ptestErr = &PackageError{
                        ImportStack: stk.Copy(),
                        Err:         err,
                }
+               embedErr := err.(*EmbedError)
+               ptestErr.setPos(p.Internal.Build.TestEmbedPatternPos[embedErr.Pattern])
        }
        stk.Pop()
 
@@ -145,12 +147,14 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
                }
                p.XTestImports[i] = p1.ImportPath
        }
-       p.XTestEmbedFiles, xtestEmbed, err = p.resolveEmbed(p.XTestEmbedPatterns)
+       p.XTestEmbedFiles, xtestEmbed, err = resolveEmbed(p.Dir, p.XTestEmbedPatterns)
        if err != nil && pxtestErr == nil {
                pxtestErr = &PackageError{
                        ImportStack: stk.Copy(),
                        Err:         err,
                }
+               embedErr := err.(*EmbedError)
+               pxtestErr.setPos(p.Internal.Build.XTestEmbedPatternPos[embedErr.Pattern])
        }
        stk.Pop()
 

diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index ef1ad780c81bec3070f7bd8957cc5f8bee8ffb71..e7d3d869cbcf0e0de5d951979f746565c18191ce 100644 (file)
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -52,7 +52,9 @@ corresponding to this Go struct:
 
 The -x flag causes download to print the commands download executes.
 
-See 'go help modules' for more about module queries.
+See https://golang.org/ref/mod#go-mod-download for more about 'go mod download'.
+
+See https://golang.org/ref/mod#version-queries for more about version queries.
        `,
 }
 

diff --git a/src/cmd/go/internal/modcmd/edit.go b/src/cmd/go/internal/modcmd/edit.go
index b203a8a2b0a6f3b19a82bb63e2de8ef807d2c9af..1df104eb1dd54954a9670c5ee86a3372a2417067 100644 (file)
--- a/src/cmd/go/internal/modcmd/edit.go
+++ b/src/cmd/go/internal/modcmd/edit.go
@@ -95,6 +95,7 @@ writing it back to go.mod. The JSON output corresponds to these Go types:
                Require []Require
                Exclude []Module
                Replace []Replace
+               Retract []Retract
        }
 
        type Require struct {
@@ -121,9 +122,7 @@ Note that this only describes the go.mod file itself, not other modules
 referred to indirectly. For the full set of modules available to a build,
 use 'go list -m -json all'.
 
-For example, a tool can obtain the go.mod as a data structure by
-parsing the output of 'go mod edit -json' and can then make changes
-by invoking 'go mod edit' with -require, -exclude, and so on.
+See https://golang.org/ref/mod#go-mod-edit for more about 'go mod edit'.
        `,
 }
 

diff --git a/src/cmd/go/internal/modcmd/graph.go b/src/cmd/go/internal/modcmd/graph.go
index 3277548c235f9297b96f5b15fb3cf8a4995631f4..a88e9ef4557ad3459cfe9db87f8af3fc63b2f591 100644 (file)
--- a/src/cmd/go/internal/modcmd/graph.go
+++ b/src/cmd/go/internal/modcmd/graph.go
@@ -26,6 +26,8 @@ Graph prints the module requirement graph (with replacements applied)
 in text form. Each line in the output has two space-separated fields: a module
 and one of its requirements. Each module is identified as a string of the form
 path@version, except for the main module, which has no @version suffix.
+
+See https://golang.org/ref/mod#go-mod-graph for more about 'go mod graph'.
        `,
        Run: runGraph,
 }

diff --git a/src/cmd/go/internal/modcmd/init.go b/src/cmd/go/internal/modcmd/init.go
index c081bb547d14c7571ba7b2511f13a3eaabec84a5..73cc282d81408a18dee2f405891fbc68813a7dc0 100644 (file)
--- a/src/cmd/go/internal/modcmd/init.go
+++ b/src/cmd/go/internal/modcmd/init.go
@@ -27,6 +27,8 @@ Gopkg.lock), and the current directory (if in GOPATH).
 
 If a configuration file for a vendoring tool is present, init will attempt to
 import module requirements from it.
+
+See https://golang.org/ref/mod#go-mod-init for more about 'go mod init'.
 `,
        Run: runInit,
 }

diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index fb43e33ec58e3a768e0388b70ace05553179ccef..3b83d87a8eb6fecf5693a49891c33fdf16bb672f 100644 (file)
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -29,6 +29,8 @@ to standard error.
 
 The -e flag causes tidy to attempt to proceed despite errors
 encountered while loading packages.
+
+See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
        `,
        Run: runTidy,
 }

diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index 1bbb57d353ba6ce2f73b44ac33e5627733b081c0..d3ed9e00e229a2021c4d7a4c3ea8a544d0ad654f 100644 (file)
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -7,7 +7,9 @@ package modcmd
 import (
        "bytes"
        "context"
+       "errors"
        "fmt"
+       "go/build"
        "io"
        "io/fs"
        "os"
@@ -19,7 +21,9 @@ import (
        "cmd/go/internal/cfg"
        "cmd/go/internal/fsys"
        "cmd/go/internal/imports"
+       "cmd/go/internal/load"
        "cmd/go/internal/modload"
+       "cmd/go/internal/str"
 
        "golang.org/x/mod/module"
        "golang.org/x/mod/semver"
@@ -38,6 +42,8 @@ modules and packages to standard error.
 
 The -e flag causes vendor to attempt to proceed despite errors
 encountered while loading packages.
+
+See https://golang.org/ref/mod#go-mod-vendor for more about 'go mod vendor'.
        `,
        Run: runVendor,
 }
@@ -180,19 +186,76 @@ func moduleLine(m, r module.Version) string {
 }
 
 func vendorPkg(vdir, pkg string) {
+       // TODO(#42504): Instead of calling modload.ImportMap then build.ImportDir,
+       // just call load.PackagesAndErrors. To do that, we need to add a good way
+       // to ignore build constraints.
        realPath := modload.ImportMap(pkg)
        if realPath != pkg && modload.ImportMap(realPath) != "" {
                fmt.Fprintf(os.Stderr, "warning: %s imported as both %s and %s; making two copies.\n", realPath, realPath, pkg)
        }
 
+       copiedFiles := make(map[string]bool)
        dst := filepath.Join(vdir, pkg)
        src := modload.PackageDir(realPath)
        if src == "" {
                fmt.Fprintf(os.Stderr, "internal error: no pkg for %s -> %s\n", pkg, realPath)
        }
-       copyDir(dst, src, matchPotentialSourceFile)
+       copyDir(dst, src, matchPotentialSourceFile, copiedFiles)
        if m := modload.PackageModule(realPath); m.Path != "" {
-               copyMetadata(m.Path, realPath, dst, src)
+               copyMetadata(m.Path, realPath, dst, src, copiedFiles)
+       }
+
+       ctx := build.Default
+       ctx.UseAllFiles = true
+       bp, err := ctx.ImportDir(src, build.IgnoreVendor)
+       // Because UseAllFiles is set on the build.Context, it's possible ta get
+       // a MultiplePackageError on an otherwise valid package: the package could
+       // have different names for GOOS=windows and GOOS=mac for example. On the
+       // other hand if there's a NoGoError, the package might have source files
+       // specifying "// +build ignore" those packages should be skipped because
+       // embeds from ignored files can't be used.
+       // TODO(#42504): Find a better way to avoid errors from ImportDir. We'll
+       // need to figure this out when we switch to PackagesAndErrors as per the
+       // TODO above.
+       var multiplePackageError *build.MultiplePackageError
+       var noGoError *build.NoGoError
+       if err != nil {
+               if errors.As(err, &noGoError) {
+                       return // No source files in this package are built. Skip embeds in ignored files.
+               } else if !errors.As(err, &multiplePackageError) { // multiplePackgeErrors are okay, but others are not.
+                       base.Fatalf("internal error: failed to find embedded files of %s: %v\n", pkg, err)
+               }
+       }
+       embedPatterns := str.StringList(bp.EmbedPatterns, bp.TestEmbedPatterns, bp.XTestEmbedPatterns)
+       embeds, err := load.ResolveEmbed(bp.Dir, embedPatterns)
+       if err != nil {
+               base.Fatalf("go mod vendor: %v", err)
+       }
+       for _, embed := range embeds {
+               embedDst := filepath.Join(dst, embed)
+               if copiedFiles[embedDst] {
+                       continue
+               }
+
+               // Copy the file as is done by copyDir below.
+               r, err := os.Open(filepath.Join(src, embed))
+               if err != nil {
+                       base.Fatalf("go mod vendor: %v", err)
+               }
+               if err := os.MkdirAll(filepath.Dir(embedDst), 0777); err != nil {
+                       base.Fatalf("go mod vendor: %v", err)
+               }
+               w, err := os.Create(embedDst)
+               if err != nil {
+                       base.Fatalf("go mod vendor: %v", err)
+               }
+               if _, err := io.Copy(w, r); err != nil {
+                       base.Fatalf("go mod vendor: %v", err)
+               }
+               r.Close()
+               if err := w.Close(); err != nil {
+                       base.Fatalf("go mod vendor: %v", err)
+               }
        }
 }
 
@@ -205,14 +268,14 @@ var copiedMetadata = make(map[metakey]bool)
 
 // copyMetadata copies metadata files from parents of src to parents of dst,
 // stopping after processing the src parent for modPath.
-func copyMetadata(modPath, pkg, dst, src string) {
+func copyMetadata(modPath, pkg, dst, src string, copiedFiles map[string]bool) {
        for parent := 0; ; parent++ {
                if copiedMetadata[metakey{modPath, dst}] {
                        break
                }
                copiedMetadata[metakey{modPath, dst}] = true
                if parent > 0 {
-                       copyDir(dst, src, matchMetadata)
+                       copyDir(dst, src, matchMetadata, copiedFiles)
                }
                if modPath == pkg {
                        break
@@ -280,7 +343,7 @@ func matchPotentialSourceFile(dir string, info fs.DirEntry) bool {
 }
 
 // copyDir copies all regular files satisfying match(info) from src to dst.
-func copyDir(dst, src string, match func(dir string, info fs.DirEntry) bool) {
+func copyDir(dst, src string, match func(dir string, info fs.DirEntry) bool, copiedFiles map[string]bool) {
        files, err := os.ReadDir(src)
        if err != nil {
                base.Fatalf("go mod vendor: %v", err)
@@ -292,11 +355,14 @@ func copyDir(dst, src string, match func(dir string, info fs.DirEntry) bool) {
                if file.IsDir() || !file.Type().IsRegular() || !match(src, file) {
                        continue
                }
+               copiedFiles[file.Name()] = true
                r, err := os.Open(filepath.Join(src, file.Name()))
                if err != nil {
                        base.Fatalf("go mod vendor: %v", err)
                }
-               w, err := os.Create(filepath.Join(dst, file.Name()))
+               dstPath := filepath.Join(dst, file.Name())
+               copiedFiles[dstPath] = true
+               w, err := os.Create(dstPath)
                if err != nil {
                        base.Fatalf("go mod vendor: %v", err)
                }

diff --git a/src/cmd/go/internal/modcmd/verify.go b/src/cmd/go/internal/modcmd/verify.go
index c83e70076ae2cc06fb4009b57e29c79f5d955e6d..832142913108976469a87a5ec4688b1ce9ae611a 100644 (file)
--- a/src/cmd/go/internal/modcmd/verify.go
+++ b/src/cmd/go/internal/modcmd/verify.go
@@ -31,6 +31,8 @@ modified since being downloaded. If all the modules are unmodified,
 verify prints "all modules verified." Otherwise it reports which
 modules have been changed and causes 'go mod' to exit with a
 non-zero status.
+
+See https://golang.org/ref/mod#go-mod-verify for more about 'go mod verify'.
        `,
        Run: runVerify,
 }

diff --git a/src/cmd/go/internal/modcmd/why.go b/src/cmd/go/internal/modcmd/why.go
index e287c8806017123420928d23d0f612b13de6c090..a5f3e8afcbe3a52072e7265eecb7e117f9dabc78 100644 (file)
--- a/src/cmd/go/internal/modcmd/why.go
+++ b/src/cmd/go/internal/modcmd/why.go
@@ -48,6 +48,8 @@ For example:
        # golang.org/x/text/encoding
        (main module does not need package golang.org/x/text/encoding)
        $
+
+See https://golang.org/ref/mod#go-mod-why for more about 'go mod why'.
        `,
 }
 

diff --git a/src/cmd/go/internal/modfetch/codehost/codehost.go b/src/cmd/go/internal/modfetch/codehost/codehost.go
index 86c1c14d4a7ad643f5fd30d0aae095ad878b7da1..378fbae34f9530378ced67a8298f797891af9e72 100644 (file)
--- a/src/cmd/go/internal/modfetch/codehost/codehost.go
+++ b/src/cmd/go/internal/modfetch/codehost/codehost.go
@@ -10,10 +10,10 @@ import (
        "bytes"
        "crypto/sha256"
        "fmt"
+       exec "internal/execabs"
        "io"
        "io/fs"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
        "sync"

diff --git a/src/cmd/go/internal/modfetch/codehost/git.go b/src/cmd/go/internal/modfetch/codehost/git.go
index 8abc039e7fc0688a1b002a34f95109182bdef0a1..72005e27d5eb83e75d56053dae51e64eb8ea63c8 100644 (file)
--- a/src/cmd/go/internal/modfetch/codehost/git.go
+++ b/src/cmd/go/internal/modfetch/codehost/git.go
@@ -8,11 +8,11 @@ import (
        "bytes"
        "errors"
        "fmt"
+       exec "internal/execabs"
        "io"
        "io/fs"
        "net/url"
        "os"
-       "os/exec"
        "path/filepath"
        "sort"
        "strconv"

diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index debeb3f3194114ea6f81e071aebdba78c95a5e0f..c55c3cf2534bfe116f3005231b002e56e6959a0f 100644 (file)
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -768,90 +768,14 @@ var HelpModuleAuth = &base.Command{
        UsageLine: "module-auth",
        Short:     "module authentication using go.sum",
        Long: `
-The go command tries to authenticate every downloaded module,
-checking that the bits downloaded for a specific module version today
-match bits downloaded yesterday. This ensures repeatable builds
-and detects introduction of unexpected changes, malicious or not.
-
-In each module's root, alongside go.mod, the go command maintains
-a file named go.sum containing the cryptographic checksums of the
-module's dependencies.
-
-The form of each line in go.sum is three fields:
-
-       <module> <version>[/go.mod] <hash>
-
-Each known module version results in two lines in the go.sum file.
-The first line gives the hash of the module version's file tree.
-The second line appends "/go.mod" to the version and gives the hash
-of only the module version's (possibly synthesized) go.mod file.
-The go.mod-only hash allows downloading and authenticating a
-module version's go.mod file, which is needed to compute the
-dependency graph, without also downloading all the module's source code.
-
-The hash begins with an algorithm prefix of the form "h<N>:".
-The only defined algorithm prefix is "h1:", which uses SHA-256.
-
-Module authentication failures
-
-The go command maintains a cache of downloaded packages and computes
-and records the cryptographic checksum of each package at download time.
-In normal operation, the go command checks the main module's go.sum file
-against these precomputed checksums instead of recomputing them on
-each command invocation. The 'go mod verify' command checks that
-the cached copies of module downloads still match both their recorded
-checksums and the entries in go.sum.
-
-In day-to-day development, the checksum of a given module version
-should never change. Each time a dependency is used by a given main
-module, the go command checks its local cached copy, freshly
-downloaded or not, against the main module's go.sum. If the checksums
-don't match, the go command reports the mismatch as a security error
-and refuses to run the build. When this happens, proceed with caution:
-code changing unexpectedly means today's build will not match
-yesterday's, and the unexpected change may not be beneficial.
-
-If the go command reports a mismatch in go.sum, the downloaded code
-for the reported module version does not match the one used in a
-previous build of the main module. It is important at that point
-to find out what the right checksum should be, to decide whether
-go.sum is wrong or the downloaded code is wrong. Usually go.sum is right:
-you want to use the same code you used yesterday.
-
-If a downloaded module is not yet included in go.sum and it is a publicly
-available module, the go command consults the Go checksum database to fetch
-the expected go.sum lines. If the downloaded code does not match those
-lines, the go command reports the mismatch and exits. Note that the
-database is not consulted for module versions already listed in go.sum.
-
-If a go.sum mismatch is reported, it is always worth investigating why
-the code downloaded today differs from what was downloaded yesterday.
-
-The GOSUMDB environment variable identifies the name of checksum database
-to use and optionally its public key and URL, as in:
-
-       GOSUMDB="sum.golang.org"
-       GOSUMDB="sum.golang.org+<publickey>"
-       GOSUMDB="sum.golang.org+<publickey> https://sum.golang.org"
-
-The go command knows the public key of sum.golang.org, and also that the name
-sum.golang.google.cn (available inside mainland China) connects to the
-sum.golang.org checksum database; use of any other database requires giving
-the public key explicitly.
-The URL defaults to "https://" followed by the database name.
-
-GOSUMDB defaults to "sum.golang.org", the Go checksum database run by Google.
-See https://sum.golang.org/privacy for the service's privacy policy.
-
-If GOSUMDB is set to "off", or if "go get" is invoked with the -insecure flag,
-the checksum database is not consulted, and all unrecognized modules are
-accepted, at the cost of giving up the security guarantee of verified repeatable
-downloads for all modules. A better way to bypass the checksum database
-for specific modules is to use the GOPRIVATE or GONOSUMDB environment
-variables. See 'go help private' for details.
-
-The 'go env -w' command (see 'go help env') can be used to set these variables
-for future go command invocations.
+When the go command downloads a module zip file or go.mod file into the
+module cache, it computes a cryptographic hash and compares it with a known
+value to verify the file hasn't changed since it was first downloaded. Known
+hashes are stored in a file in the module root directory named go.sum. Hashes
+may also be downloaded from the checksum database depending on the values of
+GOSUMDB, GOPRIVATE, and GONOSUMDB.
+
+For details, see https://golang.org/ref/mod#authenticating.
 `,
 }
 
@@ -865,8 +789,8 @@ regardless of source, against the public Go checksum database at sum.golang.org.
 These defaults work well for publicly available source code.
 
 The GOPRIVATE environment variable controls which modules the go command
-considers to be private (not available publicly) and should therefore not use the
-proxy or checksum database. The variable is a comma-separated list of
+considers to be private (not available publicly) and should therefore not use
+the proxy or checksum database. The variable is a comma-separated list of
 glob patterns (in the syntax of Go's path.Match) of module path prefixes.
 For example,
 
@@ -876,10 +800,6 @@ causes the go command to treat as private any module with a path prefix
 matching either pattern, including git.corp.example.com/xyzzy, rsc.io/private,
 and rsc.io/private/quux.
 
-The GOPRIVATE environment variable may be used by other tools as well to
-identify non-public modules. For example, an editor could use GOPRIVATE
-to decide whether to hyperlink a package import to a godoc.org page.
-
 For fine-grained control over module download and validation, the GONOPROXY
 and GONOSUMDB environment variables accept the same kind of glob list
 and override GOPRIVATE for the specific decision of whether to use the proxy
@@ -892,12 +812,6 @@ users would configure go using:
        GOPROXY=proxy.example.com
        GONOPROXY=none
 
-This would tell the go command and other tools that modules beginning with
-a corp.example.com subdomain are private but that the company proxy should
-be used for downloading both public and private modules, because
-GONOPROXY has been set to a pattern that won't match any modules,
-overriding GOPRIVATE.
-
 The GOPRIVATE variable is also used to define the "public" and "private"
 patterns for the GOVCS variable; see 'go help vcs'. For that usage,
 GOPRIVATE applies even in GOPATH mode. In that case, it matches import paths
@@ -905,5 +819,7 @@ instead of module paths.
 
 The 'go env -w' command (see 'go help env') can be used to set these variables
 for future go command invocations.
+
+For more details, see https://golang.org/ref/mod#private-modules.
 `,
 }

diff --git a/src/cmd/go/internal/modfetch/proxy.go b/src/cmd/go/internal/modfetch/proxy.go
index d75b4da52157a326283b0123abd96f89b98536ef..6c86d8d786d94a161f509a66fffcfbc9bb00189c 100644 (file)
--- a/src/cmd/go/internal/modfetch/proxy.go
+++ b/src/cmd/go/internal/modfetch/proxy.go
@@ -36,65 +36,8 @@ URLs of a specified form. The requests have no query parameters, so even
 a site serving from a fixed file system (including a file:/// URL)
 can be a module proxy.
 
-The GET requests sent to a Go module proxy are:
-
-GET $GOPROXY/<module>/@v/list returns a list of known versions of the given
-module, one per line.
-
-GET $GOPROXY/<module>/@v/<version>.info returns JSON-formatted metadata
-about that version of the given module.
-
-GET $GOPROXY/<module>/@v/<version>.mod returns the go.mod file
-for that version of the given module.
-
-GET $GOPROXY/<module>/@v/<version>.zip returns the zip archive
-for that version of the given module.
-
-GET $GOPROXY/<module>/@latest returns JSON-formatted metadata about the
-latest known version of the given module in the same format as
-<module>/@v/<version>.info. The latest version should be the version of
-the module the go command may use if <module>/@v/list is empty or no
-listed version is suitable. <module>/@latest is optional and may not
-be implemented by a module proxy.
-
-When resolving the latest version of a module, the go command will request
-<module>/@v/list, then, if no suitable versions are found, <module>/@latest.
-The go command prefers, in order: the semantically highest release version,
-the semantically highest pre-release version, and the chronologically
-most recent pseudo-version. In Go 1.12 and earlier, the go command considered
-pseudo-versions in <module>/@v/list to be pre-release versions, but this is
-no longer true since Go 1.13.
-
-To avoid problems when serving from case-sensitive file systems,
-the <module> and <version> elements are case-encoded, replacing every
-uppercase letter with an exclamation mark followed by the corresponding
-lower-case letter: github.com/Azure encodes as github.com/!azure.
-
-The JSON-formatted metadata about a given module corresponds to
-this Go data structure, which may be expanded in the future:
-
-    type Info struct {
-        Version string    // version string
-        Time    time.Time // commit time
-    }
-
-The zip archive for a specific version of a given module is a
-standard zip file that contains the file tree corresponding
-to the module's source code and related files. The archive uses
-slash-separated paths, and every file path in the archive must
-begin with <module>@<version>/, where the module and version are
-substituted directly, not case-encoded. The root of the module
-file tree corresponds to the <module>@<version>/ prefix in the
-archive.
-
-Even when downloading directly from version control systems,
-the go command synthesizes explicit info, mod, and zip files
-and stores them in its local cache, $GOPATH/pkg/mod/cache/download,
-the same as if it had downloaded them directly from a proxy.
-The cache layout is the same as the proxy URL space, so
-serving $GOPATH/pkg/mod/cache/download at (or copying it to)
-https://example.com/proxy would let other users access those
-cached module versions with GOPROXY=https://example.com/proxy.
+For details on the GOPROXY protocol, see
+https://golang.org/ref/mod#goproxy-protocol.
 `,
 }
 

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index e5f55879ee7396bd71ed9e811ba0644e6fbe31cb..6b328d8bc82789980e8d295f5a9c4e89eb40c9a8 100644 (file)
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -56,85 +56,49 @@ var CmdGet = &base.Command{
        UsageLine: "go get [-d] [-t] [-u] [-v] [-insecure] [build flags] [packages]",
        Short:     "add dependencies to current module and install them",
        Long: `
-Get resolves and adds dependencies to the current development module
-and then builds and installs them.
-
-The first step is to resolve which dependencies to add.
-
-For each named package or package pattern, get must decide which version of
-the corresponding module to use. By default, get looks up the latest tagged
-release version, such as v0.4.5 or v1.2.3. If there are no tagged release
-versions, get looks up the latest tagged pre-release version, such as
-v0.0.1-pre1. If there are no tagged versions at all, get looks up the latest
-known commit. If the module is not already required at a later version
-(for example, a pre-release newer than the latest release), get will use
-the version it looked up. Otherwise, get will use the currently
-required version.
-
-This default version selection can be overridden by adding an @version
-suffix to the package argument, as in 'go get golang.org/x/text@v0.3.0'.
-The version may be a prefix: @v1 denotes the latest available version starting
-with v1. See 'go help modules' under the heading 'Module queries' for the
-full query syntax.
-
-For modules stored in source control repositories, the version suffix can
-also be a commit hash, branch identifier, or other syntax known to the
-source control system, as in 'go get golang.org/x/text@master'. Note that
-branches with names that overlap with other module query syntax cannot be
-selected explicitly. For example, the suffix @v2 means the latest version
-starting with v2, not the branch named v2.
-
-If a module under consideration is already a dependency of the current
-development module, then get will update the required version.
-Specifying a version earlier than the current required version is valid and
-downgrades the dependency. The version suffix @none indicates that the
-dependency should be removed entirely, downgrading or removing modules
-depending on it as needed.
-
-The version suffix @latest explicitly requests the latest minor release of
-the module named by the given path. The suffix @upgrade is like @latest but
-will not downgrade a module if it is already required at a revision or
-pre-release version newer than the latest released version. The suffix
-@patch requests the latest patch release: the latest released version
-with the same major and minor version numbers as the currently required
-version. Like @upgrade, @patch will not downgrade a module already required
-at a newer version. If the path is not already required, @upgrade is
-equivalent to @latest, and @patch is disallowed.
-
-Although get defaults to using the latest version of the module containing
-a named package, it does not use the latest version of that module's
-dependencies. Instead it prefers to use the specific dependency versions
-requested by that module. For example, if the latest A requires module
-B v1.2.3, while B v1.2.4 and v1.3.1 are also available, then 'go get A'
-will use the latest A but then use B v1.2.3, as requested by A. (If there
-are competing requirements for a particular module, then 'go get' resolves
-those requirements by taking the maximum requested version.)
+Get resolves its command-line arguments to packages at specific module versions,
+updates go.mod to require those versions, downloads source code into the
+module cache, then builds and installs the named packages.
+
+To add a dependency for a package or upgrade it to its latest version:
+
+       go get example.com/pkg
+
+To upgrade or downgrade a package to a specific version:
+
+       go get example.com/pkg@v1.2.3
+
+To remove a dependency on a module and downgrade modules that require it:
+
+       go get example.com/mod@none
+
+See https://golang.org/ref/mod#go-get for details.
+
+The 'go install' command may be used to build and install packages. When a
+version is specified, 'go install' runs in module-aware mode and ignores
+the go.mod file in the current directory. For example:
+
+       go install example.com/pkg@v1.2.3
+       go install example.com/pkg@latest
+
+See 'go help install' or https://golang.org/ref/mod#go-install for details.
+
+In addition to build flags (listed in 'go help build') 'go get' accepts the
+following flags.
 
 The -t flag instructs get to consider modules needed to build tests of
 packages specified on the command line.
 
 The -u flag instructs get to update modules providing dependencies
 of packages named on the command line to use newer minor or patch
-releases when available. Continuing the previous example, 'go get -u A'
-will use the latest A with B v1.3.1 (not B v1.2.3). If B requires module C,
-but C does not provide any packages needed to build packages in A
-(not including tests), then C will not be updated.
+releases when available.
 
 The -u=patch flag (not -u patch) also instructs get to update dependencies,
 but changes the default to select patch releases.
-Continuing the previous example,
-'go get -u=patch A@latest' will use the latest A with B v1.2.4 (not B v1.2.3),
-while 'go get -u=patch A' will use a patch release of A instead.
 
 When the -t and -u flags are used together, get will update
 test dependencies as well.
 
-In general, adding a new dependency may require upgrading
-existing dependencies to keep a working build, and 'go get' does
-this automatically. Similarly, downgrading one dependency may
-require downgrading other dependencies, and 'go get' does
-this automatically as well.
-
 The -insecure flag permits fetching from repositories and resolving
 custom domains using insecure schemes such as HTTP, and also bypassess
 module sum validation using the checksum database. Use with caution.
@@ -143,12 +107,8 @@ To permit the use of insecure schemes, use the GOINSECURE environment
 variable instead. To bypass module sum validation, use GOPRIVATE or
 GONOSUMDB. See 'go help environment' for details.
 
-The second step is to download (if needed), build, and install
-the named packages.
-
-The -d flag instructs get to skip this step, downloading source code
-needed to build the named packages and their dependencies, but not
-building or installing.
+The -d flag instructs get not to build or install packages. get will only
+update go.mod and download source code needed to build packages.
 
 Building and installing packages with get is deprecated. In a future release,
 the -d flag will be enabled by default, and 'go get' will be only be used to
@@ -157,31 +117,14 @@ dependencies from the current module, use 'go install'. To install a package
 ignoring the current module, use 'go install' with an @version suffix like
 "@latest" after each argument.
 
-If an argument names a module but not a package (because there is no
-Go source code in the module's root directory), then the install step
-is skipped for that argument, instead of causing a build failure.
-For example 'go get golang.org/x/perf' succeeds even though there
-is no code corresponding to that import path.
-
-Note that package patterns are allowed and are expanded after resolving
-the module versions. For example, 'go get golang.org/x/perf/cmd/...'
-adds the latest golang.org/x/perf and then installs the commands in that
-latest version.
-
-With no package arguments, 'go get' applies to Go package in the
-current directory, if any. In particular, 'go get -u' and
-'go get -u=patch' update all the dependencies of that package.
-With no package arguments and also without -u, 'go get' is not much more
-than 'go install', and 'go get -d' not much more than 'go list'.
-
-For more about modules, see 'go help modules'.
+For more about modules, see https://golang.org/ref/mod.
 
 For more about specifying packages, see 'go help packages'.
 
 This text describes the behavior of get using modules to manage source
 code and dependencies. If instead the go command is running in GOPATH
 mode, the details of get's flags and effects change, as does 'go help get'.
-See 'go help modules' and 'go help gopath-get'.
+See 'go help gopath-get'.
 
 See also: go build, go install, go clean, go mod.
        `,
@@ -233,20 +176,23 @@ packages or when the mirror refuses to serve a public package (typically for
 legal reasons). Therefore, clients can still access public code served from
 Bazaar, Fossil, or Subversion repositories by default, because those downloads
 use the Go module mirror, which takes on the security risk of running the
-version control commands, using a custom sandbox.
+version control commands using a custom sandbox.
 
 The GOVCS variable can be used to change the allowed version control systems
 for specific packages (identified by a module or import path).
-The GOVCS variable applies both when using modules and when using GOPATH.
-When using modules, the patterns match against the module path.
-When using GOPATH, the patterns match against the import path
-corresponding to the root of the version control repository.
+The GOVCS variable applies when building package in both module-aware mode
+and GOPATH mode. When using modules, the patterns match against the module path.
+When using GOPATH, the patterns match against the import path corresponding to
+the root of the version control repository.
 
 The general form of the GOVCS setting is a comma-separated list of
 pattern:vcslist rules. The pattern is a glob pattern that must match
 one or more leading elements of the module or import path. The vcslist
 is a pipe-separated list of allowed version control commands, or "all"
-to allow use of any known command, or "off" to allow nothing.
+to allow use of any known command, or "off" to disallow all commands.
+Note that if a module matches a pattern with vcslist "off", it may still be
+downloaded if the origin server uses the "mod" scheme, which instructs the
+go command to download the module using the GOPROXY protocol.
 The earliest matching pattern in the list applies, even if later patterns
 might also match.
 
@@ -254,7 +200,7 @@ For example, consider:
 
        GOVCS=github.com:git,evil.com:off,*:git|hg
 
-With this setting, code with an module or import path beginning with
+With this setting, code with a module or import path beginning with
 github.com/ can only use git; paths on evil.com cannot use any version
 control command, and all other paths (* matches everything) can use
 only git or hg.
@@ -364,7 +310,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
                r.performWildcardQueries(ctx)
                r.performPatternAllQueries(ctx)
 
-               if changed := r.resolveCandidates(ctx, queries, nil); changed {
+               if changed := r.resolveQueries(ctx, queries); changed {
                        // 'go get' arguments can be (and often are) package patterns rather than
                        // (just) modules. A package can be provided by any module with a prefix
                        // of its import path, and a wildcard can even match packages in modules
@@ -401,12 +347,12 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
                // - ambiguous import errors.
                //   TODO(#27899): Try to resolve ambiguous import errors automatically.
                upgrades := r.findAndUpgradeImports(ctx, queries)
-               if changed := r.resolveCandidates(ctx, nil, upgrades); changed {
+               if changed := r.applyUpgrades(ctx, upgrades); changed {
                        continue
                }
 
                r.findMissingWildcards(ctx)
-               if changed := r.resolveCandidates(ctx, r.wildcardQueries, nil); changed {
+               if changed := r.resolveQueries(ctx, r.wildcardQueries); changed {
                        continue
                }
 
@@ -434,11 +380,12 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
        // directory.
        if !*getD && len(pkgPatterns) > 0 {
                work.BuildInit()
-               pkgs := load.PackagesForBuild(ctx, pkgPatterns)
+               pkgs := load.PackagesAndErrors(ctx, pkgPatterns)
+               load.CheckPackageErrors(pkgs)
                work.InstallPackages(ctx, pkgPatterns, pkgs)
-               // TODO(#40276): After Go 1.16, print a deprecation notice when building
-               // and installing main packages. 'go install pkg' or
-               // 'go install pkg@version' should be used instead.
+               // TODO(#40276): After Go 1.16, print a deprecation notice when building and
+               // installing main packages. 'go install pkg' or 'go install pkg@version'
+               // should be used instead. Give the specific argument to use if possible.
        }
 
        if !modload.HasModRoot() {
@@ -513,9 +460,8 @@ type resolver struct {
        // that resolved the module to that version (the “reason”).
        resolvedVersion map[string]versionReason
 
-       buildList                 []module.Version
-       buildListResolvedVersions int               // len(resolvedVersion) when buildList was computed
-       buildListVersion          map[string]string // index of buildList (module path → version)
+       buildList        []module.Version
+       buildListVersion map[string]string // index of buildList (module path → version)
 
        initialVersion map[string]string // index of the initial build list at the start of 'go get'
 
@@ -1229,24 +1175,19 @@ func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPack
 // to be updated before its dependencies can be loaded.
 var errVersionChange = errors.New("version change needed")
 
-// resolveCandidates resolves candidates sets that are attached to the given
+// resolveQueries resolves candidate sets that are attached to the given
 // queries and/or needed to provide the given missing-package dependencies.
 //
-// resolveCandidates starts by resolving one module version from each
+// resolveQueries starts by resolving one module version from each
 // unambiguous pathSet attached to the given queries.
 //
 // If no unambiguous query results in a change to the build list,
-// resolveCandidates modifies the build list by adding one module version from
-// each pathSet in missing, but does not mark those versions as resolved
-// (so they can still be modified by other queries).
-//
-// If that still does not result in any changes to the build list,
-// resolveCandidates revisits the ambiguous query candidates and resolves them
+// resolveQueries revisits the ambiguous query candidates and resolves them
 // arbitrarily in order to guarantee forward progress.
 //
 // If all pathSets are resolved without any changes to the build list,
-// resolveCandidates returns with changed=false.
-func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgrades []pathSet) (changed bool) {
+// resolveQueries returns with changed=false.
+func (r *resolver) resolveQueries(ctx context.Context, queries []*query) (changed bool) {
        defer base.ExitIfErrors()
 
        // Note: this is O(N²) with the number of pathSets in the worst case.
@@ -1300,12 +1241,52 @@ func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgr
                }
        }
 
-       if changed := r.updateBuildList(ctx, nil); changed {
-               // The build list has changed, so disregard any missing packages: they might
-               // now be determined by requirements in the build list, which we would
-               // prefer to use instead of arbitrary "latest" versions.
-               return true
+       if resolved > 0 {
+               if changed = r.updateBuildList(ctx, nil); changed {
+                       // The build list has changed, so disregard any remaining ambiguous queries:
+                       // they might now be determined by requirements in the build list, which we
+                       // would prefer to use instead of arbitrary versions.
+                       return true
+               }
+       }
+
+       // The build list will be the same on the next iteration as it was on this
+       // iteration, so any ambiguous queries will remain so. In order to make
+       // progress, resolve them arbitrarily but deterministically.
+       //
+       // If that results in conflicting versions, the user can re-run 'go get'
+       // with additional explicit versions for the conflicting packages or
+       // modules.
+       resolvedArbitrarily := 0
+       for _, q := range queries {
+               for _, cs := range q.candidates {
+                       isPackage, m := r.chooseArbitrarily(cs)
+                       if isPackage {
+                               q.matchesPackages = true
+                       }
+                       r.resolve(q, m)
+                       resolvedArbitrarily++
+               }
+       }
+       if resolvedArbitrarily > 0 {
+               changed = r.updateBuildList(ctx, nil)
        }
+       return changed
+}
+
+// applyUpgrades disambiguates candidate sets that are needed to upgrade (or
+// provide) transitive dependencies imported by previously-resolved packages.
+//
+// applyUpgrades modifies the build list by adding one module version from each
+// pathSet in upgrades, then downgrading (or further upgrading) those modules as
+// needed to maintain any already-resolved versions of other modules.
+// applyUpgrades does not mark the new versions as resolved, so they can still
+// be further modified by other queries (such as wildcards).
+//
+// If all pathSets are resolved without any changes to the build list,
+// applyUpgrades returns with changed=false.
+func (r *resolver) applyUpgrades(ctx context.Context, upgrades []pathSet) (changed bool) {
+       defer base.ExitIfErrors()
 
        // Arbitrarily add a "latest" version that provides each missing package, but
        // do not mark the version as resolved: we still want to allow the explicit
@@ -1329,27 +1310,9 @@ func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgr
                tentative = append(tentative, m)
        }
        base.ExitIfErrors()
-       if changed := r.updateBuildList(ctx, tentative); changed {
-               return true
-       }
 
-       // The build list will be the same on the next iteration as it was on this
-       // iteration, so any ambiguous queries will remain so. In order to make
-       // progress, resolve them arbitrarily but deterministically.
-       //
-       // If that results in conflicting versions, the user can re-run 'go get'
-       // with additional explicit versions for the conflicting packages or
-       // modules.
-       for _, q := range queries {
-               for _, cs := range q.candidates {
-                       isPackage, m := r.chooseArbitrarily(cs)
-                       if isPackage {
-                               q.matchesPackages = true
-                       }
-                       r.resolve(q, m)
-               }
-       }
-       return r.updateBuildList(ctx, nil)
+       changed = r.updateBuildList(ctx, tentative)
+       return changed
 }
 
 // disambiguate eliminates candidates from cs that conflict with other module
@@ -1508,7 +1471,18 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
                        }
                }
                for _, pkg := range pkgs {
-                       if _, _, err := modload.Lookup("", false, pkg); err != nil {
+                       if dir, _, err := modload.Lookup("", false, pkg); err != nil {
+                               if dir != "" && errors.Is(err, imports.ErrNoGo) {
+                                       // Since dir is non-empty, we must have located source files
+                                       // associated with either the package or its test — ErrNoGo must
+                                       // indicate that none of those source files happen to apply in this
+                                       // configuration. If we are actually building the package (no -d
+                                       // flag), the compiler will report the problem; otherwise, assume that
+                                       // the user is going to build or test it in some other configuration
+                                       // and suppress the error.
+                                       continue
+                               }
+
                                base.SetExitStatus(1)
                                if ambiguousErr := (*modload.AmbiguousImportError)(nil); errors.As(err, &ambiguousErr) {
                                        for _, m := range ambiguousErr.Modules {
@@ -1556,7 +1530,7 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
                }
        }
        if retractPath != "" {
-               fmt.Fprintf(os.Stderr, "go: run 'go get %s@latest' to switch to the latest unretracted version\n", retractPath)
+               fmt.Fprintf(os.Stderr, "go: to switch to the latest unretracted version, run:\n\tgo get %s@latest", retractPath)
        }
 }
 
@@ -1656,11 +1630,10 @@ func (r *resolver) resolve(q *query, m module.Version) {
 //
 // If the additional modules conflict with the resolved versions, they will be
 // downgraded to a non-conflicting version (possibly "none").
+//
+// If the resulting build list is the same as the one resulting from the last
+// call to updateBuildList, updateBuildList returns with changed=false.
 func (r *resolver) updateBuildList(ctx context.Context, additions []module.Version) (changed bool) {
-       if len(additions) == 0 && len(r.resolvedVersion) == r.buildListResolvedVersions {
-               return false
-       }
-
        defer base.ExitIfErrors()
 
        resolved := make([]module.Version, 0, len(r.resolvedVersion))
@@ -1691,7 +1664,6 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
        }
 
        buildList := modload.LoadAllModules(ctx)
-       r.buildListResolvedVersions = len(r.resolvedVersion)
        if reflect.DeepEqual(r.buildList, buildList) {
                return false
        }

diff --git a/src/cmd/go/internal/modget/query.go b/src/cmd/go/internal/modget/query.go
index 20eb0b6364ee0715af197d9862ca5944a9fcd89f..d8364c8c0d3a3cac5c96105770632961e83a4b4b 100644 (file)
--- a/src/cmd/go/internal/modget/query.go
+++ b/src/cmd/go/internal/modget/query.go
@@ -281,14 +281,14 @@ func reportError(q *query, err error) {
        // TODO(bcmills): Use errors.As to unpack these errors instead of parsing
        // strings with regular expressions.
 
-       patternRE := regexp.MustCompile("(?m)(?:[ \t(\"`]|^)" + regexp.QuoteMeta(q.pattern) + "(?:[ @:)\"`]|$)")
+       patternRE := regexp.MustCompile("(?m)(?:[ \t(\"`]|^)" + regexp.QuoteMeta(q.pattern) + "(?:[ @:;)\"`]|$)")
        if patternRE.MatchString(errStr) {
                if q.rawVersion == "" {
                        base.Errorf("go get: %s", errStr)
                        return
                }
 
-               versionRE := regexp.MustCompile("(?m)(?:[ @(\"`]|^)" + regexp.QuoteMeta(q.version) + "(?:[ :)\"`]|$)")
+               versionRE := regexp.MustCompile("(?m)(?:[ @(\"`]|^)" + regexp.QuoteMeta(q.version) + "(?:[ :;)\"`]|$)")
                if versionRE.MatchString(errStr) {
                        base.Errorf("go get: %s", errStr)
                        return

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 896adebbb19de9b71aefc310e0e7dc8f0053c1df..45f220a6ee6946b510a6bb67cb06b21971d31576 100644 (file)
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -28,6 +28,11 @@ import (
 //
 var buildList []module.Version
 
+// additionalExplicitRequirements is a list of modules paths for which
+// WriteGoMod should record explicit requirements, even if they would be
+// selected without those requirements. Each path must also appear in buildList.
+var additionalExplicitRequirements []string
+
 // capVersionSlice returns s with its cap reduced to its length.
 func capVersionSlice(s []module.Version) []module.Version {
        return s[:len(s):len(s)]
@@ -121,6 +126,12 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 
        if !inconsistent {
                buildList = final
+               additionalExplicitRequirements = make([]string, 0, len(mustSelect))
+               for _, m := range mustSelect {
+                       if m.Version != "none" {
+                               additionalExplicitRequirements = append(additionalExplicitRequirements, m.Path)
+                       }
+               }
                return nil
        }
 

diff --git a/src/cmd/go/internal/modload/help.go b/src/cmd/go/internal/modload/help.go
index d81dfd56fb54153e6c2fffe9b9fd9f6035b3fe7e..fd39ddd94ec62d6f21533a7ea7dff02c8eeb2ecb 100644 (file)
--- a/src/cmd/go/internal/modload/help.go
+++ b/src/cmd/go/internal/modload/help.go
@@ -6,401 +6,31 @@ package modload
 
 import "cmd/go/internal/base"
 
-// TODO(rsc): The "module code layout" section needs to be written.
-
 var HelpModules = &base.Command{
        UsageLine: "modules",
        Short:     "modules, module versions, and more",
        Long: `
-A module is a collection of related Go packages.
-Modules are the unit of source code interchange and versioning.
-The go command has direct support for working with modules,
-including recording and resolving dependencies on other modules.
-Modules replace the old GOPATH-based approach to specifying
-which source files are used in a given build.
-
-Module support
-
-The go command includes support for Go modules. Module-aware mode is active
-by default whenever a go.mod file is found in the current directory or in
-any parent directory.
-
-The quickest way to take advantage of module support is to check out your
-repository, create a go.mod file (described in the next section) there, and run
-go commands from within that file tree.
-
-For more fine-grained control, the go command continues to respect
-a temporary environment variable, GO111MODULE, which can be set to one
-of three string values: off, on, or auto (the default).
-If GO111MODULE=on, then the go command requires the use of modules,
-never consulting GOPATH. We refer to this as the command
-being module-aware or running in "module-aware mode".
-If GO111MODULE=off, then the go command never uses
-module support. Instead it looks in vendor directories and GOPATH
-to find dependencies; we now refer to this as "GOPATH mode."
-If GO111MODULE=auto or is unset, then the go command enables or disables
-module support based on the current directory.
-Module support is enabled only when the current directory contains a
-go.mod file or is below a directory containing a go.mod file.
-
-In module-aware mode, GOPATH no longer defines the meaning of imports
-during a build, but it still stores downloaded dependencies (in GOPATH/pkg/mod)
-and installed commands (in GOPATH/bin, unless GOBIN is set).
-
-Defining a module
-
-A module is defined by a tree of Go source files with a go.mod file
-in the tree's root directory. The directory containing the go.mod file
-is called the module root. Typically the module root will also correspond
-to a source code repository root (but in general it need not).
-The module is the set of all Go packages in the module root and its
-subdirectories, but excluding subtrees with their own go.mod files.
-
-The "module path" is the import path prefix corresponding to the module root.
-The go.mod file defines the module path and lists the specific versions
-of other modules that should be used when resolving imports during a build,
-by giving their module paths and versions.
-
-For example, this go.mod declares that the directory containing it is the root
-of the module with path example.com/m, and it also declares that the module
-depends on specific versions of golang.org/x/text and gopkg.in/yaml.v2:
-
-       module example.com/m
-
-       require (
-               golang.org/x/text v0.3.0
-               gopkg.in/yaml.v2 v2.1.0
-       )
-
-The go.mod file can also specify replacements and excluded versions
-that only apply when building the module directly; they are ignored
-when the module is incorporated into a larger build.
-For more about the go.mod file, see 'go help go.mod'.
-
-To start a new module, simply create a go.mod file in the root of the
-module's directory tree, containing only a module statement.
-The 'go mod init' command can be used to do this:
-
-       go mod init example.com/m
-
-In a project already using an existing dependency management tool like
-godep, glide, or dep, 'go mod init' will also add require statements
-matching the existing configuration.
-
-Once the go.mod file exists, no additional steps are required:
-go commands like 'go build', 'go test', or even 'go list' will automatically
-add new dependencies as needed to satisfy imports.
-
-The main module and the build list
-
-The "main module" is the module containing the directory where the go command
-is run. The go command finds the module root by looking for a go.mod in the
-current directory, or else the current directory's parent directory,
-or else the parent's parent directory, and so on.
-
-The main module's go.mod file defines the precise set of packages available
-for use by the go command, through require, replace, and exclude statements.
-Dependency modules, found by following require statements, also contribute
-to the definition of that set of packages, but only through their go.mod
-files' require statements: any replace and exclude statements in dependency
-modules are ignored. The replace and exclude statements therefore allow the
-main module complete control over its own build, without also being subject
-to complete control by dependencies.
-
-The set of modules providing packages to builds is called the "build list".
-The build list initially contains only the main module. Then the go command
-adds to the list the exact module versions required by modules already
-on the list, recursively, until there is nothing left to add to the list.
-If multiple versions of a particular module are added to the list,
-then at the end only the latest version (according to semantic version
-ordering) is kept for use in the build.
-
-The 'go list' command provides information about the main module
-and the build list. For example:
-
-       go list -m              # print path of main module
-       go list -m -f={{.Dir}}  # print root directory of main module
-       go list -m all          # print build list
-
-Maintaining module requirements
-
-The go.mod file is meant to be readable and editable by both programmers and
-tools. Most updates to dependencies can be performed using "go get" and
-"go mod tidy". Other module-aware build commands may be invoked using the
--mod=mod flag to automatically add missing requirements and fix inconsistencies.
-
-The "go get" command updates go.mod to change the module versions used in a
-build. An upgrade of one module may imply upgrading others, and similarly a
-downgrade of one module may imply downgrading others. The "go get" command
-makes these implied changes as well. See "go help module-get".
-
-The "go mod" command provides other functionality for use in maintaining
-and understanding modules and go.mod files. See "go help mod", particularly
-"go help mod tidy" and "go help mod edit".
-
-As part of maintaining the require statements in go.mod, the go command
-tracks which ones provide packages imported directly by the current module
-and which ones provide packages only used indirectly by other module
-dependencies. Requirements needed only for indirect uses are marked with a
-"// indirect" comment in the go.mod file. Indirect requirements may be
-automatically removed from the go.mod file once they are implied by other
-direct requirements. Indirect requirements only arise when using modules
-that fail to state some of their own dependencies or when explicitly
-upgrading a module's dependencies ahead of its own stated requirements.
-
-The -mod build flag provides additional control over the updating and use of
-go.mod for commands that build packages like "go build" and "go test".
-
-If invoked with -mod=readonly (the default in most situations), the go command
-reports an error if a package named on the command line or an imported package
-is not provided by any module in the build list computed from the main module's
-requirements. The go command also reports an error if a module's checksum is
-missing from go.sum (see Module downloading and verification). Either go.mod or
-go.sum must be updated in these situations.
-
-If invoked with -mod=mod, the go command automatically updates go.mod and
-go.sum, fixing inconsistencies and adding missing requirements and checksums
-as needed. If the go command finds an unfamiliar import, it looks up the
-module containing that import and adds a requirement for the latest version
-of that module to go.mod. In most cases, therefore, one may add an import to
-source code and run "go build", "go test", or even "go list" with -mod=mod:
-as part of analyzing the package, the go command will resolve the import and
-update the go.mod file.
-
-If invoked with -mod=vendor, the go command loads packages from the main
-module's vendor directory instead of downloading modules to and loading packages
-from the module cache. The go command assumes the vendor directory holds
-correct copies of dependencies, and it does not compute the set of required
-module versions from go.mod files. However, the go command does check that
-vendor/modules.txt (generated by "go mod vendor") contains metadata consistent
-with go.mod.
-
-If the go command is not invoked with a -mod flag, and the vendor directory
-is present, and the "go" version in go.mod is 1.14 or higher, the go command
-will act as if it were invoked with -mod=vendor. Otherwise, the -mod flag
-defaults to -mod=readonly.
-
-Note that neither "go get" nor the "go mod" subcommands accept the -mod flag.
-
-Pseudo-versions
-
-The go.mod file and the go command more generally use semantic versions as
-the standard form for describing module versions, so that versions can be
-compared to determine which should be considered earlier or later than another.
-A module version like v1.2.3 is introduced by tagging a revision in the
-underlying source repository. Untagged revisions can be referred to
-using a "pseudo-version" like v0.0.0-yyyymmddhhmmss-abcdefabcdef,
-where the time is the commit time in UTC and the final suffix is the prefix
-of the commit hash. The time portion ensures that two pseudo-versions can
-be compared to determine which happened later, the commit hash identifes
-the underlying commit, and the prefix (v0.0.0- in this example) is derived from
-the most recent tagged version in the commit graph before this commit.
-
-There are three pseudo-version forms:
-
-vX.0.0-yyyymmddhhmmss-abcdefabcdef is used when there is no earlier
-versioned commit with an appropriate major version before the target commit.
-(This was originally the only form, so some older go.mod files use this form
-even for commits that do follow tags.)
-
-vX.Y.Z-pre.0.yyyymmddhhmmss-abcdefabcdef is used when the most
-recent versioned commit before the target commit is vX.Y.Z-pre.
-
-vX.Y.(Z+1)-0.yyyymmddhhmmss-abcdefabcdef is used when the most
-recent versioned commit before the target commit is vX.Y.Z.
-
-Pseudo-versions never need to be typed by hand: the go command will accept
-the plain commit hash and translate it into a pseudo-version (or a tagged
-version if available) automatically. This conversion is an example of a
-module query.
-
-Module queries
+Modules are how Go manages dependencies.
 
-The go command accepts a "module query" in place of a module version
-both on the command line and in the main module's go.mod file.
-(After evaluating a query found in the main module's go.mod file,
-the go command updates the file to replace the query with its result.)
+A module is a collection of packages that are released, versioned, and
+distributed together. Modules may be downloaded directly from version control
+repositories or from module proxy servers.
 
-A fully-specified semantic version, such as "v1.2.3",
-evaluates to that specific version.
+For a series of tutorials on modules, see
+https://golang.org/doc/tutorial/create-module.
 
-A semantic version prefix, such as "v1" or "v1.2",
-evaluates to the latest available tagged version with that prefix.
+For a detailed reference on modules, see https://golang.org/ref/mod.
 
-A semantic version comparison, such as "<v1.2.3" or ">=v1.5.6",
-evaluates to the available tagged version nearest to the comparison target
-(the latest version for < and <=, the earliest version for > and >=).
+By default, the go command may download modules from https://proxy.golang.org.
+It may authenticate modules using the checksum database at
+https://sum.golang.org. Both services are operated by the Go team at Google.
+The privacy policies for these services are available at
+https://proxy.golang.org/privacy and https://sum.golang.org/privacy,
+respectively.
 
-The string "latest" matches the latest available tagged version,
-or else the underlying source repository's latest untagged revision.
-
-The string "upgrade" is like "latest", but if the module is
-currently required at a later version than the version "latest"
-would select (for example, a newer pre-release version), "upgrade"
-will select the later version instead.
-
-The string "patch" matches the latest available tagged version
-of a module with the same major and minor version numbers as the
-currently required version. If no version is currently required,
-"patch" is equivalent to "latest".
-
-A revision identifier for the underlying source repository, such as
-a commit hash prefix, revision tag, or branch name, selects that
-specific code revision. If the revision is also tagged with a
-semantic version, the query evaluates to that semantic version.
-Otherwise the query evaluates to a pseudo-version for the commit.
-Note that branches and tags with names that are matched by other
-query syntax cannot be selected this way. For example, the query
-"v2" means the latest version starting with "v2", not the branch
-named "v2".
-
-All queries prefer release versions to pre-release versions.
-For example, "<v1.2.3" will prefer to return "v1.2.2"
-instead of "v1.2.3-pre1", even though "v1.2.3-pre1" is nearer
-to the comparison target.
-
-Module versions disallowed by exclude statements in the
-main module's go.mod are considered unavailable and cannot
-be returned by queries.
-
-For example, these commands are all valid:
-
-       go get github.com/gorilla/mux@latest    # same (@latest is default for 'go get')
-       go get github.com/gorilla/mux@v1.6.2    # records v1.6.2
-       go get github.com/gorilla/mux@e3702bed2 # records v1.6.2
-       go get github.com/gorilla/mux@c856192   # records v0.0.0-20180517173623-c85619274f5d
-       go get github.com/gorilla/mux@master    # records current meaning of master
-
-Module compatibility and semantic versioning
-
-The go command requires that modules use semantic versions and expects that
-the versions accurately describe compatibility: it assumes that v1.5.4 is a
-backwards-compatible replacement for v1.5.3, v1.4.0, and even v1.0.0.
-More generally the go command expects that packages follow the
-"import compatibility rule", which says:
-
-"If an old package and a new package have the same import path,
-the new package must be backwards compatible with the old package."
-
-Because the go command assumes the import compatibility rule,
-a module definition can only set the minimum required version of one
-of its dependencies: it cannot set a maximum or exclude selected versions.
-Still, the import compatibility rule is not a guarantee: it may be that
-v1.5.4 is buggy and not a backwards-compatible replacement for v1.5.3.
-Because of this, the go command never updates from an older version
-to a newer version of a module unasked.
-
-In semantic versioning, changing the major version number indicates a lack
-of backwards compatibility with earlier versions. To preserve import
-compatibility, the go command requires that modules with major version v2
-or later use a module path with that major version as the final element.
-For example, version v2.0.0 of example.com/m must instead use module path
-example.com/m/v2, and packages in that module would use that path as
-their import path prefix, as in example.com/m/v2/sub/pkg. Including the
-major version number in the module path and import paths in this way is
-called "semantic import versioning". Pseudo-versions for modules with major
-version v2 and later begin with that major version instead of v0, as in
-v2.0.0-20180326061214-4fc5987536ef.
-
-As a special case, module paths beginning with gopkg.in/ continue to use the
-conventions established on that system: the major version is always present,
-and it is preceded by a dot instead of a slash: gopkg.in/yaml.v1
-and gopkg.in/yaml.v2, not gopkg.in/yaml and gopkg.in/yaml/v2.
-
-The go command treats modules with different module paths as unrelated:
-it makes no connection between example.com/m and example.com/m/v2.
-Modules with different major versions can be used together in a build
-and are kept separate by the fact that their packages use different
-import paths.
-
-In semantic versioning, major version v0 is for initial development,
-indicating no expectations of stability or backwards compatibility.
-Major version v0 does not appear in the module path, because those
-versions are preparation for v1.0.0, and v1 does not appear in the
-module path either.
-
-Code written before the semantic import versioning convention
-was introduced may use major versions v2 and later to describe
-the same set of unversioned import paths as used in v0 and v1.
-To accommodate such code, if a source code repository has a
-v2.0.0 or later tag for a file tree with no go.mod, the version is
-considered to be part of the v1 module's available versions
-and is given an +incompatible suffix when converted to a module
-version, as in v2.0.0+incompatible. The +incompatible tag is also
-applied to pseudo-versions derived from such versions, as in
-v2.0.1-0.yyyymmddhhmmss-abcdefabcdef+incompatible.
-
-In general, having a dependency in the build list (as reported by 'go list -m all')
-on a v0 version, pre-release version, pseudo-version, or +incompatible version
-is an indication that problems are more likely when upgrading that
-dependency, since there is no expectation of compatibility for those.
-
-See https://research.swtch.com/vgo-import for more information about
-semantic import versioning, and see https://semver.org/ for more about
-semantic versioning.
-
-Module code layout
-
-For now, see https://research.swtch.com/vgo-module for information
-about how source code in version control systems is mapped to
-module file trees.
-
-Module downloading and verification
-
-The go command can fetch modules from a proxy or connect to source control
-servers directly, according to the setting of the GOPROXY environment
-variable (see 'go help env'). The default setting for GOPROXY is
-"https://proxy.golang.org,direct", which means to try the
-Go module mirror run by Google and fall back to a direct connection
-if the proxy reports that it does not have the module (HTTP error 404 or 410).
-See https://proxy.golang.org/privacy for the service's privacy policy.
-
-If GOPROXY is set to the string "direct", downloads use a direct connection to
-source control servers. Setting GOPROXY to "off" disallows downloading modules
-from any source. Otherwise, GOPROXY is expected to be list of module proxy URLs
-separated by either comma (,) or pipe (|) characters, which control error
-fallback behavior. For each request, the go command tries each proxy in
-sequence. If there is an error, the go command will try the next proxy in the
-list if the error is a 404 or 410 HTTP response or if the current proxy is
-followed by a pipe character, indicating it is safe to fall back on any error.
-
-The GOPRIVATE and GONOPROXY environment variables allow bypassing
-the proxy for selected modules. See 'go help private' for details.
-
-No matter the source of the modules, the go command checks downloads against
-known checksums, to detect unexpected changes in the content of any specific
-module version from one day to the next. This check first consults the current
-module's go.sum file but falls back to the Go checksum database, controlled by
-the GOSUMDB and GONOSUMDB environment variables. See 'go help module-auth'
-for details.
-
-See 'go help goproxy' for details about the proxy protocol and also
-the format of the cached downloaded packages.
-
-Modules and vendoring
-
-When using modules, the go command typically satisfies dependencies by
-downloading modules from their sources and using those downloaded copies
-(after verification, as described in the previous section). Vendoring may
-be used to allow interoperation with older versions of Go, or to ensure
-that all files used for a build are stored together in a single file tree.
-
-The command 'go mod vendor' constructs a directory named vendor in the main
-module's root directory that contains copies of all packages needed to support
-builds and tests of packages in the main module. 'go mod vendor' also
-creates the file vendor/modules.txt that contains metadata about vendored
-packages and module versions. This file should be kept consistent with go.mod:
-when vendoring is used, 'go mod vendor' should be run after go.mod is updated.
-
-If the vendor directory is present in the main module's root directory, it will
-be used automatically if the "go" version in the main module's go.mod file is
-1.14 or higher. Build commands like 'go build' and 'go test' will load packages
-from the vendor directory instead of accessing the network or the local module
-cache. To explicitly enable vendoring, invoke the go command with the flag
--mod=vendor. To disable vendoring, use the flag -mod=mod.
-
-Unlike vendoring in GOPATH, the go command ignores vendor directories in
-locations other than the main module's root directory.
+The go command's download behavior may be configured using GOPROXY, GOSUMDB,
+GOPRIVATE, and other environment variables. See 'go help environment'
+and https://golang.org/ref/mod#private-module-privacy for more information.
        `,
 }
 
@@ -413,87 +43,22 @@ file in its root. When the go command is run, it looks in the current
 directory and then successive parent directories to find the go.mod
 marking the root of the main (current) module.
 
-The go.mod file itself is line-oriented, with // comments but
-no /* */ comments. Each line holds a single directive, made up of a
-verb followed by arguments. For example:
-
-       module my/thing
-       go 1.12
-       require other/thing v1.0.2
-       require new/thing/v2 v2.3.4
-       exclude old/thing v1.2.3
-       replace bad/thing v1.4.5 => good/thing v1.4.5
-       retract v1.5.6
-
-The verbs are
-       module, to define the module path;
-       go, to set the expected language version;
-       require, to require a particular module at a given version or later;
-       exclude, to exclude a particular module version from use;
-       replace, to replace a module version with a different module version; and
-       retract, to indicate a previously released version should not be used.
-Exclude and replace apply only in the main module's go.mod and are ignored
-in dependencies.  See https://golang.org/ref/mod for details.
-
-The leading verb can be factored out of adjacent lines to create a block,
-like in Go imports:
-
-       require (
-               new/thing/v2 v2.3.4
-               old/thing v1.2.3
-       )
-
-The go.mod file is designed both to be edited directly and to be
-easily updated by tools. The 'go mod edit' command can be used to
-parse and edit the go.mod file from programs and tools.
-See 'go help mod edit'.
-
-The go command automatically updates go.mod each time it uses the
-module graph, to make sure go.mod always accurately reflects reality
-and is properly formatted. For example, consider this go.mod file:
-
-        module M
-
-        require (
-                A v1
-                B v1.0.0
-                C v1.0.0
-                D v1.2.3
-                E dev
-        )
-
-        exclude D v1.2.3
-
-The update rewrites non-canonical version identifiers to semver form,
-so A's v1 becomes v1.0.0 and E's dev becomes the pseudo-version for the
-latest commit on the dev branch, perhaps v0.0.0-20180523231146-b3f5c0f6e5f1.
-
-The update modifies requirements to respect exclusions, so the
-requirement on the excluded D v1.2.3 is updated to use the next
-available version of D, perhaps D v1.2.4 or D v1.3.0.
+The go.mod file format is described in detail at
+https://golang.org/ref/mod#go-mod-file.
 
-The update removes redundant or misleading requirements.
-For example, if A v1.0.0 itself requires B v1.2.0 and C v1.0.0,
-then go.mod's requirement of B v1.0.0 is misleading (superseded by
-A's need for v1.2.0), and its requirement of C v1.0.0 is redundant
-(implied by A's need for the same version), so both will be removed.
-If module M contains packages that directly import packages from B or
-C, then the requirements will be kept but updated to the actual
-versions being used.
+To create a new go.mod file, use 'go help init'. For details see
+'go help mod init' or https://golang.org/ref/mod#go-mod-init.
 
-Finally, the update reformats the go.mod in a canonical formatting, so
-that future mechanical changes will result in minimal diffs.
+To add missing module requirements or remove unneeded requirements,
+use 'go mod tidy'. For details, see 'go help mod tidy' or
+https://golang.org/ref/mod#go-mod-tidy.
 
-Because the module graph defines the meaning of import statements, any
-commands that load packages also use and therefore update go.mod,
-including go build, go get, go install, go list, go test, go mod graph,
-go mod tidy, and go mod why.
+To add, upgrade, downgrade, or remove a specific module requirement, use
+'go get'. For details, see 'go help module-get' or
+https://golang.org/ref/mod#go-get.
 
-The expected language version, set by the go directive, determines
-which language features are available when compiling the module.
-Language features available in that version will be available for use.
-Language features removed in earlier versions, or added in later versions,
-will not be available. Note that the language version does not affect
-build tags, which are determined by the Go release being used.
+To make other changes or to parse go.mod as JSON for use by other tools,
+use 'go mod edit'. See 'go help mod edit' or
+https://golang.org/ref/mod#go-mod-edit.
        `,
 }

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index ce5671728e00a760640d038e0f131124241a0217..182429aee41b95121da18f25cc8ed7a46df1b38e 100644 (file)
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -31,10 +31,6 @@ type ImportMissingError struct {
        Module   module.Version
        QueryErr error
 
-       // inAll indicates whether Path is in the "all" package pattern,
-       // and thus would be added by 'go mod tidy'.
-       inAll bool
-
        // isStd indicates whether we would expect to find the package in the standard
        // library. This is normally true for all dotless import paths, but replace
        // directives can cause us to treat the replaced paths as also being in
@@ -58,7 +54,7 @@ func (e *ImportMissingError) Error() string {
                if e.QueryErr != nil {
                        return fmt.Sprintf("cannot find module providing package %s: %v", e.Path, e.QueryErr)
                }
-               if cfg.BuildMod == "mod" {
+               if cfg.BuildMod == "mod" || (cfg.BuildMod == "readonly" && allowMissingModuleImports) {
                        return "cannot find module providing package " + e.Path
                }
 
@@ -67,16 +63,14 @@ func (e *ImportMissingError) Error() string {
                        if !modfetch.IsZeroPseudoVersion(e.replaced.Version) {
                                suggestArg = e.replaced.String()
                        }
-                       return fmt.Sprintf("module %s provides package %s and is replaced but not required; try 'go get -d %s' to add it", e.replaced.Path, e.Path, suggestArg)
+                       return fmt.Sprintf("module %s provides package %s and is replaced but not required; to add it:\n\tgo get %s", e.replaced.Path, e.Path, suggestArg)
                }
 
                suggestion := ""
                if !HasModRoot() {
                        suggestion = ": working directory is not part of a module"
-               } else if e.inAll {
-                       suggestion = "; try 'go mod tidy' to add it"
                } else {
-                       suggestion = fmt.Sprintf("; try 'go get -d %s' to add it", e.Path)
+                       suggestion = fmt.Sprintf("; to add it:\n\tgo get %s", e.Path)
                }
                return fmt.Sprintf("no required module provides package %s%s", e.Path, suggestion)
        }
@@ -136,24 +130,57 @@ func (e *AmbiguousImportError) Error() string {
 }
 
 // ImportMissingSumError is reported in readonly mode when we need to check
-// if a module in the build list contains a package, but we don't have a sum
-// for its .zip file.
+// if a module contains a package, but we don't have a sum for its .zip file.
+// We might need sums for multiple modules to verify the package is unique.
+//
+// TODO(#43653): consolidate multiple errors of this type into a single error
+// that suggests a 'go get' command for root packages that transtively import
+// packages from modules with missing sums. load.CheckPackageErrors would be
+// a good place to consolidate errors, but we'll need to attach the import
+// stack here.
 type ImportMissingSumError struct {
-       importPath   string
-       found, inAll bool
+       importPath                string
+       found                     bool
+       mods                      []module.Version
+       importer, importerVersion string // optional, but used for additional context
+       importerIsTest            bool
 }
 
 func (e *ImportMissingSumError) Error() string {
+       var importParen string
+       if e.importer != "" {
+               importParen = fmt.Sprintf(" (imported by %s)", e.importer)
+       }
        var message string
        if e.found {
-               message = fmt.Sprintf("missing go.sum entry needed to verify package %s is provided by exactly one module", e.importPath)
+               message = fmt.Sprintf("missing go.sum entry needed to verify package %s%s is provided by exactly one module", e.importPath, importParen)
        } else {
-               message = fmt.Sprintf("missing go.sum entry for module providing package %s", e.importPath)
+               message = fmt.Sprintf("missing go.sum entry for module providing package %s%s", e.importPath, importParen)
        }
-       if e.inAll {
-               return message + "; try 'go mod tidy' to add it"
+       var hint string
+       if e.importer == "" {
+               // Importing package is unknown, or the missing package was named on the
+               // command line. Recommend 'go mod download' for the modules that could
+               // provide the package, since that shouldn't change go.mod.
+               args := make([]string, len(e.mods))
+               for i, mod := range e.mods {
+                       args[i] = mod.Path
+               }
+               hint = fmt.Sprintf("; to add:\n\tgo mod download %s", strings.Join(args, " "))
+       } else {
+               // Importing package is known (common case). Recommend 'go get' on the
+               // current version of the importing package.
+               tFlag := ""
+               if e.importerIsTest {
+                       tFlag = " -t"
+               }
+               version := ""
+               if e.importerVersion != "" {
+                       version = "@" + e.importerVersion
+               }
+               hint = fmt.Sprintf("; to add:\n\tgo get%s %s%s", tFlag, e.importer, version)
        }
-       return message
+       return message + hint
 }
 
 func (e *ImportMissingSumError) ImportPath() string {
@@ -244,7 +271,7 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
        // Check each module on the build list.
        var dirs []string
        var mods []module.Version
-       haveSumErr := false
+       var sumErrMods []module.Version
        for _, m := range buildList {
                if !maybeInModule(path, m.Path) {
                        // Avoid possibly downloading irrelevant modules.
@@ -257,8 +284,9 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
                                // We are missing a sum needed to fetch a module in the build list.
                                // We can't verify that the package is unique, and we may not find
                                // the package at all. Keep checking other modules to decide which
-                               // error to report.
-                               haveSumErr = true
+                               // error to report. Multiple sums may be missing if we need to look in
+                               // multiple nested modules to resolve the import.
+                               sumErrMods = append(sumErrMods, m)
                                continue
                        }
                        // Report fetch error.
@@ -279,8 +307,12 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
        if len(mods) > 1 {
                return module.Version{}, "", &AmbiguousImportError{importPath: path, Dirs: dirs, Modules: mods}
        }
-       if haveSumErr {
-               return module.Version{}, "", &ImportMissingSumError{importPath: path, found: len(mods) > 0}
+       if len(sumErrMods) > 0 {
+               return module.Version{}, "", &ImportMissingSumError{
+                       importPath: path,
+                       mods:       sumErrMods,
+                       found:      len(mods) > 0,
+               }
        }
        if len(mods) == 1 {
                return mods[0], dirs[0], nil
@@ -365,7 +397,7 @@ func queryImport(ctx context.Context, path string) (module.Version, error) {
                return module.Version{}, &ImportMissingError{Path: path, isStd: true}
        }
 
-       if cfg.BuildMod == "readonly" {
+       if cfg.BuildMod == "readonly" && !allowMissingModuleImports {
                // In readonly mode, we can't write go.mod, so we shouldn't try to look up
                // the module. If readonly mode was enabled explicitly, include that in
                // the error message.
@@ -547,7 +579,7 @@ func fetch(ctx context.Context, mod module.Version, needSum bool) (dir string, i
                mod = r
        }
 
-       if cfg.BuildMod == "readonly" && needSum && !modfetch.HaveSum(mod) {
+       if HasModRoot() && cfg.BuildMod == "readonly" && needSum && !modfetch.HaveSum(mod) {
                return "", false, module.VersionError(mod, &sumMissingError{})
        }
 

diff --git a/src/cmd/go/internal/modload/import_test.go b/src/cmd/go/internal/modload/import_test.go
index 22d5b82e2116a48ce6f3a9567b320a52e1afe75d..9420dc56460d1060b7723d6763c66e816956408b 100644 (file)
--- a/src/cmd/go/internal/modload/import_test.go
+++ b/src/cmd/go/internal/modload/import_test.go
@@ -58,10 +58,15 @@ var importTests = []struct {
 func TestQueryImport(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)
        testenv.MustHaveExecPath(t, "git")
-       defer func(old bool) {
-               allowMissingModuleImports = old
-       }(allowMissingModuleImports)
-       AllowMissingModuleImports()
+
+       oldAllowMissingModuleImports := allowMissingModuleImports
+       oldRootMode := RootMode
+       defer func() {
+               allowMissingModuleImports = oldAllowMissingModuleImports
+               RootMode = oldRootMode
+       }()
+       allowMissingModuleImports = true
+       RootMode = NoRoot
 
        ctx := context.Background()
 

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 3f70d041451f1e1c8168ac6b53b7234b35461619..bc8d17e0a5fb5934d93a09025a186d21a0cccb6b 100644 (file)
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -15,6 +15,7 @@ import (
        "os"
        "path"
        "path/filepath"
+       "sort"
        "strconv"
        "strings"
        "sync"
@@ -27,6 +28,7 @@ import (
        "cmd/go/internal/modfetch"
        "cmd/go/internal/mvs"
        "cmd/go/internal/search"
+       "cmd/go/internal/str"
 
        "golang.org/x/mod/modfile"
        "golang.org/x/mod/module"
@@ -200,6 +202,8 @@ func Init() {
        }
 
        // We're in module mode. Set any global variables that need to be set.
+       cfg.ModulesEnabled = true
+       setDefaultBuildMod()
        list := filepath.SplitList(cfg.BuildContext.GOPATH)
        if len(list) == 0 || list[0] == "" {
                base.Fatalf("missing $GOPATH")
@@ -209,8 +213,6 @@ func Init() {
                base.Fatalf("$GOPATH/go.mod exists but should not")
        }
 
-       cfg.ModulesEnabled = true
-
        if modRoot == "" {
                // We're in module mode, but not inside a module.
                //
@@ -346,8 +348,8 @@ func die() {
 // ensuring requirements are consistent. WriteGoMod should be called later to
 // write changes out to disk or report errors in readonly mode.
 //
-// As a side-effect, LoadModFile sets a default for cfg.BuildMod if it does not
-// already have an explicit value.
+// As a side-effect, LoadModFile may change cfg.BuildMod to "vendor" if
+// -mod wasn't set explicitly and automatic vendoring should be enabled.
 func LoadModFile(ctx context.Context) {
        if len(buildList) > 0 {
                return
@@ -378,14 +380,14 @@ func LoadModFile(ctx context.Context) {
 
        if f.Module == nil {
                // No module declaration. Must add module path.
-               base.Fatalf("go: no module declaration in go.mod.\n\tRun 'go mod edit -module=example.com/mod' to specify the module path.")
+               base.Fatalf("go: no module declaration in go.mod. To specify the module path:\n\tgo mod edit -module=example.com/mod")
        }
 
        if err := checkModulePathLax(f.Module.Mod.Path); err != nil {
                base.Fatalf("go: %v", err)
        }
 
-       setDefaultBuildMod()
+       setDefaultBuildMod() // possibly enable automatic vendoring
        modFileToBuildList()
        if cfg.BuildMod == "vendor" {
                readVendorList()
@@ -456,7 +458,7 @@ func CreateModFile(ctx context.Context, modPath string) {
                }
        }
        if !empty {
-               fmt.Fprintf(os.Stderr, "go: run 'go mod tidy' to add module requirements and sums\n")
+               fmt.Fprintf(os.Stderr, "go: to add module requirements and sums:\n\tgo mod tidy\n")
        }
 }
 
@@ -584,8 +586,8 @@ func modFileToBuildList() {
        buildList = list
 }
 
-// setDefaultBuildMod sets a default value for cfg.BuildMod
-// if it is currently empty.
+// setDefaultBuildMod sets a default value for cfg.BuildMod if the -mod flag
+// wasn't provided. setDefaultBuildMod may be called multiple times.
 func setDefaultBuildMod() {
        if cfg.BuildModExplicit {
                // Don't override an explicit '-mod=' argument.
@@ -606,7 +608,7 @@ func setDefaultBuildMod() {
 
        if fi, err := fsys.Stat(filepath.Join(modRoot, "vendor")); err == nil && fi.IsDir() {
                modGo := "unspecified"
-               if index.goVersionV != "" {
+               if index != nil && index.goVersionV != "" {
                        if semver.Compare(index.goVersionV, "v1.14") >= 0 {
                                // The Go version is at least 1.14, and a vendor directory exists.
                                // Set -mod=vendor by default.
@@ -845,13 +847,15 @@ func AllowWriteGoMod() {
 // MinReqs returns a Reqs with minimal additional dependencies of Target,
 // as will be written to go.mod.
 func MinReqs() mvs.Reqs {
-       var retain []string
+       retain := append([]string{}, additionalExplicitRequirements...)
        for _, m := range buildList[1:] {
                _, explicit := index.require[m]
                if explicit || loaded.direct[m.Path] {
                        retain = append(retain, m.Path)
                }
        }
+       sort.Strings(retain)
+       str.Uniq(&retain)
        min, err := mvs.Req(Target, retain, &mvsReqs{buildList: buildList})
        if err != nil {
                base.Fatalf("go: %v", err)
@@ -903,7 +907,7 @@ func WriteGoMod() {
                } else if cfg.BuildModReason != "" {
                        base.Fatalf("go: updates to go.mod needed, disabled by -mod=readonly\n\t(%s)", cfg.BuildModReason)
                } else {
-                       base.Fatalf("go: updates to go.mod needed; try 'go mod tidy' first")
+                       base.Fatalf("go: updates to go.mod needed; to update it:\n\tgo mod tidy")
                }
        }
 
@@ -972,9 +976,12 @@ func WriteGoMod() {
 // It also contains entries for go.mod files needed for MVS (the version
 // of these entries ends with "/go.mod").
 //
-// If addDirect is true, the set also includes sums for modules directly
-// required by go.mod, as represented by the index, with replacements applied.
-func keepSums(addDirect bool) map[module.Version]bool {
+// If keepBuildListZips is true, the set also includes sums for zip files for
+// all modules in the build list with replacements applied. 'go get' and
+// 'go mod download' may add sums to this set when adding a requirement on a
+// module without a root package or when downloading a direct or indirect
+// dependency.
+func keepSums(keepBuildListZips bool) map[module.Version]bool {
        // Re-derive the build list using the current list of direct requirements.
        // Keep the sum for the go.mod of each visited module version (or its
        // replacement).
@@ -1003,19 +1010,20 @@ func keepSums(addDirect bool) map[module.Version]bool {
                panic(fmt.Sprintf("unexpected error reloading build list: %v", err))
        }
 
+       actualMods := make(map[string]module.Version)
+       for _, m := range buildList[1:] {
+               if r := Replacement(m); r.Path != "" {
+                       actualMods[m.Path] = r
+               } else {
+                       actualMods[m.Path] = m
+               }
+       }
+
        // Add entries for modules in the build list with paths that are prefixes of
        // paths of loaded packages. We need to retain sums for modules needed to
        // report ambiguous import errors. We use our re-derived build list,
        // since the global build list may have been tidied.
        if loaded != nil {
-               actualMods := make(map[string]module.Version)
-               for _, m := range buildList[1:] {
-                       if r := Replacement(m); r.Path != "" {
-                               actualMods[m.Path] = r
-                       } else {
-                               actualMods[m.Path] = m
-                       }
-               }
                for _, pkg := range loaded.pkgs {
                        if pkg.testOf != nil || pkg.inStd || module.CheckImportPath(pkg.path) != nil {
                                continue
@@ -1028,17 +1036,13 @@ func keepSums(addDirect bool) map[module.Version]bool {
                }
        }
 
-       // Add entries for modules directly required by go.mod.
-       if addDirect {
-               for m := range index.require {
-                       var kept module.Version
-                       if r := Replacement(m); r.Path != "" {
-                               kept = r
-                       } else {
-                               kept = m
-                       }
-                       keep[kept] = true
-                       keep[module.Version{Path: kept.Path, Version: kept.Version + "/go.mod"}] = true
+       // Add entries for the zip of each module in the build list.
+       // We might not need all of these (tidy does not add them), but they may be
+       // added by a specific 'go get' or 'go mod download' command to resolve
+       // missing import sum errors.
+       if keepBuildListZips {
+               for _, m := range actualMods {
+                       keep[m] = true
                }
        }
 
@@ -1058,9 +1062,8 @@ func (r *keepSumReqs) Required(m module.Version) ([]module.Version, error) {
 }
 
 func TrimGoSum() {
-       // Don't retain sums for direct requirements in go.mod. When TrimGoSum is
-       // called, go.mod has not been updated, and it may contain requirements on
-       // modules deleted from the build list.
-       addDirect := false
-       modfetch.TrimGoSum(keepSums(addDirect))
+       // Don't retain sums for the zip file of every module in the build list.
+       // We may not need them all to build the main module's packages.
+       keepBuildListZips := false
+       modfetch.TrimGoSum(keepSums(keepBuildListZips))
 }

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index a0f93d028a54c1d553587dc9bdbc3ba8b9eb781d..6d87acc6d3b7c9371cdb62e08339b585dd149833 100644 (file)
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -280,11 +280,11 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
        checkMultiplePaths()
        for _, pkg := range loaded.pkgs {
                if pkg.err != nil {
-                       if pkg.flags.has(pkgInAll) {
-                               if imErr := (*ImportMissingError)(nil); errors.As(pkg.err, &imErr) {
-                                       imErr.inAll = true
-                               } else if sumErr := (*ImportMissingSumError)(nil); errors.As(pkg.err, &sumErr) {
-                                       sumErr.inAll = true
+                       if sumErr := (*ImportMissingSumError)(nil); errors.As(pkg.err, &sumErr) {
+                               if importer := pkg.stack; importer != nil {
+                                       sumErr.importer = importer.path
+                                       sumErr.importerVersion = importer.mod.Version
+                                       sumErr.importerIsTest = importer.testOf != nil
                                }
                        }
 
@@ -863,12 +863,21 @@ func loadFromRoots(params loaderParams) *loader {
        for _, pkg := range ld.pkgs {
                if pkg.mod == Target {
                        for _, dep := range pkg.imports {
-                               if dep.mod.Path != "" {
+                               if dep.mod.Path != "" && dep.mod.Path != Target.Path && index != nil {
+                                       _, explicit := index.require[dep.mod]
+                                       if allowWriteGoMod && cfg.BuildMod == "readonly" && !explicit {
+                                               // TODO(#40775): attach error to package instead of using
+                                               // base.Errorf. Ideally, 'go list' should not fail because of this,
+                                               // but today, LoadPackages calls WriteGoMod unconditionally, which
+                                               // would fail with a less clear message.
+                                               base.Errorf("go: %[1]s: package %[2]s imported from implicitly required module; to add missing requirements, run:\n\tgo get %[2]s@%[3]s", pkg.path, dep.path, dep.mod.Version)
+                                       }
                                        ld.direct[dep.mod.Path] = true
                                }
                        }
                }
        }
+       base.ExitIfErrors()
 
        // If we didn't scan all of the imports from the main module, or didn't use
        // imports.AnyTags, then we didn't necessarily load every package that
@@ -1074,14 +1083,21 @@ func (ld *loader) load(pkg *loadPkg) {
                }
        }
 
-       imports, testImports, err := scanDir(pkg.dir, ld.Tags)
-       if err != nil {
-               pkg.err = err
-               return
-       }
-
        pkg.inStd = (search.IsStandardImportPath(pkg.path) && search.InDir(pkg.dir, cfg.GOROOTsrc) != "")
 
+       var imports, testImports []string
+
+       if cfg.BuildContext.Compiler == "gccgo" && pkg.inStd {
+               // We can't scan standard packages for gccgo.
+       } else {
+               var err error
+               imports, testImports, err = scanDir(pkg.dir, ld.Tags)
+               if err != nil {
+                       pkg.err = err
+                       return
+               }
+       }
+
        pkg.imports = make([]*loadPkg, 0, len(imports))
        var importFlags loadPkgFlags
        if pkg.flags.has(pkgInAll) {

diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index eb05e9f9c91ce0481a07d1b8953271d124498506..c6667d0bf7944b2dcae558005363d648a05c4c5f 100644 (file)
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -446,10 +446,10 @@ func goModSummary(m module.Version) (*modFileSummary, error) {
        if actual.Path == "" {
                actual = m
        }
-       if cfg.BuildMod == "readonly" && actual.Version != "" {
+       if HasModRoot() && cfg.BuildMod == "readonly" && actual.Version != "" {
                key := module.Version{Path: actual.Path, Version: actual.Version + "/go.mod"}
                if !modfetch.HaveSum(key) {
-                       suggestion := fmt.Sprintf("; try 'go mod download %s' to add it", m.Path)
+                       suggestion := fmt.Sprintf("; to add it:\n\tgo mod download %s", m.Path)
                        return nil, module.VersionError(actual, &sumMissingError{suggestion: suggestion})
                }
        }

diff --git a/src/cmd/go/internal/modload/mvs.go b/src/cmd/go/internal/modload/mvs.go
index 167d6819b06ae51620dc01195eacc30d17116ae1..31015194f9a0192b055615bd8619b0b7a6249c7e 100644 (file)
--- a/src/cmd/go/internal/modload/mvs.go
+++ b/src/cmd/go/internal/modload/mvs.go
@@ -111,19 +111,3 @@ func (*mvsReqs) Previous(m module.Version) (module.Version, error) {
        }
        return module.Version{Path: m.Path, Version: "none"}, nil
 }
-
-// next returns the next version of m.Path after m.Version.
-// It is only used by the exclusion processing in the Required method,
-// not called directly by MVS.
-func (*mvsReqs) next(m module.Version) (module.Version, error) {
-       // TODO(golang.org/issue/38714): thread tracing context through MVS.
-       list, err := versions(context.TODO(), m.Path, CheckAllowed)
-       if err != nil {
-               return module.Version{}, err
-       }
-       i := sort.Search(len(list), func(i int) bool { return semver.Compare(list[i], m.Version) > 0 })
-       if i < len(list) {
-               return module.Version{Path: m.Path, Version: list[i]}, nil
-       }
-       return module.Version{Path: m.Path, Version: "none"}, nil
-}

diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index e35e0fc16e29b7f19790125b04b2e103d8272ec2..8affd179bb2e9c0b1d51fec1b3b2bd80e2254017 100644 (file)
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -21,6 +21,7 @@ import (
        "cmd/go/internal/imports"
        "cmd/go/internal/modfetch"
        "cmd/go/internal/search"
+       "cmd/go/internal/str"
        "cmd/go/internal/trace"
 
        "golang.org/x/mod/module"
@@ -1005,13 +1006,8 @@ func (rr *replacementRepo) Versions(prefix string) ([]string, error) {
        sort.Slice(versions, func(i, j int) bool {
                return semver.Compare(versions[i], versions[j]) < 0
        })
-       uniq := versions[:1]
-       for _, v := range versions {
-               if v != uniq[len(uniq)-1] {
-                       uniq = append(uniq, v)
-               }
-       }
-       return uniq, nil
+       str.Uniq(&versions)
+       return versions, nil
 }
 
 func (rr *replacementRepo) Stat(rev string) (*modfetch.RevInfo, error) {

diff --git a/src/cmd/go/internal/modload/vendor.go b/src/cmd/go/internal/modload/vendor.go
index 80d49053c6c6f0f2b9e91f92dbaebc27a164e5a2..d8fd91f1fea2b20339b4c2f61a1a77f5da6ab15f 100644 (file)
--- a/src/cmd/go/internal/modload/vendor.go
+++ b/src/cmd/go/internal/modload/vendor.go
@@ -214,6 +214,6 @@ func checkVendorConsistency() {
        }
 
        if vendErrors.Len() > 0 {
-               base.Fatalf("go: inconsistent vendoring in %s:%s\n\nrun 'go mod vendor' to sync, or use -mod=mod or -mod=readonly to ignore the vendor directory", modRoot, vendErrors)
+               base.Fatalf("go: inconsistent vendoring in %s:%s\n\n\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo mod vendor", modRoot, vendErrors)
        }
 }

diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index b630b610f10e03641362acf7b385f34781e58cf5..ff2c5f963cd88f13baf94066752084e95a637965 100644 (file)
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -41,6 +41,11 @@ type Reqs interface {
        // Note that v1 < v2 can be written Max(v1, v2) != v1
        // and similarly v1 <= v2 can be written Max(v1, v2) == v2.
        Max(v1, v2 string) string
+}
+
+// An UpgradeReqs is a Reqs that can also identify available upgrades.
+type UpgradeReqs interface {
+       Reqs
 
        // Upgrade returns the upgraded version of m,
        // for use during an UpgradeAll operation.
@@ -54,6 +59,11 @@ type Reqs interface {
        // TODO(rsc): Upgrade must be able to return errors,
        // but should "no latest version" just return m instead?
        Upgrade(m module.Version) (module.Version, error)
+}
+
+// A DowngradeReqs is a Reqs that can also identify available downgrades.
+type DowngradeReqs interface {
+       Reqs
 
        // Previous returns the version of m.Path immediately prior to m.Version,
        // or "none" if no such version is known.
@@ -293,10 +303,15 @@ func Req(target module.Version, base []string, reqs Reqs) ([]module.Version, err
        }
        // First walk the base modules that must be listed.
        var min []module.Version
+       haveBase := map[string]bool{}
        for _, path := range base {
+               if haveBase[path] {
+                       continue
+               }
                m := module.Version{Path: path, Version: max[path]}
                min = append(min, m)
                walk(m)
+               haveBase[path] = true
        }
        // Now the reverse postorder to bring in anything else.
        for i := len(postorder) - 1; i >= 0; i-- {
@@ -318,7 +333,7 @@ func Req(target module.Version, base []string, reqs Reqs) ([]module.Version, err
 
 // UpgradeAll returns a build list for the target module
 // in which every module is upgraded to its latest version.
-func UpgradeAll(target module.Version, reqs Reqs) ([]module.Version, error) {
+func UpgradeAll(target module.Version, reqs UpgradeReqs) ([]module.Version, error) {
        return buildList(target, reqs, func(m module.Version) (module.Version, error) {
                if m.Path == target.Path {
                        return target, nil
@@ -330,7 +345,7 @@ func UpgradeAll(target module.Version, reqs Reqs) ([]module.Version, error) {
 
 // Upgrade returns a build list for the target module
 // in which the given additional modules are upgraded.
-func Upgrade(target module.Version, reqs Reqs, upgrade ...module.Version) ([]module.Version, error) {
+func Upgrade(target module.Version, reqs UpgradeReqs, upgrade ...module.Version) ([]module.Version, error) {
        list, err := reqs.Required(target)
        if err != nil {
                return nil, err
@@ -369,11 +384,20 @@ func Upgrade(target module.Version, reqs Reqs, upgrade ...module.Version) ([]mod
 // The versions to be downgraded may be unreachable from reqs.Latest and
 // reqs.Previous, but the methods of reqs must otherwise handle such versions
 // correctly.
-func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([]module.Version, error) {
-       list, err := reqs.Required(target)
+func Downgrade(target module.Version, reqs DowngradeReqs, downgrade ...module.Version) ([]module.Version, error) {
+       // Per https://research.swtch.com/vgo-mvs#algorithm_4:
+       // “To avoid an unnecessary downgrade to E 1.1, we must also add a new
+       // requirement on E 1.2. We can apply Algorithm R to find the minimal set of
+       // new requirements to write to go.mod.”
+       //
+       // In order to generate those new requirements, we need to identify versions
+       // for every module in the build list — not just reqs.Required(target).
+       list, err := BuildList(target, reqs)
        if err != nil {
                return nil, err
        }
+       list = list[1:] // remove target
+
        max := make(map[string]string)
        for _, r := range list {
                max[r.Path] = r.Version
@@ -406,6 +430,9 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
                }
                added[m] = true
                if v, ok := max[m.Path]; ok && reqs.Max(m.Version, v) != v {
+                       // m would upgrade an existing dependency — it is not a strict downgrade,
+                       // and because it was already present as a dependency, it could affect the
+                       // behavior of other relevant packages.
                        exclude(m)
                        return
                }
@@ -422,6 +449,7 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
                        // is transient (we couldn't download go.mod), return the error from
                        // Downgrade. Currently, we can't tell what kind of error it is.
                        exclude(m)
+                       return
                }
                for _, r := range list {
                        add(r)
@@ -433,8 +461,8 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
                }
        }
 
-       var out []module.Version
-       out = append(out, target)
+       downgraded := make([]module.Version, 0, len(list)+1)
+       downgraded = append(downgraded, target)
 List:
        for _, r := range list {
                add(r)
@@ -461,10 +489,14 @@ List:
                        add(p)
                        r = p
                }
-               out = append(out, r)
+               downgraded = append(downgraded, r)
        }
 
-       return out, nil
+       return BuildList(target, &override{
+               target: target,
+               list:   downgraded,
+               Reqs:   reqs,
+       })
 }
 
 type override struct {

diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index 721cd9635c8d84dabead835817dfa9f817b97fc2..742e396e0dc95e86e97e230e8b13d79c9f75029a 100644 (file)
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -28,10 +28,11 @@ D4: E2 F1
 D5: E2
 G1: C4
 A2: B1 C4 D4
-build A: A B1 C2 D4 E2 F1
-upgrade* A: A B1 C4 D5 E2 F1 G1
-upgrade A C4: A B1 C4 D4 E2 F1 G1
-downgrade A2 D2: A2 C4 D2
+build A:       A B1 C2 D4 E2 F1
+upgrade* A:    A B1 C4 D5 E2 F1 G1
+upgrade A C4:  A B1 C4 D4 E2 F1 G1
+build A2:     A2 B1 C4 D4 E2 F1 G1
+downgrade A2 D2: A2 C4 D2 E2 F1 G1
 
 name: trim
 A: B1 C2
@@ -68,7 +69,7 @@ B2: D1
 C: D2
 D1: E2
 D2: E1
-build A: A B1 C D2 E1
+build A:      A B1 C D2 E1
 upgrade A B2: A B2 C D2 E2
 
 name: cross1R
@@ -136,17 +137,17 @@ name: cross5
 A: D1
 D1: E2
 D2: E1
-build A: A D1 E2
-upgrade* A: A D2 E2
-upgrade A D2: A D2 E2
+build A:       A D1 E2
+upgrade* A:    A D2 E2
+upgrade A D2:  A D2 E2
 upgradereq A D2: D2 E2
 
 name: cross6
 A: D2
 D1: E2
 D2: E1
-build A: A D2 E1
-upgrade* A: A D2 E2
+build A:      A D2 E1
+upgrade* A:   A D2 E2
 upgrade A E2: A D2 E2
 
 name: cross7
@@ -175,7 +176,7 @@ B1: D1
 B2:
 C2:
 D2:
-build A: A B1 C1 D1
+build A:    A B1 C1 D1
 upgrade* A: A B2 C2 D2
 
 name: simplify
@@ -194,7 +195,7 @@ B4:
 B5.hidden:
 C2:
 C3:
-build A: A B1 C1
+build A:    A B1 C1
 upgrade* A: A B4 C3
 
 name: up2
@@ -206,15 +207,15 @@ B4:
 B5.hidden:
 C2:
 C3:
-build A: A B5.hidden C1
+build A:    A B5.hidden C1
 upgrade* A: A B5.hidden C3
 
 name: down1
 A: B2
 B1: C1
 B2: C2
-build A: A B2 C2
-downgrade A C1: A B1
+build A:        A B2 C2
+downgrade A C1: A B1 C1
 
 name: down2
 A: B2 E2
@@ -227,12 +228,51 @@ D2: B2
 E2: D2
 E1:
 F1:
-downgrade A F1: A B1 E1
+build A:        A B2 C2 D2 E2 F2
+downgrade A F1: A B1 C1 D1 E1 F1
+
+# https://research.swtch.com/vgo-mvs#algorithm_4:
+# “[D]owngrades are constrained to only downgrade packages, not also upgrade
+# them; if an upgrade before downgrade is needed, the user must ask for it
+# explicitly.”
+#
+# Here, downgrading B2 to B1 upgrades C1 to C2, and C2 does not depend on D2.
+# However, C2 would be an upgrade — not a downgrade — so B1 must also be
+# rejected.
+name: downcross1
+A: B2 C1
+B1: C2
+B2: C1
+C1: D2
+C2:
+D1:
+D2:
+build A:        A B2 C1 D2
+downgrade A D1: A       D1
+
+# https://research.swtch.com/vgo-mvs#algorithm_4:
+# “Unlike upgrades, downgrades must work by removing requirements, not adding
+# them.”
+#
+# However, downgrading a requirement may introduce a new requirement on a
+# previously-unrequired module. If each dependency's requirements are complete
+# (“tidy”), that can't change the behavior of any other package whose version is
+# not also being downgraded, so we should allow it.
+name: downcross2
+A: B2
+B1: C1
+B2: D2
+C1:
+D1:
+D2:
+build A:        A B2    D2
+downgrade A D1: A B1 C1 D1
 
 name: downcycle
 A: A B2
 B2: A
 B1:
+build A:        A B2
 downgrade A B1: A B1
 
 # golang.org/issue/25542.
@@ -240,6 +280,7 @@ name: noprev1
 A: B4 C2
 B2.hidden:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 name: noprev2
@@ -247,6 +288,7 @@ A: B4 C2
 B2.hidden:
 B1:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 name: noprev3
@@ -254,6 +296,7 @@ A: B4 C2
 B3:
 B2.hidden:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 # Cycles involving the target.
@@ -264,9 +307,9 @@ A: B1
 B1: A1
 B2: A2
 B3: A3
-build A: A B1
+build A:      A B1
 upgrade A B2: A B2
-upgrade* A: A B3
+upgrade* A:   A B3
 
 # golang.org/issue/29773:
 # Requirements of older versions of the target
@@ -280,7 +323,7 @@ B2: A2
 C1: A2
 C2:
 D2:
-build A: A B1 C1 D1
+build A:    A B1 C1 D1
 upgrade* A: A B2 C2 D2
 
 # Cycles with multiple possible solutions.
@@ -293,23 +336,23 @@ B2: C2
 C1:
 C2: B2
 build M: M A1 B2 C2
-req M: A1 B2
-req M A: A1 B2
-req M C: A1 C2
+req M:     A1 B2
+req M A:   A1 B2
+req M C:   A1 C2
 
 # Requirement minimization.
 
 name: req1
 A: B1 C1 D1 E1 F1
 B1: C1 E1 F1
-req A: B1 D1
+req A:   B1    D1
 req A C: B1 C1 D1
 
 name: req2
 A: G1 H1
 G1: H1
 H1: G1
-req A: G1
+req A:   G1
 req A G: G1
 req A H: H1
 
@@ -326,7 +369,20 @@ M: Anone B1 D1 E1
 B1: Cnone D1
 E1: Fnone
 build M: M B1 D1 E1
-req M: B1 E1
+req M:     B1    E1
+
+name: reqdup
+M: A1 B1
+A1: B1
+B1:
+req M A A: A1
+
+name: reqcross
+M: A1 B1 C1
+A1: B1 C1
+B1: C1
+C1:
+req M A B: A1 B1
 `
 
 func Test(t *testing.T) {

diff --git a/src/cmd/go/internal/str/str.go b/src/cmd/go/internal/str/str.go
index 0413ed8e69e19992effa8e68a7ff57e2222cc2fd..9106ebf74d5e31cb04e7deddf26e1a72ff6e9c74 100644 (file)
--- a/src/cmd/go/internal/str/str.go
+++ b/src/cmd/go/internal/str/str.go
@@ -96,6 +96,20 @@ func Contains(x []string, s string) bool {
        return false
 }
 
+// Uniq removes consecutive duplicate strings from ss.
+func Uniq(ss *[]string) {
+       if len(*ss) <= 1 {
+               return
+       }
+       uniq := (*ss)[:1]
+       for _, s := range *ss {
+               if s != uniq[len(uniq)-1] {
+                       uniq = append(uniq, s)
+               }
+       }
+       *ss = uniq
+}
+
 func isSpaceByte(c byte) bool {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r'
 }

diff --git a/src/cmd/go/internal/test/genflags.go b/src/cmd/go/internal/test/genflags.go
index ca16113bb88ed8080ffc5af9e5ced82a833ec522..949d65ae808b5f25bb99ef25b77a2af89da3ecd6 100644 (file)
--- a/src/cmd/go/internal/test/genflags.go
+++ b/src/cmd/go/internal/test/genflags.go
@@ -9,9 +9,9 @@ package main
 import (
        "bytes"
        "flag"
+       exec "internal/execabs"
        "log"
        "os"
-       "os/exec"
        "strings"
        "testing"
        "text/template"

diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 28e49e44b53d4d870cbb63db739b1ea5d7484581..c713394141e013922692b7375d0c74acc31cd235 100644 (file)
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -11,10 +11,10 @@ import (
        "errors"
        "fmt"
        "go/build"
+       exec "internal/execabs"
        "io"
        "io/fs"
        "os"
-       "os/exec"
        "path"
        "path/filepath"
        "regexp"
@@ -596,7 +596,8 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
        work.VetFlags = testVet.flags
        work.VetExplicit = testVet.explicit
 
-       pkgs = load.PackagesForBuild(ctx, pkgArgs)
+       pkgs = load.PackagesAndErrors(ctx, pkgArgs)
+       load.CheckPackageErrors(pkgs)
        if len(pkgs) == 0 {
                base.Fatalf("no packages to test")
        }
@@ -679,7 +680,9 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
                sort.Strings(all)
 
                a := &work.Action{Mode: "go test -i"}
-               for _, p := range load.PackagesForBuild(ctx, all) {
+               pkgs := load.PackagesAndErrors(ctx, all)
+               load.CheckPackageErrors(pkgs)
+               for _, p := range pkgs {
                        if cfg.BuildToolchainName == "gccgo" && p.Standard {
                                // gccgo's standard library packages
                                // can not be reinstalled.

diff --git a/src/cmd/go/internal/test/testflag.go b/src/cmd/go/internal/test/testflag.go
index 2669aac831963af417e5162d189c27acb56ad5c1..e11b41ba76b2f68fadadf3d07d947ec2935139e4 100644 (file)
--- a/src/cmd/go/internal/test/testflag.go
+++ b/src/cmd/go/internal/test/testflag.go
@@ -327,7 +327,7 @@ func testFlags(args []string) (packageNames, passToTest []string) {
                if !testC {
                        buildFlag = "-i"
                }
-               fmt.Fprintf(os.Stderr, "flag %s is not a 'go test' flag (unknown flags cannot be used with %s)\n", firstUnknownFlag, buildFlag)
+               fmt.Fprintf(os.Stderr, "go test: unknown flag %s cannot be used with %s\n", firstUnknownFlag, buildFlag)
                exitWithUsage()
        }
 

diff --git a/src/cmd/go/internal/tool/tool.go b/src/cmd/go/internal/tool/tool.go
index 7f4dc8680211c68c87b2cd4e5bbb1daefcbf7dce..95c90ea7c8da4a3f5121af3d78db4b80d8b18f65 100644 (file)
--- a/src/cmd/go/internal/tool/tool.go
+++ b/src/cmd/go/internal/tool/tool.go
@@ -8,8 +8,9 @@ package tool
 import (
        "context"
        "fmt"
+       exec "internal/execabs"
        "os"
-       "os/exec"
+       "os/signal"
        "sort"
        "strings"
 
@@ -85,7 +86,19 @@ func runTool(ctx context.Context, cmd *base.Command, args []string) {
                Stdout: os.Stdout,
                Stderr: os.Stderr,
        }
-       err := toolCmd.Run()
+       err := toolCmd.Start()
+       if err == nil {
+               c := make(chan os.Signal, 100)
+               signal.Notify(c)
+               go func() {
+                       for sig := range c {
+                               toolCmd.Process.Signal(sig)
+                       }
+               }()
+               err = toolCmd.Wait()
+               signal.Stop(c)
+               close(c)
+       }
        if err != nil {
                // Only print about the exit status if the command
                // didn't even run (not an ExitError) or it didn't exit cleanly

diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go
index 4894ecdc35655643608c4e7e63bb642d3692fc36..9feffe07656e84fa7fc821e5b52250d85077bedf 100644 (file)
--- a/src/cmd/go/internal/vcs/vcs.go
+++ b/src/cmd/go/internal/vcs/vcs.go
@@ -8,13 +8,13 @@ import (
        "encoding/json"
        "errors"
        "fmt"
+       exec "internal/execabs"
        "internal/lazyregexp"
        "internal/singleflight"
        "io/fs"
        "log"
        urlpkg "net/url"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "strings"
@@ -729,7 +729,7 @@ func checkGOVCS(vcs *Cmd, root string) error {
                if private {
                        what = "private"
                }
-               return fmt.Errorf("GOVCS disallows using %s for %s %s", vcs.Cmd, what, root)
+               return fmt.Errorf("GOVCS disallows using %s for %s %s; see 'go help vcs'", vcs.Cmd, what, root)
        }
 
        return nil

diff --git a/src/cmd/go/internal/vet/vet.go b/src/cmd/go/internal/vet/vet.go
index b1bf806e46a432a23ee70a5dcc29c4824e3322fc..4257c90c97a193ca5a80b8a5a82abb04a98a1a81 100644 (file)
--- a/src/cmd/go/internal/vet/vet.go
+++ b/src/cmd/go/internal/vet/vet.go
@@ -87,7 +87,8 @@ func runVet(ctx context.Context, cmd *base.Command, args []string) {
                }
        }
 
-       pkgs := load.PackagesForBuild(ctx, pkgArgs)
+       pkgs := load.PackagesAndErrors(ctx, pkgArgs)
+       load.CheckPackageErrors(pkgs)
        if len(pkgs) == 0 {
                base.Fatalf("no packages to vet")
        }

diff --git a/src/cmd/go/internal/vet/vetflag.go b/src/cmd/go/internal/vet/vetflag.go
index ef995ef83539a1f2e7017fd12b3bbd6384abcb81..b5b3c462ff2acced306e495a173b43be76fd579b 100644 (file)
--- a/src/cmd/go/internal/vet/vetflag.go
+++ b/src/cmd/go/internal/vet/vetflag.go
@@ -10,9 +10,9 @@ import (
        "errors"
        "flag"
        "fmt"
+       exec "internal/execabs"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
 
@@ -184,7 +184,8 @@ func exitWithUsage() {
        if vetTool != "" {
                cmd = vetTool
        }
-       fmt.Fprintf(os.Stderr, "Run '%s -help' for the vet tool's flags.\n", cmd)
+       fmt.Fprintf(os.Stderr, "Run '%s help' for a full list of flags and analyzers.\n", cmd)
+       fmt.Fprintf(os.Stderr, "Run '%s -help' for an overview.\n", cmd)
 
        base.SetExitStatus(2)
        base.Exit()

diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index be5532d7aae750faaa33c89cc77461a3ff88b92c..0e7af6d33f570685d1ac135b30819d08bbd55d08 100644 (file)
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -9,9 +9,9 @@ import (
        "errors"
        "fmt"
        "go/build"
+       exec "internal/execabs"
        "internal/goroot"
        "os"
-       "os/exec"
        "path"
        "path/filepath"
        "runtime"
@@ -71,7 +71,7 @@ and test commands:
        -p n
                the number of programs, such as build commands or
                test binaries, that can be run in parallel.
-               The default is the number of CPUs available.
+               The default is GOMAXPROCS, normally the number of CPUs available.
        -race
                enable data race detection.
                Supported only on linux/amd64, freebsd/amd64, darwin/amd64, windows/amd64,
@@ -113,7 +113,10 @@ and test commands:
                created with -buildmode=shared.
        -mod mode
                module download mode to use: readonly, vendor, or mod.
-               See 'go help modules' for more.
+               By default, if a vendor directory is present and the go version in go.mod
+               is 1.14 or higher, the go command acts as if -mod=vendor were set.
+               Otherwise, the go command acts as if -mod=readonly were set.
+               See https://golang.org/ref/mod#build-commands for details.
        -modcacherw
                leave newly-created directories in the module cache read-write
                instead of making them read-only.
@@ -369,7 +372,8 @@ func runBuild(ctx context.Context, cmd *base.Command, args []string) {
        var b Builder
        b.Init()
 
-       pkgs := load.PackagesForBuild(ctx, args)
+       pkgs := load.PackagesAndErrors(ctx, args)
+       load.CheckPackageErrors(pkgs)
 
        explicitO := len(cfg.BuildO) > 0
 
@@ -399,7 +403,7 @@ func runBuild(ctx context.Context, cmd *base.Command, args []string) {
                fmt.Fprint(os.Stderr, "go build: -i flag is deprecated\n")
        }
 
-       pkgs = omitTestOnly(pkgsFilter(load.Packages(ctx, args)))
+       pkgs = omitTestOnly(pkgsFilter(pkgs))
 
        // Special case -o /dev/null by not writing at all.
        if cfg.BuildO == os.DevNull {
@@ -582,8 +586,32 @@ func runInstall(ctx context.Context, cmd *base.Command, args []string) {
                        return
                }
        }
+
        BuildInit()
-       pkgs := load.PackagesForBuild(ctx, args)
+       pkgs := load.PackagesAndErrors(ctx, args)
+       if cfg.ModulesEnabled && !modload.HasModRoot() {
+               haveErrors := false
+               allMissingErrors := true
+               for _, pkg := range pkgs {
+                       if pkg.Error == nil {
+                               continue
+                       }
+                       haveErrors = true
+                       if missingErr := (*modload.ImportMissingError)(nil); !errors.As(pkg.Error, &missingErr) {
+                               allMissingErrors = false
+                               break
+                       }
+               }
+               if haveErrors && allMissingErrors {
+                       latestArgs := make([]string, len(args))
+                       for i := range args {
+                               latestArgs[i] = args[i] + "@latest"
+                       }
+                       hint := strings.Join(latestArgs, " ")
+                       base.Fatalf("go install: version is required when current directory is not in a module\n\tTry 'go install %s' to install the latest version", hint)
+               }
+       }
+       load.CheckPackageErrors(pkgs)
        if cfg.BuildI {
                allGoroot := true
                for _, pkg := range pkgs {
@@ -596,6 +624,7 @@ func runInstall(ctx context.Context, cmd *base.Command, args []string) {
                        fmt.Fprint(os.Stderr, "go install: -i flag is deprecated\n")
                }
        }
+
        InstallPackages(ctx, args, pkgs)
 }
 
@@ -813,7 +842,7 @@ func installOutsideModule(ctx context.Context, args []string) {
 
        // Load packages for all arguments. Ignore non-main packages.
        // Print a warning if an argument contains "..." and matches no main packages.
-       // PackagesForBuild already prints warnings for patterns that don't match any
+       // PackagesAndErrors already prints warnings for patterns that don't match any
        // packages, so be careful not to double print.
        matchers := make([]func(string) bool, len(patterns))
        for i, p := range patterns {
@@ -824,7 +853,8 @@ func installOutsideModule(ctx context.Context, args []string) {
 
        // TODO(golang.org/issue/40276): don't report errors loading non-main packages
        // matched by a pattern.
-       pkgs := load.PackagesForBuild(ctx, patterns)
+       pkgs := load.PackagesAndErrors(ctx, patterns)
+       load.CheckPackageErrors(pkgs)
        mainPkgs := make([]*load.Package, 0, len(pkgs))
        mainCount := make([]int, len(patterns))
        nonMainCount := make([]int, len(patterns))

diff --git a/src/cmd/go/internal/work/buildid.go b/src/cmd/go/internal/work/buildid.go
index d76988145bedc780d61375ee9a3f3d60f5c99756..c555d4a9f1ed036367fbfc0a0ed4d4e748919e09 100644 (file)
--- a/src/cmd/go/internal/work/buildid.go
+++ b/src/cmd/go/internal/work/buildid.go
@@ -7,8 +7,8 @@ package work
 import (
        "bytes"
        "fmt"
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "strings"
 
        "cmd/go/internal/base"

diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index feb2299d40132bfc196142902c0d6dbd271673a9..422e83c224f84c7ae43f2e7036ca0eab5b9b90d2 100644 (file)
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -13,13 +13,13 @@ import (
        "encoding/json"
        "errors"
        "fmt"
+       exec "internal/execabs"
        "internal/lazyregexp"
        "io"
        "io/fs"
        "log"
        "math/rand"
        "os"
-       "os/exec"
        "path/filepath"
        "regexp"
        "runtime"
@@ -1164,6 +1164,7 @@ func (b *Builder) vet(ctx context.Context, a *Action) error {
                return err
        }
 
+       // TODO(rsc): Why do we pass $GCCGO to go vet?
        env := b.cCompilerEnv()
        if cfg.BuildToolchainName == "gccgo" {
                env = append(env, "GCCGO="+BuildToolchain.compiler())
@@ -2044,6 +2045,9 @@ func (b *Builder) runOut(a *Action, dir string, env []string, cmdargs ...interfa
 
        var buf bytes.Buffer
        cmd := exec.Command(cmdline[0], cmdline[1:]...)
+       if cmd.Path != "" {
+               cmd.Args[0] = cmd.Path
+       }
        cmd.Stdout = &buf
        cmd.Stderr = &buf
        cleanup := passLongArgsInResponseFiles(cmd)
@@ -2435,7 +2439,7 @@ func (b *Builder) fcExe() []string {
 func (b *Builder) compilerExe(envValue string, def string) []string {
        compiler := strings.Fields(envValue)
        if len(compiler) == 0 {
-               compiler = []string{def}
+               compiler = strings.Fields(def)
        }
        return compiler
 }
@@ -2581,7 +2585,14 @@ func (b *Builder) gccArchArgs() []string {
        case "386":
                return []string{"-m32"}
        case "amd64":
+               if cfg.Goos == "darwin" {
+                       return []string{"-arch", "x86_64", "-m64"}
+               }
                return []string{"-m64"}
+       case "arm64":
+               if cfg.Goos == "darwin" {
+                       return []string{"-arch", "arm64"}
+               }
        case "arm":
                return []string{"-marm"} // not thumb
        case "s390x":
@@ -2709,7 +2720,7 @@ func (b *Builder) cgo(a *Action, cgoExe, objdir string, pcCFLAGS, pcLDFLAGS, cgo
                for i, f := range cgoLDFLAGS {
                        flags[i] = strconv.Quote(f)
                }
-               cgoenv = []string{"CGO_LDFLAGS=" + strings.Join(flags, " ")}
+               cgoenv = append(cgoenv, "CGO_LDFLAGS="+strings.Join(flags, " "))
        }
 
        if cfg.BuildToolchainName == "gccgo" {

diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index cc4e2b2b2b96553f0d899ca2f92e8f367bd4dea5..2087855b3c04a96c632f22f93875612a5b91c749 100644 (file)
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -129,7 +129,11 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
                }
        }
 
-       args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs, "-D", p.Internal.LocalPrefix}
+       args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs}
+       if p.Internal.LocalPrefix != "" {
+               // Workaround #43883.
+               args = append(args, "-D", p.Internal.LocalPrefix)
+       }
        if importcfg != nil {
                if err := b.writeFile(objdir+"importcfg", importcfg); err != nil {
                        return "", nil, err
@@ -235,16 +239,19 @@ CheckFlags:
        //   - it has no successor packages to compile (usually package main)
        //   - all paths through the build graph pass through it
        //   - critical path scheduling says it is high priority
-       // and in such a case, set c to runtime.NumCPU.
+       // and in such a case, set c to runtime.GOMAXPROCS(0).
+       // By default this is the same as runtime.NumCPU.
        // We do this now when p==1.
+       // To limit parallelism, set GOMAXPROCS below numCPU; this may be useful
+       // on a low-memory builder, or if a deterministic build order is required.
+       c := runtime.GOMAXPROCS(0)
        if cfg.BuildP == 1 {
-               // No process parallelism. Max out c.
-               return runtime.NumCPU()
+               // No process parallelism, do not cap compiler parallelism.
+               return c
        }
-       // Some process parallelism. Set c to min(4, numcpu).
-       c := 4
-       if ncpu := runtime.NumCPU(); ncpu < c {
-               c = ncpu
+       // Some process parallelism. Set c to min(4, maxprocs).
+       if c > 4 {
+               c = 4
        }
        return c
 }

diff --git a/src/cmd/go/internal/work/gccgo.go b/src/cmd/go/internal/work/gccgo.go
index 3ffd01c473b8100101970be351d86cd27813395f..b58c8aa8854a459a53f5226a322eee342af296ab 100644 (file)
--- a/src/cmd/go/internal/work/gccgo.go
+++ b/src/cmd/go/internal/work/gccgo.go
@@ -6,8 +6,8 @@ package work
 
 import (
        "fmt"
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
        "sync"
@@ -93,6 +93,12 @@ func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg,
                        args = append(args, "-I", root)
                }
        }
+       if embedcfg != nil && b.gccSupportsFlag(args[:1], "-fgo-embedcfg=/dev/null") {
+               if err := b.writeFile(objdir+"embedcfg", embedcfg); err != nil {
+                       return "", nil, err
+               }
+               args = append(args, "-fgo-embedcfg="+objdir+"embedcfg")
+       }
 
        if b.gccSupportsFlag(args[:1], "-ffile-prefix-map=a=b") {
                if cfg.BuildTrimpath {

diff --git a/src/cmd/go/testdata/addmod.go b/src/cmd/go/testdata/addmod.go
index 58376b7ed4ace8df006bba91e703b210f42bf5e6..09fc8e713bcbcfbc9ad226567369df1f2387d446 100644 (file)
--- a/src/cmd/go/testdata/addmod.go
+++ b/src/cmd/go/testdata/addmod.go
@@ -25,7 +25,7 @@ import (
        "io/fs"
        "log"
        "os"
-       "os/exec"
+       exec "internal/execabs"
        "path/filepath"
        "strings"
 

diff --git a/src/cmd/go/testdata/script/build_darwin_cc_arch.txt b/src/cmd/go/testdata/script/build_darwin_cc_arch.txt
new file mode 100644 (file)
index 0000000..2b81b4c
--- /dev/null
+++ b/src/cmd/go/testdata/script/build_darwin_cc_arch.txt
@@ -0,0 +1,24 @@
+# Test that we pass -arch flag to C compiler on Darwin (issue 43692).
+
+[!darwin] skip
+[!cgo] skip
+
+# clear CC, in case user sets it
+env CC=
+
+env CGO_ENABLED=1
+
+env GOARCH=amd64
+go build -n -x c.go
+stderr 'clang.*-arch x86_64'
+
+env GOARCH=arm64
+go build -n -x c.go
+stderr 'clang.*-arch arm64'
+
+-- c.go --
+package main
+
+import "C"
+
+func main() {}

diff --git a/src/cmd/go/testdata/script/build_trimpath.txt b/src/cmd/go/testdata/script/build_trimpath.txt
index e1ea0a48b2acfec72a585b6d31cb05718dc9c42b..2c3bee8fdc7a925bb9bd9bdcee078a36b0ed9581 100644 (file)
--- a/src/cmd/go/testdata/script/build_trimpath.txt
+++ b/src/cmd/go/testdata/script/build_trimpath.txt
@@ -121,6 +121,7 @@ package main
 import (
        "bytes"
        "fmt"
+       "io/ioutil"
        "log"
        "os"
        "os/exec"
@@ -130,7 +131,7 @@ import (
 
 func main() {
        exe := os.Args[1]
-       data, err := os.ReadFile(exe)
+       data, err := ioutil.ReadFile(exe)
        if err != nil {
                log.Fatal(err)
        }

diff --git a/src/cmd/go/testdata/script/cgo_path.txt b/src/cmd/go/testdata/script/cgo_path.txt
new file mode 100644 (file)
index 0000000..be9609e
--- /dev/null
+++ b/src/cmd/go/testdata/script/cgo_path.txt
@@ -0,0 +1,43 @@
+[!cgo] skip
+
+# Set CC explicitly to something that requires a PATH lookup.
+# Normally, the default is gcc or clang, but if CC was set during make.bash,
+# that becomes the default.
+[exec:clang] env CC=clang
+[exec:gcc] env CC=gcc
+[!exec:clang] [!exec:gcc] skip 'Unknown C compiler'
+
+env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
+[!windows] env PATH=.:$PATH
+[!windows] chmod 0755 p/gcc p/clang
+[!windows] exists -exec p/gcc p/clang
+[windows] exists -exec p/gcc.bat p/clang.bat
+! exists p/bug.txt
+! go build -x
+stderr '^cgo: exec (clang|gcc): (clang|gcc) resolves to executable relative to current directory \(.[/\\](clang|gcc)(.bat)?\)$'
+! exists p/bug.txt
+
+-- go.mod --
+module m
+
+-- m.go --
+package m
+
+import _ "m/p"
+
+-- p/p.go --
+package p
+
+// #define X 1
+import "C"
+
+-- p/gcc --
+#!/bin/sh
+echo ran gcc >bug.txt
+-- p/clang --
+#!/bin/sh
+echo ran clang >bug.txt
+-- p/gcc.bat --
+echo ran gcc >bug.txt
+-- p/clang.bat --
+echo ran clang >bug.txt

diff --git a/src/cmd/go/testdata/script/cgo_path_space.txt b/src/cmd/go/testdata/script/cgo_path_space.txt
new file mode 100644 (file)
index 0000000..654295d
--- /dev/null
+++ b/src/cmd/go/testdata/script/cgo_path_space.txt
@@ -0,0 +1,56 @@
+# Check that if the PATH directory containing the C compiler has a space,
+# we can still use that compiler with cgo.
+# Verifies #43808.
+[!cgo] skip
+
+# Set CC explicitly to something that requires a PATH lookup.
+# Normally, the default is gcc or clang, but if CC was set during make.bash,
+# that becomes the default.
+[exec:clang] env CC=clang
+[exec:gcc] env CC=gcc
+[!exec:clang] [!exec:gcc] skip 'Unknown C compiler'
+
+[!windows] chmod 0755 $WORK/'program files'/clang
+[!windows] chmod 0755 $WORK/'program files'/gcc
+[!windows] exists -exec $WORK/'program files'/clang
+[!windows] exists -exec $WORK/'program files'/gcc
+[!windows] env PATH=$WORK/'program files':$PATH
+[windows] exists -exec $WORK/'program files'/gcc.bat
+[windows] exists -exec $WORK/'program files'/clang.bat
+[windows] env PATH=$WORK\'program files';%PATH%
+
+! exists $WORK/log.txt
+? go build -x
+exists $WORK/log.txt
+rm $WORK/log.txt
+
+# TODO(#41400, #43078): when CC is set explicitly, it should be allowed to
+# contain spaces separating arguments, and it should be possible to quote
+# arguments with spaces (including the path), as in CGO_CFLAGS and other
+# variables. For now, this doesn't work.
+[!windows] env CC=$WORK/'program files'/gcc
+[windows] env CC=$WORK\'program files'\gcc.bat
+! go build -x
+! exists $WORK/log.txt
+
+-- go.mod --
+module m
+
+-- m.go --
+package m
+
+// #define X 1
+import "C"
+
+-- $WORK/program files/gcc --
+#!/bin/sh
+
+echo ok >$WORK/log.txt
+-- $WORK/program files/clang --
+#!/bin/sh
+
+echo ok >$WORK/log.txt
+-- $WORK/program files/gcc.bat --
+echo ok >%WORK%\log.txt
+-- $WORK/program files/clang.bat --
+echo ok >%WORK%\log.txt

diff --git a/src/cmd/go/testdata/script/embed.txt b/src/cmd/go/testdata/script/embed.txt
index 7e9a548661071e8308b1a732411c98c0eb423925..6ad42e9cd18c3894931eeb25c47bba17fde519b2 100644 (file)
--- a/src/cmd/go/testdata/script/embed.txt
+++ b/src/cmd/go/testdata/script/embed.txt
@@ -3,6 +3,14 @@ go list -f '{{.EmbedPatterns}}'
 stdout '\[x\*t\*t\]'
 go list -f '{{.EmbedFiles}}'
 stdout '\[x.txt\]'
+go list -test -f '{{.TestEmbedPatterns}}'
+stdout '\[y\*t\*t\]'
+go list -test -f '{{.TestEmbedFiles}}'
+stdout '\[y.txt\]'
+go list -test -f '{{.XTestEmbedPatterns}}'
+stdout '\[z\*t\*t\]'
+go list -test -f '{{.XTestEmbedFiles}}'
+stdout '\[z.txt\]'
 
 # build embeds x.txt
 go build -x
@@ -20,7 +28,7 @@ cp x.go2 x.go
 go build -x
 cp x.txt .git
 ! go build -x
-stderr 'pattern [*]t: cannot embed file [.]git'
+stderr '^x.go:5:12: pattern [*]t: cannot embed file [.]git: invalid name [.]git$'
 rm .git
 
 # build rejects symlinks
@@ -32,19 +40,26 @@ rm .git
 # build rejects empty directories
 mkdir t
 ! go build -x
-stderr 'pattern [*]t: cannot embed directory t: contains no embeddable files'
+stderr '^x.go:5:12: pattern [*]t: cannot embed directory t: contains no embeddable files$'
 
 # build ignores symlinks and invalid names in directories
 cp x.txt t/.git
 ! go build -x
-stderr 'pattern [*]t: cannot embed directory t: contains no embeddable files'
+stderr '^x.go:5:12: pattern [*]t: cannot embed directory t: contains no embeddable files$'
+go list -e -f '{{.Incomplete}}'
+stdout 'true'
 [symlink] symlink t/x.link -> ../x.txt
 [symlink] ! go build -x
-[symlink] stderr 'pattern [*]t: cannot embed directory t: contains no embeddable files'
+[symlink] stderr '^x.go:5:12: pattern [*]t: cannot embed directory t: contains no embeddable files$'
 
 cp x.txt t/x.txt
 go build -x
 
+# build reports errors with positions in imported packages
+rm t/x.txt
+! go build m/use
+stderr '^x.go:5:12: pattern [*]t: cannot embed directory t: contains no embeddable files$'
+
 -- x.go --
 package p
 
@@ -53,6 +68,22 @@ import "embed"
 //go:embed x*t*t
 var X embed.FS
 
+-- x_test.go --
+package p
+
+import "embed"
+
+//go:embed y*t*t
+var Y string
+
+-- x_x_test.go --
+package p_test
+
+import "embed"
+
+//go:embed z*t*t
+var Z string
+
 -- x.go2 --
 package p
 
@@ -64,9 +95,15 @@ var X embed.FS
 -- x.txt --
 hello
 
+-- y.txt --
+-- z.txt --
 -- x.txt2 --
 not hello
 
+-- use/use.go --
+package use
+
+import _ "m"
 -- go.mod --
 module m
 

diff --git a/src/cmd/go/testdata/script/embed_fmt.txt b/src/cmd/go/testdata/script/embed_fmt.txt
new file mode 100644 (file)
index 0000000..8a16afe
--- /dev/null
+++ b/src/cmd/go/testdata/script/embed_fmt.txt
@@ -0,0 +1,22 @@
+# go fmt ignores file not found
+go fmt xnofmt.go
+cmp xnofmt.go xfmt.ref
+! go build xnofmt.go
+stderr 'xnofmt.go:5:12: pattern missing.txt: no matching files found'
+
+-- xnofmt.go --
+package p
+
+import "embed"
+
+//go:embed missing.txt
+var X  embed.FS
+-- xfmt.ref --
+package p
+
+import "embed"
+
+//go:embed missing.txt
+var X embed.FS
+-- go.mod --
+module m

diff --git a/src/cmd/go/testdata/script/govcs.txt b/src/cmd/go/testdata/script/govcs.txt
index 35f092ee4935501dacf04b3bc224ee22fd757730..4180d7da6ab159addd14d344d7d5135e07d50f9d 100644 (file)
--- a/src/cmd/go/testdata/script/govcs.txt
+++ b/src/cmd/go/testdata/script/govcs.txt
@@ -5,40 +5,40 @@ env GOPROXY=direct
 # GOVCS stops go get
 env GOVCS='*:none'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 env GOPRIVATE='github.com/google'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for private github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for private github.com/google/go-cmp; see ''go help vcs''$'
 
 # public pattern works
 env GOPRIVATE='github.com/google'
 env GOVCS='public:all,private:none'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for private github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for private github.com/google/go-cmp; see ''go help vcs''$'
 
 # private pattern works
 env GOPRIVATE='hubgit.com/google'
 env GOVCS='private:all,public:none'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 
 # other patterns work (for more patterns, see TestGOVCS)
 env GOPRIVATE=
 env GOVCS='github.com:svn|hg'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 env GOVCS='github.com/google/go-cmp/inner:git,github.com:svn|hg'
 ! go get github.com/google/go-cmp
-stderr 'go get: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^go get: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 
 # bad patterns are reported (for more bad patterns, see TestGOVCSErrors)
 env GOVCS='git'
 ! go get github.com/google/go-cmp
-stderr 'go get github.com/google/go-cmp: malformed entry in GOVCS \(missing colon\): "git"'
+stderr '^go get github.com/google/go-cmp: malformed entry in GOVCS \(missing colon\): "git"$'
 
 env GOVCS=github.com:hg,github.com:git
 ! go get github.com/google/go-cmp
-stderr 'go get github.com/google/go-cmp: unreachable pattern in GOVCS: "github.com:git" after "github.com:hg"'
+stderr '^go get github.com/google/go-cmp: unreachable pattern in GOVCS: "github.com:git" after "github.com:hg"$'
 
 # bad GOVCS patterns do not stop commands that do not need to check VCS
 go list
@@ -50,19 +50,19 @@ env GOPROXY=direct
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.svn/hello
-stderr 'go get rsc.io/nonexist.svn/hello: GOVCS disallows using svn for public rsc.io/nonexist.svn'
+stderr '^go get rsc.io/nonexist.svn/hello: GOVCS disallows using svn for public rsc.io/nonexist.svn; see ''go help vcs''$'
 
 # fossil is disallowed by default
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.fossil/hello
-stderr 'go get rsc.io/nonexist.fossil/hello: GOVCS disallows using fossil for public rsc.io/nonexist.fossil'
+stderr '^go get rsc.io/nonexist.fossil/hello: GOVCS disallows using fossil for public rsc.io/nonexist.fossil; see ''go help vcs''$'
 
 # bzr is disallowed by default
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.bzr/hello
-stderr 'go get rsc.io/nonexist.bzr/hello: GOVCS disallows using bzr for public rsc.io/nonexist.bzr'
+stderr '^go get rsc.io/nonexist.bzr/hello: GOVCS disallows using bzr for public rsc.io/nonexist.bzr; see ''go help vcs''$'
 
 # git is OK by default
 env GOVCS=
@@ -77,12 +77,12 @@ env GONOSUMDB='*'
 # git can be disallowed
 env GOVCS=public:hg
 ! go get rsc.io/nonexist.git/hello
-stderr 'go get rsc.io/nonexist.git/hello: GOVCS disallows using git for public rsc.io/nonexist.git'
+stderr '^go get rsc.io/nonexist.git/hello: GOVCS disallows using git for public rsc.io/nonexist.git; see ''go help vcs''$'
 
 # hg can be disallowed
 env GOVCS=public:git
 ! go get rsc.io/nonexist.hg/hello
-stderr 'go get rsc.io/nonexist.hg/hello: GOVCS disallows using hg for public rsc.io/nonexist.hg'
+stderr '^go get rsc.io/nonexist.hg/hello: GOVCS disallows using hg for public rsc.io/nonexist.hg; see ''go help vcs''$'
 
 # Repeat in GOPATH mode. Error texts slightly different.
 
@@ -91,40 +91,40 @@ env GO111MODULE=off
 # GOVCS stops go get
 env GOVCS='*:none'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 env GOPRIVATE='github.com/google'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for private github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for private github.com/google/go-cmp; see ''go help vcs''$'
 
 # public pattern works
 env GOPRIVATE='github.com/google'
 env GOVCS='public:all,private:none'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for private github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for private github.com/google/go-cmp; see ''go help vcs''$'
 
 # private pattern works
 env GOPRIVATE='hubgit.com/google'
 env GOVCS='private:all,public:none'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 
 # other patterns work (for more patterns, see TestGOVCS)
 env GOPRIVATE=
 env GOVCS='github.com:svn|hg'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 env GOVCS='github.com/google/go-cmp/inner:git,github.com:svn|hg'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp'
+stderr '^package github.com/google/go-cmp: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
 
 # bad patterns are reported (for more bad patterns, see TestGOVCSErrors)
 env GOVCS='git'
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: malformed entry in GOVCS \(missing colon\): "git"'
+stderr '^package github.com/google/go-cmp: malformed entry in GOVCS \(missing colon\): "git"$'
 
 env GOVCS=github.com:hg,github.com:git
 ! go get github.com/google/go-cmp
-stderr 'package github.com/google/go-cmp: unreachable pattern in GOVCS: "github.com:git" after "github.com:hg"'
+stderr '^package github.com/google/go-cmp: unreachable pattern in GOVCS: "github.com:git" after "github.com:hg"$'
 
 # bad GOVCS patterns do not stop commands that do not need to check VCS
 go list
@@ -133,19 +133,19 @@ go list
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.svn/hello
-stderr 'package rsc.io/nonexist.svn/hello: GOVCS disallows using svn for public rsc.io/nonexist.svn'
+stderr '^package rsc.io/nonexist.svn/hello: GOVCS disallows using svn for public rsc.io/nonexist.svn; see ''go help vcs''$'
 
 # fossil is disallowed by default
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.fossil/hello
-stderr 'package rsc.io/nonexist.fossil/hello: GOVCS disallows using fossil for public rsc.io/nonexist.fossil'
+stderr '^package rsc.io/nonexist.fossil/hello: GOVCS disallows using fossil for public rsc.io/nonexist.fossil; see ''go help vcs''$'
 
 # bzr is disallowed by default
 env GOPRIVATE=
 env GOVCS=
 ! go get rsc.io/nonexist.bzr/hello
-stderr 'package rsc.io/nonexist.bzr/hello: GOVCS disallows using bzr for public rsc.io/nonexist.bzr'
+stderr '^package rsc.io/nonexist.bzr/hello: GOVCS disallows using bzr for public rsc.io/nonexist.bzr; see ''go help vcs''$'
 
 # git is OK by default
 env GOVCS=
@@ -160,12 +160,12 @@ env GONOSUMDB='*'
 # git can be disallowed
 env GOVCS=public:hg
 ! go get rsc.io/nonexist.git/hello
-stderr 'package rsc.io/nonexist.git/hello: GOVCS disallows using git for public rsc.io/nonexist.git'
+stderr '^package rsc.io/nonexist.git/hello: GOVCS disallows using git for public rsc.io/nonexist.git; see ''go help vcs''$'
 
 # hg can be disallowed
 env GOVCS=public:git
 ! go get rsc.io/nonexist.hg/hello
-stderr 'package rsc.io/nonexist.hg/hello: GOVCS disallows using hg for public rsc.io/nonexist.hg'
+stderr '^package rsc.io/nonexist.hg/hello: GOVCS disallows using hg for public rsc.io/nonexist.hg; see ''go help vcs''$'
 
 -- go.mod --
 module m

diff --git a/src/cmd/go/testdata/script/help.txt b/src/cmd/go/testdata/script/help.txt
index 9752ede2e372830eabca429fdbc1ae67fa16d0d9..26a0194be5603e9195356981ce83923de430fc94 100644 (file)
--- a/src/cmd/go/testdata/script/help.txt
+++ b/src/cmd/go/testdata/script/help.txt
@@ -34,9 +34,10 @@ stderr 'Run ''go help mod'' for usage.'
 # Earlier versions of Go printed the same as 'go -h' here.
 # Also make sure we print the short help line.
 ! go vet -h
-stderr 'usage: go vet'
-stderr 'Run ''go help vet'' for details'
-stderr 'Run ''go tool vet -help'' for the vet tool''s flags'
+stderr 'usage: go vet .*'
+stderr 'Run ''go help vet'' for details.'
+stderr 'Run ''go tool vet help'' for a full list of flags and analyzers.'
+stderr 'Run ''go tool vet -help'' for an overview.'
 
 # Earlier versions of Go printed a large document here, instead of these two
 # lines.

diff --git a/src/cmd/go/testdata/script/link_syso_issue33139.txt b/src/cmd/go/testdata/script/link_syso_issue33139.txt
index 26034c9626661d6fa2ee3a27d0ae48390951b2c0..8a8cb4aa8c20f045a0c1e7c077bc950c35f95136 100644 (file)
--- a/src/cmd/go/testdata/script/link_syso_issue33139.txt
+++ b/src/cmd/go/testdata/script/link_syso_issue33139.txt
@@ -2,7 +2,7 @@
 # embedded in a package, that is referenced by a Go assembly function.
 # See issue 33139.
 [!gc] skip
-[!exec:cc] skip
+[!cgo] skip
 
 # External linking is not supported on linux/ppc64.
 # See: https://github.com/golang/go/issues/8912

diff --git a/src/cmd/go/testdata/script/mod_bad_domain.txt b/src/cmd/go/testdata/script/mod_bad_domain.txt
index 20199c1c2ca8e8c61ef73af5df7d59aea17bd1da..7a270d0f07cac7fa76a670037dbb6678536db7d6 100644 (file)
--- a/src/cmd/go/testdata/script/mod_bad_domain.txt
+++ b/src/cmd/go/testdata/script/mod_bad_domain.txt
@@ -19,7 +19,7 @@ stderr 'malformed module path "x/y.z": missing dot in first path element'
 ! go build ./useappengine
 stderr '^useappengine[/\\]x.go:2:8: cannot find package$'
 ! go build ./usenonexistent
-stderr '^usenonexistent[/\\]x.go:2:8: no required module provides package nonexistent.rsc.io; try ''go mod tidy'' to add it$'
+stderr '^usenonexistent[/\\]x.go:2:8: no required module provides package nonexistent.rsc.io; to add it:\n\tgo get nonexistent.rsc.io$'
 
 
 # 'get -d' should be similarly definitive

diff --git a/src/cmd/go/testdata/script/mod_edit.txt b/src/cmd/go/testdata/script/mod_edit.txt
index 78485eb86ae1d2e1df1df52d171cf7a447136fbf..d7e681e831397b56160bd2aab4f668712abe400f 100644 (file)
--- a/src/cmd/go/testdata/script/mod_edit.txt
+++ b/src/cmd/go/testdata/script/mod_edit.txt
@@ -21,6 +21,12 @@ cmpenv go.mod $WORK/go.mod.edit1
 go mod edit -droprequire=x.1 -dropexclude=x.1@v1.2.1 -dropreplace=x.1@v1.3.0 -require=x.3@v1.99.0 -dropretract=v1.0.0 -dropretract=[v1.1.0,v1.2.0]
 cmpenv go.mod $WORK/go.mod.edit2
 
+# -exclude and -retract reject invalid versions.
+! go mod edit -exclude=example.com/m@bad
+stderr '^go mod: -exclude=example.com/m@bad: version "bad" invalid: must be of the form v1.2.3$'
+! go mod edit -retract=bad
+stderr '^go mod: -retract=bad: version "bad" invalid: must be of the form v1.2.3$'
+
 # go mod edit -json
 go mod edit -json
 cmpenv stdout $WORK/go.mod.json

diff --git a/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt b/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt
new file mode 100644 (file)
index 0000000..efc38f7
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt
@@ -0,0 +1,81 @@
+# This test illustrates a case where downgrading one module may upgrade another.
+# Compare to the downcross2 test case in cmd/go/internal/mvs/mvs_test.go.
+
+# The initial package import graph used in this test looks like:
+#
+# a ---- b ---- d
+#
+# The module dependency graph originally looks like:
+#
+# a ---- b.2 ---- d.2
+#
+# b.1 ---- c.1
+#
+# If we downgrade module d to version 1, we must downgrade b as well.
+# If that downgrade selects b version 1, we will add a new dependency on module c.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod.orig go.mod
+
+go get -d example.com/d@v0.1.0
+go list -m all
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+stdout '^example.com/d v0.1.0 '
+
+-- go.mod --
+module example.com/a
+
+go 1.15
+
+require example.com/b v0.2.0
+
+replace (
+       example.com/b v0.1.0 => ./b1
+       example.com/b v0.2.0 => ./b2
+       example.com/c v0.1.0 => ./c
+       example.com/d v0.1.0 => ./d
+       example.com/d v0.2.0 => ./d
+)
+-- a.go --
+package a
+
+import _ "example.com/b"
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.1.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/d v0.2.0
+-- b2/b.go --
+package b
+
+import _ "example.com/d"
+
+-- c/go.mod --
+module example.com/c
+
+go 1.15
+
+-- c/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.15
+-- d/d.go --
+package d

diff --git a/src/cmd/go/testdata/script/mod_get_downup_artifact.txt b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
new file mode 100644 (file)
index 0000000..b35d4c4
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
@@ -0,0 +1,165 @@
+# This test illustrates a case where an upgrade–downgrade–upgrade cycle can
+# result in upgrades of otherwise-irrelevant dependencies.
+#
+# This case has no corresponding test in the mvs package, because it is an
+# artifact that results from the composition of *multiple* MVS operations.
+
+# The initial package import graph used in the test looks like:
+#
+# m ---- a
+# |      |
+# +----- b
+# |      |
+# +----- c
+# |
+# +----- d
+#
+# b version 2 adds its own import of package d.
+#
+# The module dependency graph initially looks like:
+#
+# m ---- a.1
+# |       |
+# +----- b.1
+# |       |
+# +----- c.1
+# |
+# +----- d.1
+#
+# b.2 ---- c.2
+#  |
+#  +------ d.2
+#  |
+#  +------ e.1
+#
+# If we upgrade module b to version 2, we will upgrade c and d and add a new
+# dependency on e. If b version 2 is disallowed because of any of those
+# dependencies, the other dependencies should not be upgraded as a side-effect.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+stdout '^example.com/d v0.1.0 '
+! stdout '^example.com/e '
+
+# b is imported by a, so the -u flag would normally upgrade it to v0.2.0.
+# However, that would conflict with the explicit c@v0.1.0 constraint,
+# so b must remain at v0.1.0.
+#
+# If we're not careful, we might temporarily add b@v0.2.0 and pull in its
+# upgrades of module d and addition of module e, which are not relevant to
+# b@v0.1.0 and should not be added to the main module's dependencies.
+
+go get -u -d example.com/a@latest example.com/c@v0.1.0
+
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+
+       # BUG: d should remain at v0.1.0, because it is not transitively imported by a
+       # with b@v0.1.0. Today, it is spuriously upgraded to v0.2.0.
+stdout '^example.com/d v0.2.0 '
+
+       # BUG: e should not be added, because it is not transitively imported by a
+       # with b@v0.1.0. Today, it is spuriously added.
+stdout '^example.com/e v0.1.0 '
+
+-- go.mod --
+module example.com/m
+
+go 1.16
+
+require (
+       example.com/a v0.1.0
+       example.com/b v0.1.0
+       example.com/c v0.1.0
+       example.com/d v0.1.0
+)
+
+replace (
+       example.com/a v0.1.0 => ./a1
+       example.com/b v0.1.0 => ./b1
+       example.com/b v0.2.0 => ./b2
+       example.com/c v0.1.0 => ./c
+       example.com/c v0.2.0 => ./c
+       example.com/d v0.1.0 => ./d
+       example.com/d v0.2.0 => ./d
+       example.com/e v0.1.0 => ./e
+)
+-- m.go --
+package m
+
+import (
+       _ "example.com/a"
+       _ "example.com/b"
+       _ "example.com/c"
+       _ "example.com/d"
+)
+
+-- a1/go.mod --
+module example.com/a
+
+go 1.16
+
+require example.com/b v0.1.0
+-- a1/a.go --
+package a
+
+import _ "example.com/b"
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.16
+
+require example.com/c v0.1.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.16
+
+require (
+       example.com/c v0.2.0
+       example.com/d v0.2.0
+       example.com/e v0.1.0
+)
+-- b2/b.go --
+package b
+
+import (
+       "example.com/c"
+       "example.com/d"
+       "example.com/e"
+)
+
+-- c/go.mod --
+module example.com/c
+
+go 1.16
+-- c/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.16
+-- d/d.go --
+package d
+
+-- e/go.mod --
+module example.com/e
+
+go 1.16
+-- e/e.go --
+package e

diff --git a/src/cmd/go/testdata/script/mod_get_downup_indirect.txt b/src/cmd/go/testdata/script/mod_get_downup_indirect.txt
new file mode 100644 (file)
index 0000000..ced1dcd
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downup_indirect.txt
@@ -0,0 +1,101 @@
+# This test illustrates a case where downgrading one module may upgrade another.
+# Compare to the downcross1 test case in cmd/go/internal/mvs/mvs_test.go.
+
+# The package import graph used in this test looks like:
+#
+# a ---- b
+#   \     \
+#    \     \
+#     ----- c ---- d
+#
+# The module dependency graph originally looks like:
+#
+# a ---- b.2
+#   \      \
+#    \      \
+#     ----- c.1 ---- d.2
+#
+# b.1 ---- c.2
+#
+# If we downgrade module d to version 1, we must downgrade b as well.
+# If that downgrade selects b version 1, we will upgrade module c to version 2.
+# So 'go get d@1' should instead downgrade both b and c to "none".
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod.orig go.mod
+
+go get -d example.com/d@v0.1.0
+go list -m all
+! stdout '^example.com/b '
+! stdout '^example.com/c '
+stdout '^example.com/d v0.1.0 '
+
+-- go.mod --
+module example.com/a
+
+go 1.15
+
+require (
+       example.com/b v0.2.0
+       example.com/c v0.1.0
+)
+
+replace (
+       example.com/b v0.1.0 => ./b1
+       example.com/b v0.2.0 => ./b2
+       example.com/c v0.1.0 => ./c1
+       example.com/c v0.2.0 => ./c2
+       example.com/d v0.1.0 => ./d
+       example.com/d v0.2.0 => ./d
+)
+-- a.go --
+package a
+
+import (
+       _ "example.com/b"
+       _ "example.com/c"
+)
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.2.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.1.0
+-- b2/b.go --
+package b
+
+import _ "example.com/c"
+
+-- c1/go.mod --
+module example.com/c
+
+go 1.15
+
+require example.com/d v0.2.0
+-- c1/c.go --
+package c
+
+-- c2/go.mod --
+module example.com/c
+
+go 1.15
+-- c2/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.15

diff --git a/src/cmd/go/testdata/script/mod_get_fallback.txt b/src/cmd/go/testdata/script/mod_get_fallback.txt
index a9834a324e249ae8ad19b37cfb4c55b28d657e26..9733fa366bea57eb19370d6cb125c87933f845f9 100644 (file)
--- a/src/cmd/go/testdata/script/mod_get_fallback.txt
+++ b/src/cmd/go/testdata/script/mod_get_fallback.txt
@@ -6,5 +6,5 @@ env GOPROXY=https://proxy.golang.org,direct
 env GOSUMDB=off
 
 go get -x -v -d golang.org/x/tools/cmd/goimports
-stderr '# get https://proxy.golang.org/golang.org/x/tools/@latest'
+stderr '# get https://proxy.golang.org/golang.org/x/tools/@v/list'
 ! stderr '# get https://golang.org'

diff --git a/src/cmd/go/testdata/script/mod_get_pkgtags.txt b/src/cmd/go/testdata/script/mod_get_pkgtags.txt
new file mode 100644 (file)
index 0000000..c0a57f3
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_pkgtags.txt
@@ -0,0 +1,116 @@
+# https://golang.org/issue/44106
+# 'go get' should fetch the transitive dependencies of packages regardless of
+# tags, but shouldn't error out if the package is missing tag-guarded
+# dependencies.
+
+# Control case: just adding the top-level module to the go.mod file does not
+# fetch its dependencies.
+
+go mod edit -require example.net/tools@v0.1.0
+! go list -deps example.net/cmd/tool
+stderr '^module example\.net/cmd provides package example\.net/cmd/tool and is replaced but not required; to add it:\n\tgo get example\.net/cmd@v0\.1\.0$'
+go mod edit -droprequire example.net/tools
+
+
+# 'go get -d' makes a best effort to fetch those dependencies, but shouldn't
+# error out if dependencies of tag-guarded files are missing.
+
+go get -d example.net/tools@v0.1.0
+
+! go list example.net/tools
+stderr '^package example.net/tools: build constraints exclude all Go files in .*[/\\]tools$'
+
+go list -tags=tools -e -deps example.net/tools
+stdout '^example.net/cmd/tool$'
+stdout '^example.net/missing$'
+
+go list -deps example.net/cmd/tool
+
+! go list example.net/missing
+stderr '^no required module provides package example.net/missing; to add it:\n\tgo get example.net/missing$'
+
+
+# https://golang.org/issue/29268
+# 'go get' should fetch modules whose roots contain test-only packages, but
+# without the -t flag shouldn't error out if the test has missing dependencies.
+
+go get -d example.net/testonly@v0.1.0
+
+# With the -t flag, the test dependencies must resolve successfully.
+! go get -d -t example.net/testonly@v0.1.0
+stderr '^example.net/testonly tested by\n\texample.net/testonly\.test imports\n\texample.net/missing: cannot find module providing package example.net/missing$'
+
+
+# 'go get -d' should succeed for a module path that does not contain a package,
+# but fail for a non-package subdirectory of a module.
+
+! go get -d example.net/missing/subdir@v0.1.0
+stderr '^go get: module example.net/missing@v0.1.0 found \(replaced by ./missing\), but does not contain package example.net/missing/subdir$'
+
+go get -d example.net/missing@v0.1.0
+
+
+# Getting the subdirectory should continue to fail even if the corresponding
+# module is already present in the build list.
+
+! go get -d example.net/missing/subdir@v0.1.0
+stderr '^go get: module example.net/missing@v0.1.0 found \(replaced by ./missing\), but does not contain package example.net/missing/subdir$'
+
+
+-- go.mod --
+module example.net/m
+
+go 1.15
+
+replace (
+       example.net/tools v0.1.0 => ./tools
+       example.net/cmd v0.1.0 => ./cmd
+       example.net/testonly v0.1.0 => ./testonly
+       example.net/missing v0.1.0 => ./missing
+)
+
+-- tools/go.mod --
+module example.net/tools
+
+go 1.15
+
+// Requirements intentionally omitted.
+
+-- tools/tools.go --
+// +build tools
+
+package tools
+
+import (
+       _ "example.net/cmd/tool"
+       _ "example.net/missing"
+)
+
+-- cmd/go.mod --
+module example.net/cmd
+
+go 1.16
+-- cmd/tool/tool.go --
+package main
+
+func main() {}
+
+-- testonly/go.mod --
+module example.net/testonly
+
+go 1.15
+-- testonly/testonly_test.go --
+package testonly_test
+
+import _ "example.net/missing"
+
+func Test(t *testing.T) {}
+
+-- missing/go.mod --
+module example.net/missing
+
+go 1.15
+-- missing/README.txt --
+There are no Go source files here.
+-- missing/subdir/README.txt --
+There are no Go source files here either.

diff --git a/src/cmd/go/testdata/script/mod_get_promote_implicit.txt b/src/cmd/go/testdata/script/mod_get_promote_implicit.txt
new file mode 100644 (file)
index 0000000..10ca659
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_promote_implicit.txt
@@ -0,0 +1,92 @@
+cp go.mod.orig go.mod
+
+# If we list a package in an implicit dependency imported from the main module,
+# we should get an error because the dependency should have an explicit
+# requirement.
+go list -m indirect-with-pkg
+stdout '^indirect-with-pkg v1.0.0 => ./indirect-with-pkg$'
+! go list ./use-indirect
+stderr '^go: m/use-indirect: package indirect-with-pkg imported from implicitly required module; to add missing requirements, run:\n\tgo get indirect-with-pkg@v1.0.0$'
+
+# We can promote the implicit requirement by getting the importing package.
+# NOTE: the hint recommends getting the imported package (tested below) since
+# it's more obvious and doesn't require -d. However, that adds an '// indirect'
+# comment on the requirement.
+go get -d m/use-indirect
+cmp go.mod go.mod.use
+cp go.mod.orig go.mod
+
+# We can also promote implicit requirements using 'go get' on them, or their
+# packages. This gives us "// indirect" requirements, since 'go get' doesn't
+# know they're needed by the main module. See #43131 for the rationale.
+# The hint above recommends this because it's more obvious usage and doesn't
+# require the -d flag.
+go get -d indirect-with-pkg indirect-without-pkg
+cmp go.mod go.mod.indirect
+
+-- go.mod.orig --
+module m
+
+go 1.16
+
+require direct v1.0.0
+
+replace (
+       direct v1.0.0 => ./direct
+       indirect-with-pkg v1.0.0 => ./indirect-with-pkg
+       indirect-without-pkg v1.0.0 => ./indirect-without-pkg
+)
+-- go.mod.use --
+module m
+
+go 1.16
+
+require (
+       direct v1.0.0
+       indirect-with-pkg v1.0.0
+)
+
+replace (
+       direct v1.0.0 => ./direct
+       indirect-with-pkg v1.0.0 => ./indirect-with-pkg
+       indirect-without-pkg v1.0.0 => ./indirect-without-pkg
+)
+-- go.mod.indirect --
+module m
+
+go 1.16
+
+require (
+       direct v1.0.0
+       indirect-with-pkg v1.0.0 // indirect
+       indirect-without-pkg v1.0.0 // indirect
+)
+
+replace (
+       direct v1.0.0 => ./direct
+       indirect-with-pkg v1.0.0 => ./indirect-with-pkg
+       indirect-without-pkg v1.0.0 => ./indirect-without-pkg
+)
+-- use-indirect/use-indirect.go --
+package use
+
+import _ "indirect-with-pkg"
+-- direct/go.mod --
+module direct
+
+go 1.16
+
+require (
+       indirect-with-pkg v1.0.0
+       indirect-without-pkg v1.0.0
+)
+-- indirect-with-pkg/go.mod --
+module indirect-with-pkg
+
+go 1.16
+-- indirect-with-pkg/p.go --
+package p
+-- indirect-without-pkg/go.mod --
+module indirect-without-pkg
+
+go 1.16

diff --git a/src/cmd/go/testdata/script/mod_get_replaced.txt b/src/cmd/go/testdata/script/mod_get_replaced.txt
index 76d0793ffef7c48587ede6d584636b8b85a12089..d97f3f1a40117242fba478162505e0abb9d6eb97 100644 (file)
--- a/src/cmd/go/testdata/script/mod_get_replaced.txt
+++ b/src/cmd/go/testdata/script/mod_get_replaced.txt
@@ -87,7 +87,7 @@ stderr '^go get: malformed module path "example": missing dot in first path elem
 go mod edit -replace example@v0.1.0=./example
 
 ! go list example
-stderr '^module example provides package example and is replaced but not required; try ''go get -d example@v0.1.0'' to add it$'
+stderr '^module example provides package example and is replaced but not required; to add it:\n\tgo get example@v0.1.0$'
 
 go get -d example
 go list -m example

diff --git a/src/cmd/go/testdata/script/mod_get_retract.txt b/src/cmd/go/testdata/script/mod_get_retract.txt
index 6e328eb5929292994e18cc2cd6b5b1bd0631eb6c..fe0ac886295e8f89ea11876fbedd702cda690ae0 100644 (file)
--- a/src/cmd/go/testdata/script/mod_get_retract.txt
+++ b/src/cmd/go/testdata/script/mod_get_retract.txt
@@ -11,7 +11,7 @@ cp go.mod.orig go.mod
 go mod edit -require example.com/retract/self/prev@v1.9.0
 go get -d example.com/retract/self/prev
 stderr '^go: warning: example.com/retract/self/prev@v1.9.0: retracted by module author: self$'
-stderr '^go: run ''go get example.com/retract/self/prev@latest'' to switch to the latest unretracted version$'
+stderr '^go: to switch to the latest unretracted version, run:\n\tgo get example.com/retract/self/prev@latest$'
 go list -m example.com/retract/self/prev
 stdout '^example.com/retract/self/prev v1.9.0$'
 

diff --git a/src/cmd/go/testdata/script/mod_gobuild_import.txt b/src/cmd/go/testdata/script/mod_gobuild_import.txt
index 3a133663ec78818b540361233a5ae58e9a3fe831..c13ae844b56739d1a265d3cc60b1ee39b2d926ac 100644 (file)
--- a/src/cmd/go/testdata/script/mod_gobuild_import.txt
+++ b/src/cmd/go/testdata/script/mod_gobuild_import.txt
@@ -19,7 +19,7 @@ exec $WORK/testimport$GOEXE other/x/y/z/w .
 stdout w2.go
 
 ! exec $WORK/testimport$GOEXE gobuild.example.com/x/y/z/w .
-stderr 'no required module provides package gobuild.example.com/x/y/z/w; try ''go get -d gobuild.example.com/x/y/z/w'' to add it'
+stderr 'no required module provides package gobuild.example.com/x/y/z/w; to add it:\n\tgo get gobuild.example.com/x/y/z/w'
 
 cd z
 exec $WORK/testimport$GOEXE other/x/y/z/w .

diff --git a/src/cmd/go/testdata/script/mod_init_tidy.txt b/src/cmd/go/testdata/script/mod_init_tidy.txt
index 6a37edd960a68f0a6aa4d0e33e9887cbf9562579..4a525903b23f11fc0f6cfb2c40af5042f818f41e 100644 (file)
--- a/src/cmd/go/testdata/script/mod_init_tidy.txt
+++ b/src/cmd/go/testdata/script/mod_init_tidy.txt
@@ -8,14 +8,14 @@ cd ..
 # 'go mod init' should recommend 'go mod tidy' if the directory has a .go file.
 cd pkginroot
 go mod init m
-stderr '^go: run ''go mod tidy'' to add module requirements and sums$'
+stderr '^go: to add module requirements and sums:\n\tgo mod tidy$'
 cd ..
 
 # 'go mod init' should recommend 'go mod tidy' if the directory has a
 # subdirectory. We don't walk the tree to see if it has .go files.
 cd subdir
 go mod init m
-stderr '^go: run ''go mod tidy'' to add module requirements and sums$'
+stderr '^go: to add module requirements and sums:\n\tgo mod tidy$'
 cd ..
 
 -- empty/empty.txt --

diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index e4a7668351898242c4ebb2dc5c4d57e7c957f739..e27ebc5cc5095d352329f5188066e1d954216f2a 100644 (file)
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -16,7 +16,7 @@ env GO111MODULE=auto
 cd m
 cp go.mod go.mod.orig
 ! go list -m all
-stderr '^go: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry; try ''go mod download example.com/cmd'' to add it$'
+stderr '^go: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry; to add it:\n\tgo mod download example.com/cmd$'
 go install example.com/cmd/a@latest
 cmp go.mod go.mod.orig
 exists $GOPATH/bin/a$GOEXE
@@ -67,9 +67,9 @@ cd tmp
 go mod init tmp
 go mod edit -require=rsc.io/fortune@v1.0.0
 ! go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; try ''go mod download rsc.io/fortune'' to add it$'
+stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 ! go install -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; try ''go mod download rsc.io/fortune'' to add it$'
+stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 go get -d rsc.io/fortune@v1.0.0
 go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
 exists $GOPATH/bin/fortune$GOEXE
@@ -175,6 +175,11 @@ stdout '^\tmod\texample.com/cmd\tv1.0.0\t'
 go install example.com/cmd/a@v1.9.0
 go version -m $GOPATH/bin/a$GOEXE
 stdout '^\tmod\texample.com/cmd\tv1.9.0\t'
+env GO111MODULE=
+
+# 'go install pkg@version' succeeds when -mod=readonly is set explicitly.
+# Verifies #43278.
+go install -mod=readonly example.com/cmd/a@v1.0.0
 
 -- m/go.mod --
 module m

diff --git a/src/cmd/go/testdata/script/mod_invalid_path.txt b/src/cmd/go/testdata/script/mod_invalid_path.txt
index 05a513357176cb8d301aecdb494e4ca2a90f1ba9..667828839fdd8cc3cee2a01788097495d4ad88ee 100644 (file)
--- a/src/cmd/go/testdata/script/mod_invalid_path.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_path.txt
@@ -3,7 +3,7 @@
 # Test that go list fails on a go.mod with no module declaration.
 cd $WORK/gopath/src/mod
 ! go list .
-stderr '^go: no module declaration in go.mod.\n\tRun ''go mod edit -module=example.com/mod'' to specify the module path.$'
+stderr '^go: no module declaration in go.mod. To specify the module path:\n\tgo mod edit -module=example.com/mod$'
 
 # Test that go mod init in GOPATH doesn't add a module declaration
 # with a path that can't possibly be a module path, because

diff --git a/src/cmd/go/testdata/script/mod_list_bad_import.txt b/src/cmd/go/testdata/script/mod_list_bad_import.txt
index 3cd50b0de2544450563ad81c92cfe6ced23bf0dd..b128408a612a4163ed58d9470e1f63a929b28063 100644 (file)
--- a/src/cmd/go/testdata/script/mod_list_bad_import.txt
+++ b/src/cmd/go/testdata/script/mod_list_bad_import.txt
@@ -39,7 +39,7 @@ stdout example.com/notfound
 
 # Listing the missing dependency directly should fail outright...
 ! go list -f '{{if .Error}}error{{end}} {{if .Incomplete}}incomplete{{end}}' example.com/notfound
-stderr 'no required module provides package example.com/notfound; try ''go get -d example.com/notfound'' to add it'
+stderr 'no required module provides package example.com/notfound; to add it:\n\tgo get example.com/notfound'
 ! stdout error
 ! stdout incomplete
 

diff --git a/src/cmd/go/testdata/script/mod_load_badchain.txt b/src/cmd/go/testdata/script/mod_load_badchain.txt
index c0c382bfa638b0fcb71473c560704179e7726795..32d9fb24d112c206f6be607080615c5c3a17ec84 100644 (file)
--- a/src/cmd/go/testdata/script/mod_load_badchain.txt
+++ b/src/cmd/go/testdata/script/mod_load_badchain.txt
@@ -74,8 +74,7 @@ go get: example.com/badchain/c@v1.0.0 updating to
        module declares its path as: badchain.example.com/c
                but was required as: example.com/badchain/c
 -- update-a-expected --
-go get: example.com/badchain/a@v1.0.0 updating to
-       example.com/badchain/a@v1.1.0 requires
+go get: example.com/badchain/a@v1.1.0 requires
        example.com/badchain/b@v1.1.0 requires
        example.com/badchain/c@v1.1.0: parsing go.mod:
        module declares its path as: badchain.example.com/c

diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 28379ab40d886f090977526c98c2a019c397fcab..8f01b5d242677502a87260d0a5e4d3a12459c2d3 100644 (file)
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -189,13 +189,16 @@ exists $GOPATH/bin/printversion$GOEXE
 
 # 'go install' should fail if a package argument must be resolved to a module.
 ! go install example.com/printversion
-stderr 'no required module provides package example.com/printversion: working directory is not part of a module'
+stderr '^go install: version is required when current directory is not in a module\n\tTry ''go install example.com/printversion@latest'' to install the latest version$'
 
 # 'go install' should fail if a source file imports a package that must be
 # resolved to a module.
 ! go install ./needmod/needmod.go
 stderr 'needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: working directory is not part of a module'
 
+# 'go install' should succeed with a package in GOROOT.
+go install cmd/addr2line
+! stderr .
 
 # 'go run' with a verison should fail due to syntax.
 ! go run example.com/printversion@v1.0.0

diff --git a/src/cmd/go/testdata/script/mod_readonly.txt b/src/cmd/go/testdata/script/mod_readonly.txt
index ca8cd6e068938cb64fb372b85b11af1e7eaf8a2e..176be7296794a7ebf38b1be8c8f1188840ec2a80 100644 (file)
--- a/src/cmd/go/testdata/script/mod_readonly.txt
+++ b/src/cmd/go/testdata/script/mod_readonly.txt
@@ -13,7 +13,7 @@ cmp go.mod go.mod.empty
 # -mod=readonly should be set by default.
 env GOFLAGS=
 ! go list all
-stderr '^x.go:2:8: no required module provides package rsc\.io/quote; try ''go mod tidy'' to add it$'
+stderr '^x.go:2:8: no required module provides package rsc\.io/quote; to add it:\n\tgo get rsc\.io/quote$'
 cmp go.mod go.mod.empty
 
 env GOFLAGS=-mod=readonly
@@ -51,7 +51,7 @@ cmp go.mod go.mod.inconsistent
 # We get a different message when -mod=readonly is used by default.
 env GOFLAGS=
 ! go list
-stderr '^go: updates to go.mod needed; try ''go mod tidy'' first$'
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy'
 
 # However, it should not reject files missing a 'go' directive,
 # since that was not always required.
@@ -75,15 +75,15 @@ cmp go.mod go.mod.indirect
 
 cp go.mod.untidy go.mod
 ! go list all
-stderr '^x.go:2:8: no required module provides package rsc.io/quote; try ''go mod tidy'' to add it$'
+stderr '^x.go:2:8: no required module provides package rsc.io/quote; to add it:\n\tgo get rsc.io/quote$'
 
 ! go list -deps .
-stderr '^x.go:2:8: no required module provides package rsc.io/quote; try ''go mod tidy'' to add it$'
+stderr '^x.go:2:8: no required module provides package rsc.io/quote; to add it:\n\tgo get rsc.io/quote$'
 
 # However, if we didn't see an import from the main module, we should suggest
 # 'go get -d' instead, because we don't know whether 'go mod tidy' would add it.
 ! go list rsc.io/quote
-stderr '^no required module provides package rsc.io/quote; try ''go get -d rsc.io/quote'' to add it$'
+stderr '^no required module provides package rsc.io/quote; to add it:\n\tgo get rsc.io/quote$'
 
 
 -- go.mod --

diff --git a/src/cmd/go/testdata/script/mod_replace_readonly.txt b/src/cmd/go/testdata/script/mod_replace_readonly.txt
index 882c755337a9180a1fbb64ca707c4af7b2b15ba9..d950d78bd3c621b7ebf429e33458214bb0f6cb30 100644 (file)
--- a/src/cmd/go/testdata/script/mod_replace_readonly.txt
+++ b/src/cmd/go/testdata/script/mod_replace_readonly.txt
@@ -9,7 +9,7 @@ cp go.mod go.mod.orig
 # can't in readonly mode, since its go.mod may alter the build list.
 go mod edit -replace rsc.io/quote=./quote
 ! go list rsc.io/quote
-stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; try ''go get -d rsc.io/quote'' to add it$'
+stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; to add it:\n\tgo get rsc.io/quote$'
 go get -d rsc.io/quote
 cmp go.mod go.mod.latest
 go list rsc.io/quote
@@ -18,7 +18,7 @@ cp go.mod.orig go.mod
 # Same test with a specific version.
 go mod edit -replace rsc.io/quote@v1.0.0-doesnotexist=./quote
 ! go list rsc.io/quote
-stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; try ''go get -d rsc.io/quote@v1.0.0-doesnotexist'' to add it$'
+stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; to add it:\n\tgo get rsc.io/quote@v1.0.0-doesnotexist$'
 go get -d rsc.io/quote@v1.0.0-doesnotexist
 cmp go.mod go.mod.specific
 go list rsc.io/quote
@@ -28,7 +28,7 @@ cp go.mod.orig go.mod
 go mod edit -replace rsc.io/quote@v1.0.0-doesnotexist=./quote
 go mod edit -replace rsc.io/quote@v1.1.0-doesnotexist=./quote
 ! go list rsc.io/quote
-stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; try ''go get -d rsc.io/quote@v1.1.0-doesnotexist'' to add it$'
+stderr '^module rsc.io/quote provides package rsc.io/quote and is replaced but not required; to add it:\n\tgo get rsc.io/quote@v1.1.0-doesnotexist$'
 
 -- go.mod --
 module m

diff --git a/src/cmd/go/testdata/script/mod_sum_ambiguous.txt b/src/cmd/go/testdata/script/mod_sum_ambiguous.txt
index 999257c419f8e0c28ec0ccff70f8071ec6fa7465..07c66591770342f262b64c83980184dc3fd0ee62 100644 (file)
--- a/src/cmd/go/testdata/script/mod_sum_ambiguous.txt
+++ b/src/cmd/go/testdata/script/mod_sum_ambiguous.txt
@@ -10,20 +10,34 @@ go mod tidy
 grep '^example.com/ambiguous/a v1.0.0 h1:' go.sum
 grep '^example.com/ambiguous/a/b v0.0.0-empty h1:' go.sum
 
+# 'go mod download' should also add sums.
+cp go.sum.buildlist-only go.sum
+go mod download example.com/ambiguous/a
+grep '^example.com/ambiguous/a v1.0.0 h1:' go.sum
+! grep '^example.com/ambiguous/a/b v0.0.0-empty h1:' go.sum
+go mod download example.com/ambiguous/a/b
+grep '^example.com/ambiguous/a/b v0.0.0-empty h1:' go.sum
+
 # If two modules could provide a package, and we're missing a sum for one,
 # we should see a missing sum error, even if we have a sum for a module that
 # provides the package.
 cp go.sum.a-only go.sum
 ! go list example.com/ambiguous/a/b
-stderr '^missing go.sum entry needed to verify package example.com/ambiguous/a/b is provided by exactly one module$'
+stderr '^missing go.sum entry needed to verify package example.com/ambiguous/a/b is provided by exactly one module; to add:\n\tgo mod download example.com/ambiguous/a/b$'
 ! go list -deps .
-stderr '^use.go:3:8: missing go.sum entry needed to verify package example.com/ambiguous/a/b is provided by exactly one module; try ''go mod tidy'' to add it$'
+stderr '^use.go:3:8: missing go.sum entry needed to verify package example.com/ambiguous/a/b \(imported by m\) is provided by exactly one module; to add:\n\tgo get m$'
 
 cp go.sum.b-only go.sum
 ! go list example.com/ambiguous/a/b
-stderr '^missing go.sum entry for module providing package example.com/ambiguous/a/b$'
+stderr '^missing go.sum entry for module providing package example.com/ambiguous/a/b; to add:\n\tgo mod download example.com/ambiguous/a$'
+! go list -deps .
+stderr '^use.go:3:8: missing go.sum entry for module providing package example.com/ambiguous/a/b \(imported by m\); to add:\n\tgo get m$'
+
+cp go.sum.buildlist-only go.sum
+! go list example.com/ambiguous/a/b
+stderr '^missing go.sum entry for module providing package example.com/ambiguous/a/b; to add:\n\tgo mod download example.com/ambiguous/a example.com/ambiguous/a/b$'
 ! go list -deps .
-stderr '^use.go:3:8: missing go.sum entry for module providing package example.com/ambiguous/a/b; try ''go mod tidy'' to add it$'
+stderr '^use.go:3:8: missing go.sum entry for module providing package example.com/ambiguous/a/b \(imported by m\); to add:\n\tgo get m$'
 
 -- go.mod --
 module m

diff --git a/src/cmd/go/testdata/script/mod_sum_readonly.txt b/src/cmd/go/testdata/script/mod_sum_readonly.txt
index 4d6e8aae6a9d77119aaca4f32ce7543b32a09b54..57c5bbeefdf0203c43f28b50d8294500b6dff7a7 100644 (file)
--- a/src/cmd/go/testdata/script/mod_sum_readonly.txt
+++ b/src/cmd/go/testdata/script/mod_sum_readonly.txt
@@ -4,7 +4,7 @@ env GO111MODULE=on
 # When a sum is needed to load the build list, we get an error for the
 # specific module. The .mod file is not downloaded, and go.sum is not written.
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; try ''go mod download rsc.io/quote'' to add it$'
+stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
 ! exists go.sum
 
@@ -12,7 +12,7 @@ stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; try ''go mod download rs
 # we should see the same error.
 cp go.sum.h2only go.sum
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; try ''go mod download rsc.io/quote'' to add it$'
+stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
 cmp go.sum go.sum.h2only
 rm go.sum
@@ -21,7 +21,7 @@ rm go.sum
 cp go.mod go.mod.orig
 go mod edit -replace rsc.io/quote@v1.5.2=rsc.io/quote@v1.5.1
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2 \(replaced by rsc.io/quote@v1.5.1\): missing go.sum entry; try ''go mod download rsc.io/quote'' to add it$'
+stderr '^go: rsc.io/quote@v1.5.2 \(replaced by rsc.io/quote@v1.5.1\): missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.1.mod
 ! exists go.sum
 cp go.mod.orig go.mod
@@ -35,19 +35,19 @@ exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
 # When a sum is needed to load a .mod file for a package outside the build list,
 # we get a generic missing import error.
 ! go list example.com/doesnotexist
-stderr '^no required module provides package example.com/doesnotexist; try ''go get -d example.com/doesnotexist'' to add it$'
+stderr '^no required module provides package example.com/doesnotexist; to add it:\n\tgo get example.com/doesnotexist$'
 
 # When a sum is needed to load a .zip file, we get a more specific error.
 # The .zip file is not downloaded.
 ! go list rsc.io/quote
-stderr '^missing go.sum entry for module providing package rsc.io/quote$'
+stderr '^missing go.sum entry for module providing package rsc.io/quote; to add:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
 
 # The error is attached to the package from the missing module. We can load
 # a package that imports it without that error.
 go list -e -deps -f '{{.ImportPath}}{{with .Error}} {{.Err}}{{end}}' .
 stdout '^m$'
-stdout '^rsc.io/quote missing go.sum entry for module providing package rsc.io/quote; try ''go mod tidy'' to add it$'
+stdout '^rsc.io/quote missing go.sum entry for module providing package rsc.io/quote \(imported by m\); to add:\n\tgo get m$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
 
 # go.sum should not have been written.

diff --git a/src/cmd/go/testdata/script/mod_vendor_auto.txt b/src/cmd/go/testdata/script/mod_vendor_auto.txt
index 1b362eda0bdf0b5cd8b82f55afbb88f34cfd1e91..b0ea907206a44902b6001a8df73bd80d283f7893 100644 (file)
--- a/src/cmd/go/testdata/script/mod_vendor_auto.txt
+++ b/src/cmd/go/testdata/script/mod_vendor_auto.txt
@@ -66,7 +66,7 @@ stderr '^go: inconsistent vendoring in '$WORK[/\\]auto':$'
 stderr '^\texample.com/printversion@v1.0.0: is explicitly required in go.mod, but not marked as explicit in vendor/modules.txt'
 stderr '^\texample.com/unused: is replaced in go.mod, but not marked as replaced in vendor/modules.txt'
 stderr '^\texample.com/version@v1.2.0: is replaced in go.mod, but not marked as replaced in vendor/modules.txt'
-stderr '\n\nrun .go mod vendor. to sync, or use -mod=mod or -mod=readonly to ignore the vendor directory$'
+stderr '^\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo mod vendor$'
 
 # Module-specific subcommands should continue to load the full module graph.
 go mod graph
@@ -135,7 +135,7 @@ stderr '^go: inconsistent vendoring in '$WORK[/\\]auto':$'
 stderr '^\texample.com/printversion@v1.0.0: is explicitly required in go.mod, but not marked as explicit in vendor/modules.txt'
 stderr '^\texample.com/unused: is replaced in go.mod, but not marked as replaced in vendor/modules.txt'
 stderr '^\texample.com/version@v1.2.0: is replaced in go.mod, but not marked as replaced in vendor/modules.txt'
-stderr '\n\nrun .go mod vendor. to sync, or use -mod=mod or -mod=readonly to ignore the vendor directory$'
+stderr '^\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo mod vendor$'
 
 # If -mod=vendor is set, limited consistency checks should apply even when
 # the go version is 1.13 or earlier.
@@ -151,7 +151,7 @@ cp $WORK/modules-bad-1.13.txt vendor/modules.txt
 ! go list -mod=vendor -f {{.Dir}} -tags tools all
 stderr '^go: inconsistent vendoring in '$WORK[/\\]auto':$'
 stderr '^\texample.com/printversion@v1.0.0: is explicitly required in go.mod, but vendor/modules.txt indicates example.com/printversion@v1.1.0$'
-stderr '\n\nrun .go mod vendor. to sync, or use -mod=mod or -mod=readonly to ignore the vendor directory$'
+stderr '^\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo mod vendor$'
 
 # If the go version is still 1.13, 'go mod vendor' should write a
 # matching vendor/modules.txt containing the corrected 1.13 data.

diff --git a/src/cmd/go/testdata/script/mod_vendor_embed.txt b/src/cmd/go/testdata/script/mod_vendor_embed.txt
new file mode 100644 (file)
index 0000000..be11415
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_vendor_embed.txt
@@ -0,0 +1,179 @@
+go mod vendor
+cmp vendor/example.com/a/samedir_embed.txt a/samedir_embed.txt
+cmp vendor/example.com/a/subdir/embed.txt a/subdir/embed.txt
+cmp vendor/example.com/a/subdir/test/embed.txt a/subdir/test/embed.txt
+cmp vendor/example.com/a/subdir/test/xtest/embed.txt a/subdir/test/xtest/embed.txt
+
+cd broken_no_matching_files
+! go mod vendor
+stderr 'go mod vendor: pattern foo.txt: no matching files found'
+
+cd ../broken_bad_pattern
+! go mod vendor
+stderr 'go mod vendor: pattern ../foo.txt: invalid pattern syntax'
+
+# matchPotentialSourceFile prunes out tests and unbuilt code.
+# Make sure that they are vendored if they are embedded files.
+cd ../embed_unbuilt
+go mod vendor
+cmp vendor/example.com/dep/unbuilt.go dep/unbuilt.go
+cmp vendor/example.com/dep/dep_test.go dep/dep_test.go
+! exists vendor/example.com/dep/not_embedded_unbuilt.go
+! exists vendor/example.com/dep/not_embedded_dep_test.go
+-- go.mod --
+module example.com/foo
+go 1.16
+
+require (
+       example.com/a v0.1.0
+)
+
+replace (
+       example.com/a v0.1.0 => ./a
+)
+-- foo.go --
+package main
+
+import (
+       "fmt"
+
+       "example.com/a"
+)
+
+func main() {
+    fmt.Println(a.Str())
+}
+-- a/go.mod --
+module example.com/a
+-- a/a.go --
+package a
+
+import _ "embed"
+
+//go:embed samedir_embed.txt
+var sameDir string
+
+//go:embed subdir/embed.txt
+var subDir string
+
+func Str() string {
+       return sameDir + subDir
+}
+-- a/a_test.go --
+package a
+
+import _ "embed"
+
+//go:embed subdir/test/embed.txt
+var subderTest string
+-- a/a_x_test.go --
+package a_test
+
+import _ "embed"
+
+//go:embed subdir/test/xtest/embed.txt
+var subdirXtest string
+-- a/samedir_embed.txt --
+embedded file in same directory as package
+-- a/subdir/embed.txt --
+embedded file in subdirectory of package
+-- a/subdir/test/embed.txt --
+embedded file of test in subdirectory of package
+-- a/subdir/test/xtest/embed.txt --
+embedded file of xtest in subdirectory of package
+-- broken_no_matching_files/go.mod --
+module example.com/broken
+go 1.16
+
+require (
+       example.com/brokendep v0.1.0
+)
+
+replace (
+       example.com/brokendep v0.1.0 => ./brokendep
+)
+-- broken_no_matching_files/f.go --
+package broken
+
+import _ "example.com/brokendep"
+
+func F() {}
+-- broken_no_matching_files/brokendep/go.mod --
+module example.com/brokendep
+go 1.16
+-- broken_no_matching_files/brokendep/f.go --
+package brokendep
+
+import _ "embed"
+
+//go:embed foo.txt
+var foo string
+-- broken_bad_pattern/go.mod --
+module example.com/broken
+go 1.16
+
+require (
+       example.com/brokendep v0.1.0
+)
+
+replace (
+       example.com/brokendep v0.1.0 => ./brokendep
+)
+-- broken_bad_pattern/f.go --
+package broken
+
+import _ "example.com/brokendep"
+
+func F() {}
+-- broken_bad_pattern/brokendep/go.mod --
+module example.com/brokendep
+go 1.16
+-- broken_bad_pattern/brokendep/f.go --
+package brokendep
+
+import _ "embed"
+
+//go:embed ../foo.txt
+var foo string
+-- embed_unbuilt/go.mod --
+module example.com/foo
+go 1.16
+
+require (
+       example.com/dep v0.1.0
+)
+
+replace (
+       example.com/dep v0.1.0 => ./dep
+)
+-- embed_unbuilt/foo.go --
+package a
+
+import _ "example.com/dep"
+
+func F() {}
+-- embed_unbuilt/dep/go.mod --
+module example.com/dep
+go 1.16
+-- embed_unbuilt/dep/dep.go --
+package dep
+
+import _ "embed"
+
+//go:embed unbuilt.go
+var unbuilt string
+
+//go:embed dep_test.go
+var depTest string
+-- embed_unbuilt/dep/unbuilt.go --
+// +build ignore
+
+package dep
+-- embed_unbuilt/dep/not_embedded_unbuilt.go --
+// +build ignore
+
+package dep
+-- embed_unbuilt/dep/dep_test.go --
+package dep
+-- embed_unbuilt/dep/not_embedded_dep_test.go --
+package dep

diff --git a/src/cmd/go/testdata/script/mod_versions.txt b/src/cmd/go/testdata/script/mod_versions.txt
index fd5e5c589d2237490b055de861603e1ae6938e91..9e6322bae117f778289477642521666befe32ab4 100644 (file)
--- a/src/cmd/go/testdata/script/mod_versions.txt
+++ b/src/cmd/go/testdata/script/mod_versions.txt
@@ -1,14 +1,14 @@
 # Test rejection of pkg@version in GOPATH mode.
 env GO111MODULE=off
 ! go get rsc.io/quote@v1.5.1
-stderr 'cannot use path@version syntax in GOPATH mode'
+stderr '^go: can only use path@version syntax with ''go get'' and ''go install'' in module-aware mode$'
 ! go build rsc.io/quote@v1.5.1
-stderr 'cannot use path@version syntax in GOPATH mode'
+stderr '^package rsc.io/quote@v1.5.1: can only use path@version syntax with ''go get'' and ''go install'' in module-aware mode$'
 
 env GO111MODULE=on
 cd x
 ! go build rsc.io/quote@v1.5.1
-stderr 'can only use path@version syntax with ''go get'''
+stderr '^package rsc.io/quote@v1.5.1: can only use path@version syntax with ''go get'' and ''go install'' in module-aware mode$'
 
 -- x/go.mod --
 module x

diff --git a/src/cmd/go/testdata/script/test_exit.txt b/src/cmd/go/testdata/script/test_exit.txt
index 23a2429d1ecaaaa9d7b8ab50cb975a34c6a9e386..3703ba53d362b0b0930cde8aa2ff233c5eee9934 100644 (file)
--- a/src/cmd/go/testdata/script/test_exit.txt
+++ b/src/cmd/go/testdata/script/test_exit.txt
@@ -54,6 +54,23 @@ go test -list=. ./main_zero
 stdout 'skipping all tests'
 ! stdout TestNotListed
 
+# Running the test directly still fails, if we pass the flag.
+go test -c -o ./zero.exe ./zero
+! exec ./zero.exe -test.paniconexit0
+
+# Using -json doesn't affect the exit status.
+! go test -json ./zero
+! stdout '"Output":"ok'
+! stdout 'exit status'
+stdout 'panic'
+stdout '"Output":"FAIL'
+
+# Running the test via test2json also fails.
+! go tool test2json ./zero.exe -test.v -test.paniconexit0
+! stdout '"Output":"ok'
+! stdout 'exit status'
+stdout 'panic'
+
 -- go.mod --
 module m
 

diff --git a/src/cmd/go/testdata/script/test_flag.txt b/src/cmd/go/testdata/script/test_flag.txt
index ec88d38cbe805f96194d13670e00b4fcd145e837..0142b3f308f3b28005cb05f39819ca7073fa2a67 100644 (file)
--- a/src/cmd/go/testdata/script/test_flag.txt
+++ b/src/cmd/go/testdata/script/test_flag.txt
@@ -9,13 +9,13 @@ go test -count=1 -custom -args -v=7
 # However, it should be an error to use custom flags when -i or -c are used,
 # since we know for sure that no test binary will run at all.
 ! go test -i -custom
-stderr '^flag -custom is not a ''go test'' flag \(unknown flags cannot be used with -i\)$'
+stderr '^go test: unknown flag -custom cannot be used with -i$'
 ! go test -c -custom
-stderr '^flag -custom is not a ''go test'' flag \(unknown flags cannot be used with -c\)$'
+stderr '^go test: unknown flag -custom cannot be used with -c$'
 
 # The same should apply even if -c or -i come after a custom flag.
 ! go test -custom -c
-stderr '^flag -custom is not a ''go test'' flag \(unknown flags cannot be used with -c\)$'
+stderr '^go test: unknown flag -custom cannot be used with -c$'
 
 -- go.mod --
 module m

diff --git a/src/cmd/internal/archive/archive.go b/src/cmd/internal/archive/archive.go
index c1661d7711ac901ef1ae73539e38cd2f64c83785..e9b25fe240a34941a0935464dcb0795d7cba37ff 100644 (file)
--- a/src/cmd/internal/archive/archive.go
+++ b/src/cmd/internal/archive/archive.go
@@ -118,9 +118,9 @@ type objReader struct {
 
 func (r *objReader) init(f *os.File) {
        r.a = &Archive{f, nil}
-       r.offset, _ = f.Seek(0, io.SeekCurrent)
-       r.limit, _ = f.Seek(0, io.SeekEnd)
-       f.Seek(r.offset, io.SeekStart)
+       r.offset, _ = f.Seek(0, os.SEEK_CUR)
+       r.limit, _ = f.Seek(0, os.SEEK_END)
+       f.Seek(r.offset, os.SEEK_SET)
        r.b = bio.NewReader(f)
 }
 
@@ -221,7 +221,7 @@ func (r *objReader) skip(n int64) {
                r.readFull(r.tmp[:n])
        } else {
                // Seek, giving up buffered data.
-               r.b.MustSeek(r.offset+n, io.SeekStart)
+               r.b.MustSeek(r.offset+n, os.SEEK_SET)
                r.offset += n
        }
 }
@@ -426,7 +426,7 @@ func (r *objReader) parseObject(o *GoObj, size int64) error {
 
 // AddEntry adds an entry to the end of a, with the content from r.
 func (a *Archive) AddEntry(typ EntryType, name string, mtime int64, uid, gid int, mode os.FileMode, size int64, r io.Reader) {
-       off, err := a.f.Seek(0, io.SeekEnd)
+       off, err := a.f.Seek(0, os.SEEK_END)
        if err != nil {
                log.Fatal(err)
        }
@@ -464,3 +464,24 @@ func exactly16Bytes(s string) string {
        s += sixteenSpaces[:16-len(s)]
        return s
 }
+
+// architecture-independent object file output
+const HeaderSize = 60
+
+func ReadHeader(b *bufio.Reader, name string) int {
+       var buf [HeaderSize]byte
+       if _, err := io.ReadFull(b, buf[:]); err != nil {
+               return -1
+       }
+       aname := strings.Trim(string(buf[0:16]), " ")
+       if !strings.HasPrefix(aname, name) {
+               return -1
+       }
+       asize := strings.Trim(string(buf[48:58]), " ")
+       i, _ := strconv.Atoi(asize)
+       return i
+}
+
+func FormatHeader(arhdr []byte, name string, size int64) {
+       copy(arhdr[:], fmt.Sprintf("%-16s%-12d%-6d%-6d%-8o%-10d`\n", name, 0, 0, 0, 0644, size))
+}

diff --git a/src/cmd/internal/browser/browser.go b/src/cmd/internal/browser/browser.go
index 6867c85d2320406bb4c80b8960f5b958c6a2f196..577d31789f19afcb768e847cd69d2714e4d48b06 100644 (file)
--- a/src/cmd/internal/browser/browser.go
+++ b/src/cmd/internal/browser/browser.go
@@ -6,8 +6,8 @@
 package browser
 
 import (
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "runtime"
        "time"
 )

diff --git a/src/cmd/internal/diff/diff.go b/src/cmd/internal/diff/diff.go
index e9d2c237800a9c6c658eb41db1b58dcff102fe18..0ec2d7f8f95dceb7d5872b842e650c040d24fbc4 100644 (file)
--- a/src/cmd/internal/diff/diff.go
+++ b/src/cmd/internal/diff/diff.go
@@ -7,9 +7,10 @@
 package diff
 
 import (
+       "bytes"
+       exec "internal/execabs"
        "io/ioutil"
        "os"
-       "os/exec"
        "runtime"
 )
 
@@ -38,6 +39,25 @@ func Diff(prefix string, b1, b2 []byte) ([]byte, error) {
                // Ignore that failure as long as we get output.
                err = nil
        }
+
+       // If we are on Windows and the diff is Cygwin diff,
+       // machines can get into a state where every Cygwin
+       // command works fine but prints a useless message like:
+       //
+       //      Cygwin WARNING:
+       //        Couldn't compute FAST_CWD pointer.  This typically occurs if you're using
+       //        an older Cygwin version on a newer Windows.  Please update to the latest
+       //        available Cygwin version from https://cygwin.com/.  If the problem persists,
+       //        please see https://cygwin.com/problems.html
+       //
+       // Skip over that message and just return the actual diff.
+       if len(data) > 0 && !bytes.HasPrefix(data, []byte("--- ")) {
+               i := bytes.Index(data, []byte("\n--- "))
+               if i >= 0 && i < 80*10 && bytes.Contains(data[:i], []byte("://cygwin.com/")) {
+                       data = data[i+1:]
+               }
+       }
+
        return data, err
 }
 

diff --git a/src/cmd/internal/dwarf/dwarf.go b/src/cmd/internal/dwarf/dwarf.go
index e1a70ef853e7c06d53d306f18e167f78e0b4bfcd..8de4096f068ea6fa60b655f5458686f11d765579 100644 (file)
--- a/src/cmd/internal/dwarf/dwarf.go
+++ b/src/cmd/internal/dwarf/dwarf.go
@@ -12,7 +12,7 @@ import (
        "cmd/internal/objabi"
        "errors"
        "fmt"
-       "os/exec"
+       exec "internal/execabs"
        "sort"
        "strconv"
        "strings"

diff --git a/src/cmd/internal/goobj/funcinfo.go b/src/cmd/internal/goobj/funcinfo.go
index 2cca8f6c4ef9c05f831cf8597c7190c4f2defabd..6d33a10a51cda4cde69a36aaf281f6c61a520a1c 100644 (file)
--- a/src/cmd/internal/goobj/funcinfo.go
+++ b/src/cmd/internal/goobj/funcinfo.go
@@ -19,9 +19,10 @@ type CUFileIndex uint32
 //
 // TODO: make each pcdata a separate symbol?
 type FuncInfo struct {
-       Args   uint32
-       Locals uint32
-       FuncID objabi.FuncID
+       Args     uint32
+       Locals   uint32
+       FuncID   objabi.FuncID
+       FuncFlag objabi.FuncFlag
 
        Pcsp        SymRef
        Pcfile      SymRef
@@ -35,6 +36,9 @@ type FuncInfo struct {
 }
 
 func (a *FuncInfo) Write(w *bytes.Buffer) {
+       writeUint8 := func(x uint8) {
+               w.WriteByte(x)
+       }
        var b [4]byte
        writeUint32 := func(x uint32) {
                binary.LittleEndian.PutUint32(b[:], x)
@@ -47,8 +51,10 @@ func (a *FuncInfo) Write(w *bytes.Buffer) {
 
        writeUint32(a.Args)
        writeUint32(a.Locals)
-       writeUint32(uint32(a.FuncID))
-
+       writeUint8(uint8(a.FuncID))
+       writeUint8(uint8(a.FuncFlag))
+       writeUint8(0) // pad to uint32 boundary
+       writeUint8(0)
        writeSymRef(a.Pcsp)
        writeSymRef(a.Pcfile)
        writeSymRef(a.Pcline)
@@ -72,46 +78,6 @@ func (a *FuncInfo) Write(w *bytes.Buffer) {
        }
 }
 
-func (a *FuncInfo) Read(b []byte) {
-       readUint32 := func() uint32 {
-               x := binary.LittleEndian.Uint32(b)
-               b = b[4:]
-               return x
-       }
-       readSymIdx := func() SymRef {
-               return SymRef{readUint32(), readUint32()}
-       }
-
-       a.Args = readUint32()
-       a.Locals = readUint32()
-       a.FuncID = objabi.FuncID(readUint32())
-
-       a.Pcsp = readSymIdx()
-       a.Pcfile = readSymIdx()
-       a.Pcline = readSymIdx()
-       a.Pcinline = readSymIdx()
-       a.Pcdata = make([]SymRef, readUint32())
-       for i := range a.Pcdata {
-               a.Pcdata[i] = readSymIdx()
-       }
-
-       funcdataofflen := readUint32()
-       a.Funcdataoff = make([]uint32, funcdataofflen)
-       for i := range a.Funcdataoff {
-               a.Funcdataoff[i] = readUint32()
-       }
-       filelen := readUint32()
-       a.File = make([]CUFileIndex, filelen)
-       for i := range a.File {
-               a.File[i] = CUFileIndex(readUint32())
-       }
-       inltreelen := readUint32()
-       a.InlTree = make([]InlTreeNode, inltreelen)
-       for i := range a.InlTree {
-               b = a.InlTree[i].Read(b)
-       }
-}
-
 // FuncInfoLengths is a cache containing a roadmap of offsets and
 // lengths for things within a serialized FuncInfo. Each length field
 // stores the number of items (e.g. files, inltree nodes, etc), and the
@@ -159,7 +125,9 @@ func (*FuncInfo) ReadArgs(b []byte) uint32 { return binary.LittleEndian.Uint32(b
 
 func (*FuncInfo) ReadLocals(b []byte) uint32 { return binary.LittleEndian.Uint32(b[4:]) }
 
-func (*FuncInfo) ReadFuncID(b []byte) uint32 { return binary.LittleEndian.Uint32(b[8:]) }
+func (*FuncInfo) ReadFuncID(b []byte) objabi.FuncID { return objabi.FuncID(b[8]) }
+
+func (*FuncInfo) ReadFuncFlag(b []byte) objabi.FuncFlag { return objabi.FuncFlag(b[9]) }
 
 func (*FuncInfo) ReadPcsp(b []byte) SymRef {
        return SymRef{binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])}

diff --git a/src/cmd/internal/goobj/mkbuiltin.go b/src/cmd/internal/goobj/mkbuiltin.go
index 07c340668138d1503e36959be1ee974961062fb1..22608e7e6995ee9a5ebfab8f5be57d24a9b7a2f2 100644 (file)
--- a/src/cmd/internal/goobj/mkbuiltin.go
+++ b/src/cmd/internal/goobj/mkbuiltin.go
@@ -118,8 +118,8 @@ func mkbuiltin(w io.Writer) {
 
 // addBasicTypes returns the symbol names for basic types that are
 // defined in the runtime and referenced in other packages.
-// Needs to be kept in sync with reflect.go:dumpbasictypes() and
-// reflect.go:dtypesym() in the compiler.
+// Needs to be kept in sync with reflect.go:WriteBasicTypes() and
+// reflect.go:writeType() in the compiler.
 func enumerateBasicTypes() []extra {
        names := [...]string{
                "int8", "uint8", "int16", "uint16",

diff --git a/src/cmd/internal/goobj/objfile.go b/src/cmd/internal/goobj/objfile.go
index 6e76bea1117ca762e2cae7e1367a117899d81559..d1b838f676c8256963be3f02608107c294d2fe38 100644 (file)
--- a/src/cmd/internal/goobj/objfile.go
+++ b/src/cmd/internal/goobj/objfile.go
@@ -298,7 +298,6 @@ const (
        SymFlagNoSplit
        SymFlagReflectMethod
        SymFlagGoType
-       SymFlagTopFrame
 )
 
 // Sym.Flag2
@@ -332,7 +331,6 @@ func (s *Sym) Leaf() bool          { return s.Flag()&SymFlagLeaf != 0 }
 func (s *Sym) NoSplit() bool       { return s.Flag()&SymFlagNoSplit != 0 }
 func (s *Sym) ReflectMethod() bool { return s.Flag()&SymFlagReflectMethod != 0 }
 func (s *Sym) IsGoType() bool      { return s.Flag()&SymFlagGoType != 0 }
-func (s *Sym) TopFrame() bool      { return s.Flag()&SymFlagTopFrame != 0 }
 func (s *Sym) UsedInIface() bool   { return s.Flag2()&SymFlagUsedInIface != 0 }
 func (s *Sym) IsItab() bool        { return s.Flag2()&SymFlagItab != 0 }
 
@@ -483,6 +481,11 @@ func (r *RefFlags) SetFlag2(x uint8) { r[9] = x }
 
 func (r *RefFlags) Write(w *Writer) { w.Bytes(r[:]) }
 
+// Used to construct an artifically large array type when reading an
+// item from the object file relocs section or aux sym section (needs
+// to work on 32-bit as well as 64-bit). See issue 41621.
+const huge = (1<<31 - 1) / RelocSize
+
 // Referenced symbol name.
 //
 // Serialized format:
@@ -792,7 +795,7 @@ func (r *Reader) Reloc(i uint32, j int) *Reloc {
 func (r *Reader) Relocs(i uint32) []Reloc {
        off := r.RelocOff(i, 0)
        n := r.NReloc(i)
-       return (*[1 << 20]Reloc)(unsafe.Pointer(&r.b[off]))[:n:n]
+       return (*[huge]Reloc)(unsafe.Pointer(&r.b[off]))[:n:n]
 }
 
 // NAux returns the number of aux symbols of the i-th symbol.
@@ -818,7 +821,7 @@ func (r *Reader) Aux(i uint32, j int) *Aux {
 func (r *Reader) Auxs(i uint32) []Aux {
        off := r.AuxOff(i, 0)
        n := r.NAux(i)
-       return (*[1 << 20]Aux)(unsafe.Pointer(&r.b[off]))[:n:n]
+       return (*[huge]Aux)(unsafe.Pointer(&r.b[off]))[:n:n]
 }
 
 // DataOff returns the offset of the i-th symbol's data.

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 9ea21873c5ed9075b75cc49332402547cea8613b..cba401c896aad2a6e0cc811a7425a5731216c6a4 100644 (file)
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -8,6 +8,7 @@ import (
        "encoding/json"
        "fmt"
        "internal/testenv"
+       "io"
        "io/fs"
        "io/ioutil"
        "os"
@@ -21,93 +22,34 @@ import (
        "golang.org/x/mod/module"
 )
 
-type gorootModule struct {
-       Path      string
-       Dir       string
-       hasVendor bool
-}
-
-// findGorootModules returns the list of modules found in the GOROOT source tree.
-func findGorootModules(t *testing.T) []gorootModule {
-       t.Helper()
-       goBin := testenv.GoToolPath(t)
-
-       goroot.once.Do(func() {
-               goroot.err = filepath.WalkDir(runtime.GOROOT(), func(path string, info fs.DirEntry, err error) error {
-                       if err != nil {
-                               return err
-                       }
-                       if info.IsDir() && (info.Name() == "vendor" || info.Name() == "testdata") {
-                               return filepath.SkipDir
-                       }
-                       if path == filepath.Join(runtime.GOROOT(), "pkg") {
-                               // GOROOT/pkg contains generated artifacts, not source code.
-                               //
-                               // In https://golang.org/issue/37929 it was observed to somehow contain
-                               // a module cache, so it is important to skip. (That helps with the
-                               // running time of this test anyway.)
-                               return filepath.SkipDir
-                       }
-                       if info.IsDir() || info.Name() != "go.mod" {
-                               return nil
-                       }
-                       dir := filepath.Dir(path)
-
-                       // Use 'go list' to describe the module contained in this directory (but
-                       // not its dependencies).
-                       cmd := exec.Command(goBin, "list", "-json", "-m")
-                       cmd.Env = append(os.Environ(), "GO111MODULE=on")
-                       cmd.Dir = dir
-                       cmd.Stderr = new(strings.Builder)
-                       out, err := cmd.Output()
-                       if err != nil {
-                               return fmt.Errorf("'go list -json -m' in %s: %w\n%s", dir, err, cmd.Stderr)
-                       }
-
-                       var m gorootModule
-                       if err := json.Unmarshal(out, &m); err != nil {
-                               return fmt.Errorf("decoding 'go list -json -m' in %s: %w", dir, err)
-                       }
-                       if m.Path == "" || m.Dir == "" {
-                               return fmt.Errorf("'go list -json -m' in %s failed to populate Path and/or Dir", dir)
-                       }
-                       if _, err := os.Stat(filepath.Join(dir, "vendor")); err == nil {
-                               m.hasVendor = true
-                       }
-                       goroot.modules = append(goroot.modules, m)
-                       return nil
-               })
-       })
-
-       if goroot.err != nil {
-               t.Fatal(goroot.err)
-       }
-       return goroot.modules
-}
-
-// goroot caches the list of modules found in the GOROOT source tree.
-var goroot struct {
-       once    sync.Once
-       modules []gorootModule
-       err     error
-}
-
-// TestAllDependenciesVendored ensures that all packages imported within GOROOT
-// are vendored in the corresponding GOROOT module.
+// TestAllDependencies ensures dependencies of all
+// modules in GOROOT are in a consistent state.
 //
-// This property allows offline development within the Go project, and ensures
-// that all dependency changes are presented in the usual code review process.
+// In short mode, it does a limited quick check and stops there.
+// In long mode, it also makes a copy of the entire GOROOT tree
+// and requires network access to perform more thorough checks.
+// Keep this distinction in mind when adding new checks.
 //
-// This test does NOT ensure that the vendored contents match the unmodified
-// contents of the corresponding dependency versions. Such as test would require
-// network access, and would currently either need to copy the entire GOROOT module
-// or explicitly invoke version control to check for changes.
-// (See golang.org/issue/36852 and golang.org/issue/27348.)
-func TestAllDependenciesVendored(t *testing.T) {
+// See issues 36852, 41409, and 43687.
+// (Also see golang.org/issue/27348.)
+func TestAllDependencies(t *testing.T) {
        goBin := testenv.GoToolPath(t)
 
+       // Ensure that all packages imported within GOROOT
+       // are vendored in the corresponding GOROOT module.
+       //
+       // This property allows offline development within the Go project, and ensures
+       // that all dependency changes are presented in the usual code review process.
+       //
+       // As a quick first-order check, avoid network access and the need to copy the
+       // entire GOROOT tree or explicitly invoke version control to check for changes.
+       // Just check that packages are vendored. (In non-short mode, we go on to also
+       // copy the GOROOT tree and perform more rigorous consistency checks. Jump below
+       // for more details.)
        for _, m := range findGorootModules(t) {
-               t.Run(m.Path, func(t *testing.T) {
+               // This short test does NOT ensure that the vendored contents match
+               // the unmodified contents of the corresponding dependency versions.
+               t.Run(m.Path+"(quick)", func(t *testing.T) {
                        if m.hasVendor {
                                // Load all of the packages in the module to ensure that their
                                // dependencies are vendored. If any imported package is missing,
@@ -140,6 +82,226 @@ func TestAllDependenciesVendored(t *testing.T) {
                        }
                })
        }
+
+       // We now get to the slow, but more thorough part of the test.
+       // Only run it in long test mode.
+       if testing.Short() {
+               return
+       }
+
+       // Ensure that all modules within GOROOT are tidy, vendored, and bundled.
+       // Ensure that the vendored contents match the unmodified contents of the
+       // corresponding dependency versions.
+       //
+       // The non-short section of this test requires network access and the diff
+       // command.
+       //
+       // It makes a temporary copy of the entire GOROOT tree (where it can safely
+       // perform operations that may mutate the tree), executes the same module
+       // maintenance commands that we expect Go developers to run, and then
+       // diffs the potentially modified module copy with the real one in GOROOT.
+       // (We could try to rely on Git to do things differently, but that's not the
+       // path we've chosen at this time. This allows the test to run when the tree
+       // is not checked into Git.)
+
+       testenv.MustHaveExternalNetwork(t)
+       if haveDiff := func() bool {
+               diff, err := exec.Command("diff", "--recursive", "--unified", ".", ".").CombinedOutput()
+               if err != nil || len(diff) != 0 {
+                       return false
+               }
+               diff, err = exec.Command("diff", "--recursive", "--unified", ".", "..").CombinedOutput()
+               if err == nil || len(diff) == 0 {
+                       return false
+               }
+               return true
+       }(); !haveDiff {
+               // For now, the diff command is a mandatory dependency of this test.
+               // This test will primarily run on longtest builders, since few people
+               // would test the cmd/internal/moddeps package directly, and all.bash
+               // runs tests in short mode. It's fine to skip if diff is unavailable.
+               t.Skip("skipping because a diff command with support for --recursive and --unified flags is unavailable")
+       }
+
+       // Build the bundle binary at the golang.org/x/tools
+       // module version specified in GOROOT/src/cmd/go.mod.
+       bundleDir := t.TempDir()
+       r := runner{Dir: filepath.Join(runtime.GOROOT(), "src/cmd")}
+       r.run(t, goBin, "build", "-mod=readonly", "-o", bundleDir, "golang.org/x/tools/cmd/bundle")
+
+       var gorootCopyDir string
+       for _, m := range findGorootModules(t) {
+               // Create a test-wide GOROOT copy. It can be created once
+               // and reused between subtests whenever they don't fail.
+               //
+               // This is a relatively expensive operation, but it's a pre-requisite to
+               // be able to safely run commands like "go mod tidy", "go mod vendor", and
+               // "go generate" on the GOROOT tree content. Those commands may modify the
+               // tree, and we don't want to happen to the real tree as part of executing
+               // a test.
+               if gorootCopyDir == "" {
+                       gorootCopyDir = makeGOROOTCopy(t)
+               }
+
+               t.Run(m.Path+"(thorough)", func(t *testing.T) {
+                       defer func() {
+                               if t.Failed() {
+                                       // The test failed, which means it's possible the GOROOT copy
+                                       // may have been modified. No choice but to reset it for next
+                                       // module test case. (This is slow, but it happens only during
+                                       // test failures.)
+                                       gorootCopyDir = ""
+                               }
+                       }()
+
+                       rel, err := filepath.Rel(runtime.GOROOT(), m.Dir)
+                       if err != nil {
+                               t.Fatalf("filepath.Rel(%q, %q): %v", runtime.GOROOT(), m.Dir, err)
+                       }
+                       r := runner{
+                               Dir: filepath.Join(gorootCopyDir, rel),
+                               Env: append(os.Environ(),
+                                       // Set GOROOT.
+                                       "GOROOT="+gorootCopyDir,
+                                       // Explicitly clear PWD and GOROOT_FINAL so that GOROOT=gorootCopyDir is definitely used.
+                                       "PWD=",
+                                       "GOROOT_FINAL=",
+                                       // Add GOROOTcopy/bin and bundleDir to front of PATH.
+                                       "PATH="+filepath.Join(gorootCopyDir, "bin")+string(filepath.ListSeparator)+
+                                               bundleDir+string(filepath.ListSeparator)+os.Getenv("PATH"),
+                               ),
+                       }
+                       goBinCopy := filepath.Join(gorootCopyDir, "bin", "go")
+                       r.run(t, goBinCopy, "mod", "tidy")   // See issue 43687.
+                       r.run(t, goBinCopy, "mod", "verify") // Verify should be a no-op, but test it just in case.
+                       r.run(t, goBinCopy, "mod", "vendor") // See issue 36852.
+                       pkgs := packagePattern(m.Path)
+                       r.run(t, goBinCopy, "generate", `-run=^//go:generate bundle `, pkgs) // See issue 41409.
+                       advice := "$ cd " + m.Dir + "\n" +
+                               "$ go mod tidy                               # to remove extraneous dependencies\n" +
+                               "$ go mod vendor                             # to vendor dependecies\n" +
+                               "$ go generate -run=bundle " + pkgs + "               # to regenerate bundled packages\n"
+                       if m.Path == "std" {
+                               r.run(t, goBinCopy, "generate", "syscall", "internal/syscall/...") // See issue 43440.
+                               advice += "$ go generate syscall internal/syscall/...  # to regenerate syscall packages\n"
+                       }
+                       // TODO(golang.org/issue/43440): Check anything else influenced by dependency versions.
+
+                       diff, err := exec.Command("diff", "--recursive", "--unified", r.Dir, m.Dir).CombinedOutput()
+                       if err != nil || len(diff) != 0 {
+                               t.Errorf(`Module %s in %s is not tidy (-want +got):
+
+%s
+To fix it, run:
+
+%s
+(If module %[1]s is definitely tidy, this could mean
+there's a problem in the go or bundle command.)`, m.Path, m.Dir, diff, advice)
+                       }
+               })
+       }
+}
+
+// packagePattern returns a package pattern that matches all packages
+// in the module modulePath, and ideally as few others as possible.
+func packagePattern(modulePath string) string {
+       if modulePath == "std" {
+               return "std"
+       }
+       return modulePath + "/..."
+}
+
+// makeGOROOTCopy makes a temporary copy of the current GOROOT tree.
+// The goal is to allow the calling test t to safely mutate a GOROOT
+// copy without also modifying the original GOROOT.
+//
+// It copies the entire tree as is, with the exception of the GOROOT/.git
+// directory, which is skipped, and the GOROOT/{bin,pkg} directories,
+// which are symlinked. This is done for speed, since a GOROOT tree is
+// functional without being in a Git repository, and bin and pkg are
+// deemed safe to share for the purpose of the TestAllDependencies test.
+func makeGOROOTCopy(t *testing.T) string {
+       t.Helper()
+       gorootCopyDir := t.TempDir()
+       err := filepath.Walk(runtime.GOROOT(), func(src string, info os.FileInfo, err error) error {
+               if err != nil {
+                       return err
+               }
+               if src == filepath.Join(runtime.GOROOT(), ".git") {
+                       return filepath.SkipDir
+               }
+
+               rel, err := filepath.Rel(runtime.GOROOT(), src)
+               if err != nil {
+                       return fmt.Errorf("filepath.Rel(%q, %q): %v", runtime.GOROOT(), src, err)
+               }
+               dst := filepath.Join(gorootCopyDir, rel)
+
+               switch src {
+               case filepath.Join(runtime.GOROOT(), "bin"),
+                       filepath.Join(runtime.GOROOT(), "pkg"):
+                       // If the OS supports symlinks, use them instead
+                       // of copying the bin and pkg directories.
+                       if err := os.Symlink(src, dst); err == nil {
+                               return filepath.SkipDir
+                       }
+               }
+
+               perm := info.Mode() & os.ModePerm
+               if info.Mode()&os.ModeSymlink != 0 {
+                       info, err = os.Stat(src)
+                       if err != nil {
+                               return err
+                       }
+                       perm = info.Mode() & os.ModePerm
+               }
+
+               // If it's a directory, make a corresponding directory.
+               if info.IsDir() {
+                       return os.MkdirAll(dst, perm|0200)
+               }
+
+               // Copy the file bytes.
+               // We can't create a symlink because the file may get modified;
+               // we need to ensure that only the temporary copy is affected.
+               s, err := os.Open(src)
+               if err != nil {
+                       return err
+               }
+               defer s.Close()
+               d, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
+               if err != nil {
+                       return err
+               }
+               _, err = io.Copy(d, s)
+               if err != nil {
+                       d.Close()
+                       return err
+               }
+               return d.Close()
+       })
+       if err != nil {
+               t.Fatal(err)
+       }
+       return gorootCopyDir
+}
+
+type runner struct {
+       Dir string
+       Env []string
+}
+
+// run runs the command and requires that it succeeds.
+func (r runner) run(t *testing.T, args ...string) {
+       t.Helper()
+       cmd := exec.Command(args[0], args[1:]...)
+       cmd.Dir = r.Dir
+       cmd.Env = r.Env
+       out, err := cmd.CombinedOutput()
+       if err != nil {
+               t.Logf("> %s\n", strings.Join(args, " "))
+               t.Fatalf("command failed: %s\n%s", err, out)
+       }
 }
 
 // TestDependencyVersionsConsistent verifies that each module in GOROOT that
@@ -159,8 +321,7 @@ func TestDependencyVersionsConsistent(t *testing.T) {
        seen := map[string]map[requirement][]gorootModule{} // module path → requirement → set of modules with that requirement
        for _, m := range findGorootModules(t) {
                if !m.hasVendor {
-                       // TestAllDependenciesVendored will ensure that the module has no
-                       // dependencies.
+                       // TestAllDependencies will ensure that the module has no dependencies.
                        continue
                }
 
@@ -233,3 +394,74 @@ func TestDependencyVersionsConsistent(t *testing.T) {
                }
        }
 }
+
+type gorootModule struct {
+       Path      string
+       Dir       string
+       hasVendor bool
+}
+
+// findGorootModules returns the list of modules found in the GOROOT source tree.
+func findGorootModules(t *testing.T) []gorootModule {
+       t.Helper()
+       goBin := testenv.GoToolPath(t)
+
+       goroot.once.Do(func() {
+               goroot.err = filepath.WalkDir(runtime.GOROOT(), func(path string, info fs.DirEntry, err error) error {
+                       if err != nil {
+                               return err
+                       }
+                       if info.IsDir() && (info.Name() == "vendor" || info.Name() == "testdata") {
+                               return filepath.SkipDir
+                       }
+                       if path == filepath.Join(runtime.GOROOT(), "pkg") {
+                               // GOROOT/pkg contains generated artifacts, not source code.
+                               //
+                               // In https://golang.org/issue/37929 it was observed to somehow contain
+                               // a module cache, so it is important to skip. (That helps with the
+                               // running time of this test anyway.)
+                               return filepath.SkipDir
+                       }
+                       if info.IsDir() || info.Name() != "go.mod" {
+                               return nil
+                       }
+                       dir := filepath.Dir(path)
+
+                       // Use 'go list' to describe the module contained in this directory (but
+                       // not its dependencies).
+                       cmd := exec.Command(goBin, "list", "-json", "-m")
+                       cmd.Env = append(os.Environ(), "GO111MODULE=on")
+                       cmd.Dir = dir
+                       cmd.Stderr = new(strings.Builder)
+                       out, err := cmd.Output()
+                       if err != nil {
+                               return fmt.Errorf("'go list -json -m' in %s: %w\n%s", dir, err, cmd.Stderr)
+                       }
+
+                       var m gorootModule
+                       if err := json.Unmarshal(out, &m); err != nil {
+                               return fmt.Errorf("decoding 'go list -json -m' in %s: %w", dir, err)
+                       }
+                       if m.Path == "" || m.Dir == "" {
+                               return fmt.Errorf("'go list -json -m' in %s failed to populate Path and/or Dir", dir)
+                       }
+                       if _, err := os.Stat(filepath.Join(dir, "vendor")); err == nil {
+                               m.hasVendor = true
+                       }
+                       goroot.modules = append(goroot.modules, m)
+                       return nil
+               })
+       })
+
+       if goroot.err != nil {
+               t.Fatal(goroot.err)
+       }
+       return goroot.modules
+}
+
+// goroot caches the list of modules found in the GOROOT source tree.
+var goroot struct {
+       once    sync.Once
+       modules []gorootModule
+       err     error
+}

diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 29d3a5867d5245e75f77f842427dd0a8d6228bb0..7de04302d918fe7d0d42b24f2172dcf3d3df75f9 100644 (file)
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -34,6 +34,7 @@ import (
        "cmd/internal/obj"
        "cmd/internal/objabi"
        "cmd/internal/sys"
+       "log"
 )
 
 var progedit_tlsfallback *obj.LSym
@@ -613,6 +614,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                p.From.Reg = REGSP
                        }
                }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+                       f := c.cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
+                       }
+               }
        }
 }
 

diff --git a/src/cmd/internal/obj/arm64/a.out.go b/src/cmd/internal/obj/arm64/a.out.go
index 1d1bea505cd17f9d0406f41911b38cd60452530b..7ab9c1475f7b9a74e542ec158c414d6a989647b2 100644 (file)
--- a/src/cmd/internal/obj/arm64/a.out.go
+++ b/src/cmd/internal/obj/arm64/a.out.go
@@ -239,7 +239,7 @@ const (
        REGCTXT = REG_R26 // environment for closures
        REGTMP  = REG_R27 // reserved for liblink
        REGG    = REG_R28 // G
-       REGFP   = REG_R29 // frame pointer, unused in the Go toolchain
+       REGFP   = REG_R29 // frame pointer
        REGLINK = REG_R30
 
        // ARM64 uses R31 as both stack pointer and zero register,

diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 1a359f1921b739346d118937f670d53cad65fc97..70072cfba41943a85987dc752d0c61d3e4672d09 100644 (file)
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -280,7 +280,7 @@ func MOVCONST(d int64, s int, rt int) uint32 {
 const (
        // Optab.flag
        LFROM     = 1 << 0 // p.From uses constant pool
-       LFROM3    = 1 << 1 // p.From3 uses constant pool
+       LFROM128  = 1 << 1 // p.From3<<64+p.From forms a 128-bit constant in literal pool
        LTO       = 1 << 2 // p.To uses constant pool
        NOTUSETMP = 1 << 3 // p expands to multiple instructions, but does NOT use REGTMP
 )
@@ -419,7 +419,7 @@ var optab = []Optab{
        {AMOVD, C_LACON, C_NONE, C_NONE, C_RSP, 34, 8, REGSP, LFROM, 0},
 
        // Move a large constant to a vector register.
-       {AVMOVQ, C_VCON, C_NONE, C_VCON, C_VREG, 101, 4, 0, LFROM | LFROM3, 0},
+       {AVMOVQ, C_VCON, C_NONE, C_VCON, C_VREG, 101, 4, 0, LFROM128, 0},
        {AVMOVD, C_VCON, C_NONE, C_NONE, C_VREG, 101, 4, 0, LFROM, 0},
        {AVMOVS, C_LCON, C_NONE, C_NONE, C_VREG, 101, 4, 0, LFROM, 0},
 
@@ -995,8 +995,8 @@ func span7(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                if o.flag&LFROM != 0 {
                        c.addpool(p, &p.From)
                }
-               if o.flag&LFROM3 != 0 {
-                       c.addpool(p, p.GetFrom3())
+               if o.flag&LFROM128 != 0 {
+                       c.addpool128(p, &p.From, p.GetFrom3())
                }
                if o.flag&LTO != 0 {
                        c.addpool(p, &p.To)
@@ -1201,6 +1201,36 @@ func (c *ctxt7) flushpool(p *obj.Prog, skip int) {
        }
 }
 
+// addpool128 adds a 128-bit constant to literal pool by two consecutive DWORD
+// instructions, the 128-bit constant is formed by ah.Offset<<64+al.Offset.
+func (c *ctxt7) addpool128(p *obj.Prog, al, ah *obj.Addr) {
+       lit := al.Offset
+       q := c.newprog()
+       q.As = ADWORD
+       q.To.Type = obj.TYPE_CONST
+       q.To.Offset = lit
+       q.Pc = int64(c.pool.size)
+
+       lit = ah.Offset
+       t := c.newprog()
+       t.As = ADWORD
+       t.To.Type = obj.TYPE_CONST
+       t.To.Offset = lit
+       t.Pc = int64(c.pool.size + 8)
+       q.Link = t
+
+       if c.blitrl == nil {
+               c.blitrl = q
+               c.pool.start = uint32(p.Pc)
+       } else {
+               c.elitrl.Link = q
+       }
+
+       c.elitrl = t
+       c.pool.size += 16
+       p.Pool = q
+}
+
 /*
  * MOVD foo(SB), R is actually
  *   MOVD addr, REGTMP

diff --git a/src/cmd/internal/obj/arm64/asm_test.go b/src/cmd/internal/obj/arm64/asm_arm64_test.go
similarity index 89%
rename from src/cmd/internal/obj/arm64/asm_test.go
rename to src/cmd/internal/obj/arm64/asm_arm64_test.go
index 9efdb0217f4dbc86733343516743596363bf2130..c6a00f5b941035a774649f49d3241809c18dafad 100644 (file)
--- a/src/cmd/internal/obj/arm64/asm_test.go
+++ b/src/cmd/internal/obj/arm64/asm_arm64_test.go
@@ -47,7 +47,7 @@ func TestLarge(t *testing.T) {
 
        // assemble generated file
        cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-S", "-o", filepath.Join(dir, "test.o"), tmpfile)
-       cmd.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+       cmd.Env = append(os.Environ(), "GOOS=linux")
        out, err := cmd.CombinedOutput()
        if err != nil {
                t.Errorf("Assemble failed: %v, output: %s", err, out)
@@ -62,7 +62,7 @@ func TestLarge(t *testing.T) {
 
        // build generated file
        cmd = exec.Command(testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
-       cmd.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+       cmd.Env = append(os.Environ(), "GOOS=linux")
        out, err = cmd.CombinedOutput()
        if err != nil {
                t.Errorf("Build failed: %v, output: %s", err, out)
@@ -96,7 +96,7 @@ func TestNoRet(t *testing.T) {
                t.Fatal(err)
        }
        cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
-       cmd.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+       cmd.Env = append(os.Environ(), "GOOS=linux")
        if out, err := cmd.CombinedOutput(); err != nil {
                t.Errorf("%v\n%s", err, out)
        }
@@ -134,7 +134,7 @@ func TestPCALIGN(t *testing.T) {
                        t.Fatal(err)
                }
                cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-S", "-o", tmpout, tmpfile)
-               cmd.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+               cmd.Env = append(os.Environ(), "GOOS=linux")
                out, err := cmd.CombinedOutput()
                if err != nil {
                        t.Errorf("The %s build failed: %v, output: %s", test.name, err, out)
@@ -150,3 +150,13 @@ func TestPCALIGN(t *testing.T) {
                }
        }
 }
+
+func testvmovq() (r1, r2 uint64)
+
+// TestVMOVQ checks if the arm64 VMOVQ instruction is working properly.
+func TestVMOVQ(t *testing.T) {
+       a, b := testvmovq()
+       if a != 0x7040201008040201 || b != 0x3040201008040201 {
+               t.Errorf("TestVMOVQ got: a=0x%x, b=0x%x, want: a=0x7040201008040201, b=0x3040201008040201", a, b)
+       }
+}

diff --git a/src/cmd/internal/obj/arm64/asm_arm64_test.s b/src/cmd/internal/obj/arm64/asm_arm64_test.s
new file mode 100644 (file)
index 0000000..9d337a4
--- /dev/null
+++ b/src/cmd/internal/obj/arm64/asm_arm64_test.s
@@ -0,0 +1,14 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "textflag.h"
+
+// testvmovq() (r1, r2 uint64)
+TEXT ·testvmovq(SB), NOSPLIT, $0-16
+       VMOVQ   $0x7040201008040201, $0x3040201008040201, V1
+       VMOV    V1.D[0], R0
+       VMOV    V1.D[1], R1
+       MOVD    R0, r1+0(FP)
+       MOVD    R1, r2+8(FP)
+       RET

diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 0baf51973ade229dbd5ae975a25233304bcd9e59..8f7648e5d5e2cc33a96f757056d21077c231d701 100644 (file)
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -35,6 +35,7 @@ import (
        "cmd/internal/objabi"
        "cmd/internal/src"
        "cmd/internal/sys"
+       "log"
        "math"
 )
 
@@ -621,25 +622,24 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
                        prologueEnd.Pos = prologueEnd.Pos.WithXlogue(src.PosPrologueEnd)
 
-                       if objabi.Framepointer_enabled {
-                               q1 = obj.Appendp(q1, c.newprog)
-                               q1.Pos = p.Pos
-                               q1.As = AMOVD
-                               q1.From.Type = obj.TYPE_REG
-                               q1.From.Reg = REGFP
-                               q1.To.Type = obj.TYPE_MEM
-                               q1.To.Reg = REGSP
-                               q1.To.Offset = -8
-
-                               q1 = obj.Appendp(q1, c.newprog)
-                               q1.Pos = p.Pos
-                               q1.As = ASUB
-                               q1.From.Type = obj.TYPE_CONST
-                               q1.From.Offset = 8
-                               q1.Reg = REGSP
-                               q1.To.Type = obj.TYPE_REG
-                               q1.To.Reg = REGFP
-                       }
+                       // Frame pointer.
+                       q1 = obj.Appendp(q1, c.newprog)
+                       q1.Pos = p.Pos
+                       q1.As = AMOVD
+                       q1.From.Type = obj.TYPE_REG
+                       q1.From.Reg = REGFP
+                       q1.To.Type = obj.TYPE_MEM
+                       q1.To.Reg = REGSP
+                       q1.To.Offset = -8
+
+                       q1 = obj.Appendp(q1, c.newprog)
+                       q1.Pos = p.Pos
+                       q1.As = ASUB
+                       q1.From.Type = obj.TYPE_CONST
+                       q1.From.Offset = 8
+                       q1.Reg = REGSP
+                       q1.To.Type = obj.TYPE_REG
+                       q1.To.Reg = REGFP
 
                        if c.cursym.Func().Text.From.Sym.Wrapper() {
                                // if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
@@ -764,28 +764,26 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                        p.To.Reg = REGSP
                                        p.Spadj = -c.autosize
 
-                                       if objabi.Framepointer_enabled {
-                                               p = obj.Appendp(p, c.newprog)
-                                               p.As = ASUB
-                                               p.From.Type = obj.TYPE_CONST
-                                               p.From.Offset = 8
-                                               p.Reg = REGSP
-                                               p.To.Type = obj.TYPE_REG
-                                               p.To.Reg = REGFP
-                                       }
+                                       // Frame pointer.
+                                       p = obj.Appendp(p, c.newprog)
+                                       p.As = ASUB
+                                       p.From.Type = obj.TYPE_CONST
+                                       p.From.Offset = 8
+                                       p.Reg = REGSP
+                                       p.To.Type = obj.TYPE_REG
+                                       p.To.Reg = REGFP
                                }
                        } else {
                                /* want write-back pre-indexed SP+autosize -> SP, loading REGLINK*/
 
-                               if objabi.Framepointer_enabled {
-                                       p.As = AMOVD
-                                       p.From.Type = obj.TYPE_MEM
-                                       p.From.Reg = REGSP
-                                       p.From.Offset = -8
-                                       p.To.Type = obj.TYPE_REG
-                                       p.To.Reg = REGFP
-                                       p = obj.Appendp(p, c.newprog)
-                               }
+                               // Frame pointer.
+                               p.As = AMOVD
+                               p.From.Type = obj.TYPE_MEM
+                               p.From.Reg = REGSP
+                               p.From.Offset = -8
+                               p.To.Type = obj.TYPE_REG
+                               p.To.Reg = REGFP
+                               p = obj.Appendp(p, c.newprog)
 
                                aoffset := c.autosize
 
@@ -820,6 +818,28 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                }
                        }
 
+                       // If enabled, this code emits 'MOV PC, R27' before every 'MOV LR, PC',
+                       // so that if you are debugging a low-level crash where PC and LR are zero,
+                       // you can look at R27 to see what jumped to the zero.
+                       // This is useful when bringing up Go on a new system.
+                       // (There is similar code in ../ppc64/obj9.go:/if.false.)
+                       const debugRETZERO = false
+                       if debugRETZERO {
+                               if p.As != obj.ARET {
+                                       q = newprog()
+                                       q.Pos = p.Pos
+                                       q.Link = p.Link
+                                       p.Link = q
+                                       p = q
+                               }
+                               p.As = AADR
+                               p.From.Type = obj.TYPE_BRANCH
+                               p.From.Offset = 0
+                               p.To.Type = obj.TYPE_REG
+                               p.To.Reg = REGTMP
+
+                       }
+
                        if p.As != obj.ARET {
                                q = newprog()
                                q.Pos = p.Pos
@@ -865,109 +885,120 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                        }
 
                case obj.ADUFFCOPY:
-                       if objabi.Framepointer_enabled {
-                               //  ADR ret_addr, R27
-                               //  STP (FP, R27), -24(SP)
-                               //  SUB 24, SP, FP
-                               //  DUFFCOPY
-                               // ret_addr:
-                               //  SUB 8, SP, FP
-
-                               q1 := p
-                               // copy DUFFCOPY from q1 to q4
-                               q4 := obj.Appendp(p, c.newprog)
-                               q4.Pos = p.Pos
-                               q4.As = obj.ADUFFCOPY
-                               q4.To = p.To
-
-                               q1.As = AADR
-                               q1.From.Type = obj.TYPE_BRANCH
-                               q1.To.Type = obj.TYPE_REG
-                               q1.To.Reg = REG_R27
-
-                               q2 := obj.Appendp(q1, c.newprog)
-                               q2.Pos = p.Pos
-                               q2.As = ASTP
-                               q2.From.Type = obj.TYPE_REGREG
-                               q2.From.Reg = REGFP
-                               q2.From.Offset = int64(REG_R27)
-                               q2.To.Type = obj.TYPE_MEM
-                               q2.To.Reg = REGSP
-                               q2.To.Offset = -24
-
-                               // maintaine FP for DUFFCOPY
-                               q3 := obj.Appendp(q2, c.newprog)
-                               q3.Pos = p.Pos
-                               q3.As = ASUB
-                               q3.From.Type = obj.TYPE_CONST
-                               q3.From.Offset = 24
-                               q3.Reg = REGSP
-                               q3.To.Type = obj.TYPE_REG
-                               q3.To.Reg = REGFP
-
-                               q5 := obj.Appendp(q4, c.newprog)
-                               q5.Pos = p.Pos
-                               q5.As = ASUB
-                               q5.From.Type = obj.TYPE_CONST
-                               q5.From.Offset = 8
-                               q5.Reg = REGSP
-                               q5.To.Type = obj.TYPE_REG
-                               q5.To.Reg = REGFP
-                               q1.From.SetTarget(q5)
-                               p = q5
-                       }
+                       //  ADR ret_addr, R27
+                       //  STP (FP, R27), -24(SP)
+                       //  SUB 24, SP, FP
+                       //  DUFFCOPY
+                       // ret_addr:
+                       //  SUB 8, SP, FP
+
+                       q1 := p
+                       // copy DUFFCOPY from q1 to q4
+                       q4 := obj.Appendp(p, c.newprog)
+                       q4.Pos = p.Pos
+                       q4.As = obj.ADUFFCOPY
+                       q4.To = p.To
+
+                       q1.As = AADR
+                       q1.From.Type = obj.TYPE_BRANCH
+                       q1.To.Type = obj.TYPE_REG
+                       q1.To.Reg = REG_R27
+
+                       q2 := obj.Appendp(q1, c.newprog)
+                       q2.Pos = p.Pos
+                       q2.As = ASTP
+                       q2.From.Type = obj.TYPE_REGREG
+                       q2.From.Reg = REGFP
+                       q2.From.Offset = int64(REG_R27)
+                       q2.To.Type = obj.TYPE_MEM
+                       q2.To.Reg = REGSP
+                       q2.To.Offset = -24
+
+                       // maintain FP for DUFFCOPY
+                       q3 := obj.Appendp(q2, c.newprog)
+                       q3.Pos = p.Pos
+                       q3.As = ASUB
+                       q3.From.Type = obj.TYPE_CONST
+                       q3.From.Offset = 24
+                       q3.Reg = REGSP
+                       q3.To.Type = obj.TYPE_REG
+                       q3.To.Reg = REGFP
+
+                       q5 := obj.Appendp(q4, c.newprog)
+                       q5.Pos = p.Pos
+                       q5.As = ASUB
+                       q5.From.Type = obj.TYPE_CONST
+                       q5.From.Offset = 8
+                       q5.Reg = REGSP
+                       q5.To.Type = obj.TYPE_REG
+                       q5.To.Reg = REGFP
+                       q1.From.SetTarget(q5)
+                       p = q5
 
                case obj.ADUFFZERO:
-                       if objabi.Framepointer_enabled {
-                               //  ADR ret_addr, R27
-                               //  STP (FP, R27), -24(SP)
-                               //  SUB 24, SP, FP
-                               //  DUFFZERO
-                               // ret_addr:
-                               //  SUB 8, SP, FP
-
-                               q1 := p
-                               // copy DUFFZERO from q1 to q4
-                               q4 := obj.Appendp(p, c.newprog)
-                               q4.Pos = p.Pos
-                               q4.As = obj.ADUFFZERO
-                               q4.To = p.To
-
-                               q1.As = AADR
-                               q1.From.Type = obj.TYPE_BRANCH
-                               q1.To.Type = obj.TYPE_REG
-                               q1.To.Reg = REG_R27
-
-                               q2 := obj.Appendp(q1, c.newprog)
-                               q2.Pos = p.Pos
-                               q2.As = ASTP
-                               q2.From.Type = obj.TYPE_REGREG
-                               q2.From.Reg = REGFP
-                               q2.From.Offset = int64(REG_R27)
-                               q2.To.Type = obj.TYPE_MEM
-                               q2.To.Reg = REGSP
-                               q2.To.Offset = -24
-
-                               // maintaine FP for DUFFZERO
-                               q3 := obj.Appendp(q2, c.newprog)
-                               q3.Pos = p.Pos
-                               q3.As = ASUB
-                               q3.From.Type = obj.TYPE_CONST
-                               q3.From.Offset = 24
-                               q3.Reg = REGSP
-                               q3.To.Type = obj.TYPE_REG
-                               q3.To.Reg = REGFP
-
-                               q5 := obj.Appendp(q4, c.newprog)
-                               q5.Pos = p.Pos
-                               q5.As = ASUB
-                               q5.From.Type = obj.TYPE_CONST
-                               q5.From.Offset = 8
-                               q5.Reg = REGSP
-                               q5.To.Type = obj.TYPE_REG
-                               q5.To.Reg = REGFP
-                               q1.From.SetTarget(q5)
-                               p = q5
+                       //  ADR ret_addr, R27
+                       //  STP (FP, R27), -24(SP)
+                       //  SUB 24, SP, FP
+                       //  DUFFZERO
+                       // ret_addr:
+                       //  SUB 8, SP, FP
+
+                       q1 := p
+                       // copy DUFFZERO from q1 to q4
+                       q4 := obj.Appendp(p, c.newprog)
+                       q4.Pos = p.Pos
+                       q4.As = obj.ADUFFZERO
+                       q4.To = p.To
+
+                       q1.As = AADR
+                       q1.From.Type = obj.TYPE_BRANCH
+                       q1.To.Type = obj.TYPE_REG
+                       q1.To.Reg = REG_R27
+
+                       q2 := obj.Appendp(q1, c.newprog)
+                       q2.Pos = p.Pos
+                       q2.As = ASTP
+                       q2.From.Type = obj.TYPE_REGREG
+                       q2.From.Reg = REGFP
+                       q2.From.Offset = int64(REG_R27)
+                       q2.To.Type = obj.TYPE_MEM
+                       q2.To.Reg = REGSP
+                       q2.To.Offset = -24
+
+                       // maintain FP for DUFFZERO
+                       q3 := obj.Appendp(q2, c.newprog)
+                       q3.Pos = p.Pos
+                       q3.As = ASUB
+                       q3.From.Type = obj.TYPE_CONST
+                       q3.From.Offset = 24
+                       q3.Reg = REGSP
+                       q3.To.Type = obj.TYPE_REG
+                       q3.To.Reg = REGFP
+
+                       q5 := obj.Appendp(q4, c.newprog)
+                       q5.Pos = p.Pos
+                       q5.As = ASUB
+                       q5.From.Type = obj.TYPE_CONST
+                       q5.From.Offset = 8
+                       q5.Reg = REGSP
+                       q5.To.Type = obj.TYPE_REG
+                       q5.To.Reg = REGFP
+                       q1.From.SetTarget(q5)
+                       p = q5
+               }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+                       f := c.cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
                        }
                }
        }

diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 8c8ff587ffce73a3ac6c33dc51400452ebccf9db..a48db3bdc871ff83f1830f7b16308e7d8cf07ad2 100644 (file)
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -39,6 +39,7 @@ import (
        "cmd/internal/sys"
        "fmt"
        "sync"
+       "sync/atomic"
 )
 
 // An Addr is an argument to an instruction.
@@ -250,6 +251,12 @@ func (a *Addr) SetTarget(t *Prog) {
        a.Val = t
 }
 
+func (a *Addr) SetConst(v int64) {
+       a.Sym = nil
+       a.Type = TYPE_CONST
+       a.Offset = v
+}
+
 // Prog describes a single machine instruction.
 //
 // The general instruction form is:
@@ -447,6 +454,7 @@ type FuncInfo struct {
        Locals   int32
        Align    int32
        FuncID   objabi.FuncID
+       FuncFlag objabi.FuncFlag
        Text     *Prog
        Autot    map[*LSym]struct{}
        Pcln     Pcln
@@ -612,10 +620,6 @@ const (
        // target of an inline during compilation
        AttrWasInlined
 
-       // TopFrame means that this function is an entry point and unwinders should not
-       // keep unwinding beyond this frame.
-       AttrTopFrame
-
        // Indexed indicates this symbol has been assigned with an index (when using the
        // new object file format).
        AttrIndexed
@@ -629,6 +633,10 @@ const (
        // ContentAddressable indicates this is a content-addressable symbol.
        AttrContentAddressable
 
+       // ABI wrapper is set for compiler-generated text symbols that
+       // convert between ABI0 and ABIInternal calling conventions.
+       AttrABIWrapper
+
        // attrABIBase is the value at which the ABI is encoded in
        // Attribute. This must be last; all bits after this are
        // assumed to be an ABI value.
@@ -637,36 +645,51 @@ const (
        attrABIBase
 )
 
-func (a Attribute) DuplicateOK() bool        { return a&AttrDuplicateOK != 0 }
-func (a Attribute) MakeTypelink() bool       { return a&AttrMakeTypelink != 0 }
-func (a Attribute) CFunc() bool              { return a&AttrCFunc != 0 }
-func (a Attribute) NoSplit() bool            { return a&AttrNoSplit != 0 }
-func (a Attribute) Leaf() bool               { return a&AttrLeaf != 0 }
-func (a Attribute) OnList() bool             { return a&AttrOnList != 0 }
-func (a Attribute) ReflectMethod() bool      { return a&AttrReflectMethod != 0 }
-func (a Attribute) Local() bool              { return a&AttrLocal != 0 }
-func (a Attribute) Wrapper() bool            { return a&AttrWrapper != 0 }
-func (a Attribute) NeedCtxt() bool           { return a&AttrNeedCtxt != 0 }
-func (a Attribute) NoFrame() bool            { return a&AttrNoFrame != 0 }
-func (a Attribute) Static() bool             { return a&AttrStatic != 0 }
-func (a Attribute) WasInlined() bool         { return a&AttrWasInlined != 0 }
-func (a Attribute) TopFrame() bool           { return a&AttrTopFrame != 0 }
-func (a Attribute) Indexed() bool            { return a&AttrIndexed != 0 }
-func (a Attribute) UsedInIface() bool        { return a&AttrUsedInIface != 0 }
-func (a Attribute) ContentAddressable() bool { return a&AttrContentAddressable != 0 }
+func (a *Attribute) load() Attribute { return Attribute(atomic.LoadUint32((*uint32)(a))) }
+
+func (a *Attribute) DuplicateOK() bool        { return a.load()&AttrDuplicateOK != 0 }
+func (a *Attribute) MakeTypelink() bool       { return a.load()&AttrMakeTypelink != 0 }
+func (a *Attribute) CFunc() bool              { return a.load()&AttrCFunc != 0 }
+func (a *Attribute) NoSplit() bool            { return a.load()&AttrNoSplit != 0 }
+func (a *Attribute) Leaf() bool               { return a.load()&AttrLeaf != 0 }
+func (a *Attribute) OnList() bool             { return a.load()&AttrOnList != 0 }
+func (a *Attribute) ReflectMethod() bool      { return a.load()&AttrReflectMethod != 0 }
+func (a *Attribute) Local() bool              { return a.load()&AttrLocal != 0 }
+func (a *Attribute) Wrapper() bool            { return a.load()&AttrWrapper != 0 }
+func (a *Attribute) NeedCtxt() bool           { return a.load()&AttrNeedCtxt != 0 }
+func (a *Attribute) NoFrame() bool            { return a.load()&AttrNoFrame != 0 }
+func (a *Attribute) Static() bool             { return a.load()&AttrStatic != 0 }
+func (a *Attribute) WasInlined() bool         { return a.load()&AttrWasInlined != 0 }
+func (a *Attribute) Indexed() bool            { return a.load()&AttrIndexed != 0 }
+func (a *Attribute) UsedInIface() bool        { return a.load()&AttrUsedInIface != 0 }
+func (a *Attribute) ContentAddressable() bool { return a.load()&AttrContentAddressable != 0 }
+func (a *Attribute) ABIWrapper() bool         { return a.load()&AttrABIWrapper != 0 }
 
 func (a *Attribute) Set(flag Attribute, value bool) {
-       if value {
-               *a |= flag
-       } else {
-               *a &^= flag
+       for {
+               v0 := a.load()
+               v := v0
+               if value {
+                       v |= flag
+               } else {
+                       v &^= flag
+               }
+               if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) {
+                       break
+               }
        }
 }
 
-func (a Attribute) ABI() ABI { return ABI(a / attrABIBase) }
+func (a *Attribute) ABI() ABI { return ABI(a.load() / attrABIBase) }
 func (a *Attribute) SetABI(abi ABI) {
        const mask = 1 // Only one ABI bit for now.
-       *a = (*a &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase
+       for {
+               v0 := a.load()
+               v := (v0 &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase
+               if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) {
+                       break
+               }
+       }
 }
 
 var textAttrStrings = [...]struct {
@@ -686,13 +709,13 @@ var textAttrStrings = [...]struct {
        {bit: AttrNoFrame, s: "NOFRAME"},
        {bit: AttrStatic, s: "STATIC"},
        {bit: AttrWasInlined, s: ""},
-       {bit: AttrTopFrame, s: "TOPFRAME"},
        {bit: AttrIndexed, s: ""},
        {bit: AttrContentAddressable, s: ""},
+       {bit: AttrABIWrapper, s: "ABIWRAPPER"},
 }
 
-// TextAttrString formats a for printing in as part of a TEXT prog.
-func (a Attribute) TextAttrString() string {
+// String formats a for printing in as part of a TEXT prog.
+func (a Attribute) String() string {
        var s string
        for _, x := range textAttrStrings {
                if a&x.bit != 0 {
@@ -718,13 +741,25 @@ func (a Attribute) TextAttrString() string {
        return s
 }
 
+// TextAttrString formats the symbol attributes for printing in as part of a TEXT prog.
+func (s *LSym) TextAttrString() string {
+       attr := s.Attribute.String()
+       if s.Func().FuncFlag&objabi.FuncFlag_TOPFRAME != 0 {
+               if attr != "" {
+                       attr += "|"
+               }
+               attr += "TOPFRAME"
+       }
+       return attr
+}
+
 func (s *LSym) String() string {
        return s.Name
 }
 
 // The compiler needs *LSym to be assignable to cmd/compile/internal/ssa.Sym.
-func (s *LSym) CanBeAnSSASym() {
-}
+func (*LSym) CanBeAnSSASym() {}
+func (*LSym) CanBeAnSSAAux() {}
 
 type Pcln struct {
        // Aux symbols for pcln
@@ -754,6 +789,17 @@ type Auto struct {
        Gotype  *LSym
 }
 
+// RegArg provides spill/fill information for a register-resident argument
+// to a function.  These need spilling/filling in the safepoint/stackgrowth case.
+// At the time of fill/spill, the offset must be adjusted by the architecture-dependent
+// adjustment to hardware SP that occurs in a call instruction.  E.g., for AMD64,
+// at Offset+8 because the return address was pushed.
+type RegArg struct {
+       Addr           Addr
+       Reg            int16
+       Spill, Unspill As
+}
+
 // Link holds the context for writing object code from a compiler
 // to be linker input or for reading that input into the linker.
 type Link struct {
@@ -784,6 +830,7 @@ type Link struct {
        DebugInfo          func(fn *LSym, info *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node
        GenAbstractFunc    func(fn *LSym)
        Errors             int
+       RegArgs            []RegArg
 
        InParallel    bool // parallel backend phase in effect
        UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges
@@ -832,6 +879,32 @@ func (ctxt *Link) Logf(format string, args ...interface{}) {
        ctxt.Bso.Flush()
 }
 
+func (ctxt *Link) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+       // Spill register args.
+       for _, ra := range ctxt.RegArgs {
+               spill := Appendp(last, pa)
+               spill.As = ra.Spill
+               spill.From.Type = TYPE_REG
+               spill.From.Reg = ra.Reg
+               spill.To = ra.Addr
+               last = spill
+       }
+       return last
+}
+
+func (ctxt *Link) UnspillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+       // Unspill any spilled register args
+       for _, ra := range ctxt.RegArgs {
+               unspill := Appendp(last, pa)
+               unspill.As = ra.Unspill
+               unspill.From = ra.Addr
+               unspill.To.Type = TYPE_REG
+               unspill.To.Reg = ra.Reg
+               last = unspill
+       }
+       return last
+}
+
 // The smallest possible offset from the hardware stack pointer to a local
 // variable on the stack. Architectures that use a link register save its value
 // on the stack in the function prologue and so always have a pointer between

diff --git a/src/cmd/internal/obj/mips/obj0.go b/src/cmd/internal/obj/mips/obj0.go
index 135a8df3aaa4c0c29cb69432e4fc2c44e747c224..91bba90d4197d48aa9f5a8354af79f5fbbdb8150 100644 (file)
--- a/src/cmd/internal/obj/mips/obj0.go
+++ b/src/cmd/internal/obj/mips/obj0.go
@@ -35,6 +35,7 @@ import (
        "cmd/internal/sys"
        "encoding/binary"
        "fmt"
+       "log"
        "math"
 )
 
@@ -536,6 +537,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                p.From.Reg = REGSP
                        }
                }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+                       f := c.cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
+                       }
+               }
        }
 
        if c.ctxt.Arch.Family == sys.MIPS {

diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index bb58b4f0c2b62d4103b99118f3aa458737850c73..85f0570e5df6a1057db39fe667dea0dfe075f975 100644 (file)
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -330,9 +330,6 @@ func (w *writer) Sym(s *LSym) {
        if s.ReflectMethod() {
                flag |= goobj.SymFlagReflectMethod
        }
-       if s.TopFrame() {
-               flag |= goobj.SymFlagTopFrame
-       }
        if strings.HasPrefix(s.Name, "type.") && s.Name[5] != '.' && s.Type == objabi.SRODATA {
                flag |= goobj.SymFlagGoType
        }
@@ -673,9 +670,10 @@ func genFuncInfoSyms(ctxt *Link) {
                        continue
                }
                o := goobj.FuncInfo{
-                       Args:   uint32(fn.Args),
-                       Locals: uint32(fn.Locals),
-                       FuncID: objabi.FuncID(fn.FuncID),
+                       Args:     uint32(fn.Args),
+                       Locals:   uint32(fn.Locals),
+                       FuncID:   fn.FuncID,
+                       FuncFlag: fn.FuncFlag,
                }
                pc := &fn.Pcln
                o.Pcsp = makeSymRef(preparePcSym(pc.Pcsp))
@@ -788,7 +786,7 @@ func (ctxt *Link) writeSymDebugNamed(s *LSym, name string) {
        if s.NoSplit() {
                fmt.Fprintf(ctxt.Bso, "nosplit ")
        }
-       if s.TopFrame() {
+       if s.Func() != nil && s.Func().FuncFlag&objabi.FuncFlag_TOPFRAME != 0 {
                fmt.Fprintf(ctxt.Bso, "topframe ")
        }
        fmt.Fprintf(ctxt.Bso, "size=%d", s.Size)

diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 2b096996f7a1bc10f0a2e87690168aebb2bede68..177083261c1b4947d5d8907945f0ae89c703de89 100644 (file)
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -80,6 +80,11 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
                if !strings.HasPrefix(s.Name, "\"\".") {
                        continue
                }
+               if s.ABIWrapper() {
+                       // Don't create an args_stackmap symbol reference for an ABI
+                       // wrapper function
+                       continue
+               }
                found := false
                for p := s.Func().Text; p != nil; p = p.Link {
                        if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
@@ -129,14 +134,15 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
        }
        name := strings.Replace(s.Name, "\"\"", ctxt.Pkgpath, -1)
        s.Func().FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0)
+       s.Func().FuncFlag = toFuncFlag(flag)
        s.Set(AttrOnList, true)
        s.Set(AttrDuplicateOK, flag&DUPOK != 0)
        s.Set(AttrNoSplit, flag&NOSPLIT != 0)
        s.Set(AttrReflectMethod, flag&REFLECTMETHOD != 0)
        s.Set(AttrWrapper, flag&WRAPPER != 0)
+       s.Set(AttrABIWrapper, flag&ABIWRAPPER != 0)
        s.Set(AttrNeedCtxt, flag&NEEDCTXT != 0)
        s.Set(AttrNoFrame, flag&NOFRAME != 0)
-       s.Set(AttrTopFrame, flag&TOPFRAME != 0)
        s.Type = objabi.STEXT
        ctxt.Text = append(ctxt.Text, s)
 
@@ -144,6 +150,14 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
        ctxt.dwarfSym(s)
 }
 
+func toFuncFlag(flag int) objabi.FuncFlag {
+       var out objabi.FuncFlag
+       if flag&TOPFRAME != 0 {
+               out |= objabi.FuncFlag_TOPFRAME
+       }
+       return out
+}
+
 func (ctxt *Link) Globl(s *LSym, size int64, flag int) {
        if s.OnList() {
                ctxt.Diag("symbol %s listed multiple times", s.Name)

diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index fddf552156cfbbe831758a2fdb26b613f2027ab4..a77be29cf09c70373c6a09d749ba18e0551c779c 100644 (file)
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -34,6 +34,7 @@ import (
        "cmd/internal/objabi"
        "cmd/internal/src"
        "cmd/internal/sys"
+       "log"
 )
 
 func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
@@ -984,6 +985,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                p.From.Reg = REGSP
                        }
                }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 && p.As != ACMPU {
+                       f := c.cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
+                       }
+               }
        }
 }
 

diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index 9257a6453aef81eb1bad7c46197d565a3160743e..d104f1cfa514d9e8f645f32fcd2fb80a749d79ed 100644 (file)
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -25,6 +25,7 @@ import (
        "cmd/internal/objabi"
        "cmd/internal/sys"
        "fmt"
+       "log"
 )
 
 func buildop(ctxt *obj.Link) {}
@@ -119,7 +120,7 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                        switch p.To.Name {
                        case obj.NAME_NONE:
                                p.As = AJALR
-                       case obj.NAME_EXTERN:
+                       case obj.NAME_EXTERN, obj.NAME_STATIC:
                                // Handled in preprocess.
                        default:
                                ctxt.Diag("unsupported name %d for %v", p.To.Name, p)
@@ -267,7 +268,7 @@ func rewriteMOV(ctxt *obj.Link, newprog obj.ProgAlloc, p *obj.Prog) {
                                p.As = movToStore(p.As)
                                p.To.Reg = addrToReg(p.To)
 
-                       case obj.NAME_EXTERN:
+                       case obj.NAME_EXTERN, obj.NAME_STATIC:
                                // AUIPC $off_hi, TMP
                                // S $off_lo, TMP, R
                                as := p.As
@@ -666,7 +667,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                        switch p.To.Type {
                        case obj.TYPE_MEM:
                                switch p.To.Name {
-                               case obj.NAME_EXTERN:
+                               case obj.NAME_EXTERN, obj.NAME_STATIC:
                                        // JMP to symbol.
                                        jalrToSym(ctxt, p, newprog, REG_ZERO)
                                }
@@ -716,6 +717,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                p.Spadj = int32(-p.From.Offset)
                        }
                }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+                       f := cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               f.FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s %v\n", cursym.Name, p)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
+                       }
+               }
        }
 
        // Rewrite MOV pseudo-instructions. This cannot be done in

diff --git a/src/cmd/internal/obj/s390x/condition_code.go b/src/cmd/internal/obj/s390x/condition_code.go
index 764fc5bc6a855c9f2b2149bfb22d4eef2233ffa9..f498fd6f7744214fa4c9f7ecadbbd59ef96065d2 100644 (file)
--- a/src/cmd/internal/obj/s390x/condition_code.go
+++ b/src/cmd/internal/obj/s390x/condition_code.go
@@ -124,3 +124,5 @@ func (c CCMask) String() string {
        // invalid
        return fmt.Sprintf("Invalid (%#x)", c)
 }
+
+func (CCMask) CanBeAnSSAAux() {}

diff --git a/src/cmd/internal/obj/s390x/objz.go b/src/cmd/internal/obj/s390x/objz.go
index 970cf827d6fee381b2a444b52ab0861ce92560cd..a02c4fc17f482797478d7334d2ca9d1d3727538f 100644 (file)
--- a/src/cmd/internal/obj/s390x/objz.go
+++ b/src/cmd/internal/obj/s390x/objz.go
@@ -33,6 +33,7 @@ import (
        "cmd/internal/obj"
        "cmd/internal/objabi"
        "cmd/internal/sys"
+       "log"
        "math"
 )
 
@@ -545,6 +546,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                                p.From.Reg = REGSP
                        }
                }
+
+               if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+                       f := c.cursym.Func()
+                       if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                               c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+                               if ctxt.Debugvlog || !ctxt.IsAsm {
+                                       ctxt.Logf("auto-SPWRITE: %s\n", c.cursym.Name)
+                                       if !ctxt.IsAsm {
+                                               ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                               ctxt.DiagFlush()
+                                               log.Fatalf("bad SPWRITE")
+                                       }
+                               }
+                       }
+               }
        }
        if wasSplit {
                c.stacksplitPost(pLast, pPre, pPreempt, autosize) // emit post part of split check

diff --git a/src/cmd/internal/obj/s390x/rotate.go b/src/cmd/internal/obj/s390x/rotate.go
index 7dbc45e648946f9daa50d4e969d7b878303bc0c2..5407c8df1109993f2b86f32323b2f288036b108a 100644 (file)
--- a/src/cmd/internal/obj/s390x/rotate.go
+++ b/src/cmd/internal/obj/s390x/rotate.go
@@ -28,9 +28,9 @@ import (
 // input left by. Note that this rotation is performed
 // before the masked region is used.
 type RotateParams struct {
-       Start  int8 // big-endian start bit index [0..63]
-       End    int8 // big-endian end bit index [0..63]
-       Amount int8 // amount to rotate left
+       Start  uint8 // big-endian start bit index [0..63]
+       End    uint8 // big-endian end bit index [0..63]
+       Amount uint8 // amount to rotate left
 }
 
 // NewRotateParams creates a set of parameters representing a
@@ -39,7 +39,7 @@ type RotateParams struct {
 //
 // The start and end indexes and the rotation amount must all
 // be in the range 0-63 inclusive or this function will panic.
-func NewRotateParams(start, end, amount int8) RotateParams {
+func NewRotateParams(start, end, amount uint8) RotateParams {
        if start&^63 != 0 {
                panic("start out of bounds")
        }
@@ -58,7 +58,7 @@ func NewRotateParams(start, end, amount int8) RotateParams {
 
 // RotateLeft generates a new set of parameters with the rotation amount
 // increased by the given value. The selected bits are left unchanged.
-func (r RotateParams) RotateLeft(amount int8) RotateParams {
+func (r RotateParams) RotateLeft(amount uint8) RotateParams {
        r.Amount += amount
        r.Amount &= 63
        return r
@@ -100,8 +100,8 @@ func (r RotateParams) OutMerge(mask uint64) *RotateParams {
        }
 
        // update start and end positions (rotation amount remains the same)
-       r.Start = int8(o+z) & 63
-       r.End = (r.Start + int8(l) - 1) & 63
+       r.Start = uint8(o+z) & 63
+       r.End = (r.Start + uint8(l) - 1) & 63
        return &r
 }
 
@@ -113,3 +113,5 @@ func (r RotateParams) OutMerge(mask uint64) *RotateParams {
 func (r RotateParams) InMerge(mask uint64) *RotateParams {
        return r.OutMerge(bits.RotateLeft64(mask, int(r.Amount)))
 }
+
+func (RotateParams) CanBeAnSSAAux() {}

diff --git a/src/cmd/internal/obj/s390x/rotate_test.go b/src/cmd/internal/obj/s390x/rotate_test.go
index fa5b5bdecd6b2bdac666e2726bfbf60e64439408..88421b1b833e752df2854e067ee1381f9498e4f6 100644 (file)
--- a/src/cmd/internal/obj/s390x/rotate_test.go
+++ b/src/cmd/internal/obj/s390x/rotate_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestRotateParamsMask(t *testing.T) {
        tests := []struct {
-               start, end, amount int8
+               start, end, amount uint8
                inMask, outMask    uint64
        }{
                // start before end, no rotation

diff --git a/src/cmd/internal/obj/textflag.go b/src/cmd/internal/obj/textflag.go
index d2cec734b1c1b140b01be2ad8872163c99d43702..2f55793285e2ee801ac448d02301fa0b1870a230 100644 (file)
--- a/src/cmd/internal/obj/textflag.go
+++ b/src/cmd/internal/obj/textflag.go
@@ -33,7 +33,7 @@ const (
        // This function uses its incoming context register.
        NEEDCTXT = 64
 
-       // When passed to ggloblsym, causes Local to be set to true on the LSym it creates.
+       // When passed to objw.Global, causes Local to be set to true on the LSym it creates.
        LOCAL = 128
 
        // Allocate a word of thread local storage and store the offset from the
@@ -51,4 +51,7 @@ const (
        // Function is the top of the call stack. Call stack unwinders should stop
        // at this function.
        TOPFRAME = 2048
+
+       // Function is an ABI wrapper.
+       ABIWRAPPER = 4096
 )

diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index b9bacb7a2279126d552603f38c8bbdbca2dcc4e1..1c34b4e833e2257dde4ac3e6a7e9c642258bd1f2 100644 (file)
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -187,7 +187,7 @@ func (p *Prog) WriteInstructionString(w io.Writer) {
                // In short, print one of these two:
                // TEXT foo(SB), DUPOK|NOSPLIT, $0
                // TEXT foo(SB), $0
-               s := p.From.Sym.Attribute.TextAttrString()
+               s := p.From.Sym.TextAttrString()
                if s != "" {
                        fmt.Fprintf(w, "%s%s", sep, s)
                        sep = ", "

diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index 30c1a6a44547d8f84590ab78d53f77bc99ae2d91..3be4b59da461f52dea5358173053c820b6c3c2c5 100644 (file)
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -263,6 +263,7 @@ const (
        FREGRET  = REG_X0
        REGSP    = REG_SP
        REGCTXT  = REG_DX
+       REGG     = REG_R14     // g register in ABIInternal
        REGEXT   = REG_R15     // compiler allocates external registers R15 down
        FREGMIN  = REG_X0 + 5  // first register variable
        FREGEXT  = REG_X0 + 15 // first external register

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 184fb4308bd01532369e74c30c4fc222074cf207..bc3a3b4bbe7f47c146300d79482cf6f289d5d845 100644 (file)
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -35,6 +35,7 @@ import (
        "cmd/internal/objabi"
        "cmd/internal/src"
        "cmd/internal/sys"
+       "log"
        "math"
        "strings"
 )
@@ -637,13 +638,19 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                }
        }
 
-       if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
-               p = obj.Appendp(p, newprog)
-               p = load_g_cx(ctxt, p, newprog) // load g into CX
+       var regg int16
+       if !p.From.Sym.NoSplit() || (p.From.Sym.Wrapper() && !p.From.Sym.ABIWrapper()) {
+               if ctxt.Arch.Family == sys.AMD64 && objabi.Regabi_enabled != 0 && cursym.ABI() == obj.ABIInternal {
+                       regg = REGG // use the g register directly in ABIInternal
+               } else {
+                       p = obj.Appendp(p, newprog)
+                       p = load_g_cx(ctxt, p, newprog) // load g into CX
+                       regg = REG_CX
+               }
        }
 
        if !cursym.Func().Text.From.Sym.NoSplit() {
-               p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg)) // emit split check
+               p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg), regg) // emit split check
        }
 
        // Delve debugger would like the next instruction to be noted as the end of the function prologue.
@@ -690,12 +697,12 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                p.To.Reg = REG_BP
        }
 
-       if cursym.Func().Text.From.Sym.Wrapper() {
+       if cursym.Func().Text.From.Sym.Wrapper() && !cursym.Func().Text.From.Sym.ABIWrapper() {
                // if g._panic != nil && g._panic.argp == FP {
                //   g._panic.argp = bottom-of-frame
                // }
                //
-               //      MOVQ g_panic(CX), BX
+               //      MOVQ g_panic(g), BX
                //      TESTQ BX, BX
                //      JNE checkargp
                // end:
@@ -718,7 +725,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
                p = obj.Appendp(p, newprog)
                p.As = AMOVQ
                p.From.Type = obj.TYPE_MEM
-               p.From.Reg = REG_CX
+               p.From.Reg = regg
                p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // g_panic
                p.To.Type = obj.TYPE_REG
                p.To.Reg = REG_BX
@@ -833,6 +840,20 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
                switch p.As {
                default:
+                       if p.To.Type == obj.TYPE_REG && p.To.Reg == REG_SP && p.As != ACMPL && p.As != ACMPQ {
+                               f := cursym.Func()
+                               if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+                                       f.FuncFlag |= objabi.FuncFlag_SPWRITE
+                                       if ctxt.Debugvlog || !ctxt.IsAsm {
+                                               ctxt.Logf("auto-SPWRITE: %s %v\n", cursym.Name, p)
+                                               if !ctxt.IsAsm {
+                                                       ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+                                                       ctxt.DiagFlush()
+                                                       log.Fatalf("bad SPWRITE")
+                                               }
+                                       }
+                               }
+                       }
                        continue
 
                case APUSHL, APUSHFL:
@@ -969,9 +990,9 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) *obj.Prog {
 
 // Append code to p to check for stack split.
 // Appends to (does not overwrite) p.
-// Assumes g is in CX.
+// Assumes g is in rg.
 // Returns last new instruction.
-func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgAlloc, framesize int32, textarg int32) *obj.Prog {
+func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgAlloc, framesize int32, textarg int32, rg int16) *obj.Prog {
        cmp := ACMPQ
        lea := ALEAQ
        mov := AMOVQ
@@ -993,7 +1014,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
                p.As = cmp
                p.From.Type = obj.TYPE_REG
                p.From.Reg = REG_SP
-               indir_cx(ctxt, &p.To)
+               p.To.Type = obj.TYPE_MEM
+               p.To.Reg = rg
                p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
                if cursym.CFunc() {
                        p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
@@ -1021,7 +1043,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
                p.As = cmp
                p.From.Type = obj.TYPE_REG
                p.From.Reg = REG_AX
-               indir_cx(ctxt, &p.To)
+               p.To.Type = obj.TYPE_MEM
+               p.To.Reg = rg
                p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
                if cursym.CFunc() {
                        p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
@@ -1047,7 +1070,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
                p = obj.Appendp(p, newprog)
 
                p.As = mov
-               indir_cx(ctxt, &p.From)
+               p.From.Type = obj.TYPE_MEM
+               p.From.Reg = rg
                p.From.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
                if cursym.CFunc() {
                        p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
@@ -1114,7 +1138,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
        spfix.Spadj = -framesize
 
        pcdata := ctxt.EmitEntryStackMap(cursym, spfix, newprog)
-       pcdata = ctxt.StartUnsafePoint(pcdata, newprog)
+       spill := ctxt.StartUnsafePoint(pcdata, newprog)
+       pcdata = ctxt.SpillRegisterArgs(spill, newprog)
 
        call := obj.Appendp(pcdata, newprog)
        call.Pos = cursym.Func().Text.Pos
@@ -1139,7 +1164,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
                progedit(ctxt, callend.Link, newprog)
        }
 
-       pcdata = ctxt.EndUnsafePoint(callend, newprog, -1)
+       pcdata = ctxt.UnspillRegisterArgs(callend, newprog)
+       pcdata = ctxt.EndUnsafePoint(pcdata, newprog, -1)
 
        jmp := obj.Appendp(pcdata, newprog)
        jmp.As = obj.AJMP
@@ -1147,9 +1173,9 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
        jmp.To.SetTarget(cursym.Func().Text.Link)
        jmp.Spadj = +framesize
 
-       jls.To.SetTarget(call)
+       jls.To.SetTarget(spill)
        if q1 != nil {
-               q1.To.SetTarget(call)
+               q1.To.SetTarget(spill)
        }
 
        return end

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index 1d098ee17251b379c354b01f840f53aef119c058..6e188e31bb435e45ad646564f78d3d1a75004a23 100644 (file)
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -4,97 +4,89 @@
 
 package objabi
 
+import "strings"
+
+// A FuncFlag records bits about a function, passed to the runtime.
+type FuncFlag uint8
+
+// Note: This list must match the list in runtime/symtab.go.
+const (
+       FuncFlag_TOPFRAME = 1 << iota
+       FuncFlag_SPWRITE
+)
+
 // A FuncID identifies particular functions that need to be treated
 // specially by the runtime.
 // Note that in some situations involving plugins, there may be multiple
 // copies of a particular special runtime function.
-// Note: this list must match the list in runtime/symtab.go.
 type FuncID uint8
 
+// Note: this list must match the list in runtime/symtab.go.
 const (
        FuncID_normal FuncID = iota // not a special function
-       FuncID_runtime_main
+       FuncID_asmcgocall
+       FuncID_asyncPreempt
+       FuncID_cgocallback
+       FuncID_debugCallV1
+       FuncID_externalthreadhandler
+       FuncID_gcBgMarkWorker
        FuncID_goexit
+       FuncID_gogo
+       FuncID_gopanic
+       FuncID_handleAsyncEvent
        FuncID_jmpdefer
        FuncID_mcall
        FuncID_morestack
        FuncID_mstart
+       FuncID_panicwrap
        FuncID_rt0_go
-       FuncID_asmcgocall
-       FuncID_sigpanic
        FuncID_runfinq
-       FuncID_gcBgMarkWorker
-       FuncID_systemstack_switch
+       FuncID_runtime_main
+       FuncID_sigpanic
        FuncID_systemstack
-       FuncID_cgocallback
-       FuncID_gogo
-       FuncID_externalthreadhandler
-       FuncID_debugCallV1
-       FuncID_gopanic
-       FuncID_panicwrap
-       FuncID_handleAsyncEvent
-       FuncID_asyncPreempt
+       FuncID_systemstack_switch
        FuncID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
 )
 
+var funcIDs = map[string]FuncID{
+       "asmcgocall":            FuncID_asmcgocall,
+       "asyncPreempt":          FuncID_asyncPreempt,
+       "cgocallback":           FuncID_cgocallback,
+       "debugCallV1":           FuncID_debugCallV1,
+       "externalthreadhandler": FuncID_externalthreadhandler,
+       "gcBgMarkWorker":        FuncID_gcBgMarkWorker,
+       "go":                    FuncID_rt0_go,
+       "goexit":                FuncID_goexit,
+       "gogo":                  FuncID_gogo,
+       "gopanic":               FuncID_gopanic,
+       "handleAsyncEvent":      FuncID_handleAsyncEvent,
+       "jmpdefer":              FuncID_jmpdefer,
+       "main":                  FuncID_runtime_main,
+       "mcall":                 FuncID_mcall,
+       "morestack":             FuncID_morestack,
+       "mstart":                FuncID_mstart,
+       "panicwrap":             FuncID_panicwrap,
+       "runfinq":               FuncID_runfinq,
+       "sigpanic":              FuncID_sigpanic,
+       "switch":                FuncID_systemstack_switch,
+       "systemstack":           FuncID_systemstack,
+
+       // Don't show in call stack but otherwise not special.
+       "deferreturn":       FuncID_wrapper,
+       "runOpenDeferFrame": FuncID_wrapper,
+       "reflectcallSave":   FuncID_wrapper,
+}
+
 // Get the function ID for the named function in the named file.
 // The function should be package-qualified.
 func GetFuncID(name string, isWrapper bool) FuncID {
        if isWrapper {
                return FuncID_wrapper
        }
-       switch name {
-       case "runtime.main":
-               return FuncID_runtime_main
-       case "runtime.goexit":
-               return FuncID_goexit
-       case "runtime.jmpdefer":
-               return FuncID_jmpdefer
-       case "runtime.mcall":
-               return FuncID_mcall
-       case "runtime.morestack":
-               return FuncID_morestack
-       case "runtime.mstart":
-               return FuncID_mstart
-       case "runtime.rt0_go":
-               return FuncID_rt0_go
-       case "runtime.asmcgocall":
-               return FuncID_asmcgocall
-       case "runtime.sigpanic":
-               return FuncID_sigpanic
-       case "runtime.runfinq":
-               return FuncID_runfinq
-       case "runtime.gcBgMarkWorker":
-               return FuncID_gcBgMarkWorker
-       case "runtime.systemstack_switch":
-               return FuncID_systemstack_switch
-       case "runtime.systemstack":
-               return FuncID_systemstack
-       case "runtime.cgocallback":
-               return FuncID_cgocallback
-       case "runtime.gogo":
-               return FuncID_gogo
-       case "runtime.externalthreadhandler":
-               return FuncID_externalthreadhandler
-       case "runtime.debugCallV1":
-               return FuncID_debugCallV1
-       case "runtime.gopanic":
-               return FuncID_gopanic
-       case "runtime.panicwrap":
-               return FuncID_panicwrap
-       case "runtime.handleAsyncEvent":
-               return FuncID_handleAsyncEvent
-       case "runtime.asyncPreempt":
-               return FuncID_asyncPreempt
-       case "runtime.deferreturn":
-               // Don't show in the call stack (used when invoking defer functions)
-               return FuncID_wrapper
-       case "runtime.runOpenDeferFrame":
-               // Don't show in the call stack (used when invoking defer functions)
-               return FuncID_wrapper
-       case "runtime.reflectcallSave":
-               // Don't show in the call stack (used when invoking defer functions)
-               return FuncID_wrapper
+       if strings.HasPrefix(name, "runtime.") {
+               if id, ok := funcIDs[name[len("runtime."):]]; ok {
+                       return id
+               }
        }
        return FuncID_normal
 }

diff --git a/src/cmd/internal/objabi/path.go b/src/cmd/internal/objabi/path.go
index fd1c9981c69d0f9b1220d7e37de1e08068d4584a..1a0784cf7f0d2b8a011335deca967f6df4732a6d 100644 (file)
--- a/src/cmd/internal/objabi/path.go
+++ b/src/cmd/internal/objabi/path.go
@@ -56,6 +56,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
                rval = true
        case "syscall":
                rval = true
+       case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
+               rval = true
        default:
                rval = strings.HasPrefix(pkgpath, "runtime/internal")
        }

diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index a73ab479a16337c49a32b38b2b5fcf272232326c..1f99f8ed5d66279f054ea9f3a95392fa5751f02d 100644 (file)
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -137,7 +137,7 @@ func init() {
 }
 
 // Note: must agree with runtime.framepointer_enabled.
-var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "ios")
+var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func addexp(s string) {
        // Could do general integer parsing here, but the runtime copy doesn't yet.

diff --git a/src/cmd/internal/objfile/pe.go b/src/cmd/internal/objfile/pe.go
index b20cda9a44be994e4e225eccf2c205a65c77a187..9088866fcf5326f9b84757bf72aa582acbc77096 100644 (file)
--- a/src/cmd/internal/objfile/pe.go
+++ b/src/cmd/internal/objfile/pe.go
@@ -189,6 +189,8 @@ func (f *peFile) goarch() string {
                return "amd64"
        case pe.IMAGE_FILE_MACHINE_ARMNT:
                return "arm"
+       case pe.IMAGE_FILE_MACHINE_ARM64:
+               return "arm64"
        default:
                return ""
        }

diff --git a/src/cmd/internal/objfile/xcoff.go b/src/cmd/internal/objfile/xcoff.go
index d438c802264f693ff311c8079d723d985d04c543..d6df4db8f01d0615abc9df6d814bede5507591e0 100644 (file)
--- a/src/cmd/internal/objfile/xcoff.go
+++ b/src/cmd/internal/objfile/xcoff.go
@@ -94,9 +94,7 @@ func (f *xcoffFile) pcln() (textStart uint64, symtab, pclntab []byte, err error)
        if pclntab, err = loadXCOFFTable(f.xcoff, "runtime.pclntab", "runtime.epclntab"); err != nil {
                return 0, nil, nil, err
        }
-       if symtab, err = loadXCOFFTable(f.xcoff, "runtime.symtab", "runtime.esymtab"); err != nil {
-               return 0, nil, nil, err
-       }
+       symtab, _ = loadXCOFFTable(f.xcoff, "runtime.symtab", "runtime.esymtab") // ignore error, this symbol is not useful anyway
        return textStart, symtab, pclntab, nil
 }
 

diff --git a/src/cmd/internal/pkgpath/pkgpath.go b/src/cmd/internal/pkgpath/pkgpath.go
index 40a040a81af6acb54eb272d7bf388b8f79289d99..72e3bdb6311611c4ce645e21c642f45efc847a76 100644 (file)
--- a/src/cmd/internal/pkgpath/pkgpath.go
+++ b/src/cmd/internal/pkgpath/pkgpath.go
@@ -10,9 +10,9 @@ import (
        "bytes"
        "errors"
        "fmt"
+       exec "internal/execabs"
        "io/ioutil"
        "os"
-       "os/exec"
        "strings"
 )
 

diff --git a/src/cmd/link/elf_test.go b/src/cmd/link/elf_test.go
index 334f050e8819f5a526062951f169d85a993efdbd..20754d09f5ac9d0c085d251463d0e172a59bfedd 100644 (file)
--- a/src/cmd/link/elf_test.go
+++ b/src/cmd/link/elf_test.go
@@ -226,6 +226,12 @@ func main() {
 
 func TestPIESize(t *testing.T) {
        testenv.MustHaveGoBuild(t)
+
+       // We don't want to test -linkmode=external if cgo is not supported.
+       // On some systems -buildmode=pie implies -linkmode=external, so just
+       // always skip the test if cgo is not supported.
+       testenv.MustHaveCGO(t)
+
        if !sys.BuildModeSupported(runtime.Compiler, "pie", runtime.GOOS, runtime.GOARCH) {
                t.Skip("-buildmode=pie not supported")
        }

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 755b4726948bb61c577894fdc105f50fd1edaa61..03caeae7bec820fad3343301cc448cc7e3ac6113 100644 (file)
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -370,10 +370,16 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
        r := relocs.At(ri)
        switch r.Type() {
        case objabi.R_CALLARM:
-               // r.Add is the instruction
-               // low 24-bit encodes the target address
-               t := (ldr.SymValue(rs) + int64(signext24(r.Add()&0xffffff)*4) - (ldr.SymValue(s) + int64(r.Off()))) / 4
-               if t > 0x7fffff || t < -0x800000 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+               var t int64
+               // ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
+               // laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
+               // in dependency order.
+               if ldr.SymValue(rs) != 0 {
+                       // r.Add is the instruction
+                       // low 24-bit encodes the target address
+                       t = (ldr.SymValue(rs) + int64(signext24(r.Add()&0xffffff)*4) - (ldr.SymValue(s) + int64(r.Off()))) / 4
+               }
+               if t > 0x7fffff || t < -0x800000 || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
                        // direct call too far, need to insert trampoline.
                        // look up existing trampolines first. if we found one within the range
                        // of direct call, we can reuse it. otherwise create a new one.
@@ -445,7 +451,7 @@ func gentramp(arch *sys.Arch, linkmode ld.LinkMode, ldr *loader.Loader, tramp *l
        arch.ByteOrder.PutUint32(P[8:], o3)
        tramp.SetData(P)
 
-       if linkmode == ld.LinkExternal {
+       if linkmode == ld.LinkExternal || ldr.SymValue(target) == 0 {
                r, _ := tramp.AddRel(objabi.R_ADDR)
                r.SetOff(8)
                r.SetSiz(4)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 30819db4c67e5880f055e96ccbb179eb883be176..72093268c220a6bd75476863849755b41d0f0d40 100644 (file)
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -37,6 +37,7 @@ import (
        "cmd/link/internal/loader"
        "cmd/link/internal/sym"
        "debug/elf"
+       "fmt"
        "log"
 )
 
@@ -472,6 +473,20 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
        rs := r.Xsym
        rt := r.Type
        siz := r.Size
+       xadd := r.Xadd
+
+       if xadd != signext24(xadd) {
+               // If the relocation target would overflow the addend, then target
+               // a linker-manufactured label symbol with a smaller addend instead.
+               label := ldr.Lookup(machoLabelName(ldr, rs, xadd), ldr.SymVersion(rs))
+               if label != 0 {
+                       xadd = ldr.SymValue(rs) + xadd - ldr.SymValue(label)
+                       rs = label
+               }
+               if xadd != signext24(xadd) {
+                       ldr.Errorf(s, "internal error: relocation addend overflow: %s+0x%x", ldr.SymName(rs), xadd)
+               }
+       }
 
        if ldr.SymType(rs) == sym.SHOSTOBJ || rt == objabi.R_CALLARM64 || rt == objabi.R_ADDRARM64 || rt == objabi.R_ARM64_GOTPCREL {
                if ldr.SymDynid(rs) < 0 {
@@ -489,18 +504,14 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
                }
        }
 
-       if r.Xadd != signext24(r.Xadd) {
-               ldr.Errorf(s, "relocation addend overflow: %s+0x%x", ldr.SymName(rs), r.Xadd)
-       }
-
        switch rt {
        default:
                return false
        case objabi.R_ADDR:
                v |= ld.MACHO_ARM64_RELOC_UNSIGNED << 28
        case objabi.R_CALLARM64:
-               if r.Xadd != 0 {
-                       ldr.Errorf(s, "ld64 doesn't allow BR26 reloc with non-zero addend: %s+%d", ldr.SymName(rs), r.Xadd)
+               if xadd != 0 {
+                       ldr.Errorf(s, "ld64 doesn't allow BR26 reloc with non-zero addend: %s+%d", ldr.SymName(rs), xadd)
                }
 
                v |= 1 << 24 // pc-relative bit
@@ -511,13 +522,13 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
                // if r.Xadd is non-zero, add two MACHO_ARM64_RELOC_ADDEND.
                if r.Xadd != 0 {
                        out.Write32(uint32(sectoff + 4))
-                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(r.Xadd&0xffffff))
+                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(xadd&0xffffff))
                }
                out.Write32(uint32(sectoff + 4))
                out.Write32(v | (ld.MACHO_ARM64_RELOC_PAGEOFF12 << 28) | (2 << 25))
                if r.Xadd != 0 {
                        out.Write32(uint32(sectoff))
-                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(r.Xadd&0xffffff))
+                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(xadd&0xffffff))
                }
                v |= 1 << 24 // pc-relative bit
                v |= ld.MACHO_ARM64_RELOC_PAGE21 << 28
@@ -527,13 +538,13 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
                // if r.Xadd is non-zero, add two MACHO_ARM64_RELOC_ADDEND.
                if r.Xadd != 0 {
                        out.Write32(uint32(sectoff + 4))
-                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(r.Xadd&0xffffff))
+                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(xadd&0xffffff))
                }
                out.Write32(uint32(sectoff + 4))
                out.Write32(v | (ld.MACHO_ARM64_RELOC_GOT_LOAD_PAGEOFF12 << 28) | (2 << 25))
                if r.Xadd != 0 {
                        out.Write32(uint32(sectoff))
-                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(r.Xadd&0xffffff))
+                       out.Write32((ld.MACHO_ARM64_RELOC_ADDEND << 28) | (2 << 25) | uint32(xadd&0xffffff))
                }
                v |= 1 << 24 // pc-relative bit
                v |= ld.MACHO_ARM64_RELOC_GOT_LOAD_PAGE21 << 28
@@ -557,6 +568,40 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
        return true
 }
 
+func pereloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, sectoff int64) bool {
+       var v uint32
+
+       rs := r.Xsym
+       rt := r.Type
+
+       if ldr.SymDynid(rs) < 0 {
+               ldr.Errorf(s, "reloc %d (%s) to non-coff symbol %s type=%d (%s)", rt, sym.RelocName(arch, rt), ldr.SymName(rs), ldr.SymType(rs), ldr.SymType(rs))
+               return false
+       }
+
+       out.Write32(uint32(sectoff))
+       out.Write32(uint32(ldr.SymDynid(rs)))
+
+       switch rt {
+       default:
+               return false
+
+       case objabi.R_DWARFSECREF:
+               v = ld.IMAGE_REL_ARM64_SECREL
+
+       case objabi.R_ADDR:
+               if r.Size == 8 {
+                       v = ld.IMAGE_REL_ARM64_ADDR64
+               } else {
+                       v = ld.IMAGE_REL_ARM64_ADDR32
+               }
+       }
+
+       out.Write16(uint16(v))
+
+       return true
+}
+
 func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loader.Reloc, s loader.Sym, val int64) (int64, int, bool) {
        const noExtReloc = 0
        const isOk = true
@@ -972,3 +1017,66 @@ func addpltsym(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
                ldr.Errorf(s, "addpltsym: unsupported binary format")
        }
 }
+
+const machoRelocLimit = 1 << 23
+
+func gensymlate(ctxt *ld.Link, ldr *loader.Loader) {
+       // When external linking on darwin, Mach-O relocation has only signed 24-bit
+       // addend. For large symbols, we generate "label" symbols in the middle, so
+       // that relocations can target them with smaller addends.
+       if !ctxt.IsDarwin() || !ctxt.IsExternal() {
+               return
+       }
+
+       big := false
+       for _, seg := range ld.Segments {
+               if seg.Length >= machoRelocLimit {
+                       big = true
+                       break
+               }
+       }
+       if !big {
+               return // skip work if nothing big
+       }
+
+       // addLabelSyms adds "label" symbols at s+machoRelocLimit, s+2*machoRelocLimit, etc.
+       addLabelSyms := func(s loader.Sym, sz int64) {
+               v := ldr.SymValue(s)
+               for off := int64(machoRelocLimit); off < sz; off += machoRelocLimit {
+                       p := ldr.LookupOrCreateSym(machoLabelName(ldr, s, off), ldr.SymVersion(s))
+                       ldr.SetAttrReachable(p, true)
+                       ldr.SetSymValue(p, v+off)
+                       ldr.SetSymSect(p, ldr.SymSect(s))
+                       ld.AddMachoSym(ldr, p)
+                       //fmt.Printf("gensymlate %s %x\n", ldr.SymName(p), ldr.SymValue(p))
+               }
+       }
+
+       for s, n := loader.Sym(1), loader.Sym(ldr.NSym()); s < n; s++ {
+               if !ldr.AttrReachable(s) {
+                       continue
+               }
+               if ldr.SymType(s) == sym.STEXT {
+                       continue // we don't target the middle of a function
+               }
+               sz := ldr.SymSize(s)
+               if sz <= machoRelocLimit {
+                       continue
+               }
+               addLabelSyms(s, sz)
+       }
+
+       // Also for carrier symbols (for which SymSize is 0)
+       for _, ss := range ld.CarrierSymByType {
+               if ss.Sym != 0 && ss.Size > machoRelocLimit {
+                       addLabelSyms(ss.Sym, ss.Size)
+               }
+       }
+}
+
+// machoLabelName returns the name of the "label" symbol used for a
+// relocation targeting s+off. The label symbols is used on darwin
+// when external linking, so that the addend fits in a Mach-O relocation.
+func machoLabelName(ldr *loader.Loader, s loader.Sym, off int64) string {
+       return fmt.Sprintf("%s.%d", ldr.SymExtname(s), off/machoRelocLimit)
+}

diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index ab3dfd99f73211cf5b39da8a1c7e3fdfe5b66f5a..18a32531e9035ff00f52e5d0eb4bd70af2ea17c2 100644 (file)
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -55,8 +55,10 @@ func Init() (*sys.Arch, ld.Arch) {
                ElfrelocSize:     24,
                Elfsetupplt:      elfsetupplt,
                Gentext:          gentext,
+               GenSymsLate:      gensymlate,
                Machoreloc1:      machoreloc1,
                MachorelocSize:   8,
+               PEreloc1:         pereloc1,
 
                Androiddynld: "/system/bin/linker64",
                Linuxdynld:   "/lib/ld-linux-aarch64.so.1",
@@ -107,5 +109,9 @@ func archinit(ctxt *ld.Link) {
                if *ld.FlagRound == -1 {
                        *ld.FlagRound = 16384 // 16K page alignment
                }
+
+       case objabi.Hwindows: /* PE executable */
+               // ld.HEADR, ld.FlagTextAddr, ld.FlagRound are set in ld.Peinit
+               return
        }
 }

diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index d1e06239a566f656ed67e69597b99bd4c790122e..481dc6747501db2aedf38689a97932913ea9d14d 100644 (file)
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -36,7 +36,7 @@ func (mode *BuildMode) Set(s string) error {
                return fmt.Errorf("invalid buildmode: %q", s)
        case "exe":
                switch objabi.GOOS + "/" + objabi.GOARCH {
-               case "darwin/arm64", "windows/arm": // On these platforms, everything is PIE
+               case "darwin/arm64", "windows/arm", "windows/arm64": // On these platforms, everything is PIE
                        *mode = BuildModePIE
                default:
                        *mode = BuildModeExe
@@ -65,7 +65,7 @@ func (mode *BuildMode) Set(s string) error {
                        }
                case "windows":
                        switch objabi.GOARCH {
-                       case "amd64", "386", "arm":
+                       case "amd64", "386", "arm", "arm64":
                        default:
                                return badmode()
                        }
@@ -220,7 +220,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
        case BuildModePIE:
                switch objabi.GOOS + "/" + objabi.GOARCH {
                case "linux/amd64", "linux/arm64", "android/arm64":
-               case "windows/386", "windows/amd64", "windows/arm":
+               case "windows/386", "windows/amd64", "windows/arm", "windows/arm64":
                case "darwin/amd64", "darwin/arm64":
                default:
                        // Internal linking does not support TLS_IE.

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 00130044abbb9d3a1d9e1f65ca3fa85095f88e6e..92d38bb63e54aa04c441d18a6613273a6a91ce24 100644 (file)
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -55,6 +55,7 @@ func isRuntimeDepPkg(pkg string) bool {
        switch pkg {
        case "runtime",
                "sync/atomic",      // runtime may call to sync/atomic, due to go:linkname
+               "internal/abi",     // used by reflectcall (and maybe more)
                "internal/bytealg", // for IndexByte
                "internal/cpu":     // for cpu features
                return true
@@ -106,14 +107,12 @@ func trampoline(ctxt *Link, s loader.Sym) {
                }
                rs = ldr.ResolveABIAlias(rs)
                if ldr.SymValue(rs) == 0 && (ldr.SymType(rs) != sym.SDYNIMPORT && ldr.SymType(rs) != sym.SUNDEFEXT) {
-                       if ldr.SymPkg(rs) != ldr.SymPkg(s) {
-                               if !isRuntimeDepPkg(ldr.SymPkg(s)) || !isRuntimeDepPkg(ldr.SymPkg(rs)) {
-                                       ctxt.Errorf(s, "unresolved inter-package jump to %s(%s) from %s", ldr.SymName(rs), ldr.SymPkg(rs), ldr.SymPkg(s))
-                               }
-                               // runtime and its dependent packages may call to each other.
-                               // they are fine, as they will be laid down together.
+                       if ldr.SymPkg(rs) == ldr.SymPkg(s) {
+                               continue // symbols in the same package are laid out together
+                       }
+                       if isRuntimeDepPkg(ldr.SymPkg(s)) && isRuntimeDepPkg(ldr.SymPkg(rs)) {
+                               continue // runtime packages are laid out together
                        }
-                       continue
                }
 
                thearch.Trampoline(ctxt, ldr, ri, rs, s)
@@ -206,8 +205,8 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
                }
 
                // We need to be able to reference dynimport symbols when linking against
-               // shared libraries, and Solaris, Darwin and AIX need it always
-               if !target.IsSolaris() && !target.IsDarwin() && !target.IsAIX() && rs != 0 && rst == sym.SDYNIMPORT && !target.IsDynlinkingGo() && !ldr.AttrSubSymbol(rs) {
+               // shared libraries, and AIX, Darwin, OpenBSD and Solaris always need it.
+               if !target.IsAIX() && !target.IsDarwin() && !target.IsSolaris() && !target.IsOpenbsd() && rs != 0 && rst == sym.SDYNIMPORT && !target.IsDynlinkingGo() && !ldr.AttrSubSymbol(rs) {
                        if !(target.IsPPC64() && target.IsExternal() && ldr.SymName(rs) == ".TOC.") {
                                st.err.Errorf(s, "unhandled relocation for %s (type %d (%s) rtype %d (%s))", ldr.SymName(rs), rst, rst, rt, sym.RelocName(target.Arch, rt))
                        }
@@ -1815,6 +1814,7 @@ func (state *dodataState) allocateDataSections(ctxt *Link) {
        for _, symn := range sym.ReadOnly {
                symnStartValue := state.datsize
                state.assignToSection(sect, symn, sym.SRODATA)
+               setCarrierSize(symn, state.datsize-symnStartValue)
                if ctxt.HeadType == objabi.Haix {
                        // Read-only symbols might be wrapped inside their outer
                        // symbol.
@@ -1902,6 +1902,7 @@ func (state *dodataState) allocateDataSections(ctxt *Link) {
                                }
                        }
                        state.assignToSection(sect, symn, sym.SRODATA)
+                       setCarrierSize(symn, state.datsize-symnStartValue)
                        if ctxt.HeadType == objabi.Haix {
                                // Read-only symbols might be wrapped inside their outer
                                // symbol.
@@ -1949,6 +1950,7 @@ func (state *dodataState) allocateDataSections(ctxt *Link) {
        ldr.SetSymSect(ldr.LookupOrCreateSym("runtime.pctab", 0), sect)
        ldr.SetSymSect(ldr.LookupOrCreateSym("runtime.functab", 0), sect)
        ldr.SetSymSect(ldr.LookupOrCreateSym("runtime.epclntab", 0), sect)
+       setCarrierSize(sym.SPCLNTAB, int64(sect.Length))
        if ctxt.HeadType == objabi.Haix {
                xcoffUpdateOuterSize(ctxt, int64(sect.Length), sym.SPCLNTAB)
        }

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index d8813fa9361c67a3ec8668f1509a56ffe3c76480..1874103b932f848e82b145c96f909d22719d20a4 100644 (file)
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -91,6 +91,10 @@ func (d *deadcodePass) init() {
                names = append(names, exp)
        }
 
+       if d.ctxt.Debugvlog > 1 {
+               d.ctxt.Logf("deadcode start names: %v\n", names)
+       }
+
        for _, name := range names {
                // Mark symbol as a data/ABI0 symbol.
                d.mark(d.ldr.Lookup(name, 0), 0)
@@ -165,13 +169,17 @@ func (d *deadcodePass) flood() {
                                // R_USEIFACEMETHOD is a marker relocation that marks an interface
                                // method as used.
                                rs := r.Sym()
-                               if d.ldr.SymType(rs) != sym.SDYNIMPORT { // don't decode DYNIMPORT symbol (we'll mark all exported methods anyway)
-                                       m := d.decodeIfaceMethod(d.ldr, d.ctxt.Arch, rs, r.Add())
-                                       if d.ctxt.Debugvlog > 1 {
-                                               d.ctxt.Logf("reached iface method: %v\n", m)
-                                       }
-                                       d.ifaceMethod[m] = true
+                               if d.ctxt.linkShared && (d.ldr.SymType(rs) == sym.SDYNIMPORT || d.ldr.SymType(rs) == sym.Sxxx) {
+                                       // Don't decode symbol from shared library (we'll mark all exported methods anyway).
+                                       // We check for both SDYNIMPORT and Sxxx because name-mangled symbols haven't
+                                       // been resolved at this point.
+                                       continue
+                               }
+                               m := d.decodeIfaceMethod(d.ldr, d.ctxt.Arch, rs, r.Add())
+                               if d.ctxt.Debugvlog > 1 {
+                                       d.ctxt.Logf("reached iface method: %v\n", m)
                                }
+                               d.ifaceMethod[m] = true
                                continue
                        }
                        rs := r.Sym()

diff --git a/src/cmd/link/internal/ld/decodesym.go b/src/cmd/link/internal/ld/decodesym.go
index c6e2d8ca7fc9ceda261b854e447ed9181fdd0c98..fc179fc6e44109e28134070ae122d3f93fa0de01 100644 (file)
--- a/src/cmd/link/internal/ld/decodesym.go
+++ b/src/cmd/link/internal/ld/decodesym.go
@@ -279,7 +279,7 @@ func findShlibSection(ctxt *Link, path string, addr uint64) *elf.Section {
        for _, shlib := range ctxt.Shlibs {
                if shlib.Path == path {
                        for _, sect := range shlib.File.Sections[1:] { // skip the NULL section
-                               if sect.Addr <= addr && addr <= sect.Addr+sect.Size {
+                               if sect.Addr <= addr && addr < sect.Addr+sect.Size {
                                        return sect
                                }
                        }

diff --git a/src/cmd/link/internal/ld/dwarf.go b/src/cmd/link/internal/ld/dwarf.go
index 2ab9a55e969b8c0f868e7aa5f4936b2f28e2b22a..561f6f1475994c6117d57a9772231a2eb494d443 100644 (file)
--- a/src/cmd/link/internal/ld/dwarf.go
+++ b/src/cmd/link/internal/ld/dwarf.go
@@ -1454,7 +1454,7 @@ func (d *dwctxt) writeframes(fs loader.Sym) dwarfSecInfo {
                // Emit a FDE, Section 6.4.1.
                // First build the section contents into a byte buffer.
                deltaBuf = deltaBuf[:0]
-               if haslr && d.ldr.AttrTopFrame(fn) {
+               if haslr && fi.TopFrame() {
                        // Mark the link register as having an undefined value.
                        // This stops call stack unwinders progressing any further.
                        // TODO: similar mark on non-LR architectures.
@@ -1480,7 +1480,7 @@ func (d *dwctxt) writeframes(fs loader.Sym) dwarfSecInfo {
                                spdelta += int64(d.arch.PtrSize)
                        }
 
-                       if haslr && !d.ldr.AttrTopFrame(fn) {
+                       if haslr && !fi.TopFrame() {
                                // TODO(bryanpkc): This is imprecise. In general, the instruction
                                // that stores the return address to the stack frame is not the
                                // same one that allocates the frame.

diff --git a/src/cmd/link/internal/ld/execarchive.go b/src/cmd/link/internal/ld/execarchive.go
index fe5cc4086573b4b7754ec604f6e64c09e6a7b3e2..4687c624de464611e7de9036ae187c3e94be6023 100644 (file)
--- a/src/cmd/link/internal/ld/execarchive.go
+++ b/src/cmd/link/internal/ld/execarchive.go
@@ -7,8 +7,8 @@
 package ld
 
 import (
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "path/filepath"
        "syscall"
 )

diff --git a/src/cmd/link/internal/ld/fallocate_test.go b/src/cmd/link/internal/ld/fallocate_test.go
index 51f5fcdd9fc27d6f4e138c40700d9c4474747ab8..244b70f0615067d724febf3fbb8ed91e2edb250a 100644 (file)
--- a/src/cmd/link/internal/ld/fallocate_test.go
+++ b/src/cmd/link/internal/ld/fallocate_test.go
@@ -57,8 +57,12 @@ func TestFallocate(t *testing.T) {
                if got := stat.Size(); got != sz {
                        t.Errorf("unexpected file size: got %d, want %d", got, sz)
                }
-               if got, want := stat.Sys().(*syscall.Stat_t).Blocks, (sz+511)/512; got != want {
-                       t.Errorf("unexpected disk usage: got %d blocks, want %d", got, want)
+               // The number of blocks must be enough for the requested size.
+               // We used to require an exact match, but it appears that
+               // some file systems allocate a few extra blocks in some cases.
+               // See issue #41127.
+               if got, want := stat.Sys().(*syscall.Stat_t).Blocks, (sz+511)/512; got < want {
+                       t.Errorf("unexpected disk usage: got %d blocks, want at least %d", got, want)
                }
                out.munmap()
        }

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index e1cc7184de3671a129f7f07dd958a94a8469a8dc..314896824a03fcb8d3dcb58146759d10adbeb615 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -49,11 +49,11 @@ import (
        "encoding/base64"
        "encoding/binary"
        "fmt"
+       exec "internal/execabs"
        "io"
        "io/ioutil"
        "log"
        "os"
-       "os/exec"
        "path/filepath"
        "runtime"
        "sort"
@@ -489,10 +489,16 @@ func (ctxt *Link) loadlib() {
        case 0:
                // nothing to do
        case 1, 2:
-               flags = loader.FlagStrictDups
+               flags |= loader.FlagStrictDups
        default:
                log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
        }
+       if !*flagAbiWrap || ctxt.linkShared {
+               // Use ABI aliases if ABI wrappers are not used.
+               // TODO: for now we still use ABI aliases in shared linkage, even if
+               // the wrapper is enabled.
+               flags |= loader.FlagUseABIAlias
+       }
        elfsetstring1 := func(str string, off int) { elfsetstring(ctxt, 0, str, off) }
        ctxt.loader = loader.NewLoader(flags, elfsetstring1, &ctxt.ErrorReporter.ErrorReporter)
        ctxt.ErrorReporter.SymName = func(s loader.Sym) string {
@@ -1273,6 +1279,7 @@ func (ctxt *Link) hostlink() {
                }
        case objabi.Hopenbsd:
                argv = append(argv, "-Wl,-nopie")
+               argv = append(argv, "-pthread")
        case objabi.Hwindows:
                if windowsgui {
                        argv = append(argv, "-mwindows")
@@ -1458,7 +1465,7 @@ func (ctxt *Link) hostlink() {
        }
 
        const compressDWARF = "-Wl,--compress-debug-sections=zlib-gnu"
-       if ctxt.compressDWARF && linkerFlagSupported(argv[0], altLinker, compressDWARF) {
+       if ctxt.compressDWARF && linkerFlagSupported(ctxt.Arch, argv[0], altLinker, compressDWARF) {
                argv = append(argv, compressDWARF)
        }
 
@@ -1548,7 +1555,7 @@ func (ctxt *Link) hostlink() {
        if ctxt.BuildMode == BuildModeExe && !ctxt.linkShared && !(ctxt.IsDarwin() && ctxt.IsARM64()) {
                // GCC uses -no-pie, clang uses -nopie.
                for _, nopie := range []string{"-no-pie", "-nopie"} {
-                       if linkerFlagSupported(argv[0], altLinker, nopie) {
+                       if linkerFlagSupported(ctxt.Arch, argv[0], altLinker, nopie) {
                                argv = append(argv, nopie)
                                break
                        }
@@ -1560,10 +1567,22 @@ func (ctxt *Link) hostlink() {
                checkStatic(p)
        }
        if ctxt.HeadType == objabi.Hwindows {
+               // Determine which linker we're using. Add in the extldflags in
+               // case used has specified "-fuse-ld=...".
+               cmd := exec.Command(*flagExtld, *flagExtldflags, "-Wl,--version")
+               usingLLD := false
+               if out, err := cmd.CombinedOutput(); err == nil {
+                       if bytes.Contains(out, []byte("LLD ")) {
+                               usingLLD = true
+                       }
+               }
+
                // use gcc linker script to work around gcc bug
                // (see https://golang.org/issue/20183 for details).
-               p := writeGDBLinkerScript()
-               argv = append(argv, "-Wl,-T,"+p)
+               if !usingLLD {
+                       p := writeGDBLinkerScript()
+                       argv = append(argv, "-Wl,-T,"+p)
+               }
                // libmingw32 and libmingwex have some inter-dependencies,
                // so must use linker groups.
                argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
@@ -1657,7 +1676,7 @@ func (ctxt *Link) hostlink() {
 
 var createTrivialCOnce sync.Once
 
-func linkerFlagSupported(linker, altLinker, flag string) bool {
+func linkerFlagSupported(arch *sys.Arch, linker, altLinker, flag string) bool {
        createTrivialCOnce.Do(func() {
                src := filepath.Join(*flagTmpdir, "trivial.c")
                if err := ioutil.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
@@ -1691,7 +1710,7 @@ func linkerFlagSupported(linker, altLinker, flag string) bool {
                "-target",
        }
 
-       var flags []string
+       flags := hostlinkArchArgs(arch)
        keep := false
        skip := false
        extldflags := strings.Fields(*flagExtldflags)
@@ -1737,12 +1756,19 @@ func hostlinkArchArgs(arch *sys.Arch) []string {
        switch arch.Family {
        case sys.I386:
                return []string{"-m32"}
-       case sys.AMD64, sys.S390X:
+       case sys.AMD64:
+               if objabi.GOOS == "darwin" {
+                       return []string{"-arch", "x86_64", "-m64"}
+               }
+               return []string{"-m64"}
+       case sys.S390X:
                return []string{"-m64"}
        case sys.ARM:
                return []string{"-marm"}
        case sys.ARM64:
-               // nothing needed
+               if objabi.GOOS == "darwin" {
+                       return []string{"-arch", "arm64"}
+               }
        case sys.MIPS64:
                return []string{"-mabi=64"}
        case sys.MIPS:
@@ -1801,14 +1827,14 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
                return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
        }
 
-       if c1 == 0x4c && c2 == 0x01 || c1 == 0x64 && c2 == 0x86 {
+       if /* x86 */ c1 == 0x4c && c2 == 0x01 || /* x86_64 */ c1 == 0x64 && c2 == 0x86 || /* armv7 */ c1 == 0xc4 && c2 == 0x01 {
                ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
                        textp, rsrc, err := loadpe.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
                        if err != nil {
                                Errorf(nil, "%v", err)
                                return
                        }
-                       if rsrc != 0 {
+                       if len(rsrc) != 0 {
                                setpersrc(ctxt, rsrc)
                        }
                        ctxt.Textp = append(ctxt.Textp, textp...)
@@ -2071,6 +2097,26 @@ func ldshlibsyms(ctxt *Link, shlib string) {
                Errorf(nil, "cannot read symbols from shared library: %s", libpath)
                return
        }
+
+       // collect text symbol ABI versions.
+       symabi := make(map[string]int) // map (unmangled) symbol name to version
+       if *flagAbiWrap {
+               for _, elfsym := range syms {
+                       if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
+                               continue
+                       }
+                       // Demangle the name. Keep in sync with symtab.go:putelfsym.
+                       if strings.HasSuffix(elfsym.Name, ".abiinternal") {
+                               // ABIInternal symbol has mangled name, so the primary symbol is ABI0.
+                               symabi[strings.TrimSuffix(elfsym.Name, ".abiinternal")] = 0
+                       }
+                       if strings.HasSuffix(elfsym.Name, ".abi0") {
+                               // ABI0 symbol has mangled name, so the primary symbol is ABIInternal.
+                               symabi[strings.TrimSuffix(elfsym.Name, ".abi0")] = sym.SymVerABIInternal
+                       }
+               }
+       }
+
        for _, elfsym := range syms {
                if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
                        continue
@@ -2079,12 +2125,23 @@ func ldshlibsyms(ctxt *Link, shlib string) {
                // Symbols whose names start with "type." are compiler
                // generated, so make functions with that prefix internal.
                ver := 0
+               symname := elfsym.Name // (unmangled) symbol name
                if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
                        ver = sym.SymVerABIInternal
+               } else if *flagAbiWrap && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+                       if strings.HasSuffix(elfsym.Name, ".abiinternal") {
+                               ver = sym.SymVerABIInternal
+                               symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
+                       } else if strings.HasSuffix(elfsym.Name, ".abi0") {
+                               ver = 0
+                               symname = strings.TrimSuffix(elfsym.Name, ".abi0")
+                       } else if abi, ok := symabi[elfsym.Name]; ok {
+                               ver = abi
+                       }
                }
 
                l := ctxt.loader
-               s := l.LookupOrCreateSym(elfsym.Name, ver)
+               s := l.LookupOrCreateSym(symname, ver)
 
                // Because loadlib above loads all .a files before loading
                // any shared libraries, any non-dynimport symbols we find
@@ -2109,6 +2166,10 @@ func ldshlibsyms(ctxt *Link, shlib string) {
                        }
                }
 
+               if symname != elfsym.Name {
+                       l.SetSymExtname(s, elfsym.Name)
+               }
+
                // For function symbols, we don't know what ABI is
                // available, so alias it under both ABIs.
                //
@@ -2117,7 +2178,12 @@ func ldshlibsyms(ctxt *Link, shlib string) {
                // mangle Go function names in the .so to include the
                // ABI.
                if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
-                       alias := ctxt.loader.LookupOrCreateSym(elfsym.Name, sym.SymVerABIInternal)
+                       if *flagAbiWrap {
+                               if _, ok := symabi[symname]; ok {
+                                       continue // only use alias for functions w/o ABI wrappers
+                               }
+                       }
+                       alias := ctxt.loader.LookupOrCreateSym(symname, sym.SymVerABIInternal)
                        if l.SymType(alias) != 0 {
                                continue
                        }

diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 460564476782d129733d53fb78a04968b831ec82..3630e67c25d60c7b1fddb843a57b8edb80c8884b 100644 (file)
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -969,6 +969,15 @@ func machosymorder(ctxt *Link) {
        }
 }
 
+// AddMachoSym adds s to Mach-O symbol table, used in GenSymLate.
+// Currently only used on ARM64 when external linking.
+func AddMachoSym(ldr *loader.Loader, s loader.Sym) {
+       ldr.SetSymDynid(s, int32(nsortsym))
+       sortsym = append(sortsym, s)
+       nsortsym++
+       nkind[symkind(ldr, s)]++
+}
+
 // machoShouldExport reports whether a symbol needs to be exported.
 //
 // When dynamically linking, all non-local variables and plugin-exported

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 5c8293810f99fba71d732c4c02e770d493ebc1f1..68dee1859878b7e0d1d7a8f061fa1c67d21219a8 100644 (file)
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -92,11 +92,10 @@ var (
        FlagRound         = flag.Int("R", -1, "set address rounding `quantum`")
        FlagTextAddr      = flag.Int64("T", -1, "set text segment `address`")
        flagEntrySymbol   = flag.String("E", "", "set `entry` symbol name")
-
-       cpuprofile     = flag.String("cpuprofile", "", "write cpu profile to `file`")
-       memprofile     = flag.String("memprofile", "", "write memory profile to `file`")
-       memprofilerate = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-
+       cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")
+       memprofile        = flag.String("memprofile", "", "write memory profile to `file`")
+       memprofilerate    = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
+       flagAbiWrap       = flag.Bool("abiwrap", objabi.Regabi_enabled != 0, "support ABI wrapper functions")
        benchmarkFlag     = flag.String("benchmark", "", "set to 'mem' or 'cpu' to enable phase benchmarking")
        benchmarkFileFlag = flag.String("benchmarkprofile", "", "emit phase profiles to `base`_phase.{cpu,mem}prof")
 )
@@ -117,7 +116,7 @@ func Main(arch *sys.Arch, theArch Arch) {
        }
 
        final := gorootFinal()
-       addstrdata1(ctxt, "runtime/internal/sys.DefaultGoroot="+final)
+       addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
        addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
        // TODO(matloob): define these above and then check flag values here
@@ -183,6 +182,14 @@ func Main(arch *sys.Arch, theArch Arch) {
 
        interpreter = *flagInterpreter
 
+       if *flagBuildid == "" && ctxt.Target.IsOpenbsd() {
+               // TODO(jsing): Remove once direct syscalls are no longer in use.
+               // OpenBSD 6.7 onwards will not permit direct syscalls from a
+               // dynamically linked binary unless it identifies the binary
+               // contains a .note.go.buildid ELF note. See issue #36435.
+               *flagBuildid = "go-openbsd"
+       }
+
        // enable benchmarking
        var bench *benchmark.Metrics
        if len(*benchmarkFlag) != 0 {
@@ -330,6 +337,8 @@ func Main(arch *sys.Arch, theArch Arch) {
        bench.Start("Asmb")
        asmb(ctxt)
 
+       exitIfErrors()
+
        // Generate additional symbols for the native symbol table just prior
        // to code generation.
        bench.Start("GenSymsLate")

diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go
index facb30fe15c7b4aeb60f308fad65d9054877e579..fb733117be4bd6101c8addc46d1bb46431076942 100644 (file)
--- a/src/cmd/link/internal/ld/pcln.go
+++ b/src/cmd/link/internal/ld/pcln.go
@@ -796,7 +796,14 @@ func writeFuncs(ctxt *Link, sb *loader.SymbolBuilder, funcs []loader.Sym, inlSym
                }
                off = uint32(sb.SetUint8(ctxt.Arch, int64(off), uint8(funcID)))
 
-               off += 2 // pad
+               // flag uint8
+               var flag objabi.FuncFlag
+               if fi.Valid() {
+                       flag = fi.FuncFlag()
+               }
+               off = uint32(sb.SetUint8(ctxt.Arch, int64(off), uint8(flag)))
+
+               off += 1 // pad
 
                // nfuncdata must be the final entry.
                funcdata, funcdataoff = funcData(fi, 0, funcdata, funcdataoff)
@@ -859,6 +866,7 @@ func (ctxt *Link) pclntab(container loader.Bitmap) *pclntab {
        state.carrier = ldr.LookupOrCreateSym("runtime.pclntab", 0)
        ldr.MakeSymbolUpdater(state.carrier).SetType(sym.SPCLNTAB)
        ldr.SetAttrReachable(state.carrier, true)
+       setCarrierSym(sym.SPCLNTAB, state.carrier)
 
        state.generatePCHeader(ctxt)
        nameOffsets := state.generateFuncnametab(ctxt, funcs)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index d60aa55c36049f5593a5a7387e3e44de5b355fcb..36c8e0da9a7d62f8af18201ee9b7809193da2d22 100644 (file)
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -42,11 +42,11 @@ type IMAGE_EXPORT_DIRECTORY struct {
        AddressOfNameOrdinals uint32
 }
 
-const (
-       PEBASE = 0x00400000
-)
-
 var (
+       // PEBASE is the base address for the executable.
+       // It is small for 32-bit and large for 64-bit.
+       PEBASE int64
+
        // SectionAlignment must be greater than or equal to FileAlignment.
        // The default is the page size for the architecture.
        PESECTALIGN int64 = 0x1000
@@ -69,6 +69,7 @@ const (
        IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 )
 
+// See https://docs.microsoft.com/en-us/windows/win32/debug/pe-format.
 // TODO(crawshaw): add these constants to debug/pe.
 const (
        // TODO: the Microsoft doco says IMAGE_SYM_DTYPE_ARRAY is 3 and IMAGE_SYM_DTYPE_FUNCTION is 2
@@ -95,6 +96,25 @@ const (
        IMAGE_REL_ARM_BRANCH11 = 0x0004
        IMAGE_REL_ARM_SECREL   = 0x000F
 
+       IMAGE_REL_ARM64_ABSOLUTE       = 0x0000
+       IMAGE_REL_ARM64_ADDR32         = 0x0001
+       IMAGE_REL_ARM64_ADDR32NB       = 0x0002
+       IMAGE_REL_ARM64_BRANCH26       = 0x0003
+       IMAGE_REL_ARM64_PAGEBASE_REL21 = 0x0004
+       IMAGE_REL_ARM64_REL21          = 0x0005
+       IMAGE_REL_ARM64_PAGEOFFSET_12A = 0x0006
+       IMAGE_REL_ARM64_PAGEOFFSET_12L = 0x0007
+       IMAGE_REL_ARM64_SECREL         = 0x0008
+       IMAGE_REL_ARM64_SECREL_LOW12A  = 0x0009
+       IMAGE_REL_ARM64_SECREL_HIGH12A = 0x000A
+       IMAGE_REL_ARM64_SECREL_LOW12L  = 0x000B
+       IMAGE_REL_ARM64_TOKEN          = 0x000C
+       IMAGE_REL_ARM64_SECTION        = 0x000D
+       IMAGE_REL_ARM64_ADDR64         = 0x000E
+       IMAGE_REL_ARM64_BRANCH19       = 0x000F
+       IMAGE_REL_ARM64_BRANCH14       = 0x0010
+       IMAGE_REL_ARM64_REL32          = 0x0011
+
        IMAGE_REL_BASED_HIGHLOW = 3
        IMAGE_REL_BASED_DIR64   = 10
 )
@@ -253,7 +273,7 @@ type Dll struct {
 }
 
 var (
-       rsrcsym     loader.Sym
+       rsrcsyms    []loader.Sym
        PESECTHEADR int32
        PEFILEHEADR int32
        pe64        int
@@ -316,8 +336,8 @@ func (sect *peSection) checkOffset(off int64) {
 // checkSegment verifies COFF section sect matches address
 // and file offset provided in segment seg.
 func (sect *peSection) checkSegment(seg *sym.Segment) {
-       if seg.Vaddr-PEBASE != uint64(sect.virtualAddress) {
-               Errorf(nil, "%s.VirtualAddress = %#x, want %#x", sect.name, uint64(int64(sect.virtualAddress)), uint64(int64(seg.Vaddr-PEBASE)))
+       if seg.Vaddr-uint64(PEBASE) != uint64(sect.virtualAddress) {
+               Errorf(nil, "%s.VirtualAddress = %#x, want %#x", sect.name, uint64(int64(sect.virtualAddress)), uint64(int64(seg.Vaddr-uint64(PEBASE))))
                errorexit()
        }
        if seg.Fileoff != uint64(sect.pointerToRawData) {
@@ -465,6 +485,8 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
                size = 8
        case "arm":
                size = 4
+       case "arm64":
+               size = 8
        }
        sect := f.addSection(".ctors", size, size)
        sect.characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
@@ -477,7 +499,7 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
        switch objabi.GOARCH {
        case "386", "arm":
                ctxt.Out.Write32(uint32(addr))
-       case "amd64":
+       case "amd64", "arm64":
                ctxt.Out.Write64(addr)
        }
        return sect
@@ -594,6 +616,8 @@ dwarfLoop:
                        ctxt.Out.Write16(IMAGE_REL_AMD64_ADDR64)
                case "arm":
                        ctxt.Out.Write16(IMAGE_REL_ARM_ADDR32)
+               case "arm64":
+                       ctxt.Out.Write16(IMAGE_REL_ARM64_ADDR64)
                }
                return 1
        })
@@ -788,6 +812,8 @@ func (f *peFile) writeFileHeader(ctxt *Link) {
                fh.Machine = pe.IMAGE_FILE_MACHINE_I386
        case sys.ARM:
                fh.Machine = pe.IMAGE_FILE_MACHINE_ARMNT
+       case sys.ARM64:
+               fh.Machine = pe.IMAGE_FILE_MACHINE_ARM64
        }
 
        fh.NumberOfSections = uint16(len(f.sections))
@@ -852,8 +878,8 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
        }
        oh64.BaseOfCode = f.textSect.virtualAddress
        oh.BaseOfCode = f.textSect.virtualAddress
-       oh64.ImageBase = PEBASE
-       oh.ImageBase = PEBASE
+       oh64.ImageBase = uint64(PEBASE)
+       oh.ImageBase = uint32(PEBASE)
        oh64.SectionAlignment = uint32(PESECTALIGN)
        oh.SectionAlignment = uint32(PESECTALIGN)
        oh64.FileAlignment = uint32(PEFILEALIGN)
@@ -891,13 +917,7 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
        oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_NX_COMPAT
 
        // The DLL can be relocated at load time.
-       switch ctxt.Arch.Family {
-       case sys.AMD64, sys.I386:
-               if ctxt.BuildMode == BuildModePIE {
-                       oh64.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
-                       oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
-               }
-       case sys.ARM:
+       if needPEBaseReloc(ctxt) {
                oh64.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
                oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
        }
@@ -975,18 +995,23 @@ var pefile peFile
 func Peinit(ctxt *Link) {
        var l int
 
-       switch ctxt.Arch.Family {
-       // 64-bit architectures
-       case sys.AMD64:
+       if ctxt.Arch.PtrSize == 8 {
+               // 64-bit architectures
                pe64 = 1
+               PEBASE = 1 << 32
+               if ctxt.Arch.Family == sys.AMD64 {
+                       // TODO(rsc): For cgo we currently use 32-bit relocations
+                       // that fail when PEBASE is too large.
+                       // We need to fix this, but for now, use a smaller PEBASE.
+                       PEBASE = 1 << 22
+               }
                var oh64 pe.OptionalHeader64
                l = binary.Size(&oh64)
-
-       // 32-bit architectures
-       default:
+       } else {
+               // 32-bit architectures
+               PEBASE = 1 << 22
                var oh pe.OptionalHeader32
                l = binary.Size(&oh)
-
        }
 
        if ctxt.LinkMode == LinkExternal {
@@ -1210,7 +1235,7 @@ func addimports(ctxt *Link, datsect *peSection) {
        endoff := ctxt.Out.Offset()
 
        // write FirstThunks (allocated in .data section)
-       ftbase := uint64(ldr.SymValue(dynamic)) - uint64(datsect.virtualAddress) - PEBASE
+       ftbase := uint64(ldr.SymValue(dynamic)) - uint64(datsect.virtualAddress) - uint64(PEBASE)
 
        ctxt.Out.SeekSet(int64(uint64(datsect.pointerToRawData) + ftbase))
        for d := dr; d != nil; d = d.next {
@@ -1463,17 +1488,18 @@ func addPEBaseRelocSym(ldr *loader.Loader, s loader.Sym, rt *peBaseRelocTable) {
        }
 }
 
+func needPEBaseReloc(ctxt *Link) bool {
+       // Non-PIE x86 binaries don't need the base relocation table.
+       // Everyone else does.
+       if (ctxt.Arch.Family == sys.I386 || ctxt.Arch.Family == sys.AMD64) && ctxt.BuildMode != BuildModePIE {
+               return false
+       }
+       return true
+}
+
 func addPEBaseReloc(ctxt *Link) {
-       // Arm does not work without base relocation table.
-       // 386 and amd64 will only require the table for BuildModePIE.
-       switch ctxt.Arch.Family {
-       default:
+       if !needPEBaseReloc(ctxt) {
                return
-       case sys.I386, sys.AMD64:
-               if ctxt.BuildMode != BuildModePIE {
-                       return
-               }
-       case sys.ARM:
        }
 
        var rt peBaseRelocTable
@@ -1508,56 +1534,60 @@ func (ctxt *Link) dope() {
        initdynexport(ctxt)
 }
 
-func setpersrc(ctxt *Link, sym loader.Sym) {
-       if rsrcsym != 0 {
+func setpersrc(ctxt *Link, syms []loader.Sym) {
+       if len(rsrcsyms) != 0 {
                Errorf(nil, "too many .rsrc sections")
        }
-
-       rsrcsym = sym
+       rsrcsyms = syms
 }
 
 func addpersrc(ctxt *Link) {
-       if rsrcsym == 0 {
+       if len(rsrcsyms) == 0 {
                return
        }
 
-       data := ctxt.loader.Data(rsrcsym)
-       size := len(data)
-       h := pefile.addSection(".rsrc", size, size)
-       h.characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_CNT_INITIALIZED_DATA
+       var size int64
+       for _, rsrcsym := range rsrcsyms {
+               size += ctxt.loader.SymSize(rsrcsym)
+       }
+       h := pefile.addSection(".rsrc", int(size), int(size))
+       h.characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA
        h.checkOffset(ctxt.Out.Offset())
 
-       // relocation
-       relocs := ctxt.loader.Relocs(rsrcsym)
-       for i := 0; i < relocs.Count(); i++ {
-               r := relocs.At(i)
-               p := data[r.Off():]
-               val := uint32(int64(h.virtualAddress) + r.Add())
-
-               // 32-bit little-endian
-               p[0] = byte(val)
-
-               p[1] = byte(val >> 8)
-               p[2] = byte(val >> 16)
-               p[3] = byte(val >> 24)
+       for _, rsrcsym := range rsrcsyms {
+               // A split resource happens when the actual resource data and its relocations are
+               // split across multiple sections, denoted by a $01 or $02 at the end of the .rsrc
+               // section name.
+               splitResources := strings.Contains(ctxt.loader.SymName(rsrcsym), ".rsrc$")
+               relocs := ctxt.loader.Relocs(rsrcsym)
+               data := ctxt.loader.Data(rsrcsym)
+               for ri := 0; ri < relocs.Count(); ri++ {
+                       r := relocs.At(ri)
+                       p := data[r.Off():]
+                       val := uint32(int64(h.virtualAddress) + r.Add())
+                       if splitResources {
+                               // If we're a split resource section, and that section has relocation
+                               // symbols, then the data that it points to doesn't actually begin at
+                               // the virtual address listed in this current section, but rather
+                               // begins at the section immediately after this one. So, in order to
+                               // calculate the proper virtual address of the data it's pointing to,
+                               // we have to add the length of this section to the virtual address.
+                               // This works because .rsrc sections are divided into two (but not more)
+                               // of these sections.
+                               val += uint32(len(data))
+                       }
+                       binary.LittleEndian.PutUint32(p, val)
+               }
+               ctxt.Out.Write(data)
        }
-
-       ctxt.Out.Write(data)
        h.pad(ctxt.Out, uint32(size))
 
        // update data directory
        pefile.dataDirectory[pe.IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = h.virtualAddress
-
        pefile.dataDirectory[pe.IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = h.virtualSize
 }
 
 func asmbPe(ctxt *Link) {
-       switch ctxt.Arch.Family {
-       default:
-               Exitf("unknown PE architecture: %v", ctxt.Arch.Family)
-       case sys.AMD64, sys.I386, sys.ARM:
-       }
-
        t := pefile.addSection(".text", int(Segtext.Length), int(Segtext.Length))
        t.characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
        if ctxt.LinkMode == LinkExternal {

diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index 49713896138a7faa0d7cd463eb29b3e9bb1615a8..85a8ff42ad0d00479b651436034fbd24d5cf2858 100644 (file)
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -102,6 +102,41 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
                elfshnum = xosect.Elfsect.(*ElfShdr).shnum
        }
 
+       sname := ldr.SymExtname(x)
+
+       // For functions with ABI wrappers, we have to make sure that we
+       // don't wind up with two elf symbol table entries with the same
+       // name (since this will generated an error from the external
+       // linker). In the CgoExportStatic case, we want the ABI0 symbol
+       // to have the primary symbol table entry (since it's going to be
+       // called from C), so we rename the ABIInternal symbol. In all
+       // other cases, we rename the ABI0 symbol, since we want
+       // cross-load-module calls to target ABIInternal.
+       //
+       // TODO: generalize this for non-ELF (put the rename code in the
+       // loader, and store the rename result in SymExtname).
+       //
+       // TODO: avoid the ldr.Lookup calls below by instead using an aux
+       // sym or marker relocation to associate the wrapper with the
+       // wrapped function.
+       //
+       if *flagAbiWrap {
+               if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
+                       // First case
+                       if ldr.SymVersion(x) == sym.SymVerABIInternal {
+                               if s2 := ldr.Lookup(sname, sym.SymVerABI0); s2 != 0 && ldr.AttrCgoExportStatic(s2) && ldr.SymType(s2) == sym.STEXT {
+                                       sname = sname + ".abiinternal"
+                               }
+                       }
+                       // Second case
+                       if ldr.SymVersion(x) == sym.SymVerABI0 && !ldr.AttrCgoExportStatic(x) {
+                               if s2 := ldr.Lookup(sname, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
+                                       sname = sname + ".abi0"
+                               }
+                       }
+               }
+       }
+
        // One pass for each binding: elf.STB_LOCAL, elf.STB_GLOBAL,
        // maybe one day elf.STB_WEAK.
        bind := elf.STB_GLOBAL
@@ -140,8 +175,6 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
                other |= 3 << 5
        }
 
-       sname := ldr.SymExtname(x)
-
        // When dynamically linking, we create Symbols by reading the names from
        // the symbol tables of the shared libraries and so the names need to
        // match exactly. Tools like DTrace will have to wait for now.
@@ -483,6 +516,8 @@ func (ctxt *Link) symtab(pcln *pclntab) []sym.SymKind {
                        symtype = s.Sym()
                        symtyperel = s.Sym()
                }
+               setCarrierSym(sym.STYPE, symtype)
+               setCarrierSym(sym.STYPERELRO, symtyperel)
        }
 
        groupSym := func(name string, t sym.SymKind) loader.Sym {
@@ -490,6 +525,7 @@ func (ctxt *Link) symtab(pcln *pclntab) []sym.SymKind {
                s.SetType(t)
                s.SetSize(0)
                s.SetLocal(true)
+               setCarrierSym(t, s.Sym())
                return s.Sym()
        }
        var (
@@ -800,3 +836,23 @@ func (ctxt *Link) symtab(pcln *pclntab) []sym.SymKind {
        }
        return symGroupType
 }
+
+// CarrierSymByType tracks carrier symbols and their sizes.
+var CarrierSymByType [sym.SXREF]struct {
+       Sym  loader.Sym
+       Size int64
+}
+
+func setCarrierSym(typ sym.SymKind, s loader.Sym) {
+       if CarrierSymByType[typ].Sym != 0 {
+               panic(fmt.Sprintf("carrier symbol for type %v already set", typ))
+       }
+       CarrierSymByType[typ].Sym = s
+}
+
+func setCarrierSize(typ sym.SymKind, sz int64) {
+       if CarrierSymByType[typ].Size != 0 {
+               panic(fmt.Sprintf("carrier symbol size for type %v already set", typ))
+       }
+       CarrierSymByType[typ].Size = sz
+}

diff --git a/src/cmd/link/internal/ld/xcoff.go b/src/cmd/link/internal/ld/xcoff.go
index 7bf06eaa4614e0c8d433c794ce1f417b8b072243..ba818eaa961e525293d4f573bdf7f62af56bfae1 100644 (file)
--- a/src/cmd/link/internal/ld/xcoff.go
+++ b/src/cmd/link/internal/ld/xcoff.go
@@ -574,6 +574,7 @@ func xcoffUpdateOuterSize(ctxt *Link, size int64, stype sym.SymKind) {
        if size == 0 {
                return
        }
+       // TODO: use CarrierSymByType
 
        ldr := ctxt.loader
        switch stype {

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 971cc432ff54b10921202e6a96df60494131a039..68dc3de2738276c7afb1518845ee89a2a7bd21ea 100644 (file)
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -241,7 +241,6 @@ type Loader struct {
        attrExternal         Bitmap // external symbols, indexed by ext sym index
 
        attrReadOnly         map[Sym]bool     // readonly data for this sym
-       attrTopFrame         map[Sym]struct{} // top frame symbols
        attrSpecial          map[Sym]struct{} // "special" frame symbols
        attrCgoExportDynamic map[Sym]struct{} // "cgo_export_dynamic" symbols
        attrCgoExportStatic  map[Sym]struct{} // "cgo_export_static" symbols
@@ -322,6 +321,7 @@ type extSymPayload struct {
 const (
        // Loader.flags
        FlagStrictDups = 1 << iota
+       FlagUseABIAlias
 )
 
 func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorReporter) *Loader {
@@ -348,7 +348,6 @@ func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorRepor
                plt:                  make(map[Sym]int32),
                got:                  make(map[Sym]int32),
                dynid:                make(map[Sym]int32),
-               attrTopFrame:         make(map[Sym]struct{}),
                attrSpecial:          make(map[Sym]struct{}),
                attrCgoExportDynamic: make(map[Sym]struct{}),
                attrCgoExportStatic:  make(map[Sym]struct{}),
@@ -1008,24 +1007,6 @@ func (l *Loader) SetAttrExternal(i Sym, v bool) {
        }
 }
 
-// AttrTopFrame returns true for a function symbol that is an entry
-// point, meaning that unwinders should stop when they hit this
-// function.
-func (l *Loader) AttrTopFrame(i Sym) bool {
-       _, ok := l.attrTopFrame[i]
-       return ok
-}
-
-// SetAttrTopFrame sets the "top frame" property for a symbol (see
-// AttrTopFrame).
-func (l *Loader) SetAttrTopFrame(i Sym, v bool) {
-       if v {
-               l.attrTopFrame[i] = struct{}{}
-       } else {
-               delete(l.attrTopFrame, i)
-       }
-}
-
 // AttrSpecial returns true for a symbols that do not have their
 // address (i.e. Value) computed by the usual mechanism of
 // data.go:dodata() & data.go:address().
@@ -1904,7 +1885,11 @@ func (fi *FuncInfo) Locals() int {
 }
 
 func (fi *FuncInfo) FuncID() objabi.FuncID {
-       return objabi.FuncID((*goobj.FuncInfo)(nil).ReadFuncID(fi.data))
+       return (*goobj.FuncInfo)(nil).ReadFuncID(fi.data)
+}
+
+func (fi *FuncInfo) FuncFlag() objabi.FuncFlag {
+       return (*goobj.FuncInfo)(nil).ReadFuncFlag(fi.data)
 }
 
 func (fi *FuncInfo) Pcsp() Sym {
@@ -1991,6 +1976,13 @@ func (fi *FuncInfo) File(k int) goobj.CUFileIndex {
        return (*goobj.FuncInfo)(nil).ReadFile(fi.data, fi.lengths.FileOff, uint32(k))
 }
 
+// TopFrame returns true if the function associated with this FuncInfo
+// is an entry point, meaning that unwinders should stop when they hit
+// this function.
+func (fi *FuncInfo) TopFrame() bool {
+       return (fi.FuncFlag() & objabi.FuncFlag_TOPFRAME) != 0
+}
+
 type InlTreeNode struct {
        Parent   int32
        File     goobj.CUFileIndex
@@ -2150,9 +2142,6 @@ func (st *loadState) preloadSyms(r *oReader, kind int) {
                }
                gi := st.addSym(name, v, r, i, kind, osym)
                r.syms[i] = gi
-               if osym.TopFrame() {
-                       l.SetAttrTopFrame(gi, true)
-               }
                if osym.Local() {
                        l.SetAttrLocal(gi, true)
                }
@@ -2270,6 +2259,9 @@ func abiToVer(abi uint16, localSymVersion int) int {
 // symbol. If the sym in question is not an alias, the sym itself is
 // returned.
 func (l *Loader) ResolveABIAlias(s Sym) Sym {
+       if l.flags&FlagUseABIAlias == 0 {
+               return s
+       }
        if s == 0 {
                return 0
        }
@@ -2407,7 +2399,6 @@ func (l *Loader) CopyAttributes(src Sym, dst Sym) {
                // when copying attributes from a dupOK ABI wrapper symbol to
                // the real target symbol (which may not be marked dupOK).
        }
-       l.SetAttrTopFrame(dst, l.AttrTopFrame(src))
        l.SetAttrSpecial(dst, l.AttrSpecial(src))
        l.SetAttrCgoExportDynamic(dst, l.AttrCgoExportDynamic(src))
        l.SetAttrCgoExportStatic(dst, l.AttrCgoExportStatic(src))

diff --git a/src/cmd/link/internal/loadpe/ldpe.go b/src/cmd/link/internal/loadpe/ldpe.go
index 7677278ec59c07a899cf8d2c29e0043dafa43039..a5c025de8fff54d5884fc3066f79744b8526ad1b 100644 (file)
--- a/src/cmd/link/internal/loadpe/ldpe.go
+++ b/src/cmd/link/internal/loadpe/ldpe.go
@@ -6,6 +6,7 @@
 package loadpe
 
 import (
+       "bytes"
        "cmd/internal/bio"
        "cmd/internal/objabi"
        "cmd/internal/sys"
@@ -156,8 +157,9 @@ func makeUpdater(l *loader.Loader, bld *loader.SymbolBuilder, s loader.Sym) *loa
 
 // Load loads the PE file pn from input.
 // Symbols are written into syms, and a slice of the text symbols is returned.
-// If an .rsrc section is found, its symbol is returned as rsrc.
-func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Reader, pkg string, length int64, pn string) (textp []loader.Sym, rsrc loader.Sym, err error) {
+// If an .rsrc section or set of .rsrc$xx sections is found, its symbols are
+// returned as rsrc.
+func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Reader, pkg string, length int64, pn string) (textp []loader.Sym, rsrc []loader.Sym, err error) {
        lookup := func(name string, version int) (*loader.SymbolBuilder, loader.Sym) {
                s := l.LookupOrCreateSym(name, version)
                sb := l.MakeSymbolUpdater(s)
@@ -175,7 +177,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
        // TODO: replace pe.NewFile with pe.Load (grep for "add Load function" in debug/pe for details)
        f, err := pe.NewFile(sr)
        if err != nil {
-               return nil, 0, err
+               return nil, nil, err
        }
        defer f.Close()
 
@@ -210,21 +212,21 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                        bld.SetType(sym.STEXT)
 
                default:
-                       return nil, 0, fmt.Errorf("unexpected flags %#06x for PE section %s", sect.Characteristics, sect.Name)
+                       return nil, nil, fmt.Errorf("unexpected flags %#06x for PE section %s", sect.Characteristics, sect.Name)
                }
 
                if bld.Type() != sym.SNOPTRBSS {
                        data, err := sect.Data()
                        if err != nil {
-                               return nil, 0, err
+                               return nil, nil, err
                        }
                        sectdata[sect] = data
                        bld.SetData(data)
                }
                bld.SetSize(int64(sect.Size))
                sectsyms[sect] = s
-               if sect.Name == ".rsrc" {
-                       rsrc = s
+               if sect.Name == ".rsrc" || strings.HasPrefix(sect.Name, ".rsrc$") {
+                       rsrc = append(rsrc, s)
                }
        }
 
@@ -245,22 +247,23 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                        continue
                }
 
+               splitResources := strings.HasPrefix(rsect.Name, ".rsrc$")
                sb := l.MakeSymbolUpdater(sectsyms[rsect])
                for j, r := range rsect.Relocs {
                        if int(r.SymbolTableIndex) >= len(f.COFFSymbols) {
-                               return nil, 0, fmt.Errorf("relocation number %d symbol index idx=%d cannot be large then number of symbols %d", j, r.SymbolTableIndex, len(f.COFFSymbols))
+                               return nil, nil, fmt.Errorf("relocation number %d symbol index idx=%d cannot be large then number of symbols %d", j, r.SymbolTableIndex, len(f.COFFSymbols))
                        }
                        pesym := &f.COFFSymbols[r.SymbolTableIndex]
                        _, gosym, err := readpesym(l, arch, l.LookupOrCreateSym, f, pesym, sectsyms, localSymVersion)
                        if err != nil {
-                               return nil, 0, err
+                               return nil, nil, err
                        }
                        if gosym == 0 {
                                name, err := pesym.FullName(f.StringTable)
                                if err != nil {
                                        name = string(pesym.Name[:])
                                }
-                               return nil, 0, fmt.Errorf("reloc of invalid sym %s idx=%d type=%d", name, r.SymbolTableIndex, pesym.Type)
+                               return nil, nil, fmt.Errorf("reloc of invalid sym %s idx=%d type=%d", name, r.SymbolTableIndex, pesym.Type)
                        }
 
                        rSym := gosym
@@ -270,11 +273,11 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                        var rType objabi.RelocType
                        switch arch.Family {
                        default:
-                               return nil, 0, fmt.Errorf("%s: unsupported arch %v", pn, arch.Family)
+                               return nil, nil, fmt.Errorf("%s: unsupported arch %v", pn, arch.Family)
                        case sys.I386, sys.AMD64:
                                switch r.Type {
                                default:
-                                       return nil, 0, fmt.Errorf("%s: %v: unknown relocation type %v", pn, sectsyms[rsect], r.Type)
+                                       return nil, nil, fmt.Errorf("%s: %v: unknown relocation type %v", pn, sectsyms[rsect], r.Type)
 
                                case IMAGE_REL_I386_REL32, IMAGE_REL_AMD64_REL32,
                                        IMAGE_REL_AMD64_ADDR32, // R_X86_64_PC32
@@ -301,14 +304,14 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                        case sys.ARM:
                                switch r.Type {
                                default:
-                                       return nil, 0, fmt.Errorf("%s: %v: unknown ARM relocation type %v", pn, sectsyms[rsect], r.Type)
+                                       return nil, nil, fmt.Errorf("%s: %v: unknown ARM relocation type %v", pn, sectsyms[rsect], r.Type)
 
                                case IMAGE_REL_ARM_SECREL:
                                        rType = objabi.R_PCREL
 
                                        rAdd = int64(int32(binary.LittleEndian.Uint32(sectdata[rsect][rOff:])))
 
-                               case IMAGE_REL_ARM_ADDR32:
+                               case IMAGE_REL_ARM_ADDR32, IMAGE_REL_ARM_ADDR32NB:
                                        rType = objabi.R_ADDR
 
                                        rAdd = int64(int32(binary.LittleEndian.Uint32(sectdata[rsect][rOff:])))
@@ -322,8 +325,9 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 
                        // ld -r could generate multiple section symbols for the
                        // same section but with different values, we have to take
-                       // that into account
-                       if issect(pesym) {
+                       // that into account, or in the case of split resources,
+                       // the section and its symbols are split into two sections.
+                       if issect(pesym) || splitResources {
                                rAdd += int64(pesym.Value)
                        }
 
@@ -345,7 +349,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 
                name, err := pesym.FullName(f.StringTable)
                if err != nil {
-                       return nil, 0, err
+                       return nil, nil, err
                }
                if name == "" {
                        continue
@@ -359,6 +363,20 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                if pesym.SectionNumber == IMAGE_SYM_DEBUG {
                        continue
                }
+               if pesym.SectionNumber == IMAGE_SYM_ABSOLUTE && bytes.Equal(pesym.Name[:], []byte("@feat.00")) {
+                       // Microsoft's linker looks at whether all input objects have an empty
+                       // section called @feat.00. If all of them do, then it enables SEH;
+                       // otherwise it doesn't enable that feature. So, since around the Windows
+                       // XP SP2 era, most tools that make PE objects just tack on that section,
+                       // so that it won't gimp Microsoft's linker logic. Go doesn't support SEH,
+                       // so in theory, none of this really matters to us. But actually, if the
+                       // linker tries to ingest an object with @feat.00 -- which are produced by
+                       // LLVM's resource compiler, for example -- it chokes because of the
+                       // IMAGE_SYM_ABSOLUTE section that it doesn't know how to deal with. Since
+                       // @feat.00 is just a marking anyway, skip IMAGE_SYM_ABSOLUTE sections that
+                       // are called @feat.00.
+                       continue
+               }
                var sect *pe.Section
                if pesym.SectionNumber > 0 {
                        sect = f.Sections[pesym.SectionNumber-1]
@@ -369,7 +387,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 
                bld, s, err := readpesym(l, arch, l.LookupOrCreateSym, f, pesym, sectsyms, localSymVersion)
                if err != nil {
-                       return nil, 0, err
+                       return nil, nil, err
                }
 
                if pesym.SectionNumber == 0 { // extern
@@ -387,14 +405,14 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                } else if pesym.SectionNumber > 0 && int(pesym.SectionNumber) <= len(f.Sections) {
                        sect = f.Sections[pesym.SectionNumber-1]
                        if _, found := sectsyms[sect]; !found {
-                               return nil, 0, fmt.Errorf("%s: %v: missing sect.sym", pn, s)
+                               return nil, nil, fmt.Errorf("%s: %v: missing sect.sym", pn, s)
                        }
                } else {
-                       return nil, 0, fmt.Errorf("%s: %v: sectnum < 0!", pn, s)
+                       return nil, nil, fmt.Errorf("%s: %v: sectnum < 0!", pn, s)
                }
 
                if sect == nil {
-                       return nil, 0, nil
+                       return nil, nil, nil
                }
 
                if l.OuterSym(s) != 0 {
@@ -403,7 +421,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                        }
                        outerName := l.SymName(l.OuterSym(s))
                        sectName := l.SymName(sectsyms[sect])
-                       return nil, 0, fmt.Errorf("%s: duplicate symbol reference: %s in both %s and %s", pn, l.SymName(s), outerName, sectName)
+                       return nil, nil, fmt.Errorf("%s: duplicate symbol reference: %s in both %s and %s", pn, l.SymName(s), outerName, sectName)
                }
 
                bld = makeUpdater(l, bld, s)
@@ -414,7 +432,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                bld.SetSize(4)
                if l.SymType(sectsym) == sym.STEXT {
                        if bld.External() && !bld.DuplicateOK() {
-                               return nil, 0, fmt.Errorf("%s: duplicate symbol definition", l.SymName(s))
+                               return nil, nil, fmt.Errorf("%s: duplicate symbol definition", l.SymName(s))
                        }
                        bld.SetExternal(true)
                }
@@ -431,7 +449,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
                if l.SymType(s) == sym.STEXT {
                        for ; s != 0; s = l.SubSym(s) {
                                if l.AttrOnList(s) {
-                                       return nil, 0, fmt.Errorf("symbol %s listed multiple times", l.SymName(s))
+                                       return nil, nil, fmt.Errorf("symbol %s listed multiple times", l.SymName(s))
                                }
                                l.SetAttrOnList(s, true)
                                textp = append(textp, s)

diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 5bf3898eb9de222640b9311244990625131ba699..602f0b52999a377af6fb7f823560d8cdfeb44c94 100644 (file)
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -656,13 +656,19 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 
        relocs := ldr.Relocs(s)
        r := relocs.At(ri)
-       t := ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
+       var t int64
+       // ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
+       // laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
+       // in dependency order.
+       if ldr.SymValue(rs) != 0 {
+               t = ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
+       }
        switch r.Type() {
        case objabi.R_CALLPOWER:
 
                // If branch offset is too far then create a trampoline.
 
-               if (ctxt.IsExternal() && ldr.SymSect(s) != ldr.SymSect(rs)) || (ctxt.IsInternal() && int64(int32(t<<6)>>6) != t) || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+               if (ctxt.IsExternal() && ldr.SymSect(s) != ldr.SymSect(rs)) || (ctxt.IsInternal() && int64(int32(t<<6)>>6) != t) || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
                        var tramp loader.Sym
                        for i := 0; ; i++ {
 
@@ -749,7 +755,7 @@ func gentramp(ctxt *ld.Link, ldr *loader.Loader, tramp *loader.SymbolBuilder, ta
 
                // With external linking, the target address must be
                // relocated using LO and HA
-               if ctxt.IsExternal() {
+               if ctxt.IsExternal() || ldr.SymValue(target) == 0 {
                        r, _ := tramp.AddRel(objabi.R_ADDRPOWER)
                        r.SetOff(0)
                        r.SetSiz(8) // generates 2 relocations: HA + LO

diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 158c6707391bb9a3654b8a087c8bcd2b991d5fd3..08ddd00a0c7639b1abc008275bbbc3f586717d05 100644 (file)
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -320,6 +320,7 @@ func TestBuildForTvOS(t *testing.T) {
        }
 
        link := exec.Command(CC[0], CC[1:]...)
+       link.Args = append(link.Args, "-o", filepath.Join(tmpDir, "a.out")) // Avoid writing to package directory.
        link.Args = append(link.Args, ar, filepath.Join("testdata", "testBuildFortvOS", "main.m"))
        if out, err := link.CombinedOutput(); err != nil {
                t.Fatalf("%v: %v:\n%s", link.Args, err, out)
@@ -582,7 +583,7 @@ TEXT        ·alignPc(SB),NOSPLIT, $0-0
 `
 
 // TestFuncAlign verifies that the address of a function can be aligned
-// with a specfic value on arm64.
+// with a specific value on arm64.
 func TestFuncAlign(t *testing.T) {
        if runtime.GOARCH != "arm64" || runtime.GOOS != "linux" {
                t.Skip("skipping on non-linux/arm64 platform")
@@ -786,6 +787,25 @@ func TestPErsrc(t *testing.T) {
        if !bytes.Contains(b, []byte("Hello Gophers!")) {
                t.Fatalf("binary does not contain expected content")
        }
+
+       pkgdir = filepath.Join("testdata", "testPErsrc-complex")
+       exe = filepath.Join(tmpdir, "a.exe")
+       cmd = exec.Command(testenv.GoToolPath(t), "build", "-o", exe)
+       cmd.Dir = pkgdir
+       // cmd.Env = append(os.Environ(), "GOOS=windows", "GOARCH=amd64") // uncomment if debugging in a cross-compiling environment
+       out, err = cmd.CombinedOutput()
+       if err != nil {
+               t.Fatalf("building failed: %v, output:\n%s", err, out)
+       }
+
+       // Check that the binary contains the rsrc data
+       b, err = ioutil.ReadFile(exe)
+       if err != nil {
+               t.Fatalf("reading output failed: %v", err)
+       }
+       if !bytes.Contains(b, []byte("resname RCDATA a.rc")) {
+               t.Fatalf("binary does not contain expected content")
+       }
 }
 
 func TestContentAddressableSymbols(t *testing.T) {
@@ -925,3 +945,57 @@ func TestIssue42396(t *testing.T) {
                t.Fatalf("error message incorrect: expected it to contain %q but instead got:\n%s\n", want, out)
        }
 }
+
+const testLargeRelocSrc = `
+package main
+
+var x = [1<<25]byte{1<<23: 23, 1<<24: 24}
+
+func main() {
+       check(x[1<<23-1], 0)
+       check(x[1<<23], 23)
+       check(x[1<<23+1], 0)
+       check(x[1<<24-1], 0)
+       check(x[1<<24], 24)
+       check(x[1<<24+1], 0)
+}
+
+func check(x, y byte) {
+       if x != y {
+               panic("FAIL")
+       }
+}
+`
+
+func TestLargeReloc(t *testing.T) {
+       // Test that large relocation addend is handled correctly.
+       // In particular, on darwin/arm64 when external linking,
+       // Mach-O relocation has only 24-bit addend. See issue #42738.
+       testenv.MustHaveGoBuild(t)
+       t.Parallel()
+
+       tmpdir, err := ioutil.TempDir("", "TestIssue42396")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer os.RemoveAll(tmpdir)
+
+       src := filepath.Join(tmpdir, "x.go")
+       err = ioutil.WriteFile(src, []byte(testLargeRelocSrc), 0666)
+       if err != nil {
+               t.Fatalf("failed to write source file: %v", err)
+       }
+       cmd := exec.Command(testenv.GoToolPath(t), "run", src)
+       out, err := cmd.CombinedOutput()
+       if err != nil {
+               t.Errorf("build failed: %v. output:\n%s", err, out)
+       }
+
+       if testenv.HasCGO() { // currently all targets that support cgo can external link
+               cmd = exec.Command(testenv.GoToolPath(t), "run", "-ldflags=-linkmode=external", src)
+               out, err = cmd.CombinedOutput()
+               if err != nil {
+                       t.Fatalf("build failed: %v. output:\n%s", err, out)
+               }
+       }
+}

diff --git a/src/cmd/link/testdata/testPErsrc-complex/main.go b/src/cmd/link/testdata/testPErsrc-complex/main.go
new file mode 100644 (file)
index 0000000..affd6ea
--- /dev/null
+++ b/src/cmd/link/testdata/testPErsrc-complex/main.go
@@ -0,0 +1,43 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that a PE rsrc section is handled correctly, when the object files
+// have been created by llvm-rc or msvc's rc.exe, which means there's the
+// @feat.00 symbol as well as split .rsrc$00 and .rsrc$01 section to deal with.
+//
+// rsrc.syso is created with:
+//    windres -i a.rc -o rsrc.syso -O coff
+// where this windres calls into llvm-rc and llvm-cvtres. The source file,
+// a.rc, simply contains a reference to its own bytes:
+//
+//    resname RCDATA a.rc
+//
+// Object dumping the resultant rsrc.syso, we can see the split sections and
+// the @feat.00 SEH symbol:
+//
+//     rsrc.syso:      file format coff-x86-64
+//
+//     architecture: x86_64
+//     start address: 0x0000000000000000
+//
+//     Export Table:
+//     Sections:
+//     Idx Name          Size     VMA              Type
+//       0 .rsrc$01      00000068 0000000000000000 DATA
+//       1 .rsrc$02      00000018 0000000000000000 DATA
+//
+//     SYMBOL TABLE:
+//     [ 0](sec -1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000011 @feat.00
+//     [ 1](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 1) 0x00000000 .rsrc$01
+//     AUX scnlen 0x68 nreloc 1 nlnno 0 checksum 0x0 assoc 0 comdat 0
+//     [ 3](sec  2)(fl 0x00)(ty   0)(scl   3) (nx 1) 0x00000000 .rsrc$02
+//     AUX scnlen 0x18 nreloc 0 nlnno 0 checksum 0x0 assoc 0 comdat 0
+//     [ 5](sec  2)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000000 $R000000
+//     RELOCATION RECORDS FOR [.rsrc$01]:
+//     OFFSET           TYPE                     VALUE
+//     0000000000000048 IMAGE_REL_AMD64_ADDR32NB $R000000
+
+package main
+
+func main() {}

diff --git a/src/cmd/link/testdata/testPErsrc-complex/rsrc.syso b/src/cmd/link/testdata/testPErsrc-complex/rsrc.syso
new file mode 100644 (file)
index 0000000..eff630b
Binary files /dev/null and b/src/cmd/link/testdata/testPErsrc-complex/rsrc.syso differ

diff --git a/src/cmd/objdump/objdump_test.go b/src/cmd/objdump/objdump_test.go
index edaca774f7dfba6d39cbbf9a56b9a79ff2fe96f5..1748e13a537806bfa725ef54b792e2e95b2b0e30 100644 (file)
--- a/src/cmd/objdump/objdump_test.go
+++ b/src/cmd/objdump/objdump_test.go
@@ -237,9 +237,6 @@ func testGoAndCgoDisasm(t *testing.T, printCode bool, printGnuAsm bool) {
        t.Parallel()
        testDisasm(t, "fmthello.go", printCode, printGnuAsm)
        if build.Default.CgoEnabled {
-               if runtime.GOOS == "aix" {
-                       return // issue 40972
-               }
                testDisasm(t, "fmthellocgo.go", printCode, printGnuAsm)
        }
 }
@@ -261,8 +258,6 @@ func TestDisasmExtld(t *testing.T) {
        switch runtime.GOOS {
        case "plan9", "windows":
                t.Skipf("skipping on %s", runtime.GOOS)
-       case "aix":
-               t.Skipf("skipping on AIX, see issue 40972")
        }
        t.Parallel()
        testDisasm(t, "fmthello.go", false, false, "-ldflags=-linkmode=external")

diff --git a/src/cmd/pack/pack.go b/src/cmd/pack/pack.go
index 82546ea7dcbba68caa8dad7d77c52562e944a899..412ea36d60fa905ffbe3987d301640b5d21f666a 100644 (file)
--- a/src/cmd/pack/pack.go
+++ b/src/cmd/pack/pack.go
@@ -43,7 +43,7 @@ func main() {
                ar = openArchive(os.Args[2], os.O_RDONLY, os.Args[3:])
                ar.scan(ar.printContents)
        case 'r':
-               ar = openArchive(os.Args[2], os.O_RDWR, os.Args[3:])
+               ar = openArchive(os.Args[2], os.O_RDWR|os.O_CREATE, os.Args[3:])
                ar.addFiles()
        case 'c':
                ar = openArchive(os.Args[2], os.O_RDWR|os.O_TRUNC|os.O_CREATE, os.Args[3:])
@@ -124,10 +124,13 @@ func openArchive(name string, mode int, files []string) *Archive {
                log.Fatal(err)
        }
        var a *archive.Archive
-       if mode&os.O_CREATE != 0 { // the c command
+       if mode&os.O_TRUNC != 0 { // the c command
                a, err = archive.New(f)
        } else {
                a, err = archive.Parse(f, verbose)
+               if err != nil && mode&os.O_CREATE != 0 { // the r command
+                       a, err = archive.New(f)
+               }
        }
        if err != nil {
                log.Fatal(err)
@@ -315,20 +318,25 @@ func (ar *Archive) extractContents1(e *archive.Entry, out io.Writer) {
 }
 
 // isGoCompilerObjFile reports whether file is an object file created
-// by the Go compiler, which is an archive file with exactly two entries:
-// __.PKGDEF and _go_.o.
+// by the Go compiler, which is an archive file with exactly one entry
+// of __.PKGDEF, or _go_.o, or both entries.
 func isGoCompilerObjFile(a *archive.Archive) bool {
-       if len(a.Entries) != 2 {
-               return false
-       }
-       var foundPkgDef, foundGo bool
-       for _, e := range a.Entries {
-               if e.Type == archive.EntryPkgDef && e.Name == "__.PKGDEF" {
-                       foundPkgDef = true
-               }
-               if e.Type == archive.EntryGoObj && e.Name == "_go_.o" {
-                       foundGo = true
+       switch len(a.Entries) {
+       case 1:
+               return (a.Entries[0].Type == archive.EntryGoObj && a.Entries[0].Name == "_go_.o") ||
+                       (a.Entries[0].Type == archive.EntryPkgDef && a.Entries[0].Name == "__.PKGDEF")
+       case 2:
+               var foundPkgDef, foundGo bool
+               for _, e := range a.Entries {
+                       if e.Type == archive.EntryPkgDef && e.Name == "__.PKGDEF" {
+                               foundPkgDef = true
+                       }
+                       if e.Type == archive.EntryGoObj && e.Name == "_go_.o" {
+                               foundGo = true
+                       }
                }
+               return foundPkgDef && foundGo
+       default:
+               return false
        }
-       return foundPkgDef && foundGo
 }

diff --git a/src/cmd/pack/pack_test.go b/src/cmd/pack/pack_test.go
index 218c7acda6ddf949eb3769c06ce1ee7b13f5eb41..118376f9df6b88337a0362a29282dc51fbe3961c 100644 (file)
--- a/src/cmd/pack/pack_test.go
+++ b/src/cmd/pack/pack_test.go
@@ -302,6 +302,95 @@ func TestIssue21703(t *testing.T) {
        run(goBin, "tool", "compile", "-I", ".", "b.go")
 }
 
+// Test the "c" command can "see through" the archive generated by the compiler.
+// This is peculiar. (See issue #43271)
+func TestCreateWithCompilerObj(t *testing.T) {
+       testenv.MustHaveGoBuild(t)
+
+       dir := tmpDir(t)
+       defer os.RemoveAll(dir)
+       src := filepath.Join(dir, "p.go")
+       prog := "package p; var X = 42\n"
+       err := os.WriteFile(src, []byte(prog), 0666)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       run := func(args ...string) string {
+               return doRun(t, dir, args...)
+       }
+
+       goBin := testenv.GoToolPath(t)
+       run(goBin, "build", "cmd/pack") // writes pack binary to dir
+       run(goBin, "tool", "compile", "-pack", "-o", "p.a", "p.go")
+       run("./pack", "c", "packed.a", "p.a")
+       fi, err := os.Stat(filepath.Join(dir, "p.a"))
+       if err != nil {
+               t.Fatalf("stat p.a failed: %v", err)
+       }
+       fi2, err := os.Stat(filepath.Join(dir, "packed.a"))
+       if err != nil {
+               t.Fatalf("stat packed.a failed: %v", err)
+       }
+       // For compiler-generated object file, the "c" command is
+       // expected to get (essentially) the same file back, instead
+       // of packing it into a new archive with a single entry.
+       if want, got := fi.Size(), fi2.Size(); want != got {
+               t.Errorf("packed file with different size: want %d, got %d", want, got)
+       }
+
+       // Test -linkobj flag as well.
+       run(goBin, "tool", "compile", "-linkobj", "p2.a", "-o", "p.x", "p.go")
+       run("./pack", "c", "packed2.a", "p2.a")
+       fi, err = os.Stat(filepath.Join(dir, "p2.a"))
+       if err != nil {
+               t.Fatalf("stat p2.a failed: %v", err)
+       }
+       fi2, err = os.Stat(filepath.Join(dir, "packed2.a"))
+       if err != nil {
+               t.Fatalf("stat packed2.a failed: %v", err)
+       }
+       if want, got := fi.Size(), fi2.Size(); want != got {
+               t.Errorf("packed file with different size: want %d, got %d", want, got)
+       }
+
+       run("./pack", "c", "packed3.a", "p.x")
+       fi, err = os.Stat(filepath.Join(dir, "p.x"))
+       if err != nil {
+               t.Fatalf("stat p.x failed: %v", err)
+       }
+       fi2, err = os.Stat(filepath.Join(dir, "packed3.a"))
+       if err != nil {
+               t.Fatalf("stat packed3.a failed: %v", err)
+       }
+       if want, got := fi.Size(), fi2.Size(); want != got {
+               t.Errorf("packed file with different size: want %d, got %d", want, got)
+       }
+}
+
+// Test the "r" command creates the output file if it does not exist.
+func TestRWithNonexistentFile(t *testing.T) {
+       testenv.MustHaveGoBuild(t)
+
+       dir := tmpDir(t)
+       defer os.RemoveAll(dir)
+       src := filepath.Join(dir, "p.go")
+       prog := "package p; var X = 42\n"
+       err := os.WriteFile(src, []byte(prog), 0666)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       run := func(args ...string) string {
+               return doRun(t, dir, args...)
+       }
+
+       goBin := testenv.GoToolPath(t)
+       run(goBin, "build", "cmd/pack") // writes pack binary to dir
+       run(goBin, "tool", "compile", "-o", "p.o", "p.go")
+       run("./pack", "r", "p.a", "p.o") // should succeed
+}
+
 // doRun runs a program in a directory and returns the output.
 func doRun(t *testing.T, dir string, args ...string) string {
        cmd := exec.Command(args[0], args[1:]...)

diff --git a/src/cmd/test2json/main.go b/src/cmd/test2json/main.go
index 57a874193e311cb19797dee89f16055fde81edeb..fdf681a8ffe564cc07715b7c218b789345446d27 100644 (file)
--- a/src/cmd/test2json/main.go
+++ b/src/cmd/test2json/main.go
@@ -6,7 +6,7 @@
 //
 // Usage:
 //
-//     go tool test2json [-p pkg] [-t] [./pkg.test -test.v]
+//     go tool test2json [-p pkg] [-t] [./pkg.test -test.v [-test.paniconexit0]]
 //
 // Test2json runs the given test command and converts its output to JSON;
 // with no command specified, test2json expects test output on standard input.
@@ -18,6 +18,10 @@
 //
 // The -t flag requests that time stamps be added to each test event.
 //
+// The test must be invoked with -test.v. Additionally passing
+// -test.paniconexit0 will cause test2json to exit with a non-zero
+// status if one of the tests being run calls os.Exit(0).
+//
 // Note that test2json is only intended for converting a single test
 // binary's output. To convert the output of a "go test" command,
 // use "go test -json" instead of invoking test2json directly.
@@ -82,9 +86,9 @@ package main
 import (
        "flag"
        "fmt"
+       exec "internal/execabs"
        "io"
        "os"
-       "os/exec"
 
        "cmd/internal/test2json"
 )

diff --git a/src/cmd/trace/pprof.go b/src/cmd/trace/pprof.go
index a73ff5336afab0ced026cb58775a40c4184eeeaf..c4d37428209ab61d7cc74f44725bc93a421a7dcf 100644 (file)
--- a/src/cmd/trace/pprof.go
+++ b/src/cmd/trace/pprof.go
@@ -9,11 +9,11 @@ package main
 import (
        "bufio"
        "fmt"
+       exec "internal/execabs"
        "internal/trace"
        "io"
        "net/http"
        "os"
-       "os/exec"
        "path/filepath"
        "runtime"
        "sort"

diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index 83398dda5d5c91970b1ad8c67a9a9e4dd6071c1c..c6a189dbe049d843811236ec7b7265038c0afc8d 100644 (file)
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -832,7 +832,16 @@ func (f *File) DropRequire(path string) error {
        return nil
 }
 
+// AddExclude adds a exclude statement to the mod file. Errors if the provided
+// version is not a canonical version string
 func (f *File) AddExclude(path, vers string) error {
+       if !isCanonicalVersion(vers) {
+               return &module.InvalidVersionError{
+                       Version: vers,
+                       Err:     errors.New("must be of the form v1.2.3"),
+               }
+       }
+
        var hint *Line
        for _, x := range f.Exclude {
                if x.Mod.Path == path && x.Mod.Version == vers {
@@ -904,7 +913,22 @@ func (f *File) DropReplace(oldPath, oldVers string) error {
        return nil
 }
 
+// AddRetract adds a retract statement to the mod file. Errors if the provided
+// version interval does not consist of canonical version strings
 func (f *File) AddRetract(vi VersionInterval, rationale string) error {
+       if !isCanonicalVersion(vi.High) {
+               return &module.InvalidVersionError{
+                       Version: vi.High,
+                       Err:     errors.New("must be of the form v1.2.3"),
+               }
+       }
+       if !isCanonicalVersion(vi.Low) {
+               return &module.InvalidVersionError{
+                       Version: vi.Low,
+                       Err:     errors.New("must be of the form v1.2.3"),
+               }
+       }
+
        r := &Retract{
                VersionInterval: vi,
        }
@@ -1061,3 +1085,9 @@ func lineRetractLess(li, lj *Line) bool {
        }
        return semver.Compare(vii.High, vij.High) > 0
 }
+
+// isCanonicalVersion tests if the provided version string represents a valid
+// canonical version.
+func isCanonicalVersion(vers string) bool {
+       return vers != "" && semver.Canonical(vers) == vers
+}

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
index c0f9f2d523f53e97a80b7e5bd2d9458662f1c5a1..ca98cb485ff1ba37aaa25e2381c2f83bffc7ca8b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -65,6 +65,7 @@ includes_Darwin='
 #include <sys/ptrace.h>
 #include <sys/select.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <sys/sockio.h>
 #include <sys/sys_domain.h>
 #include <sys/sysctl.h>
@@ -204,6 +205,7 @@ struct ltchars {
 #include <linux/devlink.h>
 #include <linux/dm-ioctl.h>
 #include <linux/errqueue.h>
+#include <linux/ethtool_netlink.h>
 #include <linux/falloc.h>
 #include <linux/fanotify.h>
 #include <linux/filter.h>
@@ -479,7 +481,7 @@ ccflags="$@"
                $2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
                $2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
                $2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
-               $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
+               $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
                $2 ~ /^TP_STATUS_/ ||
                $2 ~ /^FALLOC_/ ||
                $2 == "ICMPV6_FILTER" ||
@@ -561,7 +563,9 @@ ccflags="$@"
                $2 ~ /^(HDIO|WIN|SMART)_/ ||
                $2 ~ /^CRYPTO_/ ||
                $2 ~ /^TIPC_/ ||
+               $2 !~  "DEVLINK_RELOAD_LIMITS_VALID_MASK" &&
                $2 ~ /^DEVLINK_/ ||
+               $2 ~ /^ETHTOOL_/ ||
                $2 ~ /^LWTUNNEL_IP/ ||
                $2 !~ "WMESGLEN" &&
                $2 ~ /^W[A-Z0-9]+$/ ||

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
new file mode 100644 (file)
index 0000000..fc568b5
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
@@ -0,0 +1,11 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin,!ios
+
+package unix
+
+func ptrace(request int, pid int, addr uintptr, data uintptr) error {
+       return ptrace1(request, pid, addr, data)
+}

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
new file mode 100644 (file)
index 0000000..183441c
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
@@ -0,0 +1,11 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ios
+
+package unix
+
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+       return ENOTSUP
+}

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
index 4408153822dbbfe5041d0d7eead51ab829f355c1..423dcced7ef7730e71ed7782db667ee75681d40a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -419,8 +419,8 @@ func (w WaitStatus) TrapCause() int { return -1 }
 //sys  Mknod(path string, mode uint32, dev int) (err error)
 //sys  Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
 //sys  Nanosleep(time *Timespec, leftover *Timespec) (err error)
-//sys   Open(path string, mode int, perm uint32) (fd int, err error) = open64
-//sys   Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
+//sys  Open(path string, mode int, perm uint32) (fd int, err error) = open64
+//sys  Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
 //sys  read(fd int, p []byte) (n int, err error)
 //sys  Readlink(path string, buf []byte) (n int, err error)
 //sys  Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
@@ -439,8 +439,8 @@ func (w WaitStatus) TrapCause() int { return -1 }
 //sysnb        Times(tms *Tms) (ticks uintptr, err error)
 //sysnb        Umask(mask int) (oldmask int)
 //sysnb        Uname(buf *Utsname) (err error)
-//sys   Unlink(path string) (err error)
-//sys   Unlinkat(dirfd int, path string, flags int) (err error)
+//sys  Unlink(path string) (err error)
+//sys  Unlinkat(dirfd int, path string, flags int) (err error)
 //sys  Ustat(dev int, ubuf *Ustat_t) (err error)
 //sys  write(fd int, p []byte) (n int, err error)
 //sys  readlen(fd int, p *byte, np int) (n int, err error) = read
@@ -514,7 +514,7 @@ func Munmap(b []byte) (err error) {
 //sys  Munlock(b []byte) (err error)
 //sys  Munlockall() (err error)
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb        pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
index bc634a280a08c05e5879cfd8796b69299178b45a..678fb27777a7a0800a83fd8340500a70a200c489 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
@@ -318,7 +318,7 @@ func Getsockname(fd int) (sa Sockaddr, err error) {
        return anyToSockaddr(fd, &rsa)
 }
 
-//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
+//sysnb        socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
 
 // GetsockoptString returns the string value of the socket option opt for the
 // socket associated with fd at the given socket level.
@@ -332,8 +332,8 @@ func GetsockoptString(fd, level, opt int) (string, error) {
        return string(buf[:vallen-1]), nil
 }
 
-//sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
-//sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
+//sys  recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
+//sys  sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
 //sys  recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
@@ -626,7 +626,7 @@ func Futimes(fd int, tv []Timeval) error {
        return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 }
 
-//sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
+//sys  poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 
 func Poll(fds []PollFd, timeout int) (n int, err error) {
        if len(fds) == 0 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
index b6257389008784051d3169ed9ab94b82b1801a2c..e771a3c5efb61ca064d23bc73ad7a4d17ebdacb7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -119,13 +119,16 @@ type attrList struct {
        Forkattr    uint32
 }
 
-//sysnb pipe() (r int, w int, err error)
+//sysnb        pipe(p *[2]int32) (err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
                return EINVAL
        }
-       p[0], p[1], err = pipe()
+       var x [2]int32
+       err = pipe(&x)
+       p[0] = int(x[0])
+       p[1] = int(x[1])
        return
 }
 
@@ -269,7 +272,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
                options)
 }
 
-//sys setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
+//sys  setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
 
 func utimensat(dirfd int, path string, times *[2]Timespec, flags int) error {
        // Darwin doesn't support SYS_UTIMENSAT
@@ -317,7 +320,7 @@ func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
        return err
 }
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
 
 func Uname(uname *Utsname) error {
        mib := []_C_int{CTL_KERN, KERN_OSTYPE}
@@ -375,6 +378,15 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
        return
 }
 
+// GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
+// The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
+func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
+       x := new(Xucred)
+       vallen := _Socklen(unsafe.Sizeof(Xucred{}))
+       err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
+       return x, err
+}
+
 //sys  sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
 
 /*
@@ -469,8 +481,8 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys  Unlinkat(dirfd int, path string, flags int) (err error)
 //sys  Unmount(path string, flags int) (err error)
 //sys  write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys  mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys  munmap(addr uintptr, length uintptr) (err error)
 //sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
index 6c1f4ab95b477cf0526114071d526aca311dc004..ee065fcf2da979c7d2feb5cc87c4408fee3397b6 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys  Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
 //sys  getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
 //sys  Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
-//sys  ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys  ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys  Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys  Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
index 0582ae256ef43f93d3c298d496531dfd4b203ff6..7a1f64a7b6b4a5a62a5529f670f277d3109c8ff2 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys  Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
 //sys  getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
 //sys  Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
-//sys  ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys  ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys  Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys  Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
index c6a9733b4cb6eab5870518703ccc5e6d6281524c..d30735c5d630314e710101d8ff9215e9df9c98cb 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
@@ -6,7 +6,7 @@ package unix
 
 import "syscall"
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) error {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) error {
        return ENOTSUP
 }
 

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
index 253afa4de55cd4d25559d31c5ae74f41d55db4d2..9f85fd4046ea80eba82039d0ba605966f92d5998 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys  Fstatfs(fd int, stat *Statfs_t) (err error)
 //sys  getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT
 //sys  Lstat(path string, stat *Stat_t) (err error)
-//sys  ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys  ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys  Stat(path string, stat *Stat_t) (err error)
 //sys  Statfs(path string, stat *Statfs_t) (err error)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index a4f2944a24eab2115cc5686ea74f9d3886a94c0e..474141b625d29fbb9f0f213a139763006df0ab63 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -95,7 +95,7 @@ func direntNamlen(buf []byte) (uint64, bool) {
        return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
 }
 
-//sysnb pipe() (r int, w int, err error)
+//sysnb        pipe() (r int, w int, err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
@@ -105,16 +105,13 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(flags int) (r int, w int, err error)
 
-func Pipe2(p []int, flags int) error {
+func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {
                return EINVAL
        }
-       var pp [2]_C_int
-       err := pipe2(&pp, flags)
-       p[0] = int(pp[0])
-       p[1] = int(pp[1])
+       p[0], p[1], err = pipe2(flags)
        return err
 }
 
@@ -170,7 +167,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys  ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func sysctlUname(mib []_C_int, old *byte, oldlen *uintptr) error {
        err := sysctl(mib, old, oldlen, nil, 0)
@@ -337,8 +334,8 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys  Unlinkat(dirfd int, path string, flags int) (err error)
 //sys  Unmount(path string, flags int) (err error)
 //sys  write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys  mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys  munmap(addr uintptr, length uintptr) (err error)
 //sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 //sys  accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
index acc00c2e6a10a4e10e8728805ad674bf6ff52e53..15af63dd5526426d157d055de181ecd944d53ddc 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
@@ -188,9 +188,9 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
        return ENOSYS
 }
 
-//sys   ioctl(fd int, req uint, arg uintptr) (err error)
+//sys  ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func Uname(uname *Utsname) error {
        mib := []_C_int{CTL_KERN, KERN_OSTYPE}
@@ -665,8 +665,8 @@ func PtraceSingleStep(pid int) (err error) {
 //sys  Unlinkat(dirfd int, path string, flags int) (err error)
 //sys  Unmount(path string, flags int) (err error)
 //sys  write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys  mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys  munmap(addr uintptr, length uintptr) (err error)
 //sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 //sys  accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
index bbc4f3ea543963fce397ea4c2a2e2149e950b9d4..7a2d4120fc0816b17cda8251b24e15d5ae07e6b6 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
@@ -75,16 +75,3 @@ func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
        }
        return
 }
-
-//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
-
-func Pipe2(p []int, flags int) error {
-       if len(p) != 2 {
-               return EINVAL
-       }
-       var pp [2]_C_int
-       err := pipe2(&pp, flags)
-       p[0] = int(pp[0])
-       p[1] = int(pp[1])
-       return err
-}

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 28be1306ec976d018c553eaba5c435de88fdf210..1b210357000afd6ff05e6b206deaf50e8e87773a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1482,8 +1482,8 @@ func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error
        return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction)
 }
 
-//sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
-//sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
+//sys  keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
+//sys  keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
 
 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
        var msg Msghdr
@@ -1860,8 +1860,8 @@ func Getpgrp() (pid int) {
 //sys  Nanosleep(time *Timespec, leftover *Timespec) (err error)
 //sys  PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
 //sys  PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
-//sysnb prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64
-//sys   Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
+//sysnb        prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64
+//sys  Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
 //sys  Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6
 //sys  read(fd int, p []byte) (n int, err error)
 //sys  Removexattr(path string, attr string) (err error)
@@ -1934,9 +1934,9 @@ func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) {
 //sys  Syncfs(fd int) (err error)
 //sysnb        Sysinfo(info *Sysinfo_t) (err error)
 //sys  Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
-//sysnb TimerfdCreate(clockid int, flags int) (fd int, err error)
-//sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
-//sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
+//sysnb        TimerfdCreate(clockid int, flags int) (fd int, err error)
+//sysnb        TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
+//sysnb        TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
 //sysnb        Tgkill(tgid int, tid int, sig syscall.Signal) (err error)
 //sysnb        Times(tms *Tms) (ticks uintptr, err error)
 //sysnb        Umask(mask int) (oldmask int)
@@ -2196,8 +2196,8 @@ func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
        return EACCES
 }
 
-//sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
-//sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
+//sys  nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
+//sys  openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
 
 // fileHandle is the argument to nameToHandleAt and openByHandleAt. We
 // originally tried to generate it via unix/linux/types.go with "type

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
index c97c2ee53e5f58dc54e8a0fe20f7f8393a70189f..70e61bd5db41fb1e28ca7a43cbdd201b4b22d959 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
@@ -31,7 +31,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {
@@ -98,7 +98,7 @@ type rlimit32 struct {
        Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
+//sysnb        getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 
 const rlimInf32 = ^uint32(0)
 const rlimInf64 = ^uint64(0)
@@ -129,7 +129,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
        return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb        setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
        err = prlimit(0, resource, rlim, nil)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
index 72efe86ed4ffc3a4c30170ccc31760ecfcf6d3cb..4be2acd32bde323a61b87ba6906164dbd8b14a8f 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
@@ -138,7 +138,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
index 496837b1e37ef6be10b951761a007d110d930958..322b8e0fb90c6aee7454a67ef5b2a4a45b7de4b8 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
@@ -35,7 +35,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {
@@ -129,8 +129,8 @@ func Utime(path string, buf *Utimbuf) error {
 
 //sys  utimes(path string, times *[2]Timeval) (err error)
 
-//sys   Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
-//sys   Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
+//sys  Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
+//sys  Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
 //sys  Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
 //sys  Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
 
@@ -177,7 +177,7 @@ type rlimit32 struct {
        Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_UGETRLIMIT
+//sysnb        getrlimit(resource int, rlim *rlimit32) (err error) = SYS_UGETRLIMIT
 
 const rlimInf32 = ^uint32(0)
 const rlimInf64 = ^uint64(0)
@@ -208,7 +208,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
        return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb        setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
        err = prlimit(0, resource, rlim, nil)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index c6de6b91345e17209481bacbde10d5ac18b9be1a..9315cf415b75a0fa5a0833e35e23820a22413e06 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -155,7 +155,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
index f0287476cd5d0b3d53203b6c49088c0153dc335e..5fc8a47f4148f96e29df63f99f62ecaa7569ff1b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
@@ -104,7 +104,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
index c11328111d14dca9c0d83399825a67338b5b36fe..20b9825f87b08aab90e768d9230604b3c49c8e8a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
@@ -112,7 +112,7 @@ func setTimeval(sec, usec int64) Timeval {
        return Timeval{Sec: int32(sec), Usec: int32(usec)}
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {
@@ -125,7 +125,7 @@ func Pipe2(p []int, flags int) (err error) {
        return
 }
 
-//sysnb pipe() (p1 int, p2 int, err error)
+//sysnb        pipe() (p1 int, p2 int, err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
@@ -153,7 +153,7 @@ type rlimit32 struct {
        Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
+//sysnb        getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 
 func Getrlimit(resource int, rlim *Rlimit) (err error) {
        err = prlimit(0, resource, nil, rlim)
@@ -181,7 +181,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
        return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb        setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
        err = prlimit(0, resource, rlim, nil)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
index 349374409ba194f5ba586e3601e6bf382947e4fa..5162c39b0e125f0b8000d828ea2365e6e788051c 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
@@ -99,7 +99,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
        cmsg.Len = uint64(length)
 }
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb        pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
@@ -112,7 +112,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index b0b1505565b3bcc835291497043b2e26b67b5b7d..a6a66ece0995c2c00b01cf916ad73c8c09640b14 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -154,7 +154,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
index 2363f749913b8143f3b7337a4fbe1f69108a84a3..fcef0d1daf96dea29ef8a0f59367af800f2b62a7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
@@ -76,7 +76,7 @@ func setTimeval(sec, usec int64) Timeval {
        return Timeval{Sec: sec, Usec: usec}
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
index d389f1518faf0358ced16527de5d8cbac4560072..3b88044830184595d16ecabe21e2806e618ba887 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
@@ -115,7 +115,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
        cmsg.Len = uint64(length)
 }
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb        pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
@@ -128,7 +128,7 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
        if len(p) != 2 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
index 1e6843b4c3dacb31c5d25940da4fbe302e2be7c3..853d5f0f4365d6aff5f479a37769cb5c11e17482 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
@@ -110,7 +110,8 @@ func direntNamlen(buf []byte) (uint64, bool) {
        return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
 }
 
-//sysnb pipe() (fd1 int, fd2 int, err error)
+//sysnb        pipe() (fd1 int, fd2 int, err error)
+
 func Pipe(p []int) (err error) {
        if len(p) != 2 {
                return EINVAL
@@ -119,7 +120,21 @@ func Pipe(p []int) (err error) {
        return
 }
 
-//sys Getdents(fd int, buf []byte) (n int, err error)
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
+
+func Pipe2(p []int, flags int) error {
+       if len(p) != 2 {
+               return EINVAL
+       }
+       var pp [2]_C_int
+       err := pipe2(&pp, flags)
+       p[0] = int(pp[0])
+       p[1] = int(pp[1])
+       return err
+}
+
+//sys  Getdents(fd int, buf []byte) (n int, err error)
+
 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
        n, err = Getdents(fd, buf)
        if err != nil || basep == nil {
@@ -159,7 +174,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys  ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func IoctlGetPtmget(fd int, req uint) (*Ptmget, error) {
        var value Ptmget

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
index 6a50b50bd69247d8cb8d9d8b200bebbb17efc9c0..22b55038501f5f6e266dae89ca48d0a93d1c63c2 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
@@ -92,7 +92,7 @@ func Pipe2(p []int, flags int) error {
        return err
 }
 
-//sys Getdents(fd int, buf []byte) (n int, err error)
+//sys  Getdents(fd int, buf []byte) (n int, err error)
 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
        n, err = Getdents(fd, buf)
        if err != nil || basep == nil {
@@ -154,7 +154,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys  ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 //sys  ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error)
 

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
index fee6e995289112f5c3a688eee0d9a7ad4dd3e577..169497f0620e478d652fa58ba32ad55c298b6adc 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -68,6 +68,19 @@ func Pipe(p []int) (err error) {
        return nil
 }
 
+//sysnb        pipe2(p *[2]_C_int, flags int) (err error)
+
+func Pipe2(p []int, flags int) error {
+       if len(p) != 2 {
+               return EINVAL
+       }
+       var pp [2]_C_int
+       err := pipe2(&pp, flags)
+       p[0] = int(pp[0])
+       p[1] = int(pp[1])
+       return err
+}
+
 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
        if sa.Port < 0 || sa.Port > 0xFFFF {
                return nil, 0, EINVAL
@@ -566,7 +579,7 @@ func IoctlGetTermio(fd int, req uint) (*Termio, error) {
        return &value, err
 }
 
-//sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
+//sys  poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 
 func Poll(fds []PollFd, timeout int) (n int, err error) {
        if len(fds) == 0 {
@@ -669,6 +682,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys  Statvfs(path string, vfsstat *Statvfs_t) (err error)
 //sys  Symlink(path string, link string) (err error)
 //sys  Sync() (err error)
+//sys  Sysconf(which int) (n int64, err error)
 //sysnb        Times(tms *Tms) (ticks uintptr, err error)
 //sys  Truncate(path string, length int64) (err error)
 //sys  Fsync(fd int) (err error)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
index 4a672f56942abd067302123f5da066b038d79807..103604299e2a3d9942a069309734aa436e21e7db 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
@@ -8,12 +8,10 @@ package unix
 
 import "time"
 
-// TimespecToNsec converts a Timespec value into a number of
-// nanoseconds since the Unix epoch.
-func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
+// TimespecToNSec returns the time stored in ts as nanoseconds.
+func TimespecToNsec(ts Timespec) int64 { return ts.Nano() }
 
-// NsecToTimespec takes a number of nanoseconds since the Unix epoch
-// and returns the corresponding Timespec value.
+// NsecToTimespec converts a number of nanoseconds into a Timespec.
 func NsecToTimespec(nsec int64) Timespec {
        sec := nsec / 1e9
        nsec = nsec % 1e9
@@ -42,12 +40,10 @@ func TimeToTimespec(t time.Time) (Timespec, error) {
        return ts, nil
 }
 
-// TimevalToNsec converts a Timeval value into a number of nanoseconds
-// since the Unix epoch.
-func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
+// TimevalToNsec returns the time stored in tv as nanoseconds.
+func TimevalToNsec(tv Timeval) int64 { return tv.Nano() }
 
-// NsecToTimeval takes a number of nanoseconds since the Unix epoch
-// and returns the corresponding Timeval value.
+// NsecToTimeval converts a number of nanoseconds into a Timeval.
 func NsecToTimeval(nsec int64) Timeval {
        nsec += 999 // round up to microsecond
        usec := nsec % 1e9 / 1e3
@@ -59,24 +55,22 @@ func NsecToTimeval(nsec int64) Timeval {
        return setTimeval(sec, usec)
 }
 
-// Unix returns ts as the number of seconds and nanoseconds elapsed since the
-// Unix epoch.
+// Unix returns the time stored in ts as seconds plus nanoseconds.
 func (ts *Timespec) Unix() (sec int64, nsec int64) {
        return int64(ts.Sec), int64(ts.Nsec)
 }
 
-// Unix returns tv as the number of seconds and nanoseconds elapsed since the
-// Unix epoch.
+// Unix returns the time stored in tv as seconds plus nanoseconds.
 func (tv *Timeval) Unix() (sec int64, nsec int64) {
        return int64(tv.Sec), int64(tv.Usec) * 1000
 }
 
-// Nano returns ts as the number of nanoseconds elapsed since the Unix epoch.
+// Nano returns the time stored in ts as nanoseconds.
 func (ts *Timespec) Nano() int64 {
        return int64(ts.Sec)*1e9 + int64(ts.Nsec)
 }
 
-// Nano returns tv as the number of nanoseconds elapsed since the Unix epoch.
+// Nano returns the time stored in tv as nanoseconds.
 func (tv *Timeval) Nano() int64 {
        return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
 }

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index fea5dfaadb9b8936ac02c422798cd2feb46ccb43..dcb96c26c08cf524ab73f3ba151d649833016198 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -32,7 +32,7 @@ const (
        AF_LAT                            = 0xe
        AF_LINK                           = 0x12
        AF_LOCAL                          = 0x1
-       AF_MAX                            = 0x28
+       AF_MAX                            = 0x29
        AF_NATM                           = 0x1f
        AF_NDRV                           = 0x1b
        AF_NETBIOS                        = 0x21
@@ -49,6 +49,7 @@ const (
        AF_UNIX                           = 0x1
        AF_UNSPEC                         = 0x0
        AF_UTUN                           = 0x26
+       AF_VSOCK                          = 0x28
        ALTWERASE                         = 0x200
        ATTR_BIT_MAP_COUNT                = 0x5
        ATTR_CMN_ACCESSMASK               = 0x20000
@@ -83,7 +84,7 @@ const (
        ATTR_CMN_PAROBJID                 = 0x80
        ATTR_CMN_RETURNED_ATTRS           = 0x80000000
        ATTR_CMN_SCRIPT                   = 0x100
-       ATTR_CMN_SETMASK                  = 0x41c7ff00
+       ATTR_CMN_SETMASK                  = 0x51c7ff00
        ATTR_CMN_USERACCESS               = 0x200000
        ATTR_CMN_UUID                     = 0x800000
        ATTR_CMN_VALIDMASK                = 0xffffffff
@@ -357,7 +358,7 @@ const (
        DLT_LINUX_SLL                     = 0x71
        DLT_LOOP                          = 0x6c
        DLT_LTALK                         = 0x72
-       DLT_MATCHING_MAX                  = 0xf5
+       DLT_MATCHING_MAX                  = 0x10a
        DLT_MATCHING_MIN                  = 0x68
        DLT_MFR                           = 0xb6
        DLT_MOST                          = 0xd3
@@ -398,6 +399,7 @@ const (
        DLT_SYMANTEC_FIREWALL             = 0x63
        DLT_TZSP                          = 0x80
        DLT_USB                           = 0xba
+       DLT_USB_DARWIN                    = 0x10a
        DLT_USB_LINUX                     = 0xbd
        DLT_USB_LINUX_MMAPPED             = 0xdc
        DLT_USER0                         = 0x93
@@ -442,8 +444,8 @@ const (
        EVFILT_PROC                       = -0x5
        EVFILT_READ                       = -0x1
        EVFILT_SIGNAL                     = -0x6
-       EVFILT_SYSCOUNT                   = 0xf
-       EVFILT_THREADMARKER               = 0xf
+       EVFILT_SYSCOUNT                   = 0x11
+       EVFILT_THREADMARKER               = 0x11
        EVFILT_TIMER                      = -0x7
        EVFILT_USER                       = -0xa
        EVFILT_VM                         = -0xc
@@ -481,9 +483,12 @@ const (
        FSOPT_NOINMEMUPDATE               = 0x2
        FSOPT_PACK_INVAL_ATTRS            = 0x8
        FSOPT_REPORT_FULLSIZE             = 0x4
+       FSOPT_RETURN_REALDEV              = 0x200
        F_ADDFILESIGS                     = 0x3d
        F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
+       F_ADDFILESIGS_INFO                = 0x67
        F_ADDFILESIGS_RETURN              = 0x61
+       F_ADDFILESUPPL                    = 0x68
        F_ADDSIGS                         = 0x3b
        F_ALLOCATEALL                     = 0x4
        F_ALLOCATECONTIG                  = 0x2
@@ -505,8 +510,10 @@ const (
        F_GETOWN                          = 0x5
        F_GETPATH                         = 0x32
        F_GETPATH_MTMINFO                 = 0x47
+       F_GETPATH_NOFIRMLINK              = 0x66
        F_GETPROTECTIONCLASS              = 0x3f
        F_GETPROTECTIONLEVEL              = 0x4d
+       F_GETSIGSINFO                     = 0x69
        F_GLOBAL_NOCACHE                  = 0x37
        F_LOG2PHYS                        = 0x31
        F_LOG2PHYS_EXT                    = 0x41
@@ -531,6 +538,7 @@ const (
        F_SETPROTECTIONCLASS              = 0x40
        F_SETSIZE                         = 0x2b
        F_SINGLE_WRITER                   = 0x4c
+       F_SPECULATIVE_READ                = 0x65
        F_THAW_FS                         = 0x36
        F_TRANSCODEKEY                    = 0x4b
        F_TRIM_ACTIVE_FILE                = 0x64
@@ -562,6 +570,7 @@ const (
        IFF_UP                            = 0x1
        IFNAMSIZ                          = 0x10
        IFT_1822                          = 0x2
+       IFT_6LOWPAN                       = 0x40
        IFT_AAL5                          = 0x31
        IFT_ARCNET                        = 0x23
        IFT_ARCNETPLUS                    = 0x24
@@ -766,6 +775,9 @@ const (
        IPV6_2292PKTINFO                  = 0x13
        IPV6_2292PKTOPTIONS               = 0x19
        IPV6_2292RTHDR                    = 0x18
+       IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
+       IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
+       IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
        IPV6_BINDV6ONLY                   = 0x1b
        IPV6_BOUND_IF                     = 0x7d
        IPV6_CHECKSUM                     = 0x1a
@@ -775,7 +787,7 @@ const (
        IPV6_FAITH                        = 0x1d
        IPV6_FLOWINFO_MASK                = 0xffffff0f
        IPV6_FLOWLABEL_MASK               = 0xffff0f00
-       IPV6_FLOW_ECN_MASK                = 0x300
+       IPV6_FLOW_ECN_MASK                = 0x3000
        IPV6_FRAGTTL                      = 0x3c
        IPV6_FW_ADD                       = 0x1e
        IPV6_FW_DEL                       = 0x1f
@@ -818,6 +830,7 @@ const (
        IP_DEFAULT_MULTICAST_LOOP         = 0x1
        IP_DEFAULT_MULTICAST_TTL          = 0x1
        IP_DF                             = 0x4000
+       IP_DONTFRAG                       = 0x1c
        IP_DROP_MEMBERSHIP                = 0xd
        IP_DROP_SOURCE_MEMBERSHIP         = 0x47
        IP_DUMMYNET_CONFIGURE             = 0x3c
@@ -889,6 +902,12 @@ const (
        KERN_OSRELEASE                    = 0x2
        KERN_OSTYPE                       = 0x1
        KERN_VERSION                      = 0x4
+       LOCAL_PEERCRED                    = 0x1
+       LOCAL_PEEREPID                    = 0x3
+       LOCAL_PEEREUUID                   = 0x5
+       LOCAL_PEERPID                     = 0x2
+       LOCAL_PEERTOKEN                   = 0x6
+       LOCAL_PEERUUID                    = 0x4
        LOCK_EX                           = 0x2
        LOCK_NB                           = 0x4
        LOCK_SH                           = 0x1
@@ -904,6 +923,7 @@ const (
        MADV_SEQUENTIAL                   = 0x2
        MADV_WILLNEED                     = 0x3
        MADV_ZERO_WIRED_PAGES             = 0x6
+       MAP_32BIT                         = 0x8000
        MAP_ANON                          = 0x1000
        MAP_ANONYMOUS                     = 0x1000
        MAP_COPY                          = 0x2
@@ -920,6 +940,17 @@ const (
        MAP_RESILIENT_CODESIGN            = 0x2000
        MAP_RESILIENT_MEDIA               = 0x4000
        MAP_SHARED                        = 0x1
+       MAP_TRANSLATED_ALLOW_EXECUTE      = 0x20000
+       MAP_UNIX03                        = 0x40000
+       MCAST_BLOCK_SOURCE                = 0x54
+       MCAST_EXCLUDE                     = 0x2
+       MCAST_INCLUDE                     = 0x1
+       MCAST_JOIN_GROUP                  = 0x50
+       MCAST_JOIN_SOURCE_GROUP           = 0x52
+       MCAST_LEAVE_GROUP                 = 0x51
+       MCAST_LEAVE_SOURCE_GROUP          = 0x53
+       MCAST_UNBLOCK_SOURCE              = 0x55
+       MCAST_UNDEFINED                   = 0x0
        MCL_CURRENT                       = 0x1
        MCL_FUTURE                        = 0x2
        MNT_ASYNC                         = 0x40
@@ -931,6 +962,7 @@ const (
        MNT_DOVOLFS                       = 0x8000
        MNT_DWAIT                         = 0x4
        MNT_EXPORTED                      = 0x100
+       MNT_EXT_ROOT_DATA_VOL             = 0x1
        MNT_FORCE                         = 0x80000
        MNT_IGNORE_OWNERSHIP              = 0x200000
        MNT_JOURNALED                     = 0x800000
@@ -947,12 +979,15 @@ const (
        MNT_QUOTA                         = 0x2000
        MNT_RDONLY                        = 0x1
        MNT_RELOAD                        = 0x40000
+       MNT_REMOVABLE                     = 0x200
        MNT_ROOTFS                        = 0x4000
+       MNT_SNAPSHOT                      = 0x40000000
+       MNT_STRICTATIME                   = 0x80000000
        MNT_SYNCHRONOUS                   = 0x2
        MNT_UNION                         = 0x20
        MNT_UNKNOWNPERMISSIONS            = 0x200000
        MNT_UPDATE                        = 0x10000
-       MNT_VISFLAGMASK                   = 0x17f0f5ff
+       MNT_VISFLAGMASK                   = 0xd7f0f7ff
        MNT_WAIT                          = 0x1
        MSG_CTRUNC                        = 0x20
        MSG_DONTROUTE                     = 0x4
@@ -963,6 +998,7 @@ const (
        MSG_HAVEMORE                      = 0x2000
        MSG_HOLD                          = 0x800
        MSG_NEEDSA                        = 0x10000
+       MSG_NOSIGNAL                      = 0x80000
        MSG_OOB                           = 0x1
        MSG_PEEK                          = 0x2
        MSG_RCVMORE                       = 0x4000
@@ -979,9 +1015,10 @@ const (
        NET_RT_DUMP                       = 0x1
        NET_RT_DUMP2                      = 0x7
        NET_RT_FLAGS                      = 0x2
+       NET_RT_FLAGS_PRIV                 = 0xa
        NET_RT_IFLIST                     = 0x3
        NET_RT_IFLIST2                    = 0x6
-       NET_RT_MAXID                      = 0xa
+       NET_RT_MAXID                      = 0xb
        NET_RT_STAT                       = 0x4
        NET_RT_TRASH                      = 0x5
        NFDBITS                           = 0x20
@@ -1019,6 +1056,7 @@ const (
        NOTE_LEEWAY                       = 0x10
        NOTE_LINK                         = 0x10
        NOTE_LOWAT                        = 0x1
+       NOTE_MACHTIME                     = 0x100
        NOTE_MACH_CONTINUOUS_TIME         = 0x80
        NOTE_NONE                         = 0x80
        NOTE_NSECONDS                     = 0x4
@@ -1065,6 +1103,7 @@ const (
        O_NDELAY                          = 0x4
        O_NOCTTY                          = 0x20000
        O_NOFOLLOW                        = 0x100
+       O_NOFOLLOW_ANY                    = 0x20000000
        O_NONBLOCK                        = 0x4
        O_POPUP                           = 0x80000000
        O_RDONLY                          = 0x0
@@ -1136,6 +1175,7 @@ const (
        RTF_BROADCAST                     = 0x400000
        RTF_CLONING                       = 0x100
        RTF_CONDEMNED                     = 0x2000000
+       RTF_DEAD                          = 0x20000000
        RTF_DELCLONE                      = 0x80
        RTF_DONE                          = 0x40
        RTF_DYNAMIC                       = 0x10
@@ -1143,6 +1183,7 @@ const (
        RTF_HOST                          = 0x4
        RTF_IFREF                         = 0x4000000
        RTF_IFSCOPE                       = 0x1000000
+       RTF_LLDATA                        = 0x400
        RTF_LLINFO                        = 0x400
        RTF_LOCAL                         = 0x200000
        RTF_MODIFIED                      = 0x20
@@ -1210,6 +1251,7 @@ const (
        SIOCGDRVSPEC                      = 0xc028697b
        SIOCGETVLAN                       = 0xc020697f
        SIOCGHIWAT                        = 0x40047301
+       SIOCGIF6LOWPAN                    = 0xc02069c5
        SIOCGIFADDR                       = 0xc0206921
        SIOCGIFALTMTU                     = 0xc0206948
        SIOCGIFASYNCMAP                   = 0xc020697c
@@ -1220,6 +1262,7 @@ const (
        SIOCGIFDEVMTU                     = 0xc0206944
        SIOCGIFDSTADDR                    = 0xc0206922
        SIOCGIFFLAGS                      = 0xc0206911
+       SIOCGIFFUNCTIONALTYPE             = 0xc02069ad
        SIOCGIFGENERIC                    = 0xc020693a
        SIOCGIFKPI                        = 0xc0206987
        SIOCGIFMAC                        = 0xc0206982
@@ -1233,6 +1276,7 @@ const (
        SIOCGIFSTATUS                     = 0xc331693d
        SIOCGIFVLAN                       = 0xc020697f
        SIOCGIFWAKEFLAGS                  = 0xc0206988
+       SIOCGIFXMEDIA                     = 0xc02c6948
        SIOCGLOWAT                        = 0x40047303
        SIOCGPGRP                         = 0x40047309
        SIOCIFCREATE                      = 0xc0206978
@@ -1243,6 +1287,7 @@ const (
        SIOCSDRVSPEC                      = 0x8028697b
        SIOCSETVLAN                       = 0x8020697e
        SIOCSHIWAT                        = 0x80047300
+       SIOCSIF6LOWPAN                    = 0x802069c4
        SIOCSIFADDR                       = 0x8020690c
        SIOCSIFALTMTU                     = 0x80206945
        SIOCSIFASYNCMAP                   = 0x8020697d
@@ -1270,6 +1315,7 @@ const (
        SOCK_RDM                          = 0x4
        SOCK_SEQPACKET                    = 0x5
        SOCK_STREAM                       = 0x1
+       SOL_LOCAL                         = 0x0
        SOL_SOCKET                        = 0xffff
        SOMAXCONN                         = 0x80
        SO_ACCEPTCONN                     = 0x2

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index b40fb1f69675f22ba4ca795c6de7dd0f929efbe5..8602b136332293461d828c0d85f5bae6055aad45 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -32,7 +32,7 @@ const (
        AF_LAT                            = 0xe
        AF_LINK                           = 0x12
        AF_LOCAL                          = 0x1
-       AF_MAX                            = 0x28
+       AF_MAX                            = 0x29
        AF_NATM                           = 0x1f
        AF_NDRV                           = 0x1b
        AF_NETBIOS                        = 0x21
@@ -49,6 +49,7 @@ const (
        AF_UNIX                           = 0x1
        AF_UNSPEC                         = 0x0
        AF_UTUN                           = 0x26
+       AF_VSOCK                          = 0x28
        ALTWERASE                         = 0x200
        ATTR_BIT_MAP_COUNT                = 0x5
        ATTR_CMN_ACCESSMASK               = 0x20000
@@ -83,7 +84,7 @@ const (
        ATTR_CMN_PAROBJID                 = 0x80
        ATTR_CMN_RETURNED_ATTRS           = 0x80000000
        ATTR_CMN_SCRIPT                   = 0x100
-       ATTR_CMN_SETMASK                  = 0x41c7ff00
+       ATTR_CMN_SETMASK                  = 0x51c7ff00
        ATTR_CMN_USERACCESS               = 0x200000
        ATTR_CMN_UUID                     = 0x800000
        ATTR_CMN_VALIDMASK                = 0xffffffff
@@ -357,7 +358,7 @@ const (
        DLT_LINUX_SLL                     = 0x71
        DLT_LOOP                          = 0x6c
        DLT_LTALK                         = 0x72
-       DLT_MATCHING_MAX                  = 0xf5
+       DLT_MATCHING_MAX                  = 0x10a
        DLT_MATCHING_MIN                  = 0x68
        DLT_MFR                           = 0xb6
        DLT_MOST                          = 0xd3
@@ -398,6 +399,7 @@ const (
        DLT_SYMANTEC_FIREWALL             = 0x63
        DLT_TZSP                          = 0x80
        DLT_USB                           = 0xba
+       DLT_USB_DARWIN                    = 0x10a
        DLT_USB_LINUX                     = 0xbd
        DLT_USB_LINUX_MMAPPED             = 0xdc
        DLT_USER0                         = 0x93
@@ -442,8 +444,8 @@ const (
        EVFILT_PROC                       = -0x5
        EVFILT_READ                       = -0x1
        EVFILT_SIGNAL                     = -0x6
-       EVFILT_SYSCOUNT                   = 0xf
-       EVFILT_THREADMARKER               = 0xf
+       EVFILT_SYSCOUNT                   = 0x11
+       EVFILT_THREADMARKER               = 0x11
        EVFILT_TIMER                      = -0x7
        EVFILT_USER                       = -0xa
        EVFILT_VM                         = -0xc
@@ -481,9 +483,12 @@ const (
        FSOPT_NOINMEMUPDATE               = 0x2
        FSOPT_PACK_INVAL_ATTRS            = 0x8
        FSOPT_REPORT_FULLSIZE             = 0x4
+       FSOPT_RETURN_REALDEV              = 0x200
        F_ADDFILESIGS                     = 0x3d
        F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
+       F_ADDFILESIGS_INFO                = 0x67
        F_ADDFILESIGS_RETURN              = 0x61
+       F_ADDFILESUPPL                    = 0x68
        F_ADDSIGS                         = 0x3b
        F_ALLOCATEALL                     = 0x4
        F_ALLOCATECONTIG                  = 0x2
@@ -505,8 +510,10 @@ const (
        F_GETOWN                          = 0x5
        F_GETPATH                         = 0x32
        F_GETPATH_MTMINFO                 = 0x47
+       F_GETPATH_NOFIRMLINK              = 0x66
        F_GETPROTECTIONCLASS              = 0x3f
        F_GETPROTECTIONLEVEL              = 0x4d
+       F_GETSIGSINFO                     = 0x69
        F_GLOBAL_NOCACHE                  = 0x37
        F_LOG2PHYS                        = 0x31
        F_LOG2PHYS_EXT                    = 0x41
@@ -531,6 +538,7 @@ const (
        F_SETPROTECTIONCLASS              = 0x40
        F_SETSIZE                         = 0x2b
        F_SINGLE_WRITER                   = 0x4c
+       F_SPECULATIVE_READ                = 0x65
        F_THAW_FS                         = 0x36
        F_TRANSCODEKEY                    = 0x4b
        F_TRIM_ACTIVE_FILE                = 0x64
@@ -562,6 +570,7 @@ const (
        IFF_UP                            = 0x1
        IFNAMSIZ                          = 0x10
        IFT_1822                          = 0x2
+       IFT_6LOWPAN                       = 0x40
        IFT_AAL5                          = 0x31
        IFT_ARCNET                        = 0x23
        IFT_ARCNETPLUS                    = 0x24
@@ -766,6 +775,9 @@ const (
        IPV6_2292PKTINFO                  = 0x13
        IPV6_2292PKTOPTIONS               = 0x19
        IPV6_2292RTHDR                    = 0x18
+       IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
+       IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
+       IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
        IPV6_BINDV6ONLY                   = 0x1b
        IPV6_BOUND_IF                     = 0x7d
        IPV6_CHECKSUM                     = 0x1a
@@ -775,7 +787,7 @@ const (
        IPV6_FAITH                        = 0x1d
        IPV6_FLOWINFO_MASK                = 0xffffff0f
        IPV6_FLOWLABEL_MASK               = 0xffff0f00
-       IPV6_FLOW_ECN_MASK                = 0x300
+       IPV6_FLOW_ECN_MASK                = 0x3000
        IPV6_FRAGTTL                      = 0x3c
        IPV6_FW_ADD                       = 0x1e
        IPV6_FW_DEL                       = 0x1f
@@ -818,6 +830,7 @@ const (
        IP_DEFAULT_MULTICAST_LOOP         = 0x1
        IP_DEFAULT_MULTICAST_TTL          = 0x1
        IP_DF                             = 0x4000
+       IP_DONTFRAG                       = 0x1c
        IP_DROP_MEMBERSHIP                = 0xd
        IP_DROP_SOURCE_MEMBERSHIP         = 0x47
        IP_DUMMYNET_CONFIGURE             = 0x3c
@@ -889,6 +902,12 @@ const (
        KERN_OSRELEASE                    = 0x2
        KERN_OSTYPE                       = 0x1
        KERN_VERSION                      = 0x4
+       LOCAL_PEERCRED                    = 0x1
+       LOCAL_PEEREPID                    = 0x3
+       LOCAL_PEEREUUID                   = 0x5
+       LOCAL_PEERPID                     = 0x2
+       LOCAL_PEERTOKEN                   = 0x6
+       LOCAL_PEERUUID                    = 0x4
        LOCK_EX                           = 0x2
        LOCK_NB                           = 0x4
        LOCK_SH                           = 0x1
@@ -904,6 +923,7 @@ const (
        MADV_SEQUENTIAL                   = 0x2
        MADV_WILLNEED                     = 0x3
        MADV_ZERO_WIRED_PAGES             = 0x6
+       MAP_32BIT                         = 0x8000
        MAP_ANON                          = 0x1000
        MAP_ANONYMOUS                     = 0x1000
        MAP_COPY                          = 0x2
@@ -920,6 +940,17 @@ const (
        MAP_RESILIENT_CODESIGN            = 0x2000
        MAP_RESILIENT_MEDIA               = 0x4000
        MAP_SHARED                        = 0x1
+       MAP_TRANSLATED_ALLOW_EXECUTE      = 0x20000
+       MAP_UNIX03                        = 0x40000
+       MCAST_BLOCK_SOURCE                = 0x54
+       MCAST_EXCLUDE                     = 0x2
+       MCAST_INCLUDE                     = 0x1
+       MCAST_JOIN_GROUP                  = 0x50
+       MCAST_JOIN_SOURCE_GROUP           = 0x52
+       MCAST_LEAVE_GROUP                 = 0x51
+       MCAST_LEAVE_SOURCE_GROUP          = 0x53
+       MCAST_UNBLOCK_SOURCE              = 0x55
+       MCAST_UNDEFINED                   = 0x0
        MCL_CURRENT                       = 0x1
        MCL_FUTURE                        = 0x2
        MNT_ASYNC                         = 0x40
@@ -931,6 +962,7 @@ const (
        MNT_DOVOLFS                       = 0x8000
        MNT_DWAIT                         = 0x4
        MNT_EXPORTED                      = 0x100
+       MNT_EXT_ROOT_DATA_VOL             = 0x1
        MNT_FORCE                         = 0x80000
        MNT_IGNORE_OWNERSHIP              = 0x200000
        MNT_JOURNALED                     = 0x800000
@@ -947,12 +979,15 @@ const (
        MNT_QUOTA                         = 0x2000
        MNT_RDONLY                        = 0x1
        MNT_RELOAD                        = 0x40000
+       MNT_REMOVABLE                     = 0x200
        MNT_ROOTFS                        = 0x4000
+       MNT_SNAPSHOT                      = 0x40000000
+       MNT_STRICTATIME                   = 0x80000000
        MNT_SYNCHRONOUS                   = 0x2
        MNT_UNION                         = 0x20
        MNT_UNKNOWNPERMISSIONS            = 0x200000
        MNT_UPDATE                        = 0x10000
-       MNT_VISFLAGMASK                   = 0x17f0f5ff
+       MNT_VISFLAGMASK                   = 0xd7f0f7ff
        MNT_WAIT                          = 0x1
        MSG_CTRUNC                        = 0x20
        MSG_DONTROUTE                     = 0x4
@@ -963,6 +998,7 @@ const (
        MSG_HAVEMORE                      = 0x2000
        MSG_HOLD                          = 0x800
        MSG_NEEDSA                        = 0x10000
+       MSG_NOSIGNAL                      = 0x80000
        MSG_OOB                           = 0x1
        MSG_PEEK                          = 0x2
        MSG_RCVMORE                       = 0x4000
@@ -979,9 +1015,10 @@ const (
        NET_RT_DUMP                       = 0x1
        NET_RT_DUMP2                      = 0x7
        NET_RT_FLAGS                      = 0x2
+       NET_RT_FLAGS_PRIV                 = 0xa
        NET_RT_IFLIST                     = 0x3
        NET_RT_IFLIST2                    = 0x6
-       NET_RT_MAXID                      = 0xa
+       NET_RT_MAXID                      = 0xb
        NET_RT_STAT                       = 0x4
        NET_RT_TRASH                      = 0x5
        NFDBITS                           = 0x20
@@ -1019,6 +1056,7 @@ const (
        NOTE_LEEWAY                       = 0x10
        NOTE_LINK                         = 0x10
        NOTE_LOWAT                        = 0x1
+       NOTE_MACHTIME                     = 0x100
        NOTE_MACH_CONTINUOUS_TIME         = 0x80
        NOTE_NONE                         = 0x80
        NOTE_NSECONDS                     = 0x4
@@ -1065,6 +1103,7 @@ const (
        O_NDELAY                          = 0x4
        O_NOCTTY                          = 0x20000
        O_NOFOLLOW                        = 0x100
+       O_NOFOLLOW_ANY                    = 0x20000000
        O_NONBLOCK                        = 0x4
        O_POPUP                           = 0x80000000
        O_RDONLY                          = 0x0
@@ -1136,6 +1175,7 @@ const (
        RTF_BROADCAST                     = 0x400000
        RTF_CLONING                       = 0x100
        RTF_CONDEMNED                     = 0x2000000
+       RTF_DEAD                          = 0x20000000
        RTF_DELCLONE                      = 0x80
        RTF_DONE                          = 0x40
        RTF_DYNAMIC                       = 0x10
@@ -1143,6 +1183,7 @@ const (
        RTF_HOST                          = 0x4
        RTF_IFREF                         = 0x4000000
        RTF_IFSCOPE                       = 0x1000000
+       RTF_LLDATA                        = 0x400
        RTF_LLINFO                        = 0x400
        RTF_LOCAL                         = 0x200000
        RTF_MODIFIED                      = 0x20
@@ -1210,6 +1251,7 @@ const (
        SIOCGDRVSPEC                      = 0xc028697b
        SIOCGETVLAN                       = 0xc020697f
        SIOCGHIWAT                        = 0x40047301
+       SIOCGIF6LOWPAN                    = 0xc02069c5
        SIOCGIFADDR                       = 0xc0206921
        SIOCGIFALTMTU                     = 0xc0206948
        SIOCGIFASYNCMAP                   = 0xc020697c
@@ -1220,6 +1262,7 @@ const (
        SIOCGIFDEVMTU                     = 0xc0206944
        SIOCGIFDSTADDR                    = 0xc0206922
        SIOCGIFFLAGS                      = 0xc0206911
+       SIOCGIFFUNCTIONALTYPE             = 0xc02069ad
        SIOCGIFGENERIC                    = 0xc020693a
        SIOCGIFKPI                        = 0xc0206987
        SIOCGIFMAC                        = 0xc0206982
@@ -1233,6 +1276,7 @@ const (
        SIOCGIFSTATUS                     = 0xc331693d
        SIOCGIFVLAN                       = 0xc020697f
        SIOCGIFWAKEFLAGS                  = 0xc0206988
+       SIOCGIFXMEDIA                     = 0xc02c6948
        SIOCGLOWAT                        = 0x40047303
        SIOCGPGRP                         = 0x40047309
        SIOCIFCREATE                      = 0xc0206978
@@ -1243,6 +1287,7 @@ const (
        SIOCSDRVSPEC                      = 0x8028697b
        SIOCSETVLAN                       = 0x8020697e
        SIOCSHIWAT                        = 0x80047300
+       SIOCSIF6LOWPAN                    = 0x802069c4
        SIOCSIFADDR                       = 0x8020690c
        SIOCSIFALTMTU                     = 0x80206945
        SIOCSIFASYNCMAP                   = 0x8020697d
@@ -1270,6 +1315,7 @@ const (
        SOCK_RDM                          = 0x4
        SOCK_SEQPACKET                    = 0x5
        SOCK_STREAM                       = 0x1
+       SOL_LOCAL                         = 0x0
        SOL_SOCKET                        = 0xffff
        SOMAXCONN                         = 0x80
        SO_ACCEPTCONN                     = 0x2

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
index b46110354dfbe992cf96a4a40c8da7ffcaeaa5fc..c5e2f4793040112f772d28490bc67997b70119dd 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -65,6 +65,7 @@ const (
        ALG_OP_ENCRYPT                              = 0x1
        ALG_SET_AEAD_ASSOCLEN                       = 0x4
        ALG_SET_AEAD_AUTHSIZE                       = 0x5
+       ALG_SET_DRBG_ENTROPY                        = 0x6
        ALG_SET_IV                                  = 0x2
        ALG_SET_KEY                                 = 0x1
        ALG_SET_OP                                  = 0x3
@@ -179,8 +180,10 @@ const (
        BPF_F_ANY_ALIGNMENT                         = 0x2
        BPF_F_QUERY_EFFECTIVE                       = 0x1
        BPF_F_REPLACE                               = 0x4
+       BPF_F_SLEEPABLE                             = 0x10
        BPF_F_STRICT_ALIGNMENT                      = 0x1
        BPF_F_TEST_RND_HI32                         = 0x4
+       BPF_F_TEST_RUN_ON_CPU                       = 0x1
        BPF_F_TEST_STATE_FREQ                       = 0x8
        BPF_H                                       = 0x8
        BPF_IMM                                     = 0x0
@@ -219,6 +222,7 @@ const (
        BPF_NET_OFF                                 = -0x100000
        BPF_OBJ_NAME_LEN                            = 0x10
        BPF_OR                                      = 0x40
+       BPF_PSEUDO_BTF_ID                           = 0x3
        BPF_PSEUDO_CALL                             = 0x1
        BPF_PSEUDO_MAP_FD                           = 0x1
        BPF_PSEUDO_MAP_VALUE                        = 0x2
@@ -309,6 +313,7 @@ const (
        CAN_J1939                                   = 0x7
        CAN_MAX_DLC                                 = 0x8
        CAN_MAX_DLEN                                = 0x8
+       CAN_MAX_RAW_DLC                             = 0xf
        CAN_MCNET                                   = 0x5
        CAN_MTU                                     = 0x10
        CAN_NPROTO                                  = 0x8
@@ -429,10 +434,13 @@ const (
        DEBUGFS_MAGIC                               = 0x64626720
        DEVLINK_CMD_ESWITCH_MODE_GET                = 0x1d
        DEVLINK_CMD_ESWITCH_MODE_SET                = 0x1e
+       DEVLINK_FLASH_OVERWRITE_IDENTIFIERS         = 0x2
+       DEVLINK_FLASH_OVERWRITE_SETTINGS            = 0x1
        DEVLINK_GENL_MCGRP_CONFIG_NAME              = "config"
        DEVLINK_GENL_NAME                           = "devlink"
        DEVLINK_GENL_VERSION                        = 0x1
        DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX           = 0x14
+       DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS  = 0x3
        DEVMEM_MAGIC                                = 0x454d444d
        DEVPTS_SUPER_MAGIC                          = 0x1cd1
        DMA_BUF_MAGIC                               = 0x444d4142
@@ -477,9 +485,9 @@ const (
        DM_UUID_FLAG                                = 0x4000
        DM_UUID_LEN                                 = 0x81
        DM_VERSION                                  = 0xc138fd00
-       DM_VERSION_EXTRA                            = "-ioctl (2020-02-27)"
+       DM_VERSION_EXTRA                            = "-ioctl (2020-10-01)"
        DM_VERSION_MAJOR                            = 0x4
-       DM_VERSION_MINOR                            = 0x2a
+       DM_VERSION_MINOR                            = 0x2b
        DM_VERSION_PATCHLEVEL                       = 0x0
        DT_BLK                                      = 0x6
        DT_CHR                                      = 0x2
@@ -520,6 +528,119 @@ const (
        EPOLL_CTL_DEL                               = 0x2
        EPOLL_CTL_MOD                               = 0x3
        EROFS_SUPER_MAGIC_V1                        = 0xe0f5e1e2
+       ESP_V4_FLOW                                 = 0xa
+       ESP_V6_FLOW                                 = 0xc
+       ETHER_FLOW                                  = 0x12
+       ETHTOOL_BUSINFO_LEN                         = 0x20
+       ETHTOOL_EROMVERS_LEN                        = 0x20
+       ETHTOOL_FEC_AUTO                            = 0x2
+       ETHTOOL_FEC_BASER                           = 0x10
+       ETHTOOL_FEC_LLRS                            = 0x20
+       ETHTOOL_FEC_NONE                            = 0x1
+       ETHTOOL_FEC_OFF                             = 0x4
+       ETHTOOL_FEC_RS                              = 0x8
+       ETHTOOL_FLAG_ALL                            = 0x7
+       ETHTOOL_FLAG_COMPACT_BITSETS                = 0x1
+       ETHTOOL_FLAG_OMIT_REPLY                     = 0x2
+       ETHTOOL_FLAG_STATS                          = 0x4
+       ETHTOOL_FLASHDEV                            = 0x33
+       ETHTOOL_FLASH_MAX_FILENAME                  = 0x80
+       ETHTOOL_FWVERS_LEN                          = 0x20
+       ETHTOOL_F_COMPAT                            = 0x4
+       ETHTOOL_F_UNSUPPORTED                       = 0x1
+       ETHTOOL_F_WISH                              = 0x2
+       ETHTOOL_GCHANNELS                           = 0x3c
+       ETHTOOL_GCOALESCE                           = 0xe
+       ETHTOOL_GDRVINFO                            = 0x3
+       ETHTOOL_GEEE                                = 0x44
+       ETHTOOL_GEEPROM                             = 0xb
+       ETHTOOL_GENL_NAME                           = "ethtool"
+       ETHTOOL_GENL_VERSION                        = 0x1
+       ETHTOOL_GET_DUMP_DATA                       = 0x40
+       ETHTOOL_GET_DUMP_FLAG                       = 0x3f
+       ETHTOOL_GET_TS_INFO                         = 0x41
+       ETHTOOL_GFEATURES                           = 0x3a
+       ETHTOOL_GFECPARAM                           = 0x50
+       ETHTOOL_GFLAGS                              = 0x25
+       ETHTOOL_GGRO                                = 0x2b
+       ETHTOOL_GGSO                                = 0x23
+       ETHTOOL_GLINK                               = 0xa
+       ETHTOOL_GLINKSETTINGS                       = 0x4c
+       ETHTOOL_GMODULEEEPROM                       = 0x43
+       ETHTOOL_GMODULEINFO                         = 0x42
+       ETHTOOL_GMSGLVL                             = 0x7
+       ETHTOOL_GPAUSEPARAM                         = 0x12
+       ETHTOOL_GPERMADDR                           = 0x20
+       ETHTOOL_GPFLAGS                             = 0x27
+       ETHTOOL_GPHYSTATS                           = 0x4a
+       ETHTOOL_GREGS                               = 0x4
+       ETHTOOL_GRINGPARAM                          = 0x10
+       ETHTOOL_GRSSH                               = 0x46
+       ETHTOOL_GRXCLSRLALL                         = 0x30
+       ETHTOOL_GRXCLSRLCNT                         = 0x2e
+       ETHTOOL_GRXCLSRULE                          = 0x2f
+       ETHTOOL_GRXCSUM                             = 0x14
+       ETHTOOL_GRXFH                               = 0x29
+       ETHTOOL_GRXFHINDIR                          = 0x38
+       ETHTOOL_GRXNTUPLE                           = 0x36
+       ETHTOOL_GRXRINGS                            = 0x2d
+       ETHTOOL_GSET                                = 0x1
+       ETHTOOL_GSG                                 = 0x18
+       ETHTOOL_GSSET_INFO                          = 0x37
+       ETHTOOL_GSTATS                              = 0x1d
+       ETHTOOL_GSTRINGS                            = 0x1b
+       ETHTOOL_GTSO                                = 0x1e
+       ETHTOOL_GTUNABLE                            = 0x48
+       ETHTOOL_GTXCSUM                             = 0x16
+       ETHTOOL_GUFO                                = 0x21
+       ETHTOOL_GWOL                                = 0x5
+       ETHTOOL_MCGRP_MONITOR_NAME                  = "monitor"
+       ETHTOOL_NWAY_RST                            = 0x9
+       ETHTOOL_PERQUEUE                            = 0x4b
+       ETHTOOL_PHYS_ID                             = 0x1c
+       ETHTOOL_PHY_EDPD_DFLT_TX_MSECS              = 0xffff
+       ETHTOOL_PHY_EDPD_DISABLE                    = 0x0
+       ETHTOOL_PHY_EDPD_NO_TX                      = 0xfffe
+       ETHTOOL_PHY_FAST_LINK_DOWN_OFF              = 0xff
+       ETHTOOL_PHY_FAST_LINK_DOWN_ON               = 0x0
+       ETHTOOL_PHY_GTUNABLE                        = 0x4e
+       ETHTOOL_PHY_STUNABLE                        = 0x4f
+       ETHTOOL_RESET                               = 0x34
+       ETHTOOL_RXNTUPLE_ACTION_CLEAR               = -0x2
+       ETHTOOL_RXNTUPLE_ACTION_DROP                = -0x1
+       ETHTOOL_RX_FLOW_SPEC_RING                   = 0xffffffff
+       ETHTOOL_RX_FLOW_SPEC_RING_VF                = 0xff00000000
+       ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF            = 0x20
+       ETHTOOL_SCHANNELS                           = 0x3d
+       ETHTOOL_SCOALESCE                           = 0xf
+       ETHTOOL_SEEE                                = 0x45
+       ETHTOOL_SEEPROM                             = 0xc
+       ETHTOOL_SET_DUMP                            = 0x3e
+       ETHTOOL_SFEATURES                           = 0x3b
+       ETHTOOL_SFECPARAM                           = 0x51
+       ETHTOOL_SFLAGS                              = 0x26
+       ETHTOOL_SGRO                                = 0x2c
+       ETHTOOL_SGSO                                = 0x24
+       ETHTOOL_SLINKSETTINGS                       = 0x4d
+       ETHTOOL_SMSGLVL                             = 0x8
+       ETHTOOL_SPAUSEPARAM                         = 0x13
+       ETHTOOL_SPFLAGS                             = 0x28
+       ETHTOOL_SRINGPARAM                          = 0x11
+       ETHTOOL_SRSSH                               = 0x47
+       ETHTOOL_SRXCLSRLDEL                         = 0x31
+       ETHTOOL_SRXCLSRLINS                         = 0x32
+       ETHTOOL_SRXCSUM                             = 0x15
+       ETHTOOL_SRXFH                               = 0x2a
+       ETHTOOL_SRXFHINDIR                          = 0x39
+       ETHTOOL_SRXNTUPLE                           = 0x35
+       ETHTOOL_SSET                                = 0x2
+       ETHTOOL_SSG                                 = 0x19
+       ETHTOOL_STSO                                = 0x1f
+       ETHTOOL_STUNABLE                            = 0x49
+       ETHTOOL_STXCSUM                             = 0x17
+       ETHTOOL_SUFO                                = 0x22
+       ETHTOOL_SWOL                                = 0x6
+       ETHTOOL_TEST                                = 0x1a
        ETH_P_1588                                  = 0x88f7
        ETH_P_8021AD                                = 0x88a8
        ETH_P_8021AH                                = 0x88e7
@@ -544,6 +665,7 @@ const (
        ETH_P_CAIF                                  = 0xf7
        ETH_P_CAN                                   = 0xc
        ETH_P_CANFD                                 = 0xd
+       ETH_P_CFM                                   = 0x8902
        ETH_P_CONTROL                               = 0x16
        ETH_P_CUST                                  = 0x6006
        ETH_P_DDCMP                                 = 0x6
@@ -714,7 +836,6 @@ const (
        FSCRYPT_POLICY_FLAGS_PAD_4                  = 0x0
        FSCRYPT_POLICY_FLAGS_PAD_8                  = 0x1
        FSCRYPT_POLICY_FLAGS_PAD_MASK               = 0x3
-       FSCRYPT_POLICY_FLAGS_VALID                  = 0x1f
        FSCRYPT_POLICY_FLAG_DIRECT_KEY              = 0x4
        FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32          = 0x10
        FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64          = 0x8
@@ -745,7 +866,7 @@ const (
        FS_POLICY_FLAGS_PAD_4                       = 0x0
        FS_POLICY_FLAGS_PAD_8                       = 0x1
        FS_POLICY_FLAGS_PAD_MASK                    = 0x3
-       FS_POLICY_FLAGS_VALID                       = 0x1f
+       FS_POLICY_FLAGS_VALID                       = 0x7
        FS_VERITY_FL                                = 0x100000
        FS_VERITY_HASH_ALG_SHA256                   = 0x1
        FS_VERITY_HASH_ALG_SHA512                   = 0x2
@@ -989,6 +1110,7 @@ const (
        IPV6_DONTFRAG                               = 0x3e
        IPV6_DROP_MEMBERSHIP                        = 0x15
        IPV6_DSTOPTS                                = 0x3b
+       IPV6_FLOW                                   = 0x11
        IPV6_FREEBIND                               = 0x4e
        IPV6_HDRINCL                                = 0x24
        IPV6_HOPLIMIT                               = 0x34
@@ -1017,6 +1139,7 @@ const (
        IPV6_PMTUDISC_WANT                          = 0x1
        IPV6_RECVDSTOPTS                            = 0x3a
        IPV6_RECVERR                                = 0x19
+       IPV6_RECVERR_RFC4884                        = 0x1f
        IPV6_RECVFRAGSIZE                           = 0x4d
        IPV6_RECVHOPLIMIT                           = 0x33
        IPV6_RECVHOPOPTS                            = 0x35
@@ -1038,6 +1161,7 @@ const (
        IPV6_TRANSPARENT                            = 0x4b
        IPV6_UNICAST_HOPS                           = 0x10
        IPV6_UNICAST_IF                             = 0x4c
+       IPV6_USER_FLOW                              = 0xe
        IPV6_V6ONLY                                 = 0x1a
        IPV6_XFRM_POLICY                            = 0x23
        IP_ADD_MEMBERSHIP                           = 0x23
@@ -1080,6 +1204,7 @@ const (
        IP_PMTUDISC_PROBE                           = 0x3
        IP_PMTUDISC_WANT                            = 0x1
        IP_RECVERR                                  = 0xb
+       IP_RECVERR_RFC4884                          = 0x1a
        IP_RECVFRAGSIZE                             = 0x19
        IP_RECVOPTS                                 = 0x6
        IP_RECVORIGDSTADDR                          = 0x14
@@ -1094,6 +1219,7 @@ const (
        IP_TTL                                      = 0x2
        IP_UNBLOCK_SOURCE                           = 0x25
        IP_UNICAST_IF                               = 0x32
+       IP_USER_FLOW                                = 0xd
        IP_XFRM_POLICY                              = 0x11
        ISOFS_SUPER_MAGIC                           = 0x9660
        ISTRIP                                      = 0x20
@@ -1331,6 +1457,7 @@ const (
        MS_NOREMOTELOCK                             = 0x8000000
        MS_NOSEC                                    = 0x10000000
        MS_NOSUID                                   = 0x2
+       MS_NOSYMFOLLOW                              = 0x100
        MS_NOUSER                                   = -0x80000000
        MS_POSIXACL                                 = 0x10000
        MS_PRIVATE                                  = 0x40000
@@ -1572,7 +1699,7 @@ const (
        PERF_MEM_REMOTE_REMOTE                      = 0x1
        PERF_MEM_REMOTE_SHIFT                       = 0x25
        PERF_MEM_SNOOPX_FWD                         = 0x1
-       PERF_MEM_SNOOPX_SHIFT                       = 0x25
+       PERF_MEM_SNOOPX_SHIFT                       = 0x26
        PERF_MEM_SNOOP_HIT                          = 0x4
        PERF_MEM_SNOOP_HITM                         = 0x10
        PERF_MEM_SNOOP_MISS                         = 0x8
@@ -1672,6 +1799,13 @@ const (
        PR_MCE_KILL_SET                             = 0x1
        PR_MPX_DISABLE_MANAGEMENT                   = 0x2c
        PR_MPX_ENABLE_MANAGEMENT                    = 0x2b
+       PR_MTE_TAG_MASK                             = 0x7fff8
+       PR_MTE_TAG_SHIFT                            = 0x3
+       PR_MTE_TCF_ASYNC                            = 0x4
+       PR_MTE_TCF_MASK                             = 0x6
+       PR_MTE_TCF_NONE                             = 0x0
+       PR_MTE_TCF_SHIFT                            = 0x1
+       PR_MTE_TCF_SYNC                             = 0x2
        PR_PAC_APDAKEY                              = 0x4
        PR_PAC_APDBKEY                              = 0x8
        PR_PAC_APGAKEY                              = 0x10
@@ -1709,6 +1843,7 @@ const (
        PR_SET_SECCOMP                              = 0x16
        PR_SET_SECUREBITS                           = 0x1c
        PR_SET_SPECULATION_CTRL                     = 0x35
+       PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
        PR_SET_TAGGED_ADDR_CTRL                     = 0x37
        PR_SET_THP_DISABLE                          = 0x29
        PR_SET_TIMERSLACK                           = 0x1d
@@ -1728,6 +1863,8 @@ const (
        PR_SVE_SET_VL_ONEXEC                        = 0x40000
        PR_SVE_VL_INHERIT                           = 0x20000
        PR_SVE_VL_LEN_MASK                          = 0xffff
+       PR_SYS_DISPATCH_OFF                         = 0x0
+       PR_SYS_DISPATCH_ON                          = 0x1
        PR_TAGGED_ADDR_ENABLE                       = 0x1
        PR_TASK_PERF_EVENTS_DISABLE                 = 0x1f
        PR_TASK_PERF_EVENTS_ENABLE                  = 0x20
@@ -1973,12 +2110,13 @@ const (
        RTM_SETLINK                                 = 0x13
        RTM_SETNEIGHTBL                             = 0x43
        RTNH_ALIGNTO                                = 0x4
-       RTNH_COMPARE_MASK                           = 0x19
+       RTNH_COMPARE_MASK                           = 0x59
        RTNH_F_DEAD                                 = 0x1
        RTNH_F_LINKDOWN                             = 0x10
        RTNH_F_OFFLOAD                              = 0x8
        RTNH_F_ONLINK                               = 0x4
        RTNH_F_PERVASIVE                            = 0x2
+       RTNH_F_TRAP                                 = 0x40
        RTNH_F_UNRESOLVED                           = 0x20
        RTN_MAX                                     = 0xb
        RTPROT_BABEL                                = 0x2a
@@ -2206,7 +2344,7 @@ const (
        STATX_ATTR_APPEND                           = 0x20
        STATX_ATTR_AUTOMOUNT                        = 0x1000
        STATX_ATTR_COMPRESSED                       = 0x4
-       STATX_ATTR_DAX                              = 0x2000
+       STATX_ATTR_DAX                              = 0x200000
        STATX_ATTR_ENCRYPTED                        = 0x800
        STATX_ATTR_IMMUTABLE                        = 0x10
        STATX_ATTR_MOUNT_ROOT                       = 0x2000
@@ -2325,6 +2463,8 @@ const (
        TCP_TX_DELAY                                = 0x25
        TCP_ULP                                     = 0x1f
        TCP_USER_TIMEOUT                            = 0x12
+       TCP_V4_FLOW                                 = 0x1
+       TCP_V6_FLOW                                 = 0x5
        TCP_WINDOW_CLAMP                            = 0xa
        TCP_ZEROCOPY_RECEIVE                        = 0x23
        TFD_TIMER_ABSTIME                           = 0x1
@@ -2390,6 +2530,7 @@ const (
        TIPC_NODE_STATE                             = 0x0
        TIPC_OK                                     = 0x0
        TIPC_PUBLISHED                              = 0x1
+       TIPC_REKEYING_NOW                           = 0xffffffff
        TIPC_RESERVED_TYPES                         = 0x40
        TIPC_RETDATA                                = 0x2
        TIPC_SERVICE_ADDR                           = 0x2
@@ -2446,10 +2587,12 @@ const (
        VMADDR_CID_HOST                             = 0x2
        VMADDR_CID_HYPERVISOR                       = 0x0
        VMADDR_CID_LOCAL                            = 0x1
+       VMADDR_FLAG_TO_HOST                         = 0x1
        VMADDR_PORT_ANY                             = 0xffffffff
        VM_SOCKETS_INVALID_VERSION                  = 0xffffffff
        VQUIT                                       = 0x1
        VT0                                         = 0x0
+       WAKE_MAGIC                                  = 0x20
        WALL                                        = 0x40000000
        WCLONE                                      = 0x80000000
        WCONTINUED                                  = 0x8

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index dd282c08b7f11fa7dfb921aa29261969c6dbed0f..c8d5b324c750e007bdaa2d8600e8283043390873 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -4,7 +4,7 @@
 // +build 386,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -192,6 +193,7 @@ const (
        PPPIOCSPASS                      = 0x40087447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PR_SET_PTRACER_ANY               = 0xffffffff
        PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index 82fc93c7bbc128f03b1fc1f05b9063eb43754cb0..e605c08b0ec00f0e6f640da4e1651118da6941eb 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -4,7 +4,7 @@
 // +build amd64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -192,6 +193,7 @@ const (
        PPPIOCSPASS                      = 0x40107447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        PTRACE_ARCH_PRCTL                = 0x1e
@@ -269,6 +271,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -291,6 +294,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index fe7094f2763f986ae2ed38d537afadea81a40844..0279fa1abdaee7504f5d0b1c7fcd496a7d201da3 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -4,7 +4,7 @@
 // +build arm,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x40087447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PR_SET_PTRACER_ANY               = 0xffffffff
        PTRACE_GETCRUNCHREGS             = 0x19
@@ -275,6 +277,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -297,6 +300,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 3b6cc58803b6e0cb21d8ab44a8b8a0ebc05733c8..20c286a1122eb6be566a5b34978fad0f9fbc1020 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -4,7 +4,7 @@
 // +build arm64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go
 
 package unix
 
@@ -166,6 +166,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -193,9 +194,13 @@ const (
        PPPIOCSPASS                      = 0x40107447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PROT_BTI                         = 0x10
+       PROT_MTE                         = 0x20
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+       PTRACE_PEEKMTETAGS               = 0x21
+       PTRACE_POKEMTETAGS               = 0x22
        PTRACE_SYSEMU                    = 0x1f
        PTRACE_SYSEMU_SINGLESTEP         = 0x20
        RLIMIT_AS                        = 0x9
@@ -262,6 +267,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -284,6 +290,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index ce3d9ae15610c64bdd7f13f7cf2119092913dfc9..1785f33d669d51a5c7fdcd8f8c0fe8fc70c77eb7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -4,7 +4,7 @@
 // +build mips,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x80087447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PR_SET_PTRACER_ANY               = 0xffffffff
        PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
        SO_BROADCAST                     = 0x20
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
        SO_PEERCRED                      = 0x12
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1e
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x1028
        SO_RCVBUF                        = 0x1002
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 7a85215ce5231e73e7b95e8817a3143b0bb385e0..acb1ef1bf554bbb0cc6dd0fef21dc4c52997b273 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -4,7 +4,7 @@
 // +build mips64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x80107447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
        SO_BROADCAST                     = 0x20
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
        SO_PEERCRED                      = 0x12
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1e
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x1028
        SO_RCVBUF                        = 0x1002
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 07d4cc1bd5ff43ecd636563cb739ab7cd1159778..468a4e68c7fd66691bca7ebaf127bf210fedd062 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -4,7 +4,7 @@
 // +build mips64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x80107447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
        SO_BROADCAST                     = 0x20
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
        SO_PEERCRED                      = 0x12
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1e
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x1028
        SO_RCVBUF                        = 0x1002
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index d4842ba1c2a816faadfe63d28310ed8065ebec4a..6c9c7f2c76bc343e3642940a81530fcf9b6d0885 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -4,7 +4,7 @@
 // +build mipsle,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x80087447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PR_SET_PTRACER_ANY               = 0xffffffff
        PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
        SO_BROADCAST                     = 0x20
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
        SO_PEERCRED                      = 0x12
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1e
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x1028
        SO_RCVBUF                        = 0x1002
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 941e20daceca0a45616443d1efbf912e7d57d3e3..8961206e5f4bac8971ead7c62273545d50c3fdae 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -4,7 +4,7 @@
 // +build ppc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -192,6 +193,7 @@ const (
        PPPIOCSPASS                      = 0x80107447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PROT_SAO                         = 0x10
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
@@ -327,6 +329,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -349,6 +352,7 @@ const (
        SO_PEERCRED                      = 0x15
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index 63d3bc56627d2f30118a3979c8eaecfbc73f7657..6bcf79dc2e6555297c25f6d14ddcf97e83c819b8 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -4,7 +4,7 @@
 // +build ppc64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -192,6 +193,7 @@ const (
        PPPIOCSPASS                      = 0x80107447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PROT_SAO                         = 0x10
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
@@ -327,6 +329,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -349,6 +352,7 @@ const (
        SO_PEERCRED                      = 0x15
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 490bee1ab1b5531a773c18127f64e8d6a7939e1b..e861d97f1c0aa3f8826994218573b4a4ee9d5f4a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -4,7 +4,7 @@
 // +build riscv64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x40107447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        RLIMIT_AS                        = 0x9
@@ -256,6 +258,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -278,6 +281,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 467b8218e80e650e8277d6fa535475111a7a4e8f..d39278bee5927b5163585267a4de711ca2c80552 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -4,7 +4,7 @@
 // +build s390x,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
        PPPIOCATTACH                     = 0x4004743d
        PPPIOCATTCHAN                    = 0x40047438
+       PPPIOCBRIDGECHAN                 = 0x40047435
        PPPIOCCONNECT                    = 0x4004743a
        PPPIOCDETACH                     = 0x4004743c
        PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
        PPPIOCSPASS                      = 0x40107447
        PPPIOCSRASYNCMAP                 = 0x40047454
        PPPIOCSXASYNCMAP                 = 0x4020744f
+       PPPIOCUNBRIDGECHAN               = 0x7434
        PPPIOCXFERUNIT                   = 0x744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        PTRACE_DISABLE_TE                = 0x5010
@@ -329,6 +331,7 @@ const (
        SO_BROADCAST                     = 0x6
        SO_BSDCOMPAT                     = 0xe
        SO_BUSY_POLL                     = 0x2e
+       SO_BUSY_POLL_BUDGET              = 0x46
        SO_CNX_ADVICE                    = 0x35
        SO_COOKIE                        = 0x39
        SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -351,6 +354,7 @@ const (
        SO_PEERCRED                      = 0x11
        SO_PEERGROUPS                    = 0x3b
        SO_PEERSEC                       = 0x1f
+       SO_PREFER_BUSY_POLL              = 0x45
        SO_PROTOCOL                      = 0x26
        SO_RCVBUF                        = 0x8
        SO_RCVBUFFORCE                   = 0x21

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index 79fbafbcf6c47c0ccaef780646d5e067b05e40da..6a742fa7ee35450cd5fa63f5556c1572bbfd258f 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -4,7 +4,7 @@
 // +build sparc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -168,6 +168,7 @@ const (
        PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
        PPPIOCATTACH                     = 0x8004743d
        PPPIOCATTCHAN                    = 0x80047438
+       PPPIOCBRIDGECHAN                 = 0x80047435
        PPPIOCCONNECT                    = 0x8004743a
        PPPIOCDETACH                     = 0x8004743c
        PPPIOCDISCONN                    = 0x20007439
@@ -195,6 +196,7 @@ const (
        PPPIOCSPASS                      = 0x80107447
        PPPIOCSRASYNCMAP                 = 0x80047454
        PPPIOCSXASYNCMAP                 = 0x8020744f
+       PPPIOCUNBRIDGECHAN               = 0x20007434
        PPPIOCXFERUNIT                   = 0x2000744e
        PR_SET_PTRACER_ANY               = 0xffffffffffffffff
        PTRACE_GETFPAREGS                = 0x14
@@ -322,6 +324,7 @@ const (
        SO_BROADCAST                     = 0x20
        SO_BSDCOMPAT                     = 0x400
        SO_BUSY_POLL                     = 0x30
+       SO_BUSY_POLL_BUDGET              = 0x49
        SO_CNX_ADVICE                    = 0x37
        SO_COOKIE                        = 0x3b
        SO_DETACH_REUSEPORT_BPF          = 0x47
@@ -344,6 +347,7 @@ const (
        SO_PEERCRED                      = 0x40
        SO_PEERGROUPS                    = 0x3d
        SO_PEERSEC                       = 0x1e
+       SO_PREFER_BUSY_POLL              = 0x48
        SO_PROTOCOL                      = 0x1028
        SO_RCVBUF                        = 0x1002
        SO_RCVBUFFORCE                   = 0x100b

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
index 7f0f117d3208fb122915d46ce1253c6a4701d4d8..3877183483f1f4d2c91c8fd92545ca50ab3f0dc2 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-       r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-       r = int(r0)
-       w = int(r1)
+func pipe(p *[2]int32) (err error) {
+       _, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
@@ -2381,7 +2379,7 @@ func libc_lstat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
        _, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index 2daf0bd628398c7e48020e5a6d24ed8d0a0775c9..508e5639bf4a18c8227703b69a48281ea283b601 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-       r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-       r = int(r0)
-       w = int(r1)
+func pipe(p *[2]int32) (err error) {
+       _, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
@@ -2381,7 +2379,7 @@ func libc_lstat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
        _, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
index 8e79ad377be491bd9fe16b4afc3d67e8d327a2fe..c0c771f4025d3b17123bb350f2588427773096dc 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-       r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-       r = int(r0)
-       w = int(r1)
+func pipe(p *[2]int32) (err error) {
+       _, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 23be592a9f3900b30a3e31912a8a9f47a1ec6508..9b01a79c41ea67d0d4b73a5b7c4e176a8b394f40 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-       r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-       r = int(r0)
-       w = int(r1)
+func pipe(p *[2]int32) (err error) {
+       _, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
@@ -2381,7 +2379,7 @@ func libc_lstat_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
        _, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
index 1aaccd3615eea15ee770f7a34aa7515bcf432d6e..104f77d5b82abf9dd61aca3ce8013d640d093a38 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
@@ -362,8 +362,10 @@ func pipe() (r int, w int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe2(p *[2]_C_int, flags int) (err error) {
-       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+func pipe2(flags int) (r int, w int, err error) {
+       r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(flags), 0, 0)
+       r = int(r0)
+       w = int(r1)
        if e1 != 0 {
                err = errnoErr(e1)
        }

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
index d3af083f4e7cdc45f49985995c02fe77626d041f..665dd9e4b49e3741fd5e210a02f2b250249c53d1 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
@@ -14,22 +14,19 @@ import (
 //go:cgo_import_dynamic libc_writev writev "libc.so"
 //go:cgo_import_dynamic libc_pwritev pwritev "libc.so"
 //go:cgo_import_dynamic libc_accept4 accept4 "libsocket.so"
-//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 
 //go:linkname procreadv libc_readv
 //go:linkname procpreadv libc_preadv
 //go:linkname procwritev libc_writev
 //go:linkname procpwritev libc_pwritev
 //go:linkname procaccept4 libc_accept4
-//go:linkname procpipe2 libc_pipe2
 
 var (
        procreadv,
        procpreadv,
        procwritev,
        procpwritev,
-       procaccept4,
-       procpipe2 syscallFunc
+       procaccept4 syscallFunc
 )
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -102,13 +99,3 @@ func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int,
        }
        return
 }
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe2(p *[2]_C_int, flags int) (err error) {
-       _, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procpipe2)), 2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0, 0, 0, 0)
-       if e1 != 0 {
-               err = e1
-       }
-       return
-}

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
index 3bbd9e39cda46acc1e1d53e8c5703485fdde9272..1d6f71d99ad6b7bce0f0c219941bb86fddfe6b2a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
        var _p0 unsafe.Pointer
        if len(buf) > 0 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
index d8cf5012c2760fa759d571a30abb6e3423fb3670..82f50506adb8b2561969206a2e5ee3ead4d09c0c 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
        var _p0 unsafe.Pointer
        if len(buf) > 0 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
index 1153fe69b8ecce79b34b37ff7b1d83e1283f0535..b4db55a0c84b5dc54563fdfe3f1d12c94bac7e47 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
        var _p0 unsafe.Pointer
        if len(buf) > 0 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
index 24b4ebb41fa31c4d6eeb3a260bb58f62db689518..e9f6d7975a4fb5eab07dbf3627c81afa6333c4fc 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
        var _p0 unsafe.Pointer
        if len(buf) > 0 {

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index a96165d4bf06f2a31ef96ac9b5e3c00090da2a7a..9898ce1f47784194e7985c02c57f82ae5288a364 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -11,6 +11,7 @@ import (
 )
 
 //go:cgo_import_dynamic libc_pipe pipe "libc.so"
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 //go:cgo_import_dynamic libc_getsockname getsockname "libsocket.so"
 //go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
 //go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
@@ -114,6 +115,7 @@ import (
 //go:cgo_import_dynamic libc_statvfs statvfs "libc.so"
 //go:cgo_import_dynamic libc_symlink symlink "libc.so"
 //go:cgo_import_dynamic libc_sync sync "libc.so"
+//go:cgo_import_dynamic libc_sysconf sysconf "libc.so"
 //go:cgo_import_dynamic libc_times times "libc.so"
 //go:cgo_import_dynamic libc_truncate truncate "libc.so"
 //go:cgo_import_dynamic libc_fsync fsync "libc.so"
@@ -140,6 +142,7 @@ import (
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libsocket.so"
 
 //go:linkname procpipe libc_pipe
+//go:linkname procpipe2 libc_pipe2
 //go:linkname procgetsockname libc_getsockname
 //go:linkname procGetcwd libc_getcwd
 //go:linkname procgetgroups libc_getgroups
@@ -243,6 +246,7 @@ import (
 //go:linkname procStatvfs libc_statvfs
 //go:linkname procSymlink libc_symlink
 //go:linkname procSync libc_sync
+//go:linkname procSysconf libc_sysconf
 //go:linkname procTimes libc_times
 //go:linkname procTruncate libc_truncate
 //go:linkname procFsync libc_fsync
@@ -270,6 +274,7 @@ import (
 
 var (
        procpipe,
+       procpipe2,
        procgetsockname,
        procGetcwd,
        procgetgroups,
@@ -373,6 +378,7 @@ var (
        procStatvfs,
        procSymlink,
        procSync,
+       procSysconf,
        procTimes,
        procTruncate,
        procFsync,
@@ -412,6 +418,16 @@ func pipe(p *[2]_C_int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+       _, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procpipe2)), 2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0, 0, 0, 0)
+       if e1 != 0 {
+               err = e1
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
        _, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetsockname)), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
        if e1 != 0 {
@@ -1674,6 +1690,17 @@ func Sync() (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Sysconf(which int) (n int64, err error) {
+       r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procSysconf)), 1, uintptr(which), 0, 0, 0, 0, 0)
+       n = int64(r0)
+       if e1 != 0 {
+               err = e1
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Times(tms *Tms) (ticks uintptr, err error) {
        r0, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procTimes)), 1, uintptr(unsafe.Pointer(tms)), 0, 0, 0, 0, 0)
        ticks = uintptr(r0)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 0f5a3f6970a26ba5a80e52010a652b96ff192d43..c80f3c7bdd87aa3c90b169e0f1d8476b32b6e504 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -435,4 +435,6 @@ const (
        SYS_OPENAT2                      = 437
        SYS_PIDFD_GETFD                  = 438
        SYS_FACCESSAT2                   = 439
+       SYS_PROCESS_MADVISE              = 440
+       SYS_EPOLL_PWAIT2                 = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 36d5219ef824fe107998bfde93ca0507c1783d1f..2369995cec3aa3d8fee33546db2b6ee170772e88 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -357,4 +357,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 3622ba14b4e11f8f71e543f24e4a687ef09bc586..971c5af6d42358826188f6209d1ae38c35d43417 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -399,4 +399,6 @@ const (
        SYS_OPENAT2                      = 437
        SYS_PIDFD_GETFD                  = 438
        SYS_FACCESSAT2                   = 439
+       SYS_PROCESS_MADVISE              = 440
+       SYS_EPOLL_PWAIT2                 = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 6193c3dc07c146bce08efedb9e1958f2ab480ee8..a5e410b24fb871ef28465f2dbde3a0655ff34153 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -302,4 +302,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 640b974345f314b0aad674c7d1b0fcaf568df5da..438a6ea4e6b8d7619d7d63afb11a7b38877d99c1 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -420,4 +420,6 @@ const (
        SYS_OPENAT2                      = 4437
        SYS_PIDFD_GETFD                  = 4438
        SYS_FACCESSAT2                   = 4439
+       SYS_PROCESS_MADVISE              = 4440
+       SYS_EPOLL_PWAIT2                 = 4441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 3467fbb5ff1c488b8339e847a60fc2791a6b9aaf..622472da2203dde8cc949cfeda2013419062dd7d 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -350,4 +350,6 @@ const (
        SYS_OPENAT2                = 5437
        SYS_PIDFD_GETFD            = 5438
        SYS_FACCESSAT2             = 5439
+       SYS_PROCESS_MADVISE        = 5440
+       SYS_EPOLL_PWAIT2           = 5441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 0fc38d5a72f0297048f936809fac34ac39c25524..e029b989b80afd950e2cb66bb67bd0af83a7378b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -350,4 +350,6 @@ const (
        SYS_OPENAT2                = 5437
        SYS_PIDFD_GETFD            = 5438
        SYS_FACCESSAT2             = 5439
+       SYS_PROCESS_MADVISE        = 5440
+       SYS_EPOLL_PWAIT2           = 5441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index 999fd55bccb705a15df717b41ed3001c229c8733..86a497b58d49a92321c113f6d874e037852b2942 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -420,4 +420,6 @@ const (
        SYS_OPENAT2                      = 4437
        SYS_PIDFD_GETFD                  = 4438
        SYS_FACCESSAT2                   = 4439
+       SYS_PROCESS_MADVISE              = 4440
+       SYS_EPOLL_PWAIT2                 = 4441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index 1df0d799355df5f58aa83b4ce9611a6dd16bec15..b6b0b5e602a8fcced51a84a8922a750ab5c652f8 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -399,4 +399,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 4db39cca4da51a230e88e725595749d9bb4203b8..b344db0146dbe2d48018567a9a8119fdbb2aac87 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -399,4 +399,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index e6927401446f719b1558a59e1c65fd6c6eb4f219..9b8fa53dccc328c9d0c8e3e663fcfc899b149e9c 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -301,4 +301,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index a585aec4e7971e13848d08f2dc4dbd7da388f2dd..8261f72c0ba2e3b91db6ba047810b7c38ef80bdc 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -364,4 +364,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index d047e567afc60859752c9cfe6e6c7d790bea22df..f4bbeb3db5eedef27326f5e9639eb12dec8b96a8 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -378,4 +378,6 @@ const (
        SYS_OPENAT2                = 437
        SYS_PIDFD_GETFD            = 438
        SYS_FACCESSAT2             = 439
+       SYS_PROCESS_MADVISE        = 440
+       SYS_EPOLL_PWAIT2           = 441
 )

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
index 2c1f815e6f92c103904ae8c203c6300942b34795..295859c503db2aca07028e7d93bb31492330aeb6 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
@@ -219,6 +219,7 @@ const (
        SizeofSockaddrUnix     = 0x401
        SizeofSockaddrDatalink = 0x80
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofIPv6MTUInfo      = 0x20

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
index b4a069ecbdff083d29d62bc126d3c1969c83119a..a9ee0ffd44c12c0e4b33812b0ab14313333df037 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
@@ -223,6 +223,7 @@ const (
        SizeofSockaddrUnix     = 0x401
        SizeofSockaddrDatalink = 0x80
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofIPv6MTUInfo      = 0x20

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index 080ffce3255088f91c4b43d7badc5760a86d5aa2..bb39542f7a9b605d94b283c59b470ded150d3082 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -210,6 +210,13 @@ type RawSockaddrCtl struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+       Version uint32
+       Uid     uint32
+       Ngroups int16
+       Groups  [16]uint32
+}
+
 type Linger struct {
        Onoff  int32
        Linger int32
@@ -273,6 +280,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofSockaddrCtl      = 0x20
+       SizeofXucred           = 0x4c
        SizeofLinger           = 0x8
        SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index c9492428bfa3fb833f34ee4d5f6422e0a506d31b..ec5b5592721d0707fae386c0789c7d28f5549209 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -210,6 +210,13 @@ type RawSockaddrCtl struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+       Version uint32
+       Uid     uint32
+       Ngroups int16
+       Groups  [16]uint32
+}
+
 type Linger struct {
        Onoff  int32
        Linger int32
@@ -273,6 +280,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofSockaddrCtl      = 0x20
+       SizeofXucred           = 0x4c
        SizeofLinger           = 0x8
        SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
index c4772df23bfd64a37dfc4801cf93b8062a09e3df..85506a05d4b8e185a5a7f10e72737098c0accd4b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
@@ -234,6 +234,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x36
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 2a3ec615f753fb0b27bea0ca059a19f1f666115a..3e9dad33e33832ff54f51ff9175eda5bbf840a9d 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -313,6 +313,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x36
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPMreqn          = 0xc
        SizeofIPv6Mreq         = 0x14

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index e11e95499e87df29f3b864d7afd006938eec80a0..e00e615544c89ff89bf5fedc14f4ee3055e4067e 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -309,6 +309,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x36
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPMreqn          = 0xc
        SizeofIPv6Mreq         = 0x14

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index b91c2ae0f015f37b39474efcdfd760cf2b64a748..5da13c871b540851b3c242691ee769d48efc4e27 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -311,6 +311,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x36
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPMreqn          = 0xc
        SizeofIPv6Mreq         = 0x14

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index c6fe1d097d8fbdf066a355a99b41f425bbdca1f5..995ecf9d4e2c65983649e44a084befae06228f69 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -309,6 +309,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x36
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPMreqn          = 0xc
        SizeofIPv6Mreq         = 0x14

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 504ef131fb8cf5c4cd5a92653673dd467308159d..ddd655769d59144adcbd056940e19a4e01d86db0 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -288,7 +288,8 @@ type RawSockaddrVM struct {
        Reserved1 uint16
        Port      uint32
        Cid       uint32
-       Zero      [4]uint8
+       Flags     uint8
+       Zero      [3]uint8
 }
 
 type RawSockaddrXDP struct {
@@ -999,7 +1000,7 @@ const (
        PERF_SAMPLE_PHYS_ADDR                 = 0x80000
        PERF_SAMPLE_AUX                       = 0x100000
        PERF_SAMPLE_CGROUP                    = 0x200000
-       PERF_SAMPLE_MAX                       = 0x400000
+       PERF_SAMPLE_MAX                       = 0x1000000
        PERF_SAMPLE_BRANCH_USER_SHIFT         = 0x0
        PERF_SAMPLE_BRANCH_KERNEL_SHIFT       = 0x1
        PERF_SAMPLE_BRANCH_HV_SHIFT           = 0x2
@@ -1381,6 +1382,11 @@ const (
        IFLA_PROP_LIST                             = 0x34
        IFLA_ALT_IFNAME                            = 0x35
        IFLA_PERM_ADDRESS                          = 0x36
+       IFLA_PROTO_DOWN_REASON                     = 0x37
+       IFLA_PROTO_DOWN_REASON_UNSPEC              = 0x0
+       IFLA_PROTO_DOWN_REASON_MASK                = 0x1
+       IFLA_PROTO_DOWN_REASON_VALUE               = 0x2
+       IFLA_PROTO_DOWN_REASON_MAX                 = 0x2
        IFLA_INET_UNSPEC                           = 0x0
        IFLA_INET_CONF                             = 0x1
        IFLA_INET6_UNSPEC                          = 0x0
@@ -1475,6 +1481,7 @@ const (
        IFLA_BRPORT_ISOLATED                       = 0x21
        IFLA_BRPORT_BACKUP_PORT                    = 0x22
        IFLA_BRPORT_MRP_RING_OPEN                  = 0x23
+       IFLA_BRPORT_MRP_IN_OPEN                    = 0x24
        IFLA_INFO_UNSPEC                           = 0x0
        IFLA_INFO_KIND                             = 0x1
        IFLA_INFO_DATA                             = 0x2
@@ -1673,6 +1680,7 @@ const (
        IFLA_HSR_SUPERVISION_ADDR                  = 0x4
        IFLA_HSR_SEQ_NR                            = 0x5
        IFLA_HSR_VERSION                           = 0x6
+       IFLA_HSR_PROTOCOL                          = 0x7
        IFLA_STATS_UNSPEC                          = 0x0
        IFLA_STATS_LINK_64                         = 0x1
        IFLA_STATS_LINK_XSTATS                     = 0x2
@@ -2217,10 +2225,12 @@ const (
 )
 
 const (
-       NETNSA_NONE = 0x0
-       NETNSA_NSID = 0x1
-       NETNSA_PID  = 0x2
-       NETNSA_FD   = 0x3
+       NETNSA_NONE         = 0x0
+       NETNSA_NSID         = 0x1
+       NETNSA_PID          = 0x2
+       NETNSA_FD           = 0x3
+       NETNSA_TARGET_NSID  = 0x4
+       NETNSA_CURRENT_NSID = 0x5
 )
 
 type XDPRingOffset struct {
@@ -2370,281 +2380,309 @@ const (
 )
 
 const (
-       BPF_REG_0                               = 0x0
-       BPF_REG_1                               = 0x1
-       BPF_REG_2                               = 0x2
-       BPF_REG_3                               = 0x3
-       BPF_REG_4                               = 0x4
-       BPF_REG_5                               = 0x5
-       BPF_REG_6                               = 0x6
-       BPF_REG_7                               = 0x7
-       BPF_REG_8                               = 0x8
-       BPF_REG_9                               = 0x9
-       BPF_REG_10                              = 0xa
-       BPF_MAP_CREATE                          = 0x0
-       BPF_MAP_LOOKUP_ELEM                     = 0x1
-       BPF_MAP_UPDATE_ELEM                     = 0x2
-       BPF_MAP_DELETE_ELEM                     = 0x3
-       BPF_MAP_GET_NEXT_KEY                    = 0x4
-       BPF_PROG_LOAD                           = 0x5
-       BPF_OBJ_PIN                             = 0x6
-       BPF_OBJ_GET                             = 0x7
-       BPF_PROG_ATTACH                         = 0x8
-       BPF_PROG_DETACH                         = 0x9
-       BPF_PROG_TEST_RUN                       = 0xa
-       BPF_PROG_GET_NEXT_ID                    = 0xb
-       BPF_MAP_GET_NEXT_ID                     = 0xc
-       BPF_PROG_GET_FD_BY_ID                   = 0xd
-       BPF_MAP_GET_FD_BY_ID                    = 0xe
-       BPF_OBJ_GET_INFO_BY_FD                  = 0xf
-       BPF_PROG_QUERY                          = 0x10
-       BPF_RAW_TRACEPOINT_OPEN                 = 0x11
-       BPF_BTF_LOAD                            = 0x12
-       BPF_BTF_GET_FD_BY_ID                    = 0x13
-       BPF_TASK_FD_QUERY                       = 0x14
-       BPF_MAP_LOOKUP_AND_DELETE_ELEM          = 0x15
-       BPF_MAP_FREEZE                          = 0x16
-       BPF_BTF_GET_NEXT_ID                     = 0x17
-       BPF_MAP_LOOKUP_BATCH                    = 0x18
-       BPF_MAP_LOOKUP_AND_DELETE_BATCH         = 0x19
-       BPF_MAP_UPDATE_BATCH                    = 0x1a
-       BPF_MAP_DELETE_BATCH                    = 0x1b
-       BPF_LINK_CREATE                         = 0x1c
-       BPF_LINK_UPDATE                         = 0x1d
-       BPF_LINK_GET_FD_BY_ID                   = 0x1e
-       BPF_LINK_GET_NEXT_ID                    = 0x1f
-       BPF_ENABLE_STATS                        = 0x20
-       BPF_ITER_CREATE                         = 0x21
-       BPF_MAP_TYPE_UNSPEC                     = 0x0
-       BPF_MAP_TYPE_HASH                       = 0x1
-       BPF_MAP_TYPE_ARRAY                      = 0x2
-       BPF_MAP_TYPE_PROG_ARRAY                 = 0x3
-       BPF_MAP_TYPE_PERF_EVENT_ARRAY           = 0x4
-       BPF_MAP_TYPE_PERCPU_HASH                = 0x5
-       BPF_MAP_TYPE_PERCPU_ARRAY               = 0x6
-       BPF_MAP_TYPE_STACK_TRACE                = 0x7
-       BPF_MAP_TYPE_CGROUP_ARRAY               = 0x8
-       BPF_MAP_TYPE_LRU_HASH                   = 0x9
-       BPF_MAP_TYPE_LRU_PERCPU_HASH            = 0xa
-       BPF_MAP_TYPE_LPM_TRIE                   = 0xb
-       BPF_MAP_TYPE_ARRAY_OF_MAPS              = 0xc
-       BPF_MAP_TYPE_HASH_OF_MAPS               = 0xd
-       BPF_MAP_TYPE_DEVMAP                     = 0xe
-       BPF_MAP_TYPE_SOCKMAP                    = 0xf
-       BPF_MAP_TYPE_CPUMAP                     = 0x10
-       BPF_MAP_TYPE_XSKMAP                     = 0x11
-       BPF_MAP_TYPE_SOCKHASH                   = 0x12
-       BPF_MAP_TYPE_CGROUP_STORAGE             = 0x13
-       BPF_MAP_TYPE_REUSEPORT_SOCKARRAY        = 0x14
-       BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE      = 0x15
-       BPF_MAP_TYPE_QUEUE                      = 0x16
-       BPF_MAP_TYPE_STACK                      = 0x17
-       BPF_MAP_TYPE_SK_STORAGE                 = 0x18
-       BPF_MAP_TYPE_DEVMAP_HASH                = 0x19
-       BPF_MAP_TYPE_STRUCT_OPS                 = 0x1a
-       BPF_MAP_TYPE_RINGBUF                    = 0x1b
-       BPF_PROG_TYPE_UNSPEC                    = 0x0
-       BPF_PROG_TYPE_SOCKET_FILTER             = 0x1
-       BPF_PROG_TYPE_KPROBE                    = 0x2
-       BPF_PROG_TYPE_SCHED_CLS                 = 0x3
-       BPF_PROG_TYPE_SCHED_ACT                 = 0x4
-       BPF_PROG_TYPE_TRACEPOINT                = 0x5
-       BPF_PROG_TYPE_XDP                       = 0x6
-       BPF_PROG_TYPE_PERF_EVENT                = 0x7
-       BPF_PROG_TYPE_CGROUP_SKB                = 0x8
-       BPF_PROG_TYPE_CGROUP_SOCK               = 0x9
-       BPF_PROG_TYPE_LWT_IN                    = 0xa
-       BPF_PROG_TYPE_LWT_OUT                   = 0xb
-       BPF_PROG_TYPE_LWT_XMIT                  = 0xc
-       BPF_PROG_TYPE_SOCK_OPS                  = 0xd
-       BPF_PROG_TYPE_SK_SKB                    = 0xe
-       BPF_PROG_TYPE_CGROUP_DEVICE             = 0xf
-       BPF_PROG_TYPE_SK_MSG                    = 0x10
-       BPF_PROG_TYPE_RAW_TRACEPOINT            = 0x11
-       BPF_PROG_TYPE_CGROUP_SOCK_ADDR          = 0x12
-       BPF_PROG_TYPE_LWT_SEG6LOCAL             = 0x13
-       BPF_PROG_TYPE_LIRC_MODE2                = 0x14
-       BPF_PROG_TYPE_SK_REUSEPORT              = 0x15
-       BPF_PROG_TYPE_FLOW_DISSECTOR            = 0x16
-       BPF_PROG_TYPE_CGROUP_SYSCTL             = 0x17
-       BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE   = 0x18
-       BPF_PROG_TYPE_CGROUP_SOCKOPT            = 0x19
-       BPF_PROG_TYPE_TRACING                   = 0x1a
-       BPF_PROG_TYPE_STRUCT_OPS                = 0x1b
-       BPF_PROG_TYPE_EXT                       = 0x1c
-       BPF_PROG_TYPE_LSM                       = 0x1d
-       BPF_CGROUP_INET_INGRESS                 = 0x0
-       BPF_CGROUP_INET_EGRESS                  = 0x1
-       BPF_CGROUP_INET_SOCK_CREATE             = 0x2
-       BPF_CGROUP_SOCK_OPS                     = 0x3
-       BPF_SK_SKB_STREAM_PARSER                = 0x4
-       BPF_SK_SKB_STREAM_VERDICT               = 0x5
-       BPF_CGROUP_DEVICE                       = 0x6
-       BPF_SK_MSG_VERDICT                      = 0x7
-       BPF_CGROUP_INET4_BIND                   = 0x8
-       BPF_CGROUP_INET6_BIND                   = 0x9
-       BPF_CGROUP_INET4_CONNECT                = 0xa
-       BPF_CGROUP_INET6_CONNECT                = 0xb
-       BPF_CGROUP_INET4_POST_BIND              = 0xc
-       BPF_CGROUP_INET6_POST_BIND              = 0xd
-       BPF_CGROUP_UDP4_SENDMSG                 = 0xe
-       BPF_CGROUP_UDP6_SENDMSG                 = 0xf
-       BPF_LIRC_MODE2                          = 0x10
-       BPF_FLOW_DISSECTOR                      = 0x11
-       BPF_CGROUP_SYSCTL                       = 0x12
-       BPF_CGROUP_UDP4_RECVMSG                 = 0x13
-       BPF_CGROUP_UDP6_RECVMSG                 = 0x14
-       BPF_CGROUP_GETSOCKOPT                   = 0x15
-       BPF_CGROUP_SETSOCKOPT                   = 0x16
-       BPF_TRACE_RAW_TP                        = 0x17
-       BPF_TRACE_FENTRY                        = 0x18
-       BPF_TRACE_FEXIT                         = 0x19
-       BPF_MODIFY_RETURN                       = 0x1a
-       BPF_LSM_MAC                             = 0x1b
-       BPF_TRACE_ITER                          = 0x1c
-       BPF_CGROUP_INET4_GETPEERNAME            = 0x1d
-       BPF_CGROUP_INET6_GETPEERNAME            = 0x1e
-       BPF_CGROUP_INET4_GETSOCKNAME            = 0x1f
-       BPF_CGROUP_INET6_GETSOCKNAME            = 0x20
-       BPF_XDP_DEVMAP                          = 0x21
-       BPF_LINK_TYPE_UNSPEC                    = 0x0
-       BPF_LINK_TYPE_RAW_TRACEPOINT            = 0x1
-       BPF_LINK_TYPE_TRACING                   = 0x2
-       BPF_LINK_TYPE_CGROUP                    = 0x3
-       BPF_LINK_TYPE_ITER                      = 0x4
-       BPF_LINK_TYPE_NETNS                     = 0x5
-       BPF_ANY                                 = 0x0
-       BPF_NOEXIST                             = 0x1
-       BPF_EXIST                               = 0x2
-       BPF_F_LOCK                              = 0x4
-       BPF_F_NO_PREALLOC                       = 0x1
-       BPF_F_NO_COMMON_LRU                     = 0x2
-       BPF_F_NUMA_NODE                         = 0x4
-       BPF_F_RDONLY                            = 0x8
-       BPF_F_WRONLY                            = 0x10
-       BPF_F_STACK_BUILD_ID                    = 0x20
-       BPF_F_ZERO_SEED                         = 0x40
-       BPF_F_RDONLY_PROG                       = 0x80
-       BPF_F_WRONLY_PROG                       = 0x100
-       BPF_F_CLONE                             = 0x200
-       BPF_F_MMAPABLE                          = 0x400
-       BPF_STATS_RUN_TIME                      = 0x0
-       BPF_STACK_BUILD_ID_EMPTY                = 0x0
-       BPF_STACK_BUILD_ID_VALID                = 0x1
-       BPF_STACK_BUILD_ID_IP                   = 0x2
-       BPF_F_RECOMPUTE_CSUM                    = 0x1
-       BPF_F_INVALIDATE_HASH                   = 0x2
-       BPF_F_HDR_FIELD_MASK                    = 0xf
-       BPF_F_PSEUDO_HDR                        = 0x10
-       BPF_F_MARK_MANGLED_0                    = 0x20
-       BPF_F_MARK_ENFORCE                      = 0x40
-       BPF_F_INGRESS                           = 0x1
-       BPF_F_TUNINFO_IPV6                      = 0x1
-       BPF_F_SKIP_FIELD_MASK                   = 0xff
-       BPF_F_USER_STACK                        = 0x100
-       BPF_F_FAST_STACK_CMP                    = 0x200
-       BPF_F_REUSE_STACKID                     = 0x400
-       BPF_F_USER_BUILD_ID                     = 0x800
-       BPF_F_ZERO_CSUM_TX                      = 0x2
-       BPF_F_DONT_FRAGMENT                     = 0x4
-       BPF_F_SEQ_NUMBER                        = 0x8
-       BPF_F_INDEX_MASK                        = 0xffffffff
-       BPF_F_CURRENT_CPU                       = 0xffffffff
-       BPF_F_CTXLEN_MASK                       = 0xfffff00000000
-       BPF_F_CURRENT_NETNS                     = -0x1
-       BPF_CSUM_LEVEL_QUERY                    = 0x0
-       BPF_CSUM_LEVEL_INC                      = 0x1
-       BPF_CSUM_LEVEL_DEC                      = 0x2
-       BPF_CSUM_LEVEL_RESET                    = 0x3
-       BPF_F_ADJ_ROOM_FIXED_GSO                = 0x1
-       BPF_F_ADJ_ROOM_ENCAP_L3_IPV4            = 0x2
-       BPF_F_ADJ_ROOM_ENCAP_L3_IPV6            = 0x4
-       BPF_F_ADJ_ROOM_ENCAP_L4_GRE             = 0x8
-       BPF_F_ADJ_ROOM_ENCAP_L4_UDP             = 0x10
-       BPF_F_ADJ_ROOM_NO_CSUM_RESET            = 0x20
-       BPF_ADJ_ROOM_ENCAP_L2_MASK              = 0xff
-       BPF_ADJ_ROOM_ENCAP_L2_SHIFT             = 0x38
-       BPF_F_SYSCTL_BASE_NAME                  = 0x1
-       BPF_SK_STORAGE_GET_F_CREATE             = 0x1
-       BPF_F_GET_BRANCH_RECORDS_SIZE           = 0x1
-       BPF_RB_NO_WAKEUP                        = 0x1
-       BPF_RB_FORCE_WAKEUP                     = 0x2
-       BPF_RB_AVAIL_DATA                       = 0x0
-       BPF_RB_RING_SIZE                        = 0x1
-       BPF_RB_CONS_POS                         = 0x2
-       BPF_RB_PROD_POS                         = 0x3
-       BPF_RINGBUF_BUSY_BIT                    = 0x80000000
-       BPF_RINGBUF_DISCARD_BIT                 = 0x40000000
-       BPF_RINGBUF_HDR_SZ                      = 0x8
-       BPF_ADJ_ROOM_NET                        = 0x0
-       BPF_ADJ_ROOM_MAC                        = 0x1
-       BPF_HDR_START_MAC                       = 0x0
-       BPF_HDR_START_NET                       = 0x1
-       BPF_LWT_ENCAP_SEG6                      = 0x0
-       BPF_LWT_ENCAP_SEG6_INLINE               = 0x1
-       BPF_LWT_ENCAP_IP                        = 0x2
-       BPF_OK                                  = 0x0
-       BPF_DROP                                = 0x2
-       BPF_REDIRECT                            = 0x7
-       BPF_LWT_REROUTE                         = 0x80
-       BPF_SOCK_OPS_RTO_CB_FLAG                = 0x1
-       BPF_SOCK_OPS_RETRANS_CB_FLAG            = 0x2
-       BPF_SOCK_OPS_STATE_CB_FLAG              = 0x4
-       BPF_SOCK_OPS_RTT_CB_FLAG                = 0x8
-       BPF_SOCK_OPS_ALL_CB_FLAGS               = 0xf
-       BPF_SOCK_OPS_VOID                       = 0x0
-       BPF_SOCK_OPS_TIMEOUT_INIT               = 0x1
-       BPF_SOCK_OPS_RWND_INIT                  = 0x2
-       BPF_SOCK_OPS_TCP_CONNECT_CB             = 0x3
-       BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB      = 0x4
-       BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB     = 0x5
-       BPF_SOCK_OPS_NEEDS_ECN                  = 0x6
-       BPF_SOCK_OPS_BASE_RTT                   = 0x7
-       BPF_SOCK_OPS_RTO_CB                     = 0x8
-       BPF_SOCK_OPS_RETRANS_CB                 = 0x9
-       BPF_SOCK_OPS_STATE_CB                   = 0xa
-       BPF_SOCK_OPS_TCP_LISTEN_CB              = 0xb
-       BPF_SOCK_OPS_RTT_CB                     = 0xc
-       BPF_TCP_ESTABLISHED                     = 0x1
-       BPF_TCP_SYN_SENT                        = 0x2
-       BPF_TCP_SYN_RECV                        = 0x3
-       BPF_TCP_FIN_WAIT1                       = 0x4
-       BPF_TCP_FIN_WAIT2                       = 0x5
-       BPF_TCP_TIME_WAIT                       = 0x6
-       BPF_TCP_CLOSE                           = 0x7
-       BPF_TCP_CLOSE_WAIT                      = 0x8
-       BPF_TCP_LAST_ACK                        = 0x9
-       BPF_TCP_LISTEN                          = 0xa
-       BPF_TCP_CLOSING                         = 0xb
-       BPF_TCP_NEW_SYN_RECV                    = 0xc
-       BPF_TCP_MAX_STATES                      = 0xd
-       TCP_BPF_IW                              = 0x3e9
-       TCP_BPF_SNDCWND_CLAMP                   = 0x3ea
-       BPF_DEVCG_ACC_MKNOD                     = 0x1
-       BPF_DEVCG_ACC_READ                      = 0x2
-       BPF_DEVCG_ACC_WRITE                     = 0x4
-       BPF_DEVCG_DEV_BLOCK                     = 0x1
-       BPF_DEVCG_DEV_CHAR                      = 0x2
-       BPF_FIB_LOOKUP_DIRECT                   = 0x1
-       BPF_FIB_LOOKUP_OUTPUT                   = 0x2
-       BPF_FIB_LKUP_RET_SUCCESS                = 0x0
-       BPF_FIB_LKUP_RET_BLACKHOLE              = 0x1
-       BPF_FIB_LKUP_RET_UNREACHABLE            = 0x2
-       BPF_FIB_LKUP_RET_PROHIBIT               = 0x3
-       BPF_FIB_LKUP_RET_NOT_FWDED              = 0x4
-       BPF_FIB_LKUP_RET_FWD_DISABLED           = 0x5
-       BPF_FIB_LKUP_RET_UNSUPP_LWT             = 0x6
-       BPF_FIB_LKUP_RET_NO_NEIGH               = 0x7
-       BPF_FIB_LKUP_RET_FRAG_NEEDED            = 0x8
-       BPF_FD_TYPE_RAW_TRACEPOINT              = 0x0
-       BPF_FD_TYPE_TRACEPOINT                  = 0x1
-       BPF_FD_TYPE_KPROBE                      = 0x2
-       BPF_FD_TYPE_KRETPROBE                   = 0x3
-       BPF_FD_TYPE_UPROBE                      = 0x4
-       BPF_FD_TYPE_URETPROBE                   = 0x5
-       BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG     = 0x1
-       BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = 0x2
-       BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP      = 0x4
+       BPF_REG_0                                  = 0x0
+       BPF_REG_1                                  = 0x1
+       BPF_REG_2                                  = 0x2
+       BPF_REG_3                                  = 0x3
+       BPF_REG_4                                  = 0x4
+       BPF_REG_5                                  = 0x5
+       BPF_REG_6                                  = 0x6
+       BPF_REG_7                                  = 0x7
+       BPF_REG_8                                  = 0x8
+       BPF_REG_9                                  = 0x9
+       BPF_REG_10                                 = 0xa
+       BPF_MAP_CREATE                             = 0x0
+       BPF_MAP_LOOKUP_ELEM                        = 0x1
+       BPF_MAP_UPDATE_ELEM                        = 0x2
+       BPF_MAP_DELETE_ELEM                        = 0x3
+       BPF_MAP_GET_NEXT_KEY                       = 0x4
+       BPF_PROG_LOAD                              = 0x5
+       BPF_OBJ_PIN                                = 0x6
+       BPF_OBJ_GET                                = 0x7
+       BPF_PROG_ATTACH                            = 0x8
+       BPF_PROG_DETACH                            = 0x9
+       BPF_PROG_TEST_RUN                          = 0xa
+       BPF_PROG_GET_NEXT_ID                       = 0xb
+       BPF_MAP_GET_NEXT_ID                        = 0xc
+       BPF_PROG_GET_FD_BY_ID                      = 0xd
+       BPF_MAP_GET_FD_BY_ID                       = 0xe
+       BPF_OBJ_GET_INFO_BY_FD                     = 0xf
+       BPF_PROG_QUERY                             = 0x10
+       BPF_RAW_TRACEPOINT_OPEN                    = 0x11
+       BPF_BTF_LOAD                               = 0x12
+       BPF_BTF_GET_FD_BY_ID                       = 0x13
+       BPF_TASK_FD_QUERY                          = 0x14
+       BPF_MAP_LOOKUP_AND_DELETE_ELEM             = 0x15
+       BPF_MAP_FREEZE                             = 0x16
+       BPF_BTF_GET_NEXT_ID                        = 0x17
+       BPF_MAP_LOOKUP_BATCH                       = 0x18
+       BPF_MAP_LOOKUP_AND_DELETE_BATCH            = 0x19
+       BPF_MAP_UPDATE_BATCH                       = 0x1a
+       BPF_MAP_DELETE_BATCH                       = 0x1b
+       BPF_LINK_CREATE                            = 0x1c
+       BPF_LINK_UPDATE                            = 0x1d
+       BPF_LINK_GET_FD_BY_ID                      = 0x1e
+       BPF_LINK_GET_NEXT_ID                       = 0x1f
+       BPF_ENABLE_STATS                           = 0x20
+       BPF_ITER_CREATE                            = 0x21
+       BPF_LINK_DETACH                            = 0x22
+       BPF_PROG_BIND_MAP                          = 0x23
+       BPF_MAP_TYPE_UNSPEC                        = 0x0
+       BPF_MAP_TYPE_HASH                          = 0x1
+       BPF_MAP_TYPE_ARRAY                         = 0x2
+       BPF_MAP_TYPE_PROG_ARRAY                    = 0x3
+       BPF_MAP_TYPE_PERF_EVENT_ARRAY              = 0x4
+       BPF_MAP_TYPE_PERCPU_HASH                   = 0x5
+       BPF_MAP_TYPE_PERCPU_ARRAY                  = 0x6
+       BPF_MAP_TYPE_STACK_TRACE                   = 0x7
+       BPF_MAP_TYPE_CGROUP_ARRAY                  = 0x8
+       BPF_MAP_TYPE_LRU_HASH                      = 0x9
+       BPF_MAP_TYPE_LRU_PERCPU_HASH               = 0xa
+       BPF_MAP_TYPE_LPM_TRIE                      = 0xb
+       BPF_MAP_TYPE_ARRAY_OF_MAPS                 = 0xc
+       BPF_MAP_TYPE_HASH_OF_MAPS                  = 0xd
+       BPF_MAP_TYPE_DEVMAP                        = 0xe
+       BPF_MAP_TYPE_SOCKMAP                       = 0xf
+       BPF_MAP_TYPE_CPUMAP                        = 0x10
+       BPF_MAP_TYPE_XSKMAP                        = 0x11
+       BPF_MAP_TYPE_SOCKHASH                      = 0x12
+       BPF_MAP_TYPE_CGROUP_STORAGE                = 0x13
+       BPF_MAP_TYPE_REUSEPORT_SOCKARRAY           = 0x14
+       BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE         = 0x15
+       BPF_MAP_TYPE_QUEUE                         = 0x16
+       BPF_MAP_TYPE_STACK                         = 0x17
+       BPF_MAP_TYPE_SK_STORAGE                    = 0x18
+       BPF_MAP_TYPE_DEVMAP_HASH                   = 0x19
+       BPF_MAP_TYPE_STRUCT_OPS                    = 0x1a
+       BPF_MAP_TYPE_RINGBUF                       = 0x1b
+       BPF_MAP_TYPE_INODE_STORAGE                 = 0x1c
+       BPF_PROG_TYPE_UNSPEC                       = 0x0
+       BPF_PROG_TYPE_SOCKET_FILTER                = 0x1
+       BPF_PROG_TYPE_KPROBE                       = 0x2
+       BPF_PROG_TYPE_SCHED_CLS                    = 0x3
+       BPF_PROG_TYPE_SCHED_ACT                    = 0x4
+       BPF_PROG_TYPE_TRACEPOINT                   = 0x5
+       BPF_PROG_TYPE_XDP                          = 0x6
+       BPF_PROG_TYPE_PERF_EVENT                   = 0x7
+       BPF_PROG_TYPE_CGROUP_SKB                   = 0x8
+       BPF_PROG_TYPE_CGROUP_SOCK                  = 0x9
+       BPF_PROG_TYPE_LWT_IN                       = 0xa
+       BPF_PROG_TYPE_LWT_OUT                      = 0xb
+       BPF_PROG_TYPE_LWT_XMIT                     = 0xc
+       BPF_PROG_TYPE_SOCK_OPS                     = 0xd
+       BPF_PROG_TYPE_SK_SKB                       = 0xe
+       BPF_PROG_TYPE_CGROUP_DEVICE                = 0xf
+       BPF_PROG_TYPE_SK_MSG                       = 0x10
+       BPF_PROG_TYPE_RAW_TRACEPOINT               = 0x11
+       BPF_PROG_TYPE_CGROUP_SOCK_ADDR             = 0x12
+       BPF_PROG_TYPE_LWT_SEG6LOCAL                = 0x13
+       BPF_PROG_TYPE_LIRC_MODE2                   = 0x14
+       BPF_PROG_TYPE_SK_REUSEPORT                 = 0x15
+       BPF_PROG_TYPE_FLOW_DISSECTOR               = 0x16
+       BPF_PROG_TYPE_CGROUP_SYSCTL                = 0x17
+       BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE      = 0x18
+       BPF_PROG_TYPE_CGROUP_SOCKOPT               = 0x19
+       BPF_PROG_TYPE_TRACING                      = 0x1a
+       BPF_PROG_TYPE_STRUCT_OPS                   = 0x1b
+       BPF_PROG_TYPE_EXT                          = 0x1c
+       BPF_PROG_TYPE_LSM                          = 0x1d
+       BPF_PROG_TYPE_SK_LOOKUP                    = 0x1e
+       BPF_CGROUP_INET_INGRESS                    = 0x0
+       BPF_CGROUP_INET_EGRESS                     = 0x1
+       BPF_CGROUP_INET_SOCK_CREATE                = 0x2
+       BPF_CGROUP_SOCK_OPS                        = 0x3
+       BPF_SK_SKB_STREAM_PARSER                   = 0x4
+       BPF_SK_SKB_STREAM_VERDICT                  = 0x5
+       BPF_CGROUP_DEVICE                          = 0x6
+       BPF_SK_MSG_VERDICT                         = 0x7
+       BPF_CGROUP_INET4_BIND                      = 0x8
+       BPF_CGROUP_INET6_BIND                      = 0x9
+       BPF_CGROUP_INET4_CONNECT                   = 0xa
+       BPF_CGROUP_INET6_CONNECT                   = 0xb
+       BPF_CGROUP_INET4_POST_BIND                 = 0xc
+       BPF_CGROUP_INET6_POST_BIND                 = 0xd
+       BPF_CGROUP_UDP4_SENDMSG                    = 0xe
+       BPF_CGROUP_UDP6_SENDMSG                    = 0xf
+       BPF_LIRC_MODE2                             = 0x10
+       BPF_FLOW_DISSECTOR                         = 0x11
+       BPF_CGROUP_SYSCTL                          = 0x12
+       BPF_CGROUP_UDP4_RECVMSG                    = 0x13
+       BPF_CGROUP_UDP6_RECVMSG                    = 0x14
+       BPF_CGROUP_GETSOCKOPT                      = 0x15
+       BPF_CGROUP_SETSOCKOPT                      = 0x16
+       BPF_TRACE_RAW_TP                           = 0x17
+       BPF_TRACE_FENTRY                           = 0x18
+       BPF_TRACE_FEXIT                            = 0x19
+       BPF_MODIFY_RETURN                          = 0x1a
+       BPF_LSM_MAC                                = 0x1b
+       BPF_TRACE_ITER                             = 0x1c
+       BPF_CGROUP_INET4_GETPEERNAME               = 0x1d
+       BPF_CGROUP_INET6_GETPEERNAME               = 0x1e
+       BPF_CGROUP_INET4_GETSOCKNAME               = 0x1f
+       BPF_CGROUP_INET6_GETSOCKNAME               = 0x20
+       BPF_XDP_DEVMAP                             = 0x21
+       BPF_CGROUP_INET_SOCK_RELEASE               = 0x22
+       BPF_XDP_CPUMAP                             = 0x23
+       BPF_SK_LOOKUP                              = 0x24
+       BPF_XDP                                    = 0x25
+       BPF_LINK_TYPE_UNSPEC                       = 0x0
+       BPF_LINK_TYPE_RAW_TRACEPOINT               = 0x1
+       BPF_LINK_TYPE_TRACING                      = 0x2
+       BPF_LINK_TYPE_CGROUP                       = 0x3
+       BPF_LINK_TYPE_ITER                         = 0x4
+       BPF_LINK_TYPE_NETNS                        = 0x5
+       BPF_LINK_TYPE_XDP                          = 0x6
+       BPF_ANY                                    = 0x0
+       BPF_NOEXIST                                = 0x1
+       BPF_EXIST                                  = 0x2
+       BPF_F_LOCK                                 = 0x4
+       BPF_F_NO_PREALLOC                          = 0x1
+       BPF_F_NO_COMMON_LRU                        = 0x2
+       BPF_F_NUMA_NODE                            = 0x4
+       BPF_F_RDONLY                               = 0x8
+       BPF_F_WRONLY                               = 0x10
+       BPF_F_STACK_BUILD_ID                       = 0x20
+       BPF_F_ZERO_SEED                            = 0x40
+       BPF_F_RDONLY_PROG                          = 0x80
+       BPF_F_WRONLY_PROG                          = 0x100
+       BPF_F_CLONE                                = 0x200
+       BPF_F_MMAPABLE                             = 0x400
+       BPF_F_PRESERVE_ELEMS                       = 0x800
+       BPF_F_INNER_MAP                            = 0x1000
+       BPF_STATS_RUN_TIME                         = 0x0
+       BPF_STACK_BUILD_ID_EMPTY                   = 0x0
+       BPF_STACK_BUILD_ID_VALID                   = 0x1
+       BPF_STACK_BUILD_ID_IP                      = 0x2
+       BPF_F_RECOMPUTE_CSUM                       = 0x1
+       BPF_F_INVALIDATE_HASH                      = 0x2
+       BPF_F_HDR_FIELD_MASK                       = 0xf
+       BPF_F_PSEUDO_HDR                           = 0x10
+       BPF_F_MARK_MANGLED_0                       = 0x20
+       BPF_F_MARK_ENFORCE                         = 0x40
+       BPF_F_INGRESS                              = 0x1
+       BPF_F_TUNINFO_IPV6                         = 0x1
+       BPF_F_SKIP_FIELD_MASK                      = 0xff
+       BPF_F_USER_STACK                           = 0x100
+       BPF_F_FAST_STACK_CMP                       = 0x200
+       BPF_F_REUSE_STACKID                        = 0x400
+       BPF_F_USER_BUILD_ID                        = 0x800
+       BPF_F_ZERO_CSUM_TX                         = 0x2
+       BPF_F_DONT_FRAGMENT                        = 0x4
+       BPF_F_SEQ_NUMBER                           = 0x8
+       BPF_F_INDEX_MASK                           = 0xffffffff
+       BPF_F_CURRENT_CPU                          = 0xffffffff
+       BPF_F_CTXLEN_MASK                          = 0xfffff00000000
+       BPF_F_CURRENT_NETNS                        = -0x1
+       BPF_CSUM_LEVEL_QUERY                       = 0x0
+       BPF_CSUM_LEVEL_INC                         = 0x1
+       BPF_CSUM_LEVEL_DEC                         = 0x2
+       BPF_CSUM_LEVEL_RESET                       = 0x3
+       BPF_F_ADJ_ROOM_FIXED_GSO                   = 0x1
+       BPF_F_ADJ_ROOM_ENCAP_L3_IPV4               = 0x2
+       BPF_F_ADJ_ROOM_ENCAP_L3_IPV6               = 0x4
+       BPF_F_ADJ_ROOM_ENCAP_L4_GRE                = 0x8
+       BPF_F_ADJ_ROOM_ENCAP_L4_UDP                = 0x10
+       BPF_F_ADJ_ROOM_NO_CSUM_RESET               = 0x20
+       BPF_ADJ_ROOM_ENCAP_L2_MASK                 = 0xff
+       BPF_ADJ_ROOM_ENCAP_L2_SHIFT                = 0x38
+       BPF_F_SYSCTL_BASE_NAME                     = 0x1
+       BPF_LOCAL_STORAGE_GET_F_CREATE             = 0x1
+       BPF_SK_STORAGE_GET_F_CREATE                = 0x1
+       BPF_F_GET_BRANCH_RECORDS_SIZE              = 0x1
+       BPF_RB_NO_WAKEUP                           = 0x1
+       BPF_RB_FORCE_WAKEUP                        = 0x2
+       BPF_RB_AVAIL_DATA                          = 0x0
+       BPF_RB_RING_SIZE                           = 0x1
+       BPF_RB_CONS_POS                            = 0x2
+       BPF_RB_PROD_POS                            = 0x3
+       BPF_RINGBUF_BUSY_BIT                       = 0x80000000
+       BPF_RINGBUF_DISCARD_BIT                    = 0x40000000
+       BPF_RINGBUF_HDR_SZ                         = 0x8
+       BPF_SK_LOOKUP_F_REPLACE                    = 0x1
+       BPF_SK_LOOKUP_F_NO_REUSEPORT               = 0x2
+       BPF_ADJ_ROOM_NET                           = 0x0
+       BPF_ADJ_ROOM_MAC                           = 0x1
+       BPF_HDR_START_MAC                          = 0x0
+       BPF_HDR_START_NET                          = 0x1
+       BPF_LWT_ENCAP_SEG6                         = 0x0
+       BPF_LWT_ENCAP_SEG6_INLINE                  = 0x1
+       BPF_LWT_ENCAP_IP                           = 0x2
+       BPF_OK                                     = 0x0
+       BPF_DROP                                   = 0x2
+       BPF_REDIRECT                               = 0x7
+       BPF_LWT_REROUTE                            = 0x80
+       BPF_SOCK_OPS_RTO_CB_FLAG                   = 0x1
+       BPF_SOCK_OPS_RETRANS_CB_FLAG               = 0x2
+       BPF_SOCK_OPS_STATE_CB_FLAG                 = 0x4
+       BPF_SOCK_OPS_RTT_CB_FLAG                   = 0x8
+       BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG     = 0x10
+       BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG = 0x20
+       BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG         = 0x40
+       BPF_SOCK_OPS_ALL_CB_FLAGS                  = 0x7f
+       BPF_SOCK_OPS_VOID                          = 0x0
+       BPF_SOCK_OPS_TIMEOUT_INIT                  = 0x1
+       BPF_SOCK_OPS_RWND_INIT                     = 0x2
+       BPF_SOCK_OPS_TCP_CONNECT_CB                = 0x3
+       BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB         = 0x4
+       BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB        = 0x5
+       BPF_SOCK_OPS_NEEDS_ECN                     = 0x6
+       BPF_SOCK_OPS_BASE_RTT                      = 0x7
+       BPF_SOCK_OPS_RTO_CB                        = 0x8
+       BPF_SOCK_OPS_RETRANS_CB                    = 0x9
+       BPF_SOCK_OPS_STATE_CB                      = 0xa
+       BPF_SOCK_OPS_TCP_LISTEN_CB                 = 0xb
+       BPF_SOCK_OPS_RTT_CB                        = 0xc
+       BPF_SOCK_OPS_PARSE_HDR_OPT_CB              = 0xd
+       BPF_SOCK_OPS_HDR_OPT_LEN_CB                = 0xe
+       BPF_SOCK_OPS_WRITE_HDR_OPT_CB              = 0xf
+       BPF_TCP_ESTABLISHED                        = 0x1
+       BPF_TCP_SYN_SENT                           = 0x2
+       BPF_TCP_SYN_RECV                           = 0x3
+       BPF_TCP_FIN_WAIT1                          = 0x4
+       BPF_TCP_FIN_WAIT2                          = 0x5
+       BPF_TCP_TIME_WAIT                          = 0x6
+       BPF_TCP_CLOSE                              = 0x7
+       BPF_TCP_CLOSE_WAIT                         = 0x8
+       BPF_TCP_LAST_ACK                           = 0x9
+       BPF_TCP_LISTEN                             = 0xa
+       BPF_TCP_CLOSING                            = 0xb
+       BPF_TCP_NEW_SYN_RECV                       = 0xc
+       BPF_TCP_MAX_STATES                         = 0xd
+       TCP_BPF_IW                                 = 0x3e9
+       TCP_BPF_SNDCWND_CLAMP                      = 0x3ea
+       TCP_BPF_DELACK_MAX                         = 0x3eb
+       TCP_BPF_RTO_MIN                            = 0x3ec
+       TCP_BPF_SYN                                = 0x3ed
+       TCP_BPF_SYN_IP                             = 0x3ee
+       TCP_BPF_SYN_MAC                            = 0x3ef
+       BPF_LOAD_HDR_OPT_TCP_SYN                   = 0x1
+       BPF_WRITE_HDR_TCP_CURRENT_MSS              = 0x1
+       BPF_WRITE_HDR_TCP_SYNACK_COOKIE            = 0x2
+       BPF_DEVCG_ACC_MKNOD                        = 0x1
+       BPF_DEVCG_ACC_READ                         = 0x2
+       BPF_DEVCG_ACC_WRITE                        = 0x4
+       BPF_DEVCG_DEV_BLOCK                        = 0x1
+       BPF_DEVCG_DEV_CHAR                         = 0x2
+       BPF_FIB_LOOKUP_DIRECT                      = 0x1
+       BPF_FIB_LOOKUP_OUTPUT                      = 0x2
+       BPF_FIB_LKUP_RET_SUCCESS                   = 0x0
+       BPF_FIB_LKUP_RET_BLACKHOLE                 = 0x1
+       BPF_FIB_LKUP_RET_UNREACHABLE               = 0x2
+       BPF_FIB_LKUP_RET_PROHIBIT                  = 0x3
+       BPF_FIB_LKUP_RET_NOT_FWDED                 = 0x4
+       BPF_FIB_LKUP_RET_FWD_DISABLED              = 0x5
+       BPF_FIB_LKUP_RET_UNSUPP_LWT                = 0x6
+       BPF_FIB_LKUP_RET_NO_NEIGH                  = 0x7
+       BPF_FIB_LKUP_RET_FRAG_NEEDED               = 0x8
+       BPF_FD_TYPE_RAW_TRACEPOINT                 = 0x0
+       BPF_FD_TYPE_TRACEPOINT                     = 0x1
+       BPF_FD_TYPE_KPROBE                         = 0x2
+       BPF_FD_TYPE_KRETPROBE                      = 0x3
+       BPF_FD_TYPE_UPROBE                         = 0x4
+       BPF_FD_TYPE_URETPROBE                      = 0x5
+       BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG        = 0x1
+       BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL    = 0x2
+       BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP         = 0x4
 )
 
 const (
@@ -2681,6 +2719,7 @@ const (
        RTNLGRP_IPV4_MROUTE_R = 0x1e
        RTNLGRP_IPV6_MROUTE_R = 0x1f
        RTNLGRP_NEXTHOP       = 0x20
+       RTNLGRP_BRVLAN        = 0x21
 )
 
 type CapUserHeader struct {
@@ -2775,132 +2814,317 @@ const (
 )
 
 const (
-       DEVLINK_CMD_UNSPEC                        = 0x0
-       DEVLINK_CMD_GET                           = 0x1
-       DEVLINK_CMD_SET                           = 0x2
-       DEVLINK_CMD_NEW                           = 0x3
-       DEVLINK_CMD_DEL                           = 0x4
-       DEVLINK_CMD_PORT_GET                      = 0x5
-       DEVLINK_CMD_PORT_SET                      = 0x6
-       DEVLINK_CMD_PORT_NEW                      = 0x7
-       DEVLINK_CMD_PORT_DEL                      = 0x8
-       DEVLINK_CMD_PORT_SPLIT                    = 0x9
-       DEVLINK_CMD_PORT_UNSPLIT                  = 0xa
-       DEVLINK_CMD_SB_GET                        = 0xb
-       DEVLINK_CMD_SB_SET                        = 0xc
-       DEVLINK_CMD_SB_NEW                        = 0xd
-       DEVLINK_CMD_SB_DEL                        = 0xe
-       DEVLINK_CMD_SB_POOL_GET                   = 0xf
-       DEVLINK_CMD_SB_POOL_SET                   = 0x10
-       DEVLINK_CMD_SB_POOL_NEW                   = 0x11
-       DEVLINK_CMD_SB_POOL_DEL                   = 0x12
-       DEVLINK_CMD_SB_PORT_POOL_GET              = 0x13
-       DEVLINK_CMD_SB_PORT_POOL_SET              = 0x14
-       DEVLINK_CMD_SB_PORT_POOL_NEW              = 0x15
-       DEVLINK_CMD_SB_PORT_POOL_DEL              = 0x16
-       DEVLINK_CMD_SB_TC_POOL_BIND_GET           = 0x17
-       DEVLINK_CMD_SB_TC_POOL_BIND_SET           = 0x18
-       DEVLINK_CMD_SB_TC_POOL_BIND_NEW           = 0x19
-       DEVLINK_CMD_SB_TC_POOL_BIND_DEL           = 0x1a
-       DEVLINK_CMD_SB_OCC_SNAPSHOT               = 0x1b
-       DEVLINK_CMD_SB_OCC_MAX_CLEAR              = 0x1c
-       DEVLINK_CMD_ESWITCH_GET                   = 0x1d
-       DEVLINK_CMD_ESWITCH_SET                   = 0x1e
-       DEVLINK_CMD_DPIPE_TABLE_GET               = 0x1f
-       DEVLINK_CMD_DPIPE_ENTRIES_GET             = 0x20
-       DEVLINK_CMD_DPIPE_HEADERS_GET             = 0x21
-       DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET      = 0x22
-       DEVLINK_CMD_MAX                           = 0x48
-       DEVLINK_PORT_TYPE_NOTSET                  = 0x0
-       DEVLINK_PORT_TYPE_AUTO                    = 0x1
-       DEVLINK_PORT_TYPE_ETH                     = 0x2
-       DEVLINK_PORT_TYPE_IB                      = 0x3
-       DEVLINK_SB_POOL_TYPE_INGRESS              = 0x0
-       DEVLINK_SB_POOL_TYPE_EGRESS               = 0x1
-       DEVLINK_SB_THRESHOLD_TYPE_STATIC          = 0x0
-       DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC         = 0x1
-       DEVLINK_ESWITCH_MODE_LEGACY               = 0x0
-       DEVLINK_ESWITCH_MODE_SWITCHDEV            = 0x1
-       DEVLINK_ESWITCH_INLINE_MODE_NONE          = 0x0
-       DEVLINK_ESWITCH_INLINE_MODE_LINK          = 0x1
-       DEVLINK_ESWITCH_INLINE_MODE_NETWORK       = 0x2
-       DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT     = 0x3
-       DEVLINK_ESWITCH_ENCAP_MODE_NONE           = 0x0
-       DEVLINK_ESWITCH_ENCAP_MODE_BASIC          = 0x1
-       DEVLINK_ATTR_UNSPEC                       = 0x0
-       DEVLINK_ATTR_BUS_NAME                     = 0x1
-       DEVLINK_ATTR_DEV_NAME                     = 0x2
-       DEVLINK_ATTR_PORT_INDEX                   = 0x3
-       DEVLINK_ATTR_PORT_TYPE                    = 0x4
-       DEVLINK_ATTR_PORT_DESIRED_TYPE            = 0x5
-       DEVLINK_ATTR_PORT_NETDEV_IFINDEX          = 0x6
-       DEVLINK_ATTR_PORT_NETDEV_NAME             = 0x7
-       DEVLINK_ATTR_PORT_IBDEV_NAME              = 0x8
-       DEVLINK_ATTR_PORT_SPLIT_COUNT             = 0x9
-       DEVLINK_ATTR_PORT_SPLIT_GROUP             = 0xa
-       DEVLINK_ATTR_SB_INDEX                     = 0xb
-       DEVLINK_ATTR_SB_SIZE                      = 0xc
-       DEVLINK_ATTR_SB_INGRESS_POOL_COUNT        = 0xd
-       DEVLINK_ATTR_SB_EGRESS_POOL_COUNT         = 0xe
-       DEVLINK_ATTR_SB_INGRESS_TC_COUNT          = 0xf
-       DEVLINK_ATTR_SB_EGRESS_TC_COUNT           = 0x10
-       DEVLINK_ATTR_SB_POOL_INDEX                = 0x11
-       DEVLINK_ATTR_SB_POOL_TYPE                 = 0x12
-       DEVLINK_ATTR_SB_POOL_SIZE                 = 0x13
-       DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE       = 0x14
-       DEVLINK_ATTR_SB_THRESHOLD                 = 0x15
-       DEVLINK_ATTR_SB_TC_INDEX                  = 0x16
-       DEVLINK_ATTR_SB_OCC_CUR                   = 0x17
-       DEVLINK_ATTR_SB_OCC_MAX                   = 0x18
-       DEVLINK_ATTR_ESWITCH_MODE                 = 0x19
-       DEVLINK_ATTR_ESWITCH_INLINE_MODE          = 0x1a
-       DEVLINK_ATTR_DPIPE_TABLES                 = 0x1b
-       DEVLINK_ATTR_DPIPE_TABLE                  = 0x1c
-       DEVLINK_ATTR_DPIPE_TABLE_NAME             = 0x1d
-       DEVLINK_ATTR_DPIPE_TABLE_SIZE             = 0x1e
-       DEVLINK_ATTR_DPIPE_TABLE_MATCHES          = 0x1f
-       DEVLINK_ATTR_DPIPE_TABLE_ACTIONS          = 0x20
-       DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED = 0x21
-       DEVLINK_ATTR_DPIPE_ENTRIES                = 0x22
-       DEVLINK_ATTR_DPIPE_ENTRY                  = 0x23
-       DEVLINK_ATTR_DPIPE_ENTRY_INDEX            = 0x24
-       DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES     = 0x25
-       DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES    = 0x26
-       DEVLINK_ATTR_DPIPE_ENTRY_COUNTER          = 0x27
-       DEVLINK_ATTR_DPIPE_MATCH                  = 0x28
-       DEVLINK_ATTR_DPIPE_MATCH_VALUE            = 0x29
-       DEVLINK_ATTR_DPIPE_MATCH_TYPE             = 0x2a
-       DEVLINK_ATTR_DPIPE_ACTION                 = 0x2b
-       DEVLINK_ATTR_DPIPE_ACTION_VALUE           = 0x2c
-       DEVLINK_ATTR_DPIPE_ACTION_TYPE            = 0x2d
-       DEVLINK_ATTR_DPIPE_VALUE                  = 0x2e
-       DEVLINK_ATTR_DPIPE_VALUE_MASK             = 0x2f
-       DEVLINK_ATTR_DPIPE_VALUE_MAPPING          = 0x30
-       DEVLINK_ATTR_DPIPE_HEADERS                = 0x31
-       DEVLINK_ATTR_DPIPE_HEADER                 = 0x32
-       DEVLINK_ATTR_DPIPE_HEADER_NAME            = 0x33
-       DEVLINK_ATTR_DPIPE_HEADER_ID              = 0x34
-       DEVLINK_ATTR_DPIPE_HEADER_FIELDS          = 0x35
-       DEVLINK_ATTR_DPIPE_HEADER_GLOBAL          = 0x36
-       DEVLINK_ATTR_DPIPE_HEADER_INDEX           = 0x37
-       DEVLINK_ATTR_DPIPE_FIELD                  = 0x38
-       DEVLINK_ATTR_DPIPE_FIELD_NAME             = 0x39
-       DEVLINK_ATTR_DPIPE_FIELD_ID               = 0x3a
-       DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH         = 0x3b
-       DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE     = 0x3c
-       DEVLINK_ATTR_PAD                          = 0x3d
-       DEVLINK_ATTR_ESWITCH_ENCAP_MODE           = 0x3e
-       DEVLINK_ATTR_MAX                          = 0x94
-       DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE     = 0x0
-       DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX  = 0x1
-       DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT      = 0x0
-       DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY    = 0x0
-       DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC      = 0x0
-       DEVLINK_DPIPE_FIELD_IPV4_DST_IP           = 0x0
-       DEVLINK_DPIPE_FIELD_IPV6_DST_IP           = 0x0
-       DEVLINK_DPIPE_HEADER_ETHERNET             = 0x0
-       DEVLINK_DPIPE_HEADER_IPV4                 = 0x1
-       DEVLINK_DPIPE_HEADER_IPV6                 = 0x2
+       DEVLINK_CMD_UNSPEC                                 = 0x0
+       DEVLINK_CMD_GET                                    = 0x1
+       DEVLINK_CMD_SET                                    = 0x2
+       DEVLINK_CMD_NEW                                    = 0x3
+       DEVLINK_CMD_DEL                                    = 0x4
+       DEVLINK_CMD_PORT_GET                               = 0x5
+       DEVLINK_CMD_PORT_SET                               = 0x6
+       DEVLINK_CMD_PORT_NEW                               = 0x7
+       DEVLINK_CMD_PORT_DEL                               = 0x8
+       DEVLINK_CMD_PORT_SPLIT                             = 0x9
+       DEVLINK_CMD_PORT_UNSPLIT                           = 0xa
+       DEVLINK_CMD_SB_GET                                 = 0xb
+       DEVLINK_CMD_SB_SET                                 = 0xc
+       DEVLINK_CMD_SB_NEW                                 = 0xd
+       DEVLINK_CMD_SB_DEL                                 = 0xe
+       DEVLINK_CMD_SB_POOL_GET                            = 0xf
+       DEVLINK_CMD_SB_POOL_SET                            = 0x10
+       DEVLINK_CMD_SB_POOL_NEW                            = 0x11
+       DEVLINK_CMD_SB_POOL_DEL                            = 0x12
+       DEVLINK_CMD_SB_PORT_POOL_GET                       = 0x13
+       DEVLINK_CMD_SB_PORT_POOL_SET                       = 0x14
+       DEVLINK_CMD_SB_PORT_POOL_NEW                       = 0x15
+       DEVLINK_CMD_SB_PORT_POOL_DEL                       = 0x16
+       DEVLINK_CMD_SB_TC_POOL_BIND_GET                    = 0x17
+       DEVLINK_CMD_SB_TC_POOL_BIND_SET                    = 0x18
+       DEVLINK_CMD_SB_TC_POOL_BIND_NEW                    = 0x19
+       DEVLINK_CMD_SB_TC_POOL_BIND_DEL                    = 0x1a
+       DEVLINK_CMD_SB_OCC_SNAPSHOT                        = 0x1b
+       DEVLINK_CMD_SB_OCC_MAX_CLEAR                       = 0x1c
+       DEVLINK_CMD_ESWITCH_GET                            = 0x1d
+       DEVLINK_CMD_ESWITCH_SET                            = 0x1e
+       DEVLINK_CMD_DPIPE_TABLE_GET                        = 0x1f
+       DEVLINK_CMD_DPIPE_ENTRIES_GET                      = 0x20
+       DEVLINK_CMD_DPIPE_HEADERS_GET                      = 0x21
+       DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET               = 0x22
+       DEVLINK_CMD_RESOURCE_SET                           = 0x23
+       DEVLINK_CMD_RESOURCE_DUMP                          = 0x24
+       DEVLINK_CMD_RELOAD                                 = 0x25
+       DEVLINK_CMD_PARAM_GET                              = 0x26
+       DEVLINK_CMD_PARAM_SET                              = 0x27
+       DEVLINK_CMD_PARAM_NEW                              = 0x28
+       DEVLINK_CMD_PARAM_DEL                              = 0x29
+       DEVLINK_CMD_REGION_GET                             = 0x2a
+       DEVLINK_CMD_REGION_SET                             = 0x2b
+       DEVLINK_CMD_REGION_NEW                             = 0x2c
+       DEVLINK_CMD_REGION_DEL                             = 0x2d
+       DEVLINK_CMD_REGION_READ                            = 0x2e
+       DEVLINK_CMD_PORT_PARAM_GET                         = 0x2f
+       DEVLINK_CMD_PORT_PARAM_SET                         = 0x30
+       DEVLINK_CMD_PORT_PARAM_NEW                         = 0x31
+       DEVLINK_CMD_PORT_PARAM_DEL                         = 0x32
+       DEVLINK_CMD_INFO_GET                               = 0x33
+       DEVLINK_CMD_HEALTH_REPORTER_GET                    = 0x34
+       DEVLINK_CMD_HEALTH_REPORTER_SET                    = 0x35
+       DEVLINK_CMD_HEALTH_REPORTER_RECOVER                = 0x36
+       DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE               = 0x37
+       DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET               = 0x38
+       DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR             = 0x39
+       DEVLINK_CMD_FLASH_UPDATE                           = 0x3a
+       DEVLINK_CMD_FLASH_UPDATE_END                       = 0x3b
+       DEVLINK_CMD_FLASH_UPDATE_STATUS                    = 0x3c
+       DEVLINK_CMD_TRAP_GET                               = 0x3d
+       DEVLINK_CMD_TRAP_SET                               = 0x3e
+       DEVLINK_CMD_TRAP_NEW                               = 0x3f
+       DEVLINK_CMD_TRAP_DEL                               = 0x40
+       DEVLINK_CMD_TRAP_GROUP_GET                         = 0x41
+       DEVLINK_CMD_TRAP_GROUP_SET                         = 0x42
+       DEVLINK_CMD_TRAP_GROUP_NEW                         = 0x43
+       DEVLINK_CMD_TRAP_GROUP_DEL                         = 0x44
+       DEVLINK_CMD_TRAP_POLICER_GET                       = 0x45
+       DEVLINK_CMD_TRAP_POLICER_SET                       = 0x46
+       DEVLINK_CMD_TRAP_POLICER_NEW                       = 0x47
+       DEVLINK_CMD_TRAP_POLICER_DEL                       = 0x48
+       DEVLINK_CMD_HEALTH_REPORTER_TEST                   = 0x49
+       DEVLINK_CMD_MAX                                    = 0x49
+       DEVLINK_PORT_TYPE_NOTSET                           = 0x0
+       DEVLINK_PORT_TYPE_AUTO                             = 0x1
+       DEVLINK_PORT_TYPE_ETH                              = 0x2
+       DEVLINK_PORT_TYPE_IB                               = 0x3
+       DEVLINK_SB_POOL_TYPE_INGRESS                       = 0x0
+       DEVLINK_SB_POOL_TYPE_EGRESS                        = 0x1
+       DEVLINK_SB_THRESHOLD_TYPE_STATIC                   = 0x0
+       DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC                  = 0x1
+       DEVLINK_ESWITCH_MODE_LEGACY                        = 0x0
+       DEVLINK_ESWITCH_MODE_SWITCHDEV                     = 0x1
+       DEVLINK_ESWITCH_INLINE_MODE_NONE                   = 0x0
+       DEVLINK_ESWITCH_INLINE_MODE_LINK                   = 0x1
+       DEVLINK_ESWITCH_INLINE_MODE_NETWORK                = 0x2
+       DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT              = 0x3
+       DEVLINK_ESWITCH_ENCAP_MODE_NONE                    = 0x0
+       DEVLINK_ESWITCH_ENCAP_MODE_BASIC                   = 0x1
+       DEVLINK_PORT_FLAVOUR_PHYSICAL                      = 0x0
+       DEVLINK_PORT_FLAVOUR_CPU                           = 0x1
+       DEVLINK_PORT_FLAVOUR_DSA                           = 0x2
+       DEVLINK_PORT_FLAVOUR_PCI_PF                        = 0x3
+       DEVLINK_PORT_FLAVOUR_PCI_VF                        = 0x4
+       DEVLINK_PORT_FLAVOUR_VIRTUAL                       = 0x5
+       DEVLINK_PORT_FLAVOUR_UNUSED                        = 0x6
+       DEVLINK_PARAM_CMODE_RUNTIME                        = 0x0
+       DEVLINK_PARAM_CMODE_DRIVERINIT                     = 0x1
+       DEVLINK_PARAM_CMODE_PERMANENT                      = 0x2
+       DEVLINK_PARAM_CMODE_MAX                            = 0x2
+       DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER          = 0x0
+       DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH           = 0x1
+       DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK            = 0x2
+       DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_UNKNOWN         = 0x3
+       DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_UNKNOWN = 0x0
+       DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_ALWAYS  = 0x1
+       DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_NEVER   = 0x2
+       DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_DISK    = 0x3
+       DEVLINK_ATTR_STATS_RX_PACKETS                      = 0x0
+       DEVLINK_ATTR_STATS_RX_BYTES                        = 0x1
+       DEVLINK_ATTR_STATS_RX_DROPPED                      = 0x2
+       DEVLINK_ATTR_STATS_MAX                             = 0x2
+       DEVLINK_FLASH_OVERWRITE_SETTINGS_BIT               = 0x0
+       DEVLINK_FLASH_OVERWRITE_IDENTIFIERS_BIT            = 0x1
+       DEVLINK_FLASH_OVERWRITE_MAX_BIT                    = 0x1
+       DEVLINK_TRAP_ACTION_DROP                           = 0x0
+       DEVLINK_TRAP_ACTION_TRAP                           = 0x1
+       DEVLINK_TRAP_ACTION_MIRROR                         = 0x2
+       DEVLINK_TRAP_TYPE_DROP                             = 0x0
+       DEVLINK_TRAP_TYPE_EXCEPTION                        = 0x1
+       DEVLINK_TRAP_TYPE_CONTROL                          = 0x2
+       DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT            = 0x0
+       DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE          = 0x1
+       DEVLINK_RELOAD_ACTION_UNSPEC                       = 0x0
+       DEVLINK_RELOAD_ACTION_DRIVER_REINIT                = 0x1
+       DEVLINK_RELOAD_ACTION_FW_ACTIVATE                  = 0x2
+       DEVLINK_RELOAD_ACTION_MAX                          = 0x2
+       DEVLINK_RELOAD_LIMIT_UNSPEC                        = 0x0
+       DEVLINK_RELOAD_LIMIT_NO_RESET                      = 0x1
+       DEVLINK_RELOAD_LIMIT_MAX                           = 0x1
+       DEVLINK_ATTR_UNSPEC                                = 0x0
+       DEVLINK_ATTR_BUS_NAME                              = 0x1
+       DEVLINK_ATTR_DEV_NAME                              = 0x2
+       DEVLINK_ATTR_PORT_INDEX                            = 0x3
+       DEVLINK_ATTR_PORT_TYPE                             = 0x4
+       DEVLINK_ATTR_PORT_DESIRED_TYPE                     = 0x5
+       DEVLINK_ATTR_PORT_NETDEV_IFINDEX                   = 0x6
+       DEVLINK_ATTR_PORT_NETDEV_NAME                      = 0x7
+       DEVLINK_ATTR_PORT_IBDEV_NAME                       = 0x8
+       DEVLINK_ATTR_PORT_SPLIT_COUNT                      = 0x9
+       DEVLINK_ATTR_PORT_SPLIT_GROUP                      = 0xa
+       DEVLINK_ATTR_SB_INDEX                              = 0xb
+       DEVLINK_ATTR_SB_SIZE                               = 0xc
+       DEVLINK_ATTR_SB_INGRESS_POOL_COUNT                 = 0xd
+       DEVLINK_ATTR_SB_EGRESS_POOL_COUNT                  = 0xe
+       DEVLINK_ATTR_SB_INGRESS_TC_COUNT                   = 0xf
+       DEVLINK_ATTR_SB_EGRESS_TC_COUNT                    = 0x10
+       DEVLINK_ATTR_SB_POOL_INDEX                         = 0x11
+       DEVLINK_ATTR_SB_POOL_TYPE                          = 0x12
+       DEVLINK_ATTR_SB_POOL_SIZE                          = 0x13
+       DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE                = 0x14
+       DEVLINK_ATTR_SB_THRESHOLD                          = 0x15
+       DEVLINK_ATTR_SB_TC_INDEX                           = 0x16
+       DEVLINK_ATTR_SB_OCC_CUR                            = 0x17
+       DEVLINK_ATTR_SB_OCC_MAX                            = 0x18
+       DEVLINK_ATTR_ESWITCH_MODE                          = 0x19
+       DEVLINK_ATTR_ESWITCH_INLINE_MODE                   = 0x1a
+       DEVLINK_ATTR_DPIPE_TABLES                          = 0x1b
+       DEVLINK_ATTR_DPIPE_TABLE                           = 0x1c
+       DEVLINK_ATTR_DPIPE_TABLE_NAME                      = 0x1d
+       DEVLINK_ATTR_DPIPE_TABLE_SIZE                      = 0x1e
+       DEVLINK_ATTR_DPIPE_TABLE_MATCHES                   = 0x1f
+       DEVLINK_ATTR_DPIPE_TABLE_ACTIONS                   = 0x20
+       DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED          = 0x21
+       DEVLINK_ATTR_DPIPE_ENTRIES                         = 0x22
+       DEVLINK_ATTR_DPIPE_ENTRY                           = 0x23
+       DEVLINK_ATTR_DPIPE_ENTRY_INDEX                     = 0x24
+       DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES              = 0x25
+       DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES             = 0x26
+       DEVLINK_ATTR_DPIPE_ENTRY_COUNTER                   = 0x27
+       DEVLINK_ATTR_DPIPE_MATCH                           = 0x28
+       DEVLINK_ATTR_DPIPE_MATCH_VALUE                     = 0x29
+       DEVLINK_ATTR_DPIPE_MATCH_TYPE                      = 0x2a
+       DEVLINK_ATTR_DPIPE_ACTION                          = 0x2b
+       DEVLINK_ATTR_DPIPE_ACTION_VALUE                    = 0x2c
+       DEVLINK_ATTR_DPIPE_ACTION_TYPE                     = 0x2d
+       DEVLINK_ATTR_DPIPE_VALUE                           = 0x2e
+       DEVLINK_ATTR_DPIPE_VALUE_MASK                      = 0x2f
+       DEVLINK_ATTR_DPIPE_VALUE_MAPPING                   = 0x30
+       DEVLINK_ATTR_DPIPE_HEADERS                         = 0x31
+       DEVLINK_ATTR_DPIPE_HEADER                          = 0x32
+       DEVLINK_ATTR_DPIPE_HEADER_NAME                     = 0x33
+       DEVLINK_ATTR_DPIPE_HEADER_ID                       = 0x34
+       DEVLINK_ATTR_DPIPE_HEADER_FIELDS                   = 0x35
+       DEVLINK_ATTR_DPIPE_HEADER_GLOBAL                   = 0x36
+       DEVLINK_ATTR_DPIPE_HEADER_INDEX                    = 0x37
+       DEVLINK_ATTR_DPIPE_FIELD                           = 0x38
+       DEVLINK_ATTR_DPIPE_FIELD_NAME                      = 0x39
+       DEVLINK_ATTR_DPIPE_FIELD_ID                        = 0x3a
+       DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH                  = 0x3b
+       DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE              = 0x3c
+       DEVLINK_ATTR_PAD                                   = 0x3d
+       DEVLINK_ATTR_ESWITCH_ENCAP_MODE                    = 0x3e
+       DEVLINK_ATTR_RESOURCE_LIST                         = 0x3f
+       DEVLINK_ATTR_RESOURCE                              = 0x40
+       DEVLINK_ATTR_RESOURCE_NAME                         = 0x41
+       DEVLINK_ATTR_RESOURCE_ID                           = 0x42
+       DEVLINK_ATTR_RESOURCE_SIZE                         = 0x43
+       DEVLINK_ATTR_RESOURCE_SIZE_NEW                     = 0x44
+       DEVLINK_ATTR_RESOURCE_SIZE_VALID                   = 0x45
+       DEVLINK_ATTR_RESOURCE_SIZE_MIN                     = 0x46
+       DEVLINK_ATTR_RESOURCE_SIZE_MAX                     = 0x47
+       DEVLINK_ATTR_RESOURCE_SIZE_GRAN                    = 0x48
+       DEVLINK_ATTR_RESOURCE_UNIT                         = 0x49
+       DEVLINK_ATTR_RESOURCE_OCC                          = 0x4a
+       DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID               = 0x4b
+       DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS            = 0x4c
+       DEVLINK_ATTR_PORT_FLAVOUR                          = 0x4d
+       DEVLINK_ATTR_PORT_NUMBER                           = 0x4e
+       DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER             = 0x4f
+       DEVLINK_ATTR_PARAM                                 = 0x50
+       DEVLINK_ATTR_PARAM_NAME                            = 0x51
+       DEVLINK_ATTR_PARAM_GENERIC                         = 0x52
+       DEVLINK_ATTR_PARAM_TYPE                            = 0x53
+       DEVLINK_ATTR_PARAM_VALUES_LIST                     = 0x54
+       DEVLINK_ATTR_PARAM_VALUE                           = 0x55
+       DEVLINK_ATTR_PARAM_VALUE_DATA                      = 0x56
+       DEVLINK_ATTR_PARAM_VALUE_CMODE                     = 0x57
+       DEVLINK_ATTR_REGION_NAME                           = 0x58
+       DEVLINK_ATTR_REGION_SIZE                           = 0x59
+       DEVLINK_ATTR_REGION_SNAPSHOTS                      = 0x5a
+       DEVLINK_ATTR_REGION_SNAPSHOT                       = 0x5b
+       DEVLINK_ATTR_REGION_SNAPSHOT_ID                    = 0x5c
+       DEVLINK_ATTR_REGION_CHUNKS                         = 0x5d
+       DEVLINK_ATTR_REGION_CHUNK                          = 0x5e
+       DEVLINK_ATTR_REGION_CHUNK_DATA                     = 0x5f
+       DEVLINK_ATTR_REGION_CHUNK_ADDR                     = 0x60
+       DEVLINK_ATTR_REGION_CHUNK_LEN                      = 0x61
+       DEVLINK_ATTR_INFO_DRIVER_NAME                      = 0x62
+       DEVLINK_ATTR_INFO_SERIAL_NUMBER                    = 0x63
+       DEVLINK_ATTR_INFO_VERSION_FIXED                    = 0x64
+       DEVLINK_ATTR_INFO_VERSION_RUNNING                  = 0x65
+       DEVLINK_ATTR_INFO_VERSION_STORED                   = 0x66
+       DEVLINK_ATTR_INFO_VERSION_NAME                     = 0x67
+       DEVLINK_ATTR_INFO_VERSION_VALUE                    = 0x68
+       DEVLINK_ATTR_SB_POOL_CELL_SIZE                     = 0x69
+       DEVLINK_ATTR_FMSG                                  = 0x6a
+       DEVLINK_ATTR_FMSG_OBJ_NEST_START                   = 0x6b
+       DEVLINK_ATTR_FMSG_PAIR_NEST_START                  = 0x6c
+       DEVLINK_ATTR_FMSG_ARR_NEST_START                   = 0x6d
+       DEVLINK_ATTR_FMSG_NEST_END                         = 0x6e
+       DEVLINK_ATTR_FMSG_OBJ_NAME                         = 0x6f
+       DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE                   = 0x70
+       DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA                   = 0x71
+       DEVLINK_ATTR_HEALTH_REPORTER                       = 0x72
+       DEVLINK_ATTR_HEALTH_REPORTER_NAME                  = 0x73
+       DEVLINK_ATTR_HEALTH_REPORTER_STATE                 = 0x74
+       DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT             = 0x75
+       DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT         = 0x76
+       DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS               = 0x77
+       DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD       = 0x78
+       DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER          = 0x79
+       DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME                = 0x7a
+       DEVLINK_ATTR_FLASH_UPDATE_COMPONENT                = 0x7b
+       DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG               = 0x7c
+       DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE              = 0x7d
+       DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL             = 0x7e
+       DEVLINK_ATTR_PORT_PCI_PF_NUMBER                    = 0x7f
+       DEVLINK_ATTR_PORT_PCI_VF_NUMBER                    = 0x80
+       DEVLINK_ATTR_STATS                                 = 0x81
+       DEVLINK_ATTR_TRAP_NAME                             = 0x82
+       DEVLINK_ATTR_TRAP_ACTION                           = 0x83
+       DEVLINK_ATTR_TRAP_TYPE                             = 0x84
+       DEVLINK_ATTR_TRAP_GENERIC                          = 0x85
+       DEVLINK_ATTR_TRAP_METADATA                         = 0x86
+       DEVLINK_ATTR_TRAP_GROUP_NAME                       = 0x87
+       DEVLINK_ATTR_RELOAD_FAILED                         = 0x88
+       DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS            = 0x89
+       DEVLINK_ATTR_NETNS_FD                              = 0x8a
+       DEVLINK_ATTR_NETNS_PID                             = 0x8b
+       DEVLINK_ATTR_NETNS_ID                              = 0x8c
+       DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP             = 0x8d
+       DEVLINK_ATTR_TRAP_POLICER_ID                       = 0x8e
+       DEVLINK_ATTR_TRAP_POLICER_RATE                     = 0x8f
+       DEVLINK_ATTR_TRAP_POLICER_BURST                    = 0x90
+       DEVLINK_ATTR_PORT_FUNCTION                         = 0x91
+       DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER              = 0x92
+       DEVLINK_ATTR_PORT_LANES                            = 0x93
+       DEVLINK_ATTR_PORT_SPLITTABLE                       = 0x94
+       DEVLINK_ATTR_PORT_EXTERNAL                         = 0x95
+       DEVLINK_ATTR_PORT_CONTROLLER_NUMBER                = 0x96
+       DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT           = 0x97
+       DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK           = 0x98
+       DEVLINK_ATTR_RELOAD_ACTION                         = 0x99
+       DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED              = 0x9a
+       DEVLINK_ATTR_RELOAD_LIMITS                         = 0x9b
+       DEVLINK_ATTR_DEV_STATS                             = 0x9c
+       DEVLINK_ATTR_RELOAD_STATS                          = 0x9d
+       DEVLINK_ATTR_RELOAD_STATS_ENTRY                    = 0x9e
+       DEVLINK_ATTR_RELOAD_STATS_LIMIT                    = 0x9f
+       DEVLINK_ATTR_RELOAD_STATS_VALUE                    = 0xa0
+       DEVLINK_ATTR_REMOTE_RELOAD_STATS                   = 0xa1
+       DEVLINK_ATTR_RELOAD_ACTION_INFO                    = 0xa2
+       DEVLINK_ATTR_RELOAD_ACTION_STATS                   = 0xa3
+       DEVLINK_ATTR_MAX                                   = 0xa3
+       DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
+       DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
+       DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
+       DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY             = 0x0
+       DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC               = 0x0
+       DEVLINK_DPIPE_FIELD_IPV4_DST_IP                    = 0x0
+       DEVLINK_DPIPE_FIELD_IPV6_DST_IP                    = 0x0
+       DEVLINK_DPIPE_HEADER_ETHERNET                      = 0x0
+       DEVLINK_DPIPE_HEADER_IPV4                          = 0x1
+       DEVLINK_DPIPE_HEADER_IPV6                          = 0x2
+       DEVLINK_RESOURCE_UNIT_ENTRY                        = 0x0
+       DEVLINK_PORT_FUNCTION_ATTR_UNSPEC                  = 0x0
+       DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR                 = 0x1
+       DEVLINK_PORT_FUNCTION_ATTR_MAX                     = 0x1
 )
 
 type FsverityDigest struct {
@@ -2999,3 +3223,461 @@ const (
        MPLS_IPTUNNEL_TTL    = 0x2
        MPLS_IPTUNNEL_MAX    = 0x2
 )
+
+const (
+       ETHTOOL_ID_UNSPEC                                                       = 0x0
+       ETHTOOL_RX_COPYBREAK                                                    = 0x1
+       ETHTOOL_TX_COPYBREAK                                                    = 0x2
+       ETHTOOL_PFC_PREVENTION_TOUT                                             = 0x3
+       ETHTOOL_TUNABLE_UNSPEC                                                  = 0x0
+       ETHTOOL_TUNABLE_U8                                                      = 0x1
+       ETHTOOL_TUNABLE_U16                                                     = 0x2
+       ETHTOOL_TUNABLE_U32                                                     = 0x3
+       ETHTOOL_TUNABLE_U64                                                     = 0x4
+       ETHTOOL_TUNABLE_STRING                                                  = 0x5
+       ETHTOOL_TUNABLE_S8                                                      = 0x6
+       ETHTOOL_TUNABLE_S16                                                     = 0x7
+       ETHTOOL_TUNABLE_S32                                                     = 0x8
+       ETHTOOL_TUNABLE_S64                                                     = 0x9
+       ETHTOOL_PHY_ID_UNSPEC                                                   = 0x0
+       ETHTOOL_PHY_DOWNSHIFT                                                   = 0x1
+       ETHTOOL_PHY_FAST_LINK_DOWN                                              = 0x2
+       ETHTOOL_PHY_EDPD                                                        = 0x3
+       ETHTOOL_LINK_EXT_STATE_AUTONEG                                          = 0x0
+       ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE                            = 0x1
+       ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH                            = 0x2
+       ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY                             = 0x3
+       ETHTOOL_LINK_EXT_STATE_NO_CABLE                                         = 0x4
+       ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE                                      = 0x5
+       ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE                                     = 0x6
+       ETHTOOL_LINK_EXT_STATE_CALIBRATION_FAILURE                              = 0x7
+       ETHTOOL_LINK_EXT_STATE_POWER_BUDGET_EXCEEDED                            = 0x8
+       ETHTOOL_LINK_EXT_STATE_OVERHEAT                                         = 0x9
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED                        = 0x1
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED                           = 0x2
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_NEXT_PAGE_EXCHANGE_FAILED                  = 0x3
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED_FORCE_MODE             = 0x4
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_FEC_MISMATCH_DURING_OVERRIDE               = 0x5
+       ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD                                     = 0x6
+       ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_FRAME_LOCK_NOT_ACQUIRED                 = 0x1
+       ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT                    = 0x2
+       ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY = 0x3
+       ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT                               = 0x4
+       ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK            = 0x1
+       ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_AM_LOCK               = 0x2
+       ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_GET_ALIGN_STATUS              = 0x3
+       ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED                      = 0x4
+       ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED                      = 0x5
+       ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS           = 0x1
+       ETHTOOL_LINK_EXT_SUBSTATE_BSI_UNSUPPORTED_RATE                          = 0x2
+       ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE                          = 0x1
+       ETHTOOL_LINK_EXT_SUBSTATE_CI_CABLE_TEST_FAILURE                         = 0x2
+       ETHTOOL_FLASH_ALL_REGIONS                                               = 0x0
+       ETHTOOL_F_UNSUPPORTED__BIT                                              = 0x0
+       ETHTOOL_F_WISH__BIT                                                     = 0x1
+       ETHTOOL_F_COMPAT__BIT                                                   = 0x2
+       ETHTOOL_FEC_NONE_BIT                                                    = 0x0
+       ETHTOOL_FEC_AUTO_BIT                                                    = 0x1
+       ETHTOOL_FEC_OFF_BIT                                                     = 0x2
+       ETHTOOL_FEC_RS_BIT                                                      = 0x3
+       ETHTOOL_FEC_BASER_BIT                                                   = 0x4
+       ETHTOOL_FEC_LLRS_BIT                                                    = 0x5
+       ETHTOOL_LINK_MODE_10baseT_Half_BIT                                      = 0x0
+       ETHTOOL_LINK_MODE_10baseT_Full_BIT                                      = 0x1
+       ETHTOOL_LINK_MODE_100baseT_Half_BIT                                     = 0x2
+       ETHTOOL_LINK_MODE_100baseT_Full_BIT                                     = 0x3
+       ETHTOOL_LINK_MODE_1000baseT_Half_BIT                                    = 0x4
+       ETHTOOL_LINK_MODE_1000baseT_Full_BIT                                    = 0x5
+       ETHTOOL_LINK_MODE_Autoneg_BIT                                           = 0x6
+       ETHTOOL_LINK_MODE_TP_BIT                                                = 0x7
+       ETHTOOL_LINK_MODE_AUI_BIT                                               = 0x8
+       ETHTOOL_LINK_MODE_MII_BIT                                               = 0x9
+       ETHTOOL_LINK_MODE_FIBRE_BIT                                             = 0xa
+       ETHTOOL_LINK_MODE_BNC_BIT                                               = 0xb
+       ETHTOOL_LINK_MODE_10000baseT_Full_BIT                                   = 0xc
+       ETHTOOL_LINK_MODE_Pause_BIT                                             = 0xd
+       ETHTOOL_LINK_MODE_Asym_Pause_BIT                                        = 0xe
+       ETHTOOL_LINK_MODE_2500baseX_Full_BIT                                    = 0xf
+       ETHTOOL_LINK_MODE_Backplane_BIT                                         = 0x10
+       ETHTOOL_LINK_MODE_1000baseKX_Full_BIT                                   = 0x11
+       ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT                                 = 0x12
+       ETHTOOL_LINK_MODE_10000baseKR_Full_BIT                                  = 0x13
+       ETHTOOL_LINK_MODE_10000baseR_FEC_BIT                                    = 0x14
+       ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT                                = 0x15
+       ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT                                 = 0x16
+       ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT                                 = 0x17
+       ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT                                 = 0x18
+       ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT                                 = 0x19
+       ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT                                 = 0x1a
+       ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT                                 = 0x1b
+       ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT                                 = 0x1c
+       ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT                                 = 0x1d
+       ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT                                 = 0x1e
+       ETHTOOL_LINK_MODE_25000baseCR_Full_BIT                                  = 0x1f
+       ETHTOOL_LINK_MODE_25000baseKR_Full_BIT                                  = 0x20
+       ETHTOOL_LINK_MODE_25000baseSR_Full_BIT                                  = 0x21
+       ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT                                 = 0x22
+       ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT                                 = 0x23
+       ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT                                = 0x24
+       ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT                                = 0x25
+       ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT                                = 0x26
+       ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT                            = 0x27
+       ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT                                 = 0x28
+       ETHTOOL_LINK_MODE_1000baseX_Full_BIT                                    = 0x29
+       ETHTOOL_LINK_MODE_10000baseCR_Full_BIT                                  = 0x2a
+       ETHTOOL_LINK_MODE_10000baseSR_Full_BIT                                  = 0x2b
+       ETHTOOL_LINK_MODE_10000baseLR_Full_BIT                                  = 0x2c
+       ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT                                 = 0x2d
+       ETHTOOL_LINK_MODE_10000baseER_Full_BIT                                  = 0x2e
+       ETHTOOL_LINK_MODE_2500baseT_Full_BIT                                    = 0x2f
+       ETHTOOL_LINK_MODE_5000baseT_Full_BIT                                    = 0x30
+       ETHTOOL_LINK_MODE_FEC_NONE_BIT                                          = 0x31
+       ETHTOOL_LINK_MODE_FEC_RS_BIT                                            = 0x32
+       ETHTOOL_LINK_MODE_FEC_BASER_BIT                                         = 0x33
+       ETHTOOL_LINK_MODE_50000baseKR_Full_BIT                                  = 0x34
+       ETHTOOL_LINK_MODE_50000baseSR_Full_BIT                                  = 0x35
+       ETHTOOL_LINK_MODE_50000baseCR_Full_BIT                                  = 0x36
+       ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT                            = 0x37
+       ETHTOOL_LINK_MODE_50000baseDR_Full_BIT                                  = 0x38
+       ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT                                = 0x39
+       ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT                                = 0x3a
+       ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT                                = 0x3b
+       ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT                        = 0x3c
+       ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT                                = 0x3d
+       ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT                                = 0x3e
+       ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT                                = 0x3f
+       ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT                        = 0x40
+       ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT                                = 0x41
+       ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT                                = 0x42
+       ETHTOOL_LINK_MODE_100baseT1_Full_BIT                                    = 0x43
+       ETHTOOL_LINK_MODE_1000baseT1_Full_BIT                                   = 0x44
+       ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT                                = 0x45
+       ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT                                = 0x46
+       ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT                        = 0x47
+       ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT                                = 0x48
+       ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT                                = 0x49
+       ETHTOOL_LINK_MODE_FEC_LLRS_BIT                                          = 0x4a
+       ETHTOOL_LINK_MODE_100000baseKR_Full_BIT                                 = 0x4b
+       ETHTOOL_LINK_MODE_100000baseSR_Full_BIT                                 = 0x4c
+       ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT                           = 0x4d
+       ETHTOOL_LINK_MODE_100000baseCR_Full_BIT                                 = 0x4e
+       ETHTOOL_LINK_MODE_100000baseDR_Full_BIT                                 = 0x4f
+       ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT                                = 0x50
+       ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT                                = 0x51
+       ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT                        = 0x52
+       ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT                                = 0x53
+       ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT                                = 0x54
+       ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT                                = 0x55
+       ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT                                = 0x56
+       ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT                        = 0x57
+       ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT                                = 0x58
+       ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT                                = 0x59
+       ETHTOOL_LINK_MODE_100baseFX_Half_BIT                                    = 0x5a
+       ETHTOOL_LINK_MODE_100baseFX_Full_BIT                                    = 0x5b
+
+       ETHTOOL_MSG_USER_NONE                     = 0x0
+       ETHTOOL_MSG_STRSET_GET                    = 0x1
+       ETHTOOL_MSG_LINKINFO_GET                  = 0x2
+       ETHTOOL_MSG_LINKINFO_SET                  = 0x3
+       ETHTOOL_MSG_LINKMODES_GET                 = 0x4
+       ETHTOOL_MSG_LINKMODES_SET                 = 0x5
+       ETHTOOL_MSG_LINKSTATE_GET                 = 0x6
+       ETHTOOL_MSG_DEBUG_GET                     = 0x7
+       ETHTOOL_MSG_DEBUG_SET                     = 0x8
+       ETHTOOL_MSG_WOL_GET                       = 0x9
+       ETHTOOL_MSG_WOL_SET                       = 0xa
+       ETHTOOL_MSG_FEATURES_GET                  = 0xb
+       ETHTOOL_MSG_FEATURES_SET                  = 0xc
+       ETHTOOL_MSG_PRIVFLAGS_GET                 = 0xd
+       ETHTOOL_MSG_PRIVFLAGS_SET                 = 0xe
+       ETHTOOL_MSG_RINGS_GET                     = 0xf
+       ETHTOOL_MSG_RINGS_SET                     = 0x10
+       ETHTOOL_MSG_CHANNELS_GET                  = 0x11
+       ETHTOOL_MSG_CHANNELS_SET                  = 0x12
+       ETHTOOL_MSG_COALESCE_GET                  = 0x13
+       ETHTOOL_MSG_COALESCE_SET                  = 0x14
+       ETHTOOL_MSG_PAUSE_GET                     = 0x15
+       ETHTOOL_MSG_PAUSE_SET                     = 0x16
+       ETHTOOL_MSG_EEE_GET                       = 0x17
+       ETHTOOL_MSG_EEE_SET                       = 0x18
+       ETHTOOL_MSG_TSINFO_GET                    = 0x19
+       ETHTOOL_MSG_CABLE_TEST_ACT                = 0x1a
+       ETHTOOL_MSG_CABLE_TEST_TDR_ACT            = 0x1b
+       ETHTOOL_MSG_TUNNEL_INFO_GET               = 0x1c
+       ETHTOOL_MSG_USER_MAX                      = 0x1c
+       ETHTOOL_MSG_KERNEL_NONE                   = 0x0
+       ETHTOOL_MSG_STRSET_GET_REPLY              = 0x1
+       ETHTOOL_MSG_LINKINFO_GET_REPLY            = 0x2
+       ETHTOOL_MSG_LINKINFO_NTF                  = 0x3
+       ETHTOOL_MSG_LINKMODES_GET_REPLY           = 0x4
+       ETHTOOL_MSG_LINKMODES_NTF                 = 0x5
+       ETHTOOL_MSG_LINKSTATE_GET_REPLY           = 0x6
+       ETHTOOL_MSG_DEBUG_GET_REPLY               = 0x7
+       ETHTOOL_MSG_DEBUG_NTF                     = 0x8
+       ETHTOOL_MSG_WOL_GET_REPLY                 = 0x9
+       ETHTOOL_MSG_WOL_NTF                       = 0xa
+       ETHTOOL_MSG_FEATURES_GET_REPLY            = 0xb
+       ETHTOOL_MSG_FEATURES_SET_REPLY            = 0xc
+       ETHTOOL_MSG_FEATURES_NTF                  = 0xd
+       ETHTOOL_MSG_PRIVFLAGS_GET_REPLY           = 0xe
+       ETHTOOL_MSG_PRIVFLAGS_NTF                 = 0xf
+       ETHTOOL_MSG_RINGS_GET_REPLY               = 0x10
+       ETHTOOL_MSG_RINGS_NTF                     = 0x11
+       ETHTOOL_MSG_CHANNELS_GET_REPLY            = 0x12
+       ETHTOOL_MSG_CHANNELS_NTF                  = 0x13
+       ETHTOOL_MSG_COALESCE_GET_REPLY            = 0x14
+       ETHTOOL_MSG_COALESCE_NTF                  = 0x15
+       ETHTOOL_MSG_PAUSE_GET_REPLY               = 0x16
+       ETHTOOL_MSG_PAUSE_NTF                     = 0x17
+       ETHTOOL_MSG_EEE_GET_REPLY                 = 0x18
+       ETHTOOL_MSG_EEE_NTF                       = 0x19
+       ETHTOOL_MSG_TSINFO_GET_REPLY              = 0x1a
+       ETHTOOL_MSG_CABLE_TEST_NTF                = 0x1b
+       ETHTOOL_MSG_CABLE_TEST_TDR_NTF            = 0x1c
+       ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY         = 0x1d
+       ETHTOOL_MSG_KERNEL_MAX                    = 0x1d
+       ETHTOOL_A_HEADER_UNSPEC                   = 0x0
+       ETHTOOL_A_HEADER_DEV_INDEX                = 0x1
+       ETHTOOL_A_HEADER_DEV_NAME                 = 0x2
+       ETHTOOL_A_HEADER_FLAGS                    = 0x3
+       ETHTOOL_A_HEADER_MAX                      = 0x3
+       ETHTOOL_A_BITSET_BIT_UNSPEC               = 0x0
+       ETHTOOL_A_BITSET_BIT_INDEX                = 0x1
+       ETHTOOL_A_BITSET_BIT_NAME                 = 0x2
+       ETHTOOL_A_BITSET_BIT_VALUE                = 0x3
+       ETHTOOL_A_BITSET_BIT_MAX                  = 0x3
+       ETHTOOL_A_BITSET_BITS_UNSPEC              = 0x0
+       ETHTOOL_A_BITSET_BITS_BIT                 = 0x1
+       ETHTOOL_A_BITSET_BITS_MAX                 = 0x1
+       ETHTOOL_A_BITSET_UNSPEC                   = 0x0
+       ETHTOOL_A_BITSET_NOMASK                   = 0x1
+       ETHTOOL_A_BITSET_SIZE                     = 0x2
+       ETHTOOL_A_BITSET_BITS                     = 0x3
+       ETHTOOL_A_BITSET_VALUE                    = 0x4
+       ETHTOOL_A_BITSET_MASK                     = 0x5
+       ETHTOOL_A_BITSET_MAX                      = 0x5
+       ETHTOOL_A_STRING_UNSPEC                   = 0x0
+       ETHTOOL_A_STRING_INDEX                    = 0x1
+       ETHTOOL_A_STRING_VALUE                    = 0x2
+       ETHTOOL_A_STRING_MAX                      = 0x2
+       ETHTOOL_A_STRINGS_UNSPEC                  = 0x0
+       ETHTOOL_A_STRINGS_STRING                  = 0x1
+       ETHTOOL_A_STRINGS_MAX                     = 0x1
+       ETHTOOL_A_STRINGSET_UNSPEC                = 0x0
+       ETHTOOL_A_STRINGSET_ID                    = 0x1
+       ETHTOOL_A_STRINGSET_COUNT                 = 0x2
+       ETHTOOL_A_STRINGSET_STRINGS               = 0x3
+       ETHTOOL_A_STRINGSET_MAX                   = 0x3
+       ETHTOOL_A_STRINGSETS_UNSPEC               = 0x0
+       ETHTOOL_A_STRINGSETS_STRINGSET            = 0x1
+       ETHTOOL_A_STRINGSETS_MAX                  = 0x1
+       ETHTOOL_A_STRSET_UNSPEC                   = 0x0
+       ETHTOOL_A_STRSET_HEADER                   = 0x1
+       ETHTOOL_A_STRSET_STRINGSETS               = 0x2
+       ETHTOOL_A_STRSET_COUNTS_ONLY              = 0x3
+       ETHTOOL_A_STRSET_MAX                      = 0x3
+       ETHTOOL_A_LINKINFO_UNSPEC                 = 0x0
+       ETHTOOL_A_LINKINFO_HEADER                 = 0x1
+       ETHTOOL_A_LINKINFO_PORT                   = 0x2
+       ETHTOOL_A_LINKINFO_PHYADDR                = 0x3
+       ETHTOOL_A_LINKINFO_TP_MDIX                = 0x4
+       ETHTOOL_A_LINKINFO_TP_MDIX_CTRL           = 0x5
+       ETHTOOL_A_LINKINFO_TRANSCEIVER            = 0x6
+       ETHTOOL_A_LINKINFO_MAX                    = 0x6
+       ETHTOOL_A_LINKMODES_UNSPEC                = 0x0
+       ETHTOOL_A_LINKMODES_HEADER                = 0x1
+       ETHTOOL_A_LINKMODES_AUTONEG               = 0x2
+       ETHTOOL_A_LINKMODES_OURS                  = 0x3
+       ETHTOOL_A_LINKMODES_PEER                  = 0x4
+       ETHTOOL_A_LINKMODES_SPEED                 = 0x5
+       ETHTOOL_A_LINKMODES_DUPLEX                = 0x6
+       ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG      = 0x7
+       ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE    = 0x8
+       ETHTOOL_A_LINKMODES_MAX                   = 0x8
+       ETHTOOL_A_LINKSTATE_UNSPEC                = 0x0
+       ETHTOOL_A_LINKSTATE_HEADER                = 0x1
+       ETHTOOL_A_LINKSTATE_LINK                  = 0x2
+       ETHTOOL_A_LINKSTATE_SQI                   = 0x3
+       ETHTOOL_A_LINKSTATE_SQI_MAX               = 0x4
+       ETHTOOL_A_LINKSTATE_EXT_STATE             = 0x5
+       ETHTOOL_A_LINKSTATE_EXT_SUBSTATE          = 0x6
+       ETHTOOL_A_LINKSTATE_MAX                   = 0x6
+       ETHTOOL_A_DEBUG_UNSPEC                    = 0x0
+       ETHTOOL_A_DEBUG_HEADER                    = 0x1
+       ETHTOOL_A_DEBUG_MSGMASK                   = 0x2
+       ETHTOOL_A_DEBUG_MAX                       = 0x2
+       ETHTOOL_A_WOL_UNSPEC                      = 0x0
+       ETHTOOL_A_WOL_HEADER                      = 0x1
+       ETHTOOL_A_WOL_MODES                       = 0x2
+       ETHTOOL_A_WOL_SOPASS                      = 0x3
+       ETHTOOL_A_WOL_MAX                         = 0x3
+       ETHTOOL_A_FEATURES_UNSPEC                 = 0x0
+       ETHTOOL_A_FEATURES_HEADER                 = 0x1
+       ETHTOOL_A_FEATURES_HW                     = 0x2
+       ETHTOOL_A_FEATURES_WANTED                 = 0x3
+       ETHTOOL_A_FEATURES_ACTIVE                 = 0x4
+       ETHTOOL_A_FEATURES_NOCHANGE               = 0x5
+       ETHTOOL_A_FEATURES_MAX                    = 0x5
+       ETHTOOL_A_PRIVFLAGS_UNSPEC                = 0x0
+       ETHTOOL_A_PRIVFLAGS_HEADER                = 0x1
+       ETHTOOL_A_PRIVFLAGS_FLAGS                 = 0x2
+       ETHTOOL_A_PRIVFLAGS_MAX                   = 0x2
+       ETHTOOL_A_RINGS_UNSPEC                    = 0x0
+       ETHTOOL_A_RINGS_HEADER                    = 0x1
+       ETHTOOL_A_RINGS_RX_MAX                    = 0x2
+       ETHTOOL_A_RINGS_RX_MINI_MAX               = 0x3
+       ETHTOOL_A_RINGS_RX_JUMBO_MAX              = 0x4
+       ETHTOOL_A_RINGS_TX_MAX                    = 0x5
+       ETHTOOL_A_RINGS_RX                        = 0x6
+       ETHTOOL_A_RINGS_RX_MINI                   = 0x7
+       ETHTOOL_A_RINGS_RX_JUMBO                  = 0x8
+       ETHTOOL_A_RINGS_TX                        = 0x9
+       ETHTOOL_A_RINGS_MAX                       = 0x9
+       ETHTOOL_A_CHANNELS_UNSPEC                 = 0x0
+       ETHTOOL_A_CHANNELS_HEADER                 = 0x1
+       ETHTOOL_A_CHANNELS_RX_MAX                 = 0x2
+       ETHTOOL_A_CHANNELS_TX_MAX                 = 0x3
+       ETHTOOL_A_CHANNELS_OTHER_MAX              = 0x4
+       ETHTOOL_A_CHANNELS_COMBINED_MAX           = 0x5
+       ETHTOOL_A_CHANNELS_RX_COUNT               = 0x6
+       ETHTOOL_A_CHANNELS_TX_COUNT               = 0x7
+       ETHTOOL_A_CHANNELS_OTHER_COUNT            = 0x8
+       ETHTOOL_A_CHANNELS_COMBINED_COUNT         = 0x9
+       ETHTOOL_A_CHANNELS_MAX                    = 0x9
+       ETHTOOL_A_COALESCE_UNSPEC                 = 0x0
+       ETHTOOL_A_COALESCE_HEADER                 = 0x1
+       ETHTOOL_A_COALESCE_RX_USECS               = 0x2
+       ETHTOOL_A_COALESCE_RX_MAX_FRAMES          = 0x3
+       ETHTOOL_A_COALESCE_RX_USECS_IRQ           = 0x4
+       ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ      = 0x5
+       ETHTOOL_A_COALESCE_TX_USECS               = 0x6
+       ETHTOOL_A_COALESCE_TX_MAX_FRAMES          = 0x7
+       ETHTOOL_A_COALESCE_TX_USECS_IRQ           = 0x8
+       ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ      = 0x9
+       ETHTOOL_A_COALESCE_STATS_BLOCK_USECS      = 0xa
+       ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX        = 0xb
+       ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX        = 0xc
+       ETHTOOL_A_COALESCE_PKT_RATE_LOW           = 0xd
+       ETHTOOL_A_COALESCE_RX_USECS_LOW           = 0xe
+       ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW      = 0xf
+       ETHTOOL_A_COALESCE_TX_USECS_LOW           = 0x10
+       ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW      = 0x11
+       ETHTOOL_A_COALESCE_PKT_RATE_HIGH          = 0x12
+       ETHTOOL_A_COALESCE_RX_USECS_HIGH          = 0x13
+       ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH     = 0x14
+       ETHTOOL_A_COALESCE_TX_USECS_HIGH          = 0x15
+       ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH     = 0x16
+       ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
+       ETHTOOL_A_COALESCE_MAX                    = 0x17
+       ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
+       ETHTOOL_A_PAUSE_HEADER                    = 0x1
+       ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
+       ETHTOOL_A_PAUSE_RX                        = 0x3
+       ETHTOOL_A_PAUSE_TX                        = 0x4
+       ETHTOOL_A_PAUSE_STATS                     = 0x5
+       ETHTOOL_A_PAUSE_MAX                       = 0x5
+       ETHTOOL_A_PAUSE_STAT_UNSPEC               = 0x0
+       ETHTOOL_A_PAUSE_STAT_PAD                  = 0x1
+       ETHTOOL_A_PAUSE_STAT_TX_FRAMES            = 0x2
+       ETHTOOL_A_PAUSE_STAT_RX_FRAMES            = 0x3
+       ETHTOOL_A_PAUSE_STAT_MAX                  = 0x3
+       ETHTOOL_A_EEE_UNSPEC                      = 0x0
+       ETHTOOL_A_EEE_HEADER                      = 0x1
+       ETHTOOL_A_EEE_MODES_OURS                  = 0x2
+       ETHTOOL_A_EEE_MODES_PEER                  = 0x3
+       ETHTOOL_A_EEE_ACTIVE                      = 0x4
+       ETHTOOL_A_EEE_ENABLED                     = 0x5
+       ETHTOOL_A_EEE_TX_LPI_ENABLED              = 0x6
+       ETHTOOL_A_EEE_TX_LPI_TIMER                = 0x7
+       ETHTOOL_A_EEE_MAX                         = 0x7
+       ETHTOOL_A_TSINFO_UNSPEC                   = 0x0
+       ETHTOOL_A_TSINFO_HEADER                   = 0x1
+       ETHTOOL_A_TSINFO_TIMESTAMPING             = 0x2
+       ETHTOOL_A_TSINFO_TX_TYPES                 = 0x3
+       ETHTOOL_A_TSINFO_RX_FILTERS               = 0x4
+       ETHTOOL_A_TSINFO_PHC_INDEX                = 0x5
+       ETHTOOL_A_TSINFO_MAX                      = 0x5
+       ETHTOOL_A_CABLE_TEST_UNSPEC               = 0x0
+       ETHTOOL_A_CABLE_TEST_HEADER               = 0x1
+       ETHTOOL_A_CABLE_TEST_MAX                  = 0x1
+       ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC        = 0x0
+       ETHTOOL_A_CABLE_RESULT_CODE_OK            = 0x1
+       ETHTOOL_A_CABLE_RESULT_CODE_OPEN          = 0x2
+       ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT    = 0x3
+       ETHTOOL_A_CABLE_RESULT_CODE_CROSS_SHORT   = 0x4
+       ETHTOOL_A_CABLE_PAIR_A                    = 0x0
+       ETHTOOL_A_CABLE_PAIR_B                    = 0x1
+       ETHTOOL_A_CABLE_PAIR_C                    = 0x2
+       ETHTOOL_A_CABLE_PAIR_D                    = 0x3
+       ETHTOOL_A_CABLE_RESULT_UNSPEC             = 0x0
+       ETHTOOL_A_CABLE_RESULT_PAIR               = 0x1
+       ETHTOOL_A_CABLE_RESULT_CODE               = 0x2
+       ETHTOOL_A_CABLE_RESULT_MAX                = 0x2
+       ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC       = 0x0
+       ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR         = 0x1
+       ETHTOOL_A_CABLE_FAULT_LENGTH_CM           = 0x2
+       ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x2
+       ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC    = 0x0
+       ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED   = 0x1
+       ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2
+       ETHTOOL_A_CABLE_NEST_UNSPEC               = 0x0
+       ETHTOOL_A_CABLE_NEST_RESULT               = 0x1
+       ETHTOOL_A_CABLE_NEST_FAULT_LENGTH         = 0x2
+       ETHTOOL_A_CABLE_NEST_MAX                  = 0x2
+       ETHTOOL_A_CABLE_TEST_NTF_UNSPEC           = 0x0
+       ETHTOOL_A_CABLE_TEST_NTF_HEADER           = 0x1
+       ETHTOOL_A_CABLE_TEST_NTF_STATUS           = 0x2
+       ETHTOOL_A_CABLE_TEST_NTF_NEST             = 0x3
+       ETHTOOL_A_CABLE_TEST_NTF_MAX              = 0x3
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_UNSPEC       = 0x0
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST        = 0x1
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST         = 0x2
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP         = 0x3
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR         = 0x4
+       ETHTOOL_A_CABLE_TEST_TDR_CFG_MAX          = 0x4
+       ETHTOOL_A_CABLE_TEST_TDR_UNSPEC           = 0x0
+       ETHTOOL_A_CABLE_TEST_TDR_HEADER           = 0x1
+       ETHTOOL_A_CABLE_TEST_TDR_CFG              = 0x2
+       ETHTOOL_A_CABLE_TEST_TDR_MAX              = 0x2
+       ETHTOOL_A_CABLE_AMPLITUDE_UNSPEC          = 0x0
+       ETHTOOL_A_CABLE_AMPLITUDE_PAIR            = 0x1
+       ETHTOOL_A_CABLE_AMPLITUDE_mV              = 0x2
+       ETHTOOL_A_CABLE_AMPLITUDE_MAX             = 0x2
+       ETHTOOL_A_CABLE_PULSE_UNSPEC              = 0x0
+       ETHTOOL_A_CABLE_PULSE_mV                  = 0x1
+       ETHTOOL_A_CABLE_PULSE_MAX                 = 0x1
+       ETHTOOL_A_CABLE_STEP_UNSPEC               = 0x0
+       ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE       = 0x1
+       ETHTOOL_A_CABLE_STEP_LAST_DISTANCE        = 0x2
+       ETHTOOL_A_CABLE_STEP_STEP_DISTANCE        = 0x3
+       ETHTOOL_A_CABLE_STEP_MAX                  = 0x3
+       ETHTOOL_A_CABLE_TDR_NEST_UNSPEC           = 0x0
+       ETHTOOL_A_CABLE_TDR_NEST_STEP             = 0x1
+       ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE        = 0x2
+       ETHTOOL_A_CABLE_TDR_NEST_PULSE            = 0x3
+       ETHTOOL_A_CABLE_TDR_NEST_MAX              = 0x3
+       ETHTOOL_A_CABLE_TEST_TDR_NTF_UNSPEC       = 0x0
+       ETHTOOL_A_CABLE_TEST_TDR_NTF_HEADER       = 0x1
+       ETHTOOL_A_CABLE_TEST_TDR_NTF_STATUS       = 0x2
+       ETHTOOL_A_CABLE_TEST_TDR_NTF_NEST         = 0x3
+       ETHTOOL_A_CABLE_TEST_TDR_NTF_MAX          = 0x3
+       ETHTOOL_UDP_TUNNEL_TYPE_VXLAN             = 0x0
+       ETHTOOL_UDP_TUNNEL_TYPE_GENEVE            = 0x1
+       ETHTOOL_UDP_TUNNEL_TYPE_VXLAN_GPE         = 0x2
+       ETHTOOL_A_TUNNEL_UDP_ENTRY_UNSPEC         = 0x0
+       ETHTOOL_A_TUNNEL_UDP_ENTRY_PORT           = 0x1
+       ETHTOOL_A_TUNNEL_UDP_ENTRY_TYPE           = 0x2
+       ETHTOOL_A_TUNNEL_UDP_ENTRY_MAX            = 0x2
+       ETHTOOL_A_TUNNEL_UDP_TABLE_UNSPEC         = 0x0
+       ETHTOOL_A_TUNNEL_UDP_TABLE_SIZE           = 0x1
+       ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES          = 0x2
+       ETHTOOL_A_TUNNEL_UDP_TABLE_ENTRY          = 0x3
+       ETHTOOL_A_TUNNEL_UDP_TABLE_MAX            = 0x3
+       ETHTOOL_A_TUNNEL_UDP_UNSPEC               = 0x0
+       ETHTOOL_A_TUNNEL_UDP_TABLE                = 0x1
+       ETHTOOL_A_TUNNEL_UDP_MAX                  = 0x1
+       ETHTOOL_A_TUNNEL_INFO_UNSPEC              = 0x0
+       ETHTOOL_A_TUNNEL_INFO_HEADER              = 0x1
+       ETHTOOL_A_TUNNEL_INFO_UDP_PORTS           = 0x2
+       ETHTOOL_A_TUNNEL_INFO_MAX                 = 0x2
+)

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index d54618aa61f5862581ab2a1655977136c7026f86..088bd77e3be33a8c2448e5e97c81ed0b8ff5a3f6 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build 386,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index 741d25be95742c7078423593d13a69986c2d3ab8..078d958ec956acd1e3c8cc722d0caf6672cbcfd6 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build amd64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index e8d982c3df7bad3e4d45cce33bc103e2565663a2..2d39122f410c2a5c6b93d286e1a7e7aefedc3da4 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build arm,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index 311cf2155d5774cb676c32a4befdbacc2a81e1b8..304cbd04536e2c6e9e96e9cba30da36b031f040f 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build arm64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 1312bdf77feaceabf97f7a935bb821131a4370d4..7d9d57006aa87c60482314625a0256f6c35bc9cd 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index 2a993481950c8f50bcecb750c4dbe3033b9f07b2..a1eb2577b08910db8ba62f2dcf2576a2466fb6ef 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index f964307b293c9d758bb03d327a7de3b1b47303db..2e5ce3b6a69fac5b870bd1397c505674b8fd6b4e 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips64le,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index ca0fab27020bdc646d72f97d35e426b31f47aef6..bbaa1200b6a6ed05481914ef13b7cceb4d51037c 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mipsle,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index 257e0042473c25d3e0eb7716cc54861bfff33c5d..0e6e8a7748390beadde2975da6fc0fa98dff4f42 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build ppc64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index 980dd31736a6fa97e84b5146b30a3cf24ceaf0bf..7382f385faf6066a9b64b3f1395fd2999c5adfea 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build ppc64le,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index d9fdab20b83daee4fdef4f6f4f4b2eb8730a1fe8..28d552216656e168d654db26577a26e29b1aa30f 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build riscv64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index c25de8c679cda805ae7e4473e4d417ce030ce3a7..a91a7a44bd394444038411d7070db2d6f9f7eb15 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build s390x,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index 97fca65340e656c9035a3702db7005399e6dae69..f824b2358dc71d6410d37d34a0ba140f4711dfef 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build sparc64,linux

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
index a89100c08aec2fd1834ed03a1653962971446ea3..3f11f88e3c6572f1040c7d665e21a467fdd71d38 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
@@ -248,6 +248,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x1c

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
index 289184e0b3a8a17a8acbc9b27ad661c661790088..0bed83af57b37d4d0a06646b66cbbf9de1602397 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
@@ -255,6 +255,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
index 428c450e4ce0a8774f60dd45d57a62e71da68142..e4e3bf736d86551aefc0057ac0022694e05f1ea8 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
@@ -253,6 +253,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x1c

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
index 6f1f2842cc37746aafa26871315197e6b6ce152c..efac861bb7fa755dc8cd62953612c57e204312e4 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
@@ -255,6 +255,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x14
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
index 61ea0019a2981ca8a58ec8ebaa4501a6ae77433f..80fa295f1dfcdd755494f5a0f35be51b9aeaf074 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
@@ -231,6 +231,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x20
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x1c

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
index 87a493f68fd3c799f2c904213f20fdb6f2945cd8..560dd6d08af124aa1fd4e95d7d8ef3c8b643f011 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
@@ -235,6 +235,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x20
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
index d80836efaba392ea04bbde6639388cb83bdbf811..0c1700fa4356a556e30ff668e319c7c83c3e2e8a 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
@@ -235,6 +235,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x20
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x8
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x1c

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
index 4e158746f115912b041a475a33fd637bcc0056da..5b3e46633e9be4ac414c390322f55db7c9dd2780 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
@@ -231,6 +231,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x20
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
index 992a1f8c01887f41246ceea0d545e762824a803f..62bff16709790b6e8ef383cd6afaaacac4082796 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
@@ -231,6 +231,7 @@ const (
        SizeofSockaddrUnix     = 0x6a
        SizeofSockaddrDatalink = 0x20
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
index db817f3ba828c6c4ec370e30b849530a4ee7f588..ca512aff7f86f5f04ab522263b22a5faa0b8a4c7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
@@ -234,6 +234,7 @@ const (
        SizeofSockaddrUnix     = 0x6e
        SizeofSockaddrDatalink = 0xfc
        SizeofLinger           = 0x8
+       SizeofIovec            = 0x10
        SizeofIPMreq           = 0x8
        SizeofIPv6Mreq         = 0x14
        SizeofMsghdr           = 0x30

diff --git a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
index c71bad127d3f29672cbf2df68f67ecbda73cfda3..0197df87276df8396a3b6139e3a0d6a77d84b37b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -18,9 +18,11 @@ import (
 )
 
 type Handle uintptr
+type HWND uintptr
 
 const (
        InvalidHandle = ^Handle(0)
+       InvalidHWND   = ^HWND(0)
 
        // Flags for DefineDosDevice.
        DDD_EXACT_MATCH_ON_REMOVE = 0x00000004
@@ -214,6 +216,10 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys  CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
 //sys  OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error)
 //sys  ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW
+//sys  GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId
+//sys  GetShellWindow() (shellWindow HWND) = user32.GetShellWindow
+//sys  MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
+//sys  ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
 //sys  shGetKnownFolderPath(id *KNOWNFOLDERID, flags uint32, token Token, path **uint16) (ret error) = shell32.SHGetKnownFolderPath
 //sys  TerminateProcess(handle Handle, exitcode uint32) (err error)
 //sys  GetExitCodeProcess(handle Handle, exitcode *uint32) (err error)
@@ -259,22 +265,35 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys  VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) = kernel32.VirtualProtect
 //sys  TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile
 //sys  ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW
+//sys  FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.FindFirstChangeNotificationW
+//sys  FindNextChangeNotification(handle Handle) (err error)
+//sys  FindCloseChangeNotification(handle Handle) (err error)
 //sys  CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) = crypt32.CertOpenSystemStoreW
-//sys   CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) = crypt32.CertOpenStore
+//sys  CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) = crypt32.CertOpenStore
 //sys  CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore
-//sys   CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
+//sys  CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
 //sys  CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore
 //sys  CertDeleteCertificateFromStore(certContext *CertContext) (err error) = crypt32.CertDeleteCertificateFromStore
-//sys   CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
-//sys   CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
-//sys   CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
-//sys   CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
-//sys   CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
+//sys  CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) = crypt32.CertDuplicateCertificateContext
+//sys  PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) = crypt32.PFXImportCertStore
+//sys  CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
+//sys  CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
+//sys  CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
+//sys  CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
+//sys  CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
+//sys  CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) = crypt32.CertGetNameStringW
+//sys  CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) = crypt32.CertFindExtension
+//sys  CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) = crypt32.CryptQueryObject
+//sys  CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) = crypt32.CryptDecodeObject
+//sys  CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptProtectData
+//sys  CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptUnprotectData
+//sys  WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) = wintrust.WinVerifyTrustEx
 //sys  RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) = advapi32.RegOpenKeyExW
 //sys  RegCloseKey(key Handle) (regerrno error) = advapi32.RegCloseKey
 //sys  RegQueryInfoKey(key Handle, class *uint16, classLen *uint32, reserved *uint32, subkeysLen *uint32, maxSubkeyLen *uint32, maxClassLen *uint32, valuesLen *uint32, maxValueNameLen *uint32, maxValueLen *uint32, saLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegQueryInfoKeyW
 //sys  RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegEnumKeyExW
 //sys  RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegQueryValueExW
+//sys  RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) = advapi32.RegNotifyChangeKeyValue
 //sys  GetCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId
 //sys  ProcessIdToSessionId(pid uint32, sessionid *uint32) (err error) = kernel32.ProcessIdToSessionId
 //sys  GetConsoleMode(console Handle, mode *uint32) (err error) = kernel32.GetConsoleMode
@@ -341,8 +360,6 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys  QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) [failretval==0] = QueryDosDeviceW
 //sys  SetVolumeLabel(rootPathName *uint16, volumeName *uint16) (err error) = SetVolumeLabelW
 //sys  SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err error) = SetVolumeMountPointW
-//sys  MessageBox(hwnd Handle, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
-//sys  ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
 //sys  InitiateSystemShutdownEx(machineName *uint16, message *uint16, timeout uint32, forceAppsClosed bool, rebootAfterShutdown bool, reason uint32) (err error) = advapi32.InitiateSystemShutdownExW
 //sys  SetProcessShutdownParameters(level uint32, flags uint32) (err error) = kernel32.SetProcessShutdownParameters
 //sys  GetProcessShutdownParameters(level *uint32, flags *uint32) (err error) = kernel32.GetProcessShutdownParameters

diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
index 265d797cacfcc712ab1fc9943a3014c216f153e9..fd4260762a8da2173ecc714ec69c199b896f2891 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
@@ -227,7 +227,7 @@ const (
 )
 
 const (
-       // filters for ReadDirectoryChangesW
+       // filters for ReadDirectoryChangesW and FindFirstChangeNotificationW
        FILE_NOTIFY_CHANGE_FILE_NAME   = 0x001
        FILE_NOTIFY_CHANGE_DIR_NAME    = 0x002
        FILE_NOTIFY_CHANGE_ATTRIBUTES  = 0x004
@@ -249,24 +249,27 @@ const (
 
 const (
        // wincrypt.h
-       PROV_RSA_FULL                    = 1
-       PROV_RSA_SIG                     = 2
-       PROV_DSS                         = 3
-       PROV_FORTEZZA                    = 4
-       PROV_MS_EXCHANGE                 = 5
-       PROV_SSL                         = 6
-       PROV_RSA_SCHANNEL                = 12
-       PROV_DSS_DH                      = 13
-       PROV_EC_ECDSA_SIG                = 14
-       PROV_EC_ECNRA_SIG                = 15
-       PROV_EC_ECDSA_FULL               = 16
-       PROV_EC_ECNRA_FULL               = 17
-       PROV_DH_SCHANNEL                 = 18
-       PROV_SPYRUS_LYNKS                = 20
-       PROV_RNG                         = 21
-       PROV_INTEL_SEC                   = 22
-       PROV_REPLACE_OWF                 = 23
-       PROV_RSA_AES                     = 24
+       /* certenrolld_begin -- PROV_RSA_*/
+       PROV_RSA_FULL      = 1
+       PROV_RSA_SIG       = 2
+       PROV_DSS           = 3
+       PROV_FORTEZZA      = 4
+       PROV_MS_EXCHANGE   = 5
+       PROV_SSL           = 6
+       PROV_RSA_SCHANNEL  = 12
+       PROV_DSS_DH        = 13
+       PROV_EC_ECDSA_SIG  = 14
+       PROV_EC_ECNRA_SIG  = 15
+       PROV_EC_ECDSA_FULL = 16
+       PROV_EC_ECNRA_FULL = 17
+       PROV_DH_SCHANNEL   = 18
+       PROV_SPYRUS_LYNKS  = 20
+       PROV_RNG           = 21
+       PROV_INTEL_SEC     = 22
+       PROV_REPLACE_OWF   = 23
+       PROV_RSA_AES       = 24
+
+       /* dwFlags definitions for CryptAcquireContext */
        CRYPT_VERIFYCONTEXT              = 0xF0000000
        CRYPT_NEWKEYSET                  = 0x00000008
        CRYPT_DELETEKEYSET               = 0x00000010
@@ -274,6 +277,17 @@ const (
        CRYPT_SILENT                     = 0x00000040
        CRYPT_DEFAULT_CONTAINER_OPTIONAL = 0x00000080
 
+       /* Flags for PFXImportCertStore */
+       CRYPT_EXPORTABLE                   = 0x00000001
+       CRYPT_USER_PROTECTED               = 0x00000002
+       CRYPT_USER_KEYSET                  = 0x00001000
+       PKCS12_PREFER_CNG_KSP              = 0x00000100
+       PKCS12_ALWAYS_CNG_KSP              = 0x00000200
+       PKCS12_ALLOW_OVERWRITE_KEY         = 0x00004000
+       PKCS12_NO_PERSIST_KEY              = 0x00008000
+       PKCS12_INCLUDE_EXTENDED_PROPERTIES = 0x00000010
+
+       /* Default usage match type is AND with value zero */
        USAGE_MATCH_TYPE_AND = 0
        USAGE_MATCH_TYPE_OR  = 1
 
@@ -409,6 +423,71 @@ const (
        CERT_CHAIN_POLICY_EV                = 8
        CERT_CHAIN_POLICY_SSL_F12           = 9
 
+       /* Certificate Store close flags */
+       CERT_CLOSE_STORE_FORCE_FLAG = 0x00000001
+       CERT_CLOSE_STORE_CHECK_FLAG = 0x00000002
+
+       /* CryptQueryObject object type */
+       CERT_QUERY_OBJECT_FILE = 1
+       CERT_QUERY_OBJECT_BLOB = 2
+
+       /* CryptQueryObject content type flags */
+       CERT_QUERY_CONTENT_CERT                    = 1
+       CERT_QUERY_CONTENT_CTL                     = 2
+       CERT_QUERY_CONTENT_CRL                     = 3
+       CERT_QUERY_CONTENT_SERIALIZED_STORE        = 4
+       CERT_QUERY_CONTENT_SERIALIZED_CERT         = 5
+       CERT_QUERY_CONTENT_SERIALIZED_CTL          = 6
+       CERT_QUERY_CONTENT_SERIALIZED_CRL          = 7
+       CERT_QUERY_CONTENT_PKCS7_SIGNED            = 8
+       CERT_QUERY_CONTENT_PKCS7_UNSIGNED          = 9
+       CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED      = 10
+       CERT_QUERY_CONTENT_PKCS10                  = 11
+       CERT_QUERY_CONTENT_PFX                     = 12
+       CERT_QUERY_CONTENT_CERT_PAIR               = 13
+       CERT_QUERY_CONTENT_PFX_AND_LOAD            = 14
+       CERT_QUERY_CONTENT_FLAG_CERT               = (1 << CERT_QUERY_CONTENT_CERT)
+       CERT_QUERY_CONTENT_FLAG_CTL                = (1 << CERT_QUERY_CONTENT_CTL)
+       CERT_QUERY_CONTENT_FLAG_CRL                = (1 << CERT_QUERY_CONTENT_CRL)
+       CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE   = (1 << CERT_QUERY_CONTENT_SERIALIZED_STORE)
+       CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT    = (1 << CERT_QUERY_CONTENT_SERIALIZED_CERT)
+       CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL     = (1 << CERT_QUERY_CONTENT_SERIALIZED_CTL)
+       CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL     = (1 << CERT_QUERY_CONTENT_SERIALIZED_CRL)
+       CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED       = (1 << CERT_QUERY_CONTENT_PKCS7_SIGNED)
+       CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED     = (1 << CERT_QUERY_CONTENT_PKCS7_UNSIGNED)
+       CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED = (1 << CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED)
+       CERT_QUERY_CONTENT_FLAG_PKCS10             = (1 << CERT_QUERY_CONTENT_PKCS10)
+       CERT_QUERY_CONTENT_FLAG_PFX                = (1 << CERT_QUERY_CONTENT_PFX)
+       CERT_QUERY_CONTENT_FLAG_CERT_PAIR          = (1 << CERT_QUERY_CONTENT_CERT_PAIR)
+       CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD       = (1 << CERT_QUERY_CONTENT_PFX_AND_LOAD)
+       CERT_QUERY_CONTENT_FLAG_ALL                = (CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL | CERT_QUERY_CONTENT_FLAG_CRL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR)
+       CERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERT    = (CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)
+
+       /* CryptQueryObject format type flags */
+       CERT_QUERY_FORMAT_BINARY                     = 1
+       CERT_QUERY_FORMAT_BASE64_ENCODED             = 2
+       CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED      = 3
+       CERT_QUERY_FORMAT_FLAG_BINARY                = (1 << CERT_QUERY_FORMAT_BINARY)
+       CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED        = (1 << CERT_QUERY_FORMAT_BASE64_ENCODED)
+       CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED = (1 << CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED)
+       CERT_QUERY_FORMAT_FLAG_ALL                   = (CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED)
+
+       /* CertGetNameString name types */
+       CERT_NAME_EMAIL_TYPE            = 1
+       CERT_NAME_RDN_TYPE              = 2
+       CERT_NAME_ATTR_TYPE             = 3
+       CERT_NAME_SIMPLE_DISPLAY_TYPE   = 4
+       CERT_NAME_FRIENDLY_DISPLAY_TYPE = 5
+       CERT_NAME_DNS_TYPE              = 6
+       CERT_NAME_URL_TYPE              = 7
+       CERT_NAME_UPN_TYPE              = 8
+
+       /* CertGetNameString flags */
+       CERT_NAME_ISSUER_FLAG              = 0x1
+       CERT_NAME_DISABLE_IE4_UTF8_FLAG    = 0x10000
+       CERT_NAME_SEARCH_ALL_NAMES_FLAG    = 0x2
+       CERT_NAME_STR_ENABLE_PUNYCODE_FLAG = 0x00200000
+
        /* AuthType values for SSLExtraCertChainPolicyPara struct */
        AUTHTYPE_CLIENT = 1
        AUTHTYPE_SERVER = 2
@@ -419,6 +498,22 @@ const (
        SECURITY_FLAG_IGNORE_WRONG_USAGE       = 0x00000200
        SECURITY_FLAG_IGNORE_CERT_CN_INVALID   = 0x00001000
        SECURITY_FLAG_IGNORE_CERT_DATE_INVALID = 0x00002000
+
+       /* Flags for Crypt[Un]ProtectData */
+       CRYPTPROTECT_UI_FORBIDDEN      = 0x1
+       CRYPTPROTECT_LOCAL_MACHINE     = 0x4
+       CRYPTPROTECT_CRED_SYNC         = 0x8
+       CRYPTPROTECT_AUDIT             = 0x10
+       CRYPTPROTECT_NO_RECOVERY       = 0x20
+       CRYPTPROTECT_VERIFY_PROTECTION = 0x40
+       CRYPTPROTECT_CRED_REGENERATE   = 0x80
+
+       /* Flags for CryptProtectPromptStruct */
+       CRYPTPROTECT_PROMPT_ON_UNPROTECT   = 1
+       CRYPTPROTECT_PROMPT_ON_PROTECT     = 2
+       CRYPTPROTECT_PROMPT_RESERVED       = 4
+       CRYPTPROTECT_PROMPT_STRONG         = 8
+       CRYPTPROTECT_PROMPT_REQUIRE_STRONG = 16
 )
 
 const (
@@ -441,10 +536,58 @@ const (
        REALTIME_PRIORITY_CLASS       = 0x00000100
 )
 
+/* wintrust.h constants for WinVerifyTrustEx */
+const (
+       WTD_UI_ALL    = 1
+       WTD_UI_NONE   = 2
+       WTD_UI_NOBAD  = 3
+       WTD_UI_NOGOOD = 4
+
+       WTD_REVOKE_NONE       = 0
+       WTD_REVOKE_WHOLECHAIN = 1
+
+       WTD_CHOICE_FILE    = 1
+       WTD_CHOICE_CATALOG = 2
+       WTD_CHOICE_BLOB    = 3
+       WTD_CHOICE_SIGNER  = 4
+       WTD_CHOICE_CERT    = 5
+
+       WTD_STATEACTION_IGNORE           = 0x00000000
+       WTD_STATEACTION_VERIFY           = 0x00000010
+       WTD_STATEACTION_CLOSE            = 0x00000002
+       WTD_STATEACTION_AUTO_CACHE       = 0x00000003
+       WTD_STATEACTION_AUTO_CACHE_FLUSH = 0x00000004
+
+       WTD_USE_IE4_TRUST_FLAG                  = 0x1
+       WTD_NO_IE4_CHAIN_FLAG                   = 0x2
+       WTD_NO_POLICY_USAGE_FLAG                = 0x4
+       WTD_REVOCATION_CHECK_NONE               = 0x10
+       WTD_REVOCATION_CHECK_END_CERT           = 0x20
+       WTD_REVOCATION_CHECK_CHAIN              = 0x40
+       WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 0x80
+       WTD_SAFER_FLAG                          = 0x100
+       WTD_HASH_ONLY_FLAG                      = 0x200
+       WTD_USE_DEFAULT_OSVER_CHECK             = 0x400
+       WTD_LIFETIME_SIGNING_FLAG               = 0x800
+       WTD_CACHE_ONLY_URL_RETRIEVAL            = 0x1000
+       WTD_DISABLE_MD2_MD4                     = 0x2000
+       WTD_MOTW                                = 0x4000
+
+       WTD_UICONTEXT_EXECUTE = 0
+       WTD_UICONTEXT_INSTALL = 1
+)
+
 var (
        OID_PKIX_KP_SERVER_AUTH = []byte("1.3.6.1.5.5.7.3.1\x00")
        OID_SERVER_GATED_CRYPTO = []byte("1.3.6.1.4.1.311.10.3.3\x00")
        OID_SGC_NETSCAPE        = []byte("2.16.840.1.113730.4.1\x00")
+
+       WINTRUST_ACTION_GENERIC_VERIFY_V2 = GUID{
+               Data1: 0xaac56b,
+               Data2: 0xcd44,
+               Data3: 0x11d0,
+               Data4: [8]byte{0x8c, 0xc2, 0x0, 0xc0, 0x4f, 0xc2, 0x95, 0xee},
+       }
 )
 
 // Pointer represents a pointer to an arbitrary Windows type.
@@ -1033,7 +1176,57 @@ type MibIfRow struct {
 }
 
 type CertInfo struct {
-       // Not implemented
+       Version              uint32
+       SerialNumber         CryptIntegerBlob
+       SignatureAlgorithm   CryptAlgorithmIdentifier
+       Issuer               CertNameBlob
+       NotBefore            Filetime
+       NotAfter             Filetime
+       Subject              CertNameBlob
+       SubjectPublicKeyInfo CertPublicKeyInfo
+       IssuerUniqueId       CryptBitBlob
+       SubjectUniqueId      CryptBitBlob
+       CountExtensions      uint32
+       Extensions           *CertExtension
+}
+
+type CertExtension struct {
+       ObjId    *byte
+       Critical int32
+       Value    CryptObjidBlob
+}
+
+type CryptAlgorithmIdentifier struct {
+       ObjId      *byte
+       Parameters CryptObjidBlob
+}
+
+type CertPublicKeyInfo struct {
+       Algorithm CryptAlgorithmIdentifier
+       PublicKey CryptBitBlob
+}
+
+type DataBlob struct {
+       Size uint32
+       Data *byte
+}
+type CryptIntegerBlob DataBlob
+type CryptUintBlob DataBlob
+type CryptObjidBlob DataBlob
+type CertNameBlob DataBlob
+type CertRdnValueBlob DataBlob
+type CertBlob DataBlob
+type CrlBlob DataBlob
+type CryptDataBlob DataBlob
+type CryptHashBlob DataBlob
+type CryptDigestBlob DataBlob
+type CryptDerBlob DataBlob
+type CryptAttrBlob DataBlob
+
+type CryptBitBlob struct {
+       Size       uint32
+       Data       *byte
+       UnusedBits uint32
 }
 
 type CertContext struct {
@@ -1139,6 +1332,66 @@ type CertChainPolicyStatus struct {
        ExtraPolicyStatus Pointer
 }
 
+type CertPolicyInfo struct {
+       Identifier      *byte
+       CountQualifiers uint32
+       Qualifiers      *CertPolicyQualifierInfo
+}
+
+type CertPoliciesInfo struct {
+       Count       uint32
+       PolicyInfos *CertPolicyInfo
+}
+
+type CertPolicyQualifierInfo struct {
+       // Not implemented
+}
+
+type CertStrongSignPara struct {
+       Size                      uint32
+       InfoChoice                uint32
+       InfoOrSerializedInfoOrOID unsafe.Pointer
+}
+
+type CryptProtectPromptStruct struct {
+       Size        uint32
+       PromptFlags uint32
+       App         HWND
+       Prompt      *uint16
+}
+
+type WinTrustData struct {
+       Size                            uint32
+       PolicyCallbackData              uintptr
+       SIPClientData                   uintptr
+       UIChoice                        uint32
+       RevocationChecks                uint32
+       UnionChoice                     uint32
+       FileOrCatalogOrBlobOrSgnrOrCert unsafe.Pointer
+       StateAction                     uint32
+       StateData                       Handle
+       URLReference                    *uint16
+       ProvFlags                       uint32
+       UIContext                       uint32
+       SignatureSettings               *WinTrustSignatureSettings
+}
+
+type WinTrustFileInfo struct {
+       Size         uint32
+       FilePath     *uint16
+       File         Handle
+       KnownSubject *GUID
+}
+
+type WinTrustSignatureSettings struct {
+       Size             uint32
+       Index            uint32
+       Flags            uint32
+       SecondarySigs    uint32
+       VerifiedSigIndex uint32
+       CryptoPolicy     *CertStrongSignPara
+}
+
 const (
        // do not reorder
        HKEY_CLASSES_ROOT = 0x80000000 + iota
@@ -1820,3 +2073,21 @@ const (
        LOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDER = 0x00004000
        LOAD_LIBRARY_OS_INTEGRITY_CONTINUITY      = 0x00008000
 )
+
+// RegNotifyChangeKeyValue notifyFilter flags.
+const (
+       // REG_NOTIFY_CHANGE_NAME notifies the caller if a subkey is added or deleted.
+       REG_NOTIFY_CHANGE_NAME = 0x00000001
+
+       // REG_NOTIFY_CHANGE_ATTRIBUTES notifies the caller of changes to the attributes of the key, such as the security descriptor information.
+       REG_NOTIFY_CHANGE_ATTRIBUTES = 0x00000002
+
+       // REG_NOTIFY_CHANGE_LAST_SET notifies the caller of changes to a value of the key. This can include adding or deleting a value, or changing an existing value.
+       REG_NOTIFY_CHANGE_LAST_SET = 0x00000004
+
+       // REG_NOTIFY_CHANGE_SECURITY notifies the caller of changes to the security descriptor of the key.
+       REG_NOTIFY_CHANGE_SECURITY = 0x00000008
+
+       // REG_NOTIFY_THREAD_AGNOSTIC indicates that the lifetime of the registration must not be tied to the lifetime of the thread issuing the RegNotifyChangeKeyValue call. Note: This flag value is only supported in Windows 8 and later.
+       REG_NOTIFY_THREAD_AGNOSTIC = 0x10000000
+)

diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go
new file mode 100644 (file)
index 0000000..fdddc0c
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go
@@ -0,0 +1,34 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package windows
+
+type WSAData struct {
+       Version      uint16
+       HighVersion  uint16
+       MaxSockets   uint16
+       MaxUdpDg     uint16
+       VendorInfo   *byte
+       Description  [WSADESCRIPTION_LEN + 1]byte
+       SystemStatus [WSASYS_STATUS_LEN + 1]byte
+}
+
+type Servent struct {
+       Name    *byte
+       Aliases **byte
+       Proto   *byte
+       Port    uint16
+}
+
+type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {
+       PerProcessUserTimeLimit int64
+       PerJobUserTimeLimit     int64
+       LimitFlags              uint32
+       MinimumWorkingSetSize   uintptr
+       MaximumWorkingSetSize   uintptr
+       ActiveProcessLimit      uint32
+       Affinity                uintptr
+       PriorityClass           uint32
+       SchedulingClass         uint32
+}

diff --git a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index a933c0ee378b538c81ace98916c476344d2b7963..c38c59d772c4258ab42f9fcbac2cee0f08ca3f68 100644 (file)
--- a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -51,6 +51,7 @@ var (
        modshell32  = NewLazySystemDLL("shell32.dll")
        moduser32   = NewLazySystemDLL("user32.dll")
        moduserenv  = NewLazySystemDLL("userenv.dll")
+       modwintrust = NewLazySystemDLL("wintrust.dll")
        modws2_32   = NewLazySystemDLL("ws2_32.dll")
        modwtsapi32 = NewLazySystemDLL("wtsapi32.dll")
 
@@ -117,6 +118,7 @@ var (
        procQueryServiceStatusEx                                 = modadvapi32.NewProc("QueryServiceStatusEx")
        procRegCloseKey                                          = modadvapi32.NewProc("RegCloseKey")
        procRegEnumKeyExW                                        = modadvapi32.NewProc("RegEnumKeyExW")
+       procRegNotifyChangeKeyValue                              = modadvapi32.NewProc("RegNotifyChangeKeyValue")
        procRegOpenKeyExW                                        = modadvapi32.NewProc("RegOpenKeyExW")
        procRegQueryInfoKeyW                                     = modadvapi32.NewProc("RegQueryInfoKeyW")
        procRegQueryValueExW                                     = modadvapi32.NewProc("RegQueryValueExW")
@@ -142,13 +144,21 @@ var (
        procCertCloseStore                                       = modcrypt32.NewProc("CertCloseStore")
        procCertCreateCertificateContext                         = modcrypt32.NewProc("CertCreateCertificateContext")
        procCertDeleteCertificateFromStore                       = modcrypt32.NewProc("CertDeleteCertificateFromStore")
+       procCertDuplicateCertificateContext                      = modcrypt32.NewProc("CertDuplicateCertificateContext")
        procCertEnumCertificatesInStore                          = modcrypt32.NewProc("CertEnumCertificatesInStore")
+       procCertFindExtension                                    = modcrypt32.NewProc("CertFindExtension")
        procCertFreeCertificateChain                             = modcrypt32.NewProc("CertFreeCertificateChain")
        procCertFreeCertificateContext                           = modcrypt32.NewProc("CertFreeCertificateContext")
        procCertGetCertificateChain                              = modcrypt32.NewProc("CertGetCertificateChain")
+       procCertGetNameStringW                                   = modcrypt32.NewProc("CertGetNameStringW")
        procCertOpenStore                                        = modcrypt32.NewProc("CertOpenStore")
        procCertOpenSystemStoreW                                 = modcrypt32.NewProc("CertOpenSystemStoreW")
        procCertVerifyCertificateChainPolicy                     = modcrypt32.NewProc("CertVerifyCertificateChainPolicy")
+       procCryptDecodeObject                                    = modcrypt32.NewProc("CryptDecodeObject")
+       procCryptProtectData                                     = modcrypt32.NewProc("CryptProtectData")
+       procCryptQueryObject                                     = modcrypt32.NewProc("CryptQueryObject")
+       procCryptUnprotectData                                   = modcrypt32.NewProc("CryptUnprotectData")
+       procPFXImportCertStore                                   = modcrypt32.NewProc("PFXImportCertStore")
        procDnsNameCompare_W                                     = moddnsapi.NewProc("DnsNameCompare_W")
        procDnsQuery_W                                           = moddnsapi.NewProc("DnsQuery_W")
        procDnsRecordListFree                                    = moddnsapi.NewProc("DnsRecordListFree")
@@ -180,9 +190,12 @@ var (
        procDuplicateHandle                                      = modkernel32.NewProc("DuplicateHandle")
        procExitProcess                                          = modkernel32.NewProc("ExitProcess")
        procFindClose                                            = modkernel32.NewProc("FindClose")
+       procFindCloseChangeNotification                          = modkernel32.NewProc("FindCloseChangeNotification")
+       procFindFirstChangeNotificationW                         = modkernel32.NewProc("FindFirstChangeNotificationW")
        procFindFirstFileW                                       = modkernel32.NewProc("FindFirstFileW")
        procFindFirstVolumeMountPointW                           = modkernel32.NewProc("FindFirstVolumeMountPointW")
        procFindFirstVolumeW                                     = modkernel32.NewProc("FindFirstVolumeW")
+       procFindNextChangeNotification                           = modkernel32.NewProc("FindNextChangeNotification")
        procFindNextFileW                                        = modkernel32.NewProc("FindNextFileW")
        procFindNextVolumeMountPointW                            = modkernel32.NewProc("FindNextVolumeMountPointW")
        procFindNextVolumeW                                      = modkernel32.NewProc("FindNextVolumeW")
@@ -338,10 +351,13 @@ var (
        procSHGetKnownFolderPath                                 = modshell32.NewProc("SHGetKnownFolderPath")
        procShellExecuteW                                        = modshell32.NewProc("ShellExecuteW")
        procExitWindowsEx                                        = moduser32.NewProc("ExitWindowsEx")
+       procGetShellWindow                                       = moduser32.NewProc("GetShellWindow")
+       procGetWindowThreadProcessId                             = moduser32.NewProc("GetWindowThreadProcessId")
        procMessageBoxW                                          = moduser32.NewProc("MessageBoxW")
        procCreateEnvironmentBlock                               = moduserenv.NewProc("CreateEnvironmentBlock")
        procDestroyEnvironmentBlock                              = moduserenv.NewProc("DestroyEnvironmentBlock")
        procGetUserProfileDirectoryW                             = moduserenv.NewProc("GetUserProfileDirectoryW")
+       procWinVerifyTrustEx                                     = modwintrust.NewProc("WinVerifyTrustEx")
        procFreeAddrInfoW                                        = modws2_32.NewProc("FreeAddrInfoW")
        procGetAddrInfoW                                         = modws2_32.NewProc("GetAddrInfoW")
        procWSACleanup                                           = modws2_32.NewProc("WSACleanup")
@@ -931,6 +947,22 @@ func RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reser
        return
 }
 
+func RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) {
+       var _p0 uint32
+       if watchSubtree {
+               _p0 = 1
+       }
+       var _p1 uint32
+       if asynchronous {
+               _p1 = 1
+       }
+       r0, _, _ := syscall.Syscall6(procRegNotifyChangeKeyValue.Addr(), 5, uintptr(key), uintptr(_p0), uintptr(notifyFilter), uintptr(event), uintptr(_p1), 0)
+       if r0 != 0 {
+               regerrno = syscall.Errno(r0)
+       }
+       return
+}
+
 func RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) {
        r0, _, _ := syscall.Syscall6(procRegOpenKeyExW.Addr(), 5, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(options), uintptr(desiredAccess), uintptr(unsafe.Pointer(result)), 0)
        if r0 != 0 {
@@ -1163,6 +1195,12 @@ func CertDeleteCertificateFromStore(certContext *CertContext) (err error) {
        return
 }
 
+func CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) {
+       r0, _, _ := syscall.Syscall(procCertDuplicateCertificateContext.Addr(), 1, uintptr(unsafe.Pointer(certContext)), 0, 0)
+       dupContext = (*CertContext)(unsafe.Pointer(r0))
+       return
+}
+
 func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) {
        r0, _, e1 := syscall.Syscall(procCertEnumCertificatesInStore.Addr(), 2, uintptr(store), uintptr(unsafe.Pointer(prevContext)), 0)
        context = (*CertContext)(unsafe.Pointer(r0))
@@ -1172,6 +1210,12 @@ func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (contex
        return
 }
 
+func CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) {
+       r0, _, _ := syscall.Syscall(procCertFindExtension.Addr(), 3, uintptr(unsafe.Pointer(objId)), uintptr(countExtensions), uintptr(unsafe.Pointer(extensions)))
+       ret = (*CertExtension)(unsafe.Pointer(r0))
+       return
+}
+
 func CertFreeCertificateChain(ctx *CertChainContext) {
        syscall.Syscall(procCertFreeCertificateChain.Addr(), 1, uintptr(unsafe.Pointer(ctx)), 0, 0)
        return
@@ -1193,6 +1237,12 @@ func CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, a
        return
 }
 
+func CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) {
+       r0, _, _ := syscall.Syscall6(procCertGetNameStringW.Addr(), 6, uintptr(unsafe.Pointer(certContext)), uintptr(nameType), uintptr(flags), uintptr(typePara), uintptr(unsafe.Pointer(name)), uintptr(size))
+       chars = uint32(r0)
+       return
+}
+
 func CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) {
        r0, _, e1 := syscall.Syscall6(procCertOpenStore.Addr(), 5, uintptr(storeProvider), uintptr(msgAndCertEncodingType), uintptr(cryptProv), uintptr(flags), uintptr(para), 0)
        handle = Handle(r0)
@@ -1219,6 +1269,47 @@ func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext
        return
 }
 
+func CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) {
+       r1, _, e1 := syscall.Syscall9(procCryptDecodeObject.Addr(), 7, uintptr(encodingType), uintptr(unsafe.Pointer(structType)), uintptr(unsafe.Pointer(encodedBytes)), uintptr(lenEncodedBytes), uintptr(flags), uintptr(decoded), uintptr(unsafe.Pointer(decodedLen)), 0, 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
+       r1, _, e1 := syscall.Syscall9(procCryptProtectData.Addr(), 7, uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)), 0, 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) {
+       r1, _, e1 := syscall.Syscall12(procCryptQueryObject.Addr(), 11, uintptr(objectType), uintptr(object), uintptr(expectedContentTypeFlags), uintptr(expectedFormatTypeFlags), uintptr(flags), uintptr(unsafe.Pointer(msgAndCertEncodingType)), uintptr(unsafe.Pointer(contentType)), uintptr(unsafe.Pointer(formatType)), uintptr(unsafe.Pointer(certStore)), uintptr(unsafe.Pointer(msg)), uintptr(unsafe.Pointer(context)), 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
+       r1, _, e1 := syscall.Syscall9(procCryptUnprotectData.Addr(), 7, uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)), 0, 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) {
+       r0, _, e1 := syscall.Syscall(procPFXImportCertStore.Addr(), 3, uintptr(unsafe.Pointer(pfx)), uintptr(unsafe.Pointer(password)), uintptr(flags))
+       store = Handle(r0)
+       if store == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
 func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
        r0, _, _ := syscall.Syscall(procDnsNameCompare_W.Addr(), 2, uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)), 0)
        same = r0 != 0
@@ -1489,6 +1580,36 @@ func FindClose(handle Handle) (err error) {
        return
 }
 
+func FindCloseChangeNotification(handle Handle) (err error) {
+       r1, _, e1 := syscall.Syscall(procFindCloseChangeNotification.Addr(), 1, uintptr(handle), 0, 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
+       var _p0 *uint16
+       _p0, err = syscall.UTF16PtrFromString(path)
+       if err != nil {
+               return
+       }
+       return _FindFirstChangeNotification(_p0, watchSubtree, notifyFilter)
+}
+
+func _FindFirstChangeNotification(path *uint16, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
+       var _p1 uint32
+       if watchSubtree {
+               _p1 = 1
+       }
+       r0, _, e1 := syscall.Syscall(procFindFirstChangeNotificationW.Addr(), 3, uintptr(unsafe.Pointer(path)), uintptr(_p1), uintptr(notifyFilter))
+       handle = Handle(r0)
+       if handle == InvalidHandle {
+               err = errnoErr(e1)
+       }
+       return
+}
+
 func findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) {
        r0, _, e1 := syscall.Syscall(procFindFirstFileW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(data)), 0)
        handle = Handle(r0)
@@ -1516,6 +1637,14 @@ func FindFirstVolume(volumeName *uint16, bufferLength uint32) (handle Handle, er
        return
 }
 
+func FindNextChangeNotification(handle Handle) (err error) {
+       r1, _, e1 := syscall.Syscall(procFindNextChangeNotification.Addr(), 1, uintptr(handle), 0, 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
 func findNextFile1(handle Handle, data *win32finddata1) (err error) {
        r1, _, e1 := syscall.Syscall(procFindNextFileW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(data)), 0)
        if r1 == 0 {
@@ -2862,7 +2991,22 @@ func ExitWindowsEx(flags uint32, reason uint32) (err error) {
        return
 }
 
-func MessageBox(hwnd Handle, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
+func GetShellWindow() (shellWindow HWND) {
+       r0, _, _ := syscall.Syscall(procGetShellWindow.Addr(), 0, 0, 0, 0)
+       shellWindow = HWND(r0)
+       return
+}
+
+func GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) {
+       r0, _, e1 := syscall.Syscall(procGetWindowThreadProcessId.Addr(), 2, uintptr(hwnd), uintptr(unsafe.Pointer(pid)), 0)
+       tid = uint32(r0)
+       if tid == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
        r0, _, e1 := syscall.Syscall6(procMessageBoxW.Addr(), 4, uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype), 0, 0)
        ret = int32(r0)
        if ret == 0 {
@@ -2899,6 +3043,14 @@ func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) {
        return
 }
 
+func WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) {
+       r0, _, _ := syscall.Syscall(procWinVerifyTrustEx.Addr(), 3, uintptr(hwnd), uintptr(unsafe.Pointer(actionId)), uintptr(unsafe.Pointer(data)))
+       if r0 != 0 {
+               ret = syscall.Errno(r0)
+       }
+       return
+}
+
 func FreeAddrInfoW(addrinfo *AddrinfoW) {
        syscall.Syscall(procFreeAddrInfoW.Addr(), 1, uintptr(unsafe.Pointer(addrinfo)), 0, 0)
        return

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/analysis.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/analysis.go
index 8c3c2e7ab950f2497e93c5a0d27a4bc05d9fbff1..d11505a165c86ee7b56f902cbcc74a5cb8f3f5a3 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/analysis.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/analysis.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package analysis
 
 import (

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
index 57eaf6faa2ac73c24ef6ef71cc9dabeee37e18b0..cd462a0cb554458b8b63d2fd2118c58a8b116777 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
@@ -1,3 +1,7 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package analysis
 
 import "go/token"

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/doc.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/doc.go
index 9fa3302dfbe9950c7c843adae82e5a985e30155f..94a3bd5d07cac01576bf5444ded4af58212ec95f 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/doc.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/doc.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 /*
 
 Package analysis defines the interface between a modular static

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/analysisflags/help.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/analysisflags/help.go
index c5a70f3b7d65ada3d6b2acb201cda7d32ab9fb2f..ce92892c817690f5139f5b00f02355500e66b497 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/analysisflags/help.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/analysisflags/help.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package analysisflags
 
 import (

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/internal/analysisutil/util.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/internal/analysisutil/util.go
index 80c9476fcdd19f066966bba63d8dfdd989d8d4dd..ac37e4784e146be5c75c29694ce2b7daab54e0f5 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/internal/analysisutil/util.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/internal/analysisutil/util.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 // Package analysisutil defines various helper functions
 // used by two or more packages beneath go/analysis.
 package analysisutil

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/types.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/types.go
index bd8a594ef57b8bc68fc74a53654527124b39dad9..6a5fae44f469f30c81939ca951e8d8980ea6d775 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/types.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/types.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package printf
 
 import (

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
index 02555648a0bdd4f34446127e9fbb87764151514d..f0b15051c52eacc1cc5fd6912bfa03dcb3ea7558 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
@@ -207,12 +207,12 @@ var (
 )
 
 // validateStructTag parses the struct tag and returns an error if it is not
-// in the canonical format, as defined by reflect.StructTag.
+// in the canonical format, which is a space-separated list of key:"value"
+// settings. The value may contain spaces.
 func validateStructTag(tag string) error {
        // This code is based on the StructTag.Get code in package reflect.
 
        n := 0
-       var keys []string
        for ; tag != ""; n++ {
                if n > 0 && tag != "" && tag[0] != ' ' {
                        // More restrictive than reflect, but catches likely mistakes
@@ -240,27 +240,14 @@ func validateStructTag(tag string) error {
                if i == 0 {
                        return errTagKeySyntax
                }
-               if i+1 >= len(tag) || tag[i] < ' ' || tag[i] == 0x7f {
+               if i+1 >= len(tag) || tag[i] != ':' {
                        return errTagSyntax
                }
-               key := tag[:i]
-               keys = append(keys, key)
-               tag = tag[i:]
-
-               // If we found a space char here - assume that we have a tag with
-               // multiple keys.
-               if tag[0] == ' ' {
-                       continue
-               }
-
-               // Spaces were filtered above so we assume that here we have
-               // only valid tag value started with `:"`.
-               if tag[0] != ':' || tag[1] != '"' {
+               if tag[i+1] != '"' {
                        return errTagValueSyntax
                }
-
-               // Remove the colon leaving tag at the start of the quoted string.
-               tag = tag[1:]
+               key := tag[:i]
+               tag = tag[i+1:]
 
                // Scan quoted string to find value.
                i = 1
@@ -276,56 +263,51 @@ func validateStructTag(tag string) error {
                qvalue := tag[:i+1]
                tag = tag[i+1:]
 
-               wholeValue, err := strconv.Unquote(qvalue)
+               value, err := strconv.Unquote(qvalue)
                if err != nil {
                        return errTagValueSyntax
                }
 
-               for _, key := range keys {
-                       if !checkTagSpaces[key] {
-                               continue
-                       }
-
-                       value := wholeValue
-                       switch key {
-                       case "xml":
-                               // If the first or last character in the XML tag is a space, it is
-                               // suspicious.
-                               if strings.Trim(value, " ") != value {
-                                       return errTagValueSpace
-                               }
+               if !checkTagSpaces[key] {
+                       continue
+               }
 
-                               // If there are multiple spaces, they are suspicious.
-                               if strings.Count(value, " ") > 1 {
-                                       return errTagValueSpace
-                               }
+               switch key {
+               case "xml":
+                       // If the first or last character in the XML tag is a space, it is
+                       // suspicious.
+                       if strings.Trim(value, " ") != value {
+                               return errTagValueSpace
+                       }
 
-                               // If there is no comma, skip the rest of the checks.
-                               comma := strings.IndexRune(value, ',')
-                               if comma < 0 {
-                                       continue
-                               }
+                       // If there are multiple spaces, they are suspicious.
+                       if strings.Count(value, " ") > 1 {
+                               return errTagValueSpace
+                       }
 
-                               // If the character before a comma is a space, this is suspicious.
-                               if comma > 0 && value[comma-1] == ' ' {
-                                       return errTagValueSpace
-                               }
-                               value = value[comma+1:]
-                       case "json":
-                               // JSON allows using spaces in the name, so skip it.
-                               comma := strings.IndexRune(value, ',')
-                               if comma < 0 {
-                                       continue
-                               }
-                               value = value[comma+1:]
+                       // If there is no comma, skip the rest of the checks.
+                       comma := strings.IndexRune(value, ',')
+                       if comma < 0 {
+                               continue
                        }
 
-                       if strings.IndexByte(value, ' ') >= 0 {
+                       // If the character before a comma is a space, this is suspicious.
+                       if comma > 0 && value[comma-1] == ' ' {
                                return errTagValueSpace
                        }
+                       value = value[comma+1:]
+               case "json":
+                       // JSON allows using spaces in the name, so skip it.
+                       comma := strings.IndexRune(value, ',')
+                       if comma < 0 {
+                               continue
+                       }
+                       value = value[comma+1:]
                }
 
-               keys = keys[:0]
+               if strings.IndexByte(value, ' ') >= 0 {
+                       return errTagValueSpace
+               }
        }
        return nil
 }

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
index 683b7e91d25e572d5e950f38e63a7a9130c938a0..9051456e396ffcfb865b04c8f68bef4568ee509c 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 // +build go1.12
 
 package unitchecker

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/validate.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/validate.go
index ad0e7276c915f6c0c54622bbe3cf88eb3776a524..23e57bf02b66ad3f07b131d05637489c3e15f7e7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/validate.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/validate.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package analysis
 
 import (

diff --git a/src/cmd/vendor/golang.org/x/tools/go/ast/astutil/util.go b/src/cmd/vendor/golang.org/x/tools/go/ast/astutil/util.go
index 7630629824af1e839b5954b72a5d5021191d69ae..919d5305ab422eb19f91d06d6d04fbad62f40650 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/ast/astutil/util.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/ast/astutil/util.go
@@ -1,3 +1,7 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package astutil
 
 import "go/ast"

diff --git a/src/cmd/vendor/golang.org/x/tools/go/ast/inspector/typeof.go b/src/cmd/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
index d61301b133dfdc28f8187d6f736d399e4373c6b9..b6b00cf2e1e377ee30c870d0532e73c9d3716a89 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
@@ -1,3 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package inspector
 
 // This file defines func typeOf(ast.Node) uint64.

diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 4e47f41855ef24ad4e83a7220700a0173e30c02e..616fb6c1e6065d4d213402711b151dc3bb66b7ce 100644 (file)
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.0
+# golang.org/x/mod v0.4.1
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
@@ -39,12 +39,12 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20201204225414-ed752295db88
+# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
 ## explicit
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/tools v0.0.0-20201211025543-abf6a1d87e11
+# golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff
 ## explicit
 golang.org/x/tools/go/analysis
 golang.org/x/tools/go/analysis/internal/analysisflags

diff --git a/src/crypto/elliptic/p224.go b/src/crypto/elliptic/p224.go
index 2ea63f3f0c0577677464a6194670a3fc8df91791..8c76021464207f4f78a1bd0a7bc3d7d8e7bbb20e 100644 (file)
--- a/src/crypto/elliptic/p224.go
+++ b/src/crypto/elliptic/p224.go
@@ -386,10 +386,11 @@ func p224Invert(out, in *p224FieldElement) {
 // p224Contract converts a FieldElement to its unique, minimal form.
 //
 // On entry, in[i] < 2**29
-// On exit, in[i] < 2**28
+// On exit, out[i] < 2**28 and out < p
 func p224Contract(out, in *p224FieldElement) {
        copy(out[:], in[:])
 
+       // First, carry the bits above 28 to the higher limb.
        for i := 0; i < 7; i++ {
                out[i+1] += out[i] >> 28
                out[i] &= bottom28Bits
@@ -397,10 +398,13 @@ func p224Contract(out, in *p224FieldElement) {
        top := out[7] >> 28
        out[7] &= bottom28Bits
 
+       // Use the reduction identity to carry the overflow.
+       //
+       //   a + top * 2²²⁴ = a + top * 2⁹⁶ - top
        out[0] -= top
        out[3] += top << 12
 
-       // We may just have made out[i] negative. So we carry down. If we made
+       // We may just have made out[0] negative. So we carry down. If we made
        // out[0] negative then we know that out[3] is sufficiently positive
        // because we just added to it.
        for i := 0; i < 3; i++ {
@@ -425,13 +429,12 @@ func p224Contract(out, in *p224FieldElement) {
        // There are two cases to consider for out[3]:
        //   1) The first time that we eliminated top, we didn't push out[3] over
        //      2**28. In this case, the partial carry chain didn't change any values
-       //      and top is zero.
+       //      and top is now zero.
        //   2) We did push out[3] over 2**28 the first time that we eliminated top.
-       //      The first value of top was in [0..16), therefore, prior to eliminating
-       //      the first top, 0xfff1000 <= out[3] <= 0xfffffff. Therefore, after
-       //      overflowing and being reduced by the second carry chain, out[3] <=
-       //      0xf000. Thus it cannot have overflowed when we eliminated top for the
-       //      second time.
+       //      The first value of top was in [0..2], therefore, after overflowing
+       //      and being reduced by the second carry chain, out[3] <= 2<<12 - 1.
+       // In both cases, out[3] cannot have overflowed when we eliminated top for
+       // the second time.
 
        // Again, we may just have made out[0] negative, so do the same carry down.
        // As before, if we made out[0] negative then we know that out[3] is
@@ -470,12 +473,11 @@ func p224Contract(out, in *p224FieldElement) {
        bottom3NonZero |= bottom3NonZero >> 1
        bottom3NonZero = uint32(int32(bottom3NonZero<<31) >> 31)
 
-       // Everything depends on the value of out[3].
-       //    If it's > 0xffff000 and top4AllOnes != 0 then the whole value is >= p
-       //    If it's = 0xffff000 and top4AllOnes != 0 and bottom3NonZero != 0,
-       //      then the whole value is >= p
+       // Assuming top4AllOnes != 0, everything depends on the value of out[3].
+       //    If it's > 0xffff000 then the whole value is > p
+       //    If it's = 0xffff000 and bottom3NonZero != 0, then the whole value is >= p
        //    If it's < 0xffff000, then the whole value is < p
-       n := out[3] - 0xffff000
+       n := 0xffff000 - out[3]
        out3Equal := n
        out3Equal |= out3Equal >> 16
        out3Equal |= out3Equal >> 8
@@ -484,8 +486,8 @@ func p224Contract(out, in *p224FieldElement) {
        out3Equal |= out3Equal >> 1
        out3Equal = ^uint32(int32(out3Equal<<31) >> 31)
 
-       // If out[3] > 0xffff000 then n's MSB will be zero.
-       out3GT := ^uint32(int32(n) >> 31)
+       // If out[3] > 0xffff000 then n's MSB will be one.
+       out3GT := uint32(int32(n) >> 31)
 
        mask := top4AllOnes & ((out3Equal & bottom3NonZero) | out3GT)
        out[0] -= 1 & mask
@@ -494,6 +496,15 @@ func p224Contract(out, in *p224FieldElement) {
        out[5] -= 0xfffffff & mask
        out[6] -= 0xfffffff & mask
        out[7] -= 0xfffffff & mask
+
+       // Do one final carry down, in case we made out[0] negative. One of
+       // out[0..3] needs to be positive and able to absorb the -1 or the value
+       // would have been < p, and the subtraction wouldn't have happened.
+       for i := 0; i < 3; i++ {
+               mask := uint32(int32(out[i]) >> 31)
+               out[i] += (1 << 28) & mask
+               out[i+1] -= 1 & mask
+       }
 }
 
 // Group element functions.

diff --git a/src/crypto/elliptic/p224_test.go b/src/crypto/elliptic/p224_test.go
index 8b4fa0483b6a04bceb0164c0b64f6ee3a035f848..c3141b6ab4de0b00ec7382cff55b2d47b8ab1d0d 100644 (file)
--- a/src/crypto/elliptic/p224_test.go
+++ b/src/crypto/elliptic/p224_test.go
@@ -6,7 +6,11 @@ package elliptic
 
 import (
        "math/big"
+       "math/bits"
+       "math/rand"
+       "reflect"
        "testing"
+       "testing/quick"
 )
 
 var toFromBigTests = []string{
@@ -21,16 +25,16 @@ func p224AlternativeToBig(in *p224FieldElement) *big.Int {
        ret := new(big.Int)
        tmp := new(big.Int)
 
-       for i := uint(0); i < 8; i++ {
+       for i := len(in) - 1; i >= 0; i-- {
+               ret.Lsh(ret, 28)
                tmp.SetInt64(int64(in[i]))
-               tmp.Lsh(tmp, 28*i)
                ret.Add(ret, tmp)
        }
-       ret.Mod(ret, p224.P)
+       ret.Mod(ret, P224().Params().P)
        return ret
 }
 
-func TestToFromBig(t *testing.T) {
+func TestP224ToFromBig(t *testing.T) {
        for i, test := range toFromBigTests {
                n, _ := new(big.Int).SetString(test, 16)
                var x p224FieldElement
@@ -41,7 +45,270 @@ func TestToFromBig(t *testing.T) {
                }
                q := p224AlternativeToBig(&x)
                if n.Cmp(q) != 0 {
-                       t.Errorf("#%d: %x != %x (alternative)", i, n, m)
+                       t.Errorf("#%d: %x != %x (alternative)", i, n, q)
                }
        }
 }
+
+// quickCheckConfig32 will make each quickcheck test run (32 * -quickchecks)
+// times. The default value of -quickchecks is 100.
+var quickCheckConfig32 = &quick.Config{MaxCountScale: 32}
+
+// weirdLimbs can be combined to generate a range of edge-case field elements.
+var weirdLimbs = [...]uint32{
+       0, 1, (1 << 29) - 1,
+       (1 << 12), (1 << 12) - 1,
+       (1 << 28), (1 << 28) - 1,
+}
+
+func generateLimb(rand *rand.Rand) uint32 {
+       const bottom29Bits = 0x1fffffff
+       n := rand.Intn(len(weirdLimbs) + 3)
+       switch n {
+       case len(weirdLimbs):
+               // Random value.
+               return uint32(rand.Int31n(1 << 29))
+       case len(weirdLimbs) + 1:
+               // Sum of two values.
+               k := generateLimb(rand) + generateLimb(rand)
+               return k & bottom29Bits
+       case len(weirdLimbs) + 2:
+               // Difference of two values.
+               k := generateLimb(rand) - generateLimb(rand)
+               return k & bottom29Bits
+       default:
+               return weirdLimbs[n]
+       }
+}
+
+func (p224FieldElement) Generate(rand *rand.Rand, size int) reflect.Value {
+       return reflect.ValueOf(p224FieldElement{
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+               generateLimb(rand),
+       })
+}
+
+func isInBounds(x *p224FieldElement) bool {
+       return bits.Len32(x[0]) <= 29 &&
+               bits.Len32(x[1]) <= 29 &&
+               bits.Len32(x[2]) <= 29 &&
+               bits.Len32(x[3]) <= 29 &&
+               bits.Len32(x[4]) <= 29 &&
+               bits.Len32(x[5]) <= 29 &&
+               bits.Len32(x[6]) <= 29 &&
+               bits.Len32(x[7]) <= 29
+}
+
+func TestP224Mul(t *testing.T) {
+       mulMatchesBigInt := func(a, b, out p224FieldElement) bool {
+               var tmp p224LargeFieldElement
+               p224Mul(&out, &a, &b, &tmp)
+
+               exp := new(big.Int).Mul(p224AlternativeToBig(&a), p224AlternativeToBig(&b))
+               exp.Mod(exp, P224().Params().P)
+               got := p224AlternativeToBig(&out)
+               if exp.Cmp(got) != 0 || !isInBounds(&out) {
+                       t.Logf("a = %x", a)
+                       t.Logf("b = %x", b)
+                       t.Logf("p224Mul(a, b) = %x = %v", out, got)
+                       t.Logf("a * b = %v", exp)
+                       return false
+               }
+
+               return true
+       }
+
+       a := p224FieldElement{0xfffffff, 0xfffffff, 0xf00ffff, 0x20f, 0x0, 0x0, 0x0, 0x0}
+       b := p224FieldElement{1, 0, 0, 0, 0, 0, 0, 0}
+       if !mulMatchesBigInt(a, b, p224FieldElement{}) {
+               t.Fail()
+       }
+
+       if err := quick.Check(mulMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224Square(t *testing.T) {
+       squareMatchesBigInt := func(a, out p224FieldElement) bool {
+               var tmp p224LargeFieldElement
+               p224Square(&out, &a, &tmp)
+
+               exp := p224AlternativeToBig(&a)
+               exp.Mul(exp, exp)
+               exp.Mod(exp, P224().Params().P)
+               got := p224AlternativeToBig(&out)
+               if exp.Cmp(got) != 0 || !isInBounds(&out) {
+                       t.Logf("a = %x", a)
+                       t.Logf("p224Square(a, b) = %x = %v", out, got)
+                       t.Logf("a * a = %v", exp)
+                       return false
+               }
+
+               return true
+       }
+
+       if err := quick.Check(squareMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224Add(t *testing.T) {
+       addMatchesBigInt := func(a, b, out p224FieldElement) bool {
+               p224Add(&out, &a, &b)
+
+               exp := new(big.Int).Add(p224AlternativeToBig(&a), p224AlternativeToBig(&b))
+               exp.Mod(exp, P224().Params().P)
+               got := p224AlternativeToBig(&out)
+               if exp.Cmp(got) != 0 {
+                       t.Logf("a = %x", a)
+                       t.Logf("b = %x", b)
+                       t.Logf("p224Add(a, b) = %x = %v", out, got)
+                       t.Logf("a + b = %v", exp)
+                       return false
+               }
+
+               return true
+       }
+
+       if err := quick.Check(addMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224Reduce(t *testing.T) {
+       reduceMatchesBigInt := func(a p224FieldElement) bool {
+               out := a
+               // TODO: generate higher values for functions like p224Reduce that are
+               // expected to work with higher input bounds.
+               p224Reduce(&out)
+
+               exp := p224AlternativeToBig(&a)
+               got := p224AlternativeToBig(&out)
+               if exp.Cmp(got) != 0 || !isInBounds(&out) {
+                       t.Logf("a = %x = %v", a, exp)
+                       t.Logf("p224Reduce(a) = %x = %v", out, got)
+                       return false
+               }
+
+               return true
+       }
+
+       if err := quick.Check(reduceMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224Contract(t *testing.T) {
+       contractMatchesBigInt := func(a, out p224FieldElement) bool {
+               p224Contract(&out, &a)
+
+               exp := p224AlternativeToBig(&a)
+               got := p224AlternativeToBig(&out)
+               if exp.Cmp(got) != 0 {
+                       t.Logf("a = %x = %v", a, exp)
+                       t.Logf("p224Contract(a) = %x = %v", out, got)
+                       return false
+               }
+
+               // Check that out < P.
+               for i := range p224P {
+                       k := 8 - i - 1
+                       if out[k] > p224P[k] {
+                               t.Logf("p224Contract(a) = %x", out)
+                               return false
+                       }
+                       if out[k] < p224P[k] {
+                               return true
+                       }
+               }
+               t.Logf("p224Contract(a) = %x", out)
+               return false
+       }
+
+       if !contractMatchesBigInt(p224P, p224FieldElement{}) {
+               t.Error("p224Contract(p) is broken")
+       }
+       pMinus1 := p224FieldElement{0, 0, 0, 0xffff000, 0xfffffff, 0xfffffff, 0xfffffff, 0xfffffff}
+       if !contractMatchesBigInt(pMinus1, p224FieldElement{}) {
+               t.Error("p224Contract(p - 1) is broken")
+       }
+       // Check that we can handle input above p, but lowest limb zero.
+       a := p224FieldElement{0, 1, 0, 0xffff000, 0xfffffff, 0xfffffff, 0xfffffff, 0xfffffff}
+       if !contractMatchesBigInt(a, p224FieldElement{}) {
+               t.Error("p224Contract(p + 2²⁸) is broken")
+       }
+       // Check that we can handle input above p, but lowest three limbs zero.
+       b := p224FieldElement{0, 0, 0, 0xffff001, 0xfffffff, 0xfffffff, 0xfffffff, 0xfffffff}
+       if !contractMatchesBigInt(b, p224FieldElement{}) {
+               t.Error("p224Contract(p + 2⁸⁴) is broken")
+       }
+
+       if err := quick.Check(contractMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224IsZero(t *testing.T) {
+       if got := p224IsZero(&p224FieldElement{}); got != 1 {
+               t.Errorf("p224IsZero(0) = %d, expected 1", got)
+       }
+       if got := p224IsZero((*p224FieldElement)(&p224P)); got != 1 {
+               t.Errorf("p224IsZero(p) = %d, expected 1", got)
+       }
+       if got := p224IsZero(&p224FieldElement{1}); got != 0 {
+               t.Errorf("p224IsZero(1) = %d, expected 0", got)
+       }
+
+       isZeroMatchesBigInt := func(a p224FieldElement) bool {
+               isZero := p224IsZero(&a)
+
+               big := p224AlternativeToBig(&a)
+               if big.Sign() == 0 && isZero != 1 {
+                       return false
+               }
+               if big.Sign() != 0 && isZero != 0 {
+                       return false
+               }
+               return true
+       }
+
+       if err := quick.Check(isZeroMatchesBigInt, quickCheckConfig32); err != nil {
+               t.Error(err)
+       }
+}
+
+func TestP224Invert(t *testing.T) {
+       var out p224FieldElement
+
+       p224Invert(&out, &p224FieldElement{})
+       if got := p224IsZero(&out); got != 1 {
+               t.Errorf("p224Invert(0) = %x, expected 0", out)
+       }
+
+       p224Invert(&out, (*p224FieldElement)(&p224P))
+       if got := p224IsZero(&out); got != 1 {
+               t.Errorf("p224Invert(p) = %x, expected 0", out)
+       }
+
+       p224Invert(&out, &p224FieldElement{1})
+       p224Contract(&out, &out)
+       if out != (p224FieldElement{1}) {
+               t.Errorf("p224Invert(1) = %x, expected 1", out)
+       }
+
+       var tmp p224LargeFieldElement
+       a := p224FieldElement{1, 2, 3, 4, 5, 6, 7, 8}
+       p224Invert(&out, &a)
+       p224Mul(&out, &out, &a, &tmp)
+       p224Contract(&out, &out)
+       if out != (p224FieldElement{1}) {
+               t.Errorf("p224Invert(a) * a = %x, expected 1", out)
+       }
+}

diff --git a/src/crypto/rand/rand_windows.go b/src/crypto/rand/rand_windows.go
index 8b2c960906ae65c5d568596af8f0b4631f0fa006..7379f1489adbf13bb41598f56c745b9e03fccd6d 100644 (file)
--- a/src/crypto/rand/rand_windows.go
+++ b/src/crypto/rand/rand_windows.go
@@ -8,8 +8,8 @@
 package rand
 
 import (
+       "internal/syscall/windows"
        "os"
-       "syscall"
 )
 
 func init() { Reader = &rngReader{} }
@@ -24,7 +24,7 @@ func (r *rngReader) Read(b []byte) (n int, err error) {
                return 0, nil
        }
 
-       err = syscall.RtlGenRandom(&b[0], inputLen)
+       err = windows.RtlGenRandom(b)
        if err != nil {
                return 0, os.NewSyscallError("RtlGenRandom", err)
        }

diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
index 5b68742975cd079d25b3b8e4e56111e441cb2f8e..eec6e1ebbd9060559637c9d2476046b2665a4bed 100644 (file)
--- a/src/crypto/tls/common.go
+++ b/src/crypto/tls/common.go
@@ -7,7 +7,6 @@ package tls
 import (
        "bytes"
        "container/list"
-       "context"
        "crypto"
        "crypto/ecdsa"
        "crypto/ed25519"
@@ -444,16 +443,6 @@ type ClientHelloInfo struct {
        // config is embedded by the GetCertificate or GetConfigForClient caller,
        // for use with SupportsCertificate.
        config *Config
-
-       // ctx is the context of the handshake that is in progress.
-       ctx context.Context
-}
-
-// Context returns the context of the handshake that is in progress.
-// This context is a child of the context passed to HandshakeContext,
-// if any, and is canceled when the handshake concludes.
-func (c *ClientHelloInfo) Context() context.Context {
-       return c.ctx
 }
 
 // CertificateRequestInfo contains information from a server's
@@ -472,16 +461,6 @@ type CertificateRequestInfo struct {
 
        // Version is the TLS version that was negotiated for this connection.
        Version uint16
-
-       // ctx is the context of the handshake that is in progress.
-       ctx context.Context
-}
-
-// Context returns the context of the handshake that is in progress.
-// This context is a child of the context passed to HandshakeContext,
-// if any, and is canceled when the handshake concludes.
-func (c *CertificateRequestInfo) Context() context.Context {
-       return c.ctx
 }
 
 // RenegotiationSupport enumerates the different levels of support for TLS

diff --git a/src/crypto/tls/conn.go b/src/crypto/tls/conn.go
index 969f357834c0a5c1733b7b939248ebf07d514510..72ad52c194baf49c988baf83340573ed0e54cd01 100644 (file)
--- a/src/crypto/tls/conn.go
+++ b/src/crypto/tls/conn.go
@@ -8,7 +8,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto/cipher"
        "crypto/subtle"
        "crypto/x509"
@@ -28,7 +27,7 @@ type Conn struct {
        // constant
        conn        net.Conn
        isClient    bool
-       handshakeFn func(context.Context) error // (*Conn).clientHandshake or serverHandshake
+       handshakeFn func() error // (*Conn).clientHandshake or serverHandshake
 
        // handshakeStatus is 1 if the connection is currently transferring
        // application data (i.e. is not currently processing a handshake).
@@ -1191,7 +1190,7 @@ func (c *Conn) handleRenegotiation() error {
        defer c.handshakeMutex.Unlock()
 
        atomic.StoreUint32(&c.handshakeStatus, 0)
-       if c.handshakeErr = c.clientHandshake(context.Background()); c.handshakeErr == nil {
+       if c.handshakeErr = c.clientHandshake(); c.handshakeErr == nil {
                c.handshakes++
        }
        return c.handshakeErr
@@ -1374,61 +1373,8 @@ func (c *Conn) closeNotify() error {
 // first Read or Write will call it automatically.
 //
 // For control over canceling or setting a timeout on a handshake, use
-// HandshakeContext or the Dialer's DialContext method instead.
+// the Dialer's DialContext method.
 func (c *Conn) Handshake() error {
-       return c.HandshakeContext(context.Background())
-}
-
-// HandshakeContext runs the client or server handshake
-// protocol if it has not yet been run.
-//
-// The provided Context must be non-nil. If the context is canceled before
-// the handshake is complete, the handshake is interrupted and an error is returned.
-// Once the handshake has completed, cancellation of the context will not affect the
-// connection.
-//
-// Most uses of this package need not call HandshakeContext explicitly: the
-// first Read or Write will call it automatically.
-func (c *Conn) HandshakeContext(ctx context.Context) error {
-       // Delegate to unexported method for named return
-       // without confusing documented signature.
-       return c.handshakeContext(ctx)
-}
-
-func (c *Conn) handshakeContext(ctx context.Context) (ret error) {
-       handshakeCtx, cancel := context.WithCancel(ctx)
-       // Note: defer this before starting the "interrupter" goroutine
-       // so that we can tell the difference between the input being canceled and
-       // this cancellation. In the former case, we need to close the connection.
-       defer cancel()
-
-       // Start the "interrupter" goroutine, if this context might be canceled.
-       // (The background context cannot).
-       //
-       // The interrupter goroutine waits for the input context to be done and
-       // closes the connection if this happens before the function returns.
-       if ctx.Done() != nil {
-               done := make(chan struct{})
-               interruptRes := make(chan error, 1)
-               defer func() {
-                       close(done)
-                       if ctxErr := <-interruptRes; ctxErr != nil {
-                               // Return context error to user.
-                               ret = ctxErr
-                       }
-               }()
-               go func() {
-                       select {
-                       case <-handshakeCtx.Done():
-                               // Close the connection, discarding the error
-                               _ = c.conn.Close()
-                               interruptRes <- handshakeCtx.Err()
-                       case <-done:
-                               interruptRes <- nil
-                       }
-               }()
-       }
-
        c.handshakeMutex.Lock()
        defer c.handshakeMutex.Unlock()
 
@@ -1442,7 +1388,7 @@ func (c *Conn) handshakeContext(ctx context.Context) (ret error) {
        c.in.Lock()
        defer c.in.Unlock()
 
-       c.handshakeErr = c.handshakeFn(handshakeCtx)
+       c.handshakeErr = c.handshakeFn()
        if c.handshakeErr == nil {
                c.handshakes++
        } else {

diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index 92e33e716903a0ea25e3f50ddc5e0d71319a0be7..e684b21d527223e850e8a74d802e9ac0521e9753 100644 (file)
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -6,7 +6,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto"
        "crypto/ecdsa"
        "crypto/ed25519"
@@ -25,7 +24,6 @@ import (
 
 type clientHandshakeState struct {
        c            *Conn
-       ctx          context.Context
        serverHello  *serverHelloMsg
        hello        *clientHelloMsg
        suite        *cipherSuite
@@ -136,7 +134,7 @@ func (c *Conn) makeClientHello() (*clientHelloMsg, ecdheParameters, error) {
        return hello, params, nil
 }
 
-func (c *Conn) clientHandshake(ctx context.Context) (err error) {
+func (c *Conn) clientHandshake() (err error) {
        if c.config == nil {
                c.config = defaultConfig()
        }
@@ -200,7 +198,6 @@ func (c *Conn) clientHandshake(ctx context.Context) (err error) {
        if c.vers == VersionTLS13 {
                hs := &clientHandshakeStateTLS13{
                        c:           c,
-                       ctx:         ctx,
                        serverHello: serverHello,
                        hello:       hello,
                        ecdheParams: ecdheParams,
@@ -215,7 +212,6 @@ func (c *Conn) clientHandshake(ctx context.Context) (err error) {
 
        hs := &clientHandshakeState{
                c:           c,
-               ctx:         ctx,
                serverHello: serverHello,
                hello:       hello,
                session:     session,
@@ -544,7 +540,7 @@ func (hs *clientHandshakeState) doFullHandshake() error {
                certRequested = true
                hs.finishedHash.Write(certReq.marshal())
 
-               cri := certificateRequestInfoFromMsg(hs.ctx, c.vers, certReq)
+               cri := certificateRequestInfoFromMsg(c.vers, certReq)
                if chainToSend, err = c.getClientCertificate(cri); err != nil {
                        c.sendAlert(alertInternalError)
                        return err
@@ -884,11 +880,10 @@ func (c *Conn) verifyServerCertificate(certificates [][]byte) error {
 
 // certificateRequestInfoFromMsg generates a CertificateRequestInfo from a TLS
 // <= 1.2 CertificateRequest, making an effort to fill in missing information.
-func certificateRequestInfoFromMsg(ctx context.Context, vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
+func certificateRequestInfoFromMsg(vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
        cri := &CertificateRequestInfo{
                AcceptableCAs: certReq.certificateAuthorities,
                Version:       vers,
-               ctx:           ctx,
        }
 
        var rsaAvail, ecAvail bool

diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 8889e2c8c33d44304962df40e53e6330c0ad0460..12b0254123e938a71dd6b8c0592db9cf235bf255 100644 (file)
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -6,7 +6,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto/rsa"
        "crypto/x509"
        "encoding/base64"
@@ -21,7 +20,6 @@ import (
        "os/exec"
        "path/filepath"
        "reflect"
-       "runtime"
        "strconv"
        "strings"
        "testing"
@@ -2513,37 +2511,3 @@ func testResumptionKeepsOCSPAndSCT(t *testing.T, ver uint16) {
                        serverConfig.Certificates[0].SignedCertificateTimestamps, ccs.SignedCertificateTimestamps)
        }
 }
-
-func TestClientHandshakeContextCancellation(t *testing.T) {
-       c, s := localPipe(t)
-       serverConfig := testConfig.Clone()
-       serverErr := make(chan error, 1)
-       ctx, cancel := context.WithCancel(context.Background())
-       defer cancel()
-       go func() {
-               defer close(serverErr)
-               defer s.Close()
-               conn := Server(s, serverConfig)
-               _, err := conn.readClientHello(ctx)
-               cancel()
-               serverErr <- err
-       }()
-       cli := Client(c, testConfig)
-       err := cli.HandshakeContext(ctx)
-       if err == nil {
-               t.Fatal("Client handshake did not error when the context was canceled")
-       }
-       if err != context.Canceled {
-               t.Errorf("Unexpected client handshake error: %v", err)
-       }
-       if err := <-serverErr; err != nil {
-               t.Errorf("Unexpected server error: %v", err)
-       }
-       if runtime.GOARCH == "wasm" {
-               t.Skip("conn.Close does not error as expected when called multiple times on WASM")
-       }
-       err = cli.Close()
-       if err == nil {
-               t.Error("Client connection was not closed when the context was canceled")
-       }
-}

diff --git a/src/crypto/tls/handshake_client_tls13.go b/src/crypto/tls/handshake_client_tls13.go
index be37c681c6dee92a73e15945c9a7c3063a6dedf9..daa5d97fd35548c4871a2f7f7ffa3b6e5da013a7 100644 (file)
--- a/src/crypto/tls/handshake_client_tls13.go
+++ b/src/crypto/tls/handshake_client_tls13.go
@@ -6,7 +6,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto"
        "crypto/hmac"
        "crypto/rsa"
@@ -18,7 +17,6 @@ import (
 
 type clientHandshakeStateTLS13 struct {
        c           *Conn
-       ctx         context.Context
        serverHello *serverHelloMsg
        hello       *clientHelloMsg
        ecdheParams ecdheParameters
@@ -557,7 +555,6 @@ func (hs *clientHandshakeStateTLS13) sendClientCertificate() error {
                AcceptableCAs:    hs.certReq.certificateAuthorities,
                SignatureSchemes: hs.certReq.supportedSignatureAlgorithms,
                Version:          c.vers,
-               ctx:              hs.ctx,
        })
        if err != nil {
                return err

diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go
index 5a572a9db10f62d5da87cbd5e66f99f8286518a0..9c3e0f636ea7b548776ad75bf7ff112c65e7c571 100644 (file)
--- a/src/crypto/tls/handshake_server.go
+++ b/src/crypto/tls/handshake_server.go
@@ -5,7 +5,6 @@
 package tls
 
 import (
-       "context"
        "crypto"
        "crypto/ecdsa"
        "crypto/ed25519"
@@ -24,7 +23,6 @@ import (
 // It's discarded once the handshake has completed.
 type serverHandshakeState struct {
        c            *Conn
-       ctx          context.Context
        clientHello  *clientHelloMsg
        hello        *serverHelloMsg
        suite        *cipherSuite
@@ -39,8 +37,8 @@ type serverHandshakeState struct {
 }
 
 // serverHandshake performs a TLS handshake as a server.
-func (c *Conn) serverHandshake(ctx context.Context) error {
-       clientHello, err := c.readClientHello(ctx)
+func (c *Conn) serverHandshake() error {
+       clientHello, err := c.readClientHello()
        if err != nil {
                return err
        }
@@ -48,7 +46,6 @@ func (c *Conn) serverHandshake(ctx context.Context) error {
        if c.vers == VersionTLS13 {
                hs := serverHandshakeStateTLS13{
                        c:           c,
-                       ctx:         ctx,
                        clientHello: clientHello,
                }
                return hs.handshake()
@@ -56,7 +53,6 @@ func (c *Conn) serverHandshake(ctx context.Context) error {
 
        hs := serverHandshakeState{
                c:           c,
-               ctx:         ctx,
                clientHello: clientHello,
        }
        return hs.handshake()
@@ -128,7 +124,7 @@ func (hs *serverHandshakeState) handshake() error {
 }
 
 // readClientHello reads a ClientHello message and selects the protocol version.
-func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, error) {
+func (c *Conn) readClientHello() (*clientHelloMsg, error) {
        msg, err := c.readHandshake()
        if err != nil {
                return nil, err
@@ -142,7 +138,7 @@ func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, error) {
        var configForClient *Config
        originalConfig := c.config
        if c.config.GetConfigForClient != nil {
-               chi := clientHelloInfo(ctx, c, clientHello)
+               chi := clientHelloInfo(c, clientHello)
                if configForClient, err = c.config.GetConfigForClient(chi); err != nil {
                        c.sendAlert(alertInternalError)
                        return nil, err
@@ -224,7 +220,7 @@ func (hs *serverHandshakeState) processClientHello() error {
                }
        }
 
-       hs.cert, err = c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
+       hs.cert, err = c.config.getCertificate(clientHelloInfo(c, hs.clientHello))
        if err != nil {
                if err == errNoCertificates {
                        c.sendAlert(alertUnrecognizedName)
@@ -832,7 +828,7 @@ func (c *Conn) processCertsFromClient(certificate Certificate) error {
        return nil
 }
 
-func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
+func clientHelloInfo(c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
        supportedVersions := clientHello.supportedVersions
        if len(clientHello.supportedVersions) == 0 {
                supportedVersions = supportedVersionsFromMax(clientHello.vers)
@@ -848,6 +844,5 @@ func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg)
                SupportedVersions: supportedVersions,
                Conn:              c.conn,
                config:            c.config,
-               ctx:               ctx,
        }
 }

diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index ad851b6edf0a58b219baccbedc2b102c9bba572c..d6bf9e439b01c3e50b509085675ddf2a5953e60a 100644 (file)
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -6,7 +6,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto"
        "crypto/elliptic"
        "crypto/x509"
@@ -18,7 +17,6 @@ import (
        "os"
        "os/exec"
        "path/filepath"
-       "runtime"
        "strings"
        "testing"
        "time"
@@ -40,12 +38,10 @@ func testClientHelloFailure(t *testing.T, serverConfig *Config, m handshakeMessa
                cli.writeRecord(recordTypeHandshake, m.marshal())
                c.Close()
        }()
-       ctx := context.Background()
        conn := Server(s, serverConfig)
-       ch, err := conn.readClientHello(ctx)
+       ch, err := conn.readClientHello()
        hs := serverHandshakeState{
                c:           conn,
-               ctx:         ctx,
                clientHello: ch,
        }
        if err == nil {
@@ -1425,11 +1421,9 @@ func TestSNIGivenOnFailure(t *testing.T) {
                c.Close()
        }()
        conn := Server(s, serverConfig)
-       ctx := context.Background()
-       ch, err := conn.readClientHello(ctx)
+       ch, err := conn.readClientHello()
        hs := serverHandshakeState{
                c:           conn,
-               ctx:         ctx,
                clientHello: ch,
        }
        if err == nil {
@@ -1683,46 +1677,6 @@ func TestMultipleCertificates(t *testing.T) {
        }
 }
 
-func TestServerHandshakeContextCancellation(t *testing.T) {
-       c, s := localPipe(t)
-       clientConfig := testConfig.Clone()
-       clientErr := make(chan error, 1)
-       ctx, cancel := context.WithCancel(context.Background())
-       defer cancel()
-       go func() {
-               defer close(clientErr)
-               defer c.Close()
-               clientHello := &clientHelloMsg{
-                       vers:               VersionTLS10,
-                       random:             make([]byte, 32),
-                       cipherSuites:       []uint16{TLS_RSA_WITH_RC4_128_SHA},
-                       compressionMethods: []uint8{compressionNone},
-               }
-               cli := Client(c, clientConfig)
-               _, err := cli.writeRecord(recordTypeHandshake, clientHello.marshal())
-               cancel()
-               clientErr <- err
-       }()
-       conn := Server(s, testConfig)
-       err := conn.HandshakeContext(ctx)
-       if err == nil {
-               t.Fatal("Server handshake did not error when the context was canceled")
-       }
-       if err != context.Canceled {
-               t.Errorf("Unexpected server handshake error: %v", err)
-       }
-       if err := <-clientErr; err != nil {
-               t.Errorf("Unexpected client error: %v", err)
-       }
-       if runtime.GOARCH == "wasm" {
-               t.Skip("conn.Close does not error as expected when called multiple times on WASM")
-       }
-       err = conn.Close()
-       if err == nil {
-               t.Error("Server connection was not closed when the context was canceled")
-       }
-}
-
 func TestAESCipherReordering(t *testing.T) {
        currentAESSupport := hasAESGCMHardwareSupport
        defer func() { hasAESGCMHardwareSupport = currentAESSupport; initDefaultCipherSuites() }()

diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index c7837d2955d5aa7cda93d4e3840fca075f2fd4ea..c2c288aed4325b280f435fcb26239d0d9f49780e 100644 (file)
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -6,7 +6,6 @@ package tls
 
 import (
        "bytes"
-       "context"
        "crypto"
        "crypto/hmac"
        "crypto/rsa"
@@ -24,7 +23,6 @@ const maxClientPSKIdentities = 5
 
 type serverHandshakeStateTLS13 struct {
        c               *Conn
-       ctx             context.Context
        clientHello     *clientHelloMsg
        hello           *serverHelloMsg
        sentDummyCCS    bool
@@ -376,7 +374,7 @@ func (hs *serverHandshakeStateTLS13) pickCertificate() error {
                return c.sendAlert(alertMissingExtension)
        }
 
-       certificate, err := c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
+       certificate, err := c.config.getCertificate(clientHelloInfo(c, hs.clientHello))
        if err != nil {
                if err == errNoCertificates {
                        c.sendAlert(alertUnrecognizedName)

diff --git a/src/crypto/tls/tls.go b/src/crypto/tls/tls.go
index 19884f96e7d30994618e3ce33c2fcb1a0f059751..a389873d32ed1156ab1b03802aec73c59c2a1d85 100644 (file)
--- a/src/crypto/tls/tls.go
+++ b/src/crypto/tls/tls.go
@@ -25,6 +25,7 @@ import (
        "net"
        "os"
        "strings"
+       "time"
 )
 
 // Server returns a new TLS server side connection
@@ -115,16 +116,28 @@ func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*
 }
 
 func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
-       if netDialer.Timeout != 0 {
-               var cancel context.CancelFunc
-               ctx, cancel = context.WithTimeout(ctx, netDialer.Timeout)
-               defer cancel()
-       }
+       // We want the Timeout and Deadline values from dialer to cover the
+       // whole process: TCP connection and TLS handshake. This means that we
+       // also need to start our own timers now.
+       timeout := netDialer.Timeout
 
        if !netDialer.Deadline.IsZero() {
-               var cancel context.CancelFunc
-               ctx, cancel = context.WithDeadline(ctx, netDialer.Deadline)
-               defer cancel()
+               deadlineTimeout := time.Until(netDialer.Deadline)
+               if timeout == 0 || deadlineTimeout < timeout {
+                       timeout = deadlineTimeout
+               }
+       }
+
+       // hsErrCh is non-nil if we might not wait for Handshake to complete.
+       var hsErrCh chan error
+       if timeout != 0 || ctx.Done() != nil {
+               hsErrCh = make(chan error, 2)
+       }
+       if timeout != 0 {
+               timer := time.AfterFunc(timeout, func() {
+                       hsErrCh <- timeoutError{}
+               })
+               defer timer.Stop()
        }
 
        rawConn, err := netDialer.DialContext(ctx, network, addr)
@@ -151,10 +164,34 @@ func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, conf
        }
 
        conn := Client(rawConn, config)
-       if err := conn.HandshakeContext(ctx); err != nil {
+
+       if hsErrCh == nil {
+               err = conn.Handshake()
+       } else {
+               go func() {
+                       hsErrCh <- conn.Handshake()
+               }()
+
+               select {
+               case <-ctx.Done():
+                       err = ctx.Err()
+               case err = <-hsErrCh:
+                       if err != nil {
+                               // If the error was due to the context
+                               // closing, prefer the context's error, rather
+                               // than some random network teardown error.
+                               if e := ctx.Err(); e != nil {
+                                       err = e
+                               }
+                       }
+               }
+       }
+
+       if err != nil {
                rawConn.Close()
                return nil, err
        }
+
        return conn, nil
 }
 

diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go
index 9b776d4b8571e99a111eaf61852c4faf317e79c1..0572c6ccd810814634bc668b5e571963b9d7f208 100644 (file)
--- a/src/crypto/x509/internal/macos/corefoundation.go
+++ b/src/crypto/x509/internal/macos/corefoundation.go
@@ -39,7 +39,6 @@ type CFString CFRef
 const kCFAllocatorDefault = 0
 const kCFStringEncodingUTF8 = 0x08000100
 
-//go:linkname x509_CFStringCreateWithBytes x509_CFStringCreateWithBytes
 //go:cgo_import_dynamic x509_CFStringCreateWithBytes CFStringCreateWithBytes "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 // StringToCFString returns a copy of the UTF-8 contents of s as a new CFString.
@@ -52,7 +51,6 @@ func StringToCFString(s string) CFString {
 }
 func x509_CFStringCreateWithBytes_trampoline()
 
-//go:linkname x509_CFDictionaryGetValueIfPresent x509_CFDictionaryGetValueIfPresent
 //go:cgo_import_dynamic x509_CFDictionaryGetValueIfPresent CFDictionaryGetValueIfPresent "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDictionaryGetValueIfPresent(dict CFRef, key CFString) (value CFRef, ok bool) {
@@ -67,7 +65,6 @@ func x509_CFDictionaryGetValueIfPresent_trampoline()
 
 const kCFNumberSInt32Type = 3
 
-//go:linkname x509_CFNumberGetValue x509_CFNumberGetValue
 //go:cgo_import_dynamic x509_CFNumberGetValue CFNumberGetValue "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFNumberGetValue(num CFRef) (int32, error) {
@@ -81,7 +78,6 @@ func CFNumberGetValue(num CFRef) (int32, error) {
 }
 func x509_CFNumberGetValue_trampoline()
 
-//go:linkname x509_CFDataGetLength x509_CFDataGetLength
 //go:cgo_import_dynamic x509_CFDataGetLength CFDataGetLength "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetLength(data CFRef) int {
@@ -90,7 +86,6 @@ func CFDataGetLength(data CFRef) int {
 }
 func x509_CFDataGetLength_trampoline()
 
-//go:linkname x509_CFDataGetBytePtr x509_CFDataGetBytePtr
 //go:cgo_import_dynamic x509_CFDataGetBytePtr CFDataGetBytePtr "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetBytePtr(data CFRef) uintptr {
@@ -99,7 +94,6 @@ func CFDataGetBytePtr(data CFRef) uintptr {
 }
 func x509_CFDataGetBytePtr_trampoline()
 
-//go:linkname x509_CFArrayGetCount x509_CFArrayGetCount
 //go:cgo_import_dynamic x509_CFArrayGetCount CFArrayGetCount "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetCount(array CFRef) int {
@@ -108,7 +102,6 @@ func CFArrayGetCount(array CFRef) int {
 }
 func x509_CFArrayGetCount_trampoline()
 
-//go:linkname x509_CFArrayGetValueAtIndex x509_CFArrayGetValueAtIndex
 //go:cgo_import_dynamic x509_CFArrayGetValueAtIndex CFArrayGetValueAtIndex "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetValueAtIndex(array CFRef, index int) CFRef {
@@ -117,7 +110,6 @@ func CFArrayGetValueAtIndex(array CFRef, index int) CFRef {
 }
 func x509_CFArrayGetValueAtIndex_trampoline()
 
-//go:linkname x509_CFEqual x509_CFEqual
 //go:cgo_import_dynamic x509_CFEqual CFEqual "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFEqual(a, b CFRef) bool {
@@ -126,7 +118,6 @@ func CFEqual(a, b CFRef) bool {
 }
 func x509_CFEqual_trampoline()
 
-//go:linkname x509_CFRelease x509_CFRelease
 //go:cgo_import_dynamic x509_CFRelease CFRelease "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFRelease(ref CFRef) {

diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s
index a4495d68dd3575bda0423647dd4dee296ab8ceb4..1ce39fac9d752ba95f64d7f75b2fb2aa6f5b5f50 100644 (file)
--- a/src/crypto/x509/internal/macos/corefoundation.s
+++ b/src/crypto/x509/internal/macos/corefoundation.s
@@ -6,21 +6,24 @@
 
 #include "textflag.h"
 
-TEXT ·x509_CFArrayGetCount_trampoline(SB),NOSPLIT,$0-0
+// The trampolines are ABIInternal as they are address-taken in
+// Go code.
+
+TEXT ·x509_CFArrayGetCount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFArrayGetCount(SB)
-TEXT ·x509_CFArrayGetValueAtIndex_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFArrayGetValueAtIndex_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFArrayGetValueAtIndex(SB)
-TEXT ·x509_CFDataGetBytePtr_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetBytePtr_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFDataGetBytePtr(SB)
-TEXT ·x509_CFDataGetLength_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetLength_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFDataGetLength(SB)
-TEXT ·x509_CFStringCreateWithBytes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFStringCreateWithBytes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFStringCreateWithBytes(SB)
-TEXT ·x509_CFRelease_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFRelease_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFRelease(SB)
-TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFDictionaryGetValueIfPresent(SB)
-TEXT ·x509_CFNumberGetValue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFNumberGetValue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFNumberGetValue(SB)
-TEXT ·x509_CFEqual_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFEqual_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_CFEqual(SB)

diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go
index 5e39e936666292b44ebbedd87ba22faac4690da3..3163e3a4f727fe6ee4e9ab957c2e746c75183a6c 100644 (file)
--- a/src/crypto/x509/internal/macos/security.go
+++ b/src/crypto/x509/internal/macos/security.go
@@ -63,7 +63,6 @@ var ErrNoTrustSettings = errors.New("no trust settings found")
 
 const errSecNoTrustSettings = -25263
 
-//go:linkname x509_SecTrustSettingsCopyCertificates x509_SecTrustSettingsCopyCertificates
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyCertificates SecTrustSettingsCopyCertificates "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyCertificates(domain SecTrustSettingsDomain) (certArray CFRef, err error) {
@@ -80,7 +79,6 @@ func x509_SecTrustSettingsCopyCertificates_trampoline()
 
 const kSecFormatX509Cert int32 = 9
 
-//go:linkname x509_SecItemExport x509_SecItemExport
 //go:cgo_import_dynamic x509_SecItemExport SecItemExport "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecItemExport(cert CFRef) (data CFRef, err error) {
@@ -95,7 +93,6 @@ func x509_SecItemExport_trampoline()
 
 const errSecItemNotFound = -25300
 
-//go:linkname x509_SecTrustSettingsCopyTrustSettings x509_SecTrustSettingsCopyTrustSettings
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyTrustSettings SecTrustSettingsCopyTrustSettings "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyTrustSettings(cert CFRef, domain SecTrustSettingsDomain) (trustSettings CFRef, err error) {
@@ -110,7 +107,6 @@ func SecTrustSettingsCopyTrustSettings(cert CFRef, domain SecTrustSettingsDomain
 }
 func x509_SecTrustSettingsCopyTrustSettings_trampoline()
 
-//go:linkname x509_SecPolicyCopyProperties x509_SecPolicyCopyProperties
 //go:cgo_import_dynamic x509_SecPolicyCopyProperties SecPolicyCopyProperties "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecPolicyCopyProperties(policy CFRef) CFRef {

diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s
index bd446dbcbe260fa0b310667ef3dc96faa54a63cf..bea265a5ef9166b3e66c307b14d64777b9561c05 100644 (file)
--- a/src/crypto/x509/internal/macos/security.s
+++ b/src/crypto/x509/internal/macos/security.s
@@ -6,11 +6,14 @@
 
 #include "textflag.h"
 
-TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline(SB),NOSPLIT,$0-0
+// The trampolines are ABIInternal as they are address-taken in
+// Go code.
+
+TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_SecTrustSettingsCopyCertificates(SB)
-TEXT ·x509_SecItemExport_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecItemExport_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_SecItemExport(SB)
-TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_SecTrustSettingsCopyTrustSettings(SB)
-TEXT ·x509_SecPolicyCopyProperties_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecPolicyCopyProperties_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     x509_SecPolicyCopyProperties(SB)

diff --git a/src/crypto/x509/root.go b/src/crypto/x509/root.go
index ac92915128d60ed824e04482dc1d0d39c588388d..cc53f7aefcabcbe8229c13e42d44d6707af99812 100644 (file)
--- a/src/crypto/x509/root.go
+++ b/src/crypto/x509/root.go
@@ -4,7 +4,11 @@
 
 package x509
 
-//go:generate go run root_ios_gen.go -version 55161.140.3
+// To update the embedded iOS root store, update the -version
+// argument to the latest security_certificates version from
+// https://opensource.apple.com/source/security_certificates/
+// and run "go generate". See https://golang.org/issue/38843.
+//go:generate go run root_ios_gen.go -version 55188.40.9
 
 import "sync"
 

diff --git a/src/crypto/x509/root_ios.go b/src/crypto/x509/root_ios.go
index cb3529d6d53b9efe9c7e6b6f1236fb5a6f4d9e3b..d2dfb62b77c6a9ab56300c2fd9b60ab44b8f280a 100644 (file)
--- a/src/crypto/x509/root_ios.go
+++ b/src/crypto/x509/root_ios.go
@@ -1,4 +1,4 @@
-// Code generated by root_ios_gen.go -version 55161.140.3; DO NOT EDIT.
+// Code generated by root_ios_gen.go -version 55188.40.9; DO NOT EDIT.
 // Update the version in root.go and regenerate with "go generate".
 
 // +build ios
@@ -116,61 +116,6 @@ ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU
 LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT
 LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg==
 -----END CERTIFICATE-----
-# "AddTrust Class 1 CA Root"
-# 8C 72 09 27 9A C0 4E 27 5E 16 D0 7F D3 B7 75 E8
-# 01 54 B5 96 80 46 E3 1F 52 DD 25 76 63 24 E9 A7
------BEGIN CERTIFICATE-----
-MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU
-MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
-b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw
-MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML
-QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD
-VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA
-A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul
-CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n
-tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl
-dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch
-PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC
-+Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O
-BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E
-BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl
-MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk
-ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB
-IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X
-7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz
-43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY
-eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl
-pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA
-WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk=
------END CERTIFICATE-----
-# "AddTrust External CA Root"
-# 68 7F A4 51 38 22 78 FF F0 C8 B1 1F 8D 43 D5 76
-# 67 1C 6E B2 BC EA B4 13 FB 83 D9 65 D0 6D 2F F2
------BEGIN CERTIFICATE-----
-MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
-MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
-IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
-MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
-FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
-bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
-dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
-H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
-uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
-mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
-a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
-E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
-WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
-VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
-Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
-cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
-IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
-AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
-YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
-6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
-Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
-c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
-mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
------END CERTIFICATE-----
 # "Admin-Root-CA"
 # A3 1F 09 30 53 BD 12 C1 F5 C3 C6 EF D4 98 02 3F
 # D2 91 4D 77 58 D0 5D 69 8C E0 84 B5 06 26 E0 E5
@@ -1249,31 +1194,6 @@ Bvt9YAretIpjsJyp8qS5UwGH0GikJ3+r/+n6yUA4iGe0OcaEb1fJU9u6ju7AQ7L4
 CYNu/2bPPu8Xs1gYJQk0XuPL1hS27PKSb3TkL4Eq1ZKR4OCXPDJoBYVL0fdX4lId
 kxpUnwVwwEpxYB5DC2Ae/qPOgRnhCzU=
 -----END CERTIFICATE-----
-# "Class 2 Primary CA"
-# 0F 99 3C 8A EF 97 BA AF 56 87 14 0E D5 9A D1 82
-# 1B B4 AF AC F0 AA 9A 58 B5 D5 7A 33 8A 3A FB CB
------BEGIN CERTIFICATE-----
-MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw
-PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz
-cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9
-MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz
-IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ
-ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR
-VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL
-kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd
-EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas
-H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0
-HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud
-DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4
-QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu
-Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/
-AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8
-yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR
-FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA
-ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB
-kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7
-l7+ijrRU
------END CERTIFICATE-----
 # "COMODO Certification Authority"
 # 0C 2C D6 3D F7 80 6F A3 99 ED E8 09 11 6B 57 5B
 # F8 79 89 F0 65 18 F9 80 8C 86 05 03 17 8B AF 66
@@ -1529,31 +1449,6 @@ CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
 xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
 KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
 -----END CERTIFICATE-----
-# "Deutsche Telekom Root CA 2"
-# B6 19 1A 50 D0 C3 97 7F 7D A9 9B CD AA C8 6A 22
-# 7D AE B9 67 9E C7 0B A3 B0 C9 D9 22 71 C1 70 D3
------BEGIN CERTIFICATE-----
-MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc
-MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj
-IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB
-IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE
-RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl
-U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290
-IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU
-ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC
-QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr
-rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S
-NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc
-QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH
-txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP
-BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC
-AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp
-tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa
-IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl
-6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+
-xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU
-Cm26OWMohpLzGITY+9HPBVZkVw==
------END CERTIFICATE-----
 # "Developer ID Certification Authority"
 # 7A FC 9D 01 A6 2F 03 A2 DE 96 37 93 6D 4A FE 68
 # 09 0D 2D E1 8D 03 F2 9C 88 CF B0 B1 BA 63 58 7F
@@ -1801,29 +1696,6 @@ R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5
 JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo
 Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ
 -----END CERTIFICATE-----
-# "DST Root CA X4"
-# 9A 73 92 9A 50 0F 1A 0B F4 9D CB 04 6E 80 39 16
-# 96 96 55 73 45 E9 F8 13 F1 0F F9 38 0D B2 26 95
------BEGIN CERTIFICATE-----
-MIIDOzCCAiOgAwIBAgIRANAeRlAAACmMAAAAAgAAAAIwDQYJKoZIhvcNAQEFBQAw
-PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD
-Ew5EU1QgUm9vdCBDQSBYNDAeFw0wMDA5MTMwNjIyNTBaFw0yMDA5MTMwNjIyNTBa
-MD8xJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjEXMBUGA1UE
-AxMORFNUIFJvb3QgQ0EgWDQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
-AQCthX3OFEYY8gSeIYur0O4ypOT68HnDrjLfIutL5PZHRwQGjzCPb9PFo/ihboJ8
-RvfGhBAqpQCo47zwYEhpWm1jB+L/OE/dBBiyn98krfU2NiBKSom2J58RBeAwHGEy
-cO+lewyjVvbDDLUy4CheY059vfMjPAftCRXjqSZIolQb9FdPcAoa90mFwB7rKniE
-J7vppdrUScSS0+eBrHSUPLdvwyn4RGp+lSwbWYcbg5EpSpE0GRJdchic0YDjvIoC
-YHpe7Rkj93PYRTQyU4bhC88ck8tMqbvRYqMRqR+vobbkrj5LLCOQCHV5WEoxWh+0
-E2SpIFe7RkV++MmpIAc0h1tZAgMBAAGjMjAwMA8GA1UdEwEB/wQFMAMBAf8wHQYD
-VR0OBBYEFPCD6nPIP1ubWzdf9UyPWvf0hki9MA0GCSqGSIb3DQEBBQUAA4IBAQCE
-G85wl5eEWd7adH6XW/ikGN5salvpq/Fix6yVTzE6CrhlP5LBdkf6kx1bSPL18M45
-g0rw2zA/MWOhJ3+S6U+BE0zPGCuu8YQaZibR7snm3HiHUaZNMu5c8D0x0bcMxDjY
-AVVcHCoNiL53Q4PLW27nbY6wwG0ffFKmgV3blxrYWfuUDgGpyPwHwkfVFvz9qjaV
-mf12VJffL6W8omBPtgteb6UaT/k1oJ7YI0ldGf+ngpVbRhD+LC3cUtT6GO/BEPZu
-8YTV/hbiDH5v3khVqMIeKT6o8IuXGG7F6a6vKwP1F1FwTXf4UC/ivhme7vdUH7B/
-Vv4AEbT8dNfEeFxrkDbh
------END CERTIFICATE-----
 # "E-Tugra Certification Authority"
 # B0 BF D5 2B B0 D7 D9 BD 92 BF 5D 4D C1 3D A2 55
 # C0 2C 54 2F 37 83 65 EA 89 39 11 F5 5E 55 F2 3C
@@ -2671,39 +2543,6 @@ EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO
 fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi
 AmvZWg==
 -----END CERTIFICATE-----
-# "I.CA - Qualified Certification Authority, 09/2009"
-# C0 C0 5A 8D 8D A5 5E AF 27 AA 9B 91 0B 0A 6E F0
-# D8 BB DE D3 46 92 8D B8 72 E1 82 C2 07 3E 98 02
------BEGIN CERTIFICATE-----
-MIIFHjCCBAagAwIBAgIEAKA3oDANBgkqhkiG9w0BAQsFADCBtzELMAkGA1UEBhMC
-Q1oxOjA4BgNVBAMMMUkuQ0EgLSBRdWFsaWZpZWQgQ2VydGlmaWNhdGlvbiBBdXRo
-b3JpdHksIDA5LzIwMDkxLTArBgNVBAoMJFBydm7DrSBjZXJ0aWZpa2HEjW7DrSBh
-dXRvcml0YSwgYS5zLjE9MDsGA1UECww0SS5DQSAtIEFjY3JlZGl0ZWQgUHJvdmlk
-ZXIgb2YgQ2VydGlmaWNhdGlvbiBTZXJ2aWNlczAeFw0wOTA5MDEwMDAwMDBaFw0x
-OTA5MDEwMDAwMDBaMIG3MQswCQYDVQQGEwJDWjE6MDgGA1UEAwwxSS5DQSAtIFF1
-YWxpZmllZCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSwgMDkvMjAwOTEtMCsGA1UE
-CgwkUHJ2bsOtIGNlcnRpZmlrYcSNbsOtIGF1dG9yaXRhLCBhLnMuMT0wOwYDVQQL
-DDRJLkNBIC0gQWNjcmVkaXRlZCBQcm92aWRlciBvZiBDZXJ0aWZpY2F0aW9uIFNl
-cnZpY2VzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtTaEy0KC8M9l
-4lSaWHMs4+sVV1LwzyJYiIQNeCrv1HHm/YpGIdY/Z640ceankjQvIX7m23BK4OSC
-6KO8kZYA3zopOz6GFCOKV2PvLukbc+c2imF6kLHEv6qNA8WxhPbR3xKwlHDwB2yh
-Wzo7V3QVgDRG83sugqQntKYC3LnlTGbJpNP+Az72gpO9AHUn/IBhFk4ksc8lYS2L
-9GCy9CsmdKSBP78p9w8Lx7vDLqkDgt1/zBrcUWmSSb7AE/BPEeMryQV1IdI6nlGn
-BhWkXOYf6GSdayJw86btuxC7viDKNrbp44HjQRaSxnp6O3eto1x4DfiYdw/YbJFe
-7EjkxSQBywIDAQABo4IBLjCCASowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E
-BAMCAQYwgecGA1UdIASB3zCB3DCB2QYEVR0gADCB0DCBzQYIKwYBBQUHAgIwgcAa
-gb1UZW50byBjZXJ0aWZpa2F0IGplIHZ5ZGFuIGpha28ga3ZhbGlmaWtvdmFueSBz
-eXN0ZW1vdnkgY2VydGlmaWthdCBwb2RsZSB6YWtvbmEgYy4gMjI3LzIwMDAgU2Iu
-IHYgcGxhdG5lbSB6bmVuaS9UaGlzIGlzIHF1YWxpZmllZCBzeXN0ZW0gY2VydGlm
-aWNhdGUgYWNjb3JkaW5nIHRvIEN6ZWNoIEFjdCBOby4gMjI3LzIwMDAgQ29sbC4w
-HQYDVR0OBBYEFHnL0CPpOmdwkXRP01Hi4CD94Sj7MA0GCSqGSIb3DQEBCwUAA4IB
-AQB9laU214hYaBHPZftbDS/2dIGLWdmdSbj1OZbJ8LIPBMxYjPoEMqzAR74tw96T
-i6aWRa5WdOWaS6I/qibEKFZhJAVXX5mkx2ewGFLJ+0Go+eTxnjLOnhVF2V2s+57b
-m8c8j6/bS6Ij6DspcHEYpfjjh64hE2r0aSpZDjGzKFM6YpqsCJN8qYe2X1qmGMLQ
-wvNdjG+nPzCJOOuUEypIWt555ZDLXqS5F7ZjBjlfyDZjEfS2Es9Idok8alf563Mi
-9/o+Ba46wMYOkk3P1IlU0RqCajdbliioACKDztAqubONU1guZVzV8tuMASVzbJeL
-/GAB7ECTwe1RuKrLYtglMKI9
------END CERTIFICATE-----
 # "IdenTrust Commercial Root CA 1"
 # 5D 56 49 9B E4 D2 E0 8B CF CA D0 8A 3E 38 72 3D
 # 50 50 3B DE 70 69 48 E4 2F 55 60 30 19 E5 28 AE
@@ -4722,123 +4561,6 @@ VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB
 L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG
 jjxDah2nGN59PRbxYvnKkKj9
 -----END CERTIFICATE-----
-# "UTN - DATACorp SGC"
-# 85 FB 2F 91 DD 12 27 5A 01 45 B6 36 53 4F 84 02
-# 4A D6 8B 69 B8 EE 88 68 4F F7 11 37 58 05 B3 48
------BEGIN CERTIFICATE-----
-MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB
-kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
-Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
-dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw
-IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG
-EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD
-VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu
-dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN
-BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6
-E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ
-D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK
-4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq
-lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW
-bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB
-o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT
-MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js
-LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr
-BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB
-AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft
-Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj
-j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH
-KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv
-2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3
-mfnGV/TJVTl4uix5yaaIK/QI
------END CERTIFICATE-----
-# "UTN-USERFirst-Client Authentication and Email"
-# 43 F2 57 41 2D 44 0D 62 74 76 97 4F 87 7D A8 F1
-# FC 24 44 56 5A 36 7A E6 0E DD C2 7A 41 25 31 AE
------BEGIN CERTIFICATE-----
-MIIEojCCA4qgAwIBAgIQRL4Mi1AAJLQR0zYlJWfJiTANBgkqhkiG9w0BAQUFADCB
-rjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
-Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
-dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xNjA0BgNVBAMTLVVUTi1VU0VSRmlyc3Qt
-Q2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBFbWFpbDAeFw05OTA3MDkxNzI4NTBa
-Fw0xOTA3MDkxNzM2NThaMIGuMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVVQxFzAV
-BgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5l
-dHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNvbTE2MDQGA1UE
-AxMtVVROLVVTRVJGaXJzdC1DbGllbnQgQXV0aGVudGljYXRpb24gYW5kIEVtYWls
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsjmFpPJ9q0E7YkY3rs3B
-YHW8OWX5ShpHornMSMxqmNVNNRm5pELlzkniii8efNIxB8dOtINknS4p1aJkxIW9
-hVE1eaROaJB7HHqkkqgX8pgV8pPMyaQylbsMTzC9mKALi+VuG6JG+ni8om+rWV6l
-L8/K2m2qL+usobNqqrcuZzWLeeEeaYji5kbNoKXqvgvOdjp6Dpvq/NonWz1zHyLm
-SGHGTPNpsaguG7bUMSAsvIKKjqQOpdeJQ/wWWq8dcdcRWdq6hw2v+vPhwvCkxWeM
-1tZUOt4KpLoDd7NlyP0e03RiqhjKaJMeoYV+9Udly/hNVyh00jT/MLbu9mIwFIws
-6wIDAQABo4G5MIG2MAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
-DgQWBBSJgmd9xJ0mcABLtFBIfN49rgRufTBYBgNVHR8EUTBPME2gS6BJhkdodHRw
-Oi8vY3JsLnVzZXJ0cnVzdC5jb20vVVROLVVTRVJGaXJzdC1DbGllbnRBdXRoZW50
-aWNhdGlvbmFuZEVtYWlsLmNybDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUH
-AwQwDQYJKoZIhvcNAQEFBQADggEBALFtYV2mGn98q0rkMPxTbyUkxsrt4jFcKw7u
-7mFVbwQ+zznexRtJlOTrIEy05p5QLnLZjfWqo7NK2lYcYJeA3IKirUq9iiv/Cwm0
-xtcgBEXkzYABurorbs6q15L+5K/r9CYdFip/bDCVNy8zEqx/3cfREYxRmLLQo5HQ
-rfafnoOTHh1CuEava2bwm3/q4wMC5QJRwarVNZ1yQAOJujEdxRBoUp7fooXFXAim
-eOZTT7Hot9MUnpOmw2TjrH5xzbyf6QMbzPvprDHBr3wVdAKZw7JHpsIyYdfHb0gk
-USeh1YdV8nuPmD0Wnu51tvjQjvLzxq4oW6fw8zYX/MMF08oDSlQ=
------END CERTIFICATE-----
-# "UTN-USERFirst-Hardware"
-# 6E A5 47 41 D0 04 66 7E ED 1B 48 16 63 4A A3 A7
-# 9E 6E 4B 96 95 0F 82 79 DA FC 8D 9B D8 81 21 37
------BEGIN CERTIFICATE-----
-MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB
-lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
-Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
-dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt
-SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG
-A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe
-MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v
-d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh
-cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn
-0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ
-M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a
-MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd
-oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI
-DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy
-oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD
-VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0
-dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy
-bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF
-BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM
-//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli
-CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE
-CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t
-3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS
-KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA==
------END CERTIFICATE-----
-# "UTN-USERFirst-Object"
-# 6F FF 78 E4 00 A7 0C 11 01 1C D8 59 77 C4 59 FB
-# 5A F9 6A 3D F0 54 08 20 D0 F4 B8 60 78 75 E5 8F
------BEGIN CERTIFICATE-----
-MIIEZjCCA06gAwIBAgIQRL4Mi1AAJLQR0zYt4LNfGzANBgkqhkiG9w0BAQUFADCB
-lTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
-Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
-dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHTAbBgNVBAMTFFVUTi1VU0VSRmlyc3Qt
-T2JqZWN0MB4XDTk5MDcwOTE4MzEyMFoXDTE5MDcwOTE4NDAzNlowgZUxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtlIENpdHkxHjAc
-BgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8GA1UECxMYaHR0cDovL3d3
-dy51c2VydHJ1c3QuY29tMR0wGwYDVQQDExRVVE4tVVNFUkZpcnN0LU9iamVjdDCC
-ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6qgT+jo2F4qjEAVZURnicP
-HxzfOpuCaDDASmEd8S8O+r5596Uj71VRloTN2+O5bj4x2AogZ8f02b+U60cEPgLO
-KqJdhwQJ9jCdGIqXsqoc/EHSoTbL+z2RuufZcDX65OeQw5ujm9M89RKZd7G3CeBo
-5hy485RjiGpq/gt2yb70IuRnuasaXnfBhQfdDWy/7gbHd2pBnqcP1/vulBe3/IW+
-pKvEHDHd17bR5PDv3xaPslKT16HUiaEHLr/hARJCHhrh2JU022R5KP+6LhHC5ehb
-kkj7RwvCbNqtMoNB86XlQXD9ZZBt+vpRxPm9lisZBCzTbafc8H9vg2XiaquHhnUC
-AwEAAaOBrzCBrDALBgNVHQ8EBAMCAcYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
-FgQU2u1kdBScFDyr3ZmpvVsoTYs8ydgwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDov
-L2NybC51c2VydHJ1c3QuY29tL1VUTi1VU0VSRmlyc3QtT2JqZWN0LmNybDApBgNV
-HSUEIjAgBggrBgEFBQcDAwYIKwYBBQUHAwgGCisGAQQBgjcKAwQwDQYJKoZIhvcN
-AQEFBQADggEBAAgfUrE3RHjb/c652pWWmKpVZIC1WkDdIaXFwfNfLEzIR1pp6ujw
-NTX00CXzyKakh0q9G7FzCL3Uw8q2NbtZhncxzaeAFK4T7/yxSPlrJSUtUbYsbUXB
-mMiKVl0+7kNOPmsnjtA6S4ULX9Ptaqd1y9Fahy85dRNacrACgZ++8A+EVCBibGnU
-4U3GDZlDAQ0Slox4nb9QorFEqmrPF3rPbw/U+CRVX/A0FklmPlBGyWNxODFiuGK5
-81OtbLUrohKqGU8J2l7nk8aOFAj+8DCAGKCGhU3IfdeLA/5u1fedFqySLKAj5ZyR
-Uh+U3xeUc8OzwcFxBSAAeL0TUh2oPs0AH8g=
------END CERTIFICATE-----
 # "VeriSign Class 1 Public Primary Certification Authority - G3"
 # CB B5 AF 18 5E 94 2A 24 02 F9 EA CB C0 ED 5B B8
 # 76 EE A3 C1 22 36 23 D0 04 47 E4 F3 BA 55 4B 65

diff --git a/src/crypto/x509/x509.go b/src/crypto/x509/x509.go
index 60dfac741b8774017dd967abb868c9ba99a8a44a..8c0299b11e9b5ad606591c38304cc8f2c3684437 100644 (file)
--- a/src/crypto/x509/x509.go
+++ b/src/crypto/x509/x509.go
@@ -1997,49 +1997,6 @@ func buildCSRExtensions(template *CertificateRequest) ([]pkix.Extension, error)
                })
        }
 
-       if template.KeyUsage != 0 &&
-               !oidInExtensions(oidExtensionKeyUsage, template.ExtraExtensions) {
-               ext, err := marshalKeyUsage(template.KeyUsage)
-               if err != nil {
-                       return nil, err
-               }
-               ret = append(ret, ext)
-       }
-
-       if (len(template.ExtKeyUsage) > 0 || len(template.UnknownExtKeyUsage) > 0) &&
-               !oidInExtensions(oidExtensionExtendedKeyUsage, template.ExtraExtensions) {
-               ext, err := marshalExtKeyUsage(template.ExtKeyUsage, template.UnknownExtKeyUsage)
-               if err != nil {
-                       return nil, err
-               }
-               ret = append(ret, ext)
-       }
-
-       if template.BasicConstraintsValid && !oidInExtensions(oidExtensionBasicConstraints, template.ExtraExtensions) {
-               ext, err := marshalBasicConstraints(template.IsCA, template.MaxPathLen, template.MaxPathLenZero)
-               if err != nil {
-                       return nil, err
-               }
-               ret = append(ret, ext)
-       }
-
-       if len(template.SubjectKeyId) > 0 && !oidInExtensions(oidExtensionSubjectKeyId, template.ExtraExtensions) {
-               skidBytes, err := asn1.Marshal(template.SubjectKeyId)
-               if err != nil {
-                       return nil, err
-               }
-               ret = append(ret, pkix.Extension{Id: oidExtensionSubjectKeyId, Value: skidBytes})
-       }
-
-       if len(template.PolicyIdentifiers) > 0 &&
-               !oidInExtensions(oidExtensionCertificatePolicies, template.ExtraExtensions) {
-               ext, err := marshalCertificatePolicies(template.PolicyIdentifiers)
-               if err != nil {
-                       return nil, err
-               }
-               ret = append(ret, ext)
-       }
-
        return append(ret, template.ExtraExtensions...), nil
 }
 
@@ -2405,7 +2362,6 @@ type CertificateRequest struct {
        Version            int
        Signature          []byte
        SignatureAlgorithm SignatureAlgorithm
-       KeyUsage           KeyUsage
 
        PublicKeyAlgorithm PublicKeyAlgorithm
        PublicKey          interface{}
@@ -2438,37 +2394,6 @@ type CertificateRequest struct {
        EmailAddresses []string
        IPAddresses    []net.IP
        URIs           []*url.URL
-
-       ExtKeyUsage        []ExtKeyUsage           // Sequence of extended key usages.
-       UnknownExtKeyUsage []asn1.ObjectIdentifier // Encountered extended key usages unknown to this package.
-
-       // BasicConstraintsValid indicates whether IsCA, MaxPathLen,
-       // and MaxPathLenZero are valid.
-       BasicConstraintsValid bool
-       IsCA                  bool
-
-       // MaxPathLen and MaxPathLenZero indicate the presence and
-       // value of the BasicConstraints' "pathLenConstraint".
-       //
-       // When parsing a certificate, a positive non-zero MaxPathLen
-       // means that the field was specified, -1 means it was unset,
-       // and MaxPathLenZero being true mean that the field was
-       // explicitly set to zero. The case of MaxPathLen==0 with MaxPathLenZero==false
-       // should be treated equivalent to -1 (unset).
-       //
-       // When generating a certificate, an unset pathLenConstraint
-       // can be requested with either MaxPathLen == -1 or using the
-       // zero value for both MaxPathLen and MaxPathLenZero.
-       MaxPathLen int
-       // MaxPathLenZero indicates that BasicConstraintsValid==true
-       // and MaxPathLen==0 should be interpreted as an actual
-       // maximum path length of zero. Otherwise, that combination is
-       // interpreted as MaxPathLen not being set.
-       MaxPathLenZero bool
-
-       SubjectKeyId []byte
-
-       PolicyIdentifiers []asn1.ObjectIdentifier
 }
 
 // These structures reflect the ASN.1 structure of X.509 certificate
@@ -2566,15 +2491,6 @@ func parseCSRExtensions(rawAttributes []asn1.RawValue) ([]pkix.Extension, error)
 //  - EmailAddresses
 //  - IPAddresses
 //  - URIs
-//  - KeyUsage
-//  - ExtKeyUsage
-//  - UnknownExtKeyUsage
-//  - BasicConstraintsValid
-//  - IsCA
-//  - MaxPathLen
-//  - MaxPathLenZero
-//  - SubjectKeyId
-//  - PolicyIdentifiers
 //  - ExtraExtensions
 //  - Attributes (deprecated)
 //
@@ -2799,30 +2715,6 @@ func parseCertificateRequest(in *certificateRequest) (*CertificateRequest, error
                        if err != nil {
                                return nil, err
                        }
-               case extension.Id.Equal(oidExtensionKeyUsage):
-                       out.KeyUsage, err = parseKeyUsageExtension(extension.Value)
-               case extension.Id.Equal(oidExtensionExtendedKeyUsage):
-                       out.ExtKeyUsage, out.UnknownExtKeyUsage, err = parseExtKeyUsageExtension(extension.Value)
-                       if err != nil {
-                               return nil, err
-                       }
-               case extension.Id.Equal(oidExtensionBasicConstraints):
-                       out.IsCA, out.MaxPathLen, err = parseBasicConstraintsExtension(extension.Value)
-                       if err != nil {
-                               return nil, err
-                       }
-                       out.BasicConstraintsValid = true
-                       out.MaxPathLenZero = out.MaxPathLen == 0
-               case extension.Id.Equal(oidExtensionSubjectKeyId):
-                       out.SubjectKeyId, err = parseSubjectKeyIdExtension(extension.Value)
-                       if err != nil {
-                               return nil, err
-                       }
-               case extension.Id.Equal(oidExtensionCertificatePolicies):
-                       out.PolicyIdentifiers, err = parseCertificatePoliciesExtension(extension.Value)
-                       if err != nil {
-                               return nil, err
-                       }
                }
        }
 

diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go
index 65d105db3441607d5b4c392b388b79a4599f4631..51dda16815b0bb13d7bb6eb9c817ef203edd1c75 100644 (file)
--- a/src/crypto/x509/x509_test.go
+++ b/src/crypto/x509/x509_test.go
@@ -2964,44 +2964,34 @@ func certPoolEqual(a, b *CertPool) bool {
 }
 
 func TestCertificateRequestRoundtripFields(t *testing.T) {
+       urlA, err := url.Parse("https://example.com/_")
+       if err != nil {
+               t.Fatal(err)
+       }
+       urlB, err := url.Parse("https://example.org/_")
+       if err != nil {
+               t.Fatal(err)
+       }
        in := &CertificateRequest{
-               KeyUsage:              KeyUsageCertSign,
-               ExtKeyUsage:           []ExtKeyUsage{ExtKeyUsageAny},
-               UnknownExtKeyUsage:    []asn1.ObjectIdentifier{{1, 2, 3}},
-               BasicConstraintsValid: true,
-               IsCA:                  true,
-               MaxPathLen:            0,
-               MaxPathLenZero:        true,
-               SubjectKeyId:          []byte{1, 2, 3},
-               PolicyIdentifiers:     []asn1.ObjectIdentifier{{1, 2, 3}},
+               DNSNames:       []string{"example.com", "example.org"},
+               EmailAddresses: []string{"a@example.com", "b@example.com"},
+               IPAddresses:    []net.IP{net.IPv4(192, 0, 2, 0), net.IPv6loopback},
+               URIs:           []*url.URL{urlA, urlB},
        }
        out := marshalAndParseCSR(t, in)
 
-       if in.KeyUsage != out.KeyUsage {
-               t.Fatalf("Unexpected KeyUsage: got %v, want %v", out.KeyUsage, in.KeyUsage)
-       }
-       if !reflect.DeepEqual(in.ExtKeyUsage, out.ExtKeyUsage) {
-               t.Fatalf("Unexpected ExtKeyUsage: got %v, want %v", out.ExtKeyUsage, in.ExtKeyUsage)
-       }
-       if !reflect.DeepEqual(in.UnknownExtKeyUsage, out.UnknownExtKeyUsage) {
-               t.Fatalf("Unexpected UnknownExtKeyUsage: got %v, want %v", out.UnknownExtKeyUsage, in.UnknownExtKeyUsage)
-       }
-       if in.BasicConstraintsValid != out.BasicConstraintsValid {
-               t.Fatalf("Unexpected BasicConstraintsValid: got %v, want %v", out.BasicConstraintsValid, in.BasicConstraintsValid)
-       }
-       if in.IsCA != out.IsCA {
-               t.Fatalf("Unexpected IsCA: got %v, want %v", out.IsCA, in.IsCA)
-       }
-       if in.MaxPathLen != out.MaxPathLen {
-               t.Fatalf("Unexpected MaxPathLen: got %v, want %v", out.MaxPathLen, in.MaxPathLen)
+       if !reflect.DeepEqual(in.DNSNames, out.DNSNames) {
+               t.Fatalf("Unexpected DNSNames: got %v, want %v", out.DNSNames, in.DNSNames)
        }
-       if in.MaxPathLenZero != out.MaxPathLenZero {
-               t.Fatalf("Unexpected MaxPathLenZero: got %v, want %v", out.MaxPathLenZero, in.MaxPathLenZero)
+       if !reflect.DeepEqual(in.EmailAddresses, out.EmailAddresses) {
+               t.Fatalf("Unexpected EmailAddresses: got %v, want %v", out.EmailAddresses, in.EmailAddresses)
        }
-       if !reflect.DeepEqual(in.SubjectKeyId, out.SubjectKeyId) {
-               t.Fatalf("Unexpected SubjectKeyId: got %v, want %v", out.SubjectKeyId, in.SubjectKeyId)
+       if len(in.IPAddresses) != len(out.IPAddresses) ||
+               !in.IPAddresses[0].Equal(out.IPAddresses[0]) ||
+               !in.IPAddresses[1].Equal(out.IPAddresses[1]) {
+               t.Fatalf("Unexpected IPAddresses: got %v, want %v", out.IPAddresses, in.IPAddresses)
        }
-       if !reflect.DeepEqual(in.PolicyIdentifiers, out.PolicyIdentifiers) {
-               t.Fatalf("Unexpected PolicyIdentifiers: got %v, want %v", out.PolicyIdentifiers, in.PolicyIdentifiers)
+       if !reflect.DeepEqual(in.URIs, out.URIs) {
+               t.Fatalf("Unexpected URIs: got %v, want %v", out.URIs, in.URIs)
        }
 }

diff --git a/src/debug/dwarf/dwarf5ranges_test.go b/src/debug/dwarf/dwarf5ranges_test.go
index 0ff1a55bc9b9ca47769dfc73bc542a38733580a4..8bc50bcab699a3167b2ecc0127f820a9965051e1 100644 (file)
--- a/src/debug/dwarf/dwarf5ranges_test.go
+++ b/src/debug/dwarf/dwarf5ranges_test.go
@@ -22,7 +22,12 @@ func TestDwarf5Ranges(t *testing.T) {
        if err := d.AddSection(".debug_rnglists", rngLists); err != nil {
                t.Fatal(err)
        }
-       ret, err := d.dwarf5Ranges(nil, 0x5fbd, 0xc, [][2]uint64{})
+       u := &unit{
+               asize: 8,
+               vers:  5,
+               is64:  true,
+       }
+       ret, err := d.dwarf5Ranges(u, nil, 0x5fbd, 0xc, [][2]uint64{})
        if err != nil {
                t.Fatalf("could not read rnglist: %v", err)
        }

diff --git a/src/debug/dwarf/entry.go b/src/debug/dwarf/entry.go
index bc05d7ef318a59b04e5daf76dd0a0cb252772cf2..3fc73b8ead29dbe0ab50fa96635d0d939a20b92a 100644 (file)
--- a/src/debug/dwarf/entry.go
+++ b/src/debug/dwarf/entry.go
@@ -423,6 +423,47 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
                Children: a.children,
                Field:    make([]Field, len(a.field)),
        }
+
+       // If we are currently parsing the compilation unit,
+       // we can't evaluate Addrx or Strx until we've seen the
+       // relevant base entry.
+       type delayed struct {
+               idx int
+               off uint64
+               fmt format
+       }
+       var delay []delayed
+
+       resolveStrx := func(strBase, off uint64) string {
+               off += strBase
+               if uint64(int(off)) != off {
+                       b.error("DW_FORM_strx offset out of range")
+               }
+
+               b1 := makeBuf(b.dwarf, b.format, "str_offsets", 0, b.dwarf.strOffsets)
+               b1.skip(int(off))
+               is64, _ := b.format.dwarf64()
+               if is64 {
+                       off = b1.uint64()
+               } else {
+                       off = uint64(b1.uint32())
+               }
+               if b1.err != nil {
+                       b.err = b1.err
+                       return ""
+               }
+               if uint64(int(off)) != off {
+                       b.error("DW_FORM_strx indirect offset out of range")
+               }
+               b1 = makeBuf(b.dwarf, b.format, "str", 0, b.dwarf.str)
+               b1.skip(int(off))
+               val := b1.string()
+               if b1.err != nil {
+                       b.err = b1.err
+               }
+               return val
+       }
+
        for i := range e.Field {
                e.Field[i].Attr = a.field[i].attr
                e.Field[i].Class = a.field[i].class
@@ -467,10 +508,13 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
                        var addrBase int64
                        if cu != nil {
                                addrBase, _ = cu.Val(AttrAddrBase).(int64)
+                       } else if a.tag == TagCompileUnit {
+                               delay = append(delay, delayed{i, off, formAddrx})
+                               break
                        }
 
                        var err error
-                       val, err = b.dwarf.debugAddr(uint64(addrBase), off)
+                       val, err = b.dwarf.debugAddr(b.format, uint64(addrBase), off)
                        if err != nil {
                                if b.err == nil {
                                        b.err = err
@@ -611,38 +655,16 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
                        // compilation unit. This won't work if the
                        // program uses Reader.Seek to skip over the
                        // unit. Not much we can do about that.
+                       var strBase int64
                        if cu != nil {
-                               cuOff, ok := cu.Val(AttrStrOffsetsBase).(int64)
-                               if ok {
-                                       off += uint64(cuOff)
-                               }
+                               strBase, _ = cu.Val(AttrStrOffsetsBase).(int64)
+                       } else if a.tag == TagCompileUnit {
+                               delay = append(delay, delayed{i, off, formStrx})
+                               break
                        }
 
-                       if uint64(int(off)) != off {
-                               b.error("DW_FORM_strx offset out of range")
-                       }
+                       val = resolveStrx(uint64(strBase), off)
 
-                       b1 := makeBuf(b.dwarf, b.format, "str_offsets", 0, b.dwarf.strOffsets)
-                       b1.skip(int(off))
-                       if is64 {
-                               off = b1.uint64()
-                       } else {
-                               off = uint64(b1.uint32())
-                       }
-                       if b1.err != nil {
-                               b.err = b1.err
-                               return nil
-                       }
-                       if uint64(int(off)) != off {
-                               b.error("DW_FORM_strx indirect offset out of range")
-                       }
-                       b1 = makeBuf(b.dwarf, b.format, "str", 0, b.dwarf.str)
-                       b1.skip(int(off))
-                       val = b1.string()
-                       if b1.err != nil {
-                               b.err = b1.err
-                               return nil
-                       }
                case formStrpSup:
                        is64, known := b.format.dwarf64()
                        if !known {
@@ -689,11 +711,32 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
                case formRnglistx:
                        val = b.uint()
                }
+
                e.Field[i].Val = val
        }
        if b.err != nil {
                return nil
        }
+
+       for _, del := range delay {
+               switch del.fmt {
+               case formAddrx:
+                       addrBase, _ := e.Val(AttrAddrBase).(int64)
+                       val, err := b.dwarf.debugAddr(b.format, uint64(addrBase), del.off)
+                       if err != nil {
+                               b.err = err
+                               return nil
+                       }
+                       e.Field[del.idx].Val = val
+               case formStrx:
+                       strBase, _ := e.Val(AttrStrOffsetsBase).(int64)
+                       e.Field[del.idx].Val = resolveStrx(uint64(strBase), del.off)
+                       if b.err != nil {
+                               return nil
+                       }
+               }
+       }
+
        return e
 }
 
@@ -877,6 +920,7 @@ func (r *Reader) SeekPC(pc uint64) (*Entry, error) {
                r.err = nil
                r.lastChildren = false
                r.unit = unit
+               r.cu = nil
                u := &r.d.unit[unit]
                r.b = makeBuf(r.d, u, "info", u.off, u.data)
                e, err := r.Next()
@@ -946,7 +990,7 @@ func (d *Data) Ranges(e *Entry) ([][2]uint64, error) {
                        if err != nil {
                                return nil, err
                        }
-                       return d.dwarf5Ranges(cu, base, ranges, ret)
+                       return d.dwarf5Ranges(u, cu, base, ranges, ret)
 
                case ClassRngList:
                        // TODO: support DW_FORM_rnglistx
@@ -1023,13 +1067,13 @@ func (d *Data) dwarf2Ranges(u *unit, base uint64, ranges int64, ret [][2]uint64)
 
 // dwarf5Ranges interpets a debug_rnglists sequence, see DWARFv5 section
 // 2.17.3 (page 53).
-func (d *Data) dwarf5Ranges(cu *Entry, base uint64, ranges int64, ret [][2]uint64) ([][2]uint64, error) {
+func (d *Data) dwarf5Ranges(u *unit, cu *Entry, base uint64, ranges int64, ret [][2]uint64) ([][2]uint64, error) {
        var addrBase int64
        if cu != nil {
                addrBase, _ = cu.Val(AttrAddrBase).(int64)
        }
 
-       buf := makeBuf(d, d.rngLists, "rnglists", 0, d.rngLists.data)
+       buf := makeBuf(d, u, "rnglists", 0, d.rngLists)
        buf.skip(int(ranges))
        for {
                opcode := buf.uint8()
@@ -1043,7 +1087,7 @@ func (d *Data) dwarf5Ranges(cu *Entry, base uint64, ranges int64, ret [][2]uint6
                case rleBaseAddressx:
                        baseIdx := buf.uint()
                        var err error
-                       base, err = d.debugAddr(uint64(addrBase), baseIdx)
+                       base, err = d.debugAddr(u, uint64(addrBase), baseIdx)
                        if err != nil {
                                return nil, err
                        }
@@ -1052,11 +1096,11 @@ func (d *Data) dwarf5Ranges(cu *Entry, base uint64, ranges int64, ret [][2]uint6
                        startIdx := buf.uint()
                        endIdx := buf.uint()
 
-                       start, err := d.debugAddr(uint64(addrBase), startIdx)
+                       start, err := d.debugAddr(u, uint64(addrBase), startIdx)
                        if err != nil {
                                return nil, err
                        }
-                       end, err := d.debugAddr(uint64(addrBase), endIdx)
+                       end, err := d.debugAddr(u, uint64(addrBase), endIdx)
                        if err != nil {
                                return nil, err
                        }
@@ -1065,7 +1109,7 @@ func (d *Data) dwarf5Ranges(cu *Entry, base uint64, ranges int64, ret [][2]uint6
                case rleStartxLength:
                        startIdx := buf.uint()
                        len := buf.uint()
-                       start, err := d.debugAddr(uint64(addrBase), startIdx)
+                       start, err := d.debugAddr(u, uint64(addrBase), startIdx)
                        if err != nil {
                                return nil, err
                        }
@@ -1093,19 +1137,18 @@ func (d *Data) dwarf5Ranges(cu *Entry, base uint64, ranges int64, ret [][2]uint6
 }
 
 // debugAddr returns the address at idx in debug_addr
-func (d *Data) debugAddr(addrBase, idx uint64) (uint64, error) {
-       off := idx*uint64(d.addr.addrsize()) + addrBase
+func (d *Data) debugAddr(format dataFormat, addrBase, idx uint64) (uint64, error) {
+       off := idx*uint64(format.addrsize()) + addrBase
 
        if uint64(int(off)) != off {
                return 0, errors.New("offset out of range")
        }
 
-       b := makeBuf(d, d.addr, "addr", 0, d.addr.data)
+       b := makeBuf(d, format, "addr", 0, d.addr)
        b.skip(int(off))
        val := b.addr()
        if b.err != nil {
                return 0, b.err
        }
-
        return val, nil
 }

diff --git a/src/debug/dwarf/entry_test.go b/src/debug/dwarf/entry_test.go
index 2e6ee048aa526185655f4bf46679454898d150d4..b54f8b4f8daa0405ded856afa331b37e9cbdc76f 100644 (file)
--- a/src/debug/dwarf/entry_test.go
+++ b/src/debug/dwarf/entry_test.go
@@ -55,6 +55,20 @@ func TestReaderSeek(t *testing.T) {
                {0x400611, nil},
        }
        testRanges(t, "testdata/line-gcc.elf", want)
+
+       want = []wantRange{
+               {0x401122, [][2]uint64{{0x401122, 0x401166}}},
+               {0x401165, [][2]uint64{{0x401122, 0x401166}}},
+               {0x401166, [][2]uint64{{0x401166, 0x401179}}},
+       }
+       testRanges(t, "testdata/line-gcc-dwarf5.elf", want)
+
+       want = []wantRange{
+               {0x401130, [][2]uint64{{0x401130, 0x40117e}}},
+               {0x40117d, [][2]uint64{{0x401130, 0x40117e}}},
+               {0x40117e, nil},
+       }
+       testRanges(t, "testdata/line-clang-dwarf5.elf", want)
 }
 
 func TestRangesSection(t *testing.T) {
@@ -97,44 +111,72 @@ func testRanges(t *testing.T, name string, want []wantRange) {
 }
 
 func TestReaderRanges(t *testing.T) {
-       d := elfData(t, "testdata/line-gcc.elf")
-
-       subprograms := []struct {
+       type subprograms []struct {
                name   string
                ranges [][2]uint64
+       }
+       tests := []struct {
+               filename    string
+               subprograms subprograms
        }{
-               {"f1", [][2]uint64{{0x40059d, 0x4005e7}}},
-               {"main", [][2]uint64{{0x4005e7, 0x400601}}},
-               {"f2", [][2]uint64{{0x400601, 0x400611}}},
+               {
+                       "testdata/line-gcc.elf",
+                       subprograms{
+                               {"f1", [][2]uint64{{0x40059d, 0x4005e7}}},
+                               {"main", [][2]uint64{{0x4005e7, 0x400601}}},
+                               {"f2", [][2]uint64{{0x400601, 0x400611}}},
+                       },
+               },
+               {
+                       "testdata/line-gcc-dwarf5.elf",
+                       subprograms{
+                               {"main", [][2]uint64{{0x401147, 0x401166}}},
+                               {"f1", [][2]uint64{{0x401122, 0x401147}}},
+                               {"f2", [][2]uint64{{0x401166, 0x401179}}},
+                       },
+               },
+               {
+                       "testdata/line-clang-dwarf5.elf",
+                       subprograms{
+                               {"main", [][2]uint64{{0x401130, 0x401144}}},
+                               {"f1", [][2]uint64{{0x401150, 0x40117e}}},
+                               {"f2", [][2]uint64{{0x401180, 0x401197}}},
+                       },
+               },
        }
 
-       r := d.Reader()
-       i := 0
-       for entry, err := r.Next(); entry != nil && err == nil; entry, err = r.Next() {
-               if entry.Tag != TagSubprogram {
-                       continue
-               }
+       for _, test := range tests {
+               d := elfData(t, test.filename)
+               subprograms := test.subprograms
 
-               if i > len(subprograms) {
-                       t.Fatalf("too many subprograms (expected at most %d)", i)
-               }
+               r := d.Reader()
+               i := 0
+               for entry, err := r.Next(); entry != nil && err == nil; entry, err = r.Next() {
+                       if entry.Tag != TagSubprogram {
+                               continue
+                       }
 
-               if got := entry.Val(AttrName).(string); got != subprograms[i].name {
-                       t.Errorf("subprogram %d name is %s, expected %s", i, got, subprograms[i].name)
-               }
-               ranges, err := d.Ranges(entry)
-               if err != nil {
-                       t.Errorf("subprogram %d: %v", i, err)
-                       continue
-               }
-               if !reflect.DeepEqual(ranges, subprograms[i].ranges) {
-                       t.Errorf("subprogram %d ranges are %x, expected %x", i, ranges, subprograms[i].ranges)
+                       if i > len(subprograms) {
+                               t.Fatalf("%s: too many subprograms (expected at most %d)", test.filename, i)
+                       }
+
+                       if got := entry.Val(AttrName).(string); got != subprograms[i].name {
+                               t.Errorf("%s: subprogram %d name is %s, expected %s", test.filename, i, got, subprograms[i].name)
+                       }
+                       ranges, err := d.Ranges(entry)
+                       if err != nil {
+                               t.Errorf("%s: subprogram %d: %v", test.filename, i, err)
+                               continue
+                       }
+                       if !reflect.DeepEqual(ranges, subprograms[i].ranges) {
+                               t.Errorf("%s: subprogram %d ranges are %x, expected %x", test.filename, i, ranges, subprograms[i].ranges)
+                       }
+                       i++
                }
-               i++
-       }
 
-       if i < len(subprograms) {
-               t.Errorf("saw only %d subprograms, expected %d", i, len(subprograms))
+               if i < len(subprograms) {
+                       t.Errorf("%s: saw only %d subprograms, expected %d", test.filename, i, len(subprograms))
+               }
        }
 }
 

diff --git a/src/debug/dwarf/open.go b/src/debug/dwarf/open.go
index 617b8c56dd1f02365c5fc3f4c944eff0b861993c..e94103a1d7a6cc349a9ffef3237afb2c93092f81 100644 (file)
--- a/src/debug/dwarf/open.go
+++ b/src/debug/dwarf/open.go
@@ -26,10 +26,10 @@ type Data struct {
        str      []byte
 
        // New sections added in DWARF 5.
-       addr       *debugAddr
+       addr       []byte
        lineStr    []byte
        strOffsets []byte
-       rngLists   *rngLists
+       rngLists   []byte
 
        // parsed data
        abbrevCache map[uint64]abbrevTable
@@ -40,21 +40,6 @@ type Data struct {
        unit        []unit
 }
 
-// rngLists represents the contents of a debug_rnglists section (DWARFv5).
-type rngLists struct {
-       is64  bool
-       asize uint8
-       data  []byte
-       ver   uint16
-}
-
-// debugAddr represents the contents of a debug_addr section (DWARFv5).
-type debugAddr struct {
-       is64  bool
-       asize uint8
-       data  []byte
-}
-
 var errSegmentSelector = errors.New("non-zero segment_selector size not supported")
 
 // New returns a new Data object initialized from the given parameters.
@@ -132,76 +117,14 @@ func (d *Data) AddSection(name string, contents []byte) error {
        var err error
        switch name {
        case ".debug_addr":
-               d.addr, err = d.parseAddrHeader(contents)
+               d.addr = contents
        case ".debug_line_str":
                d.lineStr = contents
        case ".debug_str_offsets":
                d.strOffsets = contents
        case ".debug_rnglists":
-               d.rngLists, err = d.parseRngListsHeader(contents)
+               d.rngLists = contents
        }
        // Just ignore names that we don't yet support.
        return err
 }
-
-// parseRngListsHeader reads the header of a debug_rnglists section, see
-// DWARFv5 section 7.28 (page 242).
-func (d *Data) parseRngListsHeader(bytes []byte) (*rngLists, error) {
-       rngLists := &rngLists{data: bytes}
-
-       buf := makeBuf(d, unknownFormat{}, "rnglists", 0, bytes)
-       _, rngLists.is64 = buf.unitLength()
-
-       rngLists.ver = buf.uint16() // version
-
-       rngLists.asize = buf.uint8()
-       segsize := buf.uint8()
-       if segsize != 0 {
-               return nil, errSegmentSelector
-       }
-
-       // Header fields not read: offset_entry_count, offset table
-
-       return rngLists, nil
-}
-
-func (rngLists *rngLists) version() int {
-       return int(rngLists.ver)
-}
-
-func (rngLists *rngLists) dwarf64() (bool, bool) {
-       return rngLists.is64, true
-}
-
-func (rngLists *rngLists) addrsize() int {
-       return int(rngLists.asize)
-}
-
-// parseAddrHeader reads the header of a debug_addr section, see DWARFv5
-// section 7.27 (page 241).
-func (d *Data) parseAddrHeader(bytes []byte) (*debugAddr, error) {
-       addr := &debugAddr{data: bytes}
-
-       buf := makeBuf(d, unknownFormat{}, "addr", 0, bytes)
-       _, addr.is64 = buf.unitLength()
-
-       addr.asize = buf.uint8()
-       segsize := buf.uint8()
-       if segsize != 0 {
-               return nil, errSegmentSelector
-       }
-
-       return addr, nil
-}
-
-func (addr *debugAddr) version() int {
-       return 5
-}
-
-func (addr *debugAddr) dwarf64() (bool, bool) {
-       return addr.is64, true
-}
-
-func (addr *debugAddr) addrsize() int {
-       return int(addr.asize)
-}

diff --git a/src/debug/dwarf/testdata/line-clang-dwarf5.elf b/src/debug/dwarf/testdata/line-clang-dwarf5.elf
new file mode 100644 (file)
index 0000000..7b80c9c
Binary files /dev/null and b/src/debug/dwarf/testdata/line-clang-dwarf5.elf differ

diff --git a/src/debug/dwarf/testdata/line-gcc-dwarf5.elf b/src/debug/dwarf/testdata/line-gcc-dwarf5.elf
new file mode 100644 (file)
index 0000000..34ce17c
Binary files /dev/null and b/src/debug/dwarf/testdata/line-gcc-dwarf5.elf differ

diff --git a/src/debug/pe/file.go b/src/debug/pe/file.go
index 7d763fff19d5005b1bb31ca6189df70329f22055..e50229e5a3676b8c4e30ad61de9ca3c326fc7c6d 100644 (file)
--- a/src/debug/pe/file.go
+++ b/src/debug/pe/file.go
@@ -75,7 +75,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
                var sign [4]byte
                r.ReadAt(sign[:], signoff)
                if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
-                       return nil, fmt.Errorf("Invalid PE COFF file signature of %v.", sign)
+                       return nil, fmt.Errorf("invalid PE file signature: % x", sign)
                }
                base = signoff + 4
        } else {
@@ -86,9 +86,14 @@ func NewFile(r io.ReaderAt) (*File, error) {
                return nil, err
        }
        switch f.FileHeader.Machine {
-       case IMAGE_FILE_MACHINE_UNKNOWN, IMAGE_FILE_MACHINE_ARMNT, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386:
+       case IMAGE_FILE_MACHINE_AMD64,
+               IMAGE_FILE_MACHINE_ARM64,
+               IMAGE_FILE_MACHINE_ARMNT,
+               IMAGE_FILE_MACHINE_I386,
+               IMAGE_FILE_MACHINE_UNKNOWN:
+               // ok
        default:
-               return nil, fmt.Errorf("Unrecognised COFF file header machine value of 0x%x.", f.FileHeader.Machine)
+               return nil, fmt.Errorf("unrecognized PE machine: %#x", f.FileHeader.Machine)
        }
 
        var err error
@@ -112,7 +117,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
        // Seek past file header.
        _, err = sr.Seek(base+int64(binary.Size(f.FileHeader)), seekStart)
        if err != nil {
-               return nil, fmt.Errorf("failure to seek past the file header: %v", err)
+               return nil, err
        }
 
        // Read optional header.
@@ -309,7 +314,7 @@ func (f *File) ImportedSymbols() ([]string, error) {
                return nil, nil
        }
 
-       pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64
+       pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64 || f.Machine == IMAGE_FILE_MACHINE_ARM64
 
        // grab the number of data directory entries
        var dd_length uint32

diff --git a/src/embed/embed.go b/src/embed/embed.go
index 29e0adf1a63d1ddf6fbe165f98b3aa059346125d..7f2719d2a78062ab9749f17fe67c9ea8f4d7ab64 100644 (file)
--- a/src/embed/embed.go
+++ b/src/embed/embed.go
@@ -9,18 +9,28 @@
 // files read from the package directory or subdirectories at compile time.
 //
 // For example, here are three ways to embed a file named hello.txt
-// and then print its contents at run time:
+// and then print its contents at run time.
 //
-//     import "embed"
+// Embedding one file into a string:
+//
+//     import _ "embed"
 //
 //     //go:embed hello.txt
 //     var s string
 //     print(s)
 //
+// Embedding one file into a slice of bytes:
+//
+//     import _ "embed"
+//
 //     //go:embed hello.txt
 //     var b []byte
 //     print(string(b))
 //
+// Embedded one or more files into a file system:
+//
+//     import "embed"
+//
 //     //go:embed hello.txt
 //     var f embed.FS
 //     data, _ := f.ReadFile("hello.txt")
@@ -34,8 +44,8 @@
 // The directive must immediately precede a line containing the declaration of a single variable.
 // Only blank lines and ‘//’ line comments are permitted between the directive and the declaration.
 //
-// The variable must be of type string, []byte, or FS exactly. Named types or type aliases
-// derived from those types are not allowed.
+// The type of the variable must be a string type, or a slice of a byte type,
+// or FS (or an alias of FS).
 //
 // For example:
 //
@@ -51,12 +61,15 @@
 // The Go build system will recognize the directives and arrange for the declared variable
 // (in the example above, content) to be populated with the matching files from the file system.
 //
-// The //go:embed directive accepts multiple space-separated patterns for brevity,
-// but it can also be repeated, to avoid very long lines when there are many patterns.
-// The patterns are interpreted relative to the package directory containing the source file.
-// The path separator is a forward slash, even on Windows systems.
-// To allow for naming files with spaces in their names, patterns can be written
-// as Go double-quoted or back-quoted string literals.
+// The //go:embed directive accepts multiple space-separated patterns for
+// brevity, but it can also be repeated, to avoid very long lines when there are
+// many patterns. The patterns are interpreted relative to the package directory
+// containing the source file. The path separator is a forward slash, even on
+// Windows systems. Patterns may not contain ‘.’ or ‘..’ or empty path elements,
+// nor may they begin or end with a slash. To match everything in the current
+// directory, use ‘*’ instead of ‘.’. To allow for naming files with spaces in
+// their names, patterns can be written as Go double-quoted or back-quoted
+// string literals.
 //
 // If a pattern names a directory, all files in the subtree rooted at that directory are
 // embedded (recursively), except that files with names beginning with ‘.’ or ‘_’
@@ -70,16 +83,13 @@
 //
 // The //go:embed directive can be used with both exported and unexported variables,
 // depending on whether the package wants to make the data available to other packages.
-// Similarly, it can be used with both global and function-local variables,
-// depending on what is more convenient in context.
+// It can only be used with global variables at package scope,
+// not with local variables.
 //
 // Patterns must not match files outside the package's module, such as ‘.git/*’ or symbolic links.
 // Matches for empty directories are ignored. After that, each pattern in a //go:embed line
 // must match at least one file or non-empty directory.
 //
-// Patterns must not contain ‘.’ or ‘..’ path elements nor begin with a leading slash.
-// To match everything in the current directory, use ‘*’ instead of ‘.’.
-//
 // If any patterns are invalid or have invalid matches, the build will fail.
 //
 // Strings and Bytes
@@ -133,7 +143,7 @@ import (
 // See the package documentation for more details about initializing an FS.
 type FS struct {
        // The compiler knows the layout of this struct.
-       // See cmd/compile/internal/gc's initEmbed.
+       // See cmd/compile/internal/staticdata's WriteEmbed.
        //
        // The files list is sorted by name but not by simple string comparison.
        // Instead, each file's name takes the form "dir/elem" or "dir/elem/".
@@ -203,7 +213,7 @@ var (
 // It implements fs.FileInfo and fs.DirEntry.
 type file struct {
        // The compiler knows the layout of this struct.
-       // See cmd/compile/internal/gc's initEmbed.
+       // See cmd/compile/internal/staticdata's WriteEmbed.
        name string
        data string
        hash [16]byte // truncated SHA256 hash
@@ -244,6 +254,9 @@ func (f FS) lookup(name string) *file {
        if name == "." {
                return dotFile
        }
+       if f.files == nil {
+               return nil
+       }
 
        // Binary search to find where name would be in the list,
        // and then check if name is at that position.
@@ -261,6 +274,9 @@ func (f FS) lookup(name string) *file {
 
 // readDir returns the list of files corresponding to the directory dir.
 func (f FS) readDir(dir string) []file {
+       if f.files == nil {
+               return nil
+       }
        // Binary search to find where dir starts and ends in the list
        // and then return that slice of the list.
        files := *f.files

diff --git a/src/embed/internal/embedtest/embed_test.go b/src/embed/internal/embedtest/embed_test.go
index c6a7bea7a33125419b5d59cc46e7b3de8fc51a97..43ae5c7e0569c87e3f9b08db68e24501a2c72ca1 100644 (file)
--- a/src/embed/internal/embedtest/embed_test.go
+++ b/src/embed/internal/embedtest/embed_test.go
@@ -73,24 +73,11 @@ func TestGlobal(t *testing.T) {
        testString(t, string(glass), "glass", "I can eat glass and it doesn't hurt me.\n")
 }
 
-func TestLocal(t *testing.T) {
-       //go:embed testdata/k*.txt
-       var local embed.FS
-       testFiles(t, local, "testdata/ken.txt", "If a program is too slow, it must have a loop.\n")
-
-       //go:embed testdata/k*.txt
-       var s string
-       testString(t, s, "local variable s", "If a program is too slow, it must have a loop.\n")
-
-       //go:embed testdata/h*.txt
-       var b []byte
-       testString(t, string(b), "local variable b", "hello, world\n")
-}
+//go:embed testdata
+var testDirAll embed.FS
 
 func TestDir(t *testing.T) {
-       //go:embed testdata
-       var all embed.FS
-
+       all := testDirAll
        testFiles(t, all, "testdata/hello.txt", "hello, world\n")
        testFiles(t, all, "testdata/i/i18n.txt", "internationalization\n")
        testFiles(t, all, "testdata/i/j/k/k8s.txt", "kubernetes\n")
@@ -102,12 +89,15 @@ func TestDir(t *testing.T) {
        testDir(t, all, "testdata/i/j/k", "k8s.txt")
 }
 
-func TestHidden(t *testing.T) {
-       //go:embed testdata
-       var dir embed.FS
+//go:embed testdata
+var testHiddenDir embed.FS
 
-       //go:embed testdata/*
-       var star embed.FS
+//go:embed testdata/*
+var testHiddenStar embed.FS
+
+func TestHidden(t *testing.T) {
+       dir := testHiddenDir
+       star := testHiddenStar
 
        t.Logf("//go:embed testdata")
 
@@ -122,3 +112,20 @@ func TestHidden(t *testing.T) {
        testDir(t, star, "testdata/.hidden",
                "fortune.txt", "more/") // but not .more or _more
 }
+
+func TestUninitialized(t *testing.T) {
+       var uninitialized embed.FS
+       testDir(t, uninitialized, ".")
+       f, err := uninitialized.Open(".")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer f.Close()
+       fi, err := f.Stat()
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !fi.IsDir() {
+               t.Errorf("in uninitialized embed.FS, . is not a directory")
+       }
+}

diff --git a/src/embed/internal/embedtest/embedx_test.go b/src/embed/internal/embedtest/embedx_test.go
index 20d5a28c11df82e7c5ae440cebeb1584581ccac2..27fa11614e9268ea19149cb5c4cabd9faa374407 100644 (file)
--- a/src/embed/internal/embedtest/embedx_test.go
+++ b/src/embed/internal/embedtest/embedx_test.go
@@ -90,17 +90,3 @@ func TestXGlobal(t *testing.T) {
        }
        bbig[0] = old
 }
-
-func TestXLocal(t *testing.T) {
-       //go:embed testdata/*o.txt
-       var local embed.FS
-       testFiles(t, local, "testdata/hello.txt", "hello, world\n")
-
-       //go:embed testdata/k*.txt
-       var s string
-       testString(t, s, "local variable s", "If a program is too slow, it must have a loop.\n")
-
-       //go:embed testdata/h*.txt
-       var b []byte
-       testString(t, string(b), "local variable b", "hello, world\n")
-}

diff --git a/src/encoding/asn1/asn1.go b/src/encoding/asn1/asn1.go
index 7c260b49d90125f209984ce6c5fa1cb30ccd78ca..f9b9cb4930e9890aaf90ab83522d7bf69982509b 100644 (file)
--- a/src/encoding/asn1/asn1.go
+++ b/src/encoding/asn1/asn1.go
@@ -1067,6 +1067,15 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
 //     set         causes a SET, rather than a SEQUENCE type to be expected
 //     tag:x       specifies the ASN.1 tag number; implies ASN.1 CONTEXT SPECIFIC
 //
+// When decoding an ASN.1 value with an IMPLICIT tag into a string field,
+// Unmarshal will default to a PrintableString, which doesn't support
+// characters such as '@' and '&'. To force other encodings, use the following
+// tags:
+//
+//     ia5     causes strings to be unmarshaled as ASN.1 IA5String values
+//     numeric causes strings to be unmarshaled as ASN.1 NumericString values
+//     utf8    causes strings to be unmarshaled as ASN.1 UTF8String values
+//
 // If the type of the first field of a structure is RawContent then the raw
 // ASN1 contents of the struct will be stored in it.
 //

diff --git a/src/go.mod b/src/go.mod
index 4ae14eea5cb48a5a203a481697f19f072da5584d..999dc96787965068b68aec2e26d63add614a72f8 100644 (file)
--- a/src/go.mod
+++ b/src/go.mod
@@ -5,6 +5,6 @@ go 1.16
 require (
        golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
        golang.org/x/net v0.0.0-20201209123823-ac852fbbde11
-       golang.org/x/sys v0.0.0-20201204225414-ed752295db88 // indirect
+       golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
        golang.org/x/text v0.3.4 // indirect
 )

diff --git a/src/go.sum b/src/go.sum
index 5586aa9a4e5cea640a72d7c2e2ff09157d35b7da..6dd5f4eafdb54e372223d03b9990e53e140ef74d 100644 (file)
--- a/src/go.sum
+++ b/src/go.sum
@@ -7,8 +7,8 @@ golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

diff --git a/src/go/build/build.go b/src/go/build/build.go
index 82e481bdc212f85f50939e68900fcc083fb36ddd..217fadf5bd48600402cd310192d735c7731d9037 100644 (file)
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -11,13 +11,13 @@ import (
        "go/ast"
        "go/doc"
        "go/token"
+       exec "internal/execabs"
        "internal/goroot"
        "internal/goversion"
        "io"
        "io/fs"
        "io/ioutil"
        "os"
-       "os/exec"
        pathpkg "path"
        "path/filepath"
        "runtime"
@@ -449,9 +449,12 @@ type Package struct {
        //      //go:embed a* b.c
        // then the list will contain those two strings as separate entries.
        // (See package embed for more details about //go:embed.)
-       EmbedPatterns      []string // patterns from GoFiles, CgoFiles
-       TestEmbedPatterns  []string // patterns from TestGoFiles
-       XTestEmbedPatterns []string // patterns from XTestGoFiles
+       EmbedPatterns        []string                    // patterns from GoFiles, CgoFiles
+       EmbedPatternPos      map[string][]token.Position // line information for EmbedPatterns
+       TestEmbedPatterns    []string                    // patterns from TestGoFiles
+       TestEmbedPatternPos  map[string][]token.Position // line information for TestEmbedPatterns
+       XTestEmbedPatterns   []string                    // patterns from XTestGoFiles
+       XTestEmbedPatternPos map[string][]token.Position // line information for XTestEmbedPatternPos
 }
 
 // IsCommand reports whether the package is considered a
@@ -794,10 +797,12 @@ Found:
        var badGoError error
        var Sfiles []string // files with ".S"(capital S)/.sx(capital s equivalent for case insensitive filesystems)
        var firstFile, firstCommentFile string
-       var embeds, testEmbeds, xTestEmbeds []string
-       imported := make(map[string][]token.Position)
-       testImported := make(map[string][]token.Position)
-       xTestImported := make(map[string][]token.Position)
+       embedPos := make(map[string][]token.Position)
+       testEmbedPos := make(map[string][]token.Position)
+       xTestEmbedPos := make(map[string][]token.Position)
+       importPos := make(map[string][]token.Position)
+       testImportPos := make(map[string][]token.Position)
+       xTestImportPos := make(map[string][]token.Position)
        allTags := make(map[string]bool)
        fset := token.NewFileSet()
        for _, d := range dirs {
@@ -920,31 +925,31 @@ Found:
                        }
                }
 
-               var fileList, embedList *[]string
-               var importMap map[string][]token.Position
+               var fileList *[]string
+               var importMap, embedMap map[string][]token.Position
                switch {
                case isCgo:
                        allTags["cgo"] = true
                        if ctxt.CgoEnabled {
                                fileList = &p.CgoFiles
-                               importMap = imported
-                               embedList = &embeds
+                               importMap = importPos
+                               embedMap = embedPos
                        } else {
-                               // Ignore imports from cgo files if cgo is disabled.
+                               // Ignore imports and embeds from cgo files if cgo is disabled.
                                fileList = &p.IgnoredGoFiles
                        }
                case isXTest:
                        fileList = &p.XTestGoFiles
-                       importMap = xTestImported
-                       embedList = &xTestEmbeds
+                       importMap = xTestImportPos
+                       embedMap = xTestEmbedPos
                case isTest:
                        fileList = &p.TestGoFiles
-                       importMap = testImported
-                       embedList = &testEmbeds
+                       importMap = testImportPos
+                       embedMap = testEmbedPos
                default:
                        fileList = &p.GoFiles
-                       importMap = imported
-                       embedList = &embeds
+                       importMap = importPos
+                       embedMap = embedPos
                }
                *fileList = append(*fileList, name)
                if importMap != nil {
@@ -952,8 +957,10 @@ Found:
                                importMap[imp.path] = append(importMap[imp.path], fset.Position(imp.pos))
                        }
                }
-               if embedList != nil {
-                       *embedList = append(*embedList, info.embeds...)
+               if embedMap != nil {
+                       for _, emb := range info.embeds {
+                               embedMap[emb.pattern] = append(embedMap[emb.pattern], emb.pos)
+                       }
                }
        }
 
@@ -962,13 +969,13 @@ Found:
        }
        sort.Strings(p.AllTags)
 
-       p.EmbedPatterns = uniq(embeds)
-       p.TestEmbedPatterns = uniq(testEmbeds)
-       p.XTestEmbedPatterns = uniq(xTestEmbeds)
+       p.EmbedPatterns, p.EmbedPatternPos = cleanDecls(embedPos)
+       p.TestEmbedPatterns, p.TestEmbedPatternPos = cleanDecls(testEmbedPos)
+       p.XTestEmbedPatterns, p.XTestEmbedPatternPos = cleanDecls(xTestEmbedPos)
 
-       p.Imports, p.ImportPos = cleanImports(imported)
-       p.TestImports, p.TestImportPos = cleanImports(testImported)
-       p.XTestImports, p.XTestImportPos = cleanImports(xTestImported)
+       p.Imports, p.ImportPos = cleanDecls(importPos)
+       p.TestImports, p.TestImportPos = cleanDecls(testImportPos)
+       p.XTestImports, p.XTestImportPos = cleanDecls(xTestImportPos)
 
        // add the .S/.sx files only if we are using cgo
        // (which means gcc will compile them).
@@ -1340,7 +1347,7 @@ type fileInfo struct {
        parsed   *ast.File
        parseErr error
        imports  []fileImport
-       embeds   []string
+       embeds   []fileEmbed
        embedErr error
 }
 
@@ -1350,6 +1357,11 @@ type fileImport struct {
        doc  *ast.CommentGroup
 }
 
+type fileEmbed struct {
+       pattern string
+       pos     token.Position
+}
+
 // matchFile determines whether the file with the given name in the given directory
 // should be included in the package being constructed.
 // If the file should be included, matchFile returns a non-nil *fileInfo (and a nil error).
@@ -1424,7 +1436,7 @@ func (ctxt *Context) matchFile(dir, name string, allTags map[string]bool, binary
        return info, nil
 }
 
-func cleanImports(m map[string][]token.Position) ([]string, map[string][]token.Position) {
+func cleanDecls(m map[string][]token.Position) ([]string, map[string][]token.Position) {
        all := make([]string, 0, len(m))
        for path := range m {
                all = append(all, path)

diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 5a3e9ee71474bd7aae4251e9d02004dd8b3378e9..d8f264cac7c4c5024427ccc64c0d9e80d7770fb6 100644 (file)
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -28,6 +28,7 @@ func TestMatch(t *testing.T) {
        ctxt := Default
        what := "default"
        match := func(tag string, want map[string]bool) {
+               t.Helper()
                m := make(map[string]bool)
                if !ctxt.match(tag, m) {
                        t.Errorf("%s context should match %s, does not", what, tag)
@@ -37,6 +38,7 @@ func TestMatch(t *testing.T) {
                }
        }
        nomatch := func(tag string, want map[string]bool) {
+               t.Helper()
                m := make(map[string]bool)
                if ctxt.match(tag, m) {
                        t.Errorf("%s context should NOT match %s, does", what, tag)
@@ -57,7 +59,6 @@ func TestMatch(t *testing.T) {
        nomatch(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true})
        match(runtime.GOOS+","+runtime.GOARCH+",!bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true})
        nomatch(runtime.GOOS+","+runtime.GOARCH+",bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true})
-       nomatch("!", map[string]bool{})
 }
 
 func TestDotSlashImport(t *testing.T) {

diff --git a/src/go/build/constraint/expr.go b/src/go/build/constraint/expr.go
new file mode 100644 (file)
index 0000000..3b27870
--- /dev/null
+++ b/src/go/build/constraint/expr.go
@@ -0,0 +1,574 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package constraint implements parsing and evaluation of build constraint lines.
+// See https://golang.org/cmd/go/#hdr-Build_constraints for documentation about build constraints themselves.
+//
+// This package parses both the original “// +build” syntax and the “//go:build” syntax that will be added in Go 1.17.
+// The parser is being included in Go 1.16 to allow tools that need to process Go 1.17 source code
+// to still be built against the Go 1.16 release.
+// See https://golang.org/design/draft-gobuild for details about the “//go:build” syntax.
+package constraint
+
+import (
+       "errors"
+       "strings"
+       "unicode"
+       "unicode/utf8"
+)
+
+// An Expr is a build tag constraint expression.
+// The underlying concrete type is *AndExpr, *OrExpr, *NotExpr, or *TagExpr.
+type Expr interface {
+       // String returns the string form of the expression,
+       // using the boolean syntax used in //go:build lines.
+       String() string
+
+       // Eval reports whether the expression evaluates to true.
+       // It calls ok(tag) as needed to find out whether a given build tag
+       // is satisfied by the current build configuration.
+       Eval(ok func(tag string) bool) bool
+
+       // The presence of an isExpr method explicitly marks the type as an Expr.
+       // Only implementations in this package should be used as Exprs.
+       isExpr()
+}
+
+// A TagExpr is an Expr for the single tag Tag.
+type TagExpr struct {
+       Tag string // for example, “linux” or “cgo”
+}
+
+func (x *TagExpr) isExpr() {}
+
+func (x *TagExpr) Eval(ok func(tag string) bool) bool {
+       return ok(x.Tag)
+}
+
+func (x *TagExpr) String() string {
+       return x.Tag
+}
+
+func tag(tag string) Expr { return &TagExpr{tag} }
+
+// A NotExpr represents the expression !X (the negation of X).
+type NotExpr struct {
+       X Expr
+}
+
+func (x *NotExpr) isExpr() {}
+
+func (x *NotExpr) Eval(ok func(tag string) bool) bool {
+       return !x.X.Eval(ok)
+}
+
+func (x *NotExpr) String() string {
+       s := x.X.String()
+       switch x.X.(type) {
+       case *AndExpr, *OrExpr:
+               s = "(" + s + ")"
+       }
+       return "!" + s
+}
+
+func not(x Expr) Expr { return &NotExpr{x} }
+
+// An AndExpr represents the expression X && Y.
+type AndExpr struct {
+       X, Y Expr
+}
+
+func (x *AndExpr) isExpr() {}
+
+func (x *AndExpr) Eval(ok func(tag string) bool) bool {
+       // Note: Eval both, to make sure ok func observes all tags.
+       xok := x.X.Eval(ok)
+       yok := x.Y.Eval(ok)
+       return xok && yok
+}
+
+func (x *AndExpr) String() string {
+       return andArg(x.X) + " && " + andArg(x.Y)
+}
+
+func andArg(x Expr) string {
+       s := x.String()
+       if _, ok := x.(*OrExpr); ok {
+               s = "(" + s + ")"
+       }
+       return s
+}
+
+func and(x, y Expr) Expr {
+       return &AndExpr{x, y}
+}
+
+// An OrExpr represents the expression X || Y.
+type OrExpr struct {
+       X, Y Expr
+}
+
+func (x *OrExpr) isExpr() {}
+
+func (x *OrExpr) Eval(ok func(tag string) bool) bool {
+       // Note: Eval both, to make sure ok func observes all tags.
+       xok := x.X.Eval(ok)
+       yok := x.Y.Eval(ok)
+       return xok || yok
+}
+
+func (x *OrExpr) String() string {
+       return orArg(x.X) + " || " + orArg(x.Y)
+}
+
+func orArg(x Expr) string {
+       s := x.String()
+       if _, ok := x.(*AndExpr); ok {
+               s = "(" + s + ")"
+       }
+       return s
+}
+
+func or(x, y Expr) Expr {
+       return &OrExpr{x, y}
+}
+
+// A SyntaxError reports a syntax error in a parsed build expression.
+type SyntaxError struct {
+       Offset int    // byte offset in input where error was detected
+       Err    string // description of error
+}
+
+func (e *SyntaxError) Error() string {
+       return e.Err
+}
+
+var errNotConstraint = errors.New("not a build constraint")
+
+// Parse parses a single build constraint line of the form “//go:build ...” or “// +build ...”
+// and returns the corresponding boolean expression.
+func Parse(line string) (Expr, error) {
+       if text, ok := splitGoBuild(line); ok {
+               return parseExpr(text)
+       }
+       if text, ok := splitPlusBuild(line); ok {
+               return parsePlusBuildExpr(text), nil
+       }
+       return nil, errNotConstraint
+}
+
+// IsGoBuild reports whether the line of text is a “//go:build” constraint.
+// It only checks the prefix of the text, not that the expression itself parses.
+func IsGoBuild(line string) bool {
+       _, ok := splitGoBuild(line)
+       return ok
+}
+
+// splitGoBuild splits apart the leading //go:build prefix in line from the build expression itself.
+// It returns "", false if the input is not a //go:build line or if the input contains multiple lines.
+func splitGoBuild(line string) (expr string, ok bool) {
+       // A single trailing newline is OK; otherwise multiple lines are not.
+       if len(line) > 0 && line[len(line)-1] == '\n' {
+               line = line[:len(line)-1]
+       }
+       if strings.Contains(line, "\n") {
+               return "", false
+       }
+
+       if !strings.HasPrefix(line, "//go:build") {
+               return "", false
+       }
+
+       line = strings.TrimSpace(line)
+       line = line[len("//go:build"):]
+
+       // If strings.TrimSpace finds more to trim after removing the //go:build prefix,
+       // it means that the prefix was followed by a space, making this a //go:build line
+       // (as opposed to a //go:buildsomethingelse line).
+       // If line is empty, we had "//go:build" by itself, which also counts.
+       trim := strings.TrimSpace(line)
+       if len(line) == len(trim) && line != "" {
+               return "", false
+       }
+
+       return trim, true
+}
+
+// An exprParser holds state for parsing a build expression.
+type exprParser struct {
+       s string // input string
+       i int    // next read location in s
+
+       tok   string // last token read
+       isTag bool
+       pos   int // position (start) of last token
+}
+
+// parseExpr parses a boolean build tag expression.
+func parseExpr(text string) (x Expr, err error) {
+       defer func() {
+               if e := recover(); e != nil {
+                       if e, ok := e.(*SyntaxError); ok {
+                               err = e
+                               return
+                       }
+                       panic(e) // unreachable unless parser has a bug
+               }
+       }()
+
+       p := &exprParser{s: text}
+       x = p.or()
+       if p.tok != "" {
+               panic(&SyntaxError{Offset: p.pos, Err: "unexpected token " + p.tok})
+       }
+       return x, nil
+}
+
+// or parses a sequence of || expressions.
+// On entry, the next input token has not yet been lexed.
+// On exit, the next input token has been lexed and is in p.tok.
+func (p *exprParser) or() Expr {
+       x := p.and()
+       for p.tok == "||" {
+               x = or(x, p.and())
+       }
+       return x
+}
+
+// and parses a sequence of && expressions.
+// On entry, the next input token has not yet been lexed.
+// On exit, the next input token has been lexed and is in p.tok.
+func (p *exprParser) and() Expr {
+       x := p.not()
+       for p.tok == "&&" {
+               x = and(x, p.not())
+       }
+       return x
+}
+
+// not parses a ! expression.
+// On entry, the next input token has not yet been lexed.
+// On exit, the next input token has been lexed and is in p.tok.
+func (p *exprParser) not() Expr {
+       p.lex()
+       if p.tok == "!" {
+               p.lex()
+               if p.tok == "!" {
+                       panic(&SyntaxError{Offset: p.pos, Err: "double negation not allowed"})
+               }
+               return not(p.atom())
+       }
+       return p.atom()
+}
+
+// atom parses a tag or a parenthesized expression.
+// On entry, the next input token HAS been lexed.
+// On exit, the next input token has been lexed and is in p.tok.
+func (p *exprParser) atom() Expr {
+       // first token already in p.tok
+       if p.tok == "(" {
+               pos := p.pos
+               defer func() {
+                       if e := recover(); e != nil {
+                               if e, ok := e.(*SyntaxError); ok && e.Err == "unexpected end of expression" {
+                                       e.Err = "missing close paren"
+                               }
+                               panic(e)
+                       }
+               }()
+               x := p.or()
+               if p.tok != ")" {
+                       panic(&SyntaxError{Offset: pos, Err: "missing close paren"})
+               }
+               p.lex()
+               return x
+       }
+
+       if !p.isTag {
+               if p.tok == "" {
+                       panic(&SyntaxError{Offset: p.pos, Err: "unexpected end of expression"})
+               }
+               panic(&SyntaxError{Offset: p.pos, Err: "unexpected token " + p.tok})
+       }
+       tok := p.tok
+       p.lex()
+       return tag(tok)
+}
+
+// lex finds and consumes the next token in the input stream.
+// On return, p.tok is set to the token text,
+// p.isTag reports whether the token was a tag,
+// and p.pos records the byte offset of the start of the token in the input stream.
+// If lex reaches the end of the input, p.tok is set to the empty string.
+// For any other syntax error, lex panics with a SyntaxError.
+func (p *exprParser) lex() {
+       p.isTag = false
+       for p.i < len(p.s) && (p.s[p.i] == ' ' || p.s[p.i] == '\t') {
+               p.i++
+       }
+       if p.i >= len(p.s) {
+               p.tok = ""
+               p.pos = p.i
+               return
+       }
+       switch p.s[p.i] {
+       case '(', ')', '!':
+               p.pos = p.i
+               p.i++
+               p.tok = p.s[p.pos:p.i]
+               return
+
+       case '&', '|':
+               if p.i+1 >= len(p.s) || p.s[p.i+1] != p.s[p.i] {
+                       panic(&SyntaxError{Offset: p.i, Err: "invalid syntax at " + string(rune(p.s[p.i]))})
+               }
+               p.pos = p.i
+               p.i += 2
+               p.tok = p.s[p.pos:p.i]
+               return
+       }
+
+       tag := p.s[p.i:]
+       for i, c := range tag {
+               if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
+                       tag = tag[:i]
+                       break
+               }
+       }
+       if tag == "" {
+               c, _ := utf8.DecodeRuneInString(p.s[p.i:])
+               panic(&SyntaxError{Offset: p.i, Err: "invalid syntax at " + string(c)})
+       }
+
+       p.pos = p.i
+       p.i += len(tag)
+       p.tok = p.s[p.pos:p.i]
+       p.isTag = true
+       return
+}
+
+// IsPlusBuild reports whether the line of text is a “// +build” constraint.
+// It only checks the prefix of the text, not that the expression itself parses.
+func IsPlusBuild(line string) bool {
+       _, ok := splitPlusBuild(line)
+       return ok
+}
+
+// splitGoBuild splits apart the leading //go:build prefix in line from the build expression itself.
+// It returns "", false if the input is not a //go:build line or if the input contains multiple lines.
+func splitPlusBuild(line string) (expr string, ok bool) {
+       // A single trailing newline is OK; otherwise multiple lines are not.
+       if len(line) > 0 && line[len(line)-1] == '\n' {
+               line = line[:len(line)-1]
+       }
+       if strings.Contains(line, "\n") {
+               return "", false
+       }
+
+       if !strings.HasPrefix(line, "//") {
+               return "", false
+       }
+       line = line[len("//"):]
+       // Note the space is optional; "//+build" is recognized too.
+       line = strings.TrimSpace(line)
+
+       if !strings.HasPrefix(line, "+build") {
+               return "", false
+       }
+       line = line[len("+build"):]
+
+       // If strings.TrimSpace finds more to trim after removing the +build prefix,
+       // it means that the prefix was followed by a space, making this a +build line
+       // (as opposed to a +buildsomethingelse line).
+       // If line is empty, we had "// +build" by itself, which also counts.
+       trim := strings.TrimSpace(line)
+       if len(line) == len(trim) && line != "" {
+               return "", false
+       }
+
+       return trim, true
+}
+
+// parsePlusBuildExpr parses a legacy build tag expression (as used with “// +build”).
+func parsePlusBuildExpr(text string) Expr {
+       var x Expr
+       for _, clause := range strings.Fields(text) {
+               var y Expr
+               for _, lit := range strings.Split(clause, ",") {
+                       var z Expr
+                       var neg bool
+                       if strings.HasPrefix(lit, "!!") || lit == "!" {
+                               z = tag("ignore")
+                       } else {
+                               if strings.HasPrefix(lit, "!") {
+                                       neg = true
+                                       lit = lit[len("!"):]
+                               }
+                               if isValidTag(lit) {
+                                       z = tag(lit)
+                               } else {
+                                       z = tag("ignore")
+                               }
+                               if neg {
+                                       z = not(z)
+                               }
+                       }
+                       if y == nil {
+                               y = z
+                       } else {
+                               y = and(y, z)
+                       }
+               }
+               if x == nil {
+                       x = y
+               } else {
+                       x = or(x, y)
+               }
+       }
+       return x
+}
+
+// isValidTag reports whether the word is a valid build tag.
+// Tags must be letters, digits, underscores or dots.
+// Unlike in Go identifiers, all digits are fine (e.g., "386").
+func isValidTag(word string) bool {
+       if word == "" {
+               return false
+       }
+       for _, c := range word {
+               if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
+                       return false
+               }
+       }
+       return true
+}
+
+var errComplex = errors.New("expression too complex for // +build lines")
+
+// PlusBuildLines returns a sequence of “// +build” lines that evaluate to the build expression x.
+// If the expression is too complex to convert directly to “// +build” lines, PlusBuildLines returns an error.
+func PlusBuildLines(x Expr) ([]string, error) {
+       // Push all NOTs to the expression leaves, so that //go:build !(x && y) can be treated as !x || !y.
+       // This rewrite is both efficient and commonly needed, so it's worth doing.
+       // Essentially all other possible rewrites are too expensive and too rarely needed.
+       x = pushNot(x, false)
+
+       // Split into AND of ORs of ANDs of literals (tag or NOT tag).
+       var split [][][]Expr
+       for _, or := range appendSplitAnd(nil, x) {
+               var ands [][]Expr
+               for _, and := range appendSplitOr(nil, or) {
+                       var lits []Expr
+                       for _, lit := range appendSplitAnd(nil, and) {
+                               switch lit.(type) {
+                               case *TagExpr, *NotExpr:
+                                       lits = append(lits, lit)
+                               default:
+                                       return nil, errComplex
+                               }
+                       }
+                       ands = append(ands, lits)
+               }
+               split = append(split, ands)
+       }
+
+       // If all the ORs have length 1 (no actual OR'ing going on),
+       // push the top-level ANDs to the bottom level, so that we get
+       // one // +build line instead of many.
+       maxOr := 0
+       for _, or := range split {
+               if maxOr < len(or) {
+                       maxOr = len(or)
+               }
+       }
+       if maxOr == 1 {
+               var lits []Expr
+               for _, or := range split {
+                       lits = append(lits, or[0]...)
+               }
+               split = [][][]Expr{{lits}}
+       }
+
+       // Prepare the +build lines.
+       var lines []string
+       for _, or := range split {
+               line := "// +build"
+               for _, and := range or {
+                       clause := ""
+                       for i, lit := range and {
+                               if i > 0 {
+                                       clause += ","
+                               }
+                               clause += lit.String()
+                       }
+                       line += " " + clause
+               }
+               lines = append(lines, line)
+       }
+
+       return lines, nil
+}
+
+// pushNot applies DeMorgan's law to push negations down the expression,
+// so that only tags are negated in the result.
+// (It applies the rewrites !(X && Y) => (!X || !Y) and !(X || Y) => (!X && !Y).)
+func pushNot(x Expr, not bool) Expr {
+       switch x := x.(type) {
+       default:
+               // unreachable
+               return x
+       case *NotExpr:
+               if _, ok := x.X.(*TagExpr); ok && !not {
+                       return x
+               }
+               return pushNot(x.X, !not)
+       case *TagExpr:
+               if not {
+                       return &NotExpr{X: x}
+               }
+               return x
+       case *AndExpr:
+               x1 := pushNot(x.X, not)
+               y1 := pushNot(x.Y, not)
+               if not {
+                       return or(x1, y1)
+               }
+               if x1 == x.X && y1 == x.Y {
+                       return x
+               }
+               return and(x1, y1)
+       case *OrExpr:
+               x1 := pushNot(x.X, not)
+               y1 := pushNot(x.Y, not)
+               if not {
+                       return and(x1, y1)
+               }
+               if x1 == x.X && y1 == x.Y {
+                       return x
+               }
+               return or(x1, y1)
+       }
+}
+
+// appendSplitAnd appends x to list while splitting apart any top-level && expressions.
+// For example, appendSplitAnd({W}, X && Y && Z) = {W, X, Y, Z}.
+func appendSplitAnd(list []Expr, x Expr) []Expr {
+       if x, ok := x.(*AndExpr); ok {
+               list = appendSplitAnd(list, x.X)
+               list = appendSplitAnd(list, x.Y)
+               return list
+       }
+       return append(list, x)
+}
+
+// appendSplitOr appends x to list while splitting apart any top-level || expressions.
+// For example, appendSplitOr({W}, X || Y || Z) = {W, X, Y, Z}.
+func appendSplitOr(list []Expr, x Expr) []Expr {
+       if x, ok := x.(*OrExpr); ok {
+               list = appendSplitOr(list, x.X)
+               list = appendSplitOr(list, x.Y)
+               return list
+       }
+       return append(list, x)
+}

diff --git a/src/go/build/constraint/expr_test.go b/src/go/build/constraint/expr_test.go
new file mode 100644 (file)
index 0000000..4979f8b
--- /dev/null
+++ b/src/go/build/constraint/expr_test.go
@@ -0,0 +1,317 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package constraint
+
+import (
+       "fmt"
+       "reflect"
+       "strings"
+       "testing"
+)
+
+var exprStringTests = []struct {
+       x   Expr
+       out string
+}{
+       {
+               x:   tag("abc"),
+               out: "abc",
+       },
+       {
+               x:   not(tag("abc")),
+               out: "!abc",
+       },
+       {
+               x:   not(and(tag("abc"), tag("def"))),
+               out: "!(abc && def)",
+       },
+       {
+               x:   and(tag("abc"), or(tag("def"), tag("ghi"))),
+               out: "abc && (def || ghi)",
+       },
+       {
+               x:   or(and(tag("abc"), tag("def")), tag("ghi")),
+               out: "(abc && def) || ghi",
+       },
+}
+
+func TestExprString(t *testing.T) {
+       for i, tt := range exprStringTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       s := tt.x.String()
+                       if s != tt.out {
+                               t.Errorf("String() mismatch:\nhave %s\nwant %s", s, tt.out)
+                       }
+               })
+       }
+}
+
+var lexTests = []struct {
+       in  string
+       out string
+}{
+       {"", ""},
+       {"x", "x"},
+       {"x.y", "x.y"},
+       {"x_y", "x_y"},
+       {"αx", "αx"},
+       {"αx²", "αx err: invalid syntax at ²"},
+       {"go1.2", "go1.2"},
+       {"x y", "x y"},
+       {"x!y", "x ! y"},
+       {"&&||!()xy yx ", "&& || ! ( ) xy yx"},
+       {"x~", "x err: invalid syntax at ~"},
+       {"x ~", "x err: invalid syntax at ~"},
+       {"x &", "x err: invalid syntax at &"},
+       {"x &y", "x err: invalid syntax at &"},
+}
+
+func TestLex(t *testing.T) {
+       for i, tt := range lexTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       p := &exprParser{s: tt.in}
+                       out := ""
+                       for {
+                               tok, err := lexHelp(p)
+                               if tok == "" && err == nil {
+                                       break
+                               }
+                               if out != "" {
+                                       out += " "
+                               }
+                               if err != nil {
+                                       out += "err: " + err.Error()
+                                       break
+                               }
+                               out += tok
+                       }
+                       if out != tt.out {
+                               t.Errorf("lex(%q):\nhave %s\nwant %s", tt.in, out, tt.out)
+                       }
+               })
+       }
+}
+
+func lexHelp(p *exprParser) (tok string, err error) {
+       defer func() {
+               if e := recover(); e != nil {
+                       if e, ok := e.(*SyntaxError); ok {
+                               err = e
+                               return
+                       }
+                       panic(e)
+               }
+       }()
+
+       p.lex()
+       return p.tok, nil
+}
+
+var parseExprTests = []struct {
+       in string
+       x  Expr
+}{
+       {"x", tag("x")},
+       {"x&&y", and(tag("x"), tag("y"))},
+       {"x||y", or(tag("x"), tag("y"))},
+       {"(x)", tag("x")},
+       {"x||y&&z", or(tag("x"), and(tag("y"), tag("z")))},
+       {"x&&y||z", or(and(tag("x"), tag("y")), tag("z"))},
+       {"x&&(y||z)", and(tag("x"), or(tag("y"), tag("z")))},
+       {"(x||y)&&z", and(or(tag("x"), tag("y")), tag("z"))},
+       {"!(x&&y)", not(and(tag("x"), tag("y")))},
+}
+
+func TestParseExpr(t *testing.T) {
+       for i, tt := range parseExprTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x, err := parseExpr(tt.in)
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       if x.String() != tt.x.String() {
+                               t.Errorf("parseExpr(%q):\nhave %s\nwant %s", tt.in, x, tt.x)
+                       }
+               })
+       }
+}
+
+var parseExprErrorTests = []struct {
+       in  string
+       err error
+}{
+       {"x && ", &SyntaxError{Offset: 5, Err: "unexpected end of expression"}},
+       {"x && (", &SyntaxError{Offset: 6, Err: "missing close paren"}},
+       {"x && ||", &SyntaxError{Offset: 5, Err: "unexpected token ||"}},
+       {"x && !", &SyntaxError{Offset: 6, Err: "unexpected end of expression"}},
+       {"x && !!", &SyntaxError{Offset: 6, Err: "double negation not allowed"}},
+       {"x !", &SyntaxError{Offset: 2, Err: "unexpected token !"}},
+       {"x && (y", &SyntaxError{Offset: 5, Err: "missing close paren"}},
+}
+
+func TestParseError(t *testing.T) {
+       for i, tt := range parseExprErrorTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x, err := parseExpr(tt.in)
+                       if err == nil {
+                               t.Fatalf("parseExpr(%q) = %v, want error", tt.in, x)
+                       }
+                       if !reflect.DeepEqual(err, tt.err) {
+                               t.Fatalf("parseExpr(%q): wrong error:\nhave %#v\nwant %#v", tt.in, err, tt.err)
+                       }
+               })
+       }
+}
+
+var exprEvalTests = []struct {
+       in   string
+       ok   bool
+       tags string
+}{
+       {"x", false, "x"},
+       {"x && y", false, "x y"},
+       {"x || y", false, "x y"},
+       {"!x && yes", true, "x yes"},
+       {"yes || y", true, "y yes"},
+}
+
+func TestExprEval(t *testing.T) {
+       for i, tt := range exprEvalTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x, err := parseExpr(tt.in)
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       tags := make(map[string]bool)
+                       wantTags := make(map[string]bool)
+                       for _, tag := range strings.Fields(tt.tags) {
+                               wantTags[tag] = true
+                       }
+                       hasTag := func(tag string) bool {
+                               tags[tag] = true
+                               return tag == "yes"
+                       }
+                       ok := x.Eval(hasTag)
+                       if ok != tt.ok || !reflect.DeepEqual(tags, wantTags) {
+                               t.Errorf("Eval(%#q):\nhave ok=%v, tags=%v\nwant ok=%v, tags=%v",
+                                       tt.in, ok, tags, tt.ok, wantTags)
+                       }
+               })
+       }
+}
+
+var parsePlusBuildExprTests = []struct {
+       in string
+       x  Expr
+}{
+       {"x", tag("x")},
+       {"x,y", and(tag("x"), tag("y"))},
+       {"x y", or(tag("x"), tag("y"))},
+       {"x y,z", or(tag("x"), and(tag("y"), tag("z")))},
+       {"x,y z", or(and(tag("x"), tag("y")), tag("z"))},
+       {"x,!y !z", or(and(tag("x"), not(tag("y"))), not(tag("z")))},
+       {"!! x", or(tag("ignore"), tag("x"))},
+       {"!!x", tag("ignore")},
+       {"!x", not(tag("x"))},
+       {"!", tag("ignore")},
+}
+
+func TestParsePlusBuildExpr(t *testing.T) {
+       for i, tt := range parsePlusBuildExprTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x := parsePlusBuildExpr(tt.in)
+                       if x.String() != tt.x.String() {
+                               t.Errorf("parsePlusBuildExpr(%q):\nhave %v\nwant %v", tt.in, x, tt.x)
+                       }
+               })
+       }
+}
+
+var constraintTests = []struct {
+       in  string
+       x   Expr
+       err error
+}{
+       {"//+build x y", or(tag("x"), tag("y")), nil},
+       {"// +build x y \n", or(tag("x"), tag("y")), nil},
+       {"// +build x y \n ", nil, errNotConstraint},
+       {"// +build x y \nmore", nil, errNotConstraint},
+       {" //+build x y", nil, errNotConstraint},
+
+       {"//go:build x && y", and(tag("x"), tag("y")), nil},
+       {"//go:build x && y\n", and(tag("x"), tag("y")), nil},
+       {"//go:build x && y\n ", nil, errNotConstraint},
+       {"//go:build x && y\nmore", nil, errNotConstraint},
+       {" //go:build x && y", nil, errNotConstraint},
+}
+
+func TestParse(t *testing.T) {
+       for i, tt := range constraintTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x, err := Parse(tt.in)
+                       if err != nil {
+                               if tt.err == nil {
+                                       t.Errorf("Constraint(%q): unexpected error: %v", tt.in, err)
+                               } else if tt.err != err {
+                                       t.Errorf("Constraint(%q): error %v, want %v", tt.in, err, tt.err)
+                               }
+                               return
+                       }
+                       if tt.err != nil {
+                               t.Errorf("Constraint(%q) = %v, want error %v", tt.in, x, tt.err)
+                               return
+                       }
+                       if x.String() != tt.x.String() {
+                               t.Errorf("Constraint(%q):\nhave %v\nwant %v", tt.in, x, tt.x)
+                       }
+               })
+       }
+}
+
+var plusBuildLinesTests = []struct {
+       in  string
+       out []string
+       err error
+}{
+       {"x", []string{"x"}, nil},
+       {"x && !y", []string{"x,!y"}, nil},
+       {"x || y", []string{"x y"}, nil},
+       {"x && (y || z)", []string{"x", "y z"}, nil},
+       {"!(x && y)", []string{"!x !y"}, nil},
+       {"x || (y && z)", []string{"x y,z"}, nil},
+       {"w && (x || (y && z))", []string{"w", "x y,z"}, nil},
+       {"v || (w && (x || (y && z)))", nil, errComplex},
+}
+
+func TestPlusBuildLines(t *testing.T) {
+       for i, tt := range plusBuildLinesTests {
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       x, err := parseExpr(tt.in)
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       lines, err := PlusBuildLines(x)
+                       if err != nil {
+                               if tt.err == nil {
+                                       t.Errorf("PlusBuildLines(%q): unexpected error: %v", tt.in, err)
+                               } else if tt.err != err {
+                                       t.Errorf("PlusBuildLines(%q): error %v, want %v", tt.in, err, tt.err)
+                               }
+                               return
+                       }
+                       if tt.err != nil {
+                               t.Errorf("PlusBuildLines(%q) = %v, want error %v", tt.in, lines, tt.err)
+                               return
+                       }
+                       var want []string
+                       for _, line := range tt.out {
+                               want = append(want, "// +build "+line)
+                       }
+                       if !reflect.DeepEqual(lines, want) {
+                               t.Errorf("PlusBuildLines(%q):\nhave %q\nwant %q", tt.in, lines, want)
+                       }
+               })
+       }
+}

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 16ca675f8c80797f1777732e872efc898f37f11c..3511cf41a6b5992673b2d67b79a3fdd68a10781a 100644 (file)
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -10,6 +10,7 @@ package build
 import (
        "bytes"
        "fmt"
+       "go/token"
        "internal/testenv"
        "io/fs"
        "os"
@@ -75,8 +76,12 @@ var depsRules = `
          unicode/utf8, unicode/utf16, unicode,
          unsafe;
 
+       # These packages depend only on unsafe.
+       unsafe
+       < internal/abi;
+
        # RUNTIME is the core runtime group of packages, all of them very light-weight.
-       internal/cpu, unsafe
+       internal/abi, internal/cpu, unsafe
        < internal/bytealg
        < internal/unsafeheader
        < runtime/internal/sys
@@ -162,6 +167,9 @@ var depsRules = `
        < os
        < os/signal;
 
+       io/fs
+       < embed;
+
        unicode, fmt !< os, os/signal;
 
        os/signal, STR
@@ -174,7 +182,7 @@ var depsRules = `
        reflect !< OS;
 
        OS
-       < golang.org/x/sys/cpu, internal/goroot;
+       < golang.org/x/sys/cpu;
 
        # FMT is OS (which includes string routines) plus reflect and fmt.
        # It does not include package log, which should be avoided in core packages.
@@ -190,6 +198,12 @@ var depsRules = `
 
        log !< FMT;
 
+       OS, FMT
+       < internal/execabs;
+
+       OS, internal/execabs
+       < internal/goroot;
+
        # Misc packages needing only FMT.
        FMT
        < flag,
@@ -275,9 +289,12 @@ var depsRules = `
        math/big, go/token
        < go/constant;
 
-       container/heap, go/constant, go/parser
+       container/heap, go/constant, go/parser, regexp
        < go/types;
 
+       FMT
+       < go/build/constraint;
+
        go/doc, go/parser, internal/goroot, internal/goversion
        < go/build;
 
@@ -605,6 +622,7 @@ func findImports(pkg string) ([]string, error) {
        }
        var imports []string
        var haveImport = map[string]bool{}
+       fset := token.NewFileSet()
        for _, file := range files {
                name := file.Name()
                if name == "slice_go14.go" || name == "slice_go18.go" {
@@ -614,8 +632,10 @@ func findImports(pkg string) ([]string, error) {
                if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
                        continue
                }
-               var info fileInfo
-               info.name = filepath.Join(dir, name)
+               info := fileInfo{
+                       name: filepath.Join(dir, name),
+                       fset: fset,
+               }
                f, err := os.Open(info.name)
                if err != nil {
                        return nil, err
@@ -843,3 +863,22 @@ func TestStdlibLowercase(t *testing.T) {
                }
        }
 }
+
+// TestFindImports tests that findImports works.  See #43249.
+func TestFindImports(t *testing.T) {
+       imports, err := findImports("go/build")
+       if err != nil {
+               t.Fatal(err)
+       }
+       t.Logf("go/build imports %q", imports)
+       want := []string{"bytes", "os", "path/filepath", "strings"}
+wantLoop:
+       for _, w := range want {
+               for _, imp := range imports {
+                       if imp == w {
+                               continue wantLoop
+                       }
+               }
+               t.Errorf("expected to find %q in import list", w)
+       }
+}

diff --git a/src/go/build/read.go b/src/go/build/read.go
index 6806a51c2474d8633653505b999586335972112b..aa7c6ee59eb6d3350e262b3bb6f928646d40d10c 100644 (file)
--- a/src/go/build/read.go
+++ b/src/go/build/read.go
@@ -10,6 +10,7 @@ import (
        "fmt"
        "go/ast"
        "go/parser"
+       "go/token"
        "io"
        "strconv"
        "strings"
@@ -24,6 +25,18 @@ type importReader struct {
        err  error
        eof  bool
        nerr int
+       pos  token.Position
+}
+
+func newImportReader(name string, r io.Reader) *importReader {
+       return &importReader{
+               b: bufio.NewReader(r),
+               pos: token.Position{
+                       Filename: name,
+                       Line:     1,
+                       Column:   1,
+               },
+       }
 }
 
 func isIdent(c byte) bool {
@@ -66,22 +79,32 @@ func (r *importReader) readByte() byte {
 // readByteNoBuf is like readByte but doesn't buffer the byte.
 // It exhausts r.buf before reading from r.b.
 func (r *importReader) readByteNoBuf() byte {
+       var c byte
+       var err error
        if len(r.buf) > 0 {
-               c := r.buf[0]
+               c = r.buf[0]
                r.buf = r.buf[1:]
-               return c
-       }
-       c, err := r.b.ReadByte()
-       if err == nil && c == 0 {
-               err = errNUL
+       } else {
+               c, err = r.b.ReadByte()
+               if err == nil && c == 0 {
+                       err = errNUL
+               }
        }
+
        if err != nil {
                if err == io.EOF {
                        r.eof = true
                } else if r.err == nil {
                        r.err = err
                }
-               c = 0
+               return 0
+       }
+       r.pos.Offset++
+       if c == '\n' {
+               r.pos.Line++
+               r.pos.Column = 1
+       } else {
+               r.pos.Column++
        }
        return c
 }
@@ -171,6 +194,41 @@ func (r *importReader) findEmbed(first bool) bool {
                case ' ', '\t':
                        // leave startLine alone
 
+               case '"':
+                       startLine = false
+                       for r.err == nil {
+                               if r.eof {
+                                       r.syntaxError()
+                               }
+                               c = r.readByteNoBuf()
+                               if c == '\\' {
+                                       r.readByteNoBuf()
+                                       if r.err != nil {
+                                               r.syntaxError()
+                                               return false
+                                       }
+                                       continue
+                               }
+                               if c == '"' {
+                                       c = r.readByteNoBuf()
+                                       goto Reswitch
+                               }
+                       }
+                       goto Reswitch
+
+               case '`':
+                       startLine = false
+                       for r.err == nil {
+                               if r.eof {
+                                       r.syntaxError()
+                               }
+                               c = r.readByteNoBuf()
+                               if c == '`' {
+                                       c = r.readByteNoBuf()
+                                       goto Reswitch
+                               }
+                       }
+
                case '/':
                        c = r.readByteNoBuf()
                        switch c {
@@ -288,7 +346,7 @@ func (r *importReader) readImport() {
 // readComments is like io.ReadAll, except that it only reads the leading
 // block of comments in the file.
 func readComments(f io.Reader) ([]byte, error) {
-       r := &importReader{b: bufio.NewReader(f)}
+       r := newImportReader("", f)
        r.peekByte(true)
        if r.err == nil && !r.eof {
                // Didn't reach EOF, so must have found a non-space byte. Remove it.
@@ -305,7 +363,7 @@ func readComments(f io.Reader) ([]byte, error) {
 // It only returns an error if there are problems reading the file,
 // not for syntax errors in the file itself.
 func readGoInfo(f io.Reader, info *fileInfo) error {
-       r := &importReader{b: bufio.NewReader(f)}
+       r := newImportReader(info.name, f)
 
        r.readKeyword("package")
        r.readIdent()
@@ -393,6 +451,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
                var line []byte
                for first := true; r.findEmbed(first); first = false {
                        line = line[:0]
+                       pos := r.pos
                        for {
                                c := r.readByteNoBuf()
                                if c == '\n' || r.err != nil || r.eof {
@@ -403,9 +462,9 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
                        // Add args if line is well-formed.
                        // Ignore badly-formed lines - the compiler will report them when it finds them,
                        // and we can pretend they are not there to help go list succeed with what it knows.
-                       args, err := parseGoEmbed(string(line))
+                       embs, err := parseGoEmbed(string(line), pos)
                        if err == nil {
-                               info.embeds = append(info.embeds, args...)
+                               info.embeds = append(info.embeds, embs...)
                        }
                }
        }
@@ -415,11 +474,23 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 
 // parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
 // It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
-// There is a copy of this code in cmd/compile/internal/gc/noder.go as well.
-func parseGoEmbed(args string) ([]string, error) {
-       var list []string
-       for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
+// This is based on a similar function in cmd/compile/internal/gc/noder.go;
+// this version calculates position information as well.
+func parseGoEmbed(args string, pos token.Position) ([]fileEmbed, error) {
+       trimBytes := func(n int) {
+               pos.Offset += n
+               pos.Column += utf8.RuneCountInString(args[:n])
+               args = args[n:]
+       }
+       trimSpace := func() {
+               trim := strings.TrimLeftFunc(args, unicode.IsSpace)
+               trimBytes(len(args) - len(trim))
+       }
+
+       var list []fileEmbed
+       for trimSpace(); args != ""; trimSpace() {
                var path string
+               pathPos := pos
        Switch:
                switch args[0] {
                default:
@@ -431,7 +502,7 @@ func parseGoEmbed(args string) ([]string, error) {
                                }
                        }
                        path = args[:i]
-                       args = args[i:]
+                       trimBytes(i)
 
                case '`':
                        i := strings.Index(args[1:], "`")
@@ -439,7 +510,7 @@ func parseGoEmbed(args string) ([]string, error) {
                                return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
                        }
                        path = args[1 : 1+i]
-                       args = args[1+i+1:]
+                       trimBytes(1 + i + 1)
 
                case '"':
                        i := 1
@@ -454,7 +525,7 @@ func parseGoEmbed(args string) ([]string, error) {
                                                return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
                                        }
                                        path = q
-                                       args = args[i+1:]
+                                       trimBytes(i + 1)
                                        break Switch
                                }
                        }
@@ -469,7 +540,7 @@ func parseGoEmbed(args string) ([]string, error) {
                                return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
                        }
                }
-               list = append(list, path)
+               list = append(list, fileEmbed{path, pathPos})
        }
        return list, nil
 }

diff --git a/src/go/build/read_test.go b/src/go/build/read_test.go
index 9264d2606f1b72e2697bcd4e09219264a46da908..32e6bae008841bb4db5b7fb456729f3e6267828e 100644 (file)
--- a/src/go/build/read_test.go
+++ b/src/go/build/read_test.go
@@ -5,9 +5,9 @@
 package build
 
 import (
+       "fmt"
        "go/token"
        "io"
-       "reflect"
        "strings"
        "testing"
 )
@@ -228,55 +228,94 @@ func TestReadFailuresIgnored(t *testing.T) {
 }
 
 var readEmbedTests = []struct {
-       in  string
-       out []string
+       in, out string
 }{
        {
                "package p\n",
-               nil,
+               "",
        },
        {
                "package p\nimport \"embed\"\nvar i int\n//go:embed x y z\nvar files embed.FS",
-               []string{"x", "y", "z"},
+               `test:4:12:x
+                test:4:14:y
+                test:4:16:z`,
        },
        {
                "package p\nimport \"embed\"\nvar i int\n//go:embed x \"\\x79\" `z`\nvar files embed.FS",
-               []string{"x", "y", "z"},
+               `test:4:12:x
+                test:4:14:y
+                test:4:21:z`,
        },
        {
                "package p\nimport \"embed\"\nvar i int\n//go:embed x y\n//go:embed z\nvar files embed.FS",
-               []string{"x", "y", "z"},
+               `test:4:12:x
+                test:4:14:y
+                test:5:12:z`,
        },
        {
                "package p\nimport \"embed\"\nvar i int\n\t //go:embed x y\n\t //go:embed z\n\t var files embed.FS",
-               []string{"x", "y", "z"},
+               `test:4:14:x
+                test:4:16:y
+                test:5:14:z`,
        },
        {
                "package p\nimport \"embed\"\n//go:embed x y z\nvar files embed.FS",
-               []string{"x", "y", "z"},
+               `test:3:12:x
+                test:3:14:y
+                test:3:16:z`,
+       },
+       {
+               "package p\nimport \"embed\"\nvar s = \"/*\"\n//go:embed x\nvar files embed.FS",
+               `test:4:12:x`,
+       },
+       {
+               `package p
+                import "embed"
+                var s = "\"\\\\"
+                //go:embed x
+                var files embed.FS`,
+               `test:4:15:x`,
+       },
+       {
+               "package p\nimport \"embed\"\nvar s = `/*`\n//go:embed x\nvar files embed.FS",
+               `test:4:12:x`,
+       },
+       {
+               "package p\nimport \"embed\"\nvar s = z/ *y\n//go:embed pointer\nvar pointer embed.FS",
+               "test:4:12:pointer",
        },
        {
                "package p\n//go:embed x y z\n", // no import, no scan
-               nil,
+               "",
        },
        {
                "package p\n//go:embed x y z\nvar files embed.FS", // no import, no scan
-               nil,
+               "",
        },
 }
 
 func TestReadEmbed(t *testing.T) {
        fset := token.NewFileSet()
        for i, tt := range readEmbedTests {
-               var info fileInfo
-               info.fset = fset
+               info := fileInfo{
+                       name: "test",
+                       fset: fset,
+               }
                err := readGoInfo(strings.NewReader(tt.in), &info)
                if err != nil {
                        t.Errorf("#%d: %v", i, err)
                        continue
                }
-               if !reflect.DeepEqual(info.embeds, tt.out) {
-                       t.Errorf("#%d: embeds=%v, want %v", i, info.embeds, tt.out)
+               b := &strings.Builder{}
+               sep := ""
+               for _, emb := range info.embeds {
+                       fmt.Fprintf(b, "%s%v:%s", sep, emb.pos, emb.pattern)
+                       sep = "\n"
+               }
+               got := b.String()
+               want := strings.Join(strings.Fields(tt.out), "\n")
+               if got != want {
+                       t.Errorf("#%d: embeds:\n%s\nwant:\n%s", i, got, want)
                }
        }
 }

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 46414423f2d122f0883e347bb3c84d1d1cf99801..223c363d9b9eebe785d21fb5b7b46d3a584713b2 100644 (file)
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -17,6 +17,7 @@ import (
        "go/token"
        "math"
        "math/big"
+       "math/bits"
        "strconv"
        "strings"
        "sync"
@@ -607,7 +608,11 @@ func Make(x interface{}) Value {
 func BitLen(x Value) int {
        switch x := x.(type) {
        case int64Val:
-               return i64toi(x).val.BitLen()
+               u := uint64(x)
+               if x < 0 {
+                       u = uint64(-x)
+               }
+               return 64 - bits.LeadingZeros64(u)
        case intVal:
                return x.val.BitLen()
        case unknownVal:
@@ -1015,52 +1020,55 @@ func match(x, y Value) (_, _ Value) {
        }
        // ord(x) <= ord(y)
 
-       switch x := x.(type) {
+       // Prefer to return the original x and y arguments when possible,
+       // to avoid unnecessary heap allocations.
+
+       switch x1 := x.(type) {
        case boolVal, *stringVal, complexVal:
                return x, y
 
        case int64Val:
-               switch y := y.(type) {
+               switch y.(type) {
                case int64Val:
                        return x, y
                case intVal:
-                       return i64toi(x), y
+                       return i64toi(x1), y
                case ratVal:
-                       return i64tor(x), y
+                       return i64tor(x1), y
                case floatVal:
-                       return i64tof(x), y
+                       return i64tof(x1), y
                case complexVal:
-                       return vtoc(x), y
+                       return vtoc(x1), y
                }
 
        case intVal:
-               switch y := y.(type) {
+               switch y.(type) {
                case intVal:
                        return x, y
                case ratVal:
-                       return itor(x), y
+                       return itor(x1), y
                case floatVal:
-                       return itof(x), y
+                       return itof(x1), y
                case complexVal:
-                       return vtoc(x), y
+                       return vtoc(x1), y
                }
 
        case ratVal:
-               switch y := y.(type) {
+               switch y.(type) {
                case ratVal:
                        return x, y
                case floatVal:
-                       return rtof(x), y
+                       return rtof(x1), y
                case complexVal:
-                       return vtoc(x), y
+                       return vtoc(x1), y
                }
 
        case floatVal:
-               switch y := y.(type) {
+               switch y.(type) {
                case floatVal:
                        return x, y
                case complexVal:
-                       return vtoc(x), y
+                       return vtoc(x1), y
                }
        }
 

diff --git a/src/go/constant/value_test.go b/src/go/constant/value_test.go
index 286677407d98d832a1fbf1effb5db019ae39410b..91ad0b0c2b9d998a2a28feb2827d8b118cb56124 100644 (file)
--- a/src/go/constant/value_test.go
+++ b/src/go/constant/value_test.go
@@ -706,3 +706,24 @@ func BenchmarkStringAdd(b *testing.B) {
                })
        }
 }
+
+var bitLenTests = []struct {
+       val  int64
+       want int
+}{
+       {0, 0},
+       {1, 1},
+       {-16, 5},
+       {1 << 61, 62},
+       {1 << 62, 63},
+       {-1 << 62, 63},
+       {-1 << 63, 64},
+}
+
+func TestBitLen(t *testing.T) {
+       for _, test := range bitLenTests {
+               if got := BitLen(MakeInt64(test.val)); got != test.want {
+                       t.Errorf("%v: got %v, want %v", test.val, got, test.want)
+               }
+       }
+}

diff --git a/src/go/internal/gccgoimporter/gccgoinstallation.go b/src/go/internal/gccgoimporter/gccgoinstallation.go
index 8fc7ce3232190c93bb74f445bf55be1929e4c786..e90a3cc0b0a343e601bc2fe6389e43a160c713b9 100644 (file)
--- a/src/go/internal/gccgoimporter/gccgoinstallation.go
+++ b/src/go/internal/gccgoimporter/gccgoinstallation.go
@@ -7,8 +7,8 @@ package gccgoimporter
 import (
        "bufio"
        "go/types"
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
 )

diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go
index c59dd16533173506db93882e8c14c7f10b9950e4..a3184e7641aa01d793275a4daca78ae59f47eef1 100644 (file)
--- a/src/go/internal/gcimporter/iimport.go
+++ b/src/go/internal/gcimporter/iimport.go
@@ -15,6 +15,7 @@ import (
        "go/token"
        "go/types"
        "io"
+       "math/big"
        "sort"
 )
 
@@ -320,7 +321,9 @@ func (r *importReader) value() (typ types.Type, val constant.Value) {
                val = constant.MakeString(r.string())
 
        case types.IsInteger:
-               val = r.mpint(b)
+               var x big.Int
+               r.mpint(&x, b)
+               val = constant.Make(&x)
 
        case types.IsFloat:
                val = r.mpfloat(b)
@@ -365,8 +368,8 @@ func intSize(b *types.Basic) (signed bool, maxBytes uint) {
        return
 }
 
-func (r *importReader) mpint(b *types.Basic) constant.Value {
-       signed, maxBytes := intSize(b)
+func (r *importReader) mpint(x *big.Int, typ *types.Basic) {
+       signed, maxBytes := intSize(typ)
 
        maxSmall := 256 - maxBytes
        if signed {
@@ -385,7 +388,8 @@ func (r *importReader) mpint(b *types.Basic) constant.Value {
                                v = ^v
                        }
                }
-               return constant.MakeInt64(v)
+               x.SetInt64(v)
+               return
        }
 
        v := -n
@@ -395,39 +399,23 @@ func (r *importReader) mpint(b *types.Basic) constant.Value {
        if v < 1 || uint(v) > maxBytes {
                errorf("weird decoding: %v, %v => %v", n, signed, v)
        }
-
-       buf := make([]byte, v)
-       io.ReadFull(&r.declReader, buf)
-
-       // convert to little endian
-       // TODO(gri) go/constant should have a more direct conversion function
-       //           (e.g., once it supports a big.Float based implementation)
-       for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
-               buf[i], buf[j] = buf[j], buf[i]
-       }
-
-       x := constant.MakeFromBytes(buf)
+       b := make([]byte, v)
+       io.ReadFull(&r.declReader, b)
+       x.SetBytes(b)
        if signed && n&1 != 0 {
-               x = constant.UnaryOp(token.SUB, x, 0)
+               x.Neg(x)
        }
-       return x
 }
 
-func (r *importReader) mpfloat(b *types.Basic) constant.Value {
-       x := r.mpint(b)
-       if constant.Sign(x) == 0 {
-               return x
-       }
-
-       exp := r.int64()
-       switch {
-       case exp > 0:
-               x = constant.Shift(x, token.SHL, uint(exp))
-       case exp < 0:
-               d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
-               x = constant.BinaryOp(x, token.QUO, d)
+func (r *importReader) mpfloat(typ *types.Basic) constant.Value {
+       var mant big.Int
+       r.mpint(&mant, typ)
+       var f big.Float
+       f.SetInt(&mant)
+       if f.Sign() != 0 {
+               f.SetMantExp(&f, int(r.int64()))
        }
-       return x
+       return constant.Make(&f)
 }
 
 func (r *importReader) ident() string {

diff --git a/src/go/internal/srcimporter/srcimporter.go b/src/go/internal/srcimporter/srcimporter.go
index c4d501dcd91bbd6629eaae9cc84345af7b777bf0..438ae0ff2ee7de290df6510ebb5edcf7539ab243 100644 (file)
--- a/src/go/internal/srcimporter/srcimporter.go
+++ b/src/go/internal/srcimporter/srcimporter.go
@@ -13,9 +13,9 @@ import (
        "go/parser"
        "go/token"
        "go/types"
+       exec "internal/execabs"
        "io"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
        "sync"

diff --git a/src/go/types/api.go b/src/go/types/api.go
index d6259598172035fdcbc966fdfc0725c2e35f0810..b5bbb2d97dc7ee383f6abcea5e0e220570e18ff5 100644 (file)
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -101,6 +101,13 @@ type ImporterFrom interface {
 // A Config specifies the configuration for type checking.
 // The zero value for Config is a ready-to-use default configuration.
 type Config struct {
+       // GoVersion describes the accepted Go language version. The string
+       // must follow the format "go%d.%d" (e.g. "go1.12") or it must be
+       // empty; an empty string indicates the latest language version.
+       // If the format is invalid, invoking the type checker will cause a
+       // panic.
+       GoVersion string
+
        // If IgnoreFuncBodies is set, function bodies are not
        // type-checked.
        IgnoreFuncBodies bool

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 75cebc98261124891abf04af07bf933f868ad6c8..dde451ee3cf76e70a96f892c9e0049a46726bfc0 100644 (file)
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -42,7 +42,7 @@ func mustTypecheck(t *testing.T, path, source string, info *Info) string {
        return pkg.Name()
 }
 
-func mayTypecheck(t *testing.T, path, source string, info *Info) string {
+func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error) {
        fset := token.NewFileSet()
        f, err := parser.ParseFile(fset, path, source, 0)
        if f == nil { // ignore errors unless f is nil
@@ -52,8 +52,8 @@ func mayTypecheck(t *testing.T, path, source string, info *Info) string {
                Error:    func(err error) {},
                Importer: importer.Default(),
        }
-       pkg, _ := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
-       return pkg.Name()
+       pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
+       return pkg.Name(), err
 }
 
 func TestValuesInfo(t *testing.T) {
@@ -175,6 +175,9 @@ func TestValuesInfo(t *testing.T) {
 }
 
 func TestTypesInfo(t *testing.T) {
+       // Test sources that are not expected to typecheck must start with the broken prefix.
+       const broken = "package broken_"
+
        var tests = []struct {
                src  string
                expr string // expression
@@ -187,6 +190,39 @@ func TestTypesInfo(t *testing.T) {
                {`package b3; var x interface{} = 0i`, `0i`, `complex128`},
                {`package b4; var x interface{} = "foo"`, `"foo"`, `string`},
 
+               // uses of nil
+               {`package n0; var _ *int = nil`, `nil`, `untyped nil`},
+               {`package n1; var _ func() = nil`, `nil`, `untyped nil`},
+               {`package n2; var _ []byte = nil`, `nil`, `untyped nil`},
+               {`package n3; var _ map[int]int = nil`, `nil`, `untyped nil`},
+               {`package n4; var _ chan int = nil`, `nil`, `untyped nil`},
+               {`package n5; var _ interface{} = nil`, `nil`, `untyped nil`},
+               {`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `untyped nil`},
+
+               {`package n10; var (x *int; _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n11; var (x func(); _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n12; var (x []byte; _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n14; var (x chan int; _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n15; var (x interface{}; _ = x == nil)`, `nil`, `untyped nil`},
+               {`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `untyped nil`},
+
+               {`package n20; var _ = (*int)(nil)`, `nil`, `untyped nil`},
+               {`package n21; var _ = (func())(nil)`, `nil`, `untyped nil`},
+               {`package n22; var _ = ([]byte)(nil)`, `nil`, `untyped nil`},
+               {`package n23; var _ = (map[int]int)(nil)`, `nil`, `untyped nil`},
+               {`package n24; var _ = (chan int)(nil)`, `nil`, `untyped nil`},
+               {`package n25; var _ = (interface{})(nil)`, `nil`, `untyped nil`},
+               {`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `untyped nil`},
+
+               {`package n30; func f(*int) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n31; func f(func()) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n32; func f([]byte) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n33; func f(map[int]int) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n34; func f(chan int) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n35; func f(interface{}) { f(nil) }`, `nil`, `untyped nil`},
+               {`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `untyped nil`},
+
                // comma-ok expressions
                {`package p0; var x interface{}; var _, _ = x.(int)`,
                        `x.(int)`,
@@ -268,17 +304,27 @@ func TestTypesInfo(t *testing.T) {
                },
 
                // tests for broken code that doesn't parse or type-check
-               {`package x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
-               {`package x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
-               {`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a; f: b;}}`, `b`, `string`},
-               {`package x3; var x = panic("");`, `panic`, `func(interface{})`},
+               {broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
+               {broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
+               {broken + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a; f: b;}}`, `b`, `string`},
+               {broken + `x3; var x = panic("");`, `panic`, `func(interface{})`},
                {`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
-               {`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+               {broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
        }
 
        for _, test := range tests {
                info := Info{Types: make(map[ast.Expr]TypeAndValue)}
-               name := mayTypecheck(t, "TypesInfo", test.src, &info)
+               var name string
+               if strings.HasPrefix(test.src, broken) {
+                       var err error
+                       name, err = mayTypecheck(t, "TypesInfo", test.src, &info)
+                       if err == nil {
+                               t.Errorf("package %s: expected to fail but passed", name)
+                               continue
+                       }
+               } else {
+                       name = mustTypecheck(t, "TypesInfo", test.src, &info)
+               }
 
                // look for expression type
                var typ Type

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index fd35f7867696d789b93999a04e285144d7d5b849..078ed4488d11b3aded9e8df7a050c65e6dbd70e8 100644 (file)
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -353,8 +353,8 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
                        return
                }
 
-               if ok, code := x.assignableTo(check, m.key, nil); !ok {
-                       check.invalidArg(x, code, "%s is not assignable to %s", x, m.key)
+               check.assignment(x, m.key, "argument to delete")
+               if x.mode == invalid {
                        return
                }
 

diff --git a/src/go/types/call.go b/src/go/types/call.go
index 992598d08ce578656c6a1ce3b188b8be1f30d1fd..6765b17bf340535f91f017a64fdf02caebebea84 100644 (file)
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -33,6 +33,10 @@ func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
                case 1:
                        check.expr(x, e.Args[0])
                        if x.mode != invalid {
+                               if e.Ellipsis.IsValid() {
+                                       check.errorf(e.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
+                                       break
+                               }
                                check.conversion(x, T)
                        }
                default:

diff --git a/src/go/types/check.go b/src/go/types/check.go
index 280792e838ef24bb62849c1b93904dc436770aba..3bc8ee067c2b1b516e98bbcfbc447b91c712fc9c 100644 (file)
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -8,6 +8,7 @@ package types
 
 import (
        "errors"
+       "fmt"
        "go/ast"
        "go/constant"
        "go/token"
@@ -69,6 +70,12 @@ type importKey struct {
        path, dir string
 }
 
+// A dotImportKey describes a dot-imported object in the given scope.
+type dotImportKey struct {
+       scope *Scope
+       obj   Object
+}
+
 // A Checker maintains the state of the type checker.
 // It must be created with NewChecker.
 type Checker struct {
@@ -78,16 +85,18 @@ type Checker struct {
        fset *token.FileSet
        pkg  *Package
        *Info
-       objMap map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
-       impMap map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
-       posMap map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
-       pkgCnt map[string]int             // counts number of imported packages with a given name (for better error messages)
+       version version                    // accepted language version
+       objMap  map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
+       impMap  map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
+       posMap  map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
+       pkgCnt  map[string]int             // counts number of imported packages with a given name (for better error messages)
 
        // information collected during type-checking of a set of package files
        // (initialized by Files, valid only for the duration of check.Files;
        // maps and lists are allocated on demand)
-       files            []*ast.File                             // package files
-       unusedDotImports map[*Scope]map[*Package]*ast.ImportSpec // unused dot-imported packages
+       files        []*ast.File               // package files
+       imports      []*PkgName                // list of imported packages
+       dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through
 
        firstErr error                 // first error encountered
        methods  map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
@@ -104,22 +113,6 @@ type Checker struct {
        indent int // indentation for tracing
 }
 
-// addUnusedImport adds the position of a dot-imported package
-// pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, spec *ast.ImportSpec) {
-       mm := check.unusedDotImports
-       if mm == nil {
-               mm = make(map[*Scope]map[*Package]*ast.ImportSpec)
-               check.unusedDotImports = mm
-       }
-       m := mm[scope]
-       if m == nil {
-               m = make(map[*Package]*ast.ImportSpec)
-               mm[scope] = m
-       }
-       m[pkg] = spec
-}
-
 // addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
 func (check *Checker) addDeclDep(to Object) {
        from := check.decl
@@ -185,15 +178,21 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
                info = new(Info)
        }
 
+       version, err := parseGoVersion(conf.GoVersion)
+       if err != nil {
+               panic(fmt.Sprintf("invalid Go version %q (%v)", conf.GoVersion, err))
+       }
+
        return &Checker{
-               conf:   conf,
-               fset:   fset,
-               pkg:    pkg,
-               Info:   info,
-               objMap: make(map[Object]*declInfo),
-               impMap: make(map[importKey]*Package),
-               posMap: make(map[*Interface][]token.Pos),
-               pkgCnt: make(map[string]int),
+               conf:    conf,
+               fset:    fset,
+               pkg:     pkg,
+               Info:    info,
+               version: version,
+               objMap:  make(map[Object]*declInfo),
+               impMap:  make(map[importKey]*Package),
+               posMap:  make(map[*Interface][]token.Pos),
+               pkgCnt:  make(map[string]int),
        }
 }
 
@@ -202,7 +201,8 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 func (check *Checker) initFiles(files []*ast.File) {
        // start with a clean slate (check.Files may be called multiple times)
        check.files = nil
-       check.unusedDotImports = nil
+       check.imports = nil
+       check.dotImportMap = nil
 
        check.firstErr = nil
        check.methods = nil
@@ -272,10 +272,16 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
        if !check.conf.DisableUnusedImportCheck {
                check.unusedImports()
        }
+       // no longer needed - release memory
+       check.imports = nil
+       check.dotImportMap = nil
 
        check.recordUntyped()
 
        check.pkg.complete = true
+
+       // TODO(rFindley) There's more memory we should release at this point.
+
        return
 }
 

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index ce31dab68bb18067c453d555e26f99654761696f..ca7d926ca903990bf941af6371a7a6d86cd9b2d8 100644 (file)
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -27,12 +27,14 @@ package types_test
 
 import (
        "flag"
+       "fmt"
        "go/ast"
        "go/importer"
        "go/parser"
        "go/scanner"
        "go/token"
        "internal/testenv"
+       "io/ioutil"
        "os"
        "path/filepath"
        "regexp"
@@ -45,57 +47,10 @@ import (
 var (
        haltOnError = flag.Bool("halt", false, "halt on error")
        listErrors  = flag.Bool("errlist", false, "list errors")
-       testFiles   = flag.String("files", "", "space-separated list of test files")
+       testFiles   = flag.String("files", "", "comma-separated list of test files")
+       goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\"")
 )
 
-// The test filenames do not end in .go so that they are invisible
-// to gofmt since they contain comments that must not change their
-// positions relative to surrounding tokens.
-
-// Each tests entry is list of files belonging to the same package.
-var tests = [][]string{
-       {"testdata/errors.src"},
-       {"testdata/importdecl0a.src", "testdata/importdecl0b.src"},
-       {"testdata/importdecl1a.src", "testdata/importdecl1b.src"},
-       {"testdata/importC.src"}, // special handling in checkFiles
-       {"testdata/cycles.src"},
-       {"testdata/cycles1.src"},
-       {"testdata/cycles2.src"},
-       {"testdata/cycles3.src"},
-       {"testdata/cycles4.src"},
-       {"testdata/cycles5.src"},
-       {"testdata/init0.src"},
-       {"testdata/init1.src"},
-       {"testdata/init2.src"},
-       {"testdata/decls0.src"},
-       {"testdata/decls1.src"},
-       {"testdata/decls2a.src", "testdata/decls2b.src"},
-       {"testdata/decls3.src"},
-       {"testdata/decls4.src"},
-       {"testdata/decls5.src"},
-       {"testdata/const0.src"},
-       {"testdata/const1.src"},
-       {"testdata/constdecl.src"},
-       {"testdata/vardecl.src"},
-       {"testdata/expr0.src"},
-       {"testdata/expr1.src"},
-       {"testdata/expr2.src"},
-       {"testdata/expr3.src"},
-       {"testdata/methodsets.src"},
-       {"testdata/shifts.src"},
-       {"testdata/builtins.src"},
-       {"testdata/conversions.src"},
-       {"testdata/conversions2.src"},
-       {"testdata/stmt0.src"},
-       {"testdata/stmt1.src"},
-       {"testdata/gotos.src"},
-       {"testdata/labels.src"},
-       {"testdata/literals.src"},
-       {"testdata/issues.src"},
-       {"testdata/blank.src"},
-       {"testdata/issue25008b.src", "testdata/issue25008a.src"}, // order (b before a) is crucial!
-}
-
 var fset = token.NewFileSet()
 
 // Positioned errors are of the form filename:line:column: message .
@@ -114,11 +69,11 @@ func splitError(err error) (pos, msg string) {
        return
 }
 
-func parseFiles(t *testing.T, filenames []string) ([]*ast.File, []error) {
+func parseFiles(t *testing.T, filenames []string, srcs [][]byte) ([]*ast.File, []error) {
        var files []*ast.File
        var errlist []error
-       for _, filename := range filenames {
-               file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
+       for i, filename := range filenames {
+               file, err := parser.ParseFile(fset, filename, srcs[i], parser.AllErrors)
                if file == nil {
                        t.Fatalf("%s: %s", filename, err)
                }
@@ -147,19 +102,17 @@ var errRx = regexp.MustCompile(`^ *ERROR *(HERE)? *"?([^"]*)"?`)
 // errMap collects the regular expressions of ERROR comments found
 // in files and returns them as a map of error positions to error messages.
 //
-func errMap(t *testing.T, testname string, files []*ast.File) map[string][]string {
+// srcs must be a slice of the same length as files, containing the original
+// source for the parsed AST.
+func errMap(t *testing.T, files []*ast.File, srcs [][]byte) map[string][]string {
        // map of position strings to lists of error message patterns
        errmap := make(map[string][]string)
 
-       for _, file := range files {
-               filename := fset.Position(file.Package).Filename
-               src, err := os.ReadFile(filename)
-               if err != nil {
-                       t.Fatalf("%s: could not read %s", testname, filename)
-               }
-
+       for i, file := range files {
+               tok := fset.File(file.Package)
+               src := srcs[i]
                var s scanner.Scanner
-               s.Init(fset.AddFile(filename, -1, len(src)), src, nil, scanner.ScanComments)
+               s.Init(tok, src, nil, scanner.ScanComments)
                var prev token.Pos // position of last non-comment, non-semicolon token
                var here token.Pos // position immediately after the token at position prev
 
@@ -236,15 +189,38 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
        }
 }
 
-func checkFiles(t *testing.T, testfiles []string) {
+// goVersionRx matches a Go version string using '_', e.g. "go1_12".
+var goVersionRx = regexp.MustCompile(`^go[1-9][0-9]*_(0|[1-9][0-9]*)$`)
+
+// asGoVersion returns a regular Go language version string
+// if s is a Go version string using '_' rather than '.' to
+// separate the major and minor version numbers (e.g. "go1_12").
+// Otherwise it returns the empty string.
+func asGoVersion(s string) string {
+       if goVersionRx.MatchString(s) {
+               return strings.Replace(s, "_", ".", 1)
+       }
+       return ""
+}
+
+func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byte) {
+       if len(filenames) == 0 {
+               t.Fatal("no source files")
+       }
+
        // parse files and collect parser errors
-       files, errlist := parseFiles(t, testfiles)
+       files, errlist := parseFiles(t, filenames, srcs)
 
        pkgName := "<no package>"
        if len(files) > 0 {
                pkgName = files[0].Name.Name
        }
 
+       // if no Go version is given, consider the package name
+       if goVersion == "" {
+               goVersion = asGoVersion(pkgName)
+       }
+
        if *listErrors && len(errlist) > 0 {
                t.Errorf("--- %s:", pkgName)
                for _, err := range errlist {
@@ -254,10 +230,15 @@ func checkFiles(t *testing.T, testfiles []string) {
 
        // typecheck and collect typechecker errors
        var conf Config
+       conf.GoVersion = goVersion
+
        // special case for importC.src
-       if len(testfiles) == 1 && strings.HasSuffix(testfiles[0], "importC.src") {
-               conf.FakeImportC = true
+       if len(filenames) == 1 {
+               if strings.HasSuffix(filenames[0], "importC.src") {
+                       conf.FakeImportC = true
+               }
        }
+
        conf.Importer = importer.Default()
        conf.Error = func(err error) {
                if *haltOnError {
@@ -292,7 +273,7 @@ func checkFiles(t *testing.T, testfiles []string) {
 
        // match and eliminate errors;
        // we are expecting the following errors
-       errmap := errMap(t, pkgName, files)
+       errmap := errMap(t, files, srcs)
        eliminate(t, errmap, errlist)
 
        // there should be no expected errors left
@@ -306,44 +287,66 @@ func checkFiles(t *testing.T, testfiles []string) {
        }
 }
 
+// TestCheck is for manual testing of selected input files, provided with -files.
+// The accepted Go language version can be controlled with the -lang flag.
 func TestCheck(t *testing.T) {
-       testenv.MustHaveGoBuild(t)
-
-       // Declare builtins for testing.
-       DefPredeclaredTestFuncs()
-
-       // If explicit test files are specified, only check those.
-       if files := *testFiles; files != "" {
-               checkFiles(t, strings.Split(files, " "))
+       if *testFiles == "" {
                return
        }
+       testenv.MustHaveGoBuild(t)
+       DefPredeclaredTestFuncs()
+       testPkg(t, strings.Split(*testFiles, ","), *goVersion)
+}
 
-       // Otherwise, run all the tests.
-       for _, files := range tests {
-               checkFiles(t, files)
-       }
+func TestLongConstants(t *testing.T) {
+       format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
+       src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
+       checkFiles(t, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
 }
 
-func TestFixedBugs(t *testing.T) { testDir(t, "fixedbugs") }
+func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
+func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
 
 func testDir(t *testing.T, dir string) {
        testenv.MustHaveGoBuild(t)
 
-       dirs, err := os.ReadDir(dir)
+       fis, err := os.ReadDir(dir)
        if err != nil {
-               t.Fatal(err)
+               t.Error(err)
+               return
        }
 
-       for _, d := range dirs {
-               testname := filepath.Base(d.Name())
-               testname = strings.TrimSuffix(testname, filepath.Ext(testname))
-               t.Run(testname, func(t *testing.T) {
-                       filename := filepath.Join(dir, d.Name())
-                       if d.IsDir() {
-                               t.Errorf("skipped directory %q", filename)
-                               return
+       for _, fi := range fis {
+               path := filepath.Join(dir, fi.Name())
+
+               // if fi is a directory, its files make up a single package
+               var filenames []string
+               if fi.IsDir() {
+                       fis, err := ioutil.ReadDir(path)
+                       if err != nil {
+                               t.Error(err)
+                               continue
                        }
-                       checkFiles(t, []string{filename})
+                       for _, fi := range fis {
+                               filenames = append(filenames, filepath.Join(path, fi.Name()))
+                       }
+               } else {
+                       filenames = []string{path}
+               }
+               t.Run(filepath.Base(path), func(t *testing.T) {
+                       testPkg(t, filenames, "")
                })
        }
 }
+
+func testPkg(t *testing.T, filenames []string, goVersion string) {
+       srcs := make([][]byte, len(filenames))
+       for i, filename := range filenames {
+               src, err := os.ReadFile(filename)
+               if err != nil {
+                       t.Fatalf("could not read %s: %v", filename, err)
+               }
+               srcs[i] = src
+       }
+       checkFiles(t, goVersion, filenames, srcs)
+}

diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 1cab1cc70f0e8bfc4206422136b1f5cb65b9f66a..c634d27aa9499ea402ace950cf6813149b793580 100644 (file)
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -55,8 +55,8 @@ func (check *Checker) conversion(x *operand, T Type) {
                // - Keep untyped nil for untyped nil arguments.
                // - For integer to string conversions, keep the argument type.
                //   (See also the TODO below.)
-               if IsInterface(T) || constArg && !isConstType(T) {
-                       final = Default(x.typ)
+               if IsInterface(T) || constArg && !isConstType(T) || x.isNil() {
+                       final = Default(x.typ) // default type of untyped nil is untyped nil
                } else if isInteger(x.typ) && isString(T) {
                        final = x.typ
                }

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 1f0bc358a26e9ace5e0c3dcf396eaaf6079e2646..6462edbd75e3e63eac8f25653eb1e3fdaea4b2ad 100644 (file)
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -189,7 +189,7 @@ func (check *Checker) objDecl(obj Object, def *Named) {
                check.varDecl(obj, d.lhs, d.typ, d.init)
        case *TypeName:
                // invalid recursive types are detected via path
-               check.typeDecl(obj, d.typ, def, d.alias)
+               check.typeDecl(obj, d.typ, def, d.aliasPos)
        case *Func:
                // functions may be recursive - no need to track dependencies
                check.funcDecl(obj, d)
@@ -234,7 +234,7 @@ func (check *Checker) cycle(obj Object) (isCycle bool) {
                        // this information explicitly in the object.
                        var alias bool
                        if d := check.objMap[obj]; d != nil {
-                               alias = d.alias // package-level object
+                               alias = d.aliasPos.IsValid() // package-level object
                        } else {
                                alias = obj.IsAlias() // function local object
                        }
@@ -626,14 +626,17 @@ func (n *Named) setUnderlying(typ Type) {
        }
 }
 
-func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bool) {
+func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, aliasPos token.Pos) {
        assert(obj.typ == nil)
 
        check.later(func() {
                check.validType(obj.typ, nil)
        })
 
-       if alias {
+       if aliasPos.IsValid() {
+               if !check.allowVersion(obj.pkg, 1, 9) {
+                       check.errorf(atPos(aliasPos), _BadDecl, "type aliases requires go1.9 or later")
+               }
 
                obj.typ = Typ[Invalid]
                obj.typ = check.typ(typ)
@@ -664,9 +667,12 @@ func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bo
 
        }
 
+       // TODO(rFindley): move to the callsite, as this is only needed for top-level
+       //                 decls.
        check.addMethodDecls(obj)
 }
 
+// TODO(rFindley): rename to collectMethods, to be consistent with types2.
 func (check *Checker) addMethodDecls(obj *TypeName) {
        // get associated methods
        // (Checker.collectObjects only collects methods with non-blank names;
@@ -677,7 +683,7 @@ func (check *Checker) addMethodDecls(obj *TypeName) {
                return
        }
        delete(check.methods, obj)
-       assert(!check.objMap[obj].alias) // don't use TypeName.IsAlias (requires fully set up object)
+       assert(!check.objMap[obj].aliasPos.IsValid()) // don't use TypeName.IsAlias (requires fully set up object)
 
        // use an objset to check for name conflicts
        var mset objset
@@ -737,8 +743,12 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
        obj.typ = sig // guard against cycles
        fdecl := decl.fdecl
        check.funcType(sig, fdecl.Recv, fdecl.Type)
-       if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
-               check.errorf(fdecl, _InvalidInitSig, "func init must have no arguments and no return values")
+       if sig.recv == nil {
+               if obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
+                       check.errorf(fdecl, _InvalidInitDecl, "func init must have no arguments and no return values")
+               } else if obj.name == "main" && check.pkg.name == "main" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
+                       check.errorf(fdecl, _InvalidMainDecl, "func main must have no arguments and no return values")
+               }
                // ok to continue
        }
 
@@ -846,7 +856,7 @@ func (check *Checker) declStmt(d ast.Decl) {
                        check.declare(check.scope, d.spec.Name, obj, scopePos)
                        // mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
                        obj.setColor(grey + color(check.push(obj)))
-                       check.typeDecl(obj, d.spec.Type, nil, d.spec.Assign.IsValid())
+                       check.typeDecl(obj, d.spec.Type, nil, d.spec.Assign)
                        check.pop().setColor(black)
                default:
                        check.invalidAST(d.node(), "unknown ast.Decl node %T", d.node())

diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index e4c8311d62e42b2491647b00fb53a3568bef0371..ac28c3bd13443d65e3db53b41086a92e5751f315 100644 (file)
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -386,8 +386,8 @@ const (
        // _InvalidInitSig occurs when an init function declares parameters or
        // results.
        //
-       // Example:
-       //  func init() int { return 1 }
+       // Deprecated: no longer emitted by the type checker. _InvalidInitDecl is
+       // used instead.
        _InvalidInitSig
 
        // _InvalidInitDecl occurs when init is declared as anything other than a
@@ -395,6 +395,9 @@ const (
        //
        // Example:
        //  var init = 1
+       //
+       // Example:
+       //  func init() int { return 1 }
        _InvalidInitDecl
 
        // _InvalidMainDecl occurs when main is declared as anything other than a
@@ -1207,6 +1210,16 @@ const (
        //  }
        _InvalidTypeSwitch
 
+       // _InvalidExprSwitch occurs when a switch expression is not comparable.
+       //
+       // Example:
+       //  func _() {
+       //      var a struct{ _ func() }
+       //      switch a /* ERROR cannot switch on a */ {
+       //      }
+       //  }
+       _InvalidExprSwitch
+
        /* control flow > select */
 
        // _InvalidSelectCase occurs when a select case is not a channel send or
@@ -1353,4 +1366,7 @@ const (
        //      return i
        //  }
        _InvalidGo
+
+       // _BadDecl occurs when a declaration has invalid syntax.
+       _BadDecl
 )

diff --git a/src/go/types/eval_test.go b/src/go/types/eval_test.go
index d940bf0e80a9cb89956badca19249e2798dd88ae..3a97ac0471620fe3a835dadfdab3ad1425e830cb 100644 (file)
--- a/src/go/types/eval_test.go
+++ b/src/go/types/eval_test.go
@@ -76,7 +76,7 @@ func TestEvalArith(t *testing.T) {
                `false == false`,
                `12345678 + 87654321 == 99999999`,
                `10 * 20 == 200`,
-               `(1<<1000)*2 >> 100 == 2<<900`,
+               `(1<<500)*2 >> 100 == 2<<400`,
                `"foo" + "bar" == "foobar"`,
                `"abc" <= "bcd"`,
                `len([10]struct{}{}) == 2*5`,

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index eb2056125a7b71aecf3efb362cd98ec5146a09a1..aec3172327877b0e6905bc7a1d462b5907229b0c 100644 (file)
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -78,13 +78,77 @@ func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
        return true
 }
 
+// overflow checks that the constant x is representable by its type.
+// For untyped constants, it checks that the value doesn't become
+// arbitrarily large.
+func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
+       assert(x.mode == constant_)
+
+       if x.val.Kind() == constant.Unknown {
+               // TODO(gri) We should report exactly what went wrong. At the
+               //           moment we don't have the (go/constant) API for that.
+               //           See also TODO in go/constant/value.go.
+               check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
+               return
+       }
+
+       // Typed constants must be representable in
+       // their type after each constant operation.
+       if typ, ok := x.typ.Underlying().(*Basic); ok && isTyped(typ) {
+               check.representable(x, typ)
+               return
+       }
+
+       // Untyped integer values must not grow arbitrarily.
+       const prec = 512 // 512 is the constant precision
+       if x.val.Kind() == constant.Int && constant.BitLen(x.val) > prec {
+               check.errorf(atPos(opPos), _InvalidConstVal, "constant %s overflow", opName(x.expr))
+               x.val = constant.MakeUnknown()
+       }
+}
+
+// opName returns the name of an operation, or the empty string.
+// For now, only operations that might overflow are handled.
+// TODO(gri) Expand this to a general mechanism giving names to
+//           nodes?
+func opName(e ast.Expr) string {
+       switch e := e.(type) {
+       case *ast.BinaryExpr:
+               if int(e.Op) < len(op2str2) {
+                       return op2str2[e.Op]
+               }
+       case *ast.UnaryExpr:
+               if int(e.Op) < len(op2str1) {
+                       return op2str1[e.Op]
+               }
+       }
+       return ""
+}
+
+var op2str1 = [...]string{
+       token.XOR: "bitwise complement",
+}
+
+// This is only used for operations that may cause overflow.
+var op2str2 = [...]string{
+       token.ADD: "addition",
+       token.SUB: "subtraction",
+       token.XOR: "bitwise XOR",
+       token.MUL: "multiplication",
+       token.SHL: "shift",
+}
+
 // The unary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
-       switch op {
+func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
+       check.expr(x, e.X)
+       if x.mode == invalid {
+               return
+       }
+       switch e.Op {
        case token.AND:
                // spec: "As an exception to the addressability
                // requirement x may also be a composite literal."
-               if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable {
+               if _, ok := unparen(e.X).(*ast.CompositeLit); !ok && x.mode != variable {
                        check.invalidOp(x, _UnaddressableOperand, "cannot take address of %s", x)
                        x.mode = invalid
                        return
@@ -111,26 +175,23 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
                return
        }
 
-       if !check.op(unaryOpPredicates, x, op) {
+       if !check.op(unaryOpPredicates, x, e.Op) {
                x.mode = invalid
                return
        }
 
        if x.mode == constant_ {
-               typ := x.typ.Underlying().(*Basic)
-               var prec uint
-               if isUnsigned(typ) {
-                       prec = uint(check.conf.sizeof(typ) * 8)
+               if x.val.Kind() == constant.Unknown {
+                       // nothing to do (and don't cause an error below in the overflow check)
+                       return
                }
-               x.val = constant.UnaryOp(op, x.val, prec)
-               // Typed constants must be representable in
-               // their type after each constant operation.
-               if isTyped(typ) {
-                       if e != nil {
-                               x.expr = e // for better error message
-                       }
-                       check.representable(x, typ)
+               var prec uint
+               if isUnsigned(x.typ) {
+                       prec = uint(check.conf.sizeof(x.typ) * 8)
                }
+               x.val = constant.UnaryOp(e.Op, x.val, prec)
+               x.expr = e
+               check.overflow(x, e.Op, x.Pos())
                return
        }
 
@@ -579,6 +640,8 @@ func (check *Checker) implicitType(x *operand, target Type) Type {
                        if !hasNil(target) {
                                return nil
                        }
+                       // Preserve the type of nil as UntypedNil: see #13061.
+                       return Typ[UntypedNil]
                default:
                        return nil
                }
@@ -665,15 +728,16 @@ func (check *Checker) comparison(x, y *operand, op token.Token) {
        x.typ = Typ[UntypedBool]
 }
 
-func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
-       untypedx := isUntyped(x.typ)
+// If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
+func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
+       // TODO(gri) This function seems overly complex. Revisit.
 
        var xval constant.Value
        if x.mode == constant_ {
                xval = constant.ToInt(x.val)
        }
 
-       if isInteger(x.typ) || untypedx && xval != nil && xval.Kind() == constant.Int {
+       if isInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int {
                // The lhs is of integer type or an untyped constant representable
                // as an integer. Nothing to do.
        } else {
@@ -685,19 +749,33 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
 
        // spec: "The right operand in a shift expression must have integer type
        // or be an untyped constant representable by a value of type uint."
-       switch {
-       case isInteger(y.typ):
-               // nothing to do
-       case isUntyped(y.typ):
+
+       // Provide a good error message for negative shift counts.
+       if y.mode == constant_ {
+               yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
+               if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
+                       check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
+                       x.mode = invalid
+                       return
+               }
+       }
+
+       // Caution: Check for isUntyped first because isInteger includes untyped
+       //          integers (was bug #43697).
+       if isUntyped(y.typ) {
                check.convertUntyped(y, Typ[Uint])
                if y.mode == invalid {
                        x.mode = invalid
                        return
                }
-       default:
+       } else if !isInteger(y.typ) {
                check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
                x.mode = invalid
                return
+       } else if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
+               check.invalidOp(y, _InvalidShiftCount, "signed shift count %s requires go1.13 or later", y)
+               x.mode = invalid
+               return
        }
 
        var yval constant.Value
@@ -716,8 +794,17 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
 
        if x.mode == constant_ {
                if y.mode == constant_ {
+                       // if either x or y has an unknown value, the result is unknown
+                       if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+                               x.val = constant.MakeUnknown()
+                               // ensure the correct type - see comment below
+                               if !isInteger(x.typ) {
+                                       x.typ = Typ[UntypedInt]
+                               }
+                               return
+                       }
                        // rhs must be within reasonable bounds in constant shifts
-                       const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
+                       const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
                        s, ok := constant.Uint64Val(yval)
                        if !ok || s > shiftBound {
                                check.invalidOp(y, _InvalidShiftCount, "invalid shift count %s", y)
@@ -733,19 +820,17 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
                        }
                        // x is a constant so xval != nil and it must be of Int kind.
                        x.val = constant.Shift(xval, op, uint(s))
-                       // Typed constants must be representable in
-                       // their type after each constant operation.
-                       if isTyped(x.typ) {
-                               if e != nil {
-                                       x.expr = e // for better error message
-                               }
-                               check.representable(x, x.typ.Underlying().(*Basic))
+                       x.expr = e
+                       opPos := x.Pos()
+                       if b, _ := e.(*ast.BinaryExpr); b != nil {
+                               opPos = b.OpPos
                        }
+                       check.overflow(x, op, opPos)
                        return
                }
 
                // non-constant shift with constant lhs
-               if untypedx {
+               if isUntyped(x.typ) {
                        // spec: "If the left operand of a non-constant shift
                        // expression is an untyped constant, the type of the
                        // constant is what it would be if the shift expression
@@ -801,8 +886,9 @@ var binaryOpPredicates = opPredicates{
        token.LOR:  isBoolean,
 }
 
-// The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
+// If e != nil, it must be the binary expression; it may be nil for non-constant expressions
+// (when invoked for an assignment operation where the binary expression is implicit).
+func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
        var y operand
 
        check.expr(x, lhs)
@@ -877,30 +963,19 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o
        }
 
        if x.mode == constant_ && y.mode == constant_ {
-               xval := x.val
-               yval := y.val
-               typ := x.typ.Underlying().(*Basic)
+               // if either x or y has an unknown value, the result is unknown
+               if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+                       x.val = constant.MakeUnknown()
+                       // x.typ is unchanged
+                       return
+               }
                // force integer division of integer operands
-               if op == token.QUO && isInteger(typ) {
+               if op == token.QUO && isInteger(x.typ) {
                        op = token.QUO_ASSIGN
                }
-               x.val = constant.BinaryOp(xval, op, yval)
-               // report error if valid operands lead to an invalid result
-               if xval.Kind() != constant.Unknown && yval.Kind() != constant.Unknown && x.val.Kind() == constant.Unknown {
-                       // TODO(gri) We should report exactly what went wrong. At the
-                       //           moment we don't have the (go/constant) API for that.
-                       //           See also TODO in go/constant/value.go.
-                       check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
-                       // TODO(gri) Should we mark operands with unknown values as invalid?
-               }
-               // Typed constants must be representable in
-               // their type after each constant operation.
-               if isTyped(typ) {
-                       if e != nil {
-                               x.expr = e // for better error message
-                       }
-                       check.representable(x, typ)
-               }
+               x.val = constant.BinaryOp(x.val, op, y.val)
+               x.expr = e
+               check.overflow(x, op, opPos)
                return
        }
 
@@ -1079,6 +1154,24 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
                goto Error
 
        case *ast.BasicLit:
+               switch e.Kind {
+               case token.INT, token.FLOAT, token.IMAG:
+                       check.langCompat(e)
+                       // The max. mantissa precision for untyped numeric values
+                       // is 512 bits, or 4048 bits for each of the two integer
+                       // parts of a fraction for floating-point numbers that are
+                       // represented accurately in the go/constant package.
+                       // Constant literals that are longer than this many bits
+                       // are not meaningful; and excessively long constants may
+                       // consume a lot of space and time for a useless conversion.
+                       // Cap constant length with a generous upper limit that also
+                       // allows for separators between all digits.
+                       const limit = 10000
+                       if len(e.Value) > limit {
+                               check.errorf(e, _InvalidConstVal, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value))
+                               goto Error
+                       }
+               }
                x.setConst(e.Kind, e.Value)
                if x.mode == invalid {
                        // The parser already establishes syntactic correctness.
@@ -1536,11 +1629,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
                }
 
        case *ast.UnaryExpr:
-               check.expr(x, e.X)
-               if x.mode == invalid {
-                       goto Error
-               }
-               check.unary(x, e, e.Op)
+               check.unary(x, e)
                if x.mode == invalid {
                        goto Error
                }

diff --git a/src/go/types/fixedbugs/issue43110.src b/src/go/types/fixedbugs/issue43110.src
new file mode 100644 (file)
index 0000000..4a46945
--- /dev/null
+++ b/src/go/types/fixedbugs/issue43110.src
@@ -0,0 +1,43 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+type P *struct{}
+
+func _() {
+       // want an error even if the switch is empty
+       var a struct{ _ func() }
+       switch a /* ERROR cannot switch on a */ {
+       }
+
+       switch a /* ERROR cannot switch on a */ {
+       case a: // no follow-on error here
+       }
+
+       // this is ok because f can be compared to nil
+       var f func()
+       switch f {
+       }
+
+       switch f {
+       case nil:
+       }
+
+       switch (func())(nil) {
+       case nil:
+       }
+
+       switch (func())(nil) {
+       case f /* ERROR cannot compare */ :
+       }
+
+       switch nil /* ERROR use of untyped nil in switch expression */ {
+       }
+
+       // this is ok
+       switch P(nil) {
+       case P(nil):
+       }
+}

diff --git a/src/go/types/fixedbugs/issue43124.src b/src/go/types/fixedbugs/issue43124.src
new file mode 100644 (file)
index 0000000..f429f74
--- /dev/null
+++ b/src/go/types/fixedbugs/issue43124.src
@@ -0,0 +1,16 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+var _ = int(0 /* ERROR invalid use of \.\.\. in conversion to int */ ...)
+
+// test case from issue
+
+type M []string
+
+var (
+       x = []string{"a", "b"}
+       _ = M(x /* ERROR invalid use of \.\.\. in conversion to M */ ...)
+)

diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 148edbfb767a47d642077d1dbe2c42ed692779f4..954a7ca987a8f554c79264dae3b6da8905405db2 100644 (file)
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -6,8 +6,6 @@
 
 package types
 
-import "sort"
-
 func isNamed(typ Type) bool {
        if _, ok := typ.(*Basic); ok {
                return ok
@@ -273,8 +271,8 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
                                        p = p.prev
                                }
                                if debug {
-                                       assert(sort.IsSorted(byUniqueMethodName(a)))
-                                       assert(sort.IsSorted(byUniqueMethodName(b)))
+                                       assertSortedMethods(a)
+                                       assertSortedMethods(b)
                                }
                                for i, f := range a {
                                        g := b[i]

diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index b637f8b8cacf75793f564660081bc0c741daab1f..e4411592e82a0ae6c77ce570d8106a7828ceb155 100644 (file)
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -23,7 +23,7 @@ type declInfo struct {
        init      ast.Expr      // init/orig expression, or nil
        inherited bool          // if set, the init expression is inherited from a previous constant declaration
        fdecl     *ast.FuncDecl // func declaration, or nil
-       alias     bool          // type alias declaration
+       aliasPos  token.Pos     // If valid, the decl is a type alias and aliasPos is the position of '='.
 
        // The deps field tracks initialization expression dependencies.
        deps map[Object]bool // lazily initialized
@@ -252,14 +252,6 @@ func (check *Checker) collectObjects() {
                                        return
                                }
 
-                               // add package to list of explicit imports
-                               // (this functionality is provided as a convenience
-                               // for clients; it is not needed for type-checking)
-                               if !pkgImports[imp] {
-                                       pkgImports[imp] = true
-                                       pkg.imports = append(pkg.imports, imp)
-                               }
-
                                // local name overrides imported package name
                                name := imp.name
                                if d.spec.Name != nil {
@@ -269,27 +261,41 @@ func (check *Checker) collectObjects() {
                                                check.errorf(d.spec.Name, _ImportCRenamed, `cannot rename import "C"`)
                                                return
                                        }
-                                       if name == "init" {
-                                               check.errorf(d.spec.Name, _InvalidInitDecl, "cannot declare init - must be func")
-                                               return
-                                       }
                                }
 
-                               obj := NewPkgName(d.spec.Pos(), pkg, name, imp)
+                               if name == "init" {
+                                       check.errorf(d.spec.Name, _InvalidInitDecl, "cannot import package as init - init must be a func")
+                                       return
+                               }
+
+                               // add package to list of explicit imports
+                               // (this functionality is provided as a convenience
+                               // for clients; it is not needed for type-checking)
+                               if !pkgImports[imp] {
+                                       pkgImports[imp] = true
+                                       pkg.imports = append(pkg.imports, imp)
+                               }
+
+                               pkgName := NewPkgName(d.spec.Pos(), pkg, name, imp)
                                if d.spec.Name != nil {
                                        // in a dot-import, the dot represents the package
-                                       check.recordDef(d.spec.Name, obj)
+                                       check.recordDef(d.spec.Name, pkgName)
                                } else {
-                                       check.recordImplicit(d.spec, obj)
+                                       check.recordImplicit(d.spec, pkgName)
                                }
 
                                if path == "C" {
                                        // match cmd/compile (not prescribed by spec)
-                                       obj.used = true
+                                       pkgName.used = true
                                }
 
                                // add import to file scope
+                               check.imports = append(check.imports, pkgName)
                                if name == "." {
+                                       // dot-import
+                                       if check.dotImportMap == nil {
+                                               check.dotImportMap = make(map[dotImportKey]*PkgName)
+                                       }
                                        // merge imported scope with file scope
                                        for _, obj := range imp.scope.elems {
                                                // A package scope may contain non-exported objects,
@@ -303,16 +309,15 @@ func (check *Checker) collectObjects() {
                                                        if alt := fileScope.Insert(obj); alt != nil {
                                                                check.errorf(d.spec.Name, _DuplicateDecl, "%s redeclared in this block", obj.Name())
                                                                check.reportAltDecl(alt)
+                                                       } else {
+                                                               check.dotImportMap[dotImportKey{fileScope, obj}] = pkgName
                                                        }
                                                }
                                        }
-                                       // add position to set of dot-import positions for this file
-                                       // (this is only needed for "imported but not used" errors)
-                                       check.addUnusedDotImport(fileScope, imp, d.spec)
                                } else {
                                        // declare imported package object in file scope
                                        // (no need to provide s.Name since we called check.recordDef earlier)
-                                       check.declare(fileScope, nil, obj, token.NoPos)
+                                       check.declare(fileScope, nil, pkgName, token.NoPos)
                                }
                        case constDecl:
                                // declare all constants
@@ -361,7 +366,7 @@ func (check *Checker) collectObjects() {
                                }
                        case typeDecl:
                                obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
-                               check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, typ: d.spec.Type, alias: d.spec.Assign.IsValid()})
+                               check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, typ: d.spec.Type, aliasPos: d.spec.Assign})
                        case funcDecl:
                                info := &declInfo{file: fileScope, fdecl: d.decl}
                                name := d.decl.Name.Name
@@ -488,7 +493,7 @@ func (check *Checker) resolveBaseTypeName(typ ast.Expr) (ptr bool, base *TypeNam
                // we're done if tdecl defined tname as a new type
                // (rather than an alias)
                tdecl := check.objMap[tname] // must exist for objects in package scope
-               if !tdecl.alias {
+               if !tdecl.aliasPos.IsValid() {
                        return ptr, tname
                }
 
@@ -529,7 +534,7 @@ func (check *Checker) packageObjects() {
        // phase 1
        for _, obj := range objList {
                // If we have a type alias, collect it for the 2nd phase.
-               if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].alias {
+               if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].aliasPos.IsValid() {
                        aliasList = append(aliasList, tname)
                        continue
                }
@@ -566,39 +571,30 @@ func (check *Checker) unusedImports() {
        // any of its exported identifiers. To import a package solely for its side-effects
        // (initialization), use the blank identifier as explicit package name."
 
-       // check use of regular imported packages
-       for _, scope := range check.pkg.scope.children /* file scopes */ {
-               for _, obj := range scope.elems {
-                       if obj, ok := obj.(*PkgName); ok {
-                               // Unused "blank imports" are automatically ignored
-                               // since _ identifiers are not entered into scopes.
-                               if !obj.used {
-                                       path := obj.imported.path
-                                       base := pkgName(path)
-                                       if obj.name == base {
-                                               check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
-                                       } else {
-                                               check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
-                                       }
-                               }
-                       }
-               }
-       }
-
-       // check use of dot-imported packages
-       for _, unusedDotImports := range check.unusedDotImports {
-               for pkg, pos := range unusedDotImports {
-                       check.softErrorf(pos, _UnusedImport, "%q imported but not used", pkg.path)
+       for _, obj := range check.imports {
+               if !obj.used && obj.name != "_" {
+                       check.errorUnusedPkg(obj)
                }
        }
 }
 
-// pkgName returns the package name (last element) of an import path.
-func pkgName(path string) string {
-       if i := strings.LastIndex(path, "/"); i >= 0 {
-               path = path[i+1:]
+func (check *Checker) errorUnusedPkg(obj *PkgName) {
+       // If the package was imported with a name other than the final
+       // import path element, show it explicitly in the error message.
+       // Note that this handles both renamed imports and imports of
+       // packages containing unconventional package declarations.
+       // Note that this uses / always, even on Windows, because Go import
+       // paths always use forward slashes.
+       path := obj.imported.path
+       elem := path
+       if i := strings.LastIndex(elem, "/"); i >= 0 {
+               elem = elem[i+1:]
+       }
+       if obj.name == "" || obj.name == "." || obj.name == elem {
+               check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
+       } else {
+               check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
        }
-       return path
 }
 
 // dir makes a good-faith attempt to return the directory

diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 23f8f9a18de8fc7a265c81af72f4ee1507cb538b..29f71137df8394256a7770186f40ece33692ae7b 100644 (file)
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -106,6 +106,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
                // get per-file instructions
                expectErrors := false
                filename := filepath.Join(path, f.Name())
+               goVersion := ""
                if comment := firstComment(filename); comment != "" {
                        fields := strings.Fields(comment)
                        switch fields[0] {
@@ -115,13 +116,17 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
                                expectErrors = true
                                for _, arg := range fields[1:] {
                                        if arg == "-0" || arg == "-+" || arg == "-std" {
-                                               // Marked explicitly as not expected errors (-0),
+                                               // Marked explicitly as not expecting errors (-0),
                                                // or marked as compiling runtime/stdlib, which is only done
                                                // to trigger runtime/stdlib-only error output.
                                                // In both cases, the code should typecheck.
                                                expectErrors = false
                                                break
                                        }
+                                       const prefix = "-lang="
+                                       if strings.HasPrefix(arg, prefix) {
+                                               goVersion = arg[len(prefix):]
+                                       }
                                }
                        }
                }
@@ -129,7 +134,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
                // parse and type-check file
                file, err := parser.ParseFile(fset, filename, nil, 0)
                if err == nil {
-                       conf := Config{Importer: stdLibImporter}
+                       conf := Config{GoVersion: goVersion, Importer: stdLibImporter}
                        _, err = conf.Check(filename, fset, []*ast.File{file}, nil)
                }
 
@@ -155,6 +160,9 @@ func TestStdTest(t *testing.T) {
        testTestDir(t, filepath.Join(runtime.GOROOT(), "test"),
                "cmplxdivide.go", // also needs file cmplxdivide1.go - ignore
                "directive.go",   // tests compiler rejection of bad directive placement - ignore
+               "embedfunc.go",   // tests //go:embed
+               "embedvers.go",   // tests //go:embed
+               "linkname2.go",   // go/types doesn't check validity of //go:xxx directives
        )
 }
 
@@ -168,19 +176,15 @@ func TestStdFixed(t *testing.T) {
        testTestDir(t, filepath.Join(runtime.GOROOT(), "test", "fixedbugs"),
                "bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore
                "issue6889.go",   // gc-specific test
-               "issue7746.go",   // large constants - consumes too much memory
                "issue11362.go",  // canonical import path check
                "issue16369.go",  // go/types handles this correctly - not an issue
                "issue18459.go",  // go/types doesn't check validity of //go:xxx directives
                "issue18882.go",  // go/types doesn't check validity of //go:xxx directives
-               "issue20232.go",  // go/types handles larger constants than gc
                "issue20529.go",  // go/types does not have constraints on stack size
                "issue22200.go",  // go/types does not have constraints on stack size
                "issue22200b.go", // go/types does not have constraints on stack size
                "issue25507.go",  // go/types does not have constraints on stack size
                "issue20780.go",  // go/types does not have constraints on stack size
-               "issue31747.go",  // go/types does not have constraints on language level (-lang=go1.12) (see #31793)
-               "issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
                "bug251.go",      // issue #34333 which was exposed with fix for #34151
                "issue42058a.go", // go/types does not have constraints on channel element size
                "issue42058b.go", // go/types does not have constraints on channel element size

diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 7b3f322ced2c5763597d110ae607edbf094d57bf..d88e47170c3a676b3ffa83acebb82a27fbb0e5cf 100644 (file)
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -528,6 +528,10 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
                        // By checking assignment of x to an invisible temporary
                        // (as a compiler would), we get all the relevant checks.
                        check.assignment(&x, nil, "switch expression")
+                       if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) {
+                               check.errorf(&x, _InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ)
+                               x.mode = invalid
+                       }
                } else {
                        // spec: "A missing switch expression is
                        // equivalent to the boolean value true."

diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index 98830eb08c601458c43bc77294ef1e30f97e4fd6..6ee28f13b4291fb19c161981f1772b13ff1093a5 100644 (file)
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -283,7 +283,7 @@ func delete1() {
        delete() // ERROR not enough arguments
        delete(1) // ERROR not enough arguments
        delete(1, 2, 3) // ERROR too many arguments
-       delete(m, 0 /* ERROR not assignable */)
+       delete(m, 0 /* ERROR cannot use */)
        delete(m, s)
        _ = delete /* ERROR used as value */ (m, s)
 
@@ -514,7 +514,7 @@ func panic1() {
        panic("foo")
        panic(false)
        panic(1<<10)
-       panic(1 /* ERROR overflows */ <<1000)
+       panic(1 << /* ERROR constant shift overflow */ 1000)
        _ = panic /* ERROR used as value */ (0)
 
        var s []byte
@@ -538,7 +538,7 @@ func print1() {
        print(2.718281828)
        print(false)
        print(1<<10)
-       print(1 /* ERROR overflows */ <<1000)
+       print(1 << /* ERROR constant shift overflow */ 1000)
        println(nil /* ERROR untyped nil */ )
 
        var s []int
@@ -564,7 +564,7 @@ func println1() {
        println(2.718281828)
        println(false)
        println(1<<10)
-       println(1 /* ERROR overflows */ <<1000)
+       println(1 << /* ERROR constant shift overflow */ 1000)
        println(nil /* ERROR untyped nil */ )
 
        var s []int
@@ -695,7 +695,7 @@ func Alignof1() {
        _ = unsafe.Alignof(42)
        _ = unsafe.Alignof(new(struct{}))
        _ = unsafe.Alignof(1<<10)
-       _ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
+       _ = unsafe.Alignof(1 << /* ERROR constant shift overflow */ 1000)
        _ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
        unsafe /* ERROR not used */ .Alignof(x)
 
@@ -783,7 +783,7 @@ func Sizeof1() {
        _ = unsafe.Sizeof(42)
        _ = unsafe.Sizeof(new(complex128))
        _ = unsafe.Sizeof(1<<10)
-       _ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
+       _ = unsafe.Sizeof(1 << /* ERROR constant shift overflow */ 1000)
        _ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
        unsafe /* ERROR not used */ .Sizeof(x)
 

diff --git a/src/go/types/testdata/const0.src b/src/go/types/testdata/const0.src
index adbbf2863b03e55e0dfaeea860551f88dd7f1b1e..5608b1549ba8d7774c2463fa9faab3702673f061 100644 (file)
--- a/src/go/types/testdata/const0.src
+++ b/src/go/types/testdata/const0.src
@@ -348,3 +348,16 @@ const _ = unsafe.Sizeof(func() {
        assert(one == 1)
        assert(iota == 0)
 })
+
+// untyped constants must not get arbitrarily large
+const prec = 512 // internal maximum precision for integers
+const maxInt = (1<<(prec/2) - 1) * (1<<(prec/2) + 1) // == 1<<prec - 1
+
+const _ = maxInt + /* ERROR constant addition overflow */ 1
+const _ = -maxInt - /* ERROR constant subtraction overflow */ 1
+const _ = maxInt ^ /* ERROR constant bitwise XOR overflow */ -1
+const _ = maxInt * /* ERROR constant multiplication overflow */ 2
+const _ = maxInt << /* ERROR constant shift overflow */ 2
+const _ = 1 << /* ERROR constant shift overflow */ prec
+
+const _ = ^ /* ERROR constant bitwise complement overflow */ maxInt

diff --git a/src/go/types/testdata/const1.src b/src/go/types/testdata/const1.src
index d82770464fa73a4b84cf6dcc35f2583eed5ba3cf..56b6bd4ca55e75773e5cea3a96f88b788775ce05 100644 (file)
--- a/src/go/types/testdata/const1.src
+++ b/src/go/types/testdata/const1.src
@@ -43,7 +43,12 @@ const (
 
 const (
        smallestFloat32 = 1.0 / (1<<(127 - 1 + 23))
-       smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+       // TODO(gri) The compiler limits integers to 512 bit and thus
+       //           we cannot compute the value (1<<(1023 - 1 + 52))
+       //           without overflow. For now we match the compiler.
+       //           See also issue #44057.
+       // smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+       smallestFloat64 = 4.940656458412465441765687928682213723651e-324
 )
 
 const (
@@ -53,7 +58,12 @@ const (
 
 const (
        maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23)
-       maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+       // TODO(gri) The compiler limits integers to 512 bit and thus
+       //           we cannot compute the value 1<<1023
+       //           without overflow. For now we match the compiler.
+       //           See also issue #44057.
+       // maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+       maxFloat64 = 1.797693134862315708145274237317043567981e+308
 )
 
 const (
@@ -271,7 +281,9 @@ const (
        _ = assert(float64(smallestFloat32) == smallestFloat32)
        _ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
        _ = assert(float64(smallestFloat64) == smallestFloat64)
-       _ = assert(float64(smallestFloat64/2) == 0)
+       // TODO(gri) With the change to the declaration of smallestFloat64
+       //           this now fails to be true. See issue #44058.
+       // _ = assert(float64(smallestFloat64/2) == 0)
 )
 
 const (

diff --git a/src/go/types/testdata/decls2a.src b/src/go/types/testdata/decls2/decls2a.src
similarity index 100%
rename from src/go/types/testdata/decls2a.src
rename to src/go/types/testdata/decls2/decls2a.src

diff --git a/src/go/types/testdata/decls2b.src b/src/go/types/testdata/decls2/decls2b.src
similarity index 100%
rename from src/go/types/testdata/decls2b.src
rename to src/go/types/testdata/decls2/decls2b.src

diff --git a/src/go/types/testdata/go1_12.src b/src/go/types/testdata/go1_12.src
new file mode 100644 (file)
index 0000000..1e529f1
--- /dev/null
+++ b/src/go/types/testdata/go1_12.src
@@ -0,0 +1,35 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check Go language version-specific errors.
+
+package go1_12 // go1.12
+
+// numeric literals
+const (
+       _ = 1_000 // ERROR "underscores in numeric literals requires go1.13 or later"
+       _ = 0b111 // ERROR "binary literals requires go1.13 or later"
+       _ = 0o567 // ERROR "0o/0O-style octal literals requires go1.13 or later"
+       _ = 0xabc // ok
+       _ = 0x0p1 // ERROR "hexadecimal floating-point literals requires go1.13 or later"
+
+       _ = 0B111 // ERROR "binary"
+       _ = 0O567 // ERROR "octal"
+       _ = 0Xabc // ok
+       _ = 0X0P1 // ERROR "hexadecimal floating-point"
+
+       _ = 1_000i // ERROR "underscores"
+       _ = 0b111i // ERROR "binary"
+       _ = 0o567i // ERROR "octal"
+       _ = 0xabci // ERROR "hexadecimal floating-point"
+       _ = 0x0p1i // ERROR "hexadecimal floating-point"
+)
+
+// signed shift counts
+var (
+       s int
+       _ = 1 << s // ERROR "invalid operation: signed shift count s \(variable of type int\) requires go1.13 or later"
+       _ = 1 >> s // ERROR "signed shift count"
+)
+

diff --git a/src/go/types/testdata/go1_13.src b/src/go/types/testdata/go1_13.src
new file mode 100644 (file)
index 0000000..6aa1364
--- /dev/null
+++ b/src/go/types/testdata/go1_13.src
@@ -0,0 +1,22 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check Go language version-specific errors.
+
+package go1_13 // go1.13
+
+// interface embedding
+
+type I interface { m() }
+
+type _ interface {
+       m()
+       I // ERROR "duplicate method m"
+}
+
+type _ interface {
+       I
+       I // ERROR "duplicate method m"
+}
+

diff --git a/src/go/types/testdata/go1_8.src b/src/go/types/testdata/go1_8.src
new file mode 100644 (file)
index 0000000..3ead1e9
--- /dev/null
+++ b/src/go/types/testdata/go1_8.src
@@ -0,0 +1,11 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check Go language version-specific errors.
+
+package go1_8 // go1.8
+
+// type alias declarations
+type any = /* ERROR type aliases requires go1.9 or later */ interface{}
+

diff --git a/src/go/types/testdata/importdecl0a.src b/src/go/types/testdata/importdecl0/importdecl0a.src
similarity index 95%
rename from src/go/types/testdata/importdecl0a.src
rename to src/go/types/testdata/importdecl0/importdecl0a.src
index e96fca3cdd56fa86cb284276e78412b3c5f296a8..5ceb96e1fada684387f20c56894810a772875de2 100644 (file)
--- a/src/go/types/testdata/importdecl0a.src
+++ b/src/go/types/testdata/importdecl0/importdecl0a.src
@@ -10,7 +10,7 @@ import (
        // we can have multiple blank imports (was bug)
        _ "math"
        _ "net/rpc"
-       init /* ERROR "cannot declare init" */ "fmt"
+       init /* ERROR "cannot import package as init" */ "fmt"
        // reflect defines a type "flag" which shows up in the gc export data
        "reflect"
        . /* ERROR "imported but not used" */ "reflect"

diff --git a/src/go/types/testdata/importdecl0b.src b/src/go/types/testdata/importdecl0/importdecl0b.src
similarity index 93%
rename from src/go/types/testdata/importdecl0b.src
rename to src/go/types/testdata/importdecl0/importdecl0b.src
index 6844e7098233eb5488c860c03f5a3274f1b467d5..55690423b66ec675506fed232501d3fbd9c67b5c 100644 (file)
--- a/src/go/types/testdata/importdecl0b.src
+++ b/src/go/types/testdata/importdecl0/importdecl0b.src
@@ -8,7 +8,7 @@ import "math"
 import m "math"
 
 import . "testing" // declares T in file scope
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 import . "fmt"     // declares Println in file scope
 
 import (

diff --git a/src/go/types/testdata/importdecl1a.src b/src/go/types/testdata/importdecl1/importdecl1a.src
similarity index 100%
rename from src/go/types/testdata/importdecl1a.src
rename to src/go/types/testdata/importdecl1/importdecl1a.src

diff --git a/src/go/types/testdata/importdecl1b.src b/src/go/types/testdata/importdecl1/importdecl1b.src
similarity index 77%
rename from src/go/types/testdata/importdecl1b.src
rename to src/go/types/testdata/importdecl1/importdecl1b.src
index ee70bbd8e73f787c8aa3b3d792f5673d0f0aacbb..43a7bcd75396cbb34ab5ab3c1e354f9d1f4642b7 100644 (file)
--- a/src/go/types/testdata/importdecl1b.src
+++ b/src/go/types/testdata/importdecl1/importdecl1b.src
@@ -4,7 +4,7 @@
 
 package importdecl1
 
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 
 type B interface {
        A

diff --git a/src/go/types/testdata/issue25008a.src b/src/go/types/testdata/issue25008/issue25008a.src
similarity index 100%
rename from src/go/types/testdata/issue25008a.src
rename to src/go/types/testdata/issue25008/issue25008a.src

diff --git a/src/go/types/testdata/issue25008b.src b/src/go/types/testdata/issue25008/issue25008b.src
similarity index 100%
rename from src/go/types/testdata/issue25008b.src
rename to src/go/types/testdata/issue25008/issue25008b.src

diff --git a/src/go/types/testdata/main.src b/src/go/types/testdata/main.src
new file mode 100644 (file)
index 0000000..f892938
--- /dev/null
+++ b/src/go/types/testdata/main.src
@@ -0,0 +1,9 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main()
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ (int)
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ () int

diff --git a/src/go/types/testdata/shifts.src b/src/go/types/testdata/shifts.src
index c9a38ae169ea095d0ad030c5b6238541e6319acc..4d3c59a50fd9bd59f7a056da8fd1ba0b09e04d99 100644 (file)
--- a/src/go/types/testdata/shifts.src
+++ b/src/go/types/testdata/shifts.src
@@ -20,7 +20,7 @@ func shifts0() {
                // This depends on the exact spec wording which is not
                // done yet.
                // TODO(gri) revisit and adjust when spec change is done
-               _ = 1<<- /* ERROR "truncated to uint" */ 1.0
+               _ = 1<<- /* ERROR "negative shift count" */ 1.0
                _ = 1<<1075 /* ERROR "invalid shift" */
                _ = 2.0<<1
                _ = 1<<1.0
@@ -60,11 +60,13 @@ func shifts1() {
                _ uint = 1 << u
                _ float32 = 1 /* ERROR "must be integer" */ << u
 
-               // for issue 14822
+               // issue #14822
+               _ = 1<<( /* ERROR "overflows uint" */ 1<<64)
                _ = 1<<( /* ERROR "invalid shift count" */ 1<<64-1)
-               _ = 1<<( /* ERROR "invalid shift count" */ 1<<64)
-               _ = u<<(1<<63) // valid
-               _ = u<<(1<<64) // valid
+
+               // issue #43697
+               _ = u<<( /* ERROR "overflows uint" */ 1<<64)
+               _ = u<<(1<<64-1)
        )
 }
 

diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index 13777292a9439ba15bed008574a6316014ce8f73..de8f936a617ae106e57dd60bf37eabf6ab0178de 100644 (file)
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -90,7 +90,7 @@ func assignments1() {
 
        // assignments to _
        _ = nil /* ERROR "use of untyped nil" */
-       _ = 1 /* ERROR overflow */ <<1000
+       _ = 1  << /* ERROR constant shift overflow */ 1000
        (_) = 0
 }
 

diff --git a/src/go/types/type.go b/src/go/types/type.go
index 087cda429d689ab83c714a5f18caef0fdd442e16..66e194e967920ecb66ec4bc0a16f1c7ef2711d57 100644 (file)
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -4,8 +4,6 @@
 
 package types
 
-import "sort"
-
 // A Type represents a type of Go.
 // All types implement the Type interface.
 type Type interface {
@@ -301,8 +299,8 @@ func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
        }
 
        // sort for API stability
-       sort.Sort(byUniqueMethodName(methods))
-       sort.Stable(byUniqueTypeName(embeddeds))
+       sortMethods(methods)
+       sortTypes(embeddeds)
 
        typ.methods = methods
        typ.embeddeds = embeddeds
@@ -396,7 +394,7 @@ func (t *Interface) Complete() *Interface {
        }
 
        if methods != nil {
-               sort.Sort(byUniqueMethodName(methods))
+               sortMethods(methods)
                t.allMethods = methods
        }
 

diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 2b398010f4d0483f231c9c01b0862b2fbdcf5732..b9249494fa16d0159d65f7e1c8213d8c3e5ae8a7 100644 (file)
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -51,12 +51,12 @@ func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool)
        }
        assert(typ != nil)
 
-       // The object may be dot-imported: If so, remove its package from
-       // the map of unused dot imports for the respective file scope.
+       // The object may have been dot-imported.
+       // If so, mark the respective package as used.
        // (This code is only needed for dot-imports. Without them,
        // we only have to mark variables, see *Var case below).
-       if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
-               delete(check.unusedDotImports[scope], pkg)
+       if pkgName := check.dotImportMap[dotImportKey{scope, obj}]; pkgName != nil {
+               pkgName.used = true
        }
 
        switch obj := obj.(type) {
@@ -518,8 +518,8 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
        }
 
        // sort for API stability
-       sort.Sort(byUniqueMethodName(ityp.methods))
-       sort.Stable(byUniqueTypeName(ityp.embeddeds))
+       sortMethods(ityp.methods)
+       sortTypes(ityp.embeddeds)
 
        check.later(func() { check.completeInterface(ityp) })
 }
@@ -578,9 +578,13 @@ func (check *Checker) completeInterface(ityp *Interface) {
                        check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
                        check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
                default:
-                       // check method signatures after all types are computed (issue #33656)
+                       // We have a duplicate method name in an embedded (not explicitly declared) method.
+                       // Check method signatures after all types are computed (issue #33656).
+                       // If we're pre-go1.14 (overlapping embeddings are not permitted), report that
+                       // error here as well (even though we could do it eagerly) because it's the same
+                       // error message.
                        check.atEnd(func() {
-                               if !check.identical(m.typ, other.Type()) {
+                               if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
                                        check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
                                        check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
                                }
@@ -613,6 +617,10 @@ func (check *Checker) completeInterface(ityp *Interface) {
        }
 }
 
+func sortTypes(list []Type) {
+       sort.Stable(byUniqueTypeName(list))
+}
+
 // byUniqueTypeName named type lists can be sorted by their unique type names.
 type byUniqueTypeName []Type
 
@@ -627,6 +635,19 @@ func sortName(t Type) string {
        return ""
 }
 
+func sortMethods(list []*Func) {
+       sort.Sort(byUniqueMethodName(list))
+}
+
+func assertSortedMethods(list []*Func) {
+       if !debug {
+               panic("internal error: assertSortedMethods called outside debug mode")
+       }
+       if !sort.IsSorted(byUniqueMethodName(list)) {
+               panic("internal error: methods not sorted")
+       }
+}
+
 // byUniqueMethodName method lists can be sorted by their unique method names.
 type byUniqueMethodName []*Func
 

diff --git a/src/go/types/version.go b/src/go/types/version.go
new file mode 100644 (file)
index 0000000..1546941
--- /dev/null
+++ b/src/go/types/version.go
@@ -0,0 +1,82 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import (
+       "fmt"
+       "go/ast"
+       "go/token"
+       "regexp"
+       "strconv"
+       "strings"
+)
+
+// langCompat reports an error if the representation of a numeric
+// literal is not compatible with the current language version.
+func (check *Checker) langCompat(lit *ast.BasicLit) {
+       s := lit.Value
+       if len(s) <= 2 || check.allowVersion(check.pkg, 1, 13) {
+               return
+       }
+       // len(s) > 2
+       if strings.Contains(s, "_") {
+               check.errorf(lit, _InvalidLit, "underscores in numeric literals requires go1.13 or later")
+               return
+       }
+       if s[0] != '0' {
+               return
+       }
+       radix := s[1]
+       if radix == 'b' || radix == 'B' {
+               check.errorf(lit, _InvalidLit, "binary literals requires go1.13 or later")
+               return
+       }
+       if radix == 'o' || radix == 'O' {
+               check.errorf(lit, _InvalidLit, "0o/0O-style octal literals requires go1.13 or later")
+               return
+       }
+       if lit.Kind != token.INT && (radix == 'x' || radix == 'X') {
+               check.errorf(lit, _InvalidLit, "hexadecimal floating-point literals requires go1.13 or later")
+       }
+}
+
+// allowVersion reports whether the given package
+// is allowed to use version major.minor.
+func (check *Checker) allowVersion(pkg *Package, major, minor int) bool {
+       // We assume that imported packages have all been checked,
+       // so we only have to check for the local package.
+       if pkg != check.pkg {
+               return true
+       }
+       ma, mi := check.version.major, check.version.minor
+       return ma == 0 && mi == 0 || ma > major || ma == major && mi >= minor
+}
+
+type version struct {
+       major, minor int
+}
+
+// parseGoVersion parses a Go version string (such as "go1.12")
+// and returns the version, or an error. If s is the empty
+// string, the version is 0.0.
+func parseGoVersion(s string) (v version, err error) {
+       if s == "" {
+               return
+       }
+       matches := goVersionRx.FindStringSubmatch(s)
+       if matches == nil {
+               err = fmt.Errorf(`should be something like "go1.12"`)
+               return
+       }
+       v.major, err = strconv.Atoi(matches[1])
+       if err != nil {
+               return
+       }
+       v.minor, err = strconv.Atoi(matches[2])
+       return
+}
+
+// goVersionRx matches a Go version string, e.g. "go1.12".
+var goVersionRx = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)

diff --git a/src/html/template/exec_test.go b/src/html/template/exec_test.go
index 232945a0bb16f3824fb3c68655b897c87c02aefd..7d1bef1782a9cc0be2a97179acb080a5ab7afad3 100644 (file)
--- a/src/html/template/exec_test.go
+++ b/src/html/template/exec_test.go
@@ -14,6 +14,7 @@ import (
        "io"
        "reflect"
        "strings"
+       "sync"
        "testing"
        "text/template"
 )
@@ -1706,3 +1707,127 @@ func TestIssue31810(t *testing.T) {
                t.Errorf("%s got %q, expected %q", textCall, b.String(), "result")
        }
 }
+
+// Issue 39807. There was a race applying escapeTemplate.
+
+const raceText = `
+{{- define "jstempl" -}}
+var v = "v";
+{{- end -}}
+<script type="application/javascript">
+{{ template "jstempl" $ }}
+</script>
+`
+
+func TestEscapeRace(t *testing.T) {
+       t.Skip("this test currently fails with -race; see issue #39807")
+
+       tmpl := New("")
+       _, err := tmpl.New("templ.html").Parse(raceText)
+       if err != nil {
+               t.Fatal(err)
+       }
+       const count = 20
+       for i := 0; i < count; i++ {
+               _, err := tmpl.New(fmt.Sprintf("x%d.html", i)).Parse(`{{ template "templ.html" .}}`)
+               if err != nil {
+                       t.Fatal(err)
+               }
+       }
+
+       var wg sync.WaitGroup
+       for i := 0; i < 10; i++ {
+               wg.Add(1)
+               go func() {
+                       defer wg.Done()
+                       for j := 0; j < count; j++ {
+                               sub := tmpl.Lookup(fmt.Sprintf("x%d.html", j))
+                               if err := sub.Execute(io.Discard, nil); err != nil {
+                                       t.Error(err)
+                               }
+                       }
+               }()
+       }
+       wg.Wait()
+}
+
+func TestRecursiveExecute(t *testing.T) {
+       tmpl := New("")
+
+       recur := func() (HTML, error) {
+               var sb strings.Builder
+               if err := tmpl.ExecuteTemplate(&sb, "subroutine", nil); err != nil {
+                       t.Fatal(err)
+               }
+               return HTML(sb.String()), nil
+       }
+
+       m := FuncMap{
+               "recur": recur,
+       }
+
+       top, err := tmpl.New("x.html").Funcs(m).Parse(`{{recur}}`)
+       if err != nil {
+               t.Fatal(err)
+       }
+       _, err = tmpl.New("subroutine").Parse(`<a href="/x?p={{"'a<b'"}}">`)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if err := top.Execute(io.Discard, nil); err != nil {
+               t.Fatal(err)
+       }
+}
+
+// recursiveInvoker is for TestRecursiveExecuteViaMethod.
+type recursiveInvoker struct {
+       t    *testing.T
+       tmpl *Template
+}
+
+func (r *recursiveInvoker) Recur() (string, error) {
+       var sb strings.Builder
+       if err := r.tmpl.ExecuteTemplate(&sb, "subroutine", nil); err != nil {
+               r.t.Fatal(err)
+       }
+       return sb.String(), nil
+}
+
+func TestRecursiveExecuteViaMethod(t *testing.T) {
+       tmpl := New("")
+       top, err := tmpl.New("x.html").Parse(`{{.Recur}}`)
+       if err != nil {
+               t.Fatal(err)
+       }
+       _, err = tmpl.New("subroutine").Parse(`<a href="/x?p={{"'a<b'"}}">`)
+       if err != nil {
+               t.Fatal(err)
+       }
+       r := &recursiveInvoker{
+               t:    t,
+               tmpl: tmpl,
+       }
+       if err := top.Execute(io.Discard, r); err != nil {
+               t.Fatal(err)
+       }
+}
+
+// Issue 43295.
+func TestTemplateFuncsAfterClone(t *testing.T) {
+       s := `{{ f . }}`
+       want := "test"
+       orig := New("orig").Funcs(map[string]interface{}{
+               "f": func(in string) string {
+                       return in
+               },
+       }).New("child")
+
+       overviewTmpl := Must(Must(orig.Clone()).Parse(s))
+       var out strings.Builder
+       if err := overviewTmpl.Execute(&out, want); err != nil {
+               t.Fatal(err)
+       }
+       if got := out.String(); got != want {
+               t.Fatalf("got %q; want %q", got, want)
+       }
+}

diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go
new file mode 100644 (file)
index 0000000..6700fac
--- /dev/null
+++ b/src/internal/abi/abi.go
@@ -0,0 +1,53 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import "unsafe"
+
+// RegArgs is a struct that has space for each argument
+// and return value register on the current architecture.
+//
+// Assembly code knows the layout of the first two fields
+// of RegArgs.
+//
+// RegArgs also contains additional space to hold pointers
+// when it may not be safe to keep them only in the integer
+// register space otherwise.
+type RegArgs struct {
+       Ints   [IntArgRegs]uintptr  // untyped integer registers
+       Floats [FloatArgRegs]uint64 // untyped float registers
+
+       // Fields above this point are known to assembly.
+
+       // Ptrs is a space that duplicates Ints but with pointer type,
+       // used to make pointers passed or returned  in registers
+       // visible to the GC by making the type unsafe.Pointer.
+       Ptrs [IntArgRegs]unsafe.Pointer
+
+       // ReturnIsPtr is a bitmap that indicates which registers
+       // contain or will contain pointers on the return path from
+       // a reflectcall. The i'th bit indicates whether the i'th
+       // register contains or will contain a valid Go pointer.
+       ReturnIsPtr IntArgRegBitmap
+}
+
+// IntArgRegBitmap is a bitmap large enough to hold one bit per
+// integer argument/return register.
+type IntArgRegBitmap [(IntArgRegs + 7) / 8]uint8
+
+// Set sets the i'th bit of the bitmap to 1.
+func (b *IntArgRegBitmap) Set(i int) {
+       b[i/8] |= uint8(1) << (i % 8)
+}
+
+// Get returns whether the i'th bit of the bitmap is set.
+//
+// nosplit because it's called in extremely sensitive contexts, like
+// on the reflectcall return path.
+//
+//go:nosplit
+func (b *IntArgRegBitmap) Get(i int) bool {
+       return b[i/8]&(uint8(1)<<(i%8)) != 0
+}

diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
new file mode 100644 (file)
index 0000000..70e2ed1
--- /dev/null
+++ b/src/internal/abi/abi_amd64.go
@@ -0,0 +1,24 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build goexperiment.regabi
+
+package abi
+
+const (
+       // See abi_generic.go.
+
+       // Currently these values are zero because whatever uses
+       // them will expect the register ABI, which isn't ready
+       // yet.
+
+       // RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
+       IntArgRegs = 0 // 9
+
+       // X0 -> X14.
+       FloatArgRegs = 0 // 15
+
+       // We use SSE2 registers which support 64-bit float operations.
+       EffectiveFloatRegSize = 0 // 8
+)

diff --git a/src/internal/abi/abi_generic.go b/src/internal/abi/abi_generic.go
new file mode 100644 (file)
index 0000000..5ef9883
--- /dev/null
+++ b/src/internal/abi/abi_generic.go
@@ -0,0 +1,38 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !goexperiment.regabi
+
+package abi
+
+const (
+       // ABI-related constants.
+       //
+       // In the generic case, these are all zero
+       // which lets them gracefully degrade to ABI0.
+
+       // IntArgRegs is the number of registers dedicated
+       // to passing integer argument values. Result registers are identical
+       // to argument registers, so this number is used for those too.
+       IntArgRegs = 0
+
+       // FloatArgRegs is the number of registers dedicated
+       // to passing floating-point argument values. Result registers are
+       // identical to argument registers, so this number is used for
+       // those too.
+       FloatArgRegs = 0
+
+       // EffectiveFloatRegSize describes the width of floating point
+       // registers on the current platform from the ABI's perspective.
+       //
+       // Since Go only supports 32-bit and 64-bit floating point primitives,
+       // this number should be either 0, 4, or 8. 0 indicates no floating
+       // point registers for the ABI or that floating point values will be
+       // passed via the softfloat ABI.
+       //
+       // For platforms that support larger floating point register widths,
+       // such as x87's 80-bit "registers" (not that we support x87 currently),
+       // use 8.
+       EffectiveFloatRegSize = 0
+)

diff --git a/src/internal/execabs/execabs.go b/src/internal/execabs/execabs.go
new file mode 100644 (file)
index 0000000..9a05d97
--- /dev/null
+++ b/src/internal/execabs/execabs.go
@@ -0,0 +1,70 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package execabs is a drop-in replacement for os/exec
+// that requires PATH lookups to find absolute paths.
+// That is, execabs.Command("cmd") runs the same PATH lookup
+// as exec.Command("cmd"), but if the result is a path
+// which is relative, the Run and Start methods will report
+// an error instead of running the executable.
+package execabs
+
+import (
+       "context"
+       "fmt"
+       "os/exec"
+       "path/filepath"
+       "reflect"
+       "unsafe"
+)
+
+var ErrNotFound = exec.ErrNotFound
+
+type (
+       Cmd       = exec.Cmd
+       Error     = exec.Error
+       ExitError = exec.ExitError
+)
+
+func relError(file, path string) error {
+       return fmt.Errorf("%s resolves to executable relative to current directory (.%c%s)", file, filepath.Separator, path)
+}
+
+func LookPath(file string) (string, error) {
+       path, err := exec.LookPath(file)
+       if err != nil {
+               return "", err
+       }
+       if filepath.Base(file) == file && !filepath.IsAbs(path) {
+               return "", relError(file, path)
+       }
+       return path, nil
+}
+
+func fixCmd(name string, cmd *exec.Cmd) {
+       if filepath.Base(name) == name && !filepath.IsAbs(cmd.Path) {
+               // exec.Command was called with a bare binary name and
+               // exec.LookPath returned a path which is not absolute.
+               // Set cmd.lookPathErr and clear cmd.Path so that it
+               // cannot be run.
+               lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))
+               if *lookPathErr == nil {
+                       *lookPathErr = relError(name, cmd.Path)
+               }
+               cmd.Path = ""
+       }
+}
+
+func CommandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
+       cmd := exec.CommandContext(ctx, name, arg...)
+       fixCmd(name, cmd)
+       return cmd
+
+}
+
+func Command(name string, arg ...string) *exec.Cmd {
+       cmd := exec.Command(name, arg...)
+       fixCmd(name, cmd)
+       return cmd
+}

diff --git a/src/internal/execabs/execabs_test.go b/src/internal/execabs/execabs_test.go
new file mode 100644 (file)
index 0000000..b714585
--- /dev/null
+++ b/src/internal/execabs/execabs_test.go
@@ -0,0 +1,104 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package execabs
+
+import (
+       "context"
+       "fmt"
+       "internal/testenv"
+       "io/ioutil"
+       "os"
+       "os/exec"
+       "path/filepath"
+       "runtime"
+       "testing"
+)
+
+func TestFixCmd(t *testing.T) {
+       cmd := &exec.Cmd{Path: "hello"}
+       fixCmd("hello", cmd)
+       if cmd.Path != "" {
+               t.Error("fixCmd didn't clear cmd.Path")
+       }
+       expectedErr := fmt.Sprintf("hello resolves to executable relative to current directory (.%chello)", filepath.Separator)
+       if err := cmd.Run(); err == nil {
+               t.Fatal("Command.Run didn't fail")
+       } else if err.Error() != expectedErr {
+               t.Fatalf("Command.Run returned unexpected error: want %q, got %q", expectedErr, err.Error())
+       }
+}
+
+func TestCommand(t *testing.T) {
+       testenv.MustHaveExec(t)
+
+       for _, cmd := range []func(string) *Cmd{
+               func(s string) *Cmd { return Command(s) },
+               func(s string) *Cmd { return CommandContext(context.Background(), s) },
+       } {
+               tmpDir := t.TempDir()
+               executable := "execabs-test"
+               if runtime.GOOS == "windows" {
+                       executable += ".exe"
+               }
+               if err := ioutil.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
+                       t.Fatalf("ioutil.WriteFile failed: %s", err)
+               }
+               cwd, err := os.Getwd()
+               if err != nil {
+                       t.Fatalf("os.Getwd failed: %s", err)
+               }
+               defer os.Chdir(cwd)
+               if err = os.Chdir(tmpDir); err != nil {
+                       t.Fatalf("os.Chdir failed: %s", err)
+               }
+               if runtime.GOOS != "windows" {
+                       // add "." to PATH so that exec.LookPath looks in the current directory on
+                       // non-windows platforms as well
+                       origPath := os.Getenv("PATH")
+                       defer os.Setenv("PATH", origPath)
+                       os.Setenv("PATH", fmt.Sprintf(".:%s", origPath))
+               }
+               expectedErr := fmt.Sprintf("execabs-test resolves to executable relative to current directory (.%c%s)", filepath.Separator, executable)
+               if err = cmd("execabs-test").Run(); err == nil {
+                       t.Fatalf("Command.Run didn't fail when exec.LookPath returned a relative path")
+               } else if err.Error() != expectedErr {
+                       t.Errorf("Command.Run returned unexpected error: want %q, got %q", expectedErr, err.Error())
+               }
+       }
+}
+
+func TestLookPath(t *testing.T) {
+       testenv.MustHaveExec(t)
+
+       tmpDir := t.TempDir()
+       executable := "execabs-test"
+       if runtime.GOOS == "windows" {
+               executable += ".exe"
+       }
+       if err := ioutil.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
+               t.Fatalf("ioutil.WriteFile failed: %s", err)
+       }
+       cwd, err := os.Getwd()
+       if err != nil {
+               t.Fatalf("os.Getwd failed: %s", err)
+       }
+       defer os.Chdir(cwd)
+       if err = os.Chdir(tmpDir); err != nil {
+               t.Fatalf("os.Chdir failed: %s", err)
+       }
+       if runtime.GOOS != "windows" {
+               // add "." to PATH so that exec.LookPath looks in the current directory on
+               // non-windows platforms as well
+               origPath := os.Getenv("PATH")
+               defer os.Setenv("PATH", origPath)
+               os.Setenv("PATH", fmt.Sprintf(".:%s", origPath))
+       }
+       expectedErr := fmt.Sprintf("execabs-test resolves to executable relative to current directory (.%c%s)", filepath.Separator, executable)
+       if _, err := LookPath("execabs-test"); err == nil {
+               t.Fatalf("LookPath didn't fail when finding a non-relative path")
+       } else if err.Error() != expectedErr {
+               t.Errorf("LookPath returned unexpected error: want %q, got %q", expectedErr, err.Error())
+       }
+}

diff --git a/src/internal/goroot/gc.go b/src/internal/goroot/gc.go
index 0f541d734b0418e54ffcf9200180a4969bb42c7d..ce72bc389656a43681504ee97feff50b60526f1a 100644 (file)
--- a/src/internal/goroot/gc.go
+++ b/src/internal/goroot/gc.go
@@ -7,8 +7,8 @@
 package goroot
 
 import (
+       exec "internal/execabs"
        "os"
-       "os/exec"
        "path/filepath"
        "strings"
        "sync"

diff --git a/src/internal/goversion/goversion.go b/src/internal/goversion/goversion.go
index 513be456bdaab7c631ab02d460159d59d5b626fc..4cc15688c0b70505e47ddd4ffce5c20a85852442 100644 (file)
--- a/src/internal/goversion/goversion.go
+++ b/src/internal/goversion/goversion.go
@@ -9,4 +9,4 @@ package goversion
 //
 // It should be updated at the start of each development cycle to be
 // the version of the next Go 1.x release. See golang.org/issue/40705.
-const Version = 16
+const Version = 17

diff --git a/src/internal/poll/copy_file_range_linux.go b/src/internal/poll/copy_file_range_linux.go
index fc34aef4cba0e4320bba3e51f1be3677ab590870..01b242a4ea4e8d8fe147fbd9b3fc785d81796e13 100644 (file)
--- a/src/internal/poll/copy_file_range_linux.go
+++ b/src/internal/poll/copy_file_range_linux.go
@@ -112,7 +112,15 @@ func CopyFileRange(dst, src *FD, remain int64) (written int64, handled bool, err
                        return 0, false, nil
                case nil:
                        if n == 0 {
-                               // src is at EOF, which means we are done.
+                               // If we did not read any bytes at all,
+                               // then this file may be in a file system
+                               // where copy_file_range silently fails.
+                               // https://lore.kernel.org/linux-fsdevel/20210126233840.GG4626@dread.disaster.area/T/#m05753578c7f7882f6e9ffe01f981bc223edef2b0
+                               if written == 0 {
+                                       return 0, false, nil
+                               }
+                               // Otherwise src is at EOF, which means
+                               // we are done.
                                return written, true, nil
                        }
                        remain -= n

diff --git a/src/internal/poll/sendfile_bsd.go b/src/internal/poll/sendfile_bsd.go
index a24e41dcaa8742c8104e5071455e9e83cb92ee84..66005a9f5c952a68574a50d64cecab36b13728f1 100644 (file)
--- a/src/internal/poll/sendfile_bsd.go
+++ b/src/internal/poll/sendfile_bsd.go
@@ -18,6 +18,10 @@ func SendFile(dstFD *FD, src int, pos, remain int64) (int64, error) {
                return 0, err
        }
        defer dstFD.writeUnlock()
+       if err := dstFD.pd.prepareWrite(dstFD.isFile); err != nil {
+               return 0, err
+       }
+
        dst := int(dstFD.Sysfd)
        var written int64
        var err error

diff --git a/src/internal/poll/sendfile_linux.go b/src/internal/poll/sendfile_linux.go
index d64283007db44c03db78d768c5b9a4258f2e9c01..d6442e8666481b67c636f9bbbe00a34a1d1fe84e 100644 (file)
--- a/src/internal/poll/sendfile_linux.go
+++ b/src/internal/poll/sendfile_linux.go
@@ -16,6 +16,9 @@ func SendFile(dstFD *FD, src int, remain int64) (int64, error) {
                return 0, err
        }
        defer dstFD.writeUnlock()
+       if err := dstFD.pd.prepareWrite(dstFD.isFile); err != nil {
+               return 0, err
+       }
 
        dst := int(dstFD.Sysfd)
        var written int64

diff --git a/src/internal/poll/sendfile_solaris.go b/src/internal/poll/sendfile_solaris.go
index 762992e9eb398eac2b0ec7ec9eda78466a831ab4..748c85131e688da0c42eb4d8f8fd65195a587a77 100644 (file)
--- a/src/internal/poll/sendfile_solaris.go
+++ b/src/internal/poll/sendfile_solaris.go
@@ -20,6 +20,9 @@ func SendFile(dstFD *FD, src int, pos, remain int64) (int64, error) {
                return 0, err
        }
        defer dstFD.writeUnlock()
+       if err := dstFD.pd.prepareWrite(dstFD.isFile); err != nil {
+               return 0, err
+       }
 
        dst := int(dstFD.Sysfd)
        var written int64

diff --git a/src/internal/syscall/windows/syscall_windows.go b/src/internal/syscall/windows/syscall_windows.go
index 1f40c11820519114c3b56ef6c10a84acf0940eff..f8965d0bab175de81d8f0355794ded7ff253ea9d 100644 (file)
--- a/src/internal/syscall/windows/syscall_windows.go
+++ b/src/internal/syscall/windows/syscall_windows.go
@@ -342,3 +342,5 @@ func LoadGetFinalPathNameByHandle() error {
 
 //sys  CreateEnvironmentBlock(block **uint16, token syscall.Token, inheritExisting bool) (err error) = userenv.CreateEnvironmentBlock
 //sys  DestroyEnvironmentBlock(block *uint16) (err error) = userenv.DestroyEnvironmentBlock
+
+//sys  RtlGenRandom(buf []byte) (err error) = advapi32.SystemFunction036

diff --git a/src/internal/syscall/windows/zsyscall_windows.go b/src/internal/syscall/windows/zsyscall_windows.go
index 170b239486d4246c7d3aa451a4dc61f621863631..aaad4a5b94b7e5f7a277c021790a2d94dbb09bf9 100644 (file)
--- a/src/internal/syscall/windows/zsyscall_windows.go
+++ b/src/internal/syscall/windows/zsyscall_windows.go
@@ -52,6 +52,7 @@ var (
        procOpenThreadToken              = modadvapi32.NewProc("OpenThreadToken")
        procRevertToSelf                 = modadvapi32.NewProc("RevertToSelf")
        procSetTokenInformation          = modadvapi32.NewProc("SetTokenInformation")
+       procSystemFunction036            = modadvapi32.NewProc("SystemFunction036")
        procGetAdaptersAddresses         = modiphlpapi.NewProc("GetAdaptersAddresses")
        procGetACP                       = modkernel32.NewProc("GetACP")
        procGetComputerNameExW           = modkernel32.NewProc("GetComputerNameExW")
@@ -140,6 +141,18 @@ func SetTokenInformation(tokenHandle syscall.Token, tokenInformationClass uint32
        return
 }
 
+func RtlGenRandom(buf []byte) (err error) {
+       var _p0 *byte
+       if len(buf) > 0 {
+               _p0 = &buf[0]
+       }
+       r1, _, e1 := syscall.Syscall(procSystemFunction036.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), 0)
+       if r1 == 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
 func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) {
        r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0)
        if r0 != 0 {

diff --git a/src/io/fs/fs.go b/src/io/fs/fs.go
index d9f89fc6ee56bd85c2bb11cd5ff44bfb2edf4fa0..3d2e2ee2ac953020780614885c0279705f56dbbe 100644 (file)
--- a/src/io/fs/fs.go
+++ b/src/io/fs/fs.go
@@ -10,14 +10,14 @@ package fs
 import (
        "internal/oserror"
        "time"
+       "unicode/utf8"
 )
 
 // An FS provides access to a hierarchical file system.
 //
 // The FS interface is the minimum implementation required of the file system.
 // A file system may implement additional interfaces,
-// such as fsutil.ReadFileFS, to provide additional or optimized functionality.
-// See io/fsutil for details.
+// such as ReadFileFS, to provide additional or optimized functionality.
 type FS interface {
        // Open opens the named file.
        //
@@ -33,14 +33,22 @@ type FS interface {
 
 // ValidPath reports whether the given path name
 // is valid for use in a call to Open.
-// Path names passed to open are unrooted, slash-separated
-// sequences of path elements, like “x/y/z”.
-// Path names must not contain a “.” or “..” or empty element,
+//
+// Path names passed to open are UTF-8-encoded,
+// unrooted, slash-separated sequences of path elements, like “x/y/z”.
+// Path names must not contain an element that is “.” or “..” or the empty string,
 // except for the special case that the root directory is named “.”.
+// Paths must not start or end with a slash: “/x” and “x/” are invalid.
 //
-// Paths are slash-separated on all systems, even Windows.
-// Backslashes must not appear in path names.
+// Note that paths are slash-separated on all systems, even Windows.
+// Paths containing other characters such as backslash and colon
+// are accepted as valid, but those characters must never be
+// interpreted by an FS implementation as path element separators.
 func ValidPath(name string) bool {
+       if !utf8.ValidString(name) {
+               return false
+       }
+
        if name == "." {
                // special case
                return true
@@ -50,9 +58,6 @@ func ValidPath(name string) bool {
        for {
                i := 0
                for i < len(name) && name[i] != '/' {
-                       if name[i] == '\\' {
-                               return false
-                       }
                        i++
                }
                elem := name[:i]

diff --git a/src/io/fs/fs_test.go b/src/io/fs/fs_test.go
index 8d395fc0db1d248ca70706b81a88edb590eec019..aae1a7606f45a6f16c36f2e7c58a5925c153c443 100644 (file)
--- a/src/io/fs/fs_test.go
+++ b/src/io/fs/fs_test.go
@@ -33,9 +33,10 @@ var isValidPathTests = []struct {
        {"x/..", false},
        {"x/../y", false},
        {"x//y", false},
-       {`x\`, false},
-       {`x\y`, false},
-       {`\x`, false},
+       {`x\`, true},
+       {`x\y`, true},
+       {`x:y`, true},
+       {`\x`, true},
 }
 
 func TestValidPath(t *testing.T) {

diff --git a/src/io/fs/glob.go b/src/io/fs/glob.go
index cde6c49f3db0c6012b513101649fe580e803294c..45d9cb61b9632af83bf9834ef99d47e6133b193b 100644 (file)
--- a/src/io/fs/glob.go
+++ b/src/io/fs/glob.go
@@ -1,4 +1,4 @@
-// Copyright 2010 The Go Authors. All rights reserved.
+// Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
@@ -6,7 +6,6 @@ package fs
 
 import (
        "path"
-       "runtime"
 )
 
 // A GlobFS is a file system with a Glob method.
@@ -22,7 +21,7 @@ type GlobFS interface {
 // Glob returns the names of all files matching pattern or nil
 // if there is no matching file. The syntax of patterns is the same
 // as in path.Match. The pattern may describe hierarchical names such as
-// /usr/*/bin/ed (assuming the Separator is '/').
+// usr/*/bin/ed.
 //
 // Glob ignores file system errors such as I/O errors reading directories.
 // The only possible returned error is path.ErrBadPattern, reporting that
@@ -111,8 +110,8 @@ func glob(fs FS, dir, pattern string, matches []string) (m []string, e error) {
 // recognized by path.Match.
 func hasMeta(path string) bool {
        for i := 0; i < len(path); i++ {
-               c := path[i]
-               if c == '*' || c == '?' || c == '[' || runtime.GOOS == "windows" && c == '\\' {
+               switch path[i] {
+               case '*', '?', '[', '\\':
                        return true
                }
        }

diff --git a/src/io/fs/glob_test.go b/src/io/fs/glob_test.go
index 5c8ac3fbf32bd968f240fcbe5fd0b150b9039d35..f19bebed77f6c7c7e9fad7017b94b9c557a77bca 100644 (file)
--- a/src/io/fs/glob_test.go
+++ b/src/io/fs/glob_test.go
@@ -1,4 +1,4 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
@@ -17,6 +17,7 @@ var globTests = []struct {
 }{
        {os.DirFS("."), "glob.go", "glob.go"},
        {os.DirFS("."), "gl?b.go", "glob.go"},
+       {os.DirFS("."), `gl\ob.go`, "glob.go"},
        {os.DirFS("."), "*", "glob.go"},
        {os.DirFS(".."), "*/glob.go", "fs/glob.go"},
 }
@@ -32,7 +33,7 @@ func TestGlob(t *testing.T) {
                        t.Errorf("Glob(%#q) = %#v want %v", tt.pattern, matches, tt.result)
                }
        }
-       for _, pattern := range []string{"no_match", "../*/no_match"} {
+       for _, pattern := range []string{"no_match", "../*/no_match", `\*`} {
                matches, err := Glob(os.DirFS("."), pattern)
                if err != nil {
                        t.Errorf("Glob error for %q: %s", pattern, err)

diff --git a/src/io/fs/walk.go b/src/io/fs/walk.go
index 06d0b1769c5515e49f6909656cfd00575d90948b..534876bad342051d31bed119f35d45a707ba3a5f 100644 (file)
--- a/src/io/fs/walk.go
+++ b/src/io/fs/walk.go
@@ -15,18 +15,13 @@ import (
 var SkipDir = errors.New("skip this directory")
 
 // WalkDirFunc is the type of the function called by WalkDir to visit
-// each each file or directory.
+// each file or directory.
 //
-// The path argument contains the argument to Walk as a prefix.
-// That is, if Walk is called with root argument "dir" and finds a file
+// The path argument contains the argument to WalkDir as a prefix.
+// That is, if WalkDir is called with root argument "dir" and finds a file
 // named "a" in that directory, the walk function will be called with
 // argument "dir/a".
 //
-// The directory and file are joined with Join, which may clean the
-// directory name: if Walk is called with the root argument "x/../dir"
-// and finds a file named "a" in that directory, the walk function will
-// be called with argument "dir/a", not "x/../dir/a".
-//
 // The d argument is the fs.DirEntry for the named path.
 //
 // The error result returned by the function controls how WalkDir
@@ -42,9 +37,9 @@ var SkipDir = errors.New("skip this directory")
 //
 // WalkDir calls the function with a non-nil err argument in two cases.
 //
-// First, if the initial os.Lstat on the root directory fails, WalkDir
+// First, if the initial fs.Stat on the root directory fails, WalkDir
 // calls the function with path set to root, d set to nil, and err set to
-// the error from os.Lstat.
+// the error from fs.Stat.
 //
 // Second, if a directory's ReadDir method fails, WalkDir calls the
 // function with path set to the directory's path, d set to an

diff --git a/src/io/fs/walk_test.go b/src/io/fs/walk_test.go
index 395471e2e8a5bf15e2b4dfb50299acac95135813..ebc4e50fb319deaa05241ab84a04266742a0d08e 100644 (file)
--- a/src/io/fs/walk_test.go
+++ b/src/io/fs/walk_test.go
@@ -9,7 +9,6 @@ import (
        "io/ioutil"
        "os"
        pathpkg "path"
-       "runtime"
        "testing"
        "testing/fstest"
 )
@@ -96,32 +95,7 @@ func mark(entry DirEntry, err error, errors *[]error, clear bool) error {
        return nil
 }
 
-func chtmpdir(t *testing.T) (restore func()) {
-       oldwd, err := os.Getwd()
-       if err != nil {
-               t.Fatalf("chtmpdir: %v", err)
-       }
-       d, err := ioutil.TempDir("", "test")
-       if err != nil {
-               t.Fatalf("chtmpdir: %v", err)
-       }
-       if err := os.Chdir(d); err != nil {
-               t.Fatalf("chtmpdir: %v", err)
-       }
-       return func() {
-               if err := os.Chdir(oldwd); err != nil {
-                       t.Fatalf("chtmpdir: %v", err)
-               }
-               os.RemoveAll(d)
-       }
-}
-
 func TestWalkDir(t *testing.T) {
-       if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
-               restore := chtmpdir(t)
-               defer restore()
-       }
-
        tmpDir, err := ioutil.TempDir("", "TestWalk")
        if err != nil {
                t.Fatal("creating temp dir:", err)

diff --git a/src/io/ioutil/example_test.go b/src/io/ioutil/example_test.go
index bc2b6fba736098fe35997949592afe675415d652..78b0730c652a31e8c8a0d3742ab78d2d37fa675a 100644 (file)
--- a/src/io/ioutil/example_test.go
+++ b/src/io/ioutil/example_test.go
@@ -125,7 +125,7 @@ func ExampleReadFile() {
 
 func ExampleWriteFile() {
        message := []byte("Hello, Gophers!")
-       err := ioutil.WriteFile("testdata/hello", message, 0644)
+       err := ioutil.WriteFile("hello", message, 0644)
        if err != nil {
                log.Fatal(err)
        }

diff --git a/src/math/asin_386.s b/src/math/asin_386.s
deleted file mode 100644 (file)
index 7dab390..0000000
--- a/src/math/asin_386.s
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Asin(x float64) float64
-TEXT ·Asin(SB),NOSPLIT,$0
-       FMOVD   x+0(FP), F0  // F0=sin(x)
-       FMOVD   F0, F1       // F0=sin(x), F1=sin(x)
-       FMULD   F0, F0       // F0=sin(x)*sin(x), F1=sin(x)
-       FLD1                 // F0=1, F1=sin(x)*sin(x), F2=sin(x)
-       FSUBRDP F0, F1       // F0=1-sin(x)*sin(x) (=cos(x)*cos(x)), F1=sin(x)
-       FSQRT                // F0=cos(x), F1=sin(x)
-       FPATAN               // F0=arcsin(sin(x))=x
-       FMOVDP  F0, ret+8(FP)
-       RET
-
-// func Acos(x float64) float64
-TEXT ·Acos(SB),NOSPLIT,$0
-       FMOVD   x+0(FP), F0  // F0=cos(x)
-       FMOVD   F0, F1       // F0=cos(x), F1=cos(x)
-       FMULD   F0, F0       // F0=cos(x)*cos(x), F1=cos(x)
-       FLD1                 // F0=1, F1=cos(x)*cos(x), F2=cos(x)
-       FSUBRDP F0, F1       // F0=1-cos(x)*cos(x) (=sin(x)*sin(x)), F1=cos(x)
-       FSQRT                // F0=sin(x), F1=cos(x)
-       FXCHD   F0, F1       // F0=cos(x), F1=sin(x)
-       FPATAN               // F0=arccos(cos(x))=x
-       FMOVDP  F0, ret+8(FP)
-       RET

diff --git a/src/math/atan2_386.s b/src/math/atan2_386.s
deleted file mode 100644 (file)
index 90d211b..0000000
--- a/src/math/atan2_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Atan2(y, x float64) float64    // =atan(y/x)
-TEXT ·Atan2(SB),NOSPLIT,$0
-       FMOVD   y+0(FP), F0  // F0=y
-       FMOVD   x+8(FP), F0  // F0=x, F1=y
-       FPATAN               // F0=atan(F1/F0)
-       FMOVDP  F0, ret+16(FP)
-       RET

diff --git a/src/math/atan_386.s b/src/math/atan_386.s
deleted file mode 100644 (file)
index 43e79b9..0000000
--- a/src/math/atan_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Atan(x float64) float64
-TEXT ·Atan(SB),NOSPLIT,$0
-       FMOVD   x+0(FP), F0  // F0=x
-       FLD1                 // F0=1, F1=x
-       FPATAN               // F0=atan(F1/F0)
-       FMOVDP  F0, ret+8(FP)
-       RET

diff --git a/src/math/big/nat.go b/src/math/big/nat.go
index 068176e1c1a18c59a8a8bb0a0a13f644a140e4cd..bbd6c8850b604b365011144e9ab8e6744ee27354 100644 (file)
--- a/src/math/big/nat.go
+++ b/src/math/big/nat.go
@@ -881,7 +881,7 @@ func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
                // then floor(u1/v1) >= floor(u/v)
                //
                // Moreover, the difference is at most 2 if len(v1) >= len(u/v)
-               // We choose s = B-1 since len(v)-B >= B+1 >= len(u/v)
+               // We choose s = B-1 since len(v)-s >= B+1 >= len(u/v)
                s := (B - 1)
                // Except for the first step, the top bits are always
                // a division remainder, so the quotient length is <= n.

diff --git a/src/math/big/nat_test.go b/src/math/big/nat_test.go
index 89e913fc16ea4954737e316b657aea7a4aa500c1..08508189321795872257cf110963455a39c5c32c 100644 (file)
--- a/src/math/big/nat_test.go
+++ b/src/math/big/nat_test.go
@@ -804,3 +804,13 @@ func TestIssue37499(t *testing.T) {
                t.Fatalf("incorrect quotient: %s", s)
        }
 }
+
+// TestIssue42552 triggers an edge case of recursive division
+// where the first division loop is never entered, and correcting
+// the remainder takes exactly two iterations in the final loop.
+func TestIssue42552(t *testing.T) {
+       u := natFromString("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")
+       v := natFromString("0x838332321d443a3d30373d47301d47073847473a383d3030f25b3d3d3e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002e00000000000000000041603038331c3d32f5303441e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e01c0a5459bfc7b9be9fcbb9d2383840464319434707303030f43a32f53034411c0a5459413820878787878787878787878787878787878787878787878787878787878787878787870630303a3a30334036605b923a6101f83638413943413960204337602043323801526040523241846038414143015238604060328452413841413638523c0240384141364036605b923a6101f83638413943413960204334602043323801526040523241846038414143015238604060328452413841413638523c02403841413638433030f25a8b83838383838383838383838383838383837d838383ffffffffffffffff838383838383838383000000000000000000030000007d26e27c7c8b83838383838383838383838383838383837d838383ffffffffffffffff83838383838383838383838383838383838383838383435960f535073030f3343200000000000000011881301938343030fa398383300000002300000000000000000000f11af4600c845252904141364138383c60406032414443095238010241414303364443434132305b595a15434160b042385341ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff47476043410536613603593a6005411c437405fcfcfcfcfcfcfc0000000000005a3b075815054359000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+       q := nat(nil).make(16)
+       q.div(q, u, v)
+}

diff --git a/src/math/exp2_386.s b/src/math/exp2_386.s
deleted file mode 100644 (file)
index d04cad6..0000000
--- a/src/math/exp2_386.s
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Exp2(x float64) float64
-TEXT ·Exp2(SB),NOSPLIT,$0
-// test bits for not-finite
-       MOVL    x_hi+4(FP), AX
-       ANDL    $0x7ff00000, AX
-       CMPL    AX, $0x7ff00000
-       JEQ     not_finite
-       FMOVD   x+0(FP), F0   // F0=x
-       FMOVD   F0, F1        // F0=x, F1=x
-       FRNDINT               // F0=int(x), F1=x
-       FSUBD   F0, F1        // F0=int(x), F1=x-int(x)
-       FXCHD   F0, F1        // F0=x-int(x), F1=int(x)
-       F2XM1                 // F0=2**(x-int(x))-1, F1=int(x)
-       FLD1                  // F0=1, F1=2**(x-int(x))-1, F2=int(x)
-       FADDDP  F0, F1        // F0=2**(x-int(x)), F1=int(x)
-       FSCALE                // F0=2**x, F1=int(x)
-       FMOVDP  F0, F1        // F0=2**x
-       FMOVDP  F0, ret+8(FP)
-       RET
-not_finite:
-// test bits for -Inf
-       MOVL    x_hi+4(FP), BX
-       MOVL    x_lo+0(FP), CX
-       CMPL    BX, $0xfff00000
-       JNE     not_neginf
-       CMPL    CX, $0
-       JNE     not_neginf
-       MOVL    $0, ret_lo+8(FP)
-       MOVL    $0, ret_hi+12(FP)
-       RET
-not_neginf:
-       MOVL    CX, ret_lo+8(FP)
-       MOVL    BX, ret_hi+12(FP)
-       RET

diff --git a/src/math/expm1_386.s b/src/math/expm1_386.s
deleted file mode 100644 (file)
index d020296..0000000
--- a/src/math/expm1_386.s
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Expm1(x float64) float64
-TEXT ·Expm1(SB),NOSPLIT,$0
-       FLDLN2               // F0=log(2) = 1/log2(e) ~ 0.693147
-       FMOVD   x+0(FP), F0  // F0=x, F1=1/log2(e)
-       FABS                 // F0=|x|, F1=1/log2(e)
-       FUCOMPP F0, F1       // compare F0 to F1
-       FSTSW   AX
-       SAHF
-       JCC     use_exp      // jump if F0 >= F1
-       FLDL2E                // F0=log2(e)
-       FMULD   x+0(FP), F0   // F0=x*log2(e) (-1<F0<1)
-       F2XM1                 // F0=e**x-1 = 2**(x*log2(e))-1
-       FMOVDP  F0, ret+8(FP)
-       RET
-use_exp:
-// test bits for not-finite
-       MOVL    x_hi+4(FP), AX
-       ANDL    $0x7ff00000, AX
-       CMPL    AX, $0x7ff00000
-       JEQ     not_finite
-       FLDL2E                // F0=log2(e)
-       FMULD   x+0(FP), F0   // F0=x*log2(e)
-       FMOVD   F0, F1        // F0=x*log2(e), F1=x*log2(e)
-       FRNDINT               // F0=int(x*log2(e)), F1=x*log2(e)
-       FSUBD   F0, F1        // F0=int(x*log2(e)), F1=x*log2(e)-int(x*log2(e))
-       FXCHD   F0, F1        // F0=x*log2(e)-int(x*log2(e)), F1=int(x*log2(e))
-       F2XM1                 // F0=2**(x*log2(e)-int(x*log2(e)))-1, F1=int(x*log2(e))
-       FLD1                  // F0=1, F1=2**(x*log2(e)-int(x*log2(e)))-1, F2=int(x*log2(e))
-       FADDDP  F0, F1        // F0=2**(x*log2(e)-int(x*log2(e))), F1=int(x*log2(e))
-       FSCALE                // F0=e**x, F1=int(x*log2(e))
-       FMOVDP  F0, F1        // F0=e**x
-       FLD1                  // F0=1, F1=e**x
-       FSUBDP  F0, F1        // F0=e**x-1
-       FMOVDP  F0, ret+8(FP)
-       RET
-not_finite:
-// test bits for -Inf
-       MOVL    x_hi+4(FP), BX
-       MOVL    x_lo+0(FP), CX
-       CMPL    BX, $0xfff00000
-       JNE     not_neginf
-       CMPL    CX, $0
-       JNE     not_neginf
-       FLD1                 // F0=1
-       FCHS                 // F0=-1
-       FMOVDP  F0, ret+8(FP)
-       RET
-not_neginf:
-       MOVL    CX, ret_lo+8(FP)
-       MOVL    BX, ret_hi+12(FP)
-       RET

diff --git a/src/math/frexp_386.s b/src/math/frexp_386.s
deleted file mode 100644 (file)
index 832b435..0000000
--- a/src/math/frexp_386.s
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Frexp(f float64) (frac float64, exp int)
-TEXT ·Frexp(SB),NOSPLIT,$0
-       FMOVD   f+0(FP), F0   // F0=f
-       FXAM
-       FSTSW   AX
-       SAHF
-       JNP     nan_zero_inf
-       JCS     nan_zero_inf
-       FXTRACT               // F0=f (0<=f<1), F1=e
-       FMULD  $(0.5), F0     // F0=f (0.5<=f<1), F1=e
-       FMOVDP  F0, frac+8(FP)   // F0=e
-       FLD1                  // F0=1, F1=e
-       FADDDP  F0, F1        // F0=e+1
-       FMOVLP  F0, exp+16(FP)  // (int=int32)
-       RET
-nan_zero_inf:
-       FMOVDP  F0, frac+8(FP)   // F0=e
-       MOVL    $0, exp+16(FP)  // exp=0
-       RET

diff --git a/src/math/ldexp_386.s b/src/math/ldexp_386.s
deleted file mode 100644 (file)
index 6f67ae1..0000000
--- a/src/math/ldexp_386.s
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Ldexp(frac float64, exp int) float64
-TEXT ·Ldexp(SB),NOSPLIT,$0
-       FMOVL   exp+8(FP), F0   // F0=exp
-       FMOVD   frac+0(FP), F0   // F0=frac, F1=e
-       FSCALE                // F0=x*2**e, F1=e
-       FMOVDP  F0, F1        // F0=x*2**e
-       FMOVDP  F0, ret+12(FP)
-       RET

diff --git a/src/math/log10_386.s b/src/math/log10_386.s
deleted file mode 100644 (file)
index 10eecd9..0000000
--- a/src/math/log10_386.s
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Log10(x float64) float64
-TEXT ·Log10(SB),NOSPLIT,$0
-       FLDLG2               // F0=log10(2)
-       FMOVD   x+0(FP), F0  // F0=x, F1=log10(2)
-       FYL2X                // F0=log10(x)=log2(x)*log10(2)
-       FMOVDP  F0, ret+8(FP)
-       RET
-
-// func Log2(x float64) float64
-TEXT ·Log2(SB),NOSPLIT,$0
-       FLD1                 // F0=1
-       FMOVD   x+0(FP), F0  // F0=x, F1=1
-       FYL2X                // F0=log2(x)
-       FMOVDP  F0, ret+8(FP)
-       RET

diff --git a/src/math/log1p_386.s b/src/math/log1p_386.s
deleted file mode 100644 (file)
index 63b7e62..0000000
--- a/src/math/log1p_386.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Log1p(x float64) float64
-TEXT ·Log1p(SB),NOSPLIT,$0
-       FMOVD   $(2.928932188134524e-01), F0
-       FMOVD   x+0(FP), F0  // F0=x, F1=1-sqrt(2)/2 = 0.29289321881345247559915564
-       FABS                 // F0=|x|, F1=1-sqrt(2)/2
-       FUCOMPP F0, F1       // compare F0 to F1
-       FSTSW   AX
-       FLDLN2               // F0=log(2)
-       ANDW    $0x0100, AX
-       JEQ     use_fyl2x    // jump if F0 >= F1
-       FMOVD   x+0(FP), F0  // F0=x, F1=log(2)
-       FYL2XP1              // F0=log(1+x)=log2(1+x)*log(2)
-       FMOVDP  F0, ret+8(FP)
-       RET
-use_fyl2x:
-       FLD1                 // F0=1, F2=log(2)
-       FADDD   x+0(FP), F0  // F0=1+x, F1=log(2)
-       FYL2X                // F0=log(1+x)=log2(1+x)*log(2)
-       FMOVDP  F0, ret+8(FP)
-       RET
-

diff --git a/src/math/log_386.s b/src/math/log_386.s
deleted file mode 100644 (file)
index 0b64b50..0000000
--- a/src/math/log_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Log(x float64) float64
-TEXT ·Log(SB),NOSPLIT,$0
-       FLDLN2               // F0=log(2)
-       FMOVD   x+0(FP), F0  // F0=x, F1=log(2)
-       FYL2X                // F0=log(x)=log2(x)*log(2)
-       FMOVDP  F0, ret+8(FP)
-       RET

diff --git a/src/math/mod_386.s b/src/math/mod_386.s
deleted file mode 100644 (file)
index 10ad98b..0000000
--- a/src/math/mod_386.s
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Mod(x, y float64) float64
-TEXT ·Mod(SB),NOSPLIT,$0
-       FMOVD   y+8(FP), F0  // F0=y
-       FMOVD   x+0(FP), F0  // F0=x, F1=y
-       FPREM                // F0=reduced_x, F1=y
-       FSTSW   AX           // AX=status word
-       ANDW    $0x0400, AX
-       JNE     -3(PC)       // jump if reduction incomplete
-       FMOVDP  F0, F1       // F0=x-q*y
-       FMOVDP  F0, ret+16(FP)
-       RET

diff --git a/src/math/modf_386.s b/src/math/modf_386.s
deleted file mode 100644 (file)
index e916073..0000000
--- a/src/math/modf_386.s
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Modf(f float64) (int float64, frac float64)
-TEXT ·Modf(SB),NOSPLIT,$0
-       // special case for f == -0.0
-       MOVL f_hi+4(FP), DX     // high word
-       MOVL f_lo+0(FP), AX     // low word
-       CMPL DX, $(1<<31)       // beginning of -0.0
-       JNE notNegativeZero
-       CMPL AX, $0                     // could be denormalized
-       JNE notNegativeZero
-       MOVL AX, int_lo+8(FP)
-       MOVL DX, int_hi+12(FP)
-       MOVL AX, frac_lo+16(FP)
-       MOVL DX, frac_hi+20(FP)
-       RET
-notNegativeZero:
-       FMOVD   f+0(FP), F0  // F0=f
-       FMOVD   F0, F1       // F0=f, F1=f
-       FSTCW   -2(SP)       // save old Control Word
-       MOVW    -2(SP), AX
-       ORW     $0x0c00, AX  // Rounding Control set to truncate
-       MOVW    AX, -4(SP)   // store new Control Word
-       FLDCW   -4(SP)       // load new Control Word
-       FRNDINT              // F0=trunc(f), F1=f
-       FLDCW   -2(SP)       // load old Control Word
-       FSUBD   F0, F1       // F0=trunc(f), F1=f-trunc(f)
-       FMOVDP  F0, int+8(FP)  // F0=f-trunc(f)
-       FMOVDP  F0, frac+16(FP)
-       RET

diff --git a/src/math/rand/gen_cooked.go b/src/math/rand/gen_cooked.go
index 567b7a8d14c386add0f5d4498c78ed335d3b2f05..0afc10d727ecd11e122cca61d6bd9d769bfd8572 100644 (file)
--- a/src/math/rand/gen_cooked.go
+++ b/src/math/rand/gen_cooked.go
@@ -4,7 +4,7 @@
 
 // +build ignore
 
-// This program computes the value of rng_cooked in rng.go,
+// This program computes the value of rngCooked in rng.go,
 // which is used for seeding all instances of rand.Source.
 // a 64bit and a 63bit version of the array is printed to
 // the standard output.

diff --git a/src/math/remainder_386.s b/src/math/remainder_386.s
deleted file mode 100644 (file)
index 318fa2c..0000000
--- a/src/math/remainder_386.s
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "textflag.h"
-
-// func Remainder(x, y float64) float64
-TEXT ·Remainder(SB),NOSPLIT,$0
-       FMOVD   y+8(FP), F0  // F0=y
-       FMOVD   x+0(FP), F0  // F0=x, F1=y
-       FPREM1               // F0=reduced_x, F1=y
-       FSTSW   AX           // AX=status word
-       ANDW    $0x0400, AX
-       JNE     -3(PC)       // jump if reduction incomplete
-       FMOVDP  F0, F1       // F0=x-q*y
-       FMOVDP  F0, ret+16(FP)
-       RET

diff --git a/src/math/sqrt.go b/src/math/sqrt.go
index 7e95f2365b8d387ac60ac3d31df6b050e352060f..1077a62897d94ce7a69d4dcd573b82962e54a469 100644 (file)
--- a/src/math/sqrt.go
+++ b/src/math/sqrt.go
@@ -67,7 +67,7 @@ package math
 //
 //      One may easily use induction to prove (4) and (5).
 //      Note. Since the left hand side of (3) contain only i+2 bits,
-//            it does not necessary to do a full (53-bit) comparison
+//            it is not necessary to do a full (53-bit) comparison
 //            in (3).
 //   3. Final rounding
 //      After generating the 53 bits result, we compute one more bit.

diff --git a/src/math/stubs_386.s b/src/math/stubs_386.s
index 92c8621523edd14f8461d3fb8812f985312e6239..bccb3edd110aa8e8532ba8edde7ab4a80ab09463 100644 (file)
--- a/src/math/stubs_386.s
+++ b/src/math/stubs_386.s
@@ -4,12 +4,24 @@
 
 #include "textflag.h"
 
+TEXT ·Acos(SB), NOSPLIT, $0
+       JMP ·acos(SB)
+
 TEXT ·Acosh(SB), NOSPLIT, $0
        JMP ·acosh(SB)
 
+TEXT ·Asin(SB), NOSPLIT, $0
+       JMP ·asin(SB)
+
 TEXT ·Asinh(SB), NOSPLIT, $0
        JMP ·asinh(SB)
 
+TEXT ·Atan(SB), NOSPLIT, $0
+       JMP ·atan(SB)
+
+TEXT ·Atan2(SB), NOSPLIT, $0
+       JMP ·atan2(SB)
+
 TEXT ·Atanh(SB), NOSPLIT, $0
        JMP ·atanh(SB)
 
@@ -31,15 +43,48 @@ TEXT ·Erfc(SB), NOSPLIT, $0
 TEXT ·Exp(SB), NOSPLIT, $0
        JMP ·exp(SB)
 
+TEXT ·Exp2(SB), NOSPLIT, $0
+       JMP ·exp2(SB)
+
+TEXT ·Expm1(SB), NOSPLIT, $0
+       JMP ·expm1(SB)
+
+TEXT ·Frexp(SB), NOSPLIT, $0
+       JMP ·frexp(SB)
+
+TEXT ·Ldexp(SB), NOSPLIT, $0
+       JMP ·ldexp(SB)
+
+TEXT ·Log10(SB), NOSPLIT, $0
+       JMP ·log10(SB)
+
+TEXT ·Log2(SB), NOSPLIT, $0
+       JMP ·log2(SB)
+
+TEXT ·Log1p(SB), NOSPLIT, $0
+       JMP ·log1p(SB)
+
+TEXT ·Log(SB), NOSPLIT, $0
+       JMP ·log(SB)
+
 TEXT ·Max(SB), NOSPLIT, $0
        JMP ·max(SB)
 
 TEXT ·Min(SB), NOSPLIT, $0
        JMP ·min(SB)
 
+TEXT ·Mod(SB), NOSPLIT, $0
+       JMP ·mod(SB)
+
+TEXT ·Modf(SB), NOSPLIT, $0
+       JMP ·modf(SB)
+
 TEXT ·Pow(SB), NOSPLIT, $0
        JMP ·pow(SB)
 
+TEXT ·Remainder(SB), NOSPLIT, $0
+       JMP ·remainder(SB)
+
 TEXT ·Sin(SB), NOSPLIT, $0
        JMP ·sin(SB)
 

diff --git a/src/net/conn_test.go b/src/net/conn_test.go
index 6854898da2ab09534fa8ecc5176de17dc9314913..771cabcd3cd331d34e1958fdb05cb8b33952d596 100644 (file)
--- a/src/net/conn_test.go
+++ b/src/net/conn_test.go
@@ -32,7 +32,7 @@ func TestConnAndListener(t *testing.T) {
                }
                defer ls.teardown()
                ch := make(chan error, 1)
-               handler := func(ls *localServer, ln Listener) { transponder(ln, ch) }
+               handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
                if err := ls.buildup(handler); err != nil {
                        t.Fatal(err)
                }

diff --git a/src/net/http/fcgi/child.go b/src/net/http/fcgi/child.go
index e97b8440e1d372a71782eb8ada4261a7b83f0cfc..756722ba1412a2dcc4e55a2f6e1e6ea4772d3ef6 100644 (file)
--- a/src/net/http/fcgi/child.go
+++ b/src/net/http/fcgi/child.go
@@ -171,12 +171,9 @@ func (c *child) serve() {
        defer c.cleanUp()
        var rec record
        for {
-               c.conn.mutex.Lock()
                if err := rec.read(c.conn.rwc); err != nil {
-                       c.conn.mutex.Unlock()
                        return
                }
-               c.conn.mutex.Unlock()
                if err := c.handleRecord(&rec); err != nil {
                        return
                }

diff --git a/src/net/http/fcgi/fcgi_test.go b/src/net/http/fcgi/fcgi_test.go
index d3b704f8219b907057742f99dbf92cd98c9a09da..b58111de208dee2e05f8f46096bddba1f1a7ec74 100644 (file)
--- a/src/net/http/fcgi/fcgi_test.go
+++ b/src/net/http/fcgi/fcgi_test.go
@@ -221,7 +221,11 @@ var cleanUpTests = []struct {
 }
 
 type nopWriteCloser struct {
-       io.ReadWriter
+       io.Reader
+}
+
+func (nopWriteCloser) Write(buf []byte) (int, error) {
+       return len(buf), nil
 }
 
 func (nopWriteCloser) Close() error {
@@ -235,7 +239,7 @@ func TestChildServeCleansUp(t *testing.T) {
        for _, tt := range cleanUpTests {
                input := make([]byte, len(tt.input))
                copy(input, tt.input)
-               rc := nopWriteCloser{bytes.NewBuffer(input)}
+               rc := nopWriteCloser{bytes.NewReader(input)}
                done := make(chan bool)
                c := newChild(rc, http.HandlerFunc(func(
                        w http.ResponseWriter,
@@ -325,7 +329,7 @@ func TestChildServeReadsEnvVars(t *testing.T) {
        for _, tt := range envVarTests {
                input := make([]byte, len(tt.input))
                copy(input, tt.input)
-               rc := nopWriteCloser{bytes.NewBuffer(input)}
+               rc := nopWriteCloser{bytes.NewReader(input)}
                done := make(chan bool)
                c := newChild(rc, http.HandlerFunc(func(
                        w http.ResponseWriter,
@@ -375,7 +379,7 @@ func TestResponseWriterSniffsContentType(t *testing.T) {
                t.Run(tt.name, func(t *testing.T) {
                        input := make([]byte, len(streamFullRequestStdin))
                        copy(input, streamFullRequestStdin)
-                       rc := nopWriteCloser{bytes.NewBuffer(input)}
+                       rc := nopWriteCloser{bytes.NewReader(input)}
                        done := make(chan bool)
                        var resp *response
                        c := newChild(rc, http.HandlerFunc(func(

diff --git a/src/net/http/httputil/dump.go b/src/net/http/httputil/dump.go
index 4c9d28bed8faffeeb99620ce6a074da5033a12fc..2948f27e5d5c58b4b93a7b3452b56b7062264406 100644 (file)
--- a/src/net/http/httputil/dump.go
+++ b/src/net/http/httputil/dump.go
@@ -138,6 +138,8 @@ func DumpRequestOut(req *http.Request, body bool) ([]byte, error) {
                select {
                case dr.c <- strings.NewReader("HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n"):
                case <-quitReadCh:
+                       // Ensure delegateReader.Read doesn't block forever if we get an error.
+                       close(dr.c)
                }
        }()
 
@@ -146,7 +148,8 @@ func DumpRequestOut(req *http.Request, body bool) ([]byte, error) {
        req.Body = save
        if err != nil {
                pw.Close()
-               quitReadCh <- struct{}{}
+               dr.err = err
+               close(quitReadCh)
                return nil, err
        }
        dump := buf.Bytes()
@@ -167,13 +170,17 @@ func DumpRequestOut(req *http.Request, body bool) ([]byte, error) {
 // delegateReader is a reader that delegates to another reader,
 // once it arrives on a channel.
 type delegateReader struct {
-       c chan io.Reader
-       r io.Reader // nil until received from c
+       c   chan io.Reader
+       err error     // only used if r is nil and c is closed.
+       r   io.Reader // nil until received from c
 }
 
 func (r *delegateReader) Read(p []byte) (int, error) {
        if r.r == nil {
-               r.r = <-r.c
+               var ok bool
+               if r.r, ok = <-r.c; !ok {
+                       return 0, r.err
+               }
        }
        return r.r.Read(p)
 }

diff --git a/src/net/http/httputil/dump_test.go b/src/net/http/httputil/dump_test.go
index 7571eb0820d33254071994ca616df9cb07c771bb..8168b2ebc05d0d633a43226f37e5e7d03b51fb4e 100644 (file)
--- a/src/net/http/httputil/dump_test.go
+++ b/src/net/http/httputil/dump_test.go
@@ -7,13 +7,17 @@ package httputil
 import (
        "bufio"
        "bytes"
+       "context"
        "fmt"
        "io"
+       "math/rand"
        "net/http"
        "net/url"
        "runtime"
+       "runtime/pprof"
        "strings"
        "testing"
+       "time"
 )
 
 type eofReader struct{}
@@ -311,11 +315,39 @@ func TestDumpRequest(t *testing.T) {
                        }
                }
        }
-       if dg := runtime.NumGoroutine() - numg0; dg > 4 {
-               buf := make([]byte, 4096)
-               buf = buf[:runtime.Stack(buf, true)]
-               t.Errorf("Unexpectedly large number of new goroutines: %d new: %s", dg, buf)
+
+       // Validate we haven't leaked any goroutines.
+       var dg int
+       dl := deadline(t, 5*time.Second, time.Second)
+       for time.Now().Before(dl) {
+               if dg = runtime.NumGoroutine() - numg0; dg <= 4 {
+                       // No unexpected goroutines.
+                       return
+               }
+
+               // Allow goroutines to schedule and die off.
+               runtime.Gosched()
+       }
+
+       buf := make([]byte, 4096)
+       buf = buf[:runtime.Stack(buf, true)]
+       t.Errorf("Unexpectedly large number of new goroutines: %d new: %s", dg, buf)
+}
+
+// deadline returns the time which is needed before t.Deadline()
+// if one is configured and it is s greater than needed in the future,
+// otherwise defaultDelay from the current time.
+func deadline(t *testing.T, defaultDelay, needed time.Duration) time.Time {
+       if dl, ok := t.Deadline(); ok {
+               if dl = dl.Add(-needed); dl.After(time.Now()) {
+                       // Allow an arbitrarily long delay.
+                       return dl
+               }
        }
+
+       // No deadline configured or its closer than needed from now
+       // so just use the default.
+       return time.Now().Add(defaultDelay)
 }
 
 func chunk(s string) string {
@@ -445,3 +477,43 @@ func TestDumpResponse(t *testing.T) {
                }
        }
 }
+
+// Issue 38352: Check for deadlock on cancelled requests.
+func TestDumpRequestOutIssue38352(t *testing.T) {
+       if testing.Short() {
+               return
+       }
+       t.Parallel()
+
+       timeout := 10 * time.Second
+       if deadline, ok := t.Deadline(); ok {
+               timeout = time.Until(deadline)
+               timeout -= time.Second * 2 // Leave 2 seconds to report failures.
+       }
+       for i := 0; i < 1000; i++ {
+               delay := time.Duration(rand.Intn(5)) * time.Millisecond
+               ctx, cancel := context.WithTimeout(context.Background(), delay)
+               defer cancel()
+
+               r := bytes.NewBuffer(make([]byte, 10000))
+               req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://example.com", r)
+               if err != nil {
+                       t.Fatal(err)
+               }
+
+               out := make(chan error)
+               go func() {
+                       _, err = DumpRequestOut(req, true)
+                       out <- err
+               }()
+
+               select {
+               case <-out:
+               case <-time.After(timeout):
+                       b := &bytes.Buffer{}
+                       fmt.Fprintf(b, "deadlock detected on iteration %d after %s with delay: %v\n", i, timeout, delay)
+                       pprof.Lookup("goroutine").WriteTo(b, 1)
+                       t.Fatal(b.String())
+               }
+       }
+}

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 2bfcfb95459633d0805215db38dd72a26f301c56..5389a388c17de3dd2c7dc9b4263c6c49942ec87b 100644 (file)
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -91,7 +91,7 @@ func init() {
 func Cmdline(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-       fmt.Fprintf(w, strings.Join(os.Args, "\x00"))
+       fmt.Fprint(w, strings.Join(os.Args, "\x00"))
 }
 
 func sleep(r *http.Request, d time.Duration) {

diff --git a/src/net/http/response.go b/src/net/http/response.go
index b95abae646b10a9c9549a142cdb79cb57d48d35d..b8985da3c80fc413ef30f640bbd8fd282e65465e 100644 (file)
--- a/src/net/http/response.go
+++ b/src/net/http/response.go
@@ -361,7 +361,12 @@ func (r *Response) isProtocolSwitch() bool {
 // isProtocolSwitchResponse reports whether the response code and
 // response header indicate a successful protocol upgrade response.
 func isProtocolSwitchResponse(code int, h Header) bool {
-       return code == StatusSwitchingProtocols &&
-               h.Get("Upgrade") != "" &&
+       return code == StatusSwitchingProtocols && isProtocolSwitchHeader(h)
+}
+
+// isProtocolSwitchHeader reports whether the request or response header
+// is for a protocol switch.
+func isProtocolSwitchHeader(h Header) bool {
+       return h.Get("Upgrade") != "" &&
                httpguts.HeaderValuesContainsToken(h["Connection"], "Upgrade")
 }

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index b1bf8e6c5e808824fc742d4f4156dc80b2d11aef..f8687416fe96c019a80e7e2ae58740f2dd7508db 100644 (file)
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -6460,13 +6460,15 @@ func TestDisableKeepAliveUpgrade(t *testing.T) {
                w.Header().Set("Connection", "Upgrade")
                w.Header().Set("Upgrade", "someProto")
                w.WriteHeader(StatusSwitchingProtocols)
-               c, _, err := w.(Hijacker).Hijack()
+               c, buf, err := w.(Hijacker).Hijack()
                if err != nil {
                        return
                }
                defer c.Close()
 
-               io.Copy(c, c)
+               // Copy from the *bufio.ReadWriter, which may contain buffered data.
+               // Copy to the net.Conn, to avoid buffering the output.
+               io.Copy(c, buf)
        }))
        s.Config.SetKeepAlivesEnabled(false)
        s.Start()
@@ -6481,6 +6483,10 @@ func TestDisableKeepAliveUpgrade(t *testing.T) {
        }
        defer resp.Body.Close()
 
+       if resp.StatusCode != StatusSwitchingProtocols {
+               t.Fatalf("unexpected status code: %v", resp.StatusCode)
+       }
+
        rwc, ok := resp.Body.(io.ReadWriteCloser)
        if !ok {
                t.Fatalf("Response.Body is not a io.ReadWriteCloser: %T", resp.Body)

diff --git a/src/net/http/server.go b/src/net/http/server.go
index 102e893d5f11fd4abffe94612defaaed6b1a716e..ad99741177d50d20ad12a3ad8f5615eb8371b42e 100644 (file)
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -1837,7 +1837,7 @@ func (c *conn) serve(ctx context.Context) {
                if d := c.server.WriteTimeout; d != 0 {
                        c.rwc.SetWriteDeadline(time.Now().Add(d))
                }
-               if err := tlsConn.HandshakeContext(ctx); err != nil {
+               if err := tlsConn.Handshake(); err != nil {
                        // If the handshake failed due to the client not speaking
                        // TLS, assume they're speaking plaintext HTTP and write a
                        // 400 response on the TLS conn's underlying net.Conn.

diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index a5830703afc56c1a08d408ad7d395a3bce5688d0..0aa48273dd385848bc04166027a5d4548494f47b 100644 (file)
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -1505,7 +1505,7 @@ func (t *Transport) decConnsPerHost(key connectMethodKey) {
 // Add TLS to a persistent connection, i.e. negotiate a TLS session. If pconn is already a TLS
 // tunnel, this function establishes a nested TLS session inside the encrypted channel.
 // The remote endpoint's name may be overridden by TLSClientConfig.ServerName.
-func (pconn *persistConn) addTLS(ctx context.Context, name string, trace *httptrace.ClientTrace) error {
+func (pconn *persistConn) addTLS(name string, trace *httptrace.ClientTrace) error {
        // Initiate TLS and check remote host name against certificate.
        cfg := cloneTLSConfig(pconn.t.TLSClientConfig)
        if cfg.ServerName == "" {
@@ -1527,7 +1527,7 @@ func (pconn *persistConn) addTLS(ctx context.Context, name string, trace *httptr
                if trace != nil && trace.TLSHandshakeStart != nil {
                        trace.TLSHandshakeStart()
                }
-               err := tlsConn.HandshakeContext(ctx)
+               err := tlsConn.Handshake()
                if timer != nil {
                        timer.Stop()
                }
@@ -1583,7 +1583,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
                        if trace != nil && trace.TLSHandshakeStart != nil {
                                trace.TLSHandshakeStart()
                        }
-                       if err := tc.HandshakeContext(ctx); err != nil {
+                       if err := tc.Handshake(); err != nil {
                                go pconn.conn.Close()
                                if trace != nil && trace.TLSHandshakeDone != nil {
                                        trace.TLSHandshakeDone(tls.ConnectionState{}, err)
@@ -1607,7 +1607,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
                        if firstTLSHost, _, err = net.SplitHostPort(cm.addr()); err != nil {
                                return nil, wrapErr(err)
                        }
-                       if err = pconn.addTLS(ctx, firstTLSHost, trace); err != nil {
+                       if err = pconn.addTLS(firstTLSHost, trace); err != nil {
                                return nil, wrapErr(err)
                        }
                }
@@ -1721,7 +1721,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
        }
 
        if cm.proxyURL != nil && cm.targetScheme == "https" {
-               if err := pconn.addTLS(ctx, cm.tlsHost(), trace); err != nil {
+               if err := pconn.addTLS(cm.tlsHost(), trace); err != nil {
                        return nil, err
                }
        }
@@ -2566,7 +2566,9 @@ func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err err
                continueCh = make(chan struct{}, 1)
        }
 
-       if pc.t.DisableKeepAlives && !req.wantsClose() {
+       if pc.t.DisableKeepAlives &&
+               !req.wantsClose() &&
+               !isProtocolSwitchHeader(req.Header) {
                req.extraHeaders().Set("Connection", "close")
        }
 

diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 7f6e0938c20fa92276120d51fdc8189e1afd7cd2..ba85a61683add300f309a9cb5a166bb1f65e5ba9 100644 (file)
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -3734,7 +3734,7 @@ func TestTransportDialTLSContext(t *testing.T) {
                if err != nil {
                        return nil, err
                }
-               return c, c.HandshakeContext(ctx)
+               return c, c.Handshake()
        }
 
        req, err := NewRequest("GET", ts.URL, nil)

diff --git a/src/net/mail/message_test.go b/src/net/mail/message_test.go
index 0daa3d6c63298ecdf45af27e7602e986f8efc01f..80a17b2853ae45bbec72c2944e10f95ba05e47b6 100644 (file)
--- a/src/net/mail/message_test.go
+++ b/src/net/mail/message_test.go
@@ -107,8 +107,8 @@ func TestDateParsing(t *testing.T) {
                        time.Date(1997, 11, 20, 9, 55, 6, 0, time.FixedZone("", -6*60*60)),
                },
                {
-                       "Thu, 20 Nov 1997 09:55:06 MDT (MDT)",
-                       time.Date(1997, 11, 20, 9, 55, 6, 0, time.FixedZone("MDT", 0)),
+                       "Thu, 20 Nov 1997 09:55:06 GMT (GMT)",
+                       time.Date(1997, 11, 20, 9, 55, 6, 0, time.UTC),
                },
                {
                        "Fri, 21 Nov 1997 09:55:06 +1300 (TOT)",
@@ -278,8 +278,8 @@ func TestDateParsingCFWS(t *testing.T) {
                        true,
                },
                {
-                       "Fri, 21 Nov 1997 09:55:06 MDT (MDT)",
-                       time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("MDT", 0)),
+                       "Fri, 21 Nov 1997 09:55:06 GMT (GMT)",
+                       time.Date(1997, 11, 21, 9, 55, 6, 0, time.UTC),
                        true,
                },
        }

diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go
index 9faf173679a5aae939626258f5db821aaa5e3630..867e31e9ae6a55823a237f89fc5335594d085ca4 100644 (file)
--- a/src/net/mockserver_test.go
+++ b/src/net/mockserver_test.go
@@ -87,6 +87,7 @@ type localServer struct {
        lnmu sync.RWMutex
        Listener
        done chan bool // signal that indicates server stopped
+       cl   []Conn    // accepted connection list
 }
 
 func (ls *localServer) buildup(handler func(*localServer, Listener)) error {
@@ -99,10 +100,16 @@ func (ls *localServer) buildup(handler func(*localServer, Listener)) error {
 
 func (ls *localServer) teardown() error {
        ls.lnmu.Lock()
+       defer ls.lnmu.Unlock()
        if ls.Listener != nil {
                network := ls.Listener.Addr().Network()
                address := ls.Listener.Addr().String()
                ls.Listener.Close()
+               for _, c := range ls.cl {
+                       if err := c.Close(); err != nil {
+                               return err
+                       }
+               }
                <-ls.done
                ls.Listener = nil
                switch network {
@@ -110,7 +117,6 @@ func (ls *localServer) teardown() error {
                        os.Remove(address)
                }
        }
-       ls.lnmu.Unlock()
        return nil
 }
 
@@ -203,7 +209,7 @@ func newDualStackServer() (*dualStackServer, error) {
        }, nil
 }
 
-func transponder(ln Listener, ch chan<- error) {
+func (ls *localServer) transponder(ln Listener, ch chan<- error) {
        defer close(ch)
 
        switch ln := ln.(type) {
@@ -220,7 +226,7 @@ func transponder(ln Listener, ch chan<- error) {
                ch <- err
                return
        }
-       defer c.Close()
+       ls.cl = append(ls.cl, c)
 
        network := ln.Addr().Network()
        if c.LocalAddr().Network() != network || c.RemoteAddr().Network() != network {

diff --git a/src/net/net_windows_test.go b/src/net/net_windows_test.go
index a0000950c6686161a3ffef5da1d225a07caa9de4..2a563a078c392b557001a2e757f782571dd2951e 100644 (file)
--- a/src/net/net_windows_test.go
+++ b/src/net/net_windows_test.go
@@ -204,12 +204,17 @@ func runCmd(args ...string) ([]byte, error) {
        return removeUTF8BOM(out), nil
 }
 
-func netshSpeaksEnglish(t *testing.T) bool {
+func checkNetsh(t *testing.T) {
        out, err := runCmd("netsh", "help")
        if err != nil {
                t.Fatal(err)
        }
-       return bytes.Contains(out, []byte("The following commands are available:"))
+       if bytes.Contains(out, []byte("The following helper DLL cannot be loaded")) {
+               t.Skipf("powershell failure:\n%s", err)
+       }
+       if !bytes.Contains(out, []byte("The following commands are available:")) {
+               t.Skipf("powershell does not speak English:\n%s", out)
+       }
 }
 
 func netshInterfaceIPShowInterface(ipver string, ifaces map[string]bool) error {
@@ -256,9 +261,7 @@ func netshInterfaceIPShowInterface(ipver string, ifaces map[string]bool) error {
 }
 
 func TestInterfacesWithNetsh(t *testing.T) {
-       if !netshSpeaksEnglish(t) {
-               t.Skip("English version of netsh required for this test")
-       }
+       checkNetsh(t)
 
        toString := func(name string, isup bool) string {
                if isup {
@@ -427,9 +430,7 @@ func netshInterfaceIPv6ShowAddress(name string, netshOutput []byte) []string {
 }
 
 func TestInterfaceAddrsWithNetsh(t *testing.T) {
-       if !netshSpeaksEnglish(t) {
-               t.Skip("English version of netsh required for this test")
-       }
+       checkNetsh(t)
 
        outIPV4, err := runCmd("netsh", "interface", "ipv4", "show", "address")
        if err != nil {

diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go
index 9f6772c7d15e08ab0d10f61d5bb9aaeea878442b..6f83f526812f80f080d009cc55547d0d27a5150b 100644 (file)
--- a/src/net/protoconn_test.go
+++ b/src/net/protoconn_test.go
@@ -72,7 +72,7 @@ func TestTCPConnSpecificMethods(t *testing.T) {
                t.Fatal(err)
        }
        ch := make(chan error, 1)
-       handler := func(ls *localServer, ln Listener) { transponder(ls.Listener, ch) }
+       handler := func(ls *localServer, ln Listener) { ls.transponder(ls.Listener, ch) }
        ls, err := (&streamListener{Listener: ln}).newLocalServer()
        if err != nil {
                t.Fatal(err)

diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go
index 657a36599f943e9f6bdf09f9c28cea0883d1c203..d6057fd83912872791a2284f8f5d026b1a17fb81 100644 (file)
--- a/src/net/sendfile_test.go
+++ b/src/net/sendfile_test.go
@@ -10,8 +10,10 @@ import (
        "bytes"
        "crypto/sha256"
        "encoding/hex"
+       "errors"
        "fmt"
        "io"
+       "io/ioutil"
        "os"
        "runtime"
        "sync"
@@ -313,3 +315,66 @@ func TestSendfilePipe(t *testing.T) {
 
        wg.Wait()
 }
+
+// Issue 43822: tests that returns EOF when conn write timeout.
+func TestSendfileOnWriteTimeoutExceeded(t *testing.T) {
+       ln, err := newLocalListener("tcp")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer ln.Close()
+
+       errc := make(chan error, 1)
+       go func(ln Listener) (retErr error) {
+               defer func() {
+                       errc <- retErr
+                       close(errc)
+               }()
+
+               conn, err := ln.Accept()
+               if err != nil {
+                       return err
+               }
+               defer conn.Close()
+
+               // Set the write deadline in the past(1h ago). It makes
+               // sure that it is always write timeout.
+               if err := conn.SetWriteDeadline(time.Now().Add(-1 * time.Hour)); err != nil {
+                       return err
+               }
+
+               f, err := os.Open(newton)
+               if err != nil {
+                       return err
+               }
+               defer f.Close()
+
+               _, err = io.Copy(conn, f)
+               if errors.Is(err, os.ErrDeadlineExceeded) {
+                       return nil
+               }
+
+               if err == nil {
+                       err = fmt.Errorf("expected ErrDeadlineExceeded, but got nil")
+               }
+               return err
+       }(ln)
+
+       conn, err := Dial("tcp", ln.Addr().String())
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer conn.Close()
+
+       n, err := io.Copy(ioutil.Discard, conn)
+       if err != nil {
+               t.Fatalf("expected nil error, but got %v", err)
+       }
+       if n != 0 {
+               t.Fatalf("expected receive zero, but got %d byte(s)", n)
+       }
+
+       if err := <-errc; err != nil {
+               t.Fatal(err)
+       }
+}

diff --git a/src/net/server_test.go b/src/net/server_test.go
index 2673b87718c40f4ffc127eb8cbcf9da33c25021f..4ac5443e6a130c5cb251bc799c382cbc825eaa7b 100644 (file)
--- a/src/net/server_test.go
+++ b/src/net/server_test.go
@@ -86,7 +86,7 @@ func TestTCPServer(t *testing.T) {
                        }
                        for i := 0; i < N; i++ {
                                ch := tpchs[i]
-                               handler := func(ls *localServer, ln Listener) { transponder(ln, ch) }
+                               handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
                                if err := lss[i].buildup(handler); err != nil {
                                        t.Fatal(err)
                                }
@@ -178,7 +178,7 @@ func TestUnixAndUnixpacketServer(t *testing.T) {
                }
                for i := 0; i < N; i++ {
                        ch := tpchs[i]
-                       handler := func(ls *localServer, ln Listener) { transponder(ln, ch) }
+                       handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
                        if err := lss[i].buildup(handler); err != nil {
                                t.Fatal(err)
                        }

diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go
index 6e905aa0914b397f2c7c00a6f0a747579a28d204..d6172bc5030996f9ba7b5e75cfc33bc155705518 100644 (file)
--- a/src/net/tcpsock_test.go
+++ b/src/net/tcpsock_test.go
@@ -393,7 +393,7 @@ func TestIPv6LinkLocalUnicastTCP(t *testing.T) {
                }
                defer ls.teardown()
                ch := make(chan error, 1)
-               handler := func(ls *localServer, ln Listener) { transponder(ln, ch) }
+               handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
                if err := ls.buildup(handler); err != nil {
                        t.Fatal(err)
                }

diff --git a/src/os/exec/lp_windows_test.go b/src/os/exec/lp_windows_test.go
index c6f3d5d406bc0d72df61f694d930cf838dbfe557..56cb54f800a08f7f58ffdd71273985f8dcceba98 100644 (file)
--- a/src/os/exec/lp_windows_test.go
+++ b/src/os/exec/lp_windows_test.go
@@ -143,7 +143,7 @@ func (test lookPathTest) run(t *testing.T, tmpdir, printpathExe string) {
        if errCmd == nil && errLP == nil {
                // both succeeded
                if should != have {
-                       t.Fatalf("test=%+v failed: expected to find %q, but found %q", test, should, have)
+                       t.Fatalf("test=%+v:\ncmd /c ran: %s\nlookpath found: %s", test, should, have)
                }
                return
        }
@@ -316,12 +316,17 @@ func TestLookPath(t *testing.T) {
 
        // Run all tests.
        for i, test := range lookPathTests {
-               dir := filepath.Join(tmp, "d"+strconv.Itoa(i))
-               err := os.Mkdir(dir, 0700)
-               if err != nil {
-                       t.Fatal("Mkdir failed: ", err)
-               }
-               test.run(t, dir, printpathExe)
+               t.Run(fmt.Sprint(i), func(t *testing.T) {
+                       if i == 16 {
+                               t.Skip("golang.org/issue/44379")
+                       }
+                       dir := filepath.Join(tmp, "d"+strconv.Itoa(i))
+                       err := os.Mkdir(dir, 0700)
+                       if err != nil {
+                               t.Fatal("Mkdir failed: ", err)
+                       }
+                       test.run(t, dir, printpathExe)
+               })
        }
 }
 

diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go
index 7ecddaed374d8a31699b5a75ddc67bda31221c1d..39f11c7ec1b7be613fd9ae5b77822183df20f607 100644 (file)
--- a/src/os/exec_posix.go
+++ b/src/os/exec_posix.go
@@ -102,7 +102,12 @@ func (p *ProcessState) String() string {
        res := ""
        switch {
        case status.Exited():
-               res = "exit status " + itoa(status.ExitStatus())
+               code := status.ExitStatus()
+               if runtime.GOOS == "windows" && code >= 1<<16 { // windows uses large hex numbers
+                       res = "exit status " + uitox(uint(code))
+               } else { // unix systems use small decimal integers
+                       res = "exit status " + itoa(code) // unix
+               }
        case status.Signaled():
                res = "signal: " + status.Signal().String()
        case status.Stopped():

diff --git a/src/os/file.go b/src/os/file.go
index 416bc0efa62bfc1d62fc9469d92d90b93abec920..52dd94339b8ffbed5ceaffaec3edd002c19ca36d 100644 (file)
--- a/src/os/file.go
+++ b/src/os/file.go
@@ -620,10 +620,21 @@ func DirFS(dir string) fs.FS {
        return dirFS(dir)
 }
 
+func containsAny(s, chars string) bool {
+       for i := 0; i < len(s); i++ {
+               for j := 0; j < len(chars); j++ {
+                       if s[i] == chars[j] {
+                               return true
+                       }
+               }
+       }
+       return false
+}
+
 type dirFS string
 
 func (dir dirFS) Open(name string) (fs.File, error) {
-       if !fs.ValidPath(name) {
+       if !fs.ValidPath(name) || runtime.GOOS == "windows" && containsAny(name, `\:`) {
                return nil, &PathError{Op: "open", Path: name, Err: ErrInvalid}
        }
        f, err := Open(string(dir) + "/" + name)

diff --git a/src/os/file_plan9.go b/src/os/file_plan9.go
index bbc732838a5f7c91b8247a2540da404acbfba633..4f384e9211061d526dd6c3ca736572e79389235d 100644 (file)
--- a/src/os/file_plan9.go
+++ b/src/os/file_plan9.go
@@ -336,16 +336,6 @@ func hasPrefix(s, prefix string) bool {
        return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
 }
 
-// LastIndexByte from the strings package.
-func lastIndex(s string, sep byte) int {
-       for i := len(s) - 1; i >= 0; i-- {
-               if s[i] == sep {
-                       return i
-               }
-       }
-       return -1
-}
-
 func rename(oldname, newname string) error {
        dirname := oldname[:lastIndex(oldname, '/')+1]
        if hasPrefix(newname, dirname) {

diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index 0dc7a5a0a295c6e0fcbac619054f3647b05d5cd4..f88450018ee3c0e76d9534093357f8a09e651823 100644 (file)
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -66,6 +66,10 @@ type file struct {
 // making it invalid; see runtime.SetFinalizer for more information on when
 // a finalizer might be run. On Unix systems this will cause the SetDeadline
 // methods to stop working.
+// Because file descriptors can be reused, the returned file descriptor may
+// only be closed through the Close method of f, or by its finalizer during
+// garbage collection. Otherwise, during garbage collection the finalizer
+// may close an unrelated file descriptor with the same (reused) number.
 //
 // As an alternative, see the f.SyscallConn method.
 func (f *File) Fd() uintptr {
@@ -90,6 +94,10 @@ func (f *File) Fd() uintptr {
 // descriptor. On Unix systems, if the file descriptor is in
 // non-blocking mode, NewFile will attempt to return a pollable File
 // (one for which the SetDeadline methods work).
+//
+// After passing it to NewFile, fd may become invalid under the same
+// conditions described in the comments of the Fd method, and the same
+// constraints apply.
 func NewFile(fd uintptr, name string) *File {
        kind := kindNewFile
        if nb, err := unix.IsNonblock(int(fd)); err == nil && nb {

diff --git a/src/os/os_test.go b/src/os/os_test.go
index 765797f5fbd525770da60d3d9a953975189911e3..a32e5fc11edfa4c5e47fc33c982b731522cad0c8 100644 (file)
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -11,6 +11,7 @@ import (
        "fmt"
        "internal/testenv"
        "io"
+       "io/fs"
        "os"
        . "os"
        osexec "os/exec"
@@ -2298,6 +2299,7 @@ func TestLongPath(t *testing.T) {
 
 func testKillProcess(t *testing.T, processKiller func(p *Process)) {
        testenv.MustHaveExec(t)
+       t.Parallel()
 
        // Re-exec the test binary itself to emulate "sleep 1".
        cmd := osexec.Command(Args[0], "-test.run", "TestSleep")
@@ -2305,14 +2307,15 @@ func testKillProcess(t *testing.T, processKiller func(p *Process)) {
        if err != nil {
                t.Fatalf("Failed to start test process: %v", err)
        }
-       go func() {
-               time.Sleep(100 * time.Millisecond)
-               processKiller(cmd.Process)
+
+       defer func() {
+               if err := cmd.Wait(); err == nil {
+                       t.Errorf("Test process succeeded, but expected to fail")
+               }
        }()
-       err = cmd.Wait()
-       if err == nil {
-               t.Errorf("Test process succeeded, but expected to fail")
-       }
+
+       time.Sleep(100 * time.Millisecond)
+       processKiller(cmd.Process)
 }
 
 // TestSleep emulates "sleep 1". It is a helper for testKillProcess, so we
@@ -2687,7 +2690,67 @@ func TestOpenFileKeepsPermissions(t *testing.T) {
 }
 
 func TestDirFS(t *testing.T) {
-       if err := fstest.TestFS(DirFS("./signal"), "signal.go", "internal/pty/pty.go"); err != nil {
+       // On Windows, we force the MFT to update by reading the actual metadata from GetFileInformationByHandle and then
+       // explicitly setting that. Otherwise it might get out of sync with FindFirstFile. See golang.org/issues/42637.
+       if runtime.GOOS == "windows" {
+               if err := filepath.WalkDir("./testdata/dirfs", func(path string, d fs.DirEntry, err error) error {
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       info, err := d.Info()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       stat, err := Stat(path) // This uses GetFileInformationByHandle internally.
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       if stat.ModTime() == info.ModTime() {
+                               return nil
+                       }
+                       if err := Chtimes(path, stat.ModTime(), stat.ModTime()); err != nil {
+                               t.Log(err) // We only log, not die, in case the test directory is not writable.
+                       }
+                       return nil
+               }); err != nil {
+                       t.Fatal(err)
+               }
+       }
+       if err := fstest.TestFS(DirFS("./testdata/dirfs"), "a", "b", "dir/x"); err != nil {
+               t.Fatal(err)
+       }
+
+       // Test that Open does not accept backslash as separator.
+       d := DirFS(".")
+       _, err := d.Open(`testdata\dirfs`)
+       if err == nil {
+               t.Fatalf(`Open testdata\dirfs succeeded`)
+       }
+}
+
+func TestDirFSPathsValid(t *testing.T) {
+       if runtime.GOOS == "windows" {
+               t.Skipf("skipping on Windows")
+       }
+
+       d := t.TempDir()
+       if err := os.WriteFile(filepath.Join(d, "control.txt"), []byte(string("Hello, world!")), 0644); err != nil {
+               t.Fatal(err)
+       }
+       if err := os.WriteFile(filepath.Join(d, `e:xperi\ment.txt`), []byte(string("Hello, colon and backslash!")), 0644); err != nil {
+               t.Fatal(err)
+       }
+
+       fsys := os.DirFS(d)
+       err := fs.WalkDir(fsys, ".", func(path string, e fs.DirEntry, err error) error {
+               if fs.ValidPath(e.Name()) {
+                       t.Logf("%q ok", e.Name())
+               } else {
+                       t.Errorf("%q INVALID", e.Name())
+               }
+               return nil
+       })
+       if err != nil {
                t.Fatal(err)
        }
 }

diff --git a/src/os/os_windows_test.go b/src/os/os_windows_test.go
index 8d1d1f61b26af7832764e66e087246508fa0cae3..b0929b4f3085a5532e7b0ce5dc75ac9953804110 100644 (file)
--- a/src/os/os_windows_test.go
+++ b/src/os/os_windows_test.go
@@ -692,7 +692,16 @@ func TestReadStdin(t *testing.T) {
                poll.ReadConsole = old
        }()
 
-       testConsole := os.NewConsoleFile(syscall.Stdin, "test")
+       p, err := syscall.GetCurrentProcess()
+       if err != nil {
+               t.Fatalf("Unable to get handle to current process: %v", err)
+       }
+       var stdinDuplicate syscall.Handle
+       err = syscall.DuplicateHandle(p, syscall.Handle(syscall.Stdin), p, &stdinDuplicate, 0, false, syscall.DUPLICATE_SAME_ACCESS)
+       if err != nil {
+               t.Fatalf("Unable to duplicate stdin: %v", err)
+       }
+       testConsole := os.NewConsoleFile(stdinDuplicate, "test")
 
        var tests = []string{
                "abc",

diff --git a/src/os/readfrom_linux_test.go b/src/os/readfrom_linux_test.go
index 37047175e6fde50a8aec15a723e5e42a2c712412..1d145dadb0870dea710871a360d68125d37cd5c7 100644 (file)
--- a/src/os/readfrom_linux_test.go
+++ b/src/os/readfrom_linux_test.go
@@ -361,3 +361,35 @@ func (h *copyFileRangeHook) install() {
 func (h *copyFileRangeHook) uninstall() {
        *PollCopyFileRangeP = h.original
 }
+
+// On some kernels copy_file_range fails on files in /proc.
+func TestProcCopy(t *testing.T) {
+       const cmdlineFile = "/proc/self/cmdline"
+       cmdline, err := os.ReadFile(cmdlineFile)
+       if err != nil {
+               t.Skipf("can't read /proc file: %v", err)
+       }
+       in, err := os.Open(cmdlineFile)
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer in.Close()
+       outFile := filepath.Join(t.TempDir(), "cmdline")
+       out, err := os.Create(outFile)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if _, err := io.Copy(out, in); err != nil {
+               t.Fatal(err)
+       }
+       if err := out.Close(); err != nil {
+               t.Fatal(err)
+       }
+       copy, err := os.ReadFile(outFile)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if !bytes.Equal(cmdline, copy) {
+               t.Errorf("copy of %q got %q want %q\n", cmdlineFile, copy, cmdline)
+       }
+}

diff --git a/src/os/signal/signal_linux_test.go b/src/os/signal/signal_linux_test.go
new file mode 100644 (file)
index 0000000..2e553d0
--- /dev/null
+++ b/src/os/signal/signal_linux_test.go
@@ -0,0 +1,42 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux
+
+package signal
+
+import (
+       "os"
+       "syscall"
+       "testing"
+       "time"
+)
+
+const prSetKeepCaps = 8
+
+// This test validates that syscall.AllThreadsSyscall() can reliably
+// reach all 'm' (threads) of the nocgo runtime even when one thread
+// is blocked waiting to receive signals from the kernel. This monitors
+// for a regression vs. the fix for #43149.
+func TestAllThreadsSyscallSignals(t *testing.T) {
+       if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, prSetKeepCaps, 0, 0); err == syscall.ENOTSUP {
+               t.Skip("AllThreadsSyscall disabled with cgo")
+       }
+
+       sig := make(chan os.Signal, 1)
+       Notify(sig, os.Interrupt)
+
+       for i := 0; i <= 100; i++ {
+               if _, _, errno := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, prSetKeepCaps, uintptr(i&1), 0); errno != 0 {
+                       t.Fatalf("[%d] failed to set KEEP_CAPS=%d: %v", i, i&1, errno)
+               }
+       }
+
+       select {
+       case <-time.After(10 * time.Millisecond):
+       case <-sig:
+               t.Fatal("unexpected signal")
+       }
+       Stop(sig)
+}

diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go
index 8945cbfccba793900989198c52847d5d7d7542a1..bbc68af9fbdf4d60a663ec420d87098500bfd6a9 100644 (file)
--- a/src/os/signal/signal_test.go
+++ b/src/os/signal/signal_test.go
@@ -675,22 +675,68 @@ func TestTime(t *testing.T) {
        <-done
 }
 
-func TestNotifyContext(t *testing.T) {
-       c, stop := NotifyContext(context.Background(), syscall.SIGINT)
-       defer stop()
-
-       if want, got := "signal.NotifyContext(context.Background, [interrupt])", fmt.Sprint(c); want != got {
-               t.Errorf("c.String() = %q, want %q", got, want)
-       }
+var (
+       checkNotifyContext = flag.Bool("check_notify_ctx", false, "if true, TestNotifyContext will fail if SIGINT is not received.")
+       ctxNotifyTimes     = flag.Int("ctx_notify_times", 1, "number of times a SIGINT signal should be received")
+)
 
-       syscall.Kill(syscall.Getpid(), syscall.SIGINT)
-       select {
-       case <-c.Done():
-               if got := c.Err(); got != context.Canceled {
-                       t.Errorf("c.Err() = %q, want %q", got, context.Canceled)
+func TestNotifyContextNotifications(t *testing.T) {
+       if *checkNotifyContext {
+               ctx, _ := NotifyContext(context.Background(), syscall.SIGINT)
+               // We want to make sure not to be calling Stop() internally on NotifyContext() when processing a received signal.
+               // Being able to wait for a number of received system signals allows us to do so.
+               var wg sync.WaitGroup
+               n := *ctxNotifyTimes
+               wg.Add(n)
+               for i := 0; i < n; i++ {
+                       go func() {
+                               syscall.Kill(syscall.Getpid(), syscall.SIGINT)
+                               wg.Done()
+                       }()
                }
-       case <-time.After(time.Second):
-               t.Errorf("timed out waiting for context to be done after SIGINT")
+               wg.Wait()
+               <-ctx.Done()
+               fmt.Print("received SIGINT")
+               // Sleep to give time to simultaneous signals to reach the process.
+               // These signals must be ignored given stop() is not called on this code.
+               // We want to guarantee a SIGINT doesn't cause a premature termination of the program.
+               time.Sleep(settleTime)
+               return
+       }
+
+       t.Parallel()
+       testCases := []struct {
+               name string
+               n    int // number of times a SIGINT should be notified.
+       }{
+               {"once", 1},
+               {"multiple", 10},
+       }
+       for _, tc := range testCases {
+               t.Run(tc.name, func(t *testing.T) {
+                       var subTimeout time.Duration
+                       if deadline, ok := t.Deadline(); ok {
+                               subTimeout := time.Until(deadline)
+                               subTimeout -= subTimeout / 10 // Leave 10% headroom for cleaning up subprocess.
+                       }
+
+                       args := []string{
+                               "-test.v",
+                               "-test.run=TestNotifyContextNotifications$",
+                               "-check_notify_ctx",
+                               fmt.Sprintf("-ctx_notify_times=%d", tc.n),
+                       }
+                       if subTimeout != 0 {
+                               args = append(args, fmt.Sprintf("-test.timeout=%v", subTimeout))
+                       }
+                       out, err := exec.Command(os.Args[0], args...).CombinedOutput()
+                       if err != nil {
+                               t.Errorf("ran test with -check_notify_ctx_notification and it failed with %v.\nOutput:\n%s", err, out)
+                       }
+                       if want := []byte("received SIGINT"); !bytes.Contains(out, want) {
+                               t.Errorf("got %q, wanted %q", out, want)
+                       }
+               })
        }
 }
 
@@ -768,34 +814,6 @@ func TestNotifyContextPrematureCancelParent(t *testing.T) {
        }
 }
 
-func TestNotifyContextSimultaneousNotifications(t *testing.T) {
-       c, stop := NotifyContext(context.Background(), syscall.SIGINT)
-       defer stop()
-
-       if want, got := "signal.NotifyContext(context.Background, [interrupt])", fmt.Sprint(c); want != got {
-               t.Errorf("c.String() = %q, want %q", got, want)
-       }
-
-       var wg sync.WaitGroup
-       n := 10
-       wg.Add(n)
-       for i := 0; i < n; i++ {
-               go func() {
-                       syscall.Kill(syscall.Getpid(), syscall.SIGINT)
-                       wg.Done()
-               }()
-       }
-       wg.Wait()
-       select {
-       case <-c.Done():
-               if got := c.Err(); got != context.Canceled {
-                       t.Errorf("c.Err() = %q, want %q", got, context.Canceled)
-               }
-       case <-time.After(time.Second):
-               t.Errorf("expected context to be canceled")
-       }
-}
-
 func TestNotifyContextSimultaneousStop(t *testing.T) {
        c, stop := NotifyContext(context.Background(), syscall.SIGINT)
        defer stop()

diff --git a/src/os/str.go b/src/os/str.go
index cba9fa3e8d41de985a6f6c45eb293b4be322ea2f..9bfcc15aa82b88b232baf30902e5f9c4a0715877 100644 (file)
--- a/src/os/str.go
+++ b/src/os/str.go
@@ -6,7 +6,7 @@
 
 package os
 
-// Convert integer to decimal string
+// itoa converts val (an int) to a decimal string.
 func itoa(val int) string {
        if val < 0 {
                return "-" + uitoa(uint(-val))
@@ -14,7 +14,7 @@ func itoa(val int) string {
        return uitoa(uint(val))
 }
 
-// Convert unsigned integer to decimal string
+// uitoa converts val (a uint) to a decimal string.
 func uitoa(val uint) string {
        if val == 0 { // avoid string allocation
                return "0"
@@ -31,3 +31,35 @@ func uitoa(val uint) string {
        buf[i] = byte('0' + val)
        return string(buf[i:])
 }
+
+// itox converts val (an int) to a hexdecimal string.
+func itox(val int) string {
+       if val < 0 {
+               return "-" + uitox(uint(-val))
+       }
+       return uitox(uint(val))
+}
+
+const hex = "0123456789abcdef"
+
+// uitox converts val (a uint) to a hexdecimal string.
+func uitox(val uint) string {
+       if val == 0 { // avoid string allocation
+               return "0x0"
+       }
+       var buf [20]byte // big enough for 64bit value base 16 + 0x
+       i := len(buf) - 1
+       for val >= 16 {
+               q := val / 16
+               buf[i] = hex[val%16]
+               i--
+               val = q
+       }
+       // val < 16
+       buf[i] = hex[val%16]
+       i--
+       buf[i] = 'x'
+       i--
+       buf[i] = '0'
+       return string(buf[i:])
+}

diff --git a/src/os/tempfile.go b/src/os/tempfile.go
index 2728485c32ca158afbab291c111fd1ba12abe4cc..1ad44f1163fa58b90eca41cf9b49d55270cd60da 100644 (file)
--- a/src/os/tempfile.go
+++ b/src/os/tempfile.go
@@ -4,10 +4,7 @@
 
 package os
 
-import (
-       "errors"
-       "strings"
-)
+import "errors"
 
 // fastrand provided by runtime.
 // We generate random temporary file names so that there's a good
@@ -23,7 +20,7 @@ func nextRandom() string {
 // opens the file for reading and writing, and returns the resulting file.
 // The filename is generated by taking pattern and adding a random string to the end.
 // If pattern includes a "*", the random string replaces the last "*".
-// If dir is the empty string, TempFile uses the default directory for temporary files, as returned by TempDir.
+// If dir is the empty string, CreateTemp uses the default directory for temporary files, as returned by TempDir.
 // Multiple programs or goroutines calling CreateTemp simultaneously will not choose the same file.
 // The caller can use the file's Name method to find the pathname of the file.
 // It is the caller's responsibility to remove the file when it is no longer needed.
@@ -62,7 +59,7 @@ func prefixAndSuffix(pattern string) (prefix, suffix string, err error) {
                        return "", "", errPatternHasSeparator
                }
        }
-       if pos := strings.LastIndex(pattern, "*"); pos != -1 {
+       if pos := lastIndex(pattern, '*'); pos != -1 {
                prefix, suffix = pattern[:pos], pattern[pos+1:]
        } else {
                prefix = pattern
@@ -74,7 +71,7 @@ func prefixAndSuffix(pattern string) (prefix, suffix string, err error) {
 // and returns the pathname of the new directory.
 // The new directory's name is generated by adding a random string to the end of pattern.
 // If pattern includes a "*", the random string replaces the last "*" instead.
-// If dir is the empty string, TempFile uses the default directory for temporary files, as returned by TempDir.
+// If dir is the empty string, MkdirTemp uses the default directory for temporary files, as returned by TempDir.
 // Multiple programs or goroutines calling MkdirTemp simultaneously will not choose the same directory.
 // It is the caller's responsibility to remove the directory when it is no longer needed.
 func MkdirTemp(dir, pattern string) (string, error) {
@@ -116,3 +113,13 @@ func joinPath(dir, name string) string {
        }
        return dir + string(PathSeparator) + name
 }
+
+// LastIndexByte from the strings package.
+func lastIndex(s string, sep byte) int {
+       for i := len(s) - 1; i >= 0; i-- {
+               if s[i] == sep {
+                       return i
+               }
+       }
+       return -1
+}

diff --git a/src/os/testdata/dirfs/a b/src/os/testdata/dirfs/a
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/src/os/testdata/dirfs/b b/src/os/testdata/dirfs/b
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/src/os/testdata/dirfs/dir/x b/src/os/testdata/dirfs/dir/x
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
new file mode 100644 (file)
index 0000000..88af212
--- /dev/null
+++ b/src/reflect/abi.go
@@ -0,0 +1,403 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reflect
+
+import (
+       "internal/abi"
+       "unsafe"
+)
+
+// abiStep represents an ABI "instruction." Each instruction
+// describes one part of how to translate between a Go value
+// in memory and a call frame.
+type abiStep struct {
+       kind abiStepKind
+
+       // offset and size together describe a part of a Go value
+       // in memory.
+       offset uintptr
+       size   uintptr // size in bytes of the part
+
+       // These fields describe the ABI side of the translation.
+       stkOff uintptr // stack offset, used if kind == abiStepStack
+       ireg   int     // integer register index, used if kind == abiStepIntReg or kind == abiStepPointer
+       freg   int     // FP register index, used if kind == abiStepFloatReg
+}
+
+// abiStepKind is the "op-code" for an abiStep instruction.
+type abiStepKind int
+
+const (
+       abiStepBad      abiStepKind = iota
+       abiStepStack                // copy to/from stack
+       abiStepIntReg               // copy to/from integer register
+       abiStepPointer              // copy pointer to/from integer register
+       abiStepFloatReg             // copy to/from FP register
+)
+
+// abiSeq represents a sequence of ABI instructions for copying
+// from a series of reflect.Values to a call frame (for call arguments)
+// or vice-versa (for call results).
+//
+// An abiSeq should be populated by calling its addArg method.
+type abiSeq struct {
+       // steps is the set of instructions.
+       //
+       // The instructions are grouped together by whole arguments,
+       // with the starting index for the instructions
+       // of the i'th Go value available in valueStart.
+       //
+       // For instance, if this abiSeq represents 3 arguments
+       // passed to a function, then the 2nd argument's steps
+       // begin at steps[valueStart[1]].
+       //
+       // Because reflect accepts Go arguments in distinct
+       // Values and each Value is stored separately, each abiStep
+       // that begins a new argument will have its offset
+       // field == 0.
+       steps      []abiStep
+       valueStart []int
+
+       stackBytes   uintptr // stack space used
+       iregs, fregs int     // registers used
+}
+
+func (a *abiSeq) dump() {
+       for i, p := range a.steps {
+               println("part", i, p.kind, p.offset, p.size, p.stkOff, p.ireg, p.freg)
+       }
+       print("values ")
+       for _, i := range a.valueStart {
+               print(i, " ")
+       }
+       println()
+       println("stack", a.stackBytes)
+       println("iregs", a.iregs)
+       println("fregs", a.fregs)
+}
+
+// stepsForValue returns the ABI instructions for translating
+// the i'th Go argument or return value represented by this
+// abiSeq to the Go ABI.
+func (a *abiSeq) stepsForValue(i int) []abiStep {
+       s := a.valueStart[i]
+       var e int
+       if i == len(a.valueStart)-1 {
+               e = len(a.steps)
+       } else {
+               e = a.valueStart[i+1]
+       }
+       return a.steps[s:e]
+}
+
+// addArg extends the abiSeq with a new Go value of type t.
+//
+// If the value was stack-assigned, returns the single
+// abiStep describing that translation, and nil otherwise.
+func (a *abiSeq) addArg(t *rtype) *abiStep {
+       pStart := len(a.steps)
+       a.valueStart = append(a.valueStart, pStart)
+       if !a.regAssign(t, 0) {
+               a.steps = a.steps[:pStart]
+               a.stackAssign(t.size, uintptr(t.align))
+               return &a.steps[len(a.steps)-1]
+       }
+       return nil
+}
+
+// addRcvr extends the abiSeq with a new method call
+// receiver according to the interface calling convention.
+//
+// If the receiver was stack-assigned, returns the single
+// abiStep describing that translation, and nil otherwise.
+// Returns true if the receiver is a pointer.
+func (a *abiSeq) addRcvr(rcvr *rtype) (*abiStep, bool) {
+       // The receiver is always one word.
+       a.valueStart = append(a.valueStart, len(a.steps))
+       var ok, ptr bool
+       if ifaceIndir(rcvr) || rcvr.pointers() {
+               ok = a.assignIntN(0, ptrSize, 1, 0b1)
+               ptr = true
+       } else {
+               // TODO(mknyszek): Is this case even possible?
+               // The interface data work never contains a non-pointer
+               // value. This case was copied over from older code
+               // in the reflect package which only conditionally added
+               // a pointer bit to the reflect.(Value).Call stack frame's
+               // GC bitmap.
+               ok = a.assignIntN(0, ptrSize, 1, 0b0)
+               ptr = false
+       }
+       if !ok {
+               a.stackAssign(ptrSize, ptrSize)
+               return &a.steps[len(a.steps)-1], ptr
+       }
+       return nil, ptr
+}
+
+// regAssign attempts to reserve argument registers for a value of
+// type t, stored at some offset.
+//
+// It returns whether or not the assignment succeeded, but
+// leaves any changes it made to a.steps behind, so the caller
+// must undo that work by adjusting a.steps if it fails.
+//
+// This method along with the assign* methods represent the
+// complete register-assignment algorithm for the Go ABI.
+func (a *abiSeq) regAssign(t *rtype, offset uintptr) bool {
+       switch t.Kind() {
+       case UnsafePointer, Ptr, Chan, Map, Func:
+               return a.assignIntN(offset, t.size, 1, 0b1)
+       case Bool, Int, Uint, Int8, Uint8, Int16, Uint16, Int32, Uint32, Uintptr:
+               return a.assignIntN(offset, t.size, 1, 0b0)
+       case Int64, Uint64:
+               switch ptrSize {
+               case 4:
+                       return a.assignIntN(offset, 4, 2, 0b0)
+               case 8:
+                       return a.assignIntN(offset, 8, 1, 0b0)
+               }
+       case Float32, Float64:
+               return a.assignFloatN(offset, t.size, 1)
+       case Complex64:
+               return a.assignFloatN(offset, 4, 2)
+       case Complex128:
+               return a.assignFloatN(offset, 8, 2)
+       case String:
+               return a.assignIntN(offset, ptrSize, 2, 0b01)
+       case Interface:
+               return a.assignIntN(offset, ptrSize, 2, 0b10)
+       case Slice:
+               return a.assignIntN(offset, ptrSize, 3, 0b001)
+       case Array:
+               tt := (*arrayType)(unsafe.Pointer(t))
+               switch tt.len {
+               case 0:
+                       // There's nothing to assign, so don't modify
+                       // a.steps but succeed so the caller doesn't
+                       // try to stack-assign this value.
+                       return true
+               case 1:
+                       return a.regAssign(tt.elem, offset)
+               default:
+                       return false
+               }
+       case Struct:
+               if t.size == 0 {
+                       // There's nothing to assign, so don't modify
+                       // a.steps but succeed so the caller doesn't
+                       // try to stack-assign this value.
+                       return true
+               }
+               st := (*structType)(unsafe.Pointer(t))
+               for i := range st.fields {
+                       f := &st.fields[i]
+                       if f.typ.Size() == 0 {
+                               // Ignore zero-sized fields.
+                               continue
+                       }
+                       if !a.regAssign(f.typ, offset+f.offset()) {
+                               return false
+                       }
+               }
+               return true
+       default:
+               print("t.Kind == ", t.Kind(), "\n")
+               panic("unknown type kind")
+       }
+       panic("unhandled register assignment path")
+}
+
+// assignIntN assigns n values to registers, each "size" bytes large,
+// from the data at [offset, offset+n*size) in memory. Each value at
+// [offset+i*size, offset+(i+1)*size) for i < n is assigned to the
+// next n integer registers.
+//
+// Bit i in ptrMap indicates whether the i'th value is a pointer.
+// n must be <= 8.
+//
+// Returns whether assignment succeeded.
+func (a *abiSeq) assignIntN(offset, size uintptr, n int, ptrMap uint8) bool {
+       if n > 8 || n < 0 {
+               panic("invalid n")
+       }
+       if ptrMap != 0 && size != ptrSize {
+               panic("non-empty pointer map passed for non-pointer-size values")
+       }
+       if a.iregs+n > abi.IntArgRegs {
+               return false
+       }
+       for i := 0; i < n; i++ {
+               kind := abiStepIntReg
+               if ptrMap&(uint8(1)<<i) != 0 {
+                       kind = abiStepPointer
+               }
+               a.steps = append(a.steps, abiStep{
+                       kind:   kind,
+                       offset: offset + uintptr(i)*size,
+                       size:   size,
+                       ireg:   a.iregs,
+               })
+               a.iregs++
+       }
+       return true
+}
+
+// assignFloatN assigns n values to registers, each "size" bytes large,
+// from the data at [offset, offset+n*size) in memory. Each value at
+// [offset+i*size, offset+(i+1)*size) for i < n is assigned to the
+// next n floating-point registers.
+//
+// Returns whether assignment succeeded.
+func (a *abiSeq) assignFloatN(offset, size uintptr, n int) bool {
+       if n < 0 {
+               panic("invalid n")
+       }
+       if a.fregs+n > abi.FloatArgRegs || abi.EffectiveFloatRegSize < size {
+               return false
+       }
+       for i := 0; i < n; i++ {
+               a.steps = append(a.steps, abiStep{
+                       kind:   abiStepFloatReg,
+                       offset: offset + uintptr(i)*size,
+                       size:   size,
+                       freg:   a.fregs,
+               })
+               a.fregs++
+       }
+       return true
+}
+
+// stackAssign reserves space for one value that is "size" bytes
+// large with alignment "alignment" to the stack.
+//
+// Should not be called directly; use addArg instead.
+func (a *abiSeq) stackAssign(size, alignment uintptr) {
+       a.stackBytes = align(a.stackBytes, alignment)
+       a.steps = append(a.steps, abiStep{
+               kind:   abiStepStack,
+               offset: 0, // Only used for whole arguments, so the memory offset is 0.
+               size:   size,
+               stkOff: a.stackBytes,
+       })
+       a.stackBytes += size
+}
+
+// abiDesc describes the ABI for a function or method.
+type abiDesc struct {
+       // call and ret represent the translation steps for
+       // the call and return paths of a Go function.
+       call, ret abiSeq
+
+       // These fields describe the stack space allocated
+       // for the call. stackCallArgsSize is the amount of space
+       // reserved for arguments but not return values. retOffset
+       // is the offset at which return values begin, and
+       // spill is the size in bytes of additional space reserved
+       // to spill argument registers into in case of preemption in
+       // reflectcall's stack frame.
+       stackCallArgsSize, retOffset, spill uintptr
+
+       // stackPtrs is a bitmap that indicates whether
+       // each word in the ABI stack space (stack-assigned
+       // args + return values) is a pointer. Used
+       // as the heap pointer bitmap for stack space
+       // passed to reflectcall.
+       stackPtrs *bitVector
+
+       // outRegPtrs is a bitmap whose i'th bit indicates
+       // whether the i'th integer result register contains
+       // a pointer. Used by reflectcall to make result
+       // pointers visible to the GC.
+       outRegPtrs abi.IntArgRegBitmap
+}
+
+func (a *abiDesc) dump() {
+       println("ABI")
+       println("call")
+       a.call.dump()
+       println("ret")
+       a.ret.dump()
+       println("stackCallArgsSize", a.stackCallArgsSize)
+       println("retOffset", a.retOffset)
+       println("spill", a.spill)
+}
+
+func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
+       // We need to add space for this argument to
+       // the frame so that it can spill args into it.
+       //
+       // The size of this space is just the sum of the sizes
+       // of each register-allocated type.
+       //
+       // TODO(mknyszek): Remove this when we no longer have
+       // caller reserved spill space.
+       spillInt := uintptr(0)
+       spillFloat := uintptr(0)
+
+       // Compute gc program & stack bitmap for stack arguments
+       stackPtrs := new(bitVector)
+
+       // Compute abiSeq for input parameters.
+       var in abiSeq
+       if rcvr != nil {
+               stkStep, isPtr := in.addRcvr(rcvr)
+               if stkStep != nil {
+                       if isPtr {
+                               stackPtrs.append(1)
+                       } else {
+                               stackPtrs.append(0)
+                       }
+               } else {
+                       spillInt += ptrSize
+               }
+       }
+       for _, arg := range t.in() {
+               i, f := in.iregs, in.fregs
+               stkStep := in.addArg(arg)
+               if stkStep != nil {
+                       addTypeBits(stackPtrs, stkStep.stkOff, arg)
+               } else {
+                       i, f = in.iregs-i, in.fregs-f
+                       spillInt += uintptr(i) * ptrSize
+                       spillFloat += uintptr(f) * abi.EffectiveFloatRegSize
+               }
+       }
+       spill := align(spillInt+spillFloat, ptrSize)
+
+       // From the input parameters alone, we now know
+       // the stackCallArgsSize and retOffset.
+       stackCallArgsSize := in.stackBytes
+       retOffset := align(in.stackBytes, ptrSize)
+
+       // Compute the stack frame pointer bitmap and register
+       // pointer bitmap for return values.
+       outRegPtrs := abi.IntArgRegBitmap{}
+
+       // Compute abiSeq for output parameters.
+       var out abiSeq
+       // Stack-assigned return values do not share
+       // space with arguments like they do with registers,
+       // so we need to inject a stack offset here.
+       // Fake it by artifically extending stackBytes by
+       // the return offset.
+       out.stackBytes = retOffset
+       for i, res := range t.out() {
+               stkStep := out.addArg(res)
+               if stkStep != nil {
+                       addTypeBits(stackPtrs, stkStep.stkOff, res)
+               } else {
+                       for _, st := range out.stepsForValue(i) {
+                               if st.kind == abiStepPointer {
+                                       outRegPtrs.Set(st.ireg)
+                               }
+                       }
+               }
+       }
+       // Undo the faking from earlier so that stackBytes
+       // is accurate.
+       out.stackBytes -= retOffset
+       return abiDesc{in, out, stackCallArgsSize, retOffset, spill, stackPtrs, outRegPtrs}
+}

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index b01158635f14167d414421bc4a0573512d74031d..1225d6177d4b4709ff9c4982887adfab9dc2fb33 100644 (file)
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -7168,176 +7168,6 @@ func TestMapIterDelete1(t *testing.T) {
        }
 }
 
-func TestStructTagLookup(t *testing.T) {
-       var tests = []struct {
-               tag           StructTag
-               key           string
-               expectedValue string
-               expectedOK    bool
-       }{
-               {
-                       tag:           `json:"json_value_1"`,
-                       key:           "json",
-                       expectedValue: "json_value_1",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json:"json_value_2" xml:"xml_value_2"`,
-                       key:           "json",
-                       expectedValue: "json_value_2",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json:"json_value_3" xml:"xml_value_3"`,
-                       key:           "xml",
-                       expectedValue: "xml_value_3",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `bson json:"shared_value_4"`,
-                       key:           "json",
-                       expectedValue: "shared_value_4",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `bson json:"shared_value_5"`,
-                       key:           "bson",
-                       expectedValue: "shared_value_5",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json bson xml form:"field_1,omitempty" other:"value_1"`,
-                       key:           "xml",
-                       expectedValue: "field_1,omitempty",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json bson xml form:"field_2,omitempty" other:"value_2"`,
-                       key:           "form",
-                       expectedValue: "field_2,omitempty",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json bson xml form:"field_3,omitempty" other:"value_3"`,
-                       key:           "other",
-                       expectedValue: "value_3",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json    bson    xml    form:"field_4" other:"value_4"`,
-                       key:           "json",
-                       expectedValue: "field_4",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json    bson    xml    form:"field_5" other:"value_5"`,
-                       key:           "non_existing",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `json "json_6"`,
-                       key:           "json",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `json:"json_7" bson "bson_7"`,
-                       key:           "json",
-                       expectedValue: "json_7",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `json:"json_8" xml "xml_8"`,
-                       key:           "xml",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `json    bson    xml    form "form_9" other:"value_9"`,
-                       key:           "bson",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `json bson xml form "form_10" other:"value_10"`,
-                       key:           "other",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `json bson xml form:"form_11" other "value_11"`,
-                       key:           "json",
-                       expectedValue: "form_11",
-                       expectedOK:    true,
-               },
-               {
-                       tag:           `tag1`,
-                       key:           "tag1",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `tag2 :"hello_2"`,
-                       key:           "tag2",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           `tag3: "hello_3"`,
-                       key:           "tag3",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "json\x7fbson: \"hello_4\"",
-                       key:           "json",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "json\x7fbson: \"hello_5\"",
-                       key:           "bson",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "json bson:\x7f\"hello_6\"",
-                       key:           "json",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "json bson:\x7f\"hello_7\"",
-                       key:           "bson",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "json\x09bson:\"hello_8\"",
-                       key:           "json",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-               {
-                       tag:           "a\x7fb json:\"val\"",
-                       key:           "json",
-                       expectedValue: "",
-                       expectedOK:    false,
-               },
-       }
-
-       for _, test := range tests {
-               v, ok := test.tag.Lookup(test.key)
-               if v != test.expectedValue {
-                       t.Errorf("struct tag lookup failed, got %s, want %s", v, test.expectedValue)
-               }
-               if ok != test.expectedOK {
-                       t.Errorf("struct tag lookup failed, got %t, want %t", ok, test.expectedOK)
-               }
-       }
-}
-
 // iterateToString returns the set of elements
 // returned by an iterator in readable form.
 func iterateToString(it *MapIter) string {

diff --git a/src/reflect/export_test.go b/src/reflect/export_test.go
index de426b58a8a2cf936f967a790289d937b0ad4df5..ddcfca9dee45c22d06cb8fdd11086a95d899eea4 100644 (file)
--- a/src/reflect/export_test.go
+++ b/src/reflect/export_test.go
@@ -23,15 +23,17 @@ const PtrSize = ptrSize
 
 func FuncLayout(t Type, rcvr Type) (frametype Type, argSize, retOffset uintptr, stack []byte, gc []byte, ptrs bool) {
        var ft *rtype
-       var s *bitVector
+       var abi abiDesc
        if rcvr != nil {
-               ft, argSize, retOffset, s, _ = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
+               ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
        } else {
-               ft, argSize, retOffset, s, _ = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
+               ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
        }
+       argSize = abi.stackCallArgsSize
+       retOffset = abi.retOffset
        frametype = ft
-       for i := uint32(0); i < s.n; i++ {
-               stack = append(stack, s.data[i/8]>>(i%8)&1)
+       for i := uint32(0); i < abi.stackPtrs.n; i++ {
+               stack = append(stack, abi.stackPtrs.data[i/8]>>(i%8)&1)
        }
        if ft.kind&kindGCProg != 0 {
                panic("can't handle gc programs")

diff --git a/src/reflect/makefunc.go b/src/reflect/makefunc.go
index 67dc4859b97367ef9b507f52c0e94a3ce983b02c..e17d4ea758c3ce329896d297f648ae3912af8e2f 100644 (file)
--- a/src/reflect/makefunc.go
+++ b/src/reflect/makefunc.go
@@ -60,9 +60,9 @@ func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
        code := **(**uintptr)(unsafe.Pointer(&dummy))
 
        // makeFuncImpl contains a stack map for use by the runtime
-       _, argLen, _, stack, _ := funcLayout(ftyp, nil)
+       _, _, abi := funcLayout(ftyp, nil)
 
-       impl := &makeFuncImpl{code: code, stack: stack, argLen: argLen, ftyp: ftyp, fn: fn}
+       impl := &makeFuncImpl{code: code, stack: abi.stackPtrs, argLen: abi.stackCallArgsSize, ftyp: ftyp, fn: fn}
 
        return Value{t, unsafe.Pointer(impl), flag(Func)}
 }
@@ -112,12 +112,12 @@ func makeMethodValue(op string, v Value) Value {
        code := **(**uintptr)(unsafe.Pointer(&dummy))
 
        // methodValue contains a stack map for use by the runtime
-       _, argLen, _, stack, _ := funcLayout(ftyp, nil)
+       _, _, abi := funcLayout(ftyp, nil)
 
        fv := &methodValue{
                fn:     code,
-               stack:  stack,
-               argLen: argLen,
+               stack:  abi.stackPtrs,
+               argLen: abi.stackCallArgsSize,
                method: int(v.flag) >> flagMethodShift,
                rcvr:   rcvr,
        }

diff --git a/src/reflect/type.go b/src/reflect/type.go
index 1f1e70d485c840ed0d7b1e1d3087251ac5259e4c..d52816628f0d1e735929dc9d31c2b5e763b41aa7 100644 (file)
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -1104,16 +1104,12 @@ type StructField struct {
 
 // A StructTag is the tag string in a struct field.
 //
-// By convention, tag strings are a mapping of keys to values.
-// The format is key:"value". Each key is a non-empty string consisting
-// of non-control characters other than space (U+0020 ' '),
-// quote (U+0022 '"'), and colon (U+003A ':'). Each value is quoted
-// using U+0022 '"' characters and Go string literal syntax.
-// Multiple key-value mappings are separated by zero or more spaces, as in
-//   key1:"value1" key2:"value2"
-// Multiple keys may map to a single shared value by separating the keys
-// with spaces, as in
-//   key1 key2:"value"
+// By convention, tag strings are a concatenation of
+// optionally space-separated key:"value" pairs.
+// Each key is a non-empty string consisting of non-control
+// characters other than space (U+0020 ' '), quote (U+0022 '"'),
+// and colon (U+003A ':').  Each value is quoted using U+0022 '"'
+// characters and Go string literal syntax.
 type StructTag string
 
 // Get returns the value associated with key in the tag string.
@@ -1136,9 +1132,6 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
        // When modifying this code, also update the validateStructTag code
        // in cmd/vet/structtag.go.
 
-       // keyFound indicates that such key on the left side has already been found.
-       var keyFound bool
-
        for tag != "" {
                // Skip leading space.
                i := 0
@@ -1158,29 +1151,11 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
                for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
                        i++
                }
-               if i == 0 || i+1 >= len(tag) || tag[i] < ' ' || tag[i] == 0x7f {
+               if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
                        break
                }
                name := string(tag[:i])
-               tag = tag[i:]
-
-               // If we found a space char here - assume that we have a tag with
-               // multiple keys.
-               if tag[0] == ' ' {
-                       if name == key {
-                               keyFound = true
-                       }
-                       continue
-               }
-
-               // Spaces were filtered above so we assume that here we have
-               // only valid tag value started with `:"`.
-               if tag[0] != ':' || tag[1] != '"' {
-                       break
-               }
-
-               // Remove the colon leaving tag at the start of the quoted string.
-               tag = tag[1:]
+               tag = tag[i+1:]
 
                // Scan quoted string to find value.
                i = 1
@@ -1196,7 +1171,7 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
                qvalue := string(tag[:i+1])
                tag = tag[i+1:]
 
-               if key == name || keyFound {
+               if key == name {
                        value, err := strconv.Unquote(qvalue)
                        if err != nil {
                                break
@@ -1890,7 +1865,7 @@ func MapOf(key, elem Type) Type {
 
        // Make a map type.
        // Note: flag values must match those used in the TMAP case
-       // in ../cmd/compile/internal/gc/reflect.go:dtypesym.
+       // in ../cmd/compile/internal/gc/reflect.go:writeType.
        var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
        mt := **(**mapType)(unsafe.Pointer(&imap))
        mt.str = resolveReflectName(newName(s, "", false))
@@ -3009,21 +2984,20 @@ type layoutKey struct {
 
 type layoutType struct {
        t         *rtype
-       argSize   uintptr // size of arguments
-       retOffset uintptr // offset of return values.
-       stack     *bitVector
        framePool *sync.Pool
+       abi       abiDesc
 }
 
 var layoutCache sync.Map // map[layoutKey]layoutType
 
 // funcLayout computes a struct type representing the layout of the
-// function arguments and return values for the function type t.
+// stack-assigned function arguments and return values for the function
+// type t.
 // If rcvr != nil, rcvr specifies the type of the receiver.
 // The returned type exists only for GC, so we only fill out GC relevant info.
 // Currently, that's just size and the GC program. We also fill in
 // the name for possible debugging use.
-func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset uintptr, stk *bitVector, framePool *sync.Pool) {
+func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, framePool *sync.Pool, abi abiDesc) {
        if t.Kind() != Func {
                panic("reflect: funcLayout of non-func type " + t.String())
        }
@@ -3033,46 +3007,24 @@ func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset
        k := layoutKey{t, rcvr}
        if lti, ok := layoutCache.Load(k); ok {
                lt := lti.(layoutType)
-               return lt.t, lt.argSize, lt.retOffset, lt.stack, lt.framePool
+               return lt.t, lt.framePool, lt.abi
        }
 
-       // compute gc program & stack bitmap for arguments
-       ptrmap := new(bitVector)
-       var offset uintptr
-       if rcvr != nil {
-               // Reflect uses the "interface" calling convention for
-               // methods, where receivers take one word of argument
-               // space no matter how big they actually are.
-               if ifaceIndir(rcvr) || rcvr.pointers() {
-                       ptrmap.append(1)
-               } else {
-                       ptrmap.append(0)
-               }
-               offset += ptrSize
-       }
-       for _, arg := range t.in() {
-               offset += -offset & uintptr(arg.align-1)
-               addTypeBits(ptrmap, offset, arg)
-               offset += arg.size
-       }
-       argSize = offset
-       offset += -offset & (ptrSize - 1)
-       retOffset = offset
-       for _, res := range t.out() {
-               offset += -offset & uintptr(res.align-1)
-               addTypeBits(ptrmap, offset, res)
-               offset += res.size
-       }
-       offset += -offset & (ptrSize - 1)
+       // Compute the ABI layout.
+       abi = newAbiDesc(t, rcvr)
 
        // build dummy rtype holding gc program
        x := &rtype{
-               align:   ptrSize,
-               size:    offset,
-               ptrdata: uintptr(ptrmap.n) * ptrSize,
+               align: ptrSize,
+               // Don't add spill space here; it's only necessary in
+               // reflectcall's frame, not in the allocated frame.
+               // TODO(mknyszek): Remove this comment when register
+               // spill space in the frame is no longer required.
+               size:    align(abi.retOffset+abi.ret.stackBytes, ptrSize),
+               ptrdata: uintptr(abi.stackPtrs.n) * ptrSize,
        }
-       if ptrmap.n > 0 {
-               x.gcdata = &ptrmap.data[0]
+       if abi.stackPtrs.n > 0 {
+               x.gcdata = &abi.stackPtrs.data[0]
        }
 
        var s string
@@ -3089,13 +3041,11 @@ func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset
        }}
        lti, _ := layoutCache.LoadOrStore(k, layoutType{
                t:         x,
-               argSize:   argSize,
-               retOffset: retOffset,
-               stack:     ptrmap,
                framePool: framePool,
+               abi:       abi,
        })
        lt := lti.(layoutType)
-       return lt.t, lt.argSize, lt.retOffset, lt.stack, lt.framePool
+       return lt.t, lt.framePool, lt.abi
 }
 
 // ifaceIndir reports whether t is stored indirectly in an interface value.

diff --git a/src/reflect/value.go b/src/reflect/value.go
index 1f185b52e49e3c73761f584da3a9c71cc269c2f9..eae1b9bf294b70589c5c22bbd9ddc1671b455c91 100644 (file)
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -5,6 +5,7 @@
 package reflect
 
 import (
+       "internal/abi"
        "internal/unsafeheader"
        "math"
        "runtime"
@@ -352,6 +353,8 @@ func (v Value) CallSlice(in []Value) []Value {
 
 var callGC bool // for testing; see TestCallMethodJump
 
+const debugReflectCall = false
+
 func (v Value) call(op string, in []Value) []Value {
        // Get function pointer, type.
        t := (*funcType)(unsafe.Pointer(v.typ))
@@ -430,50 +433,112 @@ func (v Value) call(op string, in []Value) []Value {
        }
        nout := t.NumOut()
 
+       // Register argument space.
+       var regArgs abi.RegArgs
+
        // Compute frame type.
-       frametype, _, retOffset, _, framePool := funcLayout(t, rcvrtype)
+       frametype, framePool, abi := funcLayout(t, rcvrtype)
 
-       // Allocate a chunk of memory for frame.
-       var args unsafe.Pointer
-       if nout == 0 {
-               args = framePool.Get().(unsafe.Pointer)
-       } else {
-               // Can't use pool if the function has return values.
-               // We will leak pointer to args in ret, so its lifetime is not scoped.
-               args = unsafe_New(frametype)
+       // Allocate a chunk of memory for frame if needed.
+       var stackArgs unsafe.Pointer
+       if frametype.size != 0 {
+               if nout == 0 {
+                       stackArgs = framePool.Get().(unsafe.Pointer)
+               } else {
+                       // Can't use pool if the function has return values.
+                       // We will leak pointer to args in ret, so its lifetime is not scoped.
+                       stackArgs = unsafe_New(frametype)
+               }
+       }
+       frameSize := frametype.size
+
+       if debugReflectCall {
+               println("reflect.call", t.String())
+               abi.dump()
        }
-       off := uintptr(0)
 
        // Copy inputs into args.
+
+       // Handle receiver.
+       inStart := 0
        if rcvrtype != nil {
-               storeRcvr(rcvr, args)
-               off = ptrSize
+               // Guaranteed to only be one word in size,
+               // so it will only take up exactly 1 abiStep (either
+               // in a register or on the stack).
+               switch st := abi.call.steps[0]; st.kind {
+               case abiStepStack:
+                       storeRcvr(rcvr, stackArgs)
+               case abiStepIntReg, abiStepPointer:
+                       // Even pointers can go into the uintptr slot because
+                       // they'll be kept alive by the Values referenced by
+                       // this frame. Reflection forces these to be heap-allocated,
+                       // so we don't need to worry about stack copying.
+                       storeRcvr(rcvr, unsafe.Pointer(&regArgs.Ints[st.ireg]))
+               case abiStepFloatReg:
+                       storeRcvr(rcvr, unsafe.Pointer(&regArgs.Floats[st.freg]))
+               default:
+                       panic("unknown ABI parameter kind")
+               }
+               inStart = 1
        }
+
+       // Handle arguments.
        for i, v := range in {
                v.mustBeExported()
                targ := t.In(i).(*rtype)
-               a := uintptr(targ.align)
-               off = (off + a - 1) &^ (a - 1)
-               n := targ.size
-               if n == 0 {
-                       // Not safe to compute args+off pointing at 0 bytes,
-                       // because that might point beyond the end of the frame,
-                       // but we still need to call assignTo to check assignability.
-                       v.assignTo("reflect.Value.Call", targ, nil)
-                       continue
-               }
-               addr := add(args, off, "n > 0")
-               v = v.assignTo("reflect.Value.Call", targ, addr)
-               if v.flag&flagIndir != 0 {
-                       typedmemmove(targ, addr, v.ptr)
-               } else {
-                       *(*unsafe.Pointer)(addr) = v.ptr
+               // TODO(mknyszek): Figure out if it's possible to get some
+               // scratch space for this assignment check. Previously, it
+               // was possible to use space in the argument frame.
+               v = v.assignTo("reflect.Value.Call", targ, nil)
+       stepsLoop:
+               for _, st := range abi.call.stepsForValue(i + inStart) {
+                       switch st.kind {
+                       case abiStepStack:
+                               // Copy values to the "stack."
+                               addr := add(stackArgs, st.stkOff, "precomputed stack arg offset")
+                               if v.flag&flagIndir != 0 {
+                                       typedmemmove(targ, addr, v.ptr)
+                               } else {
+                                       *(*unsafe.Pointer)(addr) = v.ptr
+                               }
+                               // There's only one step for a stack-allocated value.
+                               break stepsLoop
+                       case abiStepIntReg, abiStepPointer:
+                               // Copy values to "integer registers."
+                               if v.flag&flagIndir != 0 {
+                                       offset := add(v.ptr, st.offset, "precomputed value offset")
+                                       memmove(unsafe.Pointer(&regArgs.Ints[st.ireg]), offset, st.size)
+                               } else {
+                                       if st.kind == abiStepPointer {
+                                               // Duplicate this pointer in the pointer area of the
+                                               // register space. Otherwise, there's the potential for
+                                               // this to be the last reference to v.ptr.
+                                               regArgs.Ptrs[st.ireg] = v.ptr
+                                       }
+                                       regArgs.Ints[st.ireg] = uintptr(v.ptr)
+                               }
+                       case abiStepFloatReg:
+                               // Copy values to "float registers."
+                               if v.flag&flagIndir == 0 {
+                                       panic("attempted to copy pointer to FP register")
+                               }
+                               offset := add(v.ptr, st.offset, "precomputed value offset")
+                               memmove(unsafe.Pointer(&regArgs.Floats[st.freg]), offset, st.size)
+                       default:
+                               panic("unknown ABI part kind")
+                       }
                }
-               off += n
        }
+       // TODO(mknyszek): Remove this when we no longer have
+       // caller reserved spill space.
+       frameSize = align(frameSize, ptrSize)
+       frameSize += abi.spill
+
+       // Mark pointers in registers for the return path.
+       regArgs.ReturnIsPtr = abi.outRegPtrs
 
        // Call.
-       call(frametype, fn, args, uint32(frametype.size), uint32(retOffset))
+       call(frametype, fn, stackArgs, uint32(frametype.size), uint32(abi.retOffset), uint32(frameSize), &regArgs)
 
        // For testing; see TestCallMethodJump.
        if callGC {
@@ -482,34 +547,82 @@ func (v Value) call(op string, in []Value) []Value {
 
        var ret []Value
        if nout == 0 {
-               typedmemclr(frametype, args)
-               framePool.Put(args)
+               if stackArgs != nil {
+                       typedmemclr(frametype, stackArgs)
+                       framePool.Put(stackArgs)
+               }
        } else {
-               // Zero the now unused input area of args,
-               // because the Values returned by this function contain pointers to the args object,
-               // and will thus keep the args object alive indefinitely.
-               typedmemclrpartial(frametype, args, 0, retOffset)
+               if stackArgs != nil {
+                       // Zero the now unused input area of args,
+                       // because the Values returned by this function contain pointers to the args object,
+                       // and will thus keep the args object alive indefinitely.
+                       typedmemclrpartial(frametype, stackArgs, 0, abi.retOffset)
+               }
 
                // Wrap Values around return values in args.
                ret = make([]Value, nout)
-               off = retOffset
                for i := 0; i < nout; i++ {
                        tv := t.Out(i)
-                       a := uintptr(tv.Align())
-                       off = (off + a - 1) &^ (a - 1)
-                       if tv.Size() != 0 {
+                       if tv.Size() == 0 {
+                               // For zero-sized return value, args+off may point to the next object.
+                               // In this case, return the zero value instead.
+                               ret[i] = Zero(tv)
+                               continue
+                       }
+                       steps := abi.ret.stepsForValue(i)
+                       if st := steps[0]; st.kind == abiStepStack {
+                               // This value is on the stack. If part of a value is stack
+                               // allocated, the entire value is according to the ABI. So
+                               // just make an indirection into the allocated frame.
                                fl := flagIndir | flag(tv.Kind())
-                               ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl}
+                               ret[i] = Value{tv.common(), add(stackArgs, st.stkOff, "tv.Size() != 0"), fl}
                                // Note: this does introduce false sharing between results -
                                // if any result is live, they are all live.
                                // (And the space for the args is live as well, but as we've
                                // cleared that space it isn't as big a deal.)
-                       } else {
-                               // For zero-sized return value, args+off may point to the next object.
-                               // In this case, return the zero value instead.
-                               ret[i] = Zero(tv)
+                               continue
+                       }
+
+                       // Handle pointers passed in registers.
+                       if !ifaceIndir(tv.common()) {
+                               // Pointer-valued data gets put directly
+                               // into v.ptr.
+                               if steps[0].kind != abiStepPointer {
+                                       print("kind=", steps[0].kind, ", type=", tv.String(), "\n")
+                                       panic("mismatch between ABI description and types")
+                               }
+                               ret[i] = Value{tv.common(), regArgs.Ptrs[steps[0].ireg], flag(t.Kind())}
+                               continue
+                       }
+
+                       // All that's left is values passed in registers that we need to
+                       // create space for and copy values back into.
+                       //
+                       // TODO(mknyszek): We make a new allocation for each register-allocated
+                       // value, but previously we could always point into the heap-allocated
+                       // stack frame. This is a regression that could be fixed by adding
+                       // additional space to the allocated stack frame and storing the
+                       // register-allocated return values into the allocated stack frame and
+                       // referring there in the resulting Value.
+                       s := unsafe_New(tv.common())
+                       for _, st := range steps {
+                               switch st.kind {
+                               case abiStepIntReg:
+                                       offset := add(s, st.offset, "precomputed value offset")
+                                       memmove(offset, unsafe.Pointer(&regArgs.Ints[st.ireg]), st.size)
+                               case abiStepPointer:
+                                       s := add(s, st.offset, "precomputed value offset")
+                                       *((*unsafe.Pointer)(s)) = regArgs.Ptrs[st.ireg]
+                               case abiStepFloatReg:
+                                       offset := add(s, st.offset, "precomputed value offset")
+                                       memmove(offset, unsafe.Pointer(&regArgs.Floats[st.freg]), st.size)
+                               case abiStepStack:
+                                       panic("register-based return value has stack component")
+                               default:
+                                       panic("unknown ABI part kind")
+                               }
                        }
-                       off += tv.Size()
+                       ret[i] = Value{tv.common(), s, flagIndir | flag(tv.Kind())}
                }
        }
 
@@ -709,7 +822,8 @@ func align(x, n uintptr) uintptr {
 func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
        rcvr := ctxt.rcvr
        rcvrtype, t, fn := methodReceiver("call", rcvr, ctxt.method)
-       frametype, argSize, retOffset, _, framePool := funcLayout(t, rcvrtype)
+       frametype, framePool, abid := funcLayout(t, rcvrtype)
+       argSize, retOffset := abid.stackCallArgsSize, abid.retOffset
 
        // Make a new frame that is one word bigger so we can store the receiver.
        // This space is used for both arguments and return values.
@@ -727,10 +841,19 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
                typedmemmovepartial(frametype, add(scratch, argOffset, "argSize > argOffset"), frame, argOffset, argSize-argOffset)
        }
 
+       frameSize := frametype.size
+       // TODO(mknyszek): Remove this when we no longer have
+       // caller reserved spill space.
+       frameSize = align(frameSize, ptrSize)
+       frameSize += abid.spill
+
        // Call.
        // Call copies the arguments from scratch to the stack, calls fn,
        // and then copies the results back into scratch.
-       call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset))
+       //
+       // TODO(mknyszek): Have this actually support the register-based ABI.
+       var regs abi.RegArgs
+       call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset), uint32(frameSize), &regs)
 
        // Copy return values.
        // Ignore any changes to args and just copy return values.
@@ -2802,14 +2925,32 @@ func mapiternext(it unsafe.Pointer)
 //go:noescape
 func maplen(m unsafe.Pointer) int
 
-// call calls fn with a copy of the n argument bytes pointed at by arg.
-// After fn returns, reflectcall copies n-retoffset result bytes
-// back into arg+retoffset before returning. If copying result bytes back,
-// the caller must pass the argument frame type as argtype, so that
-// call can execute appropriate write barriers during the copy.
+// call calls fn with "stackArgsSize" bytes of stack arguments laid out
+// at stackArgs and register arguments laid out in regArgs. frameSize is
+// the total amount of stack space that will be reserved by call, so this
+// should include enough space to spill register arguments to the stack in
+// case of preemption.
+//
+// After fn returns, call copies stackArgsSize-stackRetOffset result bytes
+// back into stackArgs+stackRetOffset before returning, for any return
+// values passed on the stack. Register-based return values will be found
+// in the same regArgs structure.
+//
+// regArgs must also be prepared with an appropriate ReturnIsPtr bitmap
+// indicating which registers will contain pointer-valued return values. The
+// purpose of this bitmap is to keep pointers visible to the GC between
+// returning from reflectcall and actually using them.
 //
+// If copying result bytes back from the stack, the caller must pass the
+// argument frame type as stackArgsType, so that call can execute appropriate
+// write barriers during the copy.
+//
+// Arguments passed through to call do not escape. The type is used only in a
+// very limited callee of call, the stackArgs are copied, and regArgs is only
+// used in the call frame.
+//go:noescape
 //go:linkname call runtime.reflectcall
-func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+func call(stackArgsType *rtype, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
 func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
 

diff --git a/src/run.bash b/src/run.bash
index 706b4b60ee4f16edfdb6e137915670f4f1161017..2123c509f8b2511864001564858eec7698c2e7d0 100755 (executable)
--- a/src/run.bash
+++ b/src/run.bash
@@ -23,15 +23,7 @@ fi
 
 eval $(../bin/go env)
 export GOROOT   # The api test requires GOROOT to be set, so set it to match ../bin/go.
-
-# We disallow local import for non-local packages, if $GOROOT happens
-# to be under $GOPATH, then some tests below will fail.  $GOPATH needs
-# to be set to a non-empty string, else Go will set a default value
-# that may also conflict with $GOROOT.  The $GOPATH value doesn't need
-# to point to an actual directory, it just needs to pass the semantic
-# checks performed by Go.  Use $GOROOT to define $GOPATH so that we
-# don't blunder into a user-defined symbolic link.
-export GOPATH=/dev/null
+export GOPATH=/nonexist-gopath
 
 unset CDPATH   # in case user has it set
 export GOBIN=$GOROOT/bin  # Issue 14340

diff --git a/src/run.bat b/src/run.bat
index c299671c13f31381f997ce1c059d93f94db39369..edcaf5265931b8218b7e13990df35ba9e63bd8b3 100644 (file)
--- a/src/run.bat
+++ b/src/run.bat
@@ -18,9 +18,7 @@ setlocal
 \r
 set GOBUILDFAIL=0\r
 \r
-:: we disallow local import for non-local packages, if %GOROOT% happens\r
-:: to be under %GOPATH%, then some tests below will fail\r
-set GOPATH=\r
+set GOPATH=c:\nonexist-gopath\r
 :: Issue 14340: ignore GOBIN during all.bat.\r
 set GOBIN=\r
 set GOFLAGS=\r

diff --git a/src/run.rc b/src/run.rc
index ab7abfa991a62e7349c77e222a4ad0487e240169..a7b4801207051ae105eb44d639bf5876bf32e756 100755 (executable)
--- a/src/run.rc
+++ b/src/run.rc
@@ -12,10 +12,9 @@ if(! test -f ../bin/go){
 
 eval `{../bin/go env}
 
-GOPATH = () # we disallow local import for non-local packages, if $GOROOT happens
-            # to be under $GOPATH, then some tests below will fail
-GOBIN = () # Issue 14340
-GOFLAGS = ()
-GO111MODULE = ()
+GOPATH=/nonexist-gopath
+GOBIN=() # Issue 14340
+GOFLAGS=()
+GO111MODULE=()
 
 exec ../bin/go tool dist test -rebuild $*

diff --git a/src/runtime/asm.s b/src/runtime/asm.s
index 27d8df9e063ecf8404e5da9ffa15b88c5f4fffbc..72c744925d89aec9d1cc33a6eacf55f826866fcf 100644 (file)
--- a/src/runtime/asm.s
+++ b/src/runtime/asm.s
@@ -11,3 +11,8 @@
 DATA runtime·no_pointers_stackmap+0x00(SB)/4, $2
 DATA runtime·no_pointers_stackmap+0x04(SB)/4, $0
 GLOBL runtime·no_pointers_stackmap(SB),RODATA, $8
+
+#ifndef GOARCH_amd64
+TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     ·sigpanic<ABIInternal>(SB)
+#endif

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index fa3b1be3392598526a34281624482662069921be..5b0852f78043eb9c087b8dd2a3185ec10096f427 100644 (file)
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -89,7 +89,7 @@ GLOBL _rt0_386_lib_argc<>(SB),NOPTR, $4
 DATA _rt0_386_lib_argv<>(SB)/4, $0
 GLOBL _rt0_386_lib_argv<>(SB),NOPTR, $4
 
-TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
        // Copy arguments forward on an even stack.
        // Users of this function jump to it, they don't call it.
        MOVL    0(SP), AX
@@ -269,35 +269,23 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
        FLDCW   runtime·controlWord64(SB)
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       CALL    runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $0-4
-       MOVL    buf+0(FP), AX           // gobuf
-       LEAL    buf+0(FP), BX           // caller's SP
-       MOVL    BX, gobuf_sp(AX)
-       MOVL    0(SP), BX               // caller's PC
-       MOVL    BX, gobuf_pc(AX)
-       MOVL    $0, gobuf_ret(AX)
-       // Assert ctxt is zero. See func save.
-       MOVL    gobuf_ctxt(AX), BX
-       TESTL   BX, BX
-       JZ      2(PC)
-       CALL    runtime·badctxt(SB)
-       get_tls(CX)
-       MOVL    g(CX), BX
-       MOVL    BX, gobuf_g(AX)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $8-4
+TEXT runtime·gogo(SB), NOSPLIT, $0-4
        MOVL    buf+0(FP), BX           // gobuf
        MOVL    gobuf_g(BX), DX
        MOVL    0(DX), CX               // make sure g != nil
+       JMP     gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT, $0
        get_tls(CX)
        MOVL    DX, g(CX)
        MOVL    gobuf_sp(BX), SP        // restore SP
@@ -322,7 +310,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
        MOVL    BX, (g_sched+gobuf_pc)(AX)
        LEAL    fn+0(FP), BX    // caller's SP
        MOVL    BX, (g_sched+gobuf_sp)(AX)
-       MOVL    AX, (g_sched+gobuf_g)(AX)
 
        // switch to m->g0 & its stack, call fn
        MOVL    g(DX), BX
@@ -371,18 +358,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-4
        // switch stacks
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVL    $runtime·systemstack_switch(SB), (g_sched+gobuf_pc)(AX)
-       MOVL    SP, (g_sched+gobuf_sp)(AX)
-       MOVL    AX, (g_sched+gobuf_g)(AX)
+       CALL    gosave_systemstack_switch<>(SB)
 
        // switch to g0
        get_tls(CX)
        MOVL    DX, g(CX)
        MOVL    (g_sched+gobuf_sp)(DX), BX
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUBL    $4, BX
-       MOVL    $runtime·mstart(SB), DX
-       MOVL    DX, 0(BX)
        MOVL    BX, SP
 
        // call target function
@@ -457,7 +438,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
        // Set g->sched to context in f.
        MOVL    0(SP), AX       // f's PC
        MOVL    AX, (g_sched+gobuf_pc)(SI)
-       MOVL    SI, (g_sched+gobuf_g)(SI)
        LEAL    4(SP), AX       // f's SP
        MOVL    AX, (g_sched+gobuf_sp)(SI)
        MOVL    DX, (g_sched+gobuf_ctxt)(SI)
@@ -477,7 +457,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
        JMP runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -489,8 +469,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
        JMP     AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT, $0-20
-       MOVL    argsize+12(FP), CX
+TEXT ·reflectcall(SB), NOSPLIT, $0-28
+       MOVL    frameSize+20(FP), CX
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -522,11 +502,11 @@ TEXT ·reflectcall(SB), NOSPLIT, $0-20
        JMP     AX
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-28;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVL    argptr+8(FP), SI;               \
-       MOVL    argsize+12(FP), CX;             \
+       MOVL    stackArgs+8(FP), SI;            \
+       MOVL    stackArgsSize+12(FP), CX;               \
        MOVL    SP, DI;                         \
        REP;MOVSB;                              \
        /* call function */                     \
@@ -535,10 +515,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;              \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        CALL    AX;                             \
        /* copy return values back */           \
-       MOVL    argtype+0(FP), DX;              \
-       MOVL    argptr+8(FP), DI;               \
-       MOVL    argsize+12(FP), CX;             \
-       MOVL    retoffset+16(FP), BX;           \
+       MOVL    stackArgsType+0(FP), DX;                \
+       MOVL    stackArgs+8(FP), DI;            \
+       MOVL    stackArgsSize+12(FP), CX;               \
+       MOVL    stackRetOffset+16(FP), BX;              \
        MOVL    SP, SI;                         \
        ADDL    BX, DI;                         \
        ADDL    BX, SI;                         \
@@ -550,11 +530,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
        MOVL    DX, 0(SP)
        MOVL    DI, 4(SP)
        MOVL    SI, 8(SP)
        MOVL    CX, 12(SP)
+       MOVL    $0, 16(SP)
        CALL    runtime·reflectcallmove(SB)
        RET
 
@@ -619,15 +600,18 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
        MOVL    0(DX), BX
        JMP     BX      // but first run the deferred function
 
-// Save state of caller into g->sched.
-TEXT gosave<>(SB),NOSPLIT,$0
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
        PUSHL   AX
        PUSHL   BX
        get_tls(BX)
        MOVL    g(BX), BX
        LEAL    arg+0(FP), AX
        MOVL    AX, (g_sched+gobuf_sp)(BX)
-       MOVL    -4(AX), AX
+       MOVL    $runtime·systemstack_switch(SB), AX
        MOVL    AX, (g_sched+gobuf_pc)(BX)
        MOVL    $0, (g_sched+gobuf_ret)(BX)
        // Assert ctxt is zero. See func save.
@@ -639,6 +623,22 @@ TEXT gosave<>(SB),NOSPLIT,$0
        POPL    AX
        RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-8
+       MOVL    fn+0(FP), AX
+       MOVL    arg+4(FP), BX
+       MOVL    SP, DX
+       SUBL    $32, SP
+       ANDL    $~15, SP        // alignment, perhaps unnecessary
+       MOVL    DX, 8(SP)       // save old SP
+       MOVL    BX, 0(SP)       // first argument in x86-32 ABI
+       CALL    AX
+       MOVL    8(SP), DX
+       MOVL    DX, SP
+       RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
@@ -663,7 +663,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
        JEQ     noswitch
        CMPL    DI, m_gsignal(BP)
        JEQ     noswitch
-       CALL    gosave<>(SB)
+       CALL    gosave_systemstack_switch<>(SB)
        get_tls(CX)
        MOVL    SI, g(CX)
        MOVL    (g_sched+gobuf_sp)(SI), SP
@@ -1311,7 +1311,7 @@ TEXT _cgo_topofstack(SB),NOSPLIT,$0
 
 // The top-most function running on a goroutine
 // returns to goexit+PCQuantum.
-TEXT runtime·goexit(SB),NOSPLIT,$0-0
+TEXT runtime·goexit(SB),NOSPLIT|TOPFRAME,$0-0
        BYTE    $0x90   // NOP
        CALL    runtime·goexit1(SB)    // does not return
        // traceback from goexit1 must hit code range of goexit

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 196252e1dd993c8a7d18fd8e027fbd8df588eddc..a68dc72ae5332a8bf3bf91d84004632b71e52ede 100644 (file)
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -84,9 +84,7 @@ GLOBL _rt0_amd64_lib_argc<>(SB),NOPTR, $8
 DATA _rt0_amd64_lib_argv<>(SB)/8, $0
 GLOBL _rt0_amd64_lib_argv<>(SB),NOPTR, $8
 
-// Defined as ABIInternal since it does not use the stack-based Go ABI (and
-// in addition there are no calls to this entry point from Go code).
-TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // copy arguments forward on an even stack
        MOVQ    DI, AX          // argc
        MOVQ    SI, BX          // argv
@@ -181,6 +179,10 @@ needtls:
        // skip TLS setup on Darwin
        JMP ok
 #endif
+#ifdef GOOS_openbsd
+       // skip TLS setup on OpenBSD
+       JMP ok
+#endif
 
        LEAQ    runtime·m0+m_tls(SB), DI
        CALL    runtime·settls(SB)
@@ -248,38 +250,26 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
        // No per-thread init.
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       CALL    runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// func gosave(buf *gobuf)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $0-8
-       MOVQ    buf+0(FP), AX           // gobuf
-       LEAQ    buf+0(FP), BX           // caller's SP
-       MOVQ    BX, gobuf_sp(AX)
-       MOVQ    0(SP), BX               // caller's PC
-       MOVQ    BX, gobuf_pc(AX)
-       MOVQ    $0, gobuf_ret(AX)
-       MOVQ    BP, gobuf_bp(AX)
-       // Assert ctxt is zero. See func save.
-       MOVQ    gobuf_ctxt(AX), BX
-       TESTQ   BX, BX
-       JZ      2(PC)
-       CALL    runtime·badctxt(SB)
-       get_tls(CX)
-       MOVQ    g(CX), BX
-       MOVQ    BX, gobuf_g(AX)
-       RET
-
 // func gogo(buf *gobuf)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT, $0-8
        MOVQ    buf+0(FP), BX           // gobuf
        MOVQ    gobuf_g(BX), DX
        MOVQ    0(DX), CX               // make sure g != nil
+       JMP     gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT, $0
        get_tls(CX)
        MOVQ    DX, g(CX)
+       MOVQ    DX, R14         // set the g register
        MOVQ    gobuf_sp(BX), SP        // restore SP
        MOVQ    gobuf_ret(BX), AX
        MOVQ    gobuf_ctxt(BX), DX
@@ -304,7 +294,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
        MOVQ    BX, (g_sched+gobuf_pc)(AX)
        LEAQ    fn+0(FP), BX    // caller's SP
        MOVQ    BX, (g_sched+gobuf_sp)(AX)
-       MOVQ    AX, (g_sched+gobuf_g)(AX)
        MOVQ    BP, (g_sched+gobuf_bp)(AX)
 
        // switch to m->g0 & its stack, call fn
@@ -316,6 +305,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
        MOVQ    $runtime·badmcall(SB), AX
        JMP     AX
        MOVQ    SI, g(CX)       // g = m->g0
+       MOVQ    SI, R14 // set the g register
        MOVQ    (g_sched+gobuf_sp)(SI), SP      // sp = m->g0->sched.sp
        PUSHQ   AX
        MOVQ    DI, DX
@@ -354,19 +344,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
        // switch stacks
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVQ    $runtime·systemstack_switch(SB), SI
-       MOVQ    SI, (g_sched+gobuf_pc)(AX)
-       MOVQ    SP, (g_sched+gobuf_sp)(AX)
-       MOVQ    AX, (g_sched+gobuf_g)(AX)
-       MOVQ    BP, (g_sched+gobuf_bp)(AX)
+       CALL    gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVQ    DX, g(CX)
+       MOVQ    DX, R14 // set the g register
        MOVQ    (g_sched+gobuf_sp)(DX), BX
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUBQ    $8, BX
-       MOVQ    $runtime·mstart(SB), DX
-       MOVQ    DX, 0(BX)
        MOVQ    BX, SP
 
        // call target function
@@ -441,7 +424,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
        // Set g->sched to context in f.
        MOVQ    0(SP), AX // f's PC
        MOVQ    AX, (g_sched+gobuf_pc)(SI)
-       MOVQ    SI, (g_sched+gobuf_g)(SI)
        LEAQ    8(SP), AX // f's SP
        MOVQ    AX, (g_sched+gobuf_sp)(SI)
        MOVQ    BP, (g_sched+gobuf_bp)(SI)
@@ -460,8 +442,77 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
        MOVL    $0, DX
        JMP     runtime·morestack(SB)
 
+// REFLECTCALL_USE_REGABI is not defined. It must be defined in conjunction with the
+// register constants in the internal/abi package.
+
+#ifdef REFLECTCALL_USE_REGABI
+// spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
+TEXT spillArgs<>(SB),NOSPLIT,$0-0
+       MOVQ AX, 0(R12)
+       MOVQ BX, 8(R12)
+       MOVQ CX, 16(R12)
+       MOVQ DI, 24(R12)
+       MOVQ SI, 32(R12)
+       MOVQ R8, 40(R12)
+       MOVQ R9, 48(R12)
+       MOVQ R10, 56(R12)
+       MOVQ R11, 64(R12)
+       MOVQ X0, 72(R12)
+       MOVQ X1, 80(R12)
+       MOVQ X2, 88(R12)
+       MOVQ X3, 96(R12)
+       MOVQ X4, 104(R12)
+       MOVQ X5, 112(R12)
+       MOVQ X6, 120(R12)
+       MOVQ X7, 128(R12)
+       MOVQ X8, 136(R12)
+       MOVQ X9, 144(R12)
+       MOVQ X10, 152(R12)
+       MOVQ X11, 160(R12)
+       MOVQ X12, 168(R12)
+       MOVQ X13, 176(R12)
+       MOVQ X14, 184(R12)
+       RET
+
+// unspillArgs loads args into registers from a *internal/abi.RegArgs in R12.
+TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+       MOVQ 0(R12), AX
+       MOVQ 8(R12), BX
+       MOVQ 16(R12), CX
+       MOVQ 24(R12), DI
+       MOVQ 32(R12), SI
+       MOVQ 40(R12), R8
+       MOVQ 48(R12), R9
+       MOVQ 56(R12), R10
+       MOVQ 64(R12), R11
+       MOVQ 72(R12), X0
+       MOVQ 80(R12), X1
+       MOVQ 88(R12), X2
+       MOVQ 96(R12), X3
+       MOVQ 104(R12), X4
+       MOVQ 112(R12), X5
+       MOVQ 120(R12), X6
+       MOVQ 128(R12), X7
+       MOVQ 136(R12), X8
+       MOVQ 144(R12), X9
+       MOVQ 152(R12), X10
+       MOVQ 160(R12), X11
+       MOVQ 168(R12), X12
+       MOVQ 176(R12), X13
+       MOVQ 184(R12), X14
+       RET
+#else
+// spillArgs stores return values from registers to a pointer in R12.
+TEXT spillArgs<>(SB),NOSPLIT,$0-0
+       RET
+
+// unspillArgs loads args into registers from a pointer in R12.
+TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+       RET
+#endif
+
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -473,8 +524,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
        JMP     AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-32
-       MOVLQZX argsize+24(FP), CX
+TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-48
+       MOVLQZX frameSize+32(FP), CX
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -506,23 +557,28 @@ TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-32
        JMP     AX
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-32;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVQ    argptr+16(FP), SI;              \
-       MOVLQZX argsize+24(FP), CX;             \
+       MOVQ    stackArgs+16(FP), SI;           \
+       MOVLQZX stackArgsSize+24(FP), CX;               \
        MOVQ    SP, DI;                         \
        REP;MOVSB;                              \
+       /* set up argument registers */         \
+       MOVQ    regArgs+40(FP), R12;            \
+       CALL    unspillArgs<>(SB);              \
        /* call function */                     \
        MOVQ    f+8(FP), DX;                    \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
-       MOVQ    (DX), AX;                       \
-       CALL    AX;                             \
-       /* copy return values back */           \
-       MOVQ    argtype+0(FP), DX;              \
-       MOVQ    argptr+16(FP), DI;              \
-       MOVLQZX argsize+24(FP), CX;             \
-       MOVLQZX retoffset+28(FP), BX;           \
+       MOVQ    (DX), R12;                      \
+       CALL    R12;                            \
+       /* copy register return values back */          \
+       MOVQ    regArgs+40(FP), R12;            \
+       CALL    spillArgs<>(SB);                \
+       MOVLQZX stackArgsSize+24(FP), CX;               \
+       MOVLQZX stackRetOffset+28(FP), BX;              \
+       MOVQ    stackArgs+16(FP), DI;           \
+       MOVQ    stackArgsType+0(FP), DX;                \
        MOVQ    SP, SI;                         \
        ADDQ    BX, DI;                         \
        ADDQ    BX, SI;                         \
@@ -534,12 +590,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        NO_LOCAL_POINTERS
        MOVQ    DX, 0(SP)
        MOVQ    DI, 8(SP)
        MOVQ    SI, 16(SP)
        MOVQ    CX, 24(SP)
+       MOVQ    R12, 32(SP)
        CALL    runtime·reflectcallmove(SB)
        RET
 
@@ -600,23 +657,46 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
        MOVQ    0(DX), BX
        JMP     BX      // but first run the deferred function
 
-// Save state of caller into g->sched. Smashes R8, R9.
-TEXT gosave<>(SB),NOSPLIT,$0
-       get_tls(R8)
-       MOVQ    g(R8), R8
-       MOVQ    0(SP), R9
-       MOVQ    R9, (g_sched+gobuf_pc)(R8)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R9.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
+#ifndef GOEXPERIMENT_REGABI
+       get_tls(R14)
+       MOVQ    g(R14), R14
+#endif
+       MOVQ    $runtime·systemstack_switch(SB), R9
+       MOVQ    R9, (g_sched+gobuf_pc)(R14)
        LEAQ    8(SP), R9
-       MOVQ    R9, (g_sched+gobuf_sp)(R8)
-       MOVQ    $0, (g_sched+gobuf_ret)(R8)
-       MOVQ    BP, (g_sched+gobuf_bp)(R8)
+       MOVQ    R9, (g_sched+gobuf_sp)(R14)
+       MOVQ    $0, (g_sched+gobuf_ret)(R14)
+       MOVQ    BP, (g_sched+gobuf_bp)(R14)
        // Assert ctxt is zero. See func save.
-       MOVQ    (g_sched+gobuf_ctxt)(R8), R9
+       MOVQ    (g_sched+gobuf_ctxt)(R14), R9
        TESTQ   R9, R9
        JZ      2(PC)
        CALL    runtime·badctxt(SB)
        RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+       MOVQ    fn+0(FP), AX
+       MOVQ    arg+8(FP), BX
+       MOVQ    SP, DX
+       SUBQ    $32, SP
+       ANDQ    $~15, SP        // alignment
+       MOVQ    DX, 8(SP)
+       MOVQ    BX, DI          // DI = first argument in AMD64 ABI
+       MOVQ    BX, CX          // CX = first argument in Win64
+       CALL    AX
+       MOVQ    8(SP), DX
+       MOVQ    DX, SP
+       RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
@@ -645,7 +725,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 
        // Switch to system stack.
        MOVQ    m_g0(R8), SI
-       CALL    gosave<>(SB)
+       CALL    gosave_systemstack_switch<>(SB)
        MOVQ    SI, g(CX)
        MOVQ    (g_sched+gobuf_sp)(SI), SP
 
@@ -842,6 +922,7 @@ settls:
 TEXT setg_gcc<>(SB),NOSPLIT,$0
        get_tls(AX)
        MOVQ    DI, g(AX)
+       MOVQ    DI, R14 // set the g register
        RET
 
 TEXT runtime·abort(SB),NOSPLIT,$0-0
@@ -1363,7 +1444,7 @@ TEXT _cgo_topofstack(SB),NOSPLIT,$0
 // so as to make it identifiable to traceback (this
 // function it used as a sentinel; traceback wants to
 // see the func PC, not a wrapper PC).
-TEXT runtime·goexit<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT runtime·goexit<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0-0
        BYTE    $0x90   // NOP
        CALL    runtime·goexit1(SB)    // does not return
        // traceback from goexit1 must hit code range of goexit
@@ -1378,6 +1459,18 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
        POPQ    R15
        RET
 
+// Initialize special registers then jump to sigpanic.
+// This function is injected from the signal handler for panicking
+// signals. It is quite painful to set X15 in the signal context,
+// so we do it here.
+TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
+#ifdef GOEXPERIMENT_REGABI
+       get_tls(R14)
+       MOVQ    g(R14), R14
+       XORPS   X15, X15
+#endif
+       JMP     ·sigpanic<ABIInternal>(SB)
+
 // gcWriteBarrier performs a heap pointer write and informs the GC.
 //
 // gcWriteBarrier does NOT follow the Go ABI. It takes two arguments:
@@ -1386,24 +1479,28 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 // It clobbers FLAGS. It does not clobber any general-purpose registers,
 // but may clobber others (e.g., SSE registers).
 // Defined as ABIInternal since it does not use the stack-based Go ABI.
-TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$120
+TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$112
        // Save the registers clobbered by the fast path. This is slightly
        // faster than having the caller spill these.
-       MOVQ    R14, 104(SP)
-       MOVQ    R13, 112(SP)
+       MOVQ    R12, 96(SP)
+       MOVQ    R13, 104(SP)
        // TODO: Consider passing g.m.p in as an argument so they can be shared
        // across a sequence of write barriers.
+#ifdef GOEXPERIMENT_REGABI
+       MOVQ    g_m(R14), R13
+#else
        get_tls(R13)
        MOVQ    g(R13), R13
        MOVQ    g_m(R13), R13
+#endif
        MOVQ    m_p(R13), R13
-       MOVQ    (p_wbBuf+wbBuf_next)(R13), R14
+       MOVQ    (p_wbBuf+wbBuf_next)(R13), R12
        // Increment wbBuf.next position.
-       LEAQ    16(R14), R14
-       MOVQ    R14, (p_wbBuf+wbBuf_next)(R13)
-       CMPQ    R14, (p_wbBuf+wbBuf_end)(R13)
+       LEAQ    16(R12), R12
+       MOVQ    R12, (p_wbBuf+wbBuf_next)(R13)
+       CMPQ    R12, (p_wbBuf+wbBuf_end)(R13)
        // Record the write.
-       MOVQ    AX, -16(R14)    // Record value
+       MOVQ    AX, -16(R12)    // Record value
        // Note: This turns bad pointer writes into bad
        // pointer reads, which could be confusing. We could avoid
        // reading from obviously bad pointers, which would
@@ -1411,12 +1508,12 @@ TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$120
        // patch this up in the signal handler, or use XCHG to
        // combine the read and the write.
        MOVQ    (DI), R13
-       MOVQ    R13, -8(R14)    // Record *slot
+       MOVQ    R13, -8(R12)    // Record *slot
        // Is the buffer full? (flags set in CMPQ above)
        JEQ     flush
 ret:
-       MOVQ    104(SP), R14
-       MOVQ    112(SP), R13
+       MOVQ    96(SP), R12
+       MOVQ    104(SP), R13
        // Do the write.
        MOVQ    AX, (DI)
        RET
@@ -1446,10 +1543,10 @@ flush:
        MOVQ    R9, 64(SP)
        MOVQ    R10, 72(SP)
        MOVQ    R11, 80(SP)
-       MOVQ    R12, 88(SP)
+       // R12 already saved
        // R13 already saved
-       // R14 already saved
-       MOVQ    R15, 96(SP)
+       // R14 is g
+       MOVQ    R15, 88(SP)
 
        // This takes arguments DI and AX
        CALL    runtime·wbBufFlush(SB)
@@ -1465,8 +1562,7 @@ flush:
        MOVQ    64(SP), R9
        MOVQ    72(SP), R10
        MOVQ    80(SP), R11
-       MOVQ    88(SP), R12
-       MOVQ    96(SP), R15
+       MOVQ    88(SP), R15
        JMP     ret
 
 // gcWriteBarrierCX is gcWriteBarrier, but with args in DI and CX.
@@ -1728,67 +1824,67 @@ TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
 TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicIndex(SB)
+       JMP     runtime·goPanicIndex<ABIInternal>(SB)
 TEXT runtime·panicIndexU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicIndexU(SB)
+       JMP     runtime·goPanicIndexU<ABIInternal>(SB)
 TEXT runtime·panicSliceAlen<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSliceAlen(SB)
+       JMP     runtime·goPanicSliceAlen<ABIInternal>(SB)
 TEXT runtime·panicSliceAlenU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSliceAlenU(SB)
+       JMP     runtime·goPanicSliceAlenU<ABIInternal>(SB)
 TEXT runtime·panicSliceAcap<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSliceAcap(SB)
+       JMP     runtime·goPanicSliceAcap<ABIInternal>(SB)
 TEXT runtime·panicSliceAcapU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSliceAcapU(SB)
+       JMP     runtime·goPanicSliceAcapU<ABIInternal>(SB)
 TEXT runtime·panicSliceB<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicSliceB(SB)
+       JMP     runtime·goPanicSliceB<ABIInternal>(SB)
 TEXT runtime·panicSliceBU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicSliceBU(SB)
+       JMP     runtime·goPanicSliceBU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Alen<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    DX, x+0(FP)
        MOVQ    BX, y+8(FP)
-       JMP     runtime·goPanicSlice3Alen(SB)
+       JMP     runtime·goPanicSlice3Alen<ABIInternal>(SB)
 TEXT runtime·panicSlice3AlenU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    DX, x+0(FP)
        MOVQ    BX, y+8(FP)
-       JMP     runtime·goPanicSlice3AlenU(SB)
+       JMP     runtime·goPanicSlice3AlenU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Acap<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    DX, x+0(FP)
        MOVQ    BX, y+8(FP)
-       JMP     runtime·goPanicSlice3Acap(SB)
+       JMP     runtime·goPanicSlice3Acap<ABIInternal>(SB)
 TEXT runtime·panicSlice3AcapU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    DX, x+0(FP)
        MOVQ    BX, y+8(FP)
-       JMP     runtime·goPanicSlice3AcapU(SB)
+       JMP     runtime·goPanicSlice3AcapU<ABIInternal>(SB)
 TEXT runtime·panicSlice3B<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSlice3B(SB)
+       JMP     runtime·goPanicSlice3B<ABIInternal>(SB)
 TEXT runtime·panicSlice3BU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    CX, x+0(FP)
        MOVQ    DX, y+8(FP)
-       JMP     runtime·goPanicSlice3BU(SB)
+       JMP     runtime·goPanicSlice3BU<ABIInternal>(SB)
 TEXT runtime·panicSlice3C<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicSlice3C(SB)
+       JMP     runtime·goPanicSlice3C<ABIInternal>(SB)
 TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
        MOVQ    AX, x+0(FP)
        MOVQ    CX, y+8(FP)
-       JMP     runtime·goPanicSlice3CU(SB)
+       JMP     runtime·goPanicSlice3CU<ABIInternal>(SB)
 
 #ifdef GOOS_android
 // Use the free TLS_SLOT_APP slot #2 on Android Q.

diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index c54b4eb0061e64ce95b779a2a091da1fd00e18ac..f9535bb1bc1198aae4769deecf754ffc8cf3a801 100644 (file)
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -112,7 +112,7 @@ GLOBL _rt0_arm_lib_argv<>(SB),NOPTR,$4
 
 // using NOFRAME means do not save LR on stack.
 // argc is in R0, argv is in R1.
-TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
        MOVW    $0xcafebabe, R12
 
        // copy arguments forward on an even stack
@@ -202,44 +202,24 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
        WORD    $0xeee1ba10     // vmsr fpscr, r11
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       BL      runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB),NOSPLIT|NOFRAME,$0-4
-       MOVW    buf+0(FP), R0
-       MOVW    R13, gobuf_sp(R0)
-       MOVW    LR, gobuf_pc(R0)
-       MOVW    g, gobuf_g(R0)
-       MOVW    $0, R11
-       MOVW    R11, gobuf_lr(R0)
-       MOVW    R11, gobuf_ret(R0)
-       // Assert ctxt is zero. See func save.
-       MOVW    gobuf_ctxt(R0), R0
-       CMP     R0, R11
-       B.EQ    2(PC)
-       CALL    runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB),NOSPLIT,$8-4
+TEXT runtime·gogo(SB),NOSPLIT|NOFRAME,$0-4
        MOVW    buf+0(FP), R1
        MOVW    gobuf_g(R1), R0
-       BL      setg<>(SB)
+       MOVW    0(R0), R2       // make sure g != nil
+       B       gogo<>(SB)
 
-       // NOTE: We updated g above, and we are about to update SP.
-       // Until LR and PC are also updated, the g/SP/LR/PC quadruple
-       // are out of sync and must not be used as the basis of a traceback.
-       // Sigprof skips the traceback when SP is not within g's bounds,
-       // and when the PC is inside this function, runtime.gogo.
-       // Since we are about to update SP, until we complete runtime.gogo
-       // we must not leave this function. In particular, no calls
-       // after this point: it must be straight-line code until the
-       // final B instruction.
-       // See large comment in sigprof for more details.
+TEXT gogo<>(SB),NOSPLIT|NOFRAME,$0
+       BL      setg<>(SB)
        MOVW    gobuf_sp(R1), R13       // restore SP==R13
        MOVW    gobuf_lr(R1), LR
        MOVW    gobuf_ret(R1), R0
@@ -263,7 +243,6 @@ TEXT runtime·mcall(SB),NOSPLIT|NOFRAME,$0-4
        MOVW    LR, (g_sched+gobuf_pc)(g)
        MOVW    $0, R11
        MOVW    R11, (g_sched+gobuf_lr)(g)
-       MOVW    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVW    g, R1
@@ -322,24 +301,14 @@ TEXT runtime·systemstack(SB),NOSPLIT,$0-4
 switch:
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVW    $runtime·systemstack_switch(SB), R3
-       ADD     $4, R3, R3 // get past push {lr}
-       MOVW    R3, (g_sched+gobuf_pc)(g)
-       MOVW    R13, (g_sched+gobuf_sp)(g)
-       MOVW    LR, (g_sched+gobuf_lr)(g)
-       MOVW    g, (g_sched+gobuf_g)(g)
+       BL      gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVW    R0, R5
        MOVW    R2, R0
        BL      setg<>(SB)
        MOVW    R5, R0
-       MOVW    (g_sched+gobuf_sp)(R2), R3
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUB     $4, R3, R3
-       MOVW    $runtime·mstart(SB), R4
-       MOVW    R4, 0(R3)
-       MOVW    R3, R13
+       MOVW    (g_sched+gobuf_sp)(R2), R13
 
        // call target function
        MOVW    R0, R7
@@ -421,7 +390,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        B runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -432,8 +401,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        MOVW    $NAME(SB), R1;          \
        B       (R1)
 
-TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
-       MOVW    argsize+12(FP), R0
+TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-28
+       MOVW    frameSize+20(FP), R0
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -465,11 +434,11 @@ TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
        B       (R1)
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-28;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVW    argptr+8(FP), R0;               \
-       MOVW    argsize+12(FP), R2;             \
+       MOVW    stackArgs+8(FP), R0;            \
+       MOVW    stackArgsSize+12(FP), R2;               \
        ADD     $4, R13, R1;                    \
        CMP     $0, R2;                         \
        B.EQ    5(PC);                          \
@@ -483,10 +452,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;              \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        BL      (R0);                           \
        /* copy return values back */           \
-       MOVW    argtype+0(FP), R4;              \
-       MOVW    argptr+8(FP), R0;               \
-       MOVW    argsize+12(FP), R2;             \
-       MOVW    retoffset+16(FP), R3;           \
+       MOVW    stackArgsType+0(FP), R4;                \
+       MOVW    stackArgs+8(FP), R0;            \
+       MOVW    stackArgsSize+12(FP), R2;               \
+       MOVW    stackArgsRetOffset+16(FP), R3;          \
        ADD     $4, R13, R1;                    \
        ADD     R3, R1;                         \
        ADD     R3, R0;                         \
@@ -498,11 +467,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
        MOVW    R4, 4(R13)
        MOVW    R0, 8(R13)
        MOVW    R1, 12(R13)
        MOVW    R2, 16(R13)
+       MOVW    $0, R7
+       MOVW    R7, 20(R13)
        BL      runtime·reflectcallmove(SB)
        RET
 
@@ -539,10 +510,6 @@ CALLFN(·call1073741824, 1073741824)
 // 1. grab stored LR for caller
 // 2. sub 4 bytes to get back to BL deferreturn
 // 3. B to fn
-// TODO(rsc): Push things on stack and then use pop
-// to load all registers simultaneously, so that a profiling
-// interrupt can never see mismatched SP/LR/PC.
-// (And double-check that pop is atomic in that way.)
 TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
        MOVW    0(R13), LR
        MOVW    $-4(LR), LR     // BL deferreturn
@@ -552,19 +519,39 @@ TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
        MOVW    0(R7), R1
        B       (R1)
 
-// Save state of caller into g->sched. Smashes R11.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVW    LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R11.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVW    $runtime·systemstack_switch(SB), R11
+       ADD     $4, R11 // get past push {lr}
+       MOVW    R11, (g_sched+gobuf_pc)(g)
        MOVW    R13, (g_sched+gobuf_sp)(g)
        MOVW    $0, R11
        MOVW    R11, (g_sched+gobuf_lr)(g)
        MOVW    R11, (g_sched+gobuf_ret)(g)
-       MOVW    R11, (g_sched+gobuf_ctxt)(g)
        // Assert ctxt is zero. See func save.
        MOVW    (g_sched+gobuf_ctxt)(g), R11
-       CMP     $0, R11
+       TST     R11, R11
        B.EQ    2(PC)
-       CALL    runtime·badctxt(SB)
+       BL      runtime·badctxt(SB)
+       RET
+
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-8
+       MOVW    fn+0(FP), R1
+       MOVW    arg+4(FP), R0
+       MOVW    R13, R2
+       SUB     $32, R13
+       BIC     $0x7, R13       // alignment for gcc ABI
+       MOVW    R2, 8(R13)
+       BL      (R1)
+       MOVW    8(R13), R2
+       MOVW    R2, R13
        RET
 
 // func asmcgocall(fn, arg unsafe.Pointer) int32
@@ -590,7 +577,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
        MOVW    m_g0(R8), R3
        CMP     R3, g
        BEQ     nosave
-       BL      gosave<>(SB)
+       BL      gosave_systemstack_switch<>(SB)
        MOVW    R0, R5
        MOVW    R3, R0
        BL      setg<>(SB)

diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index a09172f0c964dc3d2d52e068aaf67bfdd8b39931..699fc99d589e06e1e173fced5a894d3d922ff07b 100644 (file)
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -8,7 +8,7 @@
 #include "funcdata.h"
 #include "textflag.h"
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // SP = stack; R0 = argc; R1 = argv
 
        SUB     $32, RSP
@@ -73,6 +73,10 @@ nocgo:
 
        BL      runtime·check(SB)
 
+#ifdef GOOS_windows
+       BL      runtime·wintls(SB)
+#endif
+
        MOVW    8(RSP), R0      // copy argc
        MOVW    R0, -8(RSP)
        MOVD    16(RSP), R0             // copy argv
@@ -109,35 +113,26 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       BL      runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-       MOVD    buf+0(FP), R3
-       MOVD    RSP, R0
-       MOVD    R0, gobuf_sp(R3)
-       MOVD    R29, gobuf_bp(R3)
-       MOVD    LR, gobuf_pc(R3)
-       MOVD    g, gobuf_g(R3)
-       MOVD    ZR, gobuf_lr(R3)
-       MOVD    ZR, gobuf_ret(R3)
-       // Assert ctxt is zero. See func save.
-       MOVD    gobuf_ctxt(R3), R0
-       CBZ     R0, 2(PC)
-       CALL    runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $24-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
        MOVD    buf+0(FP), R5
-       MOVD    gobuf_g(R5), g
+       MOVD    gobuf_g(R5), R6
+       MOVD    0(R6), R4       // make sure g != nil
+       B       gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+       MOVD    R6, g
        BL      runtime·save_g(SB)
 
-       MOVD    0(g), R4        // make sure g is not nil
        MOVD    gobuf_sp(R5), R0
        MOVD    R0, RSP
        MOVD    gobuf_bp(R5), R29
@@ -164,7 +159,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
        MOVD    R29, (g_sched+gobuf_bp)(g)
        MOVD    LR, (g_sched+gobuf_pc)(g)
        MOVD    $0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVD    g, R3
@@ -222,24 +216,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVD    $runtime·systemstack_switch(SB), R6
-       ADD     $8, R6  // get past prologue
-       MOVD    R6, (g_sched+gobuf_pc)(g)
-       MOVD    RSP, R0
-       MOVD    R0, (g_sched+gobuf_sp)(g)
-       MOVD    R29, (g_sched+gobuf_bp)(g)
-       MOVD    $0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
+       BL      gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVD    R5, g
        BL      runtime·save_g(SB)
        MOVD    (g_sched+gobuf_sp)(g), R3
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUB     $16, R3
-       AND     $~15, R3
-       MOVD    $runtime·mstart(SB), R4
-       MOVD    R4, 0(R3)
        MOVD    R3, RSP
        MOVD    (g_sched+gobuf_bp)(g), R29
 
@@ -329,7 +311,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        B runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -342,8 +324,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        B       (R27)
 // Note: can't just "B NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-       MOVWU argsize+24(FP), R16
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+       MOVWU   frameSize+32(FP), R16
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -375,11 +357,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
        B       (R0)
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVD    arg+16(FP), R3;                 \
-       MOVWU   argsize+24(FP), R4;             \
+       MOVD    stackArgs+16(FP), R3;                   \
+       MOVWU   stackArgsSize+24(FP), R4;               \
        ADD     $8, RSP, R5;                    \
        BIC     $0xf, R4, R6;                   \
        CBZ     R6, 6(PC);                      \
@@ -405,10 +387,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        BL      (R0);                           \
        /* copy return values back */           \
-       MOVD    argtype+0(FP), R7;              \
-       MOVD    arg+16(FP), R3;                 \
-       MOVWU   n+24(FP), R4;                   \
-       MOVWU   retoffset+28(FP), R6;           \
+       MOVD    stackArgsType+0(FP), R7;                \
+       MOVD    stackArgs+16(FP), R3;                   \
+       MOVWU   stackArgsSize+24(FP), R4;                       \
+       MOVWU   stackRetOffset+28(FP), R6;              \
        ADD     $8, RSP, R5;                    \
        ADD     R6, R5;                         \
        ADD     R6, R3;                         \
@@ -420,11 +402,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $40-0
+TEXT callRet<>(SB), NOSPLIT, $48-0
        MOVD    R7, 8(RSP)
        MOVD    R3, 16(RSP)
        MOVD    R5, 24(RSP)
        MOVD    R4, 32(RSP)
+       MOVD    $0, 40(RSP)
        BL      runtime·reflectcallmove(SB)
        RET
 
@@ -875,9 +858,15 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
        MOVD    0(R26), R3
        B       (R3)
 
-// Save state of caller into g->sched. Smashes R0.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVD    LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R0.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·systemstack_switch(SB), R0
+       ADD     $8, R0  // get past prologue
+       MOVD    R0, (g_sched+gobuf_pc)(g)
        MOVD    RSP, R0
        MOVD    R0, (g_sched+gobuf_sp)(g)
        MOVD    R29, (g_sched+gobuf_bp)(g)
@@ -889,6 +878,17 @@ TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
        CALL    runtime·badctxt(SB)
        RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+       MOVD    fn+0(FP), R1
+       MOVD    arg+8(FP), R0
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R1)
+       ADD     $16, RSP        // skip over saved frame pointer below RSP
+       RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
@@ -913,8 +913,8 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
        BEQ     nosave
 
        // Switch to system stack.
-       MOVD    R0, R9  // gosave<> and save_g might clobber R0
-       BL      gosave<>(SB)
+       MOVD    R0, R9  // gosave_systemstack_switch<> and save_g might clobber R0
+       BL      gosave_systemstack_switch<>(SB)
        MOVD    R3, g
        BL      runtime·save_g(SB)
        MOVD    (g_sched+gobuf_sp)(g), R0
@@ -967,7 +967,7 @@ nosave:
        BL      (R1)
        // Restore stack pointer.
        MOVD    8(RSP), R2
-       MOVD    R2, RSP 
+       MOVD    R2, RSP
        MOVD    R0, ret+16(FP)
        RET
 
@@ -1115,6 +1115,9 @@ TEXT setg_gcc<>(SB),NOSPLIT,$8
        MOVD    savedR27-8(SP), R27
        RET
 
+TEXT runtime·emptyfunc(SB),0,$0-0
+       RET
+
 TEXT runtime·abort(SB),NOSPLIT|NOFRAME,$0-0
        MOVD    ZR, R0
        MOVD    (R0), R0

diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 19781f7885fda201c2f5b437bda1ef68cf8d1ec2..c123e96a71add56c1561aebe214fecb884057d2a 100644 (file)
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -11,7 +11,7 @@
 
 #define        REGCTXT R22
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // R29 = stack; R4 = argc; R5 = argv
 
        ADDV    $-24, R29
@@ -85,30 +85,24 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       JAL     runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-       MOVV    buf+0(FP), R1
-       MOVV    R29, gobuf_sp(R1)
-       MOVV    R31, gobuf_pc(R1)
-       MOVV    g, gobuf_g(R1)
-       MOVV    R0, gobuf_lr(R1)
-       MOVV    R0, gobuf_ret(R1)
-       // Assert ctxt is zero. See func save.
-       MOVV    gobuf_ctxt(R1), R1
-       BEQ     R1, 2(PC)
-       JAL     runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
        MOVV    buf+0(FP), R3
-       MOVV    gobuf_g(R3), g  // make sure g is not nil
+       MOVV    gobuf_g(R3), R4
+       MOVV    0(R4), R0       // make sure g != nil
+       JMP     gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+       MOVV    R4, g
        JAL     runtime·save_g(SB)
 
        MOVV    0(g), R2
@@ -132,7 +126,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
        MOVV    R29, (g_sched+gobuf_sp)(g)
        MOVV    R31, (g_sched+gobuf_pc)(g)
        MOVV    R0, (g_sched+gobuf_lr)(g)
-       MOVV    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVV    g, R1
@@ -184,21 +177,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVV    $runtime·systemstack_switch(SB), R4
-       ADDV    $8, R4  // get past prologue
-       MOVV    R4, (g_sched+gobuf_pc)(g)
-       MOVV    R29, (g_sched+gobuf_sp)(g)
-       MOVV    R0, (g_sched+gobuf_lr)(g)
-       MOVV    g, (g_sched+gobuf_g)(g)
+       JAL     gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVV    R3, g
        JAL     runtime·save_g(SB)
        MOVV    (g_sched+gobuf_sp)(g), R1
-       // make it look like mstart called systemstack on g0, to stop traceback
-       ADDV    $-8, R1
-       MOVV    $runtime·mstart(SB), R2
-       MOVV    R2, 0(R1)
        MOVV    R1, R29
 
        // call target function
@@ -279,7 +263,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        JMP     runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -292,8 +276,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        JMP     (R4)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-       MOVWU argsize+24(FP), R1
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+       MOVWU   frameSize+32(FP), R1
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -325,11 +309,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
        JMP     (R4)
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVV    arg+16(FP), R1;                 \
-       MOVWU   argsize+24(FP), R2;                     \
+       MOVV    stackArgs+16(FP), R1;                   \
+       MOVWU   stackArgsSize+24(FP), R2;                       \
        MOVV    R29, R3;                                \
        ADDV    $8, R3;                 \
        ADDV    R3, R2;                         \
@@ -345,10 +329,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        JAL     (R4);                           \
        /* copy return values back */           \
-       MOVV    argtype+0(FP), R5;              \
-       MOVV    arg+16(FP), R1;                 \
-       MOVWU   n+24(FP), R2;                   \
-       MOVWU   retoffset+28(FP), R4;           \
+       MOVV    stackArgsType+0(FP), R5;                \
+       MOVV    stackArgs+16(FP), R1;                   \
+       MOVWU   stackArgsSize+24(FP), R2;                       \
+       MOVWU   stackRetOffset+28(FP), R4;              \
        ADDV    $8, R29, R3;                            \
        ADDV    R4, R3;                         \
        ADDV    R4, R1;                         \
@@ -360,11 +344,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        MOVV    R5, 8(R29)
        MOVV    R1, 16(R29)
        MOVV    R3, 24(R29)
        MOVV    R2, 32(R29)
+       MOVV    $0, 40(R29)
        JAL     runtime·reflectcallmove(SB)
        RET
 
@@ -415,9 +400,15 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
        MOVV    0(REGCTXT), R4
        JMP     (R4)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVV    R31, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVV    $runtime·systemstack_switch(SB), R1
+       ADDV    $8, R1  // get past prologue
+       MOVV    R1, (g_sched+gobuf_pc)(g)
        MOVV    R29, (g_sched+gobuf_sp)(g)
        MOVV    R0, (g_sched+gobuf_lr)(g)
        MOVV    R0, (g_sched+gobuf_ret)(g)
@@ -427,6 +418,15 @@ TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
        JAL     runtime·badctxt(SB)
        RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+       MOVV    fn+0(FP), R25
+       MOVV    arg+8(FP), R4
+       JAL     (R25)
+       RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
@@ -445,7 +445,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
        MOVV    m_g0(R5), R6
        BEQ     R6, g, g0
 
-       JAL     gosave<>(SB)
+       JAL     gosave_systemstack_switch<>(SB)
        MOVV    R6, g
        JAL     runtime·save_g(SB)
        MOVV    (g_sched+gobuf_sp)(g), R29

diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index ee87d81436304436952bdafc72ed5cd4bd185281..0c7d28dcf7da16ba82060aa50e4d99893ad04f2c 100644 (file)
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -11,7 +11,7 @@
 
 #define        REGCTXT R22
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // R29 = stack; R4 = argc; R5 = argv
 
        ADDU    $-12, R29
@@ -86,33 +86,25 @@ TEXT runtime·breakpoint(SB),NOSPLIT,$0-0
 TEXT runtime·asminit(SB),NOSPLIT,$0-0
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       JAL     runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB),NOSPLIT|NOFRAME,$0-4
-       MOVW    buf+0(FP), R1
-       MOVW    R29, gobuf_sp(R1)
-       MOVW    R31, gobuf_pc(R1)
-       MOVW    g, gobuf_g(R1)
-       MOVW    R0, gobuf_lr(R1)
-       MOVW    R0, gobuf_ret(R1)
-       // Assert ctxt is zero. See func save.
-       MOVW    gobuf_ctxt(R1), R1
-       BEQ     R1, 2(PC)
-       JAL     runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB),NOSPLIT,$8-4
+TEXT runtime·gogo(SB),NOSPLIT|NOFRAME,$0-4
        MOVW    buf+0(FP), R3
-       MOVW    gobuf_g(R3), g  // make sure g is not nil
-       JAL     runtime·save_g(SB)
+       MOVW    gobuf_g(R3), R4
+       MOVW    0(R4), R5       // make sure g != nil
+       JMP     gogo<>(SB)
 
-       MOVW    0(g), R2
+TEXT gogo<>(SB),NOSPLIT|NOFRAME,$0
+       MOVW    R4, g
+       JAL     runtime·save_g(SB)
        MOVW    gobuf_sp(R3), R29
        MOVW    gobuf_lr(R3), R31
        MOVW    gobuf_ret(R3), R1
@@ -133,7 +125,6 @@ TEXT runtime·mcall(SB),NOSPLIT|NOFRAME,$0-4
        MOVW    R29, (g_sched+gobuf_sp)(g)
        MOVW    R31, (g_sched+gobuf_pc)(g)
        MOVW    R0, (g_sched+gobuf_lr)(g)
-       MOVW    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVW    g, R1
@@ -185,21 +176,12 @@ TEXT runtime·systemstack(SB),NOSPLIT,$0-4
 switch:
        // save our state in g->sched.  Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVW    $runtime·systemstack_switch(SB), R4
-       ADDU    $8, R4  // get past prologue
-       MOVW    R4, (g_sched+gobuf_pc)(g)
-       MOVW    R29, (g_sched+gobuf_sp)(g)
-       MOVW    R0, (g_sched+gobuf_lr)(g)
-       MOVW    g, (g_sched+gobuf_g)(g)
+       JAL     gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVW    R3, g
        JAL     runtime·save_g(SB)
        MOVW    (g_sched+gobuf_sp)(g), R1
-       // make it look like mstart called systemstack on g0, to stop traceback
-       ADDU    $-4, R1
-       MOVW    $runtime·mstart(SB), R2
-       MOVW    R2, 0(R1)
        MOVW    R1, R29
 
        // call target function
@@ -280,7 +262,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
        JMP     runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 
@@ -291,8 +273,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
        MOVW    $NAME(SB), R4;  \
        JMP     (R4)
 
-TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
-       MOVW    argsize+12(FP), R1
+TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-28
+       MOVW    frameSize+20(FP), R1
 
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
@@ -325,11 +307,11 @@ TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
        JMP     (R4)
 
 #define CALLFN(NAME,MAXSIZE)   \
-TEXT NAME(SB),WRAPPER,$MAXSIZE-20;     \
+TEXT NAME(SB),WRAPPER,$MAXSIZE-28;     \
        NO_LOCAL_POINTERS;      \
        /* copy arguments to stack */           \
-       MOVW    arg+8(FP), R1;  \
-       MOVW    argsize+12(FP), R2;     \
+       MOVW    stackArgs+8(FP), R1;    \
+       MOVW    stackArgsSize+12(FP), R2;       \
        MOVW    R29, R3;        \
        ADDU    $4, R3; \
        ADDU    R3, R2; \
@@ -345,10 +327,10 @@ TEXT NAME(SB),WRAPPER,$MAXSIZE-20;        \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        JAL     (R4);   \
        /* copy return values back */           \
-       MOVW    argtype+0(FP), R5;      \
-       MOVW    arg+8(FP), R1;  \
-       MOVW    n+12(FP), R2;   \
-       MOVW    retoffset+16(FP), R4;   \
+       MOVW    stackArgsType+0(FP), R5;        \
+       MOVW    stackArgs+8(FP), R1;    \
+       MOVW    stackArgsSize+12(FP), R2;       \
+       MOVW    stackRetOffset+16(FP), R4;      \
        ADDU    $4, R29, R3;    \
        ADDU    R4, R3; \
        ADDU    R4, R1; \
@@ -360,11 +342,12 @@ TEXT NAME(SB),WRAPPER,$MAXSIZE-20;        \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
        MOVW    R5, 4(R29)
        MOVW    R1, 8(R29)
        MOVW    R3, 12(R29)
        MOVW    R2, 16(R29)
+       MOVW    $0, 20(R29)
        JAL     runtime·reflectcallmove(SB)
        RET
 
@@ -415,9 +398,15 @@ TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
        MOVW    0(REGCTXT), R4
        JMP     (R4)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVW    R31, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVW    $runtime·systemstack_switch(SB), R1
+       ADDU    $8, R1  // get past prologue
+       MOVW    R1, (g_sched+gobuf_pc)(g)
        MOVW    R29, (g_sched+gobuf_sp)(g)
        MOVW    R0, (g_sched+gobuf_lr)(g)
        MOVW    R0, (g_sched+gobuf_ret)(g)
@@ -445,7 +434,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
        MOVW    m_g0(R5), R6
        BEQ     R6, g, g0
 
-       JAL     gosave<>(SB)
+       JAL     gosave_systemstack_switch<>(SB)
        MOVW    R6, g
        JAL     runtime·save_g(SB)
        MOVW    (g_sched+gobuf_sp)(g), R29

diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index dc34c0e4c876bd1d8d83e96b54307262a15835d2..56e73742ea446fdc69bb3b29067868fdc00f40fe 100644 (file)
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -16,7 +16,7 @@
 #define cgoCalleeStackSize 32
 #endif
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // R1 = stack; R3 = argc; R4 = argv; R13 = C TLS base pointer
 
        // initialize essential registers
@@ -124,35 +124,26 @@ TEXT runtime·reginit(SB),NOSPLIT|NOFRAME,$0-0
        XOR R0, R0
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       BL      runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-       MOVD    buf+0(FP), R3
-       MOVD    R1, gobuf_sp(R3)
-       MOVD    LR, R31
-       MOVD    R31, gobuf_pc(R3)
-       MOVD    g, gobuf_g(R3)
-       MOVD    R0, gobuf_lr(R3)
-       MOVD    R0, gobuf_ret(R3)
-       // Assert ctxt is zero. See func save.
-       MOVD    gobuf_ctxt(R3), R3
-       CMP     R0, R3
-       BEQ     2(PC)
-       BL      runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
        MOVD    buf+0(FP), R5
-       MOVD    gobuf_g(R5), g  // make sure g is not nil
+       MOVD    gobuf_g(R5), R6
+       MOVD    0(R6), R4       // make sure g != nil
+       BR      gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+       MOVD    R6, g
        BL      runtime·save_g(SB)
 
-       MOVD    0(g), R4
        MOVD    gobuf_sp(R5), R1
        MOVD    gobuf_lr(R5), R31
 #ifndef GOOS_aix
@@ -180,7 +171,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
        MOVD    LR, R31
        MOVD    R31, (g_sched+gobuf_pc)(g)
        MOVD    R0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVD    g, R3
@@ -246,22 +236,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVD    $runtime·systemstack_switch(SB), R6
-       ADD     $16, R6 // get past prologue (including r2-setting instructions when they're there)
-       MOVD    R6, (g_sched+gobuf_pc)(g)
-       MOVD    R1, (g_sched+gobuf_sp)(g)
-       MOVD    R0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
+       BL      gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVD    R5, g
        BL      runtime·save_g(SB)
-       MOVD    (g_sched+gobuf_sp)(g), R3
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUB     $FIXED_FRAME, R3
-       MOVD    $runtime·mstart(SB), R4
-       MOVD    R4, 0(R3)
-       MOVD    R3, R1
+       MOVD    (g_sched+gobuf_sp)(g), R1
 
        // call target function
        MOVD    0(R11), R12     // code pointer
@@ -356,7 +336,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        BR      runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -370,8 +350,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        BR      (CTR)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-       MOVWZ argsize+24(FP), R3
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+       MOVWZ   frameSize+32(FP), R3
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -404,11 +384,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
        BR      (CTR)
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVD    arg+16(FP), R3;                 \
-       MOVWZ   argsize+24(FP), R4;                     \
+       MOVD    stackArgs+16(FP), R3;                   \
+       MOVWZ   stackArgsSize+24(FP), R4;                       \
        MOVD    R1, R5;                         \
        CMP     R4, $8;                         \
        BLT     tailsetup;                      \
@@ -456,10 +436,10 @@ callfn: \
        MOVD    24(R1), R2;                     \
 #endif                                         \
        /* copy return values back */           \
-       MOVD    argtype+0(FP), R7;              \
-       MOVD    arg+16(FP), R3;                 \
-       MOVWZ   n+24(FP), R4;                   \
-       MOVWZ   retoffset+28(FP), R6;           \
+       MOVD    stackArgsType+0(FP), R7;                \
+       MOVD    stackArgs+16(FP), R3;                   \
+       MOVWZ   stackArgsSize+24(FP), R4;                       \
+       MOVWZ   stackRetOffset+28(FP), R6;              \
        ADD     $FIXED_FRAME, R1, R5;           \
        ADD     R6, R5;                         \
        ADD     R6, R3;                         \
@@ -471,11 +451,12 @@ callfn: \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        MOVD    R7, FIXED_FRAME+0(R1)
        MOVD    R3, FIXED_FRAME+8(R1)
        MOVD    R5, FIXED_FRAME+16(R1)
        MOVD    R4, FIXED_FRAME+24(R1)
+       MOVD    $0, FIXED_FRAME+32(R1)
        BL      runtime·reflectcallmove(SB)
        RET
 
@@ -550,9 +531,14 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
        MOVD    R12, CTR
        BR      (CTR)
 
-// Save state of caller into g->sched. Smashes R31.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVD    LR, R31
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R31.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·systemstack_switch(SB), R31
+       ADD     $16, R31 // get past prologue (including r2-setting instructions when they're there)
        MOVD    R31, (g_sched+gobuf_pc)(g)
        MOVD    R1, (g_sched+gobuf_sp)(g)
        MOVD    R0, (g_sched+gobuf_lr)(g)
@@ -593,7 +579,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
        MOVD    m_g0(R8), R6
        CMP     R6, g
        BEQ     g0
-       BL      gosave<>(SB)
+       BL      gosave_systemstack_switch<>(SB)
        MOVD    R6, g
        BL      runtime·save_g(SB)
        MOVD    (g_sched+gobuf_sp)(g), R1

diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index 01b42dc3debe6d98b975e586a963639e27467735..30f2bd2e4a587438eb19e69dc401ee980e0c9584 100644 (file)
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -7,7 +7,7 @@
 #include "textflag.h"
 
 // func rt0_go()
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // X2 = stack; A0 = argc; A1 = argv
        ADD     $-24, X2
        MOV     A0, 8(X2)       // argc
@@ -70,6 +70,10 @@ nocgo:
        WORD $0 // crash if reached
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       CALL    runtime·mstart0(SB)
+       RET // not reached
+
 // void setg_gcc(G*); set g called from gcc with g in A0
 TEXT setg_gcc<>(SB),NOSPLIT,$0-0
        MOV     A0, g
@@ -114,21 +118,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
        // save our state in g->sched. Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOV     $runtime·systemstack_switch(SB), T2
-       ADD     $8, T2  // get past prologue
-       MOV     T2, (g_sched+gobuf_pc)(g)
-       MOV     X2, (g_sched+gobuf_sp)(g)
-       MOV     ZERO, (g_sched+gobuf_lr)(g)
-       MOV     g, (g_sched+gobuf_g)(g)
+       CALL    gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOV     T1, g
        CALL    runtime·save_g(SB)
        MOV     (g_sched+gobuf_sp)(g), T0
-       // make it look like mstart called systemstack on g0, to stop traceback
-       ADD     $-8, T0
-       MOV     $runtime·mstart(SB), T1
-       MOV     T1, 0(T0)
        MOV     T0, X2
 
        // call target function
@@ -233,12 +228,16 @@ TEXT runtime·return0(SB), NOSPLIT, $0
 // restore state from Gobuf; longjmp
 
 // func gogo(buf *gobuf)
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
        MOV     buf+0(FP), T0
-       MOV     gobuf_g(T0), g  // make sure g is not nil
+       MOV     gobuf_g(T0), T1
+       MOV     0(T1), ZERO // make sure g != nil
+       JMP     gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+       MOV     T1, g
        CALL    runtime·save_g(SB)
 
-       MOV     (g), ZERO // make sure g is not nil
        MOV     gobuf_sp(T0), X2
        MOV     gobuf_lr(T0), RA
        MOV     gobuf_ret(T0), A0
@@ -279,7 +278,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
        MOV     X2, (g_sched+gobuf_sp)(g)
        MOV     RA, (g_sched+gobuf_pc)(g)
        MOV     ZERO, (g_sched+gobuf_lr)(g)
-       MOV     g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOV     g, T0
@@ -297,24 +295,15 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
        JALR    RA, T1
        JMP     runtime·badmcall2(SB)
 
-// func gosave(buf *gobuf)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-       MOV     buf+0(FP), T1
-       MOV     X2, gobuf_sp(T1)
-       MOV     RA, gobuf_pc(T1)
-       MOV     g, gobuf_g(T1)
-       MOV     ZERO, gobuf_lr(T1)
-       MOV     ZERO, gobuf_ret(T1)
-       // Assert ctxt is zero. See func save.
-       MOV     gobuf_ctxt(T1), T1
-       BEQ     T1, ZERO, 2(PC)
-       CALL    runtime·badctxt(SB)
-       RET
-
-// Save state of caller into g->sched. Smashes X31.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOV     X1, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes X31.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOV     $runtime·systemstack_switch(SB), X31
+       ADD     $8, X31 // get past prologue
+       MOV     X31, (g_sched+gobuf_pc)(g)
        MOV     X2, (g_sched+gobuf_sp)(g)
        MOV     ZERO, (g_sched+gobuf_lr)(g)
        MOV     ZERO, (g_sched+gobuf_ret)(g)
@@ -342,7 +331,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
        MOV     m_g0(X6), X7
        BEQ     X7, g, g0
 
-       CALL    gosave<>(SB)
+       CALL    gosave_systemstack_switch<>(SB)
        MOV     X7, g
        CALL    runtime·save_g(SB)
        MOV     (g_sched+gobuf_sp)(g), X2
@@ -374,7 +363,7 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
        RET
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -386,13 +375,13 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
        JALR    ZERO, T2
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-// func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+// func call(stackArgsType *rtype, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 TEXT reflect·call(SB), NOSPLIT, $0-0
        JMP     ·reflectcall(SB)
 
-// func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-       MOVWU argsize+24(FP), T0
+// func call(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+       MOVWU   frameSize+32(FP), T0
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -424,11 +413,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
        JALR    ZERO, T2
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOV     arg+16(FP), A1;                 \
-       MOVWU   argsize+24(FP), A2;             \
+       MOV     stackArgs+16(FP), A1;                   \
+       MOVWU   stackArgsSize+24(FP), A2;               \
        MOV     X2, A3;                         \
        ADD     $8, A3;                         \
        ADD     A3, A2;                         \
@@ -444,10 +433,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        JALR    RA, A4;                         \
        /* copy return values back */           \
-       MOV     argtype+0(FP), A5;              \
-       MOV     arg+16(FP), A1;                 \
-       MOVWU   n+24(FP), A2;                   \
-       MOVWU   retoffset+28(FP), A4;           \
+       MOV     stackArgsType+0(FP), A5;                \
+       MOV     stackArgs+16(FP), A1;                   \
+       MOVWU   stackArgsSize+24(FP), A2;                       \
+       MOVWU   stackRetOffset+28(FP), A4;              \
        ADD     $8, X2, A3;                     \
        ADD     A4, A3;                         \
        ADD     A4, A1;                         \
@@ -459,11 +448,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;              \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        MOV     A5, 8(X2)
        MOV     A1, 16(X2)
        MOV     A3, 24(X2)
        MOV     A2, 32(X2)
+       MOV     ZERO, 40(X2)
        CALL    runtime·reflectcallmove(SB)
        RET
 

diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 7baef373247551d0b8de92862e271b1b256d45e6..f9fb1a4c5522c75a672ff20ec26b71362227d090 100644 (file)
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -84,7 +84,7 @@ GLOBL _rt0_s390x_lib_argc<>(SB), NOPTR, $8
 DATA _rt0_s90x_lib_argv<>(SB)/8, $0
 GLOBL _rt0_s390x_lib_argv<>(SB), NOPTR, $8
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
        // R2 = argc; R3 = argv; R11 = temp; R13 = g; R15 = stack pointer
        // C TLS base pointer in AR0:AR1
 
@@ -170,30 +170,24 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
        RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       CALL    runtime·mstart0(SB)
+       RET // not reached
+
 /*
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $-8-8
-       MOVD    buf+0(FP), R3
-       MOVD    R15, gobuf_sp(R3)
-       MOVD    LR, gobuf_pc(R3)
-       MOVD    g, gobuf_g(R3)
-       MOVD    $0, gobuf_lr(R3)
-       MOVD    $0, gobuf_ret(R3)
-       // Assert ctxt is zero. See func save.
-       MOVD    gobuf_ctxt(R3), R3
-       CMPBEQ  R3, $0, 2(PC)
-       BL      runtime·badctxt(SB)
-       RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
        MOVD    buf+0(FP), R5
-       MOVD    gobuf_g(R5), g  // make sure g is not nil
+       MOVD    gobuf_g(R5), R6
+       MOVD    0(R6), R7       // make sure g != nil
+       BR      gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+       MOVD    R6, g
        BL      runtime·save_g(SB)
 
        MOVD    0(g), R4
@@ -218,7 +212,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $-8-8
        MOVD    R15, (g_sched+gobuf_sp)(g)
        MOVD    LR, (g_sched+gobuf_pc)(g)
        MOVD    $0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
 
        // Switch to m->g0 & its stack, call fn.
        MOVD    g, R3
@@ -271,22 +264,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
        // save our state in g->sched.  Pretend to
        // be systemstack_switch if the G stack is scanned.
-       MOVD    $runtime·systemstack_switch(SB), R6
-       ADD     $16, R6 // get past prologue
-       MOVD    R6, (g_sched+gobuf_pc)(g)
-       MOVD    R15, (g_sched+gobuf_sp)(g)
-       MOVD    $0, (g_sched+gobuf_lr)(g)
-       MOVD    g, (g_sched+gobuf_g)(g)
+       BL      gosave_systemstack_switch<>(SB)
 
        // switch to g0
        MOVD    R5, g
        BL      runtime·save_g(SB)
-       MOVD    (g_sched+gobuf_sp)(g), R3
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUB     $8, R3
-       MOVD    $runtime·mstart(SB), R4
-       MOVD    R4, 0(R3)
-       MOVD    R3, R15
+       MOVD    (g_sched+gobuf_sp)(g), R15
 
        // call target function
        MOVD    0(R12), R3      // code pointer
@@ -368,7 +351,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        BR      runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -381,8 +364,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
        BR      (R5)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT, $-8-32
-       MOVWZ argsize+24(FP), R3
+TEXT ·reflectcall(SB), NOSPLIT, $-8-48
+       MOVWZ   frameSize+32(FP), R3
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
        DISPATCH(runtime·call64, 64)
@@ -414,11 +397,11 @@ TEXT ·reflectcall(SB), NOSPLIT, $-8-32
        BR      (R5)
 
 #define CALLFN(NAME,MAXSIZE)                   \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;           \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;           \
        NO_LOCAL_POINTERS;                      \
        /* copy arguments to stack */           \
-       MOVD    arg+16(FP), R4;                 \
-       MOVWZ   argsize+24(FP), R5;             \
+       MOVD    stackArgs+16(FP), R4;                   \
+       MOVWZ   stackArgsSize+24(FP), R5;               \
        MOVD    $stack-MAXSIZE(SP), R6;         \
 loopArgs: /* copy 256 bytes at a time */       \
        CMP     R5, $256;                       \
@@ -439,11 +422,11 @@ callFunction:                                     \
        PCDATA  $PCDATA_StackMapIndex, $0;      \
        BL      (R8);                           \
        /* copy return values back */           \
-       MOVD    argtype+0(FP), R7;              \
-       MOVD    arg+16(FP), R6;                 \
-       MOVWZ   n+24(FP), R5;                   \
+       MOVD    stackArgsType+0(FP), R7;                \
+       MOVD    stackArgs+16(FP), R6;                   \
+       MOVWZ   stackArgsSize+24(FP), R5;                       \
        MOVD    $stack-MAXSIZE(SP), R4;         \
-       MOVWZ   retoffset+28(FP), R1;           \
+       MOVWZ   stackRetOffset+28(FP), R1;              \
        ADD     R1, R4;                         \
        ADD     R1, R6;                         \
        SUB     R1, R5;                         \
@@ -454,11 +437,12 @@ callFunction:                                     \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        MOVD    R7, 8(R15)
        MOVD    R6, 16(R15)
        MOVD    R4, 24(R15)
        MOVD    R5, 32(R15)
+       MOVD    $0, 40(R15)
        BL      runtime·reflectcallmove(SB)
        RET
 
@@ -512,9 +496,15 @@ TEXT runtime·jmpdefer(SB),NOSPLIT|NOFRAME,$0-16
        MOVD    0(R12), R3
        BR      (R3)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-       MOVD    LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·systemstack_switch(SB), R1
+       ADD     $16, R1 // get past prologue
+       MOVD    R1, (g_sched+gobuf_pc)(g)
        MOVD    R15, (g_sched+gobuf_sp)(g)
        MOVD    $0, (g_sched+gobuf_lr)(g)
        MOVD    $0, (g_sched+gobuf_ret)(g)
@@ -543,7 +533,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
        MOVD    g_m(g), R6
        MOVD    m_g0(R6), R6
        CMPBEQ  R6, g, g0
-       BL      gosave<>(SB)
+       BL      gosave_systemstack_switch<>(SB)
        MOVD    R6, g
        BL      runtime·save_g(SB)
        MOVD    (g_sched+gobuf_sp)(g), R15

diff --git a/src/runtime/asm_wasm.s b/src/runtime/asm_wasm.s
index fcb780f1dc8303619969d972b1731d146678ff5a..33c335ba5af91bfde9c613cd164b095e03ea090f 100644 (file)
--- a/src/runtime/asm_wasm.s
+++ b/src/runtime/asm_wasm.s
@@ -7,7 +7,7 @@
 #include "funcdata.h"
 #include "textflag.h"
 
-TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME, $0
+TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME|TOPFRAME, $0
        // save m->g0 = g0
        MOVD $runtime·g0(SB), runtime·m0+m_g0(SB)
        // save m0 to g0->m
@@ -24,6 +24,10 @@ TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME, $0
        CALL runtime·mstart(SB) // WebAssembly stack will unwind when switching to another goroutine
        UNDEF
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+       CALL    runtime·mstart0(SB)
+       RET // not reached
+
 DATA  runtime·mainPC+0(SB)/8,$runtime·main(SB)
 GLOBL runtime·mainPC(SB),RODATA,$8
 
@@ -34,7 +38,9 @@ TEXT ·checkASM(SB), NOSPLIT, $0-1
 
 TEXT runtime·gogo(SB), NOSPLIT, $0-8
        MOVD buf+0(FP), R0
-       MOVD gobuf_g(R0), g
+       MOVD gobuf_g(R0), R1
+       MOVD 0(R1), R2  // make sure g != nil
+       MOVD R1, g
        MOVD gobuf_sp(R0), SP
 
        // Put target PC at -8(SP), wasm_pc_f_loop will pick it up
@@ -69,7 +75,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
        // save state in g->sched
        MOVD 0(SP), g_sched+gobuf_pc(g)     // caller's PC
        MOVD $fn+0(FP), g_sched+gobuf_sp(g) // caller's SP
-       MOVD g, g_sched+gobuf_g(g)
 
        // if g == g0 call badmcall
        Get g
@@ -143,7 +148,6 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
        MOVD $runtime·systemstack_switch(SB), g_sched+gobuf_pc(g)
 
        MOVD SP, g_sched+gobuf_sp(g)
-       MOVD g, g_sched+gobuf_g(g)
 
        // switch to g0
        MOVD R2, g
@@ -270,7 +274,6 @@ TEXT runtime·morestack(SB), NOSPLIT, $0-0
 
        // Set g->sched to context in f.
        MOVD 0(SP), g_sched+gobuf_pc(g)
-       MOVD g, g_sched+gobuf_g(g)
        MOVD $8(SP), g_sched+gobuf_sp(g) // f's SP
        MOVD CTXT, g_sched+gobuf_ctxt(g)
 
@@ -296,14 +299,14 @@ TEXT ·asmcgocall(SB), NOSPLIT, $0-0
                JMP NAME(SB); \
        End
 
-TEXT ·reflectcall(SB), NOSPLIT, $0-32
+TEXT ·reflectcall(SB), NOSPLIT, $0-48
        I64Load fn+8(FP)
        I64Eqz
        If
                CALLNORESUME runtime·sigpanic<ABIInternal>(SB)
        End
 
-       MOVW argsize+24(FP), R0
+       MOVW frameSize+32(FP), R0
 
        DISPATCH(runtime·call16, 16)
        DISPATCH(runtime·call32, 32)
@@ -335,18 +338,18 @@ TEXT ·reflectcall(SB), NOSPLIT, $0-32
        JMP runtime·badreflectcall(SB)
 
 #define CALLFN(NAME, MAXSIZE) \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48; \
        NO_LOCAL_POINTERS; \
-       MOVW argsize+24(FP), R0; \
+       MOVW stackArgsSize+24(FP), R0; \
        \
        Get R0; \
        I64Eqz; \
        Not; \
        If; \
                Get SP; \
-               I64Load argptr+16(FP); \
+               I64Load stackArgs+16(FP); \
                I32WrapI64; \
-               I64Load argsize+24(FP); \
+               I64Load stackArgsSize+24(FP); \
                I64Const $3; \
                I64ShrU; \
                I32WrapI64; \
@@ -359,12 +362,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
        I64Load $0; \
        CALL; \
        \
-       I64Load32U retoffset+28(FP); \
+       I64Load32U stackRetOffset+28(FP); \
        Set R0; \
        \
-       MOVD argtype+0(FP), RET0; \
+       MOVD stackArgsType+0(FP), RET0; \
        \
-       I64Load argptr+16(FP); \
+       I64Load stackArgs+16(FP); \
        Get R0; \
        I64Add; \
        Set RET1; \
@@ -375,7 +378,7 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
        I64Add; \
        Set RET2; \
        \
-       I64Load32U argsize+24(FP); \
+       I64Load32U stackArgsSize+24(FP); \
        Get R0; \
        I64Sub; \
        Set RET3; \
@@ -387,12 +390,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
        NO_LOCAL_POINTERS
        MOVD RET0, 0(SP)
        MOVD RET1, 8(SP)
        MOVD RET2, 16(SP)
        MOVD RET3, 24(SP)
+       MOVD $0,   32(SP)
        CALL runtime·reflectcallmove(SB)
        RET
 
@@ -424,7 +428,7 @@ CALLFN(·call268435456, 268435456)
 CALLFN(·call536870912, 536870912)
 CALLFN(·call1073741824, 1073741824)
 
-TEXT runtime·goexit(SB), NOSPLIT, $0-0
+TEXT runtime·goexit(SB), NOSPLIT|TOPFRAME, $0-0
        NOP // first PC of goexit is skipped
        CALL runtime·goexit1(SB) // does not return
        UNDEF

diff --git a/src/runtime/cgo/gcc_amd64.S b/src/runtime/cgo/gcc_amd64.S
index 17d9d47ef40cbc7d3f4e641b012c5cd6d6fd63ab..d75f8646663ab497a7ef5bcea498291f7301772b 100644 (file)
--- a/src/runtime/cgo/gcc_amd64.S
+++ b/src/runtime/cgo/gcc_amd64.S
@@ -30,9 +30,14 @@ EXT(crosscall_amd64):
        pushq %r15
 
 #if defined(_WIN64)
+       movq %r8, %rdi  /* arg of setg_gcc */
+       call *%rdx      /* setg_gcc */
        call *%rcx      /* fn */
 #else
-       call *%rdi      /* fn */
+       movq %rdi, %rbx
+       movq %rdx, %rdi /* arg of setg_gcc */
+       call *%rsi      /* setg_gcc */
+       call *%rbx      /* fn */
 #endif
 
        popq %r15

diff --git a/src/runtime/cgo/gcc_darwin_amd64.c b/src/runtime/cgo/gcc_darwin_amd64.c
index 51410d50269dafd1d5ee4c34294d08b1984a48eb..d5b7fd8fd802bf21d734db635e2a5455fb83403f 100644 (file)
--- a/src/runtime/cgo/gcc_darwin_amd64.c
+++ b/src/runtime/cgo/gcc_darwin_amd64.c
@@ -9,13 +9,16 @@
 #include "libcgo_unix.h"
 
 static void* threadentry(void*);
+static void (*setg_gcc)(void*);
 
 void
-x_cgo_init(G *g)
+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
 {
        pthread_attr_t attr;
        size_t size;
 
+       setg_gcc = setg;
+
        pthread_attr_init(&attr);
        pthread_attr_getstacksize(&attr, &size);
        g->stacklo = (uintptr)&attr - size + 4096;
@@ -57,10 +60,6 @@ threadentry(void *v)
        ts = *(ThreadStart*)v;
        free(v);
 
-       // Move the g pointer into the slot reserved in thread local storage.
-       // Constant must match the one in cmd/link/internal/ld/sym.go.
-       asm volatile("movq %0, %%gs:0x30" :: "r"(ts.g));
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c
index d25db91900071aea15e9ceaa4c46a245f73bbb43..0003414bf8665aba986a510192f2e7918fc62a55 100644 (file)
--- a/src/runtime/cgo/gcc_dragonfly_amd64.c
+++ b/src/runtime/cgo/gcc_dragonfly_amd64.c
@@ -61,11 +61,6 @@ threadentry(void *v)
        ts = *(ThreadStart*)v;
        free(v);
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_freebsd_amd64.c b/src/runtime/cgo/gcc_freebsd_amd64.c
index 514a2f8a235ee78c2c1f2e5e75e9ecc01ea49eac..6071ec39093783c469b99079dc770b0f19f896d7 100644 (file)
--- a/src/runtime/cgo/gcc_freebsd_amd64.c
+++ b/src/runtime/cgo/gcc_freebsd_amd64.c
@@ -69,11 +69,6 @@ threadentry(void *v)
        free(v);
        _cgo_tsan_release();
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_linux_386.c b/src/runtime/cgo/gcc_linux_386.c
index ece9f933c5603419f4511cf93bacba41f79ba090..70c942aeb842d9bd87d23d2bb6a61e3ec666184d 100644 (file)
--- a/src/runtime/cgo/gcc_linux_386.c
+++ b/src/runtime/cgo/gcc_linux_386.c
@@ -12,7 +12,7 @@ static void *threadentry(void*);
 static void (*setg_gcc)(void*);
 
 // This will be set in gcc_android.c for android-specific customization.
-void (*x_cgo_inittls)(void **tlsg, void **tlsbase);
+void (*x_cgo_inittls)(void **tlsg, void **tlsbase) __attribute__((common));
 
 void
 x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)

diff --git a/src/runtime/cgo/gcc_linux_amd64.c b/src/runtime/cgo/gcc_linux_amd64.c
index 9134e0df920fcb8c8f6bfa3e228a0e5258a9ccda..c25e7e769ba23ddae032e510b1c062dd776f1f6c 100644 (file)
--- a/src/runtime/cgo/gcc_linux_amd64.c
+++ b/src/runtime/cgo/gcc_linux_amd64.c
@@ -14,7 +14,7 @@ static void* threadentry(void*);
 static void (*setg_gcc)(void*);
 
 // This will be set in gcc_android.c for android-specific customization.
-void (*x_cgo_inittls)(void **tlsg, void **tlsbase);
+void (*x_cgo_inittls)(void **tlsg, void **tlsbase) __attribute__((common));
 
 void
 x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
@@ -89,11 +89,6 @@ threadentry(void *v)
        free(v);
        _cgo_tsan_release();
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_linux_arm.c b/src/runtime/cgo/gcc_linux_arm.c
index 61855b96b227ea310c36f8e49fab2d7f0e34ab6b..5bc0fee90d4949bda561b86195005296d9e70567 100644 (file)
--- a/src/runtime/cgo/gcc_linux_arm.c
+++ b/src/runtime/cgo/gcc_linux_arm.c
@@ -10,7 +10,7 @@
 
 static void *threadentry(void*);
 
-void (*x_cgo_inittls)(void **tlsg, void **tlsbase);
+void (*x_cgo_inittls)(void **tlsg, void **tlsbase) __attribute__((common));
 static void (*setg_gcc)(void*);
 
 void

diff --git a/src/runtime/cgo/gcc_linux_arm64.c b/src/runtime/cgo/gcc_linux_arm64.c
index 261c884ac95982ab578727359cc4f87bd02fdbe3..17ff274fbbeae61c2a42f702502e63f07c92e985 100644 (file)
--- a/src/runtime/cgo/gcc_linux_arm64.c
+++ b/src/runtime/cgo/gcc_linux_arm64.c
@@ -12,7 +12,7 @@
 
 static void *threadentry(void*);
 
-void (*x_cgo_inittls)(void **tlsg, void **tlsbase);
+void (*x_cgo_inittls)(void **tlsg, void **tlsbase) __attribute__((common));
 static void (*setg_gcc)(void*);
 
 void

diff --git a/src/runtime/cgo/gcc_netbsd_amd64.c b/src/runtime/cgo/gcc_netbsd_amd64.c
index dc966fc45b4ba4f3a9b723aace2de527297ea450..9f4b031a08954de8cba3ef6b63e6cd6ff17b0600 100644 (file)
--- a/src/runtime/cgo/gcc_netbsd_amd64.c
+++ b/src/runtime/cgo/gcc_netbsd_amd64.c
@@ -62,11 +62,6 @@ threadentry(void *v)
        ts = *(ThreadStart*)v;
        free(v);
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
        // On NetBSD, a new thread inherits the signal stack of the
        // creating thread. That confuses minit, so we remove that
        // signal stack here before calling the regular mstart. It's
@@ -78,6 +73,6 @@ threadentry(void *v)
        ss.ss_flags = SS_DISABLE;
        sigaltstack(&ss, nil);
 
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_openbsd_amd64.c b/src/runtime/cgo/gcc_openbsd_amd64.c
index 34319fb0b80e3b642ba8f6ce5a51b8bef9609816..09d2750f3ad8f96c7b31d69262fed414381e4be9 100644 (file)
--- a/src/runtime/cgo/gcc_openbsd_amd64.c
+++ b/src/runtime/cgo/gcc_openbsd_amd64.c
@@ -60,11 +60,6 @@ threadentry(void *v)
        ts = *(ThreadStart*)v;
        free(v);
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_solaris_amd64.c b/src/runtime/cgo/gcc_solaris_amd64.c
index 079bd12898e25652bc791cafd5acef38b6e8fc5a..e89e844b1e0ad30ba76d3af59695391e7ceb0eff 100644 (file)
--- a/src/runtime/cgo/gcc_solaris_amd64.c
+++ b/src/runtime/cgo/gcc_solaris_amd64.c
@@ -72,11 +72,6 @@ threadentry(void *v)
        ts = *(ThreadStart*)v;
        free(v);
 
-       /*
-        * Set specific keys.
-        */
-       setg_gcc((void*)ts.g);
-
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c
index 0f8c817f0e4d138fd7d0efd396d26f16435bd6b3..25cfd086ddc3331997d59e7cb24a061b42d64e15 100644 (file)
--- a/src/runtime/cgo/gcc_windows_amd64.c
+++ b/src/runtime/cgo/gcc_windows_amd64.c
@@ -12,10 +12,12 @@
 #include "libcgo_windows.h"
 
 static void threadentry(void*);
+static void (*setg_gcc)(void*);
 
 void
-x_cgo_init(G *g)
+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
 {
+       setg_gcc = setg;
 }
 
 
@@ -46,10 +48,8 @@ threadentry(void *v)
         */
        asm volatile (
          "movq %0, %%gs:0x28\n"        // MOVL tls0, 0x28(GS)
-         "movq %%gs:0x28, %%rax\n" // MOVQ 0x28(GS), tmp
-         "movq %1, 0(%%rax)\n" // MOVQ g, 0(GS)
-         :: "r"(ts.tls), "r"(ts.g) : "%rax"
+         :: "r"(ts.tls)
        );
 
-       crosscall_amd64(ts.fn);
+       crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 }

diff --git a/src/runtime/cgo/libcgo.h b/src/runtime/cgo/libcgo.h
index aba500a301c66a0c1864c3fd9c61ebfc56e21a5f..af4960e7e952206a0923d4495137bb8eafeac9b4 100644 (file)
--- a/src/runtime/cgo/libcgo.h
+++ b/src/runtime/cgo/libcgo.h
@@ -66,7 +66,7 @@ uintptr_t _cgo_wait_runtime_init_done(void);
 /*
  * Call fn in the 6c world.
  */
-void crosscall_amd64(void (*fn)(void));
+void crosscall_amd64(void (*fn)(void), void (*setg_gcc)(void*), void *g);
 
 /*
  * Call fn in the 8c world.

diff --git a/src/runtime/cgo/linux_syscall.c b/src/runtime/cgo/linux_syscall.c
index 56f3d67d8bf670dbc3ca7a1867900d59aced2705..59761c8b409ef2f5da5121dae80fb26374fe3157 100644 (file)
--- a/src/runtime/cgo/linux_syscall.c
+++ b/src/runtime/cgo/linux_syscall.c
@@ -32,7 +32,7 @@ typedef struct {
 
 #define SET_RETVAL(fn) \
   uintptr_t ret = (uintptr_t) fn ; \
-  if (ret == -1) {                 \
+  if (ret == (uintptr_t) -1) {    \
     x->retval = (uintptr_t) errno; \
   } else                           \
     x->retval = ret

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 20cacd6043a12dd708d6dc637aa19a1c61205947..534a2c42951949e003aa6370acfe38ececc03d48 100644 (file)
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -306,14 +306,7 @@ func unwindm(restore *bool) {
                // unwind of g's stack (see comment at top of file).
                mp := acquirem()
                sched := &mp.g0.sched
-               switch GOARCH {
-               default:
-                       throw("unwindm not implemented")
-               case "386", "amd64", "arm", "ppc64", "ppc64le", "mips64", "mips64le", "s390x", "mips", "mipsle", "riscv64":
-                       sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + sys.MinFrameSize))
-               case "arm64":
-                       sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 16))
-               }
+               sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))
 
                // Do the accounting that cgocall will not have a chance to do
                // during an unwind.

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 9bfdfe7c7461a76fef305bd79c63ef71f5c56b62..e5d0193b9cbd4f5c10fc9ca0cac49464658ddec3 100644 (file)
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -103,7 +103,16 @@ func (p *cpuProfile) add(gp *g, stk []uintptr) {
                // because otherwise its write barrier behavior may not
                // be correct. See the long comment there before
                // changing the argument here.
-               cpuprof.log.write(&gp.labels, nanotime(), hdr[:], stk)
+               //
+               // Note: it can happen on Windows, where we are calling
+               // p.add with a gp that is not the current g, that gp is nil,
+               // meaning we interrupted a system thread with no g.
+               // Avoid faulting in that case.
+               var tagPtr *unsafe.Pointer
+               if gp != nil {
+                       tagPtr = &gp.labels
+               }
+               cpuprof.log.write(tagPtr, nanotime(), hdr[:], stk)
        }
 
        atomic.Store(&prof.signalLock, 0)

diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go
index 58ad4f3ebac399f37780281850f80e48ff873a8a..e5bd7973b70b781771b40eb734a49e0de7a0d4d6 100644 (file)
--- a/src/runtime/crash_test.go
+++ b/src/runtime/crash_test.go
@@ -294,6 +294,18 @@ func TestRecursivePanic4(t *testing.T) {
 
 }
 
+func TestRecursivePanic5(t *testing.T) {
+       output := runTestProg(t, "testprog", "RecursivePanic5")
+       want := `first panic
+second panic
+panic: third panic
+`
+       if !strings.HasPrefix(output, want) {
+               t.Fatalf("output does not start with %q:\n%s", want, output)
+       }
+
+}
+
 func TestGoexitCrash(t *testing.T) {
        // External linking brings in cgo, causing deadlock detection not working.
        testenv.MustInternalLink(t)

diff --git a/src/runtime/defer_test.go b/src/runtime/defer_test.go
index 5ac08145646063bee6e87c47cf1c48691d8149ad..9a40ea19842faf029d6a2502c38c15fedddb1f52 100644 (file)
--- a/src/runtime/defer_test.go
+++ b/src/runtime/defer_test.go
@@ -410,3 +410,31 @@ func rec1(max int) {
                rec1(max - 1)
        }
 }
+
+func TestIssue43921(t *testing.T) {
+       defer func() {
+               expect(t, 1, recover())
+       }()
+       func() {
+               // Prevent open-coded defers
+               for {
+                       defer func() {}()
+                       break
+               }
+
+               defer func() {
+                       defer func() {
+                               expect(t, 4, recover())
+                       }()
+                       panic(4)
+               }()
+               panic(1)
+
+       }()
+}
+
+func expect(t *testing.T, n int, err interface{}) {
+       if n != err {
+               t.Fatalf("have %v, want %v", err, n)
+       }
+}

diff --git a/src/runtime/defs_freebsd_386.go b/src/runtime/defs_freebsd_386.go
index 767755425c125d8c9bcca51a5122449d30230d19..f822934d582c74b40700067c676199181692409c 100644 (file)
--- a/src/runtime/defs_freebsd_386.go
+++ b/src/runtime/defs_freebsd_386.go
@@ -13,10 +13,11 @@ const (
 )
 
 const (
-       _EINTR  = 0x4
-       _EFAULT = 0xe
-       _EAGAIN = 0x23
-       _ENOSYS = 0x4e
+       _EINTR     = 0x4
+       _EFAULT    = 0xe
+       _EAGAIN    = 0x23
+       _ENOSYS    = 0x4e
+       _ETIMEDOUT = 0x3c
 
        _O_NONBLOCK = 0x4
        _O_CLOEXEC  = 0x100000

diff --git a/src/runtime/defs_freebsd_amd64.go b/src/runtime/defs_freebsd_amd64.go
index 5a833426fd68e49e2a8087d29ad04aef53c51479..0b696cf227090112fc430fe4a68a2f43ee75157f 100644 (file)
--- a/src/runtime/defs_freebsd_amd64.go
+++ b/src/runtime/defs_freebsd_amd64.go
@@ -13,10 +13,11 @@ const (
 )
 
 const (
-       _EINTR  = 0x4
-       _EFAULT = 0xe
-       _EAGAIN = 0x23
-       _ENOSYS = 0x4e
+       _EINTR     = 0x4
+       _EFAULT    = 0xe
+       _EAGAIN    = 0x23
+       _ENOSYS    = 0x4e
+       _ETIMEDOUT = 0x3c
 
        _O_NONBLOCK = 0x4
        _O_CLOEXEC  = 0x100000

diff --git a/src/runtime/defs_freebsd_arm.go b/src/runtime/defs_freebsd_arm.go
index b55dfd88cf2e36cc0c630c4d0b59e6d9421de52d..b6f3e790cff9315b02d0db5eea9621425207f1c7 100644 (file)
--- a/src/runtime/defs_freebsd_arm.go
+++ b/src/runtime/defs_freebsd_arm.go
@@ -13,10 +13,11 @@ const (
 )
 
 const (
-       _EINTR  = 0x4
-       _EFAULT = 0xe
-       _EAGAIN = 0x23
-       _ENOSYS = 0x4e
+       _EINTR     = 0x4
+       _EFAULT    = 0xe
+       _EAGAIN    = 0x23
+       _ENOSYS    = 0x4e
+       _ETIMEDOUT = 0x3c
 
        _O_NONBLOCK = 0x4
        _O_CLOEXEC  = 0x100000

diff --git a/src/runtime/defs_freebsd_arm64.go b/src/runtime/defs_freebsd_arm64.go
index 5b9d504ba6f990a15285f1248e8c4e78d67fa717..0759a1238f940ced32e496aa3e7f5cc4282be83b 100644 (file)
--- a/src/runtime/defs_freebsd_arm64.go
+++ b/src/runtime/defs_freebsd_arm64.go
@@ -13,10 +13,11 @@ const (
 )
 
 const (
-       _EINTR  = 0x4
-       _EFAULT = 0xe
-       _EAGAIN = 0x23
-       _ENOSYS = 0x4e
+       _EINTR     = 0x4
+       _EFAULT    = 0xe
+       _EAGAIN    = 0x23
+       _ENOSYS    = 0x4e
+       _ETIMEDOUT = 0x3c
 
        _O_NONBLOCK = 0x4
        _O_CLOEXEC  = 0x100000

diff --git a/src/runtime/defs_openbsd.go b/src/runtime/defs_openbsd.go
index 53e9d59a3ce3cd9da7d65cdbc02ff696b2e30674..ff7e21c71e3631d8465bed7276f93d1f616ca777 100644 (file)
--- a/src/runtime/defs_openbsd.go
+++ b/src/runtime/defs_openbsd.go
@@ -54,6 +54,13 @@ const (
        SA_RESTART = C.SA_RESTART
        SA_ONSTACK = C.SA_ONSTACK
 
+       PTHREAD_CREATE_DETACHED = C.PTHREAD_CREATE_DETACHED
+
+       F_SETFD    = C.F_SETFD
+       F_GETFL    = C.F_GETFL
+       F_SETFL    = C.F_SETFL
+       FD_CLOEXEC = C.FD_CLOEXEC
+
        SIGHUP    = C.SIGHUP
        SIGINT    = C.SIGINT
        SIGQUIT   = C.SIGQUIT
@@ -129,3 +136,10 @@ type Timeval C.struct_timeval
 type Itimerval C.struct_itimerval
 
 type KeventT C.struct_kevent
+
+type Pthread C.pthread_t
+type PthreadAttr C.pthread_attr_t
+type PthreadCond C.pthread_cond_t
+type PthreadCondAttr C.pthread_condattr_t
+type PthreadMutex C.pthread_mutex_t
+type PthreadMutexAttr C.pthread_mutexattr_t

diff --git a/src/runtime/defs_openbsd_amd64.go b/src/runtime/defs_openbsd_amd64.go
index c187a98ae0c0f1f823a094e4c21d43ce7c373780..46f1245201ce322f60dbf19a43cd15a260eb30f0 100644 (file)
--- a/src/runtime/defs_openbsd_amd64.go
+++ b/src/runtime/defs_openbsd_amd64.go
@@ -30,6 +30,13 @@ const (
        _SA_RESTART = 0x2
        _SA_ONSTACK = 0x1
 
+       _PTHREAD_CREATE_DETACHED = 0x1
+
+       _F_SETFD    = 0x2
+       _F_GETFL    = 0x3
+       _F_SETFL    = 0x4
+       _FD_CLOEXEC = 0x1
+
        _SIGHUP    = 0x1
        _SIGINT    = 0x2
        _SIGQUIT   = 0x3
@@ -177,3 +184,10 @@ type keventt struct {
        data   int64
        udata  *byte
 }
+
+type pthread uintptr
+type pthreadattr uintptr
+type pthreadcond uintptr
+type pthreadcondattr uintptr
+type pthreadmutex uintptr
+type pthreadmutexattr uintptr

diff --git a/src/runtime/defs_openbsd_arm64.go b/src/runtime/defs_openbsd_arm64.go
index 628f4bc5a5679b6084b2a91b68a0afe3ad80fb65..d2b947feb2741c00f8b9da264a444367bdfb8147 100644 (file)
--- a/src/runtime/defs_openbsd_arm64.go
+++ b/src/runtime/defs_openbsd_arm64.go
@@ -31,6 +31,13 @@ const (
        _SA_RESTART = 0x2
        _SA_ONSTACK = 0x1
 
+       _PTHREAD_CREATE_DETACHED = 0x1
+
+       _F_SETFD    = 0x2
+       _F_GETFL    = 0x3
+       _F_SETFL    = 0x4
+       _FD_CLOEXEC = 0x1
+
        _SIGHUP    = 0x1
        _SIGINT    = 0x2
        _SIGQUIT   = 0x3
@@ -157,3 +164,10 @@ type keventt struct {
        data   int64
        udata  *byte
 }
+
+type pthread uintptr
+type pthreadattr uintptr
+type pthreadcond uintptr
+type pthreadcondattr uintptr
+type pthreadmutex uintptr
+type pthreadmutexattr uintptr

diff --git a/src/runtime/defs_windows.go b/src/runtime/defs_windows.go
index 43f358d56af9f2333f624f6b072691849f19823d..8d4e38120ea538f47588a0dac49d6648d07a11bc 100644 (file)
--- a/src/runtime/defs_windows.go
+++ b/src/runtime/defs_windows.go
@@ -2,77 +2,83 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
-/*
-Input to cgo.
-
-GOARCH=amd64 go tool cgo -cdefs defs_windows.go > defs_windows_amd64.h
-GOARCH=386 go tool cgo -cdefs defs_windows.go > defs_windows_386.h
-*/
+// Windows architecture-independent definitions.
 
 package runtime
 
-/*
-#include <signal.h>
-#include <stdarg.h>
-#include <windef.h>
-#include <winbase.h>
-#include <wincon.h>
+const (
+       _PROT_NONE  = 0
+       _PROT_READ  = 1
+       _PROT_WRITE = 2
+       _PROT_EXEC  = 4
 
-#ifndef _X86_
-typedef struct {} FLOATING_SAVE_AREA;
-#endif
-#ifndef _AMD64_
-typedef struct {} M128A;
-#endif
-*/
-import "C"
+       _MAP_ANON    = 1
+       _MAP_PRIVATE = 2
 
-const (
-       PROT_NONE  = 0
-       PROT_READ  = 1
-       PROT_WRITE = 2
-       PROT_EXEC  = 4
+       _DUPLICATE_SAME_ACCESS   = 0x2
+       _THREAD_PRIORITY_HIGHEST = 0x2
 
-       MAP_ANON    = 1
-       MAP_PRIVATE = 2
+       _SIGINT              = 0x2
+       _SIGTERM             = 0xF
+       _CTRL_C_EVENT        = 0x0
+       _CTRL_BREAK_EVENT    = 0x1
+       _CTRL_CLOSE_EVENT    = 0x2
+       _CTRL_LOGOFF_EVENT   = 0x5
+       _CTRL_SHUTDOWN_EVENT = 0x6
 
-       DUPLICATE_SAME_ACCESS   = C.DUPLICATE_SAME_ACCESS
-       THREAD_PRIORITY_HIGHEST = C.THREAD_PRIORITY_HIGHEST
+       _EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
+       _EXCEPTION_BREAKPOINT           = 0x80000003
+       _EXCEPTION_ILLEGAL_INSTRUCTION  = 0xc000001d
+       _EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
+       _EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
+       _EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
+       _EXCEPTION_FLT_OVERFLOW         = 0xc0000091
+       _EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
+       _EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
+       _EXCEPTION_INT_OVERFLOW         = 0xc0000095
 
-       SIGINT              = C.SIGINT
-       SIGTERM             = C.SIGTERM
-       CTRL_C_EVENT        = C.CTRL_C_EVENT
-       CTRL_BREAK_EVENT    = C.CTRL_BREAK_EVENT
-       CTRL_CLOSE_EVENT    = C.CTRL_CLOSE_EVENT
-       CTRL_LOGOFF_EVENT   = C.CTRL_LOGOFF_EVENT
-       CTRL_SHUTDOWN_EVENT = C.CTRL_SHUTDOWN_EVENT
+       _INFINITE     = 0xffffffff
+       _WAIT_TIMEOUT = 0x102
 
-       CONTEXT_CONTROL = C.CONTEXT_CONTROL
-       CONTEXT_FULL    = C.CONTEXT_FULL
+       _EXCEPTION_CONTINUE_EXECUTION = -0x1
+       _EXCEPTION_CONTINUE_SEARCH    = 0x0
+)
 
-       EXCEPTION_ACCESS_VIOLATION     = C.STATUS_ACCESS_VIOLATION
-       EXCEPTION_BREAKPOINT           = C.STATUS_BREAKPOINT
-       EXCEPTION_FLT_DENORMAL_OPERAND = C.STATUS_FLOAT_DENORMAL_OPERAND
-       EXCEPTION_FLT_DIVIDE_BY_ZERO   = C.STATUS_FLOAT_DIVIDE_BY_ZERO
-       EXCEPTION_FLT_INEXACT_RESULT   = C.STATUS_FLOAT_INEXACT_RESULT
-       EXCEPTION_FLT_OVERFLOW         = C.STATUS_FLOAT_OVERFLOW
-       EXCEPTION_FLT_UNDERFLOW        = C.STATUS_FLOAT_UNDERFLOW
-       EXCEPTION_INT_DIVIDE_BY_ZERO   = C.STATUS_INTEGER_DIVIDE_BY_ZERO
-       EXCEPTION_INT_OVERFLOW         = C.STATUS_INTEGER_OVERFLOW
+type systeminfo struct {
+       anon0                       [4]byte
+       dwpagesize                  uint32
+       lpminimumapplicationaddress *byte
+       lpmaximumapplicationaddress *byte
+       dwactiveprocessormask       uintptr
+       dwnumberofprocessors        uint32
+       dwprocessortype             uint32
+       dwallocationgranularity     uint32
+       wprocessorlevel             uint16
+       wprocessorrevision          uint16
+}
 
-       INFINITE     = C.INFINITE
-       WAIT_TIMEOUT = C.WAIT_TIMEOUT
+type exceptionrecord struct {
+       exceptioncode        uint32
+       exceptionflags       uint32
+       exceptionrecord      *exceptionrecord
+       exceptionaddress     *byte
+       numberparameters     uint32
+       exceptioninformation [15]uintptr
+}
 
-       EXCEPTION_CONTINUE_EXECUTION = C.EXCEPTION_CONTINUE_EXECUTION
-       EXCEPTION_CONTINUE_SEARCH    = C.EXCEPTION_CONTINUE_SEARCH
-)
+type overlapped struct {
+       internal     uintptr
+       internalhigh uintptr
+       anon0        [8]byte
+       hevent       *byte
+}
 
-type SystemInfo C.SYSTEM_INFO
-type ExceptionRecord C.EXCEPTION_RECORD
-type FloatingSaveArea C.FLOATING_SAVE_AREA
-type M128a C.M128A
-type Context C.CONTEXT
-type Overlapped C.OVERLAPPED
-type MemoryBasicInformation C.MEMORY_BASIC_INFORMATION
+type memoryBasicInformation struct {
+       baseAddress       uintptr
+       allocationBase    uintptr
+       allocationProtect uint32
+       regionSize        uintptr
+       state             uint32
+       protect           uint32
+       type_             uint32
+}

diff --git a/src/runtime/defs_windows_386.go b/src/runtime/defs_windows_386.go
index 3c5057b86f0b72fcb070d9133d08de6efcc48ef3..37fe74c542364fa60355672854cd29b9c724821d 100644 (file)
--- a/src/runtime/defs_windows_386.go
+++ b/src/runtime/defs_windows_386.go
@@ -1,69 +1,10 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_windows.go
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
 
 package runtime
 
-const (
-       _PROT_NONE  = 0
-       _PROT_READ  = 1
-       _PROT_WRITE = 2
-       _PROT_EXEC  = 4
-
-       _MAP_ANON    = 1
-       _MAP_PRIVATE = 2
-
-       _DUPLICATE_SAME_ACCESS   = 0x2
-       _THREAD_PRIORITY_HIGHEST = 0x2
-
-       _SIGINT              = 0x2
-       _SIGTERM             = 0xF
-       _CTRL_C_EVENT        = 0x0
-       _CTRL_BREAK_EVENT    = 0x1
-       _CTRL_CLOSE_EVENT    = 0x2
-       _CTRL_LOGOFF_EVENT   = 0x5
-       _CTRL_SHUTDOWN_EVENT = 0x6
-
-       _CONTEXT_CONTROL = 0x10001
-       _CONTEXT_FULL    = 0x10007
-
-       _EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-       _EXCEPTION_BREAKPOINT           = 0x80000003
-       _EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-       _EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-       _EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-       _EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-       _EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-       _EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-       _EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-       _INFINITE     = 0xffffffff
-       _WAIT_TIMEOUT = 0x102
-
-       _EXCEPTION_CONTINUE_EXECUTION = -0x1
-       _EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-       anon0                       [4]byte
-       dwpagesize                  uint32
-       lpminimumapplicationaddress *byte
-       lpmaximumapplicationaddress *byte
-       dwactiveprocessormask       uint32
-       dwnumberofprocessors        uint32
-       dwprocessortype             uint32
-       dwallocationgranularity     uint32
-       wprocessorlevel             uint16
-       wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-       exceptioncode        uint32
-       exceptionflags       uint32
-       exceptionrecord      *exceptionrecord
-       exceptionaddress     *byte
-       numberparameters     uint32
-       exceptioninformation [15]uint32
-}
+const _CONTEXT_CONTROL = 0x10001
 
 type floatingsavearea struct {
        controlword   uint32
@@ -130,20 +71,3 @@ func dumpregs(r *context) {
        print("fs      ", hex(r.segfs), "\n")
        print("gs      ", hex(r.seggs), "\n")
 }
-
-type overlapped struct {
-       internal     uint32
-       internalhigh uint32
-       anon0        [8]byte
-       hevent       *byte
-}
-
-type memoryBasicInformation struct {
-       baseAddress       uintptr
-       allocationBase    uintptr
-       allocationProtect uint32
-       regionSize        uintptr
-       state             uint32
-       protect           uint32
-       type_             uint32
-}

diff --git a/src/runtime/defs_windows_amd64.go b/src/runtime/defs_windows_amd64.go
index ebb1506e2f50cb29e726fc16e4638ceb280e9df3..ac636a68ecc57ee81d6b575df8124eb6b7e995e6 100644 (file)
--- a/src/runtime/defs_windows_amd64.go
+++ b/src/runtime/defs_windows_amd64.go
@@ -1,70 +1,10 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_windows.go
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
 
 package runtime
 
-const (
-       _PROT_NONE  = 0
-       _PROT_READ  = 1
-       _PROT_WRITE = 2
-       _PROT_EXEC  = 4
-
-       _MAP_ANON    = 1
-       _MAP_PRIVATE = 2
-
-       _DUPLICATE_SAME_ACCESS   = 0x2
-       _THREAD_PRIORITY_HIGHEST = 0x2
-
-       _SIGINT              = 0x2
-       _SIGTERM             = 0xF
-       _CTRL_C_EVENT        = 0x0
-       _CTRL_BREAK_EVENT    = 0x1
-       _CTRL_CLOSE_EVENT    = 0x2
-       _CTRL_LOGOFF_EVENT   = 0x5
-       _CTRL_SHUTDOWN_EVENT = 0x6
-
-       _CONTEXT_CONTROL = 0x100001
-       _CONTEXT_FULL    = 0x10000b
-
-       _EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-       _EXCEPTION_BREAKPOINT           = 0x80000003
-       _EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-       _EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-       _EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-       _EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-       _EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-       _EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-       _EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-       _INFINITE     = 0xffffffff
-       _WAIT_TIMEOUT = 0x102
-
-       _EXCEPTION_CONTINUE_EXECUTION = -0x1
-       _EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-       anon0                       [4]byte
-       dwpagesize                  uint32
-       lpminimumapplicationaddress *byte
-       lpmaximumapplicationaddress *byte
-       dwactiveprocessormask       uint64
-       dwnumberofprocessors        uint32
-       dwprocessortype             uint32
-       dwallocationgranularity     uint32
-       wprocessorlevel             uint16
-       wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-       exceptioncode        uint32
-       exceptionflags       uint32
-       exceptionrecord      *exceptionrecord
-       exceptionaddress     *byte
-       numberparameters     uint32
-       pad_cgo_0            [4]byte
-       exceptioninformation [15]uint64
-}
+const _CONTEXT_CONTROL = 0x100001
 
 type m128a struct {
        low  uint64
@@ -123,7 +63,7 @@ type context struct {
 func (c *context) ip() uintptr { return uintptr(c.rip) }
 func (c *context) sp() uintptr { return uintptr(c.rsp) }
 
-// Amd64 does not have link register, so this returns 0.
+// AMD64 does not have link register, so this returns 0.
 func (c *context) lr() uintptr      { return 0 }
 func (c *context) set_lr(x uintptr) {}
 
@@ -152,20 +92,3 @@ func dumpregs(r *context) {
        print("fs      ", hex(r.segfs), "\n")
        print("gs      ", hex(r.seggs), "\n")
 }
-
-type overlapped struct {
-       internal     uint64
-       internalhigh uint64
-       anon0        [8]byte
-       hevent       *byte
-}
-
-type memoryBasicInformation struct {
-       baseAddress       uintptr
-       allocationBase    uintptr
-       allocationProtect uint32
-       regionSize        uintptr
-       state             uint32
-       protect           uint32
-       type_             uint32
-}

diff --git a/src/runtime/defs_windows_arm.go b/src/runtime/defs_windows_arm.go
index b275b0572a7e762f277f5bac35922ec57116bcce..370470e35d94fb9846b659d9fd093b79dbd1e071 100644 (file)
--- a/src/runtime/defs_windows_arm.go
+++ b/src/runtime/defs_windows_arm.go
@@ -4,67 +4,13 @@
 
 package runtime
 
-const (
-       _PROT_NONE  = 0
-       _PROT_READ  = 1
-       _PROT_WRITE = 2
-       _PROT_EXEC  = 4
-
-       _MAP_ANON    = 1
-       _MAP_PRIVATE = 2
-
-       _DUPLICATE_SAME_ACCESS   = 0x2
-       _THREAD_PRIORITY_HIGHEST = 0x2
-
-       _SIGINT              = 0x2
-       _SIGTERM             = 0xF
-       _CTRL_C_EVENT        = 0x0
-       _CTRL_BREAK_EVENT    = 0x1
-       _CTRL_CLOSE_EVENT    = 0x2
-       _CTRL_LOGOFF_EVENT   = 0x5
-       _CTRL_SHUTDOWN_EVENT = 0x6
-
-       _CONTEXT_CONTROL = 0x10001
-       _CONTEXT_FULL    = 0x10007
-
-       _EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-       _EXCEPTION_BREAKPOINT           = 0x80000003
-       _EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-       _EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-       _EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-       _EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-       _EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-       _EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-       _EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-       _INFINITE     = 0xffffffff
-       _WAIT_TIMEOUT = 0x102
-
-       _EXCEPTION_CONTINUE_EXECUTION = -0x1
-       _EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-       anon0                       [4]byte
-       dwpagesize                  uint32
-       lpminimumapplicationaddress *byte
-       lpmaximumapplicationaddress *byte
-       dwactiveprocessormask       uint32
-       dwnumberofprocessors        uint32
-       dwprocessortype             uint32
-       dwallocationgranularity     uint32
-       wprocessorlevel             uint16
-       wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-       exceptioncode        uint32
-       exceptionflags       uint32
-       exceptionrecord      *exceptionrecord
-       exceptionaddress     *byte
-       numberparameters     uint32
-       exceptioninformation [15]uint32
-}
+// NOTE(rsc): _CONTEXT_CONTROL is actually 0x200001 and should include PC, SP, and LR.
+// However, empirically, LR doesn't come along on Windows 10
+// unless you also set _CONTEXT_INTEGER (0x200002).
+// Without LR, we skip over the next-to-bottom function in profiles
+// when the bottom function is frameless.
+// So we set both here, to make a working _CONTEXT_CONTROL.
+const _CONTEXT_CONTROL = 0x200003
 
 type neon128 struct {
        low  uint64
@@ -132,23 +78,6 @@ func dumpregs(r *context) {
        print("cpsr ", hex(r.cpsr), "\n")
 }
 
-type overlapped struct {
-       internal     uint32
-       internalhigh uint32
-       anon0        [8]byte
-       hevent       *byte
-}
-
-type memoryBasicInformation struct {
-       baseAddress       uintptr
-       allocationBase    uintptr
-       allocationProtect uint32
-       regionSize        uintptr
-       state             uint32
-       protect           uint32
-       type_             uint32
-}
-
 func stackcheck() {
        // TODO: not implemented on ARM
 }

diff --git a/src/runtime/defs_windows_arm64.go b/src/runtime/defs_windows_arm64.go
new file mode 100644 (file)
index 0000000..9ccce46
--- /dev/null
+++ b/src/runtime/defs_windows_arm64.go
@@ -0,0 +1,83 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+// NOTE(rsc): _CONTEXT_CONTROL is actually 0x400001 and should include PC, SP, and LR.
+// However, empirically, LR doesn't come along on Windows 10
+// unless you also set _CONTEXT_INTEGER (0x400002).
+// Without LR, we skip over the next-to-bottom function in profiles
+// when the bottom function is frameless.
+// So we set both here, to make a working _CONTEXT_CONTROL.
+const _CONTEXT_CONTROL = 0x400003
+
+type neon128 struct {
+       low  uint64
+       high int64
+}
+
+// See https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-arm64_nt_context
+type context struct {
+       contextflags uint32
+       cpsr         uint32
+       x            [31]uint64 // fp is x[29], lr is x[30]
+       xsp          uint64
+       pc           uint64
+       v            [32]neon128
+       fpcr         uint32
+       fpsr         uint32
+       bcr          [8]uint32
+       bvr          [8]uint64
+       wcr          [2]uint32
+       wvr          [2]uint64
+}
+
+func (c *context) ip() uintptr { return uintptr(c.pc) }
+func (c *context) sp() uintptr { return uintptr(c.xsp) }
+func (c *context) lr() uintptr { return uintptr(c.x[30]) }
+
+func (c *context) set_ip(x uintptr) { c.pc = uint64(x) }
+func (c *context) set_sp(x uintptr) { c.xsp = uint64(x) }
+func (c *context) set_lr(x uintptr) { c.x[30] = uint64(x) }
+
+func dumpregs(r *context) {
+       print("r0   ", hex(r.x[0]), "\n")
+       print("r1   ", hex(r.x[1]), "\n")
+       print("r2   ", hex(r.x[2]), "\n")
+       print("r3   ", hex(r.x[3]), "\n")
+       print("r4   ", hex(r.x[4]), "\n")
+       print("r5   ", hex(r.x[5]), "\n")
+       print("r6   ", hex(r.x[6]), "\n")
+       print("r7   ", hex(r.x[7]), "\n")
+       print("r8   ", hex(r.x[8]), "\n")
+       print("r9   ", hex(r.x[9]), "\n")
+       print("r10  ", hex(r.x[10]), "\n")
+       print("r11  ", hex(r.x[11]), "\n")
+       print("r12  ", hex(r.x[12]), "\n")
+       print("r13  ", hex(r.x[13]), "\n")
+       print("r14  ", hex(r.x[14]), "\n")
+       print("r15  ", hex(r.x[15]), "\n")
+       print("r16  ", hex(r.x[16]), "\n")
+       print("r17  ", hex(r.x[17]), "\n")
+       print("r18  ", hex(r.x[18]), "\n")
+       print("r19  ", hex(r.x[19]), "\n")
+       print("r20  ", hex(r.x[20]), "\n")
+       print("r21  ", hex(r.x[21]), "\n")
+       print("r22  ", hex(r.x[22]), "\n")
+       print("r23  ", hex(r.x[23]), "\n")
+       print("r24  ", hex(r.x[24]), "\n")
+       print("r25  ", hex(r.x[25]), "\n")
+       print("r26  ", hex(r.x[26]), "\n")
+       print("r27  ", hex(r.x[27]), "\n")
+       print("r28  ", hex(r.x[28]), "\n")
+       print("r29  ", hex(r.x[29]), "\n")
+       print("lr   ", hex(r.x[30]), "\n")
+       print("sp   ", hex(r.xsp), "\n")
+       print("pc   ", hex(r.pc), "\n")
+       print("cpsr ", hex(r.cpsr), "\n")
+}
+
+func stackcheck() {
+       // TODO: not implemented on ARM
+}

diff --git a/src/runtime/duff_amd64.s b/src/runtime/duff_amd64.s
index 2ff5bf6dbcd66cfa51d8c0d0ca6bf32dcdcc9c03..df010f58533be30ae2ad5ae99c2ce55af283611b 100644 (file)
--- a/src/runtime/duff_amd64.s
+++ b/src/runtime/duff_amd64.s
@@ -5,100 +5,100 @@
 #include "textflag.h"
 
 TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT, $0-0
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
-       MOVUPS  X0,(DI)
-       MOVUPS  X0,16(DI)
-       MOVUPS  X0,32(DI)
-       MOVUPS  X0,48(DI)
+       MOVUPS  X15,(DI)
+       MOVUPS  X15,16(DI)
+       MOVUPS  X15,32(DI)
+       MOVUPS  X15,48(DI)
        LEAQ    64(DI),DI
 
        RET

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 44551dcaf141ef859383313c6c3c64081b26fdb8..a48bb2636f7dd51aa2088e02bfff1ed7d179a4cd 100644 (file)
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -200,8 +200,6 @@ func GostringW(w []uint16) (s string) {
        return
 }
 
-type Uintreg sys.Uintreg
-
 var Open = open
 var Close = closefd
 var Read = read
@@ -1201,12 +1199,12 @@ type TimeHistogram timeHistogram
 
 // Counts returns the counts for the given bucket, subBucket indices.
 // Returns true if the bucket was valid, otherwise returns the counts
-// for the overflow bucket and false.
+// for the underflow bucket and false.
 func (th *TimeHistogram) Count(bucket, subBucket uint) (uint64, bool) {
        t := (*timeHistogram)(th)
        i := bucket*TimeHistNumSubBuckets + subBucket
        if i >= uint(len(t.counts)) {
-               return t.overflow, false
+               return t.underflow, false
        }
        return t.counts[i], true
 }

diff --git a/src/runtime/extern.go b/src/runtime/extern.go
index dacdf4f38308da4de04b780c5993bf66209c75ff..bbe41dd0d430a4e59894244496c9392aef2d9222 100644 (file)
--- a/src/runtime/extern.go
+++ b/src/runtime/extern.go
@@ -229,6 +229,8 @@ func Callers(skip int, pc []uintptr) int {
        return callers(skip, pc)
 }
 
+var defaultGOROOT string // set by cmd/link
+
 // GOROOT returns the root of the Go tree. It uses the
 // GOROOT environment variable, if set at process start,
 // or else the root used during the Go build.
@@ -237,7 +239,7 @@ func GOROOT() string {
        if s != "" {
                return s
        }
-       return sys.DefaultGoroot
+       return defaultGOROOT
 }
 
 // Version returns the Go tree's version string.

diff --git a/src/runtime/histogram.go b/src/runtime/histogram.go
index 4020969eb993a590a121d475b6cb66b285f06fb9..da4910d341cbcf861059f292eb4576a8e762e75a 100644 (file)
--- a/src/runtime/histogram.go
+++ b/src/runtime/histogram.go
@@ -7,6 +7,7 @@ package runtime
 import (
        "runtime/internal/atomic"
        "runtime/internal/sys"
+       "unsafe"
 )
 
 const (
@@ -25,7 +26,7 @@ const (
        // The number of super-buckets (timeHistNumSuperBuckets), on the
        // other hand, defines the range. To reserve room for sub-buckets,
        // bit timeHistSubBucketBits is the first bit considered for
-       // super-buckets, so super-bucket indicies are adjusted accordingly.
+       // super-buckets, so super-bucket indices are adjusted accordingly.
        //
        // As an example, consider 45 super-buckets with 16 sub-buckets.
        //
@@ -69,17 +70,21 @@ const (
 // for concurrent use. It is also safe to read all the values
 // atomically.
 type timeHistogram struct {
-       counts   [timeHistNumSuperBuckets * timeHistNumSubBuckets]uint64
-       overflow uint64
+       counts [timeHistNumSuperBuckets * timeHistNumSubBuckets]uint64
+
+       // underflow counts all the times we got a negative duration
+       // sample. Because of how time works on some platforms, it's
+       // possible to measure negative durations. We could ignore them,
+       // but we record them anyway because it's better to have some
+       // signal that it's happening than just missing samples.
+       underflow uint64
 }
 
 // record adds the given duration to the distribution.
-//
-// Although the duration is an int64 to facilitate ease-of-use
-// with e.g. nanotime, the duration must be non-negative.
 func (h *timeHistogram) record(duration int64) {
        if duration < 0 {
-               throw("timeHistogram encountered negative duration")
+               atomic.Xadd64(&h.underflow, 1)
+               return
        }
        // The index of the exponential bucket is just the index
        // of the highest set bit adjusted for how many bits we
@@ -92,29 +97,47 @@ func (h *timeHistogram) record(duration int64) {
                superBucket = uint(sys.Len64(uint64(duration))) - timeHistSubBucketBits
                if superBucket*timeHistNumSubBuckets >= uint(len(h.counts)) {
                        // The bucket index we got is larger than what we support, so
-                       // add into the special overflow bucket.
-                       atomic.Xadd64(&h.overflow, 1)
-                       return
+                       // include this count in the highest bucket, which extends to
+                       // infinity.
+                       superBucket = timeHistNumSuperBuckets - 1
+                       subBucket = timeHistNumSubBuckets - 1
+               } else {
+                       // The linear subbucket index is just the timeHistSubBucketsBits
+                       // bits after the top bit. To extract that value, shift down
+                       // the duration such that we leave the top bit and the next bits
+                       // intact, then extract the index.
+                       subBucket = uint((duration >> (superBucket - 1)) % timeHistNumSubBuckets)
                }
-               // The linear subbucket index is just the timeHistSubBucketsBits
-               // bits after the top bit. To extract that value, shift down
-               // the duration such that we leave the top bit and the next bits
-               // intact, then extract the index.
-               subBucket = uint((duration >> (superBucket - 1)) % timeHistNumSubBuckets)
        } else {
                subBucket = uint(duration)
        }
        atomic.Xadd64(&h.counts[superBucket*timeHistNumSubBuckets+subBucket], 1)
 }
 
+const (
+       fInf    = 0x7FF0000000000000
+       fNegInf = 0xFFF0000000000000
+)
+
+func float64Inf() float64 {
+       inf := uint64(fInf)
+       return *(*float64)(unsafe.Pointer(&inf))
+}
+
+func float64NegInf() float64 {
+       inf := uint64(fNegInf)
+       return *(*float64)(unsafe.Pointer(&inf))
+}
+
 // timeHistogramMetricsBuckets generates a slice of boundaries for
 // the timeHistogram. These boundaries are represented in seconds,
 // not nanoseconds like the timeHistogram represents durations.
 func timeHistogramMetricsBuckets() []float64 {
-       b := make([]float64, timeHistTotalBuckets-1)
+       b := make([]float64, timeHistTotalBuckets+1)
+       b[0] = float64NegInf()
        for i := 0; i < timeHistNumSuperBuckets; i++ {
                superBucketMin := uint64(0)
-               // The (inclusive) minimum for the first bucket is 0.
+               // The (inclusive) minimum for the first non-negative bucket is 0.
                if i > 0 {
                        // The minimum for the second bucket will be
                        // 1 << timeHistSubBucketBits, indicating that all
@@ -128,7 +151,7 @@ func timeHistogramMetricsBuckets() []float64 {
                // index to combine it with the bucketMin.
                subBucketShift := uint(0)
                if i > 1 {
-                       // The first two buckets are exact with respect to integers,
+                       // The first two super buckets are exact with respect to integers,
                        // so we'll never have to shift the sub-bucket index. Thereafter,
                        // we shift up by 1 with each subsequent bucket.
                        subBucketShift = uint(i - 2)
@@ -141,8 +164,9 @@ func timeHistogramMetricsBuckets() []float64 {
 
                        // Convert the subBucketMin which is in nanoseconds to a float64 seconds value.
                        // These values will all be exactly representable by a float64.
-                       b[i*timeHistNumSubBuckets+j] = float64(subBucketMin) / 1e9
+                       b[i*timeHistNumSubBuckets+j+1] = float64(subBucketMin) / 1e9
                }
        }
+       b[len(b)-1] = float64Inf()
        return b
 }

diff --git a/src/runtime/histogram_test.go b/src/runtime/histogram_test.go
index 5f5b28f7848d3f1b1b353f444345f94b1ee9029e..dbc64fa5592407bc728a5f0c1d70d30048e2b0b6 100644 (file)
--- a/src/runtime/histogram_test.go
+++ b/src/runtime/histogram_test.go
@@ -5,6 +5,7 @@
 package runtime_test
 
 import (
+       "math"
        . "runtime"
        "testing"
 )
@@ -32,8 +33,8 @@ func TestTimeHistogram(t *testing.T) {
                        h.Record(base + v)
                }
        }
-       // Hit the overflow bucket.
-       h.Record(int64(^uint64(0) >> 1))
+       // Hit the underflow bucket.
+       h.Record(int64(-1))
 
        // Check to make sure there's exactly one count in each
        // bucket.
@@ -41,7 +42,7 @@ func TestTimeHistogram(t *testing.T) {
                for j := uint(0); j < TimeHistNumSubBuckets; j++ {
                        c, ok := h.Count(i, j)
                        if !ok {
-                               t.Errorf("hit overflow bucket unexpectedly: (%d, %d)", i, j)
+                               t.Errorf("hit underflow bucket unexpectedly: (%d, %d)", i, j)
                        } else if c != 1 {
                                t.Errorf("bucket (%d, %d) has count that is not 1: %d", i, j, c)
                        }
@@ -49,10 +50,21 @@ func TestTimeHistogram(t *testing.T) {
        }
        c, ok := h.Count(TimeHistNumSuperBuckets, 0)
        if ok {
-               t.Errorf("expected to hit overflow bucket: (%d, %d)", TimeHistNumSuperBuckets, 0)
+               t.Errorf("expected to hit underflow bucket: (%d, %d)", TimeHistNumSuperBuckets, 0)
        }
        if c != 1 {
-               t.Errorf("overflow bucket has count that is not 1: %d", c)
+               t.Errorf("underflow bucket has count that is not 1: %d", c)
        }
+
+       // Check overflow behavior.
+       // By hitting a high value, we should just be adding into the highest bucket.
+       h.Record(math.MaxInt64)
+       c, ok = h.Count(TimeHistNumSuperBuckets-1, TimeHistNumSubBuckets-1)
+       if !ok {
+               t.Error("hit underflow bucket in highest bucket unexpectedly")
+       } else if c != 2 {
+               t.Errorf("highest has count that is not 2: %d", c)
+       }
+
        dummyTimeHistogram = TimeHistogram{}
 }

diff --git a/src/runtime/internal/sys/arch.go b/src/runtime/internal/sys/arch.go
index 13c00cf6392ff50155531ddbeb1660e960f996a8..3c99a2f7da0831048e2aa5ae24cb8914e5d83785 100644 (file)
--- a/src/runtime/internal/sys/arch.go
+++ b/src/runtime/internal/sys/arch.go
@@ -18,3 +18,37 @@ const (
        S390X
        WASM
 )
+
+// PtrSize is the size of a pointer in bytes - unsafe.Sizeof(uintptr(0)) but as an ideal constant.
+// It is also the size of the machine's native word size (that is, 4 on 32-bit systems, 8 on 64-bit).
+const PtrSize = 4 << (^uintptr(0) >> 63)
+
+// AIX requires a larger stack for syscalls.
+const StackGuardMultiplier = StackGuardMultiplierDefault*(1-GoosAix) + 2*GoosAix
+
+// ArchFamily is the architecture family (AMD64, ARM, ...)
+const ArchFamily ArchFamilyType = _ArchFamily
+
+// BigEndian reports whether the architecture is big-endian.
+const BigEndian = GoarchArmbe|GoarchArm64be|GoarchMips|GoarchMips64|GoarchPpc|GoarchPpc64|GoarchS390|GoarchS390x|GoarchSparc|GoarchSparc64 == 1
+
+// DefaultPhysPageSize is the default physical page size.
+const DefaultPhysPageSize = _DefaultPhysPageSize
+
+// PCQuantum is the minimal unit for a program counter (1 on x86, 4 on most other systems).
+// The various PC tables record PC deltas pre-divided by PCQuantum.
+const PCQuantum = _PCQuantum
+
+// Int64Align is the required alignment for a 64-bit integer (4 on 32-bit systems, 8 on 64-bit).
+const Int64Align = PtrSize
+
+// MinFrameSize is the size of the system-reserved words at the bottom
+// of a frame (just above the architectural stack pointer).
+// It is zero on x86 and PtrSize on most non-x86 (LR-based) systems.
+// On PowerPC it is larger, to cover three more reserved words:
+// the compiler word, the link editor word, and the TOC save word.
+const MinFrameSize = _MinFrameSize
+
+// StackAlign is the required alignment of the SP register.
+// The stack must be at least word aligned, but some architectures require more.
+const StackAlign = _StackAlign

diff --git a/src/runtime/internal/sys/arch_386.go b/src/runtime/internal/sys/arch_386.go
index b51f70a512f885a3efe70a91113bc474630cd09c..1ebce3435e4be374308d59601ab52d4d572d5eb1 100644 (file)
--- a/src/runtime/internal/sys/arch_386.go
+++ b/src/runtime/internal/sys/arch_386.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = I386
-       BigEndian           = false
-       DefaultPhysPageSize = 4096
-       PCQuantum           = 1
-       Int64Align          = 4
-       MinFrameSize        = 0
+       _ArchFamily          = I386
+       _DefaultPhysPageSize = 4096
+       _PCQuantum           = 1
+       _MinFrameSize        = 0
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint32

diff --git a/src/runtime/internal/sys/arch_amd64.go b/src/runtime/internal/sys/arch_amd64.go
index 3d6776e71eea54654553c99b4794e3177c804abb..7f003d0f1d503431452dca3003f47c6c1d080621 100644 (file)
--- a/src/runtime/internal/sys/arch_amd64.go
+++ b/src/runtime/internal/sys/arch_amd64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = AMD64
-       BigEndian           = false
-       DefaultPhysPageSize = 4096
-       PCQuantum           = 1
-       Int64Align          = 8
-       MinFrameSize        = 0
+       _ArchFamily          = AMD64
+       _DefaultPhysPageSize = 4096
+       _PCQuantum           = 1
+       _MinFrameSize        = 0
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_arm.go b/src/runtime/internal/sys/arch_arm.go
index 97960d6f83181272442185ee4a58883cb64e3549..ef2048bb71a5dd837c2c6e03ccb312ade0baf48f 100644 (file)
--- a/src/runtime/internal/sys/arch_arm.go
+++ b/src/runtime/internal/sys/arch_arm.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = ARM
-       BigEndian           = false
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 4
-       MinFrameSize        = 4
+       _ArchFamily          = ARM
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 4
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint32

diff --git a/src/runtime/internal/sys/arch_arm64.go b/src/runtime/internal/sys/arch_arm64.go
index 911a9485e1d675062b929d1b852dcc5f628536af..b9f2f7b1fe226abd96e5907e34b04be368fa6ea3 100644 (file)
--- a/src/runtime/internal/sys/arch_arm64.go
+++ b/src/runtime/internal/sys/arch_arm64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = ARM64
-       BigEndian           = false
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 8
-       MinFrameSize        = 8
+       _ArchFamily          = ARM64
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 8
+       _StackAlign          = 16
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_mips.go b/src/runtime/internal/sys/arch_mips.go
index 75cdb2e07fdd2b7e9fa8e799490543c68389e9ac..4cb0eebea7bb5c0fbaafe59ff2b9bfe8a7448e2a 100644 (file)
--- a/src/runtime/internal/sys/arch_mips.go
+++ b/src/runtime/internal/sys/arch_mips.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = MIPS
-       BigEndian           = true
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 4
-       MinFrameSize        = 4
+       _ArchFamily          = MIPS
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 4
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint32

diff --git a/src/runtime/internal/sys/arch_mips64.go b/src/runtime/internal/sys/arch_mips64.go
index 494291a802c2b4385eabc84fb475fd1168016800..57636ac4a4e0ebe933066ca9a6fb1722e12436a5 100644 (file)
--- a/src/runtime/internal/sys/arch_mips64.go
+++ b/src/runtime/internal/sys/arch_mips64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = MIPS64
-       BigEndian           = true
-       DefaultPhysPageSize = 16384
-       PCQuantum           = 4
-       Int64Align          = 8
-       MinFrameSize        = 8
+       _ArchFamily          = MIPS64
+       _DefaultPhysPageSize = 16384
+       _PCQuantum           = 4
+       _MinFrameSize        = 8
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_mips64le.go b/src/runtime/internal/sys/arch_mips64le.go
index d36d1202f690eb15cf5696e52599b079f95b6bce..57636ac4a4e0ebe933066ca9a6fb1722e12436a5 100644 (file)
--- a/src/runtime/internal/sys/arch_mips64le.go
+++ b/src/runtime/internal/sys/arch_mips64le.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = MIPS64
-       BigEndian           = false
-       DefaultPhysPageSize = 16384
-       PCQuantum           = 4
-       Int64Align          = 8
-       MinFrameSize        = 8
+       _ArchFamily          = MIPS64
+       _DefaultPhysPageSize = 16384
+       _PCQuantum           = 4
+       _MinFrameSize        = 8
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_mipsle.go b/src/runtime/internal/sys/arch_mipsle.go
index 323bf820591b1b3721212f3d4dcebc91bd4df923..4240f5ce47bb7f8abfaffc75f2f3c5ffed838aa1 100644 (file)
--- a/src/runtime/internal/sys/arch_mipsle.go
+++ b/src/runtime/internal/sys/arch_mipsle.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = MIPS
-       BigEndian           = false
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 4
-       MinFrameSize        = 4
+       _ArchFamily          = MIPS
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 4
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint32

diff --git a/src/runtime/internal/sys/arch_ppc64.go b/src/runtime/internal/sys/arch_ppc64.go
index da1fe3d596c8b982c36a492c9d4ab88808c88c90..1869213ce241ee5f6da403b2714652756dc956dc 100644 (file)
--- a/src/runtime/internal/sys/arch_ppc64.go
+++ b/src/runtime/internal/sys/arch_ppc64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = PPC64
-       BigEndian           = true
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 8
-       MinFrameSize        = 32
+       _ArchFamily          = PPC64
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 32
+       _StackAlign          = 16
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_ppc64le.go b/src/runtime/internal/sys/arch_ppc64le.go
index 605979903a87d4ad18f5e86997947a9e7e3a19d2..1869213ce241ee5f6da403b2714652756dc956dc 100644 (file)
--- a/src/runtime/internal/sys/arch_ppc64le.go
+++ b/src/runtime/internal/sys/arch_ppc64le.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = PPC64
-       BigEndian           = false
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 4
-       Int64Align          = 8
-       MinFrameSize        = 32
+       _ArchFamily          = PPC64
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 4
+       _MinFrameSize        = 32
+       _StackAlign          = 16
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_riscv64.go b/src/runtime/internal/sys/arch_riscv64.go
index 7cdcc8fcbd32068c820fbdaa6a2d372be5a4ec8d..360d236e32072ac431f19ed75095b406cb6b4beb 100644 (file)
--- a/src/runtime/internal/sys/arch_riscv64.go
+++ b/src/runtime/internal/sys/arch_riscv64.go
@@ -5,14 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = RISCV64
-       BigEndian           = false
-       CacheLineSize       = 64
-       DefaultPhysPageSize = 4096
-       PCQuantum           = 4
-       Int64Align          = 8
-       HugePageSize        = 1 << 21
-       MinFrameSize        = 8
+       _ArchFamily          = RISCV64
+       _DefaultPhysPageSize = 4096
+       _PCQuantum           = 4
+       _MinFrameSize        = 8
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_s390x.go b/src/runtime/internal/sys/arch_s390x.go
index 12cb8a0fcbaad64da9d561561970b47928730b6c..e33e0b7f2b890b416ac5e70c2cbdcff6a5ad2eb5 100644 (file)
--- a/src/runtime/internal/sys/arch_s390x.go
+++ b/src/runtime/internal/sys/arch_s390x.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = S390X
-       BigEndian           = true
-       DefaultPhysPageSize = 4096
-       PCQuantum           = 2
-       Int64Align          = 8
-       MinFrameSize        = 8
+       _ArchFamily          = S390X
+       _DefaultPhysPageSize = 4096
+       _PCQuantum           = 2
+       _MinFrameSize        = 8
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/arch_wasm.go b/src/runtime/internal/sys/arch_wasm.go
index eb825df62622ec9f2aa93da6f09bb1235d779bc7..ee919ff9e634996eeb54bd40e7a9c73e0509a5ec 100644 (file)
--- a/src/runtime/internal/sys/arch_wasm.go
+++ b/src/runtime/internal/sys/arch_wasm.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-       ArchFamily          = WASM
-       BigEndian           = false
-       DefaultPhysPageSize = 65536
-       PCQuantum           = 1
-       Int64Align          = 8
-       MinFrameSize        = 0
+       _ArchFamily          = WASM
+       _DefaultPhysPageSize = 65536
+       _PCQuantum           = 1
+       _MinFrameSize        = 0
+       _StackAlign          = PtrSize
 )
-
-type Uintreg uint64

diff --git a/src/runtime/internal/sys/stubs.go b/src/runtime/internal/sys/stubs.go
deleted file mode 100644 (file)
index 10b0173..0000000
--- a/src/runtime/internal/sys/stubs.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package sys
-
-// Declarations for runtime services implemented in C or assembly.
-
-const PtrSize = 4 << (^uintptr(0) >> 63)           // unsafe.Sizeof(uintptr(0)) but an ideal const
-const RegSize = 4 << (^Uintreg(0) >> 63)           // unsafe.Sizeof(uintreg(0)) but an ideal const
-const SpAlign = 1*(1-GoarchArm64) + 16*GoarchArm64 // SP alignment: 1 normally, 16 for ARM64
-
-var DefaultGoroot string // set at link time
-
-// AIX requires a larger stack for syscalls.
-const StackGuardMultiplier = StackGuardMultiplierDefault*(1-GoosAix) + 2*GoosAix

diff --git a/src/runtime/mbarrier.go b/src/runtime/mbarrier.go
index 2b5affce5219a540bba2cc85c893f84817344c86..4994347bdeb35610d1f45efb714b233004835105 100644 (file)
--- a/src/runtime/mbarrier.go
+++ b/src/runtime/mbarrier.go
@@ -14,6 +14,7 @@
 package runtime
 
 import (
+       "internal/abi"
        "runtime/internal/sys"
        "unsafe"
 )
@@ -223,11 +224,18 @@ func reflect_typedmemmovepartial(typ *_type, dst, src unsafe.Pointer, off, size
 // stack map of reflectcall is wrong.
 //
 //go:nosplit
-func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr) {
+func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
        if writeBarrier.needed && typ != nil && typ.ptrdata != 0 && size >= sys.PtrSize {
                bulkBarrierPreWrite(uintptr(dst), uintptr(src), size)
        }
        memmove(dst, src, size)
+
+       // Move pointers returned in registers to a place where the GC can see them.
+       for i := range regs.Ints {
+               if regs.ReturnIsPtr.Get(i) {
+                       regs.Ptrs[i] = unsafe.Pointer(regs.Ints[i])
+               }
+       }
 }
 
 //go:nosplit

diff --git a/src/runtime/memclr_386.s b/src/runtime/memclr_386.s
index 65f7196312cec0fa6d3aa758f2b61b573013b2a0..5e090ef09ebf2b8f6a6fba8efe1045943e96bb49 100644 (file)
--- a/src/runtime/memclr_386.s
+++ b/src/runtime/memclr_386.s
@@ -9,6 +9,8 @@
 
 // NOTE: Windows externalthreadhandler expects memclr to preserve DX.
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-8
        MOVL    ptr+0(FP), DI

diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s
index d79078fd00bf5f389837603ad1c40fda72b20c18..37fe9745b1be082d4c0380899ed2bc1cc0009cb9 100644 (file)
--- a/src/runtime/memclr_amd64.s
+++ b/src/runtime/memclr_amd64.s
@@ -9,6 +9,8 @@
 
 // NOTE: Windows externalthreadhandler expects memclr to preserve DX.
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-16
        MOVQ    ptr+0(FP), DI

diff --git a/src/runtime/memclr_arm.s b/src/runtime/memclr_arm.s
index 7326b8be34066ad7bce04d8973e724c366b909a0..f02d058ead8b157625464ca2726eeb08c89f8b77 100644 (file)
--- a/src/runtime/memclr_arm.s
+++ b/src/runtime/memclr_arm.s
@@ -30,7 +30,10 @@
 #define N      R12
 #define TMP    R12                             /* N and TMP don't overlap */
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+// Also called from assembly in sys_windows_arm.s without g (but using Go stack convention).
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-8
        MOVW    ptr+0(FP), TO
        MOVW    n+4(FP), N

diff --git a/src/runtime/memclr_arm64.s b/src/runtime/memclr_arm64.s
index a56a6dfb85df8099e3c80bbb457cfce239f330a6..c1a0dcef584fa1c03eba2f71fa99b1066b91dd69 100644 (file)
--- a/src/runtime/memclr_arm64.s
+++ b/src/runtime/memclr_arm64.s
@@ -4,7 +4,10 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+// Also called from assembly in sys_windows_arm64.s without g (but using Go stack convention).
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-16
        MOVD    ptr+0(FP), R0
        MOVD    n+8(FP), R1

diff --git a/src/runtime/memclr_mips64x.s b/src/runtime/memclr_mips64x.s
index 4c2292eae8520e4ae782121a586f488f1e92b93d..d7a3251e2046abf15ac9e487dfa6884ef4e714ac 100644 (file)
--- a/src/runtime/memclr_mips64x.s
+++ b/src/runtime/memclr_mips64x.s
@@ -7,6 +7,8 @@
 #include "go_asm.h"
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-16
        MOVV    ptr+0(FP), R1

diff --git a/src/runtime/memclr_mipsx.s b/src/runtime/memclr_mipsx.s
index 1561a23dbe297171a8c4aded6eceb71e4e5636e9..eb2a8a7219c6bbf0bc39064e5beef20cc0306573 100644 (file)
--- a/src/runtime/memclr_mipsx.s
+++ b/src/runtime/memclr_mipsx.s
@@ -14,6 +14,8 @@
 #define MOVWLO  MOVWL
 #endif
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-8
        MOVW    n+4(FP), R2

diff --git a/src/runtime/memclr_plan9_386.s b/src/runtime/memclr_plan9_386.s
index 5b880ae86f81b43206c55c51ed06a7399be316ae..54701a94536e5493cb9005dcfb82a2823a627b95 100644 (file)
--- a/src/runtime/memclr_plan9_386.s
+++ b/src/runtime/memclr_plan9_386.s
@@ -4,6 +4,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-8
        MOVL    ptr+0(FP), DI

diff --git a/src/runtime/memclr_plan9_amd64.s b/src/runtime/memclr_plan9_amd64.s
index ad383cd6b3d69c230362b9881eaf4d1cfacbf9de..8c6a1cc7809ac6a94a81c753009382e53d8842e6 100644 (file)
--- a/src/runtime/memclr_plan9_amd64.s
+++ b/src/runtime/memclr_plan9_amd64.s
@@ -4,6 +4,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-16
        MOVQ    ptr+0(FP), DI

diff --git a/src/runtime/memclr_ppc64x.s b/src/runtime/memclr_ppc64x.s
index 072963f75687dcdae62c7dd88ec8c24a966d0094..751262089425430eeec3a7208972d4c01507236f 100644 (file)
--- a/src/runtime/memclr_ppc64x.s
+++ b/src/runtime/memclr_ppc64x.s
@@ -6,6 +6,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT|NOFRAME, $0-16
        MOVD ptr+0(FP), R3

diff --git a/src/runtime/memclr_riscv64.s b/src/runtime/memclr_riscv64.s
index ba7704e805d2b536823f9a03b7c6018a6b0136a3..54ddaa4560c77635e357b9b0a14b8f7da5c211dd 100644 (file)
--- a/src/runtime/memclr_riscv64.s
+++ b/src/runtime/memclr_riscv64.s
@@ -4,6 +4,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // void runtime·memclrNoHeapPointers(void*, uintptr)
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-16
        MOV     ptr+0(FP), T1

diff --git a/src/runtime/memclr_s390x.s b/src/runtime/memclr_s390x.s
index dd14a441cc2bb77bba15bb4227d7b431ecc7ee99..fa657ef66e6b9545417223164a4d163329fc6e1a 100644 (file)
--- a/src/runtime/memclr_s390x.s
+++ b/src/runtime/memclr_s390x.s
@@ -4,6 +4,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT|NOFRAME,$0-16
        MOVD    ptr+0(FP), R4

diff --git a/src/runtime/memclr_wasm.s b/src/runtime/memclr_wasm.s
index 68ffe2f67b513079ad66c6ecf21dc70fd058e224..5a053049f8154eaabe70d92280e7ec6c1edf48d1 100644 (file)
--- a/src/runtime/memclr_wasm.s
+++ b/src/runtime/memclr_wasm.s
@@ -4,6 +4,8 @@
 
 #include "textflag.h"
 
+// See memclrNoHeapPointers Go doc for important implementation constraints.
+
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-16
        MOVD ptr+0(FP), R0

diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index d3c0341aee81fb17667d1d34ff38c37ca93330fc..3e8dbda0cadf7112269625ed65f7301e8052455e 100644 (file)
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -41,10 +41,28 @@ func initMetrics() {
        if metricsInit {
                return
        }
-       sizeClassBuckets = make([]float64, _NumSizeClasses)
-       for i := range sizeClassBuckets {
-               sizeClassBuckets[i] = float64(class_to_size[i])
+
+       sizeClassBuckets = make([]float64, _NumSizeClasses, _NumSizeClasses+1)
+       // Skip size class 0 which is a stand-in for large objects, but large
+       // objects are tracked separately (and they actually get placed in
+       // the last bucket, not the first).
+       sizeClassBuckets[0] = 1 // The smallest allocation is 1 byte in size.
+       for i := 1; i < _NumSizeClasses; i++ {
+               // Size classes have an inclusive upper-bound
+               // and exclusive lower bound (e.g. 48-byte size class is
+               // (32, 48]) whereas we want and inclusive lower-bound
+               // and exclusive upper-bound (e.g. 48-byte size class is
+               // [33, 49). We can achieve this by shifting all bucket
+               // boundaries up by 1.
+               //
+               // Also, a float64 can precisely represent integers with
+               // value up to 2^53 and size classes are relatively small
+               // (nowhere near 2^48 even) so this will give us exact
+               // boundaries.
+               sizeClassBuckets[i] = float64(class_to_size[i] + 1)
        }
+       sizeClassBuckets = append(sizeClassBuckets, float64Inf())
+
        timeHistBuckets = timeHistogramMetricsBuckets()
        metrics = map[string]metricData{
                "/gc/cycles/automatic:gc-cycles": {
@@ -68,23 +86,27 @@ func initMetrics() {
                                out.scalar = in.sysStats.gcCyclesDone
                        },
                },
-               "/gc/heap/allocs-by-size:objects": {
+               "/gc/heap/allocs-by-size:bytes": {
                        deps: makeStatDepSet(heapStatsDep),
                        compute: func(in *statAggregate, out *metricValue) {
                                hist := out.float64HistOrInit(sizeClassBuckets)
                                hist.counts[len(hist.counts)-1] = uint64(in.heapStats.largeAllocCount)
-                               for i := range hist.buckets {
-                                       hist.counts[i] = uint64(in.heapStats.smallAllocCount[i])
+                               // Cut off the first index which is ostensibly for size class 0,
+                               // but large objects are tracked separately so it's actually unused.
+                               for i, count := range in.heapStats.smallAllocCount[1:] {
+                                       hist.counts[i] = uint64(count)
                                }
                        },
                },
-               "/gc/heap/frees-by-size:objects": {
+               "/gc/heap/frees-by-size:bytes": {
                        deps: makeStatDepSet(heapStatsDep),
                        compute: func(in *statAggregate, out *metricValue) {
                                hist := out.float64HistOrInit(sizeClassBuckets)
                                hist.counts[len(hist.counts)-1] = uint64(in.heapStats.largeFreeCount)
-                               for i := range hist.buckets {
-                                       hist.counts[i] = uint64(in.heapStats.smallFreeCount[i])
+                               // Cut off the first index which is ostensibly for size class 0,
+                               // but large objects are tracked separately so it's actually unused.
+                               for i, count := range in.heapStats.smallFreeCount[1:] {
+                                       hist.counts[i] = uint64(count)
                                }
                        },
                },
@@ -105,9 +127,12 @@ func initMetrics() {
                "/gc/pauses:seconds": {
                        compute: func(_ *statAggregate, out *metricValue) {
                                hist := out.float64HistOrInit(timeHistBuckets)
-                               hist.counts[len(hist.counts)-1] = atomic.Load64(&memstats.gcPauseDist.overflow)
-                               for i := range hist.buckets {
-                                       hist.counts[i] = atomic.Load64(&memstats.gcPauseDist.counts[i])
+                               // The bottom-most bucket, containing negative values, is tracked
+                               // as a separately as underflow, so fill that in manually and then
+                               // iterate over the rest.
+                               hist.counts[0] = atomic.Load64(&memstats.gcPauseDist.underflow)
+                               for i := range memstats.gcPauseDist.counts {
+                                       hist.counts[i+1] = atomic.Load64(&memstats.gcPauseDist.counts[i])
                                }
                        },
                },
@@ -426,8 +451,8 @@ func (v *metricValue) float64HistOrInit(buckets []float64) *metricFloat64Histogr
                v.pointer = unsafe.Pointer(hist)
        }
        hist.buckets = buckets
-       if len(hist.counts) != len(hist.buckets)+1 {
-               hist.counts = make([]uint64, len(buckets)+1)
+       if len(hist.counts) != len(hist.buckets)-1 {
+               hist.counts = make([]uint64, len(buckets)-1)
        }
        return hist
 }

diff --git a/src/runtime/metrics/description.go b/src/runtime/metrics/description.go
index 32af5d172790050274995d3e731c4090bc538f80..117515610436f2a27145a79f589400d8076e14b3 100644 (file)
--- a/src/runtime/metrics/description.go
+++ b/src/runtime/metrics/description.go
@@ -23,6 +23,11 @@ type Description struct {
        // Examples of units might be "seconds", "bytes", "bytes/second", "cpu-seconds",
        // "byte*cpu-seconds", and "bytes/second/second".
        //
+       // For histograms, multiple units may apply. For instance, the units of the buckets and
+       // the count. By convention, for histograms, the units of the count are always "samples"
+       // with the type of sample evident by the metric's name, while the unit in the name
+       // specifies the buckets' unit.
+       //
        // A complete name might look like "/memory/heap/free:bytes".
        Name string
 
@@ -41,10 +46,6 @@ type Description struct {
        //
        // This flag thus indicates whether or not it's useful to compute a rate from this value.
        Cumulative bool
-
-       // StopTheWorld is whether or not the metric requires a stop-the-world
-       // event in order to collect it.
-       StopTheWorld bool
 }
 
 // The English language descriptions below must be kept in sync with the
@@ -69,14 +70,16 @@ var allDesc = []Description{
                Cumulative:  true,
        },
        {
-               Name:        "/gc/heap/allocs-by-size:objects",
+               Name:        "/gc/heap/allocs-by-size:bytes",
                Description: "Distribution of all objects allocated by approximate size.",
                Kind:        KindFloat64Histogram,
+               Cumulative:  true,
        },
        {
-               Name:        "/gc/heap/frees-by-size:objects",
+               Name:        "/gc/heap/frees-by-size:bytes",
                Description: "Distribution of all objects freed by approximate size.",
                Kind:        KindFloat64Histogram,
+               Cumulative:  true,
        },
        {
                Name:        "/gc/heap/goal:bytes",
@@ -92,6 +95,7 @@ var allDesc = []Description{
                Name:        "/gc/pauses:seconds",
                Description: "Distribution individual GC-related stop-the-world pause latencies.",
                Kind:        KindFloat64Histogram,
+               Cumulative:  true,
        },
        {
                Name: "/memory/classes/heap/free:bytes",

diff --git a/src/runtime/metrics/doc.go b/src/runtime/metrics/doc.go
index a68184ee822c01f186f71c457f686a7bb87d70ec..7f790afc12eeabcdda78f0d01a0d83003155d18a 100644 (file)
--- a/src/runtime/metrics/doc.go
+++ b/src/runtime/metrics/doc.go
@@ -16,13 +16,12 @@ Interface
 Metrics are designated by a string key, rather than, for example, a field name in
 a struct. The full list of supported metrics is always available in the slice of
 Descriptions returned by All. Each Description also includes useful information
-about the metric, such as how to display it (e.g. gauge vs. counter) and how difficult
-or disruptive it is to obtain it (e.g. do you need to stop the world?).
+about the metric.
 
 Thus, users of this API are encouraged to sample supported metrics defined by the
 slice returned by All to remain compatible across Go versions. Of course, situations
 arise where reading specific metrics is critical. For these cases, users are
-encouranged to use build tags, and although metrics may be deprecated and removed,
+encouraged to use build tags, and although metrics may be deprecated and removed,
 users should consider this to be an exceptional and rare event, coinciding with a
 very large change in a particular Go implementation.
 
@@ -61,10 +60,10 @@ Below is the full list of supported metrics, ordered lexicographically.
        /gc/cycles/total:gc-cycles
                Count of all completed GC cycles.
 
-       /gc/heap/allocs-by-size:objects
+       /gc/heap/allocs-by-size:bytes
                Distribution of all objects allocated by approximate size.
 
-       /gc/heap/frees-by-size:objects
+       /gc/heap/frees-by-size:bytes
                Distribution of all objects freed by approximate size.
 
        /gc/heap/goal:bytes

diff --git a/src/runtime/metrics/example_test.go b/src/runtime/metrics/example_test.go
new file mode 100644 (file)
index 0000000..624d9d8
--- /dev/null
+++ b/src/runtime/metrics/example_test.go
@@ -0,0 +1,96 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package metrics_test
+
+import (
+       "fmt"
+       "runtime/metrics"
+)
+
+func ExampleRead_readingOneMetric() {
+       // Name of the metric we want to read.
+       const myMetric = "/memory/classes/heap/free:bytes"
+
+       // Create a sample for the metric.
+       sample := make([]metrics.Sample, 1)
+       sample[0].Name = myMetric
+
+       // Sample the metric.
+       metrics.Read(sample)
+
+       // Check if the metric is actually supported.
+       // If it's not, the resulting value will always have
+       // kind KindBad.
+       if sample[0].Value.Kind() == metrics.KindBad {
+               panic(fmt.Sprintf("metric %q no longer supported", myMetric))
+       }
+
+       // Handle the result.
+       //
+       // It's OK to assume a particular Kind for a metric;
+       // they're guaranteed not to change.
+       freeBytes := sample[0].Value.Uint64()
+
+       fmt.Printf("free but not released memory: %d\n", freeBytes)
+}
+
+func ExampleRead_readingAllMetrics() {
+       // Get descriptions for all supported metrics.
+       descs := metrics.All()
+
+       // Create a sample for each metric.
+       samples := make([]metrics.Sample, len(descs))
+       for i := range samples {
+               samples[i].Name = descs[i].Name
+       }
+
+       // Sample the metrics. Re-use the samples slice if you can!
+       metrics.Read(samples)
+
+       // Iterate over all results.
+       for _, sample := range samples {
+               // Pull out the name and value.
+               name, value := sample.Name, sample.Value
+
+               // Handle each sample.
+               switch value.Kind() {
+               case metrics.KindUint64:
+                       fmt.Printf("%s: %d\n", name, value.Uint64())
+               case metrics.KindFloat64:
+                       fmt.Printf("%s: %f\n", name, value.Float64())
+               case metrics.KindFloat64Histogram:
+                       // The histogram may be quite large, so let's just pull out
+                       // a crude estimate for the median for the sake of this example.
+                       fmt.Printf("%s: %f\n", name, medianBucket(value.Float64Histogram()))
+               case metrics.KindBad:
+                       // This should never happen because all metrics are supported
+                       // by construction.
+                       panic("bug in runtime/metrics package!")
+               default:
+                       // This may happen as new metrics get added.
+                       //
+                       // The safest thing to do here is to simply log it somewhere
+                       // as something to look into, but ignore it for now.
+                       // In the worst case, you might temporarily miss out on a new metric.
+                       fmt.Printf("%s: unexpected metric Kind: %v\n", name, value.Kind())
+               }
+       }
+}
+
+func medianBucket(h *metrics.Float64Histogram) float64 {
+       total := uint64(0)
+       for _, count := range h.Counts {
+               total += count
+       }
+       thresh := total / 2
+       total = 0
+       for i, count := range h.Counts {
+               total += count
+               if total >= thresh {
+                       return h.Buckets[i]
+               }
+       }
+       panic("should not happen")
+}

diff --git a/src/runtime/metrics/histogram.go b/src/runtime/metrics/histogram.go
index e1364e1e26577e9ca80474b4607e4787a5b36a39..956422bf84ea250d6c3c5c533d6be5b3990685c5 100644 (file)
--- a/src/runtime/metrics/histogram.go
+++ b/src/runtime/metrics/histogram.go
@@ -6,25 +6,28 @@ package metrics
 
 // Float64Histogram represents a distribution of float64 values.
 type Float64Histogram struct {
-       // Counts contains the weights for each histogram bucket. The length of
-       // Counts is equal to the length of Buckets (in the metric description)
-       // plus one to account for the implicit minimum bucket.
+       // Counts contains the weights for each histogram bucket.
        //
-       // Given N buckets, the following is the mathematical relationship between
-       // Counts and Buckets.
-       // count[0] is the weight of the range (-inf, bucket[0])
-       // count[n] is the weight of the range [bucket[n], bucket[n+1]), for 0 < n < N-1
-       // count[N-1] is the weight of the range [bucket[N-1], inf)
+       // Given N buckets, Count[n] is the weight of the range
+       // [bucket[n], bucket[n+1]), for 0 <= n < N.
        Counts []uint64
 
-       // Buckets contains the boundaries between histogram buckets, in increasing order.
+       // Buckets contains the boundaries of the histogram buckets, in increasing order.
        //
-       // Because this slice contains boundaries, there are len(Buckets)+1 counts:
-       // a count for all values less than the first boundary, a count covering each
-       // [slice[i], slice[i+1]) interval, and a count for all values greater than or
-       // equal to the last boundary.
+       // Buckets[0] is the inclusive lower bound of the minimum bucket while
+       // Buckets[len(Buckets)-1] is the exclusive upper bound of the maximum bucket.
+       // Hence, there are len(Buckets)-1 counts. Furthermore, len(Buckets) != 1, always,
+       // since at least two boundaries are required to describe one bucket (and 0
+       // boundaries are used to describe 0 buckets).
+       //
+       // Buckets[0] is permitted to have value -Inf and Buckets[len(Buckets)-1] is
+       // permitted to have value Inf.
        //
        // For a given metric name, the value of Buckets is guaranteed not to change
        // between calls until program exit.
+       //
+       // This slice value is permitted to alias with other Float64Histograms' Buckets
+       // fields, so the values within should only ever be read. If they need to be
+       // modified, the user must make a copy.
        Buckets []float64
 }

diff --git a/src/runtime/metrics/sample.go b/src/runtime/metrics/sample.go
index 35534dd70da50f6cf05cc21845f24e781e8dd1ad..4cf8cdf79942820e6f0acf6b20adc71144fcd95a 100644 (file)
--- a/src/runtime/metrics/sample.go
+++ b/src/runtime/metrics/sample.go
@@ -14,7 +14,7 @@ type Sample struct {
        // Name is the name of the metric sampled.
        //
        // It must correspond to a name in one of the metric descriptions
-       // returned by Descriptions.
+       // returned by All.
        Name string
 
        // Value is the value of the metric sample.
@@ -32,9 +32,9 @@ func runtime_readMetrics(unsafe.Pointer, int, int)
 //
 // Note that re-use has some caveats. Notably, Values should not be read or
 // manipulated while a Read with that value is outstanding; that is a data race.
-// This property includes pointer-typed Values (e.g. Float64Histogram) whose
-// underlying storage will be reused by Read when possible. To safely use such
-// values in a concurrent setting, all data must be deep-copied.
+// This property includes pointer-typed Values (for example, Float64Histogram)
+// whose underlying storage will be reused by Read when possible. To safely use
+// such values in a concurrent setting, all data must be deep-copied.
 //
 // It is safe to execute multiple Read calls concurrently, but their arguments
 // must share no underlying memory. When in doubt, create a new []Sample from

diff --git a/src/runtime/metrics/value.go b/src/runtime/metrics/value.go
index 0b056b4ea8c8f476611b586c0e5f8fcfe18631b6..ed9a33d87cc64e126f68f165e20411aa7cd7a813 100644 (file)
--- a/src/runtime/metrics/value.go
+++ b/src/runtime/metrics/value.go
@@ -33,7 +33,7 @@ type Value struct {
        pointer unsafe.Pointer // contains non-scalar values.
 }
 
-// Kind returns the a tag representing the kind of value this is.
+// Kind returns the tag representing the kind of value this is.
 func (v Value) Kind() ValueKind {
        return v.kind
 }
@@ -63,7 +63,7 @@ func (v Value) Float64() float64 {
 // If v.Kind() != KindFloat64Histogram, this method panics.
 func (v Value) Float64Histogram() *Float64Histogram {
        if v.kind != KindFloat64Histogram {
-               panic("called Float64 on non-float64 metric value")
+               panic("called Float64Histogram on non-Float64Histogram metric value")
        }
        return (*Float64Histogram)(v.pointer)
 }

diff --git a/src/runtime/metrics_test.go b/src/runtime/metrics_test.go
index 167edd57fd882151a3eab3f2954280b613feda46..8a3cf019bdb474155b6daee86eee14d9cad00b39 100644 (file)
--- a/src/runtime/metrics_test.go
+++ b/src/runtime/metrics_test.go
@@ -70,6 +70,34 @@ func TestReadMetrics(t *testing.T) {
                        checkUint64(t, name, samples[i].Value.Uint64(), mstats.BuckHashSys)
                case "/memory/classes/total:bytes":
                        checkUint64(t, name, samples[i].Value.Uint64(), mstats.Sys)
+               case "/gc/heap/allocs-by-size:bytes":
+                       hist := samples[i].Value.Float64Histogram()
+                       // Skip size class 0 in BySize, because it's always empty and not represented
+                       // in the histogram.
+                       for i, sc := range mstats.BySize[1:] {
+                               if b, s := hist.Buckets[i+1], float64(sc.Size+1); b != s {
+                                       t.Errorf("bucket does not match size class: got %f, want %f", b, s)
+                                       // The rest of the checks aren't expected to work anyway.
+                                       continue
+                               }
+                               if c, m := hist.Counts[i], sc.Mallocs; c != m {
+                                       t.Errorf("histogram counts do not much BySize for class %d: got %d, want %d", i, c, m)
+                               }
+                       }
+               case "/gc/heap/frees-by-size:bytes":
+                       hist := samples[i].Value.Float64Histogram()
+                       // Skip size class 0 in BySize, because it's always empty and not represented
+                       // in the histogram.
+                       for i, sc := range mstats.BySize[1:] {
+                               if b, s := hist.Buckets[i+1], float64(sc.Size+1); b != s {
+                                       t.Errorf("bucket does not match size class: got %f, want %f", b, s)
+                                       // The rest of the checks aren't expected to work anyway.
+                                       continue
+                               }
+                               if c, f := hist.Counts[i], sc.Frees; c != f {
+                                       t.Errorf("histogram counts do not much BySize for class %d: got %d, want %d", i, c, f)
+                               }
+                       }
                case "/gc/heap/objects:objects":
                        checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapObjects)
                case "/gc/heap/goal:bytes":
@@ -133,9 +161,9 @@ func TestReadMetricsConsistency(t *testing.T) {
                        totalVirtual.got = samples[i].Value.Uint64()
                case "/gc/heap/objects:objects":
                        objects.total = samples[i].Value.Uint64()
-               case "/gc/heap/allocs-by-size:objects":
+               case "/gc/heap/allocs-by-size:bytes":
                        objects.alloc = samples[i].Value.Float64Histogram()
-               case "/gc/heap/frees-by-size:objects":
+               case "/gc/heap/frees-by-size:bytes":
                        objects.free = samples[i].Value.Float64Histogram()
                case "/gc/cycles:gc-cycles":
                        gc.numGC = samples[i].Value.Uint64()
@@ -154,6 +182,12 @@ func TestReadMetricsConsistency(t *testing.T) {
        if totalVirtual.got != totalVirtual.want {
                t.Errorf(`"/memory/classes/total:bytes" does not match sum of /memory/classes/**: got %d, want %d`, totalVirtual.got, totalVirtual.want)
        }
+       if b, c := len(objects.alloc.Buckets), len(objects.alloc.Counts); b != c+1 {
+               t.Errorf("allocs-by-size has wrong bucket or counts length: %d buckets, %d counts", b, c)
+       }
+       if b, c := len(objects.free.Buckets), len(objects.free.Counts); b != c+1 {
+               t.Errorf("frees-by-size has wrong bucket or counts length: %d buckets, %d counts", b, c)
+       }
        if len(objects.alloc.Buckets) != len(objects.free.Buckets) {
                t.Error("allocs-by-size and frees-by-size buckets don't match in length")
        } else if len(objects.alloc.Counts) != len(objects.free.Counts) {

diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index f4dbd772528904fe289486adc28b83a7ceaac82a..7d0313be1202691809651ae2dc967cb4b747b892 100644 (file)
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -7,6 +7,7 @@
 package runtime
 
 import (
+       "internal/abi"
        "runtime/internal/atomic"
        "runtime/internal/sys"
        "unsafe"
@@ -219,7 +220,11 @@ func runfinq() {
                                        throw("bad kind in runfinq")
                                }
                                fingRunning = true
-                               reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
+                               // Pass a dummy RegArgs for now.
+                               //
+                               // TODO(mknyszek): Pass arguments in registers.
+                               var regs abi.RegArgs
+                               reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), &regs)
                                fingRunning = false
 
                                // Drop finalizer queue heap references

diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 5a24cdac88aff06fb8c6f876e93d4461a9dab5fc..46fae5de7234a52d3131a71da95104e32f8ae241 100644 (file)
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -101,8 +101,7 @@ func gcMarkRootPrepare() {
        // Gs may be created after this point, but it's okay that we
        // ignore them because they begin life without any roots, so
        // there's nothing to scan, and any roots they create during
-       // the concurrent phase will be scanned during mark
-       // termination.
+       // the concurrent phase will be caught by the write barrier.
        work.nStackRoots = int(atomic.Loaduintptr(&allglen))
 
        work.markrootNext = 0
@@ -133,7 +132,6 @@ fail:
        println("gp", gp, "goid", gp.goid,
                "status", readgstatus(gp),
                "gcscandone", gp.gcscandone)
-       unlock(&allglock) // Avoid self-deadlock with traceback.
        throw("scan missed a g")
 }
 

diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 38f09309dc8d16b38867854c0f4fb2d85c2f1973..a7c5bc49b874498694a7cc4c5305ea22deb81be7 100644 (file)
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -562,7 +562,7 @@ func (p *pageAlloc) scavengeUnreserve(r addrRange, gen uint32) {
 func (p *pageAlloc) scavengeOne(work addrRange, max uintptr, mayUnlock bool) (uintptr, addrRange) {
        assertLockHeld(p.mheapLock)
 
-       // Defensively check if we've recieved an empty address range.
+       // Defensively check if we've received an empty address range.
        // If so, just return.
        if work.size() == 0 {
                // Nothing to do.

diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index 94ae75fbfe5ff93166e5b0243d01c206e5b6bffe..ef297f073e099fa4538cea75c218cc60c37638ee 100644 (file)
--- a/src/runtime/mkduff.go
+++ b/src/runtime/mkduff.go
@@ -62,15 +62,15 @@ func gen(arch string, tags, zero, copy func(io.Writer)) {
 func notags(w io.Writer) { fmt.Fprintln(w) }
 
 func zeroAMD64(w io.Writer) {
-       // X0: zero
+       // X15: zero
        // DI: ptr to memory to be zeroed
        // DI is updated as a side effect.
-       fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT, $0-0")
+       fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT, $0-0")
        for i := 0; i < 16; i++ {
-               fmt.Fprintln(w, "\tMOVUPS\tX0,(DI)")
-               fmt.Fprintln(w, "\tMOVUPS\tX0,16(DI)")
-               fmt.Fprintln(w, "\tMOVUPS\tX0,32(DI)")
-               fmt.Fprintln(w, "\tMOVUPS\tX0,48(DI)")
+               fmt.Fprintln(w, "\tMOVUPS\tX15,(DI)")
+               fmt.Fprintln(w, "\tMOVUPS\tX15,16(DI)")
+               fmt.Fprintln(w, "\tMOVUPS\tX15,32(DI)")
+               fmt.Fprintln(w, "\tMOVUPS\tX15,48(DI)")
                fmt.Fprintln(w, "\tLEAQ\t64(DI),DI") // We use lea instead of add, to avoid clobbering flags
                fmt.Fprintln(w)
        }
@@ -84,7 +84,7 @@ func copyAMD64(w io.Writer) {
        //
        // This is equivalent to a sequence of MOVSQ but
        // for some reason that is 3.5x slower than this code.
-       fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT, $0-0")
+       fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT, $0-0")
        for i := 0; i < 64; i++ {
                fmt.Fprintln(w, "\tMOVUPS\t(SI), X0")
                fmt.Fprintln(w, "\tADDQ\t$16, SI")

diff --git a/src/runtime/mmap.go b/src/runtime/mmap.go
index 9fe31cb41666a019c7bc819501c11353bb5e2c3b..1b1848b79ec54f2ec6f894c31bfa2b7feb229152 100644 (file)
--- a/src/runtime/mmap.go
+++ b/src/runtime/mmap.go
@@ -2,14 +2,15 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build !aix
+// +build !darwin
+// +build !js
+// +build !linux !amd64
+// +build !linux !arm64
+// +build !openbsd
 // +build !plan9
 // +build !solaris
 // +build !windows
-// +build !linux !amd64
-// +build !linux !arm64
-// +build !js
-// +build !darwin
-// +build !aix
 
 package runtime
 

diff --git a/src/runtime/msan0.go b/src/runtime/msan0.go
index 117c5e5789cb51e9224a58ec14bebbebb86bbe15..374d13f30b516978a1154ea7e932f55a9d1af492 100644 (file)
--- a/src/runtime/msan0.go
+++ b/src/runtime/msan0.go
@@ -16,7 +16,8 @@ const msanenabled = false
 
 // Because msanenabled is false, none of these functions should be called.
 
-func msanread(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
-func msanwrite(addr unsafe.Pointer, sz uintptr)  { throw("msan") }
-func msanmalloc(addr unsafe.Pointer, sz uintptr) { throw("msan") }
-func msanfree(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
+func msanread(addr unsafe.Pointer, sz uintptr)     { throw("msan") }
+func msanwrite(addr unsafe.Pointer, sz uintptr)    { throw("msan") }
+func msanmalloc(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
+func msanfree(addr unsafe.Pointer, sz uintptr)     { throw("msan") }
+func msanmove(dst, src unsafe.Pointer, sz uintptr) { throw("msan") }

diff --git a/src/runtime/os2_aix.go b/src/runtime/os2_aix.go
index 428ff7f225c3701019e6df7130c37680043d403b..4d77f0de6dd2fea3b50da21268f6d934fcdbb4da 100644 (file)
--- a/src/runtime/os2_aix.go
+++ b/src/runtime/os2_aix.go
@@ -18,11 +18,11 @@ import (
 
 //go:cgo_import_dynamic libc___n_pthreads __n_pthreads "libpthread.a/shr_xpg5_64.o"
 //go:cgo_import_dynamic libc___mod_init __mod_init "libc.a/shr_64.o"
-//go:linkname libc___n_pthreads libc___n_pthread
+//go:linkname libc___n_pthreads libc___n_pthreads
 //go:linkname libc___mod_init libc___mod_init
 
 var (
-       libc___n_pthread,
+       libc___n_pthreads,
        libc___mod_init libFunc
 )
 
@@ -527,20 +527,17 @@ func internal_cpu_getsystemcfg(label uint) uint {
 func usleep1(us uint32)
 
 //go:nosplit
-func usleep(us uint32) {
-       _g_ := getg()
+func usleep_no_g(us uint32) {
+       usleep1(us)
+}
 
-       // Check the validity of m because we might be called in cgo callback
-       // path early enough where there isn't a g or a m available yet.
-       if _g_ != nil && _g_.m != nil {
-               r, err := syscall1(&libc_usleep, uintptr(us))
-               if int32(r) == -1 {
-                       println("syscall usleep failed: ", hex(err))
-                       throw("syscall usleep")
-               }
-               return
+//go:nosplit
+func usleep(us uint32) {
+       r, err := syscall1(&libc_usleep, uintptr(us))
+       if int32(r) == -1 {
+               println("syscall usleep failed: ", hex(err))
+               throw("syscall usleep")
        }
-       usleep1(us)
 }
 
 //go:nosplit
@@ -611,20 +608,17 @@ func raiseproc(sig uint32) {
 func osyield1()
 
 //go:nosplit
-func osyield() {
-       _g_ := getg()
+func osyield_no_g() {
+       osyield1()
+}
 
-       // Check the validity of m because it might be called during a cgo
-       // callback early enough where m isn't available yet.
-       if _g_ != nil && _g_.m != nil {
-               r, err := syscall0(&libc_sched_yield)
-               if int32(r) == -1 {
-                       println("syscall osyield failed: ", hex(err))
-                       throw("syscall osyield")
-               }
-               return
+//go:nosplit
+func osyield() {
+       r, err := syscall0(&libc_sched_yield)
+       if int32(r) == -1 {
+               println("syscall osyield failed: ", hex(err))
+               throw("syscall osyield")
        }
-       osyield1()
 }
 
 //go:nosplit

diff --git a/src/runtime/os3_plan9.go b/src/runtime/os3_plan9.go
index 15ca3359d2bf743da0a6983ab172b516e018cd90..b6ee98cab6e79bc31d051f7d104a4a46c7d9e97b 100644 (file)
--- a/src/runtime/os3_plan9.go
+++ b/src/runtime/os3_plan9.go
@@ -92,10 +92,6 @@ func sighandler(_ureg *ureg, note *byte, gp *g) int {
                        if usesLR {
                                c.setlr(pc)
                        } else {
-                               if sys.RegSize > sys.PtrSize {
-                                       sp -= sys.PtrSize
-                                       *(*uintptr)(unsafe.Pointer(sp)) = 0
-                               }
                                sp -= sys.PtrSize
                                *(*uintptr)(unsafe.Pointer(sp)) = pc
                                c.setsp(sp)

diff --git a/src/runtime/os3_solaris.go b/src/runtime/os3_solaris.go
index d6e36fbfbbe51fa7d57ce5e4eaf39e897204d9c7..4b65139eb81075c543e7bc867ff84dc41ebfef3c 100644 (file)
--- a/src/runtime/os3_solaris.go
+++ b/src/runtime/os3_solaris.go
@@ -227,6 +227,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func sigtramp()
 
 //go:nosplit
@@ -516,6 +521,11 @@ func sysconf(name int32) int64 {
 
 func usleep1(usec uint32)
 
+//go:nosplit
+func usleep_no_g(µs uint32) {
+       usleep1(µs)
+}
+
 //go:nosplit
 func usleep(µs uint32) {
        usleep1(µs)
@@ -564,18 +574,15 @@ func setNonblock(fd int32) {
 func osyield1()
 
 //go:nosplit
-func osyield() {
-       _g_ := getg()
-
-       // Check the validity of m because we might be called in cgo callback
-       // path early enough where there isn't a m available yet.
-       if _g_ != nil && _g_.m != nil {
-               sysvicall0(&libc_sched_yield)
-               return
-       }
+func osyield_no_g() {
        osyield1()
 }
 
+//go:nosplit
+func osyield() {
+       sysvicall0(&libc_sched_yield)
+}
+
 //go:linkname executablePath os.executablePath
 var executablePath string
 

diff --git a/src/runtime/os_aix.go b/src/runtime/os_aix.go
index 0c501be96a94c8366781c2f075cb9f117812d824..303f0876deb711333cda9836eb26adfd67f10cfc 100644 (file)
--- a/src/runtime/os_aix.go
+++ b/src/runtime/os_aix.go
@@ -180,6 +180,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 // tstart is a function descriptor to _tstart defined in assembly.
 var tstart funcDescriptor
 

diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index e0a43c28aaa693dce07e1ae1689a77d606f6232e..470698d0a3ab6922ae93edb9539ac9a05e5069bf 100644 (file)
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -325,6 +325,16 @@ func unminit() {
        }
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
+//go:nosplit
+func osyield_no_g() {
+       usleep_no_g(1)
+}
+
 //go:nosplit
 func osyield() {
        usleep(1)

diff --git a/src/runtime/os_dragonfly.go b/src/runtime/os_dragonfly.go
index 6578fcbeb1f331f75b2ee15e9ed4907c77b3411e..b786c8ab5f79e1ba703534301e912c4556fce999 100644 (file)
--- a/src/runtime/os_dragonfly.go
+++ b/src/runtime/os_dragonfly.go
@@ -51,6 +51,11 @@ func sys_umtx_wakeup(addr *uint32, val int32) int32
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
@@ -203,6 +208,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func sigtramp()
 
 type sigactiont struct {

diff --git a/src/runtime/os_freebsd.go b/src/runtime/os_freebsd.go
index 730973a20296fc3c85da49e4698694b96f59d658..09dd50ce59477583ff418da334e3769f191890a4 100644 (file)
--- a/src/runtime/os_freebsd.go
+++ b/src/runtime/os_freebsd.go
@@ -36,6 +36,11 @@ func sys_umtx_op(addr *uint32, mode int32, val uint32, uaddr1 uintptr, ut *umtx_
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
@@ -166,7 +171,7 @@ func futexsleep1(addr *uint32, val uint32, ns int64) {
                utp = &ut
        }
        ret := sys_umtx_op(addr, _UMTX_OP_WAIT_UINT_PRIVATE, val, unsafe.Sizeof(*utp), utp)
-       if ret >= 0 || ret == -_EINTR {
+       if ret >= 0 || ret == -_EINTR || ret == -_ETIMEDOUT {
                return
        }
        print("umtx_wait addr=", addr, " val=", val, " ret=", ret, "\n")
@@ -208,7 +213,6 @@ func newosproc(mp *m) {
 
        var oset sigset
        sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
-       // TODO: Check for error.
        ret := thr_new(&param, int32(unsafe.Sizeof(param)))
        sigprocmask(_SIG_SETMASK, &oset, nil)
        if ret < 0 {
@@ -320,6 +324,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func sigtramp()
 
 type sigactiont struct {

diff --git a/src/runtime/os_js.go b/src/runtime/os_js.go
index 94983b358d4abdc604a84fcb488e3628bc81e397..5b2c53795a2d32f8bf6c38e8933de231d3324817 100644 (file)
--- a/src/runtime/os_js.go
+++ b/src/runtime/os_js.go
@@ -30,12 +30,22 @@ func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
 
 func usleep(usec uint32)
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+       usleep(usec)
+}
+
 func exitThread(wait *uint32)
 
 type mOS struct{}
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 const _SIGSEGV = 0xb
 
 func sigpanic() {
@@ -72,7 +82,7 @@ func clearSignalHandlers() {
 }
 
 //go:nosplit
-func sigblock() {
+func sigblock(exiting bool) {
 }
 
 // Called to initialize a new m (including the bootstrap m).
@@ -84,6 +94,11 @@ func minit() {
 func unminit() {
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func osinit() {
        ncpu = 1
        getg().m.procid = 2

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 371db73502915d92d360b41713854e9fe1df7512..21d3ae653ec9d48ff58ad5f4fc23f36135c57a3e 100644 (file)
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -301,6 +301,24 @@ func getHugePageSize() uintptr {
 func osinit() {
        ncpu = getproccount()
        physHugePageSize = getHugePageSize()
+       if iscgo {
+               // #42494 glibc and musl reserve some signals for
+               // internal use and require they not be blocked by
+               // the rest of a normal C runtime. When the go runtime
+               // blocks...unblocks signals, temporarily, the blocked
+               // interval of time is generally very short. As such,
+               // these expectations of *libc code are mostly met by
+               // the combined go+cgo system of threads. However,
+               // when go causes a thread to exit, via a return from
+               // mstart(), the combined runtime can deadlock if
+               // these signals are blocked. Thus, don't block these
+               // signals when exiting threads.
+               // - glibc: SIGCANCEL (32), SIGSETXID (33)
+               // - musl: SIGTIMER (32), SIGCANCEL (33), SIGSYNCCALL (34)
+               sigdelset(&sigsetAllExiting, 32)
+               sigdelset(&sigsetAllExiting, 33)
+               sigdelset(&sigsetAllExiting, 34)
+       }
        osArchInit()
 }
 
@@ -357,6 +375,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 //#ifdef GOARCH_386
 //#define sa_handler k_sa_handler
 //#endif
@@ -387,6 +410,11 @@ func raiseproc(sig uint32)
 func sched_getaffinity(pid, len uintptr, buf *byte) int32
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 func pipe() (r, w int32, errno int32)
 func pipe2(flags int32) (r, w int32, errno int32)
 func setNonblock(fd int32)

diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go
index f7f90cedc1a8b9eacd7bcd0feedd90bb1897d81a..0328fa57ae67082b05e054b45a93877a924c4898 100644 (file)
--- a/src/runtime/os_netbsd.go
+++ b/src/runtime/os_netbsd.go
@@ -67,6 +67,11 @@ func lwp_self() int32
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
@@ -290,6 +295,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func sigtramp()
 
 type sigactiont struct {

diff --git a/src/runtime/os_openbsd.go b/src/runtime/os_openbsd.go
index d7960f4c91c9580aa9185d190bb67967609b3361..6259b96c22b84e05eb2d5ac203496c3381f8cf36 100644 (file)
--- a/src/runtime/os_openbsd.go
+++ b/src/runtime/os_openbsd.go
@@ -6,7 +6,6 @@ package runtime
 
 import (
        "runtime/internal/atomic"
-       "runtime/internal/sys"
        "unsafe"
 )
 
@@ -14,60 +13,6 @@ type mOS struct {
        waitsemacount uint32
 }
 
-//go:noescape
-func setitimer(mode int32, new, old *itimerval)
-
-//go:noescape
-func sigaction(sig uint32, new, old *sigactiont)
-
-//go:noescape
-func sigaltstack(new, old *stackt)
-
-//go:noescape
-func obsdsigprocmask(how int32, new sigset) sigset
-
-//go:nosplit
-//go:nowritebarrierrec
-func sigprocmask(how int32, new, old *sigset) {
-       n := sigset(0)
-       if new != nil {
-               n = *new
-       }
-       r := obsdsigprocmask(how, n)
-       if old != nil {
-               *old = r
-       }
-}
-
-//go:noescape
-func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
-
-func raiseproc(sig uint32)
-
-func getthrid() int32
-func thrkill(tid int32, sig int)
-
-//go:noescape
-func tfork(param *tforkt, psize uintptr, mm *m, gg *g, fn uintptr) int32
-
-//go:noescape
-func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32
-
-//go:noescape
-func thrwakeup(ident uintptr, n int32) int32
-
-func osyield()
-
-func kqueue() int32
-
-//go:noescape
-func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
-
-func pipe() (r, w int32, errno int32)
-func pipe2(flags int32) (r, w int32, errno int32)
-func closeonexec(fd int32)
-func setNonblock(fd int32)
-
 const (
        _ESRCH       = 3
        _EWOULDBLOCK = _EAGAIN
@@ -183,36 +128,6 @@ func semawakeup(mp *m) {
        }
 }
 
-// May run with m.p==nil, so write barriers are not allowed.
-//go:nowritebarrier
-func newosproc(mp *m) {
-       stk := unsafe.Pointer(mp.g0.stack.hi)
-       if false {
-               print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " id=", mp.id, " ostk=", &mp, "\n")
-       }
-
-       // Stack pointer must point inside stack area (as marked with MAP_STACK),
-       // rather than at the top of it.
-       param := tforkt{
-               tf_tcb:   unsafe.Pointer(&mp.tls[0]),
-               tf_tid:   nil, // minit will record tid
-               tf_stack: uintptr(stk) - sys.PtrSize,
-       }
-
-       var oset sigset
-       sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
-       ret := tfork(&param, unsafe.Sizeof(param), mp, mp.g0, funcPC(mstart))
-       sigprocmask(_SIG_SETMASK, &oset, nil)
-
-       if ret < 0 {
-               print("runtime: failed to create new OS thread (have ", mcount()-1, " already; errno=", -ret, ")\n")
-               if ret == -_EAGAIN {
-                       println("runtime: may need to increase max user processes (ulimit -p)")
-               }
-               throw("runtime.newosproc")
-       }
-}
-
 func osinit() {
        ncpu = getncpu()
        physPageSize = getPageSize()
@@ -257,6 +172,11 @@ func unminit() {
        unminitSignals()
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 func sigtramp()
 
 type sigactiont struct {

diff --git a/src/runtime/os_openbsd_libc.go b/src/runtime/os_openbsd_libc.go
new file mode 100644 (file)
index 0000000..2edb035
--- /dev/null
+++ b/src/runtime/os_openbsd_libc.go
@@ -0,0 +1,58 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import (
+       "unsafe"
+)
+
+var failThreadCreate = []byte("runtime: failed to create new OS thread\n")
+
+// mstart_stub provides glue code to call mstart from pthread_create.
+func mstart_stub()
+
+// May run with m.p==nil, so write barriers are not allowed.
+//go:nowritebarrierrec
+func newosproc(mp *m) {
+       if false {
+               print("newosproc m=", mp, " g=", mp.g0, " id=", mp.id, " ostk=", &mp, "\n")
+       }
+
+       // Initialize an attribute object.
+       var attr pthreadattr
+       if err := pthread_attr_init(&attr); err != 0 {
+               write(2, unsafe.Pointer(&failThreadCreate[0]), int32(len(failThreadCreate)))
+               exit(1)
+       }
+
+       // Find out OS stack size for our own stack guard.
+       var stacksize uintptr
+       if pthread_attr_getstacksize(&attr, &stacksize) != 0 {
+               write(2, unsafe.Pointer(&failThreadCreate[0]), int32(len(failThreadCreate)))
+               exit(1)
+       }
+       mp.g0.stack.hi = stacksize // for mstart
+
+       // Tell the pthread library we won't join with this thread.
+       if pthread_attr_setdetachstate(&attr, _PTHREAD_CREATE_DETACHED) != 0 {
+               write(2, unsafe.Pointer(&failThreadCreate[0]), int32(len(failThreadCreate)))
+               exit(1)
+       }
+
+       // Finally, create the thread. It starts at mstart_stub, which does some low-level
+       // setup and then calls mstart.
+       var oset sigset
+       sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
+       err := pthread_create(&attr, funcPC(mstart_stub), unsafe.Pointer(mp))
+       sigprocmask(_SIG_SETMASK, &oset, nil)
+       if err != 0 {
+               write(2, unsafe.Pointer(&failThreadCreate[0]), int32(len(failThreadCreate)))
+               exit(1)
+       }
+
+       pthread_attr_destroy(&attr)
+}

diff --git a/src/runtime/os_openbsd_syscall.go b/src/runtime/os_openbsd_syscall.go
new file mode 100644 (file)
index 0000000..16ff2b8
--- /dev/null
+++ b/src/runtime/os_openbsd_syscall.go
@@ -0,0 +1,46 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,!amd64
+// +build openbsd,!arm64
+
+package runtime
+
+import (
+       "runtime/internal/sys"
+       "unsafe"
+)
+
+//go:noescape
+func tfork(param *tforkt, psize uintptr, mm *m, gg *g, fn uintptr) int32
+
+// May run with m.p==nil, so write barriers are not allowed.
+//go:nowritebarrier
+func newosproc(mp *m) {
+       stk := unsafe.Pointer(mp.g0.stack.hi)
+       if false {
+               print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " id=", mp.id, " ostk=", &mp, "\n")
+       }
+
+       // Stack pointer must point inside stack area (as marked with MAP_STACK),
+       // rather than at the top of it.
+       param := tforkt{
+               tf_tcb:   unsafe.Pointer(&mp.tls[0]),
+               tf_tid:   nil, // minit will record tid
+               tf_stack: uintptr(stk) - sys.PtrSize,
+       }
+
+       var oset sigset
+       sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
+       ret := tfork(&param, unsafe.Sizeof(param), mp, mp.g0, funcPC(mstart))
+       sigprocmask(_SIG_SETMASK, &oset, nil)
+
+       if ret < 0 {
+               print("runtime: failed to create new OS thread (have ", mcount()-1, " already; errno=", -ret, ")\n")
+               if ret == -_EAGAIN {
+                       println("runtime: may need to increase max user processes (ulimit -p)")
+               }
+               throw("runtime.newosproc")
+       }
+}

diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
new file mode 100644 (file)
index 0000000..f37da04
--- /dev/null
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -0,0 +1,20 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,!amd64,!arm64
+
+package runtime
+
+//go:noescape
+func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32
+
+//go:noescape
+func thrwakeup(ident uintptr, n int32) int32
+
+func osyield()
+
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}

diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
new file mode 100644 (file)
index 0000000..81cfb08
--- /dev/null
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -0,0 +1,100 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,!amd64,!arm64
+
+package runtime
+
+import (
+       "unsafe"
+)
+
+//go:noescape
+func sigaction(sig uint32, new, old *sigactiont)
+
+func kqueue() int32
+
+//go:noescape
+func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
+
+func raiseproc(sig uint32)
+
+func getthrid() int32
+func thrkill(tid int32, sig int)
+
+// read calls the read system call.
+// It returns a non-negative number of bytes written or a negative errno value.
+func read(fd int32, p unsafe.Pointer, n int32) int32
+
+func closefd(fd int32) int32
+
+func exit(code int32)
+func usleep(usec uint32)
+
+//go:nosplit
+func usleep_no_g(usec uint32) {
+       usleep(usec)
+}
+
+// write calls the write system call.
+// It returns a non-negative number of bytes written or a negative errno value.
+//go:noescape
+func write1(fd uintptr, p unsafe.Pointer, n int32) int32
+
+//go:noescape
+func open(name *byte, mode, perm int32) int32
+
+// return value is only set on linux to be used in osinit()
+func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32
+
+// exitThread terminates the current thread, writing *wait = 0 when
+// the stack is safe to reclaim.
+//
+//go:noescape
+func exitThread(wait *uint32)
+
+//go:noescape
+func obsdsigprocmask(how int32, new sigset) sigset
+
+//go:nosplit
+//go:nowritebarrierrec
+func sigprocmask(how int32, new, old *sigset) {
+       n := sigset(0)
+       if new != nil {
+               n = *new
+       }
+       r := obsdsigprocmask(how, n)
+       if old != nil {
+               *old = r
+       }
+}
+
+func pipe() (r, w int32, errno int32)
+func pipe2(flags int32) (r, w int32, errno int32)
+
+//go:noescape
+func setitimer(mode int32, new, old *itimerval)
+
+//go:noescape
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+
+// mmap calls the mmap system call. It is implemented in assembly.
+// We only pass the lower 32 bits of file offset to the
+// assembly routine; the higher bits (if required), should be provided
+// by the assembly routine as 0.
+// The err result is an OS error code such as ENOMEM.
+func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
+
+// munmap calls the munmap system call. It is implemented in assembly.
+func munmap(addr unsafe.Pointer, n uintptr)
+
+func nanotime1() int64
+
+//go:noescape
+func sigaltstack(new, old *stackt)
+
+func closeonexec(fd int32)
+func setNonblock(fd int32)
+
+func walltime1() (sec int64, nsec int32)

diff --git a/src/runtime/os_plan9.go b/src/runtime/os_plan9.go
index 62aecea06041de4bb65afdf959d9c18526915bff..77665f461ae1924a38194f95e01808c95b75d1f8 100644 (file)
--- a/src/runtime/os_plan9.go
+++ b/src/runtime/os_plan9.go
@@ -195,7 +195,7 @@ func msigrestore(sigmask sigset) {
 func clearSignalHandlers() {
 }
 
-func sigblock() {
+func sigblock(exiting bool) {
 }
 
 // Called to initialize a new m (including the bootstrap m).
@@ -213,6 +213,11 @@ func minit() {
 func unminit() {
 }
 
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+func mdestroy(mp *m) {
+}
+
 var sysstat = []byte("/dev/sysstat\x00")
 
 func getproccount() int32 {
@@ -334,6 +339,11 @@ func osyield() {
        sleep(0)
 }
 
+//go:nosplit
+func osyield_no_g() {
+       osyield()
+}
+
 //go:nosplit
 func usleep(µs uint32) {
        ms := int32(µs / 1000)
@@ -343,6 +353,11 @@ func usleep(µs uint32) {
        sleep(ms)
 }
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+       usleep(usec)
+}
+
 //go:nosplit
 func nanotime1() int64 {
        var scratch int64

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index ffb087f9db2794794ab2308dc642f7b57bb3b620..f4e21a93ed894357e4da5045404af97c83e8df3f 100644 (file)
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -46,6 +46,7 @@ const (
 //go:cgo_import_dynamic runtime._SetThreadPriority SetThreadPriority%2 "kernel32.dll"
 //go:cgo_import_dynamic runtime._SetUnhandledExceptionFilter SetUnhandledExceptionFilter%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._SetWaitableTimer SetWaitableTimer%6 "kernel32.dll"
+//go:cgo_import_dynamic runtime._Sleep Sleep%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._SuspendThread SuspendThread%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._SwitchToThread SwitchToThread%0 "kernel32.dll"
 //go:cgo_import_dynamic runtime._TlsAlloc TlsAlloc%0 "kernel32.dll"
@@ -97,6 +98,7 @@ var (
        _SetThreadPriority,
        _SetUnhandledExceptionFilter,
        _SetWaitableTimer,
+       _Sleep,
        _SuspendThread,
        _SwitchToThread,
        _TlsAlloc,
@@ -146,6 +148,9 @@ func tstart_stdcall(newm *m)
 // Called by OS using stdcall ABI.
 func ctrlhandler()
 
+// Init-time helper
+func wintls()
+
 type mOS struct {
        threadLock mutex   // protects "thread" and prevents closing
        thread     uintptr // thread handle
@@ -234,6 +239,8 @@ func windowsLoadSystemLib(name []byte) uintptr {
        }
 }
 
+const haveCputicksAsm = GOARCH == "386" || GOARCH == "amd64"
+
 func loadOptionalSyscalls() {
        var kernel32dll = []byte("kernel32.dll\000")
        k32 := stdcall1(_LoadLibraryA, uintptr(unsafe.Pointer(&kernel32dll[0])))
@@ -260,7 +267,7 @@ func loadOptionalSyscalls() {
        }
        _NtWaitForSingleObject = windowsFindfunc(n32, []byte("NtWaitForSingleObject\000"))
 
-       if GOARCH == "arm" {
+       if !haveCputicksAsm {
                _QueryPerformanceCounter = windowsFindfunc(k32, []byte("QueryPerformanceCounter\000"))
                if _QueryPerformanceCounter == nil {
                        throw("could not find QPC syscalls")
@@ -377,7 +384,6 @@ const (
 // in sys_windows_386.s and sys_windows_amd64.s:
 func externalthreadhandler()
 func getlasterror() uint32
-func setlasterror(err uint32)
 
 // When loading DLLs, we prefer to use LoadLibraryEx with
 // LOAD_LIBRARY_SEARCH_* flags, if available. LoadLibraryEx is not
@@ -451,23 +457,22 @@ func createHighResTimer() uintptr {
                _SYNCHRONIZE|_TIMER_QUERY_STATE|_TIMER_MODIFY_STATE)
 }
 
+const highResTimerSupported = GOARCH == "386" || GOARCH == "amd64"
+
 func initHighResTimer() {
-       if GOARCH == "arm" {
+       if !highResTimerSupported {
                // TODO: Not yet implemented.
                return
        }
        h := createHighResTimer()
        if h != 0 {
                haveHighResTimer = true
-               usleep2Addr = unsafe.Pointer(funcPC(usleep2HighRes))
                stdcall1(_CloseHandle, h)
        }
 }
 
 func osinit() {
        asmstdcallAddr = unsafe.Pointer(funcPC(asmstdcall))
-       usleep2Addr = unsafe.Pointer(funcPC(usleep2))
-       switchtothreadAddr = unsafe.Pointer(funcPC(switchtothread))
 
        setBadSignalMsg()
 
@@ -886,29 +891,30 @@ func clearSignalHandlers() {
 }
 
 //go:nosplit
-func sigblock() {
+func sigblock(exiting bool) {
 }
 
 // Called to initialize a new m (including the bootstrap m).
 // Called on the new thread, cannot allocate memory.
 func minit() {
        var thandle uintptr
-       stdcall7(_DuplicateHandle, currentProcess, currentThread, currentProcess, uintptr(unsafe.Pointer(&thandle)), 0, 0, _DUPLICATE_SAME_ACCESS)
+       if stdcall7(_DuplicateHandle, currentProcess, currentThread, currentProcess, uintptr(unsafe.Pointer(&thandle)), 0, 0, _DUPLICATE_SAME_ACCESS) == 0 {
+               print("runtime.minit: duplicatehandle failed; errno=", getlasterror(), "\n")
+               throw("runtime.minit: duplicatehandle failed")
+       }
+
+       mp := getg().m
+       lock(&mp.threadLock)
+       mp.thread = thandle
 
        // Configure usleep timer, if possible.
-       var timer uintptr
-       if haveHighResTimer {
-               timer = createHighResTimer()
-               if timer == 0 {
+       if mp.highResTimer == 0 && haveHighResTimer {
+               mp.highResTimer = createHighResTimer()
+               if mp.highResTimer == 0 {
                        print("runtime: CreateWaitableTimerEx failed; errno=", getlasterror(), "\n")
                        throw("CreateWaitableTimerEx when creating timer failed")
                }
        }
-
-       mp := getg().m
-       lock(&mp.threadLock)
-       mp.thread = thandle
-       mp.highResTimer = timer
        unlock(&mp.threadLock)
 
        // Query the true stack base from the OS. Currently we're
@@ -944,13 +950,29 @@ func minit() {
 func unminit() {
        mp := getg().m
        lock(&mp.threadLock)
-       stdcall1(_CloseHandle, mp.thread)
-       mp.thread = 0
+       if mp.thread != 0 {
+               stdcall1(_CloseHandle, mp.thread)
+               mp.thread = 0
+       }
+       unlock(&mp.threadLock)
+}
+
+// Called from exitm, but not from drop, to undo the effect of thread-owned
+// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
+//go:nosplit
+func mdestroy(mp *m) {
        if mp.highResTimer != 0 {
                stdcall1(_CloseHandle, mp.highResTimer)
                mp.highResTimer = 0
        }
-       unlock(&mp.threadLock)
+       if mp.waitsema != 0 {
+               stdcall1(_CloseHandle, mp.waitsema)
+               mp.waitsema = 0
+       }
+       if mp.resumesema != 0 {
+               stdcall1(_CloseHandle, mp.resumesema)
+               mp.resumesema = 0
+       }
 }
 
 // Calling stdcall on os stack.
@@ -1042,26 +1064,39 @@ func stdcall7(fn stdFunction, a0, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
        return stdcall(fn)
 }
 
-// In sys_windows_386.s and sys_windows_amd64.s.
-func onosstack(fn unsafe.Pointer, arg uint32)
-
-// These are not callable functions. They should only be called via onosstack.
-func usleep2(usec uint32)
-func usleep2HighRes(usec uint32)
+// These must run on the system stack only.
+func usleep2(dt int32)
+func usleep2HighRes(dt int32)
 func switchtothread()
 
-var usleep2Addr unsafe.Pointer
-var switchtothreadAddr unsafe.Pointer
+//go:nosplit
+func osyield_no_g() {
+       switchtothread()
+}
 
 //go:nosplit
 func osyield() {
-       onosstack(switchtothreadAddr, 0)
+       systemstack(switchtothread)
+}
+
+//go:nosplit
+func usleep_no_g(us uint32) {
+       dt := -10 * int32(us) // relative sleep (negative), 100ns units
+       usleep2(dt)
 }
 
 //go:nosplit
 func usleep(us uint32) {
-       // Have 1us units; want 100ns units.
-       onosstack(usleep2Addr, 10*us)
+       systemstack(func() {
+               dt := -10 * int32(us) // relative sleep (negative), 100ns units
+               // If the high-res timer is available and its handle has been allocated for this m, use it.
+               // Otherwise fall back to the low-res one, which doesn't need a handle.
+               if haveHighResTimer && getg().m.highResTimer != 0 {
+                       usleep2HighRes(dt)
+               } else {
+                       usleep2(dt)
+               }
+       })
 }
 
 func ctrlhandler1(_type uint32) uint32 {
@@ -1077,6 +1112,11 @@ func ctrlhandler1(_type uint32) uint32 {
        }
 
        if sigsend(s) {
+               if s == _SIGTERM {
+                       // Windows terminates the process after this handler returns.
+                       // Block indefinitely to give signal handlers a chance to clean up.
+                       stdcall1(_Sleep, uintptr(_INFINITE))
+               }
                return 1
        }
        return 0
@@ -1099,21 +1139,21 @@ func profilem(mp *m, thread uintptr) {
        c.contextflags = _CONTEXT_CONTROL
        stdcall2(_GetThreadContext, thread, uintptr(unsafe.Pointer(c)))
 
-       gp := gFromTLS(mp)
+       gp := gFromSP(mp, c.sp())
 
        sigprof(c.ip(), c.sp(), c.lr(), gp, mp)
 }
 
-func gFromTLS(mp *m) *g {
-       switch GOARCH {
-       case "arm":
-               tls := &mp.tls[0]
-               return **((***g)(unsafe.Pointer(tls)))
-       case "386", "amd64":
-               tls := &mp.tls[0]
-               return *((**g)(unsafe.Pointer(tls)))
+func gFromSP(mp *m, sp uintptr) *g {
+       if gp := mp.g0; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+               return gp
+       }
+       if gp := mp.gsignal; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+               return gp
+       }
+       if gp := mp.curg; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+               return gp
        }
-       throw("unsupported architecture")
        return nil
 }
 
@@ -1134,8 +1174,12 @@ func profileloop1(param uintptr) uint32 {
                        }
                        // Acquire our own handle to the thread.
                        var thread uintptr
-                       stdcall7(_DuplicateHandle, currentProcess, mp.thread, currentProcess, uintptr(unsafe.Pointer(&thread)), 0, 0, _DUPLICATE_SAME_ACCESS)
+                       if stdcall7(_DuplicateHandle, currentProcess, mp.thread, currentProcess, uintptr(unsafe.Pointer(&thread)), 0, 0, _DUPLICATE_SAME_ACCESS) == 0 {
+                               print("runtime.profileloop1: duplicatehandle failed; errno=", getlasterror(), "\n")
+                               throw("runtime.profileloop1: duplicatehandle failed")
+                       }
                        unlock(&mp.threadLock)
+
                        // mp may exit between the DuplicateHandle
                        // above and the SuspendThread. The handle
                        // will remain valid, but SuspendThread may
@@ -1180,14 +1224,14 @@ func setThreadCPUProfiler(hz int32) {
        atomic.Store((*uint32)(unsafe.Pointer(&getg().m.profilehz)), uint32(hz))
 }
 
-const preemptMSupported = GOARCH != "arm"
+const preemptMSupported = GOARCH == "386" || GOARCH == "amd64"
 
 // suspendLock protects simultaneous SuspendThread operations from
 // suspending each other.
 var suspendLock mutex
 
 func preemptM(mp *m) {
-       if GOARCH == "arm" {
+       if !preemptMSupported {
                // TODO: Implement call injection
                return
        }
@@ -1214,7 +1258,10 @@ func preemptM(mp *m) {
                return
        }
        var thread uintptr
-       stdcall7(_DuplicateHandle, currentProcess, mp.thread, currentProcess, uintptr(unsafe.Pointer(&thread)), 0, 0, _DUPLICATE_SAME_ACCESS)
+       if stdcall7(_DuplicateHandle, currentProcess, mp.thread, currentProcess, uintptr(unsafe.Pointer(&thread)), 0, 0, _DUPLICATE_SAME_ACCESS) == 0 {
+               print("runtime.preemptM: duplicatehandle failed; errno=", getlasterror(), "\n")
+               throw("runtime.preemptM: duplicatehandle failed")
+       }
        unlock(&mp.threadLock)
 
        // Prepare thread context buffer. This must be aligned to 16 bytes.
@@ -1255,7 +1302,7 @@ func preemptM(mp *m) {
        unlock(&suspendLock)
 
        // Does it want a preemption and is it safe to preempt?
-       gp := gFromTLS(mp)
+       gp := gFromSP(mp, c.sp())
        if wantAsyncPreempt(gp) {
                if ok, newpc := isAsyncSafePoint(gp, c.ip(), c.sp(), c.lr()); ok {
                        // Inject call to asyncPreempt

diff --git a/src/runtime/os_windows_arm64.go b/src/runtime/os_windows_arm64.go
new file mode 100644 (file)
index 0000000..7e41344
--- /dev/null
+++ b/src/runtime/os_windows_arm64.go
@@ -0,0 +1,14 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+//go:nosplit
+func cputicks() int64 {
+       var counter int64
+       stdcall1(_QueryPerformanceCounter, uintptr(unsafe.Pointer(&counter)))
+       return counter
+}

diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index aed17d6fc62bd5704559477e192ba22468a055e3..e320eaa59666d19f6549745fd823990867be9102 100644 (file)
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+       "internal/abi"
        "runtime/internal/atomic"
        "runtime/internal/sys"
        "unsafe"
@@ -874,7 +875,13 @@ func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
                p.pc = getcallerpc()
                p.sp = unsafe.Pointer(getcallersp())
        }
-       reflectcall(nil, fn, arg, argsize, argsize)
+       // Pass a dummy RegArgs for now since no function actually implements
+       // the register-based ABI.
+       //
+       // TODO(mknyszek): Implement this properly, setting up arguments in
+       // registers as necessary in the caller.
+       var regs abi.RegArgs
+       reflectcall(nil, fn, arg, argsize, argsize, argsize, &regs)
        if p != nil {
                p.pc = 0
                p.sp = unsafe.Pointer(nil)
@@ -968,7 +975,9 @@ func gopanic(e interface{}) {
                        }
                } else {
                        p.argp = unsafe.Pointer(getargp(0))
-                       reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
+
+                       var regs abi.RegArgs
+                       reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz), uint32(d.siz), &regs)
                }
                p.argp = nil
 
@@ -1000,37 +1009,42 @@ func gopanic(e interface{}) {
                        }
                        atomic.Xadd(&runningPanicDefers, -1)
 
-                       if done {
-                               // Remove any remaining non-started, open-coded
-                               // defer entries after a recover, since the
-                               // corresponding defers will be executed normally
-                               // (inline). Any such entry will become stale once
-                               // we run the corresponding defers inline and exit
-                               // the associated stack frame.
-                               d := gp._defer
-                               var prev *_defer
-                               for d != nil {
-                                       if d.openDefer {
-                                               if d.started {
-                                                       // This defer is started but we
-                                                       // are in the middle of a
-                                                       // defer-panic-recover inside of
-                                                       // it, so don't remove it or any
-                                                       // further defer entries
-                                                       break
-                                               }
-                                               if prev == nil {
-                                                       gp._defer = d.link
-                                               } else {
-                                                       prev.link = d.link
-                                               }
-                                               newd := d.link
-                                               freedefer(d)
-                                               d = newd
+                       // Remove any remaining non-started, open-coded
+                       // defer entries after a recover, since the
+                       // corresponding defers will be executed normally
+                       // (inline). Any such entry will become stale once
+                       // we run the corresponding defers inline and exit
+                       // the associated stack frame.
+                       d := gp._defer
+                       var prev *_defer
+                       if !done {
+                               // Skip our current frame, if not done. It is
+                               // needed to complete any remaining defers in
+                               // deferreturn()
+                               prev = d
+                               d = d.link
+                       }
+                       for d != nil {
+                               if d.started {
+                                       // This defer is started but we
+                                       // are in the middle of a
+                                       // defer-panic-recover inside of
+                                       // it, so don't remove it or any
+                                       // further defer entries
+                                       break
+                               }
+                               if d.openDefer {
+                                       if prev == nil {
+                                               gp._defer = d.link
                                        } else {
-                                               prev = d
-                                               d = d.link
+                                               prev.link = d.link
                                        }
+                                       newd := d.link
+                                       freedefer(d)
+                                       d = newd
+                               } else {
+                                       prev = d
+                                       d = d.link
                                }
                        }
 

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index b6ee160e847155eaf91705b6bdbce61cd2e5c481..d7571953a9bf45298fe9653ca8d338e503aeac68 100644 (file)
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -279,16 +279,12 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri
 
        broken := false
        switch runtime.GOOS {
-       case "darwin", "ios", "dragonfly", "netbsd", "illumos", "solaris":
+       case "ios", "dragonfly", "netbsd", "illumos", "solaris":
                broken = true
        case "openbsd":
                if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
                        broken = true
                }
-       case "windows":
-               if runtime.GOARCH == "arm" {
-                       broken = true // See https://golang.org/issues/42862
-               }
        }
 
        maxDuration := 5 * time.Second
@@ -514,8 +510,10 @@ func TestGoroutineSwitch(t *testing.T) {
                }
                StopCPUProfile()
 
-               // Read profile to look for entries for runtime.gogo with an attempt at a traceback.
-               // The special entry
+               // Read profile to look for entries for gogo with an attempt at a traceback.
+               // "runtime.gogo" is OK, because that's the part of the context switch
+               // before the actual switch begins. But we should not see "gogo",
+               // aka "gogo<>(SB)", which does the actual switch and is marked SPWRITE.
                parseProfile(t, prof.Bytes(), func(count uintptr, stk []*profile.Location, _ map[string][]string) {
                        // An entry with two frames with 'System' in its top frame
                        // exists to record a PC without a traceback. Those are okay.
@@ -526,13 +524,19 @@ func TestGoroutineSwitch(t *testing.T) {
                                }
                        }
 
-                       // Otherwise, should not see runtime.gogo.
+                       // An entry with just one frame is OK too:
+                       // it knew to stop at gogo.
+                       if len(stk) == 1 {
+                               return
+                       }
+
+                       // Otherwise, should not see gogo.
                        // The place we'd see it would be the inner most frame.
                        name := stk[0].Line[0].Function.Name
-                       if name == "runtime.gogo" {
+                       if name == "gogo" {
                                var buf bytes.Buffer
                                fprintStack(&buf, stk)
-                               t.Fatalf("found profile entry for runtime.gogo:\n%s", buf.String())
+                               t.Fatalf("found profile entry for gogo:\n%s", buf.String())
                        }
                })
        }

diff --git a/src/runtime/print.go b/src/runtime/print.go
index 64055a34ccde28488693c58b5c1503926fd16dc3..f15296cf024587f1b655ae7e75eb1103d1cb91d8 100644 (file)
--- a/src/runtime/print.go
+++ b/src/runtime/print.go
@@ -216,13 +216,15 @@ func printint(v int64) {
        printuint(uint64(v))
 }
 
+var minhexdigits = 0 // protected by printlock
+
 func printhex(v uint64) {
        const dig = "0123456789abcdef"
        var buf [100]byte
        i := len(buf)
        for i--; i > 0; i-- {
                buf[i] = dig[v%16]
-               if v < 16 {
+               if v < 16 && len(buf)-i >= minhexdigits {
                        break
                }
                v /= 16
@@ -265,29 +267,16 @@ func printiface(i iface) {
 // and should return a character mark to appear just before that
 // word's value. It can return 0 to indicate no mark.
 func hexdumpWords(p, end uintptr, mark func(uintptr) byte) {
-       p1 := func(x uintptr) {
-               var buf [2 * sys.PtrSize]byte
-               for i := len(buf) - 1; i >= 0; i-- {
-                       if x&0xF < 10 {
-                               buf[i] = byte(x&0xF) + '0'
-                       } else {
-                               buf[i] = byte(x&0xF) - 10 + 'a'
-                       }
-                       x >>= 4
-               }
-               gwrite(buf[:])
-       }
-
        printlock()
        var markbuf [1]byte
        markbuf[0] = ' '
+       minhexdigits = int(unsafe.Sizeof(uintptr(0)) * 2)
        for i := uintptr(0); p+i < end; i += sys.PtrSize {
                if i%16 == 0 {
                        if i != 0 {
                                println()
                        }
-                       p1(p + i)
-                       print(": ")
+                       print(hex(p+i), ": ")
                }
 
                if mark != nil {
@@ -298,15 +287,16 @@ func hexdumpWords(p, end uintptr, mark func(uintptr) byte) {
                }
                gwrite(markbuf[:])
                val := *(*uintptr)(unsafe.Pointer(p + i))
-               p1(val)
+               print(hex(val))
                print(" ")
 
                // Can we symbolize val?
                fn := findfunc(val)
                if fn.valid() {
-                       print("<", funcname(fn), "+", val-fn.entry, "> ")
+                       print("<", funcname(fn), "+", hex(val-fn.entry), "> ")
                }
        }
+       minhexdigits = 0
        println()
        printunlock()
 }

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 64e102fb0aa19aa19d5a18868b39a36b046eb6b4..dbb430fd259db9abcbb492bedea4fc0cbe2ecc48 100644 (file)
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -490,8 +490,29 @@ func lockedOSThread() bool {
 }
 
 var (
-       allgs    []*g
+       // allgs contains all Gs ever created (including dead Gs), and thus
+       // never shrinks.
+       //
+       // Access via the slice is protected by allglock or stop-the-world.
+       // Readers that cannot take the lock may (carefully!) use the atomic
+       // variables below.
        allglock mutex
+       allgs    []*g
+
+       // allglen and allgptr are atomic variables that contain len(allg) and
+       // &allg[0] respectively. Proper ordering depends on totally-ordered
+       // loads and stores. Writes are protected by allglock.
+       //
+       // allgptr is updated before allglen. Readers should read allglen
+       // before allgptr to ensure that allglen is always <= len(allgptr). New
+       // Gs appended during the race can be missed. For a consistent view of
+       // all Gs, allglock must be held.
+       //
+       // allgptr copies should always be stored as a concrete type or
+       // unsafe.Pointer, not uintptr, to ensure that GC can still reach it
+       // even if it points to a stale array.
+       allglen uintptr
+       allgptr **g
 )
 
 func allgadd(gp *g) {
@@ -501,10 +522,25 @@ func allgadd(gp *g) {
 
        lock(&allglock)
        allgs = append(allgs, gp)
-       allglen = uintptr(len(allgs))
+       if &allgs[0] != allgptr {
+               atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
+       }
+       atomic.Storeuintptr(&allglen, uintptr(len(allgs)))
        unlock(&allglock)
 }
 
+// atomicAllG returns &allgs[0] and len(allgs) for use with atomicAllGIndex.
+func atomicAllG() (**g, uintptr) {
+       length := atomic.Loaduintptr(&allglen)
+       ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
+       return ptr, length
+}
+
+// atomicAllGIndex returns ptr[i] with the allgptr returned from atomicAllG.
+func atomicAllGIndex(ptr **g, i uintptr) *g {
+       return *(**g)(add(unsafe.Pointer(ptr), i*sys.PtrSize))
+}
+
 const (
        // Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
        // 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
@@ -1170,8 +1206,38 @@ func startTheWorldWithSema(emitTraceEvent bool) int64 {
        return startTime
 }
 
+// usesLibcall indicates whether this runtime performs system calls
+// via libcall.
+func usesLibcall() bool {
+       switch GOOS {
+       case "aix", "darwin", "illumos", "ios", "solaris", "windows":
+               return true
+       case "openbsd":
+               return GOARCH == "amd64" || GOARCH == "arm64"
+       }
+       return false
+}
+
+// mStackIsSystemAllocated indicates whether this runtime starts on a
+// system-allocated stack.
+func mStackIsSystemAllocated() bool {
+       switch GOOS {
+       case "aix", "darwin", "plan9", "illumos", "ios", "solaris", "windows":
+               return true
+       case "openbsd":
+               switch GOARCH {
+               case "amd64", "arm64":
+                       return true
+               }
+       }
+       return false
+}
+
 // mstart is the entry-point for new Ms.
-//
+// It is written in assembly, marked TOPFRAME, and calls mstart0.
+func mstart()
+
+// mstart0 is the Go entry-point for new Ms.
 // This must not split the stack because we may not even have stack
 // bounds set up yet.
 //
@@ -1180,7 +1246,7 @@ func startTheWorldWithSema(emitTraceEvent bool) int64 {
 //
 //go:nosplit
 //go:nowritebarrierrec
-func mstart() {
+func mstart0() {
        _g_ := getg()
 
        osStack := _g_.stack.lo == 0
@@ -1188,6 +1254,11 @@ func mstart() {
                // Initialize stack bounds from system stack.
                // Cgo may have left stack size in stack.hi.
                // minit may update the stack bounds.
+               //
+               // Note: these bounds may not be very accurate.
+               // We set hi to &size, but there are things above
+               // it. The 1024 is supposed to compensate this,
+               // but is somewhat arbitrary.
                size := _g_.stack.hi
                if size == 0 {
                        size = 8192 * sys.StackGuardMultiplier
@@ -1204,8 +1275,7 @@ func mstart() {
        mstart1()
 
        // Exit this thread.
-       switch GOOS {
-       case "windows", "solaris", "illumos", "plan9", "darwin", "ios", "aix":
+       if mStackIsSystemAllocated() {
                // Windows, Solaris, illumos, Darwin, AIX and Plan 9 always system-allocate
                // the stack, but put it in _g_.stack before mstart,
                // so the logic above hasn't set osStack yet.
@@ -1214,6 +1284,9 @@ func mstart() {
        mexit(osStack)
 }
 
+// The go:noinline is to guarantee the getcallerpc/getcallersp below are safe,
+// so that we can set up g0.sched to return to the call of mstart1 above.
+//go:noinline
 func mstart1() {
        _g_ := getg()
 
@@ -1221,11 +1294,16 @@ func mstart1() {
                throw("bad runtime·mstart")
        }
 
-       // Record the caller for use as the top of stack in mcall and
-       // for terminating the thread.
+       // Set up m.g0.sched as a label returning returning to just
+       // after the mstart1 call in mstart0 above, for use by goexit0 and mcall.
        // We're never coming back to mstart1 after we call schedule,
        // so other calls can reuse the current frame.
-       save(getcallerpc(), getcallersp())
+       // And goexit0 does a gogo that needs to return from mstart1
+       // and let mstart0 exit the thread.
+       _g_.sched.g = guintptr(unsafe.Pointer(_g_))
+       _g_.sched.pc = getcallerpc()
+       _g_.sched.sp = getcallersp()
+
        asminit()
        minit()
 
@@ -1313,7 +1391,7 @@ func mexit(osStack bool) {
                throw("locked m0 woke up")
        }
 
-       sigblock()
+       sigblock(true)
        unminit()
 
        // Free the gsignal stack.
@@ -1371,6 +1449,10 @@ found:
                }
        }
 
+       // Destroy all allocated resources. After this is called, we may no
+       // longer take any locks.
+       mdestroy(m)
+
        if osStack {
                // Return from mstart and let the system thread
                // library free the g0 stack and terminate the thread.
@@ -1515,6 +1597,7 @@ func syscall_runtime_doAllThreadsSyscall(fn func(bool) bool) {
        if netpollinited() {
                netpollBreak()
        }
+       sigRecvPrepareForFixup()
        _g_ := getg()
        if raceenabled {
                // For m's running without racectx, we loan out the
@@ -1683,7 +1766,7 @@ func allocm(_p_ *p, fn func(), id int64) *m {
 
        // In case of cgo or Solaris or illumos or Darwin, pthread_create will make us a stack.
        // Windows and Plan 9 will layout sched stack on OS stack.
-       if iscgo || GOOS == "solaris" || GOOS == "illumos" || GOOS == "windows" || GOOS == "plan9" || GOOS == "darwin" || GOOS == "ios" {
+       if iscgo || mStackIsSystemAllocated() {
                mp.g0 = malg(-1)
        } else {
                mp.g0 = malg(8192 * sys.StackGuardMultiplier)
@@ -1754,7 +1837,7 @@ func needm() {
        // starting a new m to run Go code via newosproc.
        var sigmask sigset
        sigsave(&sigmask)
-       sigblock()
+       sigblock(false)
 
        // Lock extra list, take head, unlock popped list.
        // nilokay=false is safe here because of the invariant above,
@@ -1828,7 +1911,7 @@ func oneNewExtraM() {
        gp := malg(4096)
        gp.sched.pc = funcPC(goexit) + sys.PCQuantum
        gp.sched.sp = gp.stack.hi
-       gp.sched.sp -= 4 * sys.RegSize // extra space in case of reads slightly beyond frame
+       gp.sched.sp -= 4 * sys.PtrSize // extra space in case of reads slightly beyond frame
        gp.sched.lr = 0
        gp.sched.g = guintptr(unsafe.Pointer(gp))
        gp.syscallpc = gp.sched.pc
@@ -1903,7 +1986,7 @@ func dropm() {
        // Setg(nil) clears g, which is the signal handler's cue not to run Go handlers.
        // It's important not to try to handle a signal between those two steps.
        sigmask := mp.sigmask
-       sigblock()
+       sigblock(false)
        unminit()
 
        mnext := lockextra(true)
@@ -1940,7 +2023,7 @@ func lockextra(nilokay bool) *m {
        for {
                old := atomic.Loaduintptr(&extram)
                if old == locked {
-                       osyield()
+                       osyield_no_g()
                        continue
                }
                if old == 0 && !nilokay {
@@ -1951,13 +2034,13 @@ func lockextra(nilokay bool) *m {
                                atomic.Xadd(&extraMWaiters, 1)
                                incr = true
                        }
-                       usleep(1)
+                       usleep_no_g(1)
                        continue
                }
                if atomic.Casuintptr(&extram, old, locked) {
                        return (*m)(unsafe.Pointer(old))
                }
-               osyield()
+               osyield_no_g()
                continue
        }
 }
@@ -2882,7 +2965,9 @@ func wakeNetPoller(when int64) {
        } else {
                // There are no threads in the network poller, try to get
                // one there so it can handle new timers.
-               wakep()
+               if GOOS != "plan9" { // Temporary workaround - see issue #42303.
+                       wakep()
+               }
        }
 }
 
@@ -3371,11 +3456,19 @@ func goexit0(gp *g) {
 func save(pc, sp uintptr) {
        _g_ := getg()
 
+       if _g_ == _g_.m.g0 || _g_ == _g_.m.gsignal {
+               // m.g0.sched is special and must describe the context
+               // for exiting the thread. mstart1 writes to it directly.
+               // m.gsignal.sched should not be used at all.
+               // This check makes sure save calls do not accidentally
+               // run in contexts where they'd write to system g's.
+               throw("save on system g not allowed")
+       }
+
        _g_.sched.pc = pc
        _g_.sched.sp = sp
        _g_.sched.lr = 0
        _g_.sched.ret = 0
-       _g_.sched.g = guintptr(unsafe.Pointer(_g_))
        // We need to ensure ctxt is zero, but can't have a write
        // barrier here. However, it should always already be zero.
        // Assert that.
@@ -3389,7 +3482,7 @@ func save(pc, sp uintptr) {
 // This is called only from the go syscall library and cgocall,
 // not from the low-level system calls used by the runtime.
 //
-// Entersyscall cannot split the stack: the gosave must
+// Entersyscall cannot split the stack: the save must
 // make g->sched refer to the caller's stack segment, because
 // entersyscall is going to return immediately after.
 //
@@ -3774,7 +3867,7 @@ func beforefork() {
        // group. See issue #18600.
        gp.m.locks++
        sigsave(&gp.m.sigmask)
-       sigblock()
+       sigblock(false)
 
        // This function is called before fork in syscall package.
        // Code between fork and exec must not allocate memory nor even try to grow stack.
@@ -3935,9 +4028,9 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
 
        // We could allocate a larger initial stack if necessary.
        // Not worth it: this is almost always an error.
-       // 4*sizeof(uintreg): extra space added below
-       // sizeof(uintreg): caller's LR (arm) or return address (x86, in gostartcall).
-       if siz >= _StackMin-4*sys.RegSize-sys.RegSize {
+       // 4*PtrSize: extra space added below
+       // PtrSize: caller's LR (arm) or return address (x86, in gostartcall).
+       if siz >= _StackMin-4*sys.PtrSize-sys.PtrSize {
                throw("newproc: function arguments too large for new goroutine")
        }
 
@@ -3956,8 +4049,8 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
                throw("newproc1: new g is not Gdead")
        }
 
-       totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
-       totalSize += -totalSize & (sys.SpAlign - 1)                  // align to spAlign
+       totalSize := 4*sys.PtrSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
+       totalSize += -totalSize & (sys.StackAlign - 1)               // align to StackAlign
        sp := newg.stack.hi - totalSize
        spArg := sp
        if usesLR {
@@ -4263,7 +4356,7 @@ func badunlockosthread() {
 }
 
 func gcount() int32 {
-       n := int32(allglen) - sched.gFree.n - int32(atomic.Load(&sched.ngsys))
+       n := int32(atomic.Loaduintptr(&allglen)) - sched.gFree.n - int32(atomic.Load(&sched.ngsys))
        for _, _p_ := range allp {
                n -= _p_.gFree.n
        }
@@ -4330,75 +4423,6 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
        // See golang.org/issue/17165.
        getg().m.mallocing++
 
-       // Define that a "user g" is a user-created goroutine, and a "system g"
-       // is one that is m->g0 or m->gsignal.
-       //
-       // We might be interrupted for profiling halfway through a
-       // goroutine switch. The switch involves updating three (or four) values:
-       // g, PC, SP, and (on arm) LR. The PC must be the last to be updated,
-       // because once it gets updated the new g is running.
-       //
-       // When switching from a user g to a system g, LR is not considered live,
-       // so the update only affects g, SP, and PC. Since PC must be last, there
-       // the possible partial transitions in ordinary execution are (1) g alone is updated,
-       // (2) both g and SP are updated, and (3) SP alone is updated.
-       // If SP or g alone is updated, we can detect the partial transition by checking
-       // whether the SP is within g's stack bounds. (We could also require that SP
-       // be changed only after g, but the stack bounds check is needed by other
-       // cases, so there is no need to impose an additional requirement.)
-       //
-       // There is one exceptional transition to a system g, not in ordinary execution.
-       // When a signal arrives, the operating system starts the signal handler running
-       // with an updated PC and SP. The g is updated last, at the beginning of the
-       // handler. There are two reasons this is okay. First, until g is updated the
-       // g and SP do not match, so the stack bounds check detects the partial transition.
-       // Second, signal handlers currently run with signals disabled, so a profiling
-       // signal cannot arrive during the handler.
-       //
-       // When switching from a system g to a user g, there are three possibilities.
-       //
-       // First, it may be that the g switch has no PC update, because the SP
-       // either corresponds to a user g throughout (as in asmcgocall)
-       // or because it has been arranged to look like a user g frame
-       // (as in cgocallback). In this case, since the entire
-       // transition is a g+SP update, a partial transition updating just one of
-       // those will be detected by the stack bounds check.
-       //
-       // Second, when returning from a signal handler, the PC and SP updates
-       // are performed by the operating system in an atomic update, so the g
-       // update must be done before them. The stack bounds check detects
-       // the partial transition here, and (again) signal handlers run with signals
-       // disabled, so a profiling signal cannot arrive then anyway.
-       //
-       // Third, the common case: it may be that the switch updates g, SP, and PC
-       // separately. If the PC is within any of the functions that does this,
-       // we don't ask for a traceback. C.F. the function setsSP for more about this.
-       //
-       // There is another apparently viable approach, recorded here in case
-       // the "PC within setsSP function" check turns out not to be usable.
-       // It would be possible to delay the update of either g or SP until immediately
-       // before the PC update instruction. Then, because of the stack bounds check,
-       // the only problematic interrupt point is just before that PC update instruction,
-       // and the sigprof handler can detect that instruction and simulate stepping past
-       // it in order to reach a consistent state. On ARM, the update of g must be made
-       // in two places (in R10 and also in a TLS slot), so the delayed update would
-       // need to be the SP update. The sigprof handler must read the instruction at
-       // the current PC and if it was the known instruction (for example, JMP BX or
-       // MOV R2, PC), use that other register in place of the PC value.
-       // The biggest drawback to this solution is that it requires that we can tell
-       // whether it's safe to read from the memory pointed at by PC.
-       // In a correct program, we can test PC == nil and otherwise read,
-       // but if a profiling signal happens at the instant that a program executes
-       // a bad jump (before the program manages to handle the resulting fault)
-       // the profiling handler could fault trying to read nonexistent memory.
-       //
-       // To recap, there are no constraints on the assembly being used for the
-       // transition. We simply require that g and SP match and that the PC is not
-       // in gogo.
-       traceback := true
-       if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
-               traceback = false
-       }
        var stk [maxCPUProfStack]uintptr
        n := 0
        if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
@@ -4421,7 +4445,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
                if n > 0 {
                        n += cgoOff
                }
-       } else if traceback {
+       } else {
                n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
        }
 
@@ -4429,7 +4453,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
                // Normal traceback is impossible or has failed.
                // See if it falls into several common cases.
                n = 0
-               if (GOOS == "windows" || GOOS == "solaris" || GOOS == "illumos" || GOOS == "darwin" || GOOS == "ios" || GOOS == "aix") && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 {
+               if usesLibcall() && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 {
                        // Libcall, i.e. runtime syscall on windows.
                        // Collect Go stack that leads to the call.
                        n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0)
@@ -4500,30 +4524,6 @@ func sigprofNonGoPC(pc uintptr) {
        }
 }
 
-// Reports whether a function will set the SP
-// to an absolute value. Important that
-// we don't traceback when these are at the bottom
-// of the stack since we can't be sure that we will
-// find the caller.
-//
-// If the function is not on the bottom of the stack
-// we assume that it will have set it up so that traceback will be consistent,
-// either by being a traceback terminating function
-// or putting one on the stack at the right offset.
-func setsSP(pc uintptr) bool {
-       f := findfunc(pc)
-       if !f.valid() {
-               // couldn't find the function for this PC,
-               // so assume the worst and stop traceback
-               return true
-       }
-       switch f.funcID {
-       case funcID_gogo, funcID_systemstack, funcID_mcall, funcID_morestack:
-               return true
-       }
-       return false
-}
-
 // setcpuprofilerate sets the CPU profiling rate to hz times per second.
 // If hz <= 0, setcpuprofilerate turns off CPU profiling.
 func setcpuprofilerate(hz int32) {
@@ -4967,7 +4967,6 @@ func checkdead() {
                case _Grunnable,
                        _Grunning,
                        _Gsyscall:
-                       unlock(&allglock)
                        print("runtime: checkdead: find g ", gp.goid, " in status ", s, "\n")
                        throw("checkdead: runnable g")
                }
@@ -5128,6 +5127,26 @@ func sysmon() {
                        }
                }
                mDoFixup()
+               if GOOS == "netbsd" {
+                       // netpoll is responsible for waiting for timer
+                       // expiration, so we typically don't have to worry
+                       // about starting an M to service timers. (Note that
+                       // sleep for timeSleepUntil above simply ensures sysmon
+                       // starts running again when that timer expiration may
+                       // cause Go code to run again).
+                       //
+                       // However, netbsd has a kernel bug that sometimes
+                       // misses netpollBreak wake-ups, which can lead to
+                       // unbounded delays servicing timers. If we detect this
+                       // overrun, then startm to get something to handle the
+                       // timer.
+                       //
+                       // See issue 42515 and
+                       // https://gnats.netbsd.org/cgi-bin/query-pr-single.pl?number=50094.
+                       if next, _ := timeSleepUntil(); next < now {
+                               startm(nil, false)
+                       }
+               }
                if atomic.Load(&scavenge.sysmonWake) != 0 {
                        // Kick the scavenger awake if someone requested it.
                        wakeScavenger()

diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index 986667332f37fcef6b4b967d344785dfe5d4b20c..17dc32013f3ee5bbc4c1b29ebb72227710e94b89 100644 (file)
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -7,6 +7,7 @@
 package race_test
 
 import (
+       "fmt"
        "internal/testenv"
        "os"
        "os/exec"
@@ -71,9 +72,24 @@ func TestOutput(t *testing.T) {
                        "GORACE="+test.gorace,
                )
                got, _ := cmd.CombinedOutput()
-               if !regexp.MustCompile(test.re).MatchString(string(got)) {
-                       t.Fatalf("failed test case %v, expect:\n%v\ngot:\n%s",
-                               test.name, test.re, got)
+               matched := false
+               for _, re := range test.re {
+                       if regexp.MustCompile(re).MatchString(string(got)) {
+                               matched = true
+                               break
+                       }
+               }
+               if !matched {
+                       exp := fmt.Sprintf("expect:\n%v\n", test.re[0])
+                       if len(test.re) > 1 {
+                               exp = fmt.Sprintf("expected one of %d patterns:\n",
+                                       len(test.re))
+                               for k, re := range test.re {
+                                       exp += fmt.Sprintf("pattern %d:\n%v\n", k, re)
+                               }
+                       }
+                       t.Fatalf("failed test case %v, %sgot:\n%s",
+                               test.name, exp, got)
                }
        }
 }
@@ -84,7 +100,7 @@ var tests = []struct {
        goos   string
        gorace string
        source string
-       re     string
+       re     []string
 }{
        {"simple", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -107,7 +123,7 @@ func racer(x *int, done chan bool) {
        store(x, 42)
        done <- true
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Write at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.store\(\)
@@ -129,7 +145,7 @@ Goroutine [0-9] \(running\) created at:
 ==================
 Found 1 data race\(s\)
 exit status 66
-`},
+`}},
 
        {"exitcode", "run", "", "atexit_sleep_ms=0 exitcode=13", `
 package main
@@ -143,7 +159,7 @@ func main() {
        x = 43
        <-done
 }
-`, `exit status 13`},
+`, []string{`exit status 13`}},
 
        {"strip_path_prefix", "run", "", "atexit_sleep_ms=0 strip_path_prefix=/main.", `
 package main
@@ -157,9 +173,9 @@ func main() {
        x = 43
        <-done
 }
-`, `
+`, []string{`
       go:7 \+0x[0-9,a-f]+
-`},
+`}},
 
        {"halt_on_error", "run", "", "atexit_sleep_ms=0 halt_on_error=1", `
 package main
@@ -173,10 +189,10 @@ func main() {
        x = 43
        <-done
 }
-`, `
+`, []string{`
 ==================
 exit status 66
-`},
+`}},
 
        {"test_fails_on_race", "test", "", "atexit_sleep_ms=0", `
 package main_test
@@ -193,12 +209,12 @@ func TestFail(t *testing.T) {
        <-done
        t.Log(t.Failed())
 }
-`, `
+`, []string{`
 ==================
 --- FAIL: TestFail \(0...s\)
 .*main_test.go:14: true
 .*testing.go:.*: race detected during execution of test
-FAIL`},
+FAIL`}},
 
        {"slicebytetostring_pc", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -211,11 +227,11 @@ func main() {
        data[0] = 1
        <-done
 }
-`, `
+`, []string{`
   runtime\.slicebytetostring\(\)
       .*/runtime/string\.go:.*
   main\.main\.func1\(\)
-      .*/main.go:7`},
+      .*/main.go:7`}},
 
        // Test for https://golang.org/issue/33309
        {"midstack_inlining_traceback", "run", "linux", "atexit_sleep_ms=0", `
@@ -241,7 +257,7 @@ func g(c chan int) {
 func h(c chan int) {
        c <- x
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Read at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.h\(\)
@@ -261,7 +277,7 @@ Goroutine [0-9] \(running\) created at:
 ==================
 Found 1 data race\(s\)
 exit status 66
-`},
+`}},
 
        // Test for https://golang.org/issue/17190
        {"external_cgo_thread", "run", "linux", "atexit_sleep_ms=0", `
@@ -284,22 +300,23 @@ static inline void startThread(cb* c) {
 */
 import "C"
 
-import "time"
-
+var done chan bool
 var racy int
 
 //export goCallback
 func goCallback() {
        racy++
+       done <- true
 }
 
 func main() {
+       done = make(chan bool)
        var c C.cb
        C.startThread(&c)
-       time.Sleep(time.Second)
        racy++
+       <- done
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Read at 0x[0-9,a-f]+ by main goroutine:
   main\.main\(\)
@@ -310,11 +327,27 @@ Previous write at 0x[0-9,a-f]+ by goroutine [0-9]:
       .*/main\.go:27 \+0x[0-9,a-f]+
   _cgoexp_[0-9a-z]+_goCallback\(\)
       .*_cgo_gotypes\.go:[0-9]+ \+0x[0-9,a-f]+
+  _cgoexp_[0-9a-z]+_goCallback\(\)
+      <autogenerated>:1 \+0x[0-9,a-f]+
+
+Goroutine [0-9] \(running\) created at:
+  runtime\.newextram\(\)
+      .*/runtime/proc.go:[0-9]+ \+0x[0-9,a-f]+
+==================`,
+               `==================
+WARNING: DATA RACE
+Read at 0x[0-9,a-f]+ by .*:
+  main\..*
+      .*/main\.go:[0-9]+ \+0x[0-9,a-f]+(?s).*
+
+Previous write at 0x[0-9,a-f]+ by .*:
+  main\..*
+      .*/main\.go:[0-9]+ \+0x[0-9,a-f]+(?s).*
 
 Goroutine [0-9] \(running\) created at:
   runtime\.newextram\(\)
       .*/runtime/proc.go:[0-9]+ \+0x[0-9,a-f]+
-==================`},
+==================`}},
        {"second_test_passes", "test", "", "atexit_sleep_ms=0", `
 package main_test
 import "testing"
@@ -332,11 +365,11 @@ func TestFail(t *testing.T) {
 
 func TestPass(t *testing.T) {
 }
-`, `
+`, []string{`
 ==================
 --- FAIL: TestFail \(0...s\)
 .*testing.go:.*: race detected during execution of test
-FAIL`},
+FAIL`}},
        {"mutex", "run", "", "atexit_sleep_ms=0", `
 package main
 import (
@@ -367,7 +400,7 @@ func main() {
        }
        wg.Wait()
        if (data == iterations*(threads+1)) { fmt.Println("pass") }
-}`, `pass`},
+}`, []string{`pass`}},
        // Test for https://github.com/golang/go/issues/37355
        {"chanmm", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -396,7 +429,7 @@ func main() {
        wg.Wait()
        _ = data
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Write at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.main\.func2\(\)
@@ -409,5 +442,5 @@ Previous write at 0x[0-9,a-f]+ by main goroutine:
 Goroutine [0-9] \(running\) created at:
   main\.main\(\)
       .*/main.go:[0-9]+ \+0x[0-9,a-f]+
-==================`},
+==================`}},
 }

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 9818bc6ddff97e2366c80fb89cc4e4b3f2362c75..c3b7bbfbfe2e8084780fa123c1b326252705a362 100644 (file)
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -146,8 +146,10 @@ TEXT       runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 // If addr (RARG1) is out of range, do nothing.
 // Otherwise, setup goroutine context and invoke racecall. Other arguments already set.
 TEXT   racecalladdr<>(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_racectx(R14), RARG0   // goroutine context
        // Check that addr is within [arenastart, arenaend) or within [racedatastart, racedataend).
        CMPQ    RARG1, runtime·racearenastart(SB)
@@ -183,8 +185,10 @@ TEXT       runtime·racefuncenter(SB), NOSPLIT, $0-8
 // R11 = caller's return address
 TEXT   racefuncenter<>(SB), NOSPLIT, $0-0
        MOVQ    DX, R15         // save function entry context (for closures)
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_racectx(R14), RARG0   // goroutine context
        MOVQ    R11, RARG1
        // void __tsan_func_enter(ThreadState *thr, void *pc);
@@ -197,8 +201,10 @@ TEXT       racefuncenter<>(SB), NOSPLIT, $0-0
 // func runtime·racefuncexit()
 // Called from instrumented code.
 TEXT   runtime·racefuncexit(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_racectx(R14), RARG0   // goroutine context
        // void __tsan_func_exit(ThreadState *thr);
        MOVQ    $__tsan_func_exit(SB), AX
@@ -357,8 +363,10 @@ racecallatomic_data:
        JAE     racecallatomic_ignore
 racecallatomic_ok:
        // Addr is within the good range, call the atomic function.
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_racectx(R14), RARG0   // goroutine context
        MOVQ    8(SP), RARG1    // caller pc
        MOVQ    (SP), RARG2     // pc
@@ -370,8 +378,10 @@ racecallatomic_ignore:
        // An attempt to synchronize on the address would cause crash.
        MOVQ    AX, R15 // remember the original function
        MOVQ    $__tsan_go_ignore_sync_begin(SB), AX
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_racectx(R14), RARG0   // goroutine context
        CALL    racecall<>(SB)
        MOVQ    R15, AX // restore the original function
@@ -399,8 +409,10 @@ TEXT       runtime·racecall(SB), NOSPLIT, $0-0
 
 // Switches SP to g0 stack and calls (AX). Arguments already set.
 TEXT   racecall<>(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
        get_tls(R12)
        MOVQ    g(R12), R14
+#endif
        MOVQ    g_m(R14), R13
        // Switch to g0 stack.
        MOVQ    SP, R12         // callee-saved, preserved across the CALL
@@ -412,6 +424,9 @@ call:
        ANDQ    $~15, SP        // alignment for gcc ABI
        CALL    AX
        MOVQ    R12, SP
+       // Back to Go world, set special registers.
+       // The g register (R14) is preserved in C.
+       XORPS   X15, X15
        RET
 
 // C->Go callback thunk that allows to call runtime·racesymbolize from C code.
@@ -419,7 +434,9 @@ call:
 // The overall effect of Go->C->Go call chain is similar to that of mcall.
 // RARG0 contains command code. RARG1 contains command-specific context.
 // See racecallback for command codes.
-TEXT   runtime·racecallbackthunk(SB), NOSPLIT, $56-8
+// Defined as ABIInternal so as to avoid introducing a wrapper,
+// because its address is passed to C via funcPC.
+TEXT   runtime·racecallbackthunk<ABIInternal>(SB), NOSPLIT, $56-8
        // Handle command raceGetProcCmd (0) here.
        // First, code below assumes that we are on curg, while raceGetProcCmd
        // can be executed on g0. Second, it is called frequently, so will
@@ -447,12 +464,13 @@ rest:
        PUSHQ   R15
        // Set g = g0.
        get_tls(R12)
-       MOVQ    g(R12), R13
-       MOVQ    g_m(R13), R14
-       MOVQ    m_g0(R14), R15
+       MOVQ    g(R12), R14
+       MOVQ    g_m(R14), R13
+       MOVQ    m_g0(R13), R15
        CMPQ    R13, R15
        JEQ     noswitch        // branch if already on g0
        MOVQ    R15, g(R12)     // g = m->g0
+       MOVQ    R15, R14        // set g register
        PUSHQ   RARG1   // func arg
        PUSHQ   RARG0   // func arg
        CALL    runtime·racecallback(SB)

diff --git a/src/runtime/rt0_windows_arm64.s b/src/runtime/rt0_windows_arm64.s
new file mode 100644 (file)
index 0000000..1e71a06
--- /dev/null
+++ b/src/runtime/rt0_windows_arm64.s
@@ -0,0 +1,12 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+// This is the entry point for the program from the
+// kernel for an ordinary -buildmode=exe program.
+TEXT _rt0_arm64_windows(SB),NOSPLIT|NOFRAME,$0
+       B       ·rt0_go(SB)

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index c9376827da14ac15aa7f9d704f0b4bac67ba346e..5bd283d12f349a8842a8dd70bf719da799ed3418 100644 (file)
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -327,7 +327,7 @@ type gobuf struct {
        pc   uintptr
        g    guintptr
        ctxt unsafe.Pointer
-       ret  sys.Uintreg
+       ret  uintptr
        lr   uintptr
        bp   uintptr // for framepointer-enabled architectures
 }
@@ -833,10 +833,11 @@ type _func struct {
        pcfile    uint32
        pcln      uint32
        npcdata   uint32
-       cuOffset  uint32  // runtime.cutab offset of this function's CU
-       funcID    funcID  // set for certain special runtime functions
-       _         [2]byte // pad
-       nfuncdata uint8   // must be last
+       cuOffset  uint32 // runtime.cutab offset of this function's CU
+       funcID    funcID // set for certain special runtime functions
+       flag      funcFlag
+       _         [1]byte // pad
+       nfuncdata uint8   // must be last, must end on a uint32-aligned boundary
 }
 
 // Pseudo-Func that is returned for PCs that occur in inlined code.
@@ -853,7 +854,7 @@ type funcinl struct {
 // layout of Itab known to compilers
 // allocated in non-garbage-collected memory
 // Needs to be in sync with
-// ../cmd/compile/internal/gc/reflect.go:/^func.dumptabs.
+// ../cmd/compile/internal/gc/reflect.go:/^func.WriteTabs.
 type itab struct {
        inter *interfacetype
        _type *_type
@@ -1052,7 +1053,6 @@ func (w waitReason) String() string {
 }
 
 var (
-       allglen    uintptr
        allm       *m
        gomaxprocs int32
        ncpu       int32
@@ -1106,4 +1106,4 @@ var (
 )
 
 // Must agree with cmd/internal/objabi.Framepointer_enabled.
-const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "ios")
+const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"

diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go
index e5d2d97d05f184a14e0cd9ab96ff9fc93c9f9d2d..4572a25195d3e6fbf3843f09762b1032213c3db6 100644 (file)
--- a/src/runtime/runtime_test.go
+++ b/src/runtime/runtime_test.go
@@ -266,8 +266,8 @@ func TestTrailingZero(t *testing.T) {
                n int64
                z struct{}
        }
-       if unsafe.Sizeof(T2{}) != 8+unsafe.Sizeof(Uintreg(0)) {
-               t.Errorf("sizeof(%#v)==%d, want %d", T2{}, unsafe.Sizeof(T2{}), 8+unsafe.Sizeof(Uintreg(0)))
+       if unsafe.Sizeof(T2{}) != 8+unsafe.Sizeof(uintptr(0)) {
+               t.Errorf("sizeof(%#v)==%d, want %d", T2{}, unsafe.Sizeof(T2{}), 8+unsafe.Sizeof(uintptr(0)))
        }
        type T3 struct {
                n byte

diff --git a/src/runtime/signal_amd64.go b/src/runtime/signal_amd64.go
index 6ab1f758c2293542396062811536109be2964ccb..3eeb5e044ff0ff1c5cae3d43ca064dda5b37dde1 100644 (file)
--- a/src/runtime/signal_amd64.go
+++ b/src/runtime/signal_amd64.go
@@ -65,11 +65,14 @@ func (c *sigctxt) preparePanic(sig uint32, gp *g) {
        pc := uintptr(c.rip())
        sp := uintptr(c.rsp())
 
+       // In case we are panicking from external code, we need to initialize
+       // Go special registers. We inject sigpanic0 (instead of sigpanic),
+       // which takes care of that.
        if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
-               c.pushCall(funcPC(sigpanic), pc)
+               c.pushCall(funcPC(sigpanic0), pc)
        } else {
                // Not safe to push the call. Just clobber the frame.
-               c.set_rip(uint64(funcPC(sigpanic)))
+               c.set_rip(uint64(funcPC(sigpanic0)))
        }
 }
 

diff --git a/src/runtime/signal_arm64.go b/src/runtime/signal_arm64.go
index 3c20139c99fdb5ae7a56f6f680c1df18000ff2cc..b559b93938849a95e1a89de6404262df6ccb2d01 100644 (file)
--- a/src/runtime/signal_arm64.go
+++ b/src/runtime/signal_arm64.go
@@ -63,7 +63,7 @@ func (c *sigctxt) preparePanic(sig uint32, gp *g) {
        // functions are correctly handled. This smashes
        // the stack frame but we're not going back there
        // anyway.
-       sp := c.sp() - sys.SpAlign // needs only sizeof uint64, but must align the stack
+       sp := c.sp() - sys.StackAlign // needs only sizeof uint64, but must align the stack
        c.set_sp(sp)
        *(*uint64)(unsafe.Pointer(uintptr(sp))) = c.lr()
 

diff --git a/src/runtime/signal_openbsd.go b/src/runtime/signal_openbsd.go
index 99c601ce58a0cfa6cbec4de952513d7408c1a27c..d2c5c5e39a01b34fb9252b9b70cbf62c7e5b204d 100644 (file)
--- a/src/runtime/signal_openbsd.go
+++ b/src/runtime/signal_openbsd.go
@@ -37,5 +37,5 @@ var sigtable = [...]sigTabT{
        /* 29 */ {_SigNotify, "SIGINFO: status request from keyboard"},
        /* 30 */ {_SigNotify, "SIGUSR1: user-defined signal 1"},
        /* 31 */ {_SigNotify, "SIGUSR2: user-defined signal 2"},
-       /* 32 */ {_SigNotify, "SIGTHR: reserved"},
+       /* 32 */ {0, "SIGTHR: reserved"}, // thread AST - cannot be registered.
 }

diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index e8f39c3321f9272cccc5a3cb9a3a38d72f13f526..3f70707ab4e3697655aa73a79c03b8d7bbe6f7f1 100644 (file)
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -475,6 +475,14 @@ func adjustSignalStack(sig uint32, mp *m, gsigStack *gsignalStack) bool {
                return false
        }
 
+       var st stackt
+       sigaltstack(nil, &st)
+       stsp := uintptr(unsafe.Pointer(st.ss_sp))
+       if st.ss_flags&_SS_DISABLE == 0 && sp >= stsp && sp < stsp+st.ss_size {
+               setGsignalStack(&st, gsigStack)
+               return true
+       }
+
        if sp >= mp.g0.stack.lo && sp < mp.g0.stack.hi {
                // The signal was delivered on the g0 stack.
                // This can happen when linked with C code
@@ -483,29 +491,25 @@ func adjustSignalStack(sig uint32, mp *m, gsigStack *gsignalStack) bool {
                // the signal handler directly when C code,
                // including C code called via cgo, calls a
                // TSAN-intercepted function such as malloc.
+               //
+               // We check this condition last as g0.stack.lo
+               // may be not very accurate (see mstart).
                st := stackt{ss_size: mp.g0.stack.hi - mp.g0.stack.lo}
                setSignalstackSP(&st, mp.g0.stack.lo)
                setGsignalStack(&st, gsigStack)
                return true
        }
 
-       var st stackt
-       sigaltstack(nil, &st)
+       // sp is not within gsignal stack, g0 stack, or sigaltstack. Bad.
+       setg(nil)
+       needm()
        if st.ss_flags&_SS_DISABLE != 0 {
-               setg(nil)
-               needm()
                noSignalStack(sig)
-               dropm()
-       }
-       stsp := uintptr(unsafe.Pointer(st.ss_sp))
-       if sp < stsp || sp >= stsp+st.ss_size {
-               setg(nil)
-               needm()
+       } else {
                sigNotOnStack(sig)
-               dropm()
        }
-       setGsignalStack(&st, gsigStack)
-       return true
+       dropm()
+       return false
 }
 
 // crashing is the number of m's we have waited for when implementing
@@ -1042,15 +1046,26 @@ func msigrestore(sigmask sigset) {
        sigprocmask(_SIG_SETMASK, &sigmask, nil)
 }
 
-// sigblock blocks all signals in the current thread's signal mask.
+// sigsetAllExiting is used by sigblock(true) when a thread is
+// exiting. sigset_all is defined in OS specific code, and per GOOS
+// behavior may override this default for sigsetAllExiting: see
+// osinit().
+var sigsetAllExiting = sigset_all
+
+// sigblock blocks signals in the current thread's signal mask.
 // This is used to block signals while setting up and tearing down g
-// when a non-Go thread calls a Go function.
-// The OS-specific code is expected to define sigset_all.
+// when a non-Go thread calls a Go function. When a thread is exiting
+// we use the sigsetAllExiting value, otherwise the OS specific
+// definition of sigset_all is used.
 // This is nosplit and nowritebarrierrec because it is called by needm
 // which may be called on a non-Go thread with no g available.
 //go:nosplit
 //go:nowritebarrierrec
-func sigblock() {
+func sigblock(exiting bool) {
+       if exiting {
+               sigprocmask(_SIG_SETMASK, &sigsetAllExiting, nil)
+               return
+       }
        sigprocmask(_SIG_SETMASK, &sigset_all, nil)
 }
 

diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 3af2e39b088d43bcdc6ee858e40d08bad06b5bd5..6215d0ba2dc7a6d45d16368df0e57ffb0d3afd3c 100644 (file)
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+       "runtime/internal/sys"
        "unsafe"
 )
 
@@ -43,13 +44,17 @@ func initExceptionHandler() {
 //
 //go:nosplit
 func isAbort(r *context) bool {
-       // In the case of an abort, the exception IP is one byte after
-       // the INT3 (this differs from UNIX OSes).
-       return isAbortPC(r.ip() - 1)
+       pc := r.ip()
+       if GOARCH == "386" || GOARCH == "amd64" {
+               // In the case of an abort, the exception IP is one byte after
+               // the INT3 (this differs from UNIX OSes).
+               pc--
+       }
+       return isAbortPC(pc)
 }
 
 // isgoexception reports whether this exception should be translated
-// into a Go panic.
+// into a Go panic or throw.
 //
 // It is nosplit to avoid growing the stack in case we're aborting
 // because of a stack overflow.
@@ -63,11 +68,6 @@ func isgoexception(info *exceptionrecord, r *context) bool {
                return false
        }
 
-       if isAbort(r) {
-               // Never turn abort into a panic.
-               return false
-       }
-
        // Go will only handle some exceptions.
        switch info.exceptioncode {
        default:
@@ -81,6 +81,7 @@ func isgoexception(info *exceptionrecord, r *context) bool {
        case _EXCEPTION_FLT_OVERFLOW:
        case _EXCEPTION_FLT_UNDERFLOW:
        case _EXCEPTION_BREAKPOINT:
+       case _EXCEPTION_ILLEGAL_INSTRUCTION: // breakpoint arrives this way on arm64
        }
        return true
 }
@@ -99,21 +100,23 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
                return _EXCEPTION_CONTINUE_SEARCH
        }
 
-       // After this point, it is safe to grow the stack.
-
-       if gp.throwsplit {
-               // We can't safely sigpanic because it may grow the
-               // stack. Let it fall through.
-               return _EXCEPTION_CONTINUE_SEARCH
+       if gp.throwsplit || isAbort(r) {
+               // We can't safely sigpanic because it may grow the stack.
+               // Or this is a call to abort.
+               // Don't go through any more of the Windows handler chain.
+               // Crash now.
+               winthrow(info, r, gp)
        }
 
+       // After this point, it is safe to grow the stack.
+
        // Make it look like a call to the signal func.
        // Have to pass arguments out of band since
        // augmenting the stack frame would break
        // the unwinding code.
        gp.sig = info.exceptioncode
-       gp.sigcode0 = uintptr(info.exceptioninformation[0])
-       gp.sigcode1 = uintptr(info.exceptioninformation[1])
+       gp.sigcode0 = info.exceptioninformation[0]
+       gp.sigcode1 = info.exceptioninformation[1]
        gp.sigpc = r.ip()
 
        // Only push runtime·sigpanic if r.ip() != 0.
@@ -131,16 +134,14 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
        // overwrite the PC. (See issue #35773)
        if r.ip() != 0 && r.ip() != funcPC(asyncPreempt) {
                sp := unsafe.Pointer(r.sp())
-               sp = add(sp, ^(unsafe.Sizeof(uintptr(0)) - 1)) // sp--
+               delta := uintptr(sys.StackAlign)
+               sp = add(sp, -delta)
                r.set_sp(uintptr(sp))
-               switch GOARCH {
-               default:
-                       panic("unsupported architecture")
-               case "386", "amd64":
-                       *((*uintptr)(sp)) = r.ip()
-               case "arm":
+               if usesLR {
                        *((*uintptr)(sp)) = r.lr()
                        r.set_lr(r.ip())
+               } else {
+                       *((*uintptr)(sp)) = r.ip()
                }
        }
        r.set_ip(funcPC(sigpanic))
@@ -181,6 +182,12 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
                return _EXCEPTION_CONTINUE_SEARCH
        }
 
+       winthrow(info, r, gp)
+       return 0 // not reached
+}
+
+//go:nosplit
+func winthrow(info *exceptionrecord, r *context, gp *g) {
        _g_ := getg()
 
        if panicking != 0 { // traceback already printed
@@ -206,11 +213,8 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
        }
        print("\n")
 
-       // TODO(jordanrh1): This may be needed for 386/AMD64 as well.
-       if GOARCH == "arm" {
-               _g_.m.throwing = 1
-               _g_.m.caughtsig.set(gp)
-       }
+       _g_.m.throwing = 1
+       _g_.m.caughtsig.set(gp)
 
        level, _, docrash := gotraceback()
        if level > 0 {
@@ -224,7 +228,6 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
        }
 
        exit(2)
-       return 0 // not reached
 }
 
 func sigpanic() {

diff --git a/src/runtime/signal_windows_test.go b/src/runtime/signal_windows_test.go
index a5a885c2f79d296f485dab34c30e53d2bebc4c17..33a9b92ee73f1f51b9ca265ed3be6c1587e67331 100644 (file)
--- a/src/runtime/signal_windows_test.go
+++ b/src/runtime/signal_windows_test.go
@@ -11,6 +11,7 @@ import (
        "os/exec"
        "path/filepath"
        "runtime"
+       "strconv"
        "strings"
        "syscall"
        "testing"
@@ -79,6 +80,69 @@ func sendCtrlBreak(pid int) error {
        return nil
 }
 
+// TestCtrlHandler tests that Go can gracefully handle closing the console window.
+// See https://golang.org/issues/41884.
+func TestCtrlHandler(t *testing.T) {
+       testenv.MustHaveGoBuild(t)
+       t.Parallel()
+
+       // build go program
+       exe := filepath.Join(t.TempDir(), "test.exe")
+       cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", exe, "testdata/testwinsignal/main.go")
+       out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
+       if err != nil {
+               t.Fatalf("failed to build go exe: %v\n%s", err, out)
+       }
+
+       // run test program
+       cmd = exec.Command(exe)
+       var stderr bytes.Buffer
+       cmd.Stderr = &stderr
+       outPipe, err := cmd.StdoutPipe()
+       if err != nil {
+               t.Fatalf("Failed to create stdout pipe: %v", err)
+       }
+       outReader := bufio.NewReader(outPipe)
+
+       // in a new command window
+       const _CREATE_NEW_CONSOLE = 0x00000010
+       cmd.SysProcAttr = &syscall.SysProcAttr{
+               CreationFlags: _CREATE_NEW_CONSOLE,
+               HideWindow:    true,
+       }
+       if err := cmd.Start(); err != nil {
+               t.Fatalf("Start failed: %v", err)
+       }
+       defer func() {
+               cmd.Process.Kill()
+               cmd.Wait()
+       }()
+
+       // wait for child to be ready to receive signals
+       if line, err := outReader.ReadString('\n'); err != nil {
+               t.Fatalf("could not read stdout: %v", err)
+       } else if strings.TrimSpace(line) != "ready" {
+               t.Fatalf("unexpected message: %s", line)
+       }
+
+       // gracefully kill pid, this closes the command window
+       if err := exec.Command("taskkill.exe", "/pid", strconv.Itoa(cmd.Process.Pid)).Run(); err != nil {
+               t.Fatalf("failed to kill: %v", err)
+       }
+
+       // check child received, handled SIGTERM
+       if line, err := outReader.ReadString('\n'); err != nil {
+               t.Fatalf("could not read stdout: %v", err)
+       } else if expected, got := syscall.SIGTERM.String(), strings.TrimSpace(line); expected != got {
+               t.Fatalf("Expected '%s' got: %s", expected, got)
+       }
+
+       // check child exited gracefully, did not timeout
+       if err := cmd.Wait(); err != nil {
+               t.Fatalf("Program exited with error: %v\n%s", err, &stderr)
+       }
+}
+
 // TestLibraryCtrlHandler tests that Go DLL allows calling program to handle console control events.
 // See https://golang.org/issues/35965.
 func TestLibraryCtrlHandler(t *testing.T) {

diff --git a/src/runtime/sigqueue.go b/src/runtime/sigqueue.go
index 0605f5da803b2e651e3017c7d93d2f79abe9d004..28b9e26d0fd43d875fd1830666ef4f40632f7f51 100644 (file)
--- a/src/runtime/sigqueue.go
+++ b/src/runtime/sigqueue.go
@@ -12,12 +12,16 @@
 // sigsend is called by the signal handler to queue a new signal.
 // signal_recv is called by the Go program to receive a newly queued signal.
 // Synchronization between sigsend and signal_recv is based on the sig.state
-// variable. It can be in 3 states: sigIdle, sigReceiving and sigSending.
+// variable. It can be in 4 states: sigIdle, sigReceiving, sigSending and sigFixup.
 // sigReceiving means that signal_recv is blocked on sig.Note and there are no
 // new pending signals.
 // sigSending means that sig.mask *may* contain new pending signals,
 // signal_recv can't be blocked in this state.
 // sigIdle means that there are no new pending signals and signal_recv is not blocked.
+// sigFixup is a transient state that can only exist as a short
+// transition from sigReceiving and then on to sigIdle: it is
+// used to ensure the AllThreadsSyscall()'s mDoFixup() operation
+// occurs on the sleeping m, waiting to receive a signal.
 // Transitions between states are done atomically with CAS.
 // When signal_recv is unblocked, it resets sig.Note and rechecks sig.mask.
 // If several sigsends and signal_recv execute concurrently, it can lead to
@@ -59,6 +63,7 @@ const (
        sigIdle = iota
        sigReceiving
        sigSending
+       sigFixup
 )
 
 // sigsend delivers a signal from sighandler to the internal signal delivery queue.
@@ -112,6 +117,9 @@ Send:
                                notewakeup(&sig.note)
                                break Send
                        }
+               case sigFixup:
+                       // nothing to do - we need to wait for sigIdle.
+                       osyield()
                }
        }
 
@@ -119,6 +127,19 @@ Send:
        return true
 }
 
+// sigRecvPrepareForFixup is used to temporarily wake up the
+// signal_recv() running thread while it is blocked waiting for the
+// arrival of a signal. If it causes the thread to wake up, the
+// sig.state travels through this sequence: sigReceiving -> sigFixup
+// -> sigIdle -> sigReceiving and resumes. (This is only called while
+// GC is disabled.)
+//go:nosplit
+func sigRecvPrepareForFixup() {
+       if atomic.Cas(&sig.state, sigReceiving, sigFixup) {
+               notewakeup(&sig.note)
+       }
+}
+
 // Called to receive the next queued signal.
 // Must only be called from a single goroutine at a time.
 //go:linkname signal_recv os/signal.signal_recv
@@ -146,7 +167,16 @@ func signal_recv() uint32 {
                                        }
                                        notetsleepg(&sig.note, -1)
                                        noteclear(&sig.note)
-                                       break Receive
+                                       if !atomic.Cas(&sig.state, sigFixup, sigIdle) {
+                                               break Receive
+                                       }
+                                       // Getting here, the code will
+                                       // loop around again to sleep
+                                       // in state sigReceiving. This
+                                       // path is taken when
+                                       // sigRecvPrepareForFixup()
+                                       // has been called by another
+                                       // thread.
                                }
                        case sigSending:
                                if atomic.Cas(&sig.state, sigSending, sigIdle) {

diff --git a/src/runtime/sigqueue_plan9.go b/src/runtime/sigqueue_plan9.go
index d5fe8f8b35df83f483d3c39a74acb63243f4062c..aebd2060e791ac721987da89532930ac6432d847 100644 (file)
--- a/src/runtime/sigqueue_plan9.go
+++ b/src/runtime/sigqueue_plan9.go
@@ -92,6 +92,13 @@ func sendNote(s *byte) bool {
        return true
 }
 
+// sigRecvPrepareForFixup is a no-op on plan9. (This would only be
+// called while GC is disabled.)
+//
+//go:nosplit
+func sigRecvPrepareForFixup() {
+}
+
 // Called to receive the next queued signal.
 // Must only be called from a single goroutine at a time.
 //go:linkname signal_recv os/signal.signal_recv

diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index 7b9dce53931e98f7a99fca052f7692c11c0b868f..d971e5e26f8e544259606e8a73522c2bf0e4afa7 100644 (file)
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -651,7 +651,7 @@ func adjustframe(frame *stkframe, arg unsafe.Pointer) bool {
 
        // Adjust saved base pointer if there is one.
        // TODO what about arm64 frame pointer adjustment?
-       if sys.ArchFamily == sys.AMD64 && frame.argp-frame.varp == 2*sys.RegSize {
+       if sys.ArchFamily == sys.AMD64 && frame.argp-frame.varp == 2*sys.PtrSize {
                if stackDebug >= 3 {
                        print("      saved bp\n")
                }
@@ -1089,7 +1089,7 @@ func nilfunc() {
 }
 
 // adjust Gobuf as if it executed a call to fn
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcallfn(gobuf *gobuf, fv *funcval) {
        var fn unsafe.Pointer
        if fv != nil {
@@ -1245,7 +1245,7 @@ func getStackMap(frame *stkframe, cache *pcvalueCache, debug bool) (locals, args
        var minsize uintptr
        switch sys.ArchFamily {
        case sys.ARM64:
-               minsize = sys.SpAlign
+               minsize = sys.StackAlign
        default:
                minsize = sys.MinFrameSize
        }

diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index b55c3c0590072ed67f7ee64ce2a6af302969d5f9..b9b313a71127cded6b09dee4f13c42fa0d363fb5 100644 (file)
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -4,7 +4,10 @@
 
 package runtime
 
-import "unsafe"
+import (
+       "internal/abi"
+       "unsafe"
+)
 
 // Should be a built-in for unsafe.Pointer?
 //go:nosplit
@@ -73,7 +76,15 @@ func badsystemstack() {
 // *ptr is uninitialized memory (e.g., memory that's being reused
 // for a new allocation) and hence contains only "junk".
 //
+// memclrNoHeapPointers ensures that if ptr is pointer-aligned, and n
+// is a multiple of the pointer size, then any pointer-aligned,
+// pointer-sized portion is cleared atomically. Despite the function
+// name, this is necessary because this function is the underlying
+// implementation of typedmemclr and memclrHasPointers. See the doc of
+// memmove for more details.
+//
 // The (CPU-specific) implementations of this function are in memclr_*.s.
+//
 //go:noescape
 func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 
@@ -158,8 +169,8 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 // This in turn calls cgocallbackg, which is where we'll find
 // pointer-declared arguments.
 func cgocallback(fn, frame, ctxt uintptr)
+
 func gogo(buf *gobuf)
-func gosave(buf *gobuf)
 
 //go:noescape
 func jmpdefer(fv *funcval, argp uintptr)
@@ -167,19 +178,50 @@ func asminit()
 func setg(gg *g)
 func breakpoint()
 
-// reflectcall calls fn with a copy of the n argument bytes pointed at by arg.
-// After fn returns, reflectcall copies n-retoffset result bytes
-// back into arg+retoffset before returning. If copying result bytes back,
-// the caller should pass the argument frame type as argtype, so that
-// call can execute appropriate write barriers during the copy.
+// reflectcall calls fn with arguments described by stackArgs, stackArgsSize,
+// frameSize, and regArgs.
+//
+// Arguments passed on the stack and space for return values passed on the stack
+// must be laid out at the space pointed to by stackArgs (with total length
+// stackArgsSize) according to the ABI.
+//
+// stackRetOffset must be some value <= stackArgsSize that indicates the
+// offset within stackArgs where the return value space begins.
+//
+// frameSize is the total size of the argument frame at stackArgs and must
+// therefore be >= stackArgsSize. It must include additional space for spilling
+// register arguments for stack growth and preemption.
+//
+// TODO(mknyszek): Once we don't need the additional spill space, remove frameSize,
+// since frameSize will be redundant with stackArgsSize.
 //
-// Package reflect always passes a frame type. In package runtime,
-// Windows callbacks are the only use of this that copies results
-// back, and those cannot have pointers in their results, so runtime
-// passes nil for the frame type.
+// Arguments passed in registers must be laid out in regArgs according to the ABI.
+// regArgs will hold any return values passed in registers after the call.
+//
+// reflectcall copies stack arguments from stackArgs to the goroutine stack, and
+// then copies back stackArgsSize-stackRetOffset bytes back to the return space
+// in stackArgs once fn has completed. It also "unspills" argument registers from
+// regArgs before calling fn, and spills them back into regArgs immediately
+// following the call to fn. If there are results being returned on the stack,
+// the caller should pass the argument frame type as stackArgsType so that
+// reflectcall can execute appropriate write barriers during the copy.
+//
+// reflectcall expects regArgs.ReturnIsPtr to be populated indicating which
+// registers on the return path will contain Go pointers. It will then store
+// these pointers in regArgs.Ptrs such that they are visible to the GC.
+//
+// Package reflect passes a frame type. In package runtime, there is only
+// one call that copies results back, in callbackWrap in syscall_windows.go, and it
+// does NOT pass a frame type, meaning there are no write barriers invoked. See that
+// call site for justification.
 //
 // Package reflect accesses this symbol through a linkname.
-func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
+//
+// Arguments passed through to reflectcall do not escape. The type is used
+// only in a very limited callee of reflectcall, the stackArgs are copied, and
+// regArgs is only used in the reflectcall frame.
+//go:noescape
+func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
 func procyield(cycles uint32)
 
@@ -349,3 +391,7 @@ func duffcopy()
 
 // Called from linker-generated .initarray; declared for go vet; do NOT call from Go.
 func addmoduledata()
+
+// Injected by the signal handler for panicking signals. On many platforms it just
+// jumps to sigpanic.
+func sigpanic0()

diff --git a/src/runtime/stubs2.go b/src/runtime/stubs2.go
index 4a1a5cc3d90bb04c5266f20a27e9eb0e9725ee98..96096d236b8cb23589f58f8ce06e341c64f73b27 100644 (file)
--- a/src/runtime/stubs2.go
+++ b/src/runtime/stubs2.go
@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build !aix
+// +build !darwin
+// +build !js
+// +build !openbsd
 // +build !plan9
 // +build !solaris
 // +build !windows
-// +build !js
-// +build !darwin
-// +build !aix
 
 package runtime
 
@@ -22,6 +23,11 @@ func closefd(fd int32) int32
 func exit(code int32)
 func usleep(usec uint32)
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+       usleep(usec)
+}
+
 // write calls the write system call.
 // It returns a non-negative number of bytes written or a negative errno value.
 //go:noescape

diff --git a/src/runtime/stubs3.go b/src/runtime/stubs3.go
index 95eecc7ecaf6a570bcba1dec464cf2f6f26299b4..1885d320510810d5c8eca55668c2b1ab40a4e5d5 100644 (file)
--- a/src/runtime/stubs3.go
+++ b/src/runtime/stubs3.go
@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build !aix
+// +build !darwin
+// +build !freebsd
+// +build !openbsd
 // +build !plan9
 // +build !solaris
-// +build !freebsd
-// +build !darwin
-// +build !aix
 
 package runtime
 

diff --git a/src/runtime/stubs_386.go b/src/runtime/stubs_386.go
index 5108294d83375750819c817b8a06e82658e7407c..300f167fff3132ec2a2d4a53e2b7ac7a5f85cc5c 100644 (file)
--- a/src/runtime/stubs_386.go
+++ b/src/runtime/stubs_386.go
@@ -15,3 +15,6 @@ func stackcheck()
 // Called from assembly only; declared for go vet.
 func setldt(slot uintptr, base unsafe.Pointer, size uintptr)
 func emptyfunc()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)

diff --git a/src/runtime/stubs_amd64.go b/src/runtime/stubs_amd64.go
index 8c14bc227162691631014dd005f9dad60968e96c..bf98493e9dd590b020a1c63409bbe23b868cd85b 100644 (file)
--- a/src/runtime/stubs_amd64.go
+++ b/src/runtime/stubs_amd64.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from compiled code; declared for vet; do NOT call from Go.
 func gcWriteBarrierCX()
 func gcWriteBarrierDX()
@@ -35,3 +37,6 @@ func retpolineR12()
 func retpolineR13()
 func retpolineR14()
 func retpolineR15()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)

diff --git a/src/runtime/stubs_arm.go b/src/runtime/stubs_arm.go
index c13bf16de2f420c4a4094440acc4df01c0c03e98..52c32937aead8ca998408e265adef8c42c2786cd 100644 (file)
--- a/src/runtime/stubs_arm.go
+++ b/src/runtime/stubs_arm.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from compiler-generated code; declared for go vet.
 func udiv()
 func _div()
@@ -18,3 +20,6 @@ func save_g()
 func emptyfunc()
 func _initcgo()
 func read_tls_fallback()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)

diff --git a/src/runtime/stubs_arm64.go b/src/runtime/stubs_arm64.go
index 44c566e602d5a3033093a4a4a93b16f85a60401e..f5e3bb4854083c5ef80f7b8d251c8a10865ba195 100644 (file)
--- a/src/runtime/stubs_arm64.go
+++ b/src/runtime/stubs_arm64.go
@@ -4,6 +4,13 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
 func load_g()
 func save_g()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
+
+func emptyfunc()

diff --git a/src/runtime/stubs_mips64x.go b/src/runtime/stubs_mips64x.go
index 4e62c1ce908934eac01987e00e18a5d3afcd7fab..652e7a9e34b612596b85adaf9a7f76a2977b60b0 100644 (file)
--- a/src/runtime/stubs_mips64x.go
+++ b/src/runtime/stubs_mips64x.go
@@ -6,6 +6,11 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
 func load_g()
 func save_g()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 7667f23f1dba734fae6d4bbbe9f5837d383be6c0..00f802aaa7738c8384f564d5dffb7d87783ff75a 100644 (file)
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -308,30 +308,53 @@ type funcID uint8
 
 const (
        funcID_normal funcID = iota // not a special function
-       funcID_runtime_main
+       funcID_asmcgocall
+       funcID_asyncPreempt
+       funcID_cgocallback
+       funcID_debugCallV1
+       funcID_externalthreadhandler
+       funcID_gcBgMarkWorker
        funcID_goexit
+       funcID_gogo
+       funcID_gopanic
+       funcID_handleAsyncEvent
        funcID_jmpdefer
        funcID_mcall
        funcID_morestack
        funcID_mstart
+       funcID_panicwrap
        funcID_rt0_go
-       funcID_asmcgocall
-       funcID_sigpanic
        funcID_runfinq
-       funcID_gcBgMarkWorker
-       funcID_systemstack_switch
+       funcID_runtime_main
+       funcID_sigpanic
        funcID_systemstack
-       funcID_cgocallback
-       funcID_gogo
-       funcID_externalthreadhandler
-       funcID_debugCallV1
-       funcID_gopanic
-       funcID_panicwrap
-       funcID_handleAsyncEvent
-       funcID_asyncPreempt
+       funcID_systemstack_switch
        funcID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
 )
 
+// A FuncFlag holds bits about a function.
+// This list must match the list in cmd/internal/objabi/funcid.go.
+type funcFlag uint8
+
+const (
+       // TOPFRAME indicates a function that appears at the top of its stack.
+       // The traceback routine stop at such a function and consider that a
+       // successful, complete traversal of the stack.
+       // Examples of TOPFRAME functions include goexit, which appears
+       // at the top of a user goroutine stack, and mstart, which appears
+       // at the top of a system goroutine stack.
+       funcFlag_TOPFRAME funcFlag = 1 << iota
+
+       // SPWRITE indicates a function that writes an arbitrary value to SP
+       // (any write other than adding or subtracting a constant amount).
+       // The traceback routines cannot encode such changes into the
+       // pcsp tables, so the function traceback cannot safely unwind past
+       // SPWRITE functions. Stopping at an SPWRITE function is considered
+       // to be an incomplete unwinding of the stack. In certain contexts
+       // (in particular garbage collector stack scans) that is a fatal error.
+       funcFlag_SPWRITE
+)
+
 // pcHeader holds data used by the pclntab lookups.
 type pcHeader struct {
        magic          uint32  // 0xFFFFFFFA

diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index c89ce780124cbeca77f57bad28e735e03731a559..dacce2ee1abb5149c21f4b4239b41f81c851659f 100644 (file)
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -6,50 +6,6 @@ package runtime
 
 import "unsafe"
 
-// Call fn with arg as its argument. Return what fn returns.
-// fn is the raw pc value of the entry point of the desired function.
-// Switches to the system stack, if not already there.
-// Preserves the calling point as the location where a profiler traceback will begin.
-//go:nosplit
-func libcCall(fn, arg unsafe.Pointer) int32 {
-       // Leave caller's PC/SP/G around for traceback.
-       gp := getg()
-       var mp *m
-       if gp != nil {
-               mp = gp.m
-       }
-       if mp != nil && mp.libcallsp == 0 {
-               mp.libcallg.set(gp)
-               mp.libcallpc = getcallerpc()
-               // sp must be the last, because once async cpu profiler finds
-               // all three values to be non-zero, it will use them
-               mp.libcallsp = getcallersp()
-       } else {
-               // Make sure we don't reset libcallsp. This makes
-               // libcCall reentrant; We remember the g/pc/sp for the
-               // first call on an M, until that libcCall instance
-               // returns.  Reentrance only matters for signals, as
-               // libc never calls back into Go.  The tricky case is
-               // where we call libcX from an M and record g/pc/sp.
-               // Before that call returns, a signal arrives on the
-               // same M and the signal handling code calls another
-               // libc function.  We don't want that second libcCall
-               // from within the handler to be recorded, and we
-               // don't want that call's completion to zero
-               // libcallsp.
-               // We don't need to set libcall* while we're in a sighandler
-               // (even if we're not currently in libc) because we block all
-               // signals while we're handling a signal. That includes the
-               // profile signal, which is the one that uses the libcall* info.
-               mp = nil
-       }
-       res := asmcgocall(fn, arg)
-       if mp != nil {
-               mp.libcallsp = 0
-       }
-       return res
-}
-
 // The X versions of syscall expect the libc call to return a 64-bit result.
 // Otherwise (the non-X version) expects a 32-bit result.
 // This distinction is required because an error is indicated by returning -1,
@@ -271,6 +227,12 @@ func usleep(usec uint32) {
 }
 func usleep_trampoline()
 
+//go:nosplit
+//go:cgo_unsafe_args
+func usleep_no_g(usec uint32) {
+       asmcgocall_no_g(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+}
+
 //go:nosplit
 //go:cgo_unsafe_args
 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
@@ -467,7 +429,7 @@ func setNonblock(fd int32) {
 //go:cgo_import_dynamic libc_pthread_create pthread_create "/usr/lib/libSystem.B.dylib"
 //go:cgo_import_dynamic libc_pthread_self pthread_self "/usr/lib/libSystem.B.dylib"
 //go:cgo_import_dynamic libc_pthread_kill pthread_kill "/usr/lib/libSystem.B.dylib"
-//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
+//go:cgo_import_dynamic libc_exit _exit "/usr/lib/libSystem.B.dylib"
 //go:cgo_import_dynamic libc_raise raise "/usr/lib/libSystem.B.dylib"
 
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"

diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index 630fb5df64fd2c73fd0c49f0d630a571a41dc2f5..0fe8c7e172f5b59df7aefa62379186b6ee00d489 100644 (file)
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -5,6 +5,8 @@
 // System calls and other sys.stuff for AMD64, Darwin
 // System calls are implemented in libSystem, this file contains
 // trampolines that convert from Go to C calling convention.
+// The trampolines are ABIInternal as they are referenced from
+// Go code with funcPC.
 
 #include "go_asm.h"
 #include "go_tls.h"
@@ -13,7 +15,7 @@
 #define CLOCK_REALTIME         0
 
 // Exit the entire program (like C exit)
-TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
+TEXT runtime·exit_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    0(DI), DI               // arg 1 exit status
@@ -22,7 +24,7 @@ TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+TEXT runtime·open_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 flags
@@ -33,7 +35,7 @@ TEXT runtime·open_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+TEXT runtime·close_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    0(DI), DI               // arg 1 fd
@@ -41,7 +43,7 @@ TEXT runtime·close_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+TEXT runtime·read_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 buf
@@ -57,7 +59,7 @@ noerr:
        POPQ    BP
        RET
 
-TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+TEXT runtime·write_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 buf
@@ -73,7 +75,7 @@ noerr:
        POPQ    BP
        RET
 
-TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        CALL    libc_pipe(SB)           // pointer already in DI
@@ -84,7 +86,7 @@ TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+TEXT runtime·setitimer_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 new
@@ -94,7 +96,7 @@ TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
+TEXT runtime·madvise_trampoline<ABIInternal>(SB), NOSPLIT, $0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 len
@@ -105,12 +107,12 @@ TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
        POPQ    BP
        RET
 
-TEXT runtime·mlock_trampoline(SB), NOSPLIT, $0
+TEXT runtime·mlock_trampoline<ABIInternal>(SB), NOSPLIT, $0
        UNDEF // unimplemented
 
 GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
 
-TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$0
+TEXT runtime·nanotime_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    DI, BX
@@ -139,7 +141,7 @@ initialized:
        POPQ    BP
        RET
 
-TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
+TEXT runtime·walltime_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP                      // make a frame; keep stack aligned
        MOVQ    SP, BP
        MOVQ    DI, SI                  // arg 2 timespec
@@ -148,7 +150,7 @@ TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigaction_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 new
@@ -161,7 +163,7 @@ TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigprocmask_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 new
@@ -174,7 +176,7 @@ TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigaltstack_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 old
@@ -186,7 +188,7 @@ TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+TEXT runtime·raiseproc_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    0(DI), BX       // signal
@@ -212,7 +214,7 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 
 // This is the function registered during sigaction and is invoked when
 // a signal is received. It just redirects to the Go function sigtrampgo.
-TEXT runtime·sigtramp(SB),NOSPLIT,$0
+TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
        // This runs on the signal stack, so we have lots of stack available.
        // We allocate our own stack space, because if we tell the linker
        // how much we're using, the NOSPLIT check fails.
@@ -246,7 +248,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 
 // Used instead of sigtramp in programs that use cgo.
 // Arguments from kernel are in DI, SI, DX.
-TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
+TEXT runtime·cgoSigtramp<ABIInternal>(SB),NOSPLIT,$0
        // If no traceback function, do usual sigtramp.
        MOVQ    runtime·cgoTraceback(SB), AX
        TESTQ   AX, AX
@@ -289,12 +291,12 @@ TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
        // The first three arguments, and the fifth, are already in registers.
        // Set the two remaining arguments now.
        MOVQ    runtime·cgoTraceback(SB), CX
-       MOVQ    $runtime·sigtramp(SB), R9
+       MOVQ    $runtime·sigtramp<ABIInternal>(SB), R9
        MOVQ    _cgo_callers(SB), AX
        JMP     AX
 
 sigtramp:
-       JMP     runtime·sigtramp(SB)
+       JMP     runtime·sigtramp<ABIInternal>(SB)
 
 sigtrampnog:
        // Signal arrived on a non-Go thread. If this is SIGPROF, get a
@@ -320,7 +322,7 @@ sigtrampnog:
        MOVQ    _cgo_callers(SB), AX
        JMP     AX
 
-TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+TEXT runtime·mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP                      // make a frame; keep stack aligned
        MOVQ    SP, BP
        MOVQ    DI, BX
@@ -343,7 +345,7 @@ ok:
        POPQ    BP
        RET
 
-TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+TEXT runtime·munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 len
@@ -355,7 +357,7 @@ TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+TEXT runtime·usleep_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    0(DI), DI       // arg 1 usec
@@ -367,7 +369,7 @@ TEXT runtime·settls(SB),NOSPLIT,$32
        // Nothing to do on Darwin, pthread already set thread-local storage up.
        RET
 
-TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 miblen
@@ -380,7 +382,7 @@ TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sysctlbyname_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 oldp
@@ -392,14 +394,14 @@ TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+TEXT runtime·kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        CALL    libc_kqueue(SB)
        POPQ    BP
        RET
 
-TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+TEXT runtime·kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 keventt
@@ -418,7 +420,7 @@ ok:
        POPQ    BP
        RET
 
-TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+TEXT runtime·fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    4(DI), SI               // arg 2 cmd
@@ -475,7 +477,7 @@ TEXT runtime·mstart_stub(SB),NOSPLIT,$0
 // A pointer to the arguments is passed in DI.
 // A single int32 result is returned in AX.
 // (For more results, make an args/results structure.)
-TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP      // make frame, keep stack 16-byte aligned.
        MOVQ    SP, BP
        MOVQ    0(DI), DI // arg 1 attr
@@ -483,7 +485,7 @@ TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_getstacksize_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 size
@@ -492,7 +494,7 @@ TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_setdetachstate_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 state
@@ -501,7 +503,7 @@ TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_create_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -514,7 +516,7 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
+TEXT runtime·raise_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVL    0(DI), DI       // arg 1 signal
@@ -522,7 +524,7 @@ TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 attr
@@ -531,7 +533,7 @@ TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_lock_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    0(DI), DI       // arg 1 mutex
@@ -539,7 +541,7 @@ TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_unlock_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    0(DI), DI       // arg 1 mutex
@@ -547,7 +549,7 @@ TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 attr
@@ -556,7 +558,7 @@ TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_wait_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 mutex
@@ -565,7 +567,7 @@ TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_timedwait_relative_np_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 mutex
@@ -575,7 +577,7 @@ TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_signal_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    0(DI), DI       // arg 1 cond
@@ -583,7 +585,7 @@ TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_self_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    DI, BX          // BX is caller-save
@@ -592,7 +594,7 @@ TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
        POPQ    BP
        RET
 
-TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 sig
@@ -617,7 +619,7 @@ TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
 //
 // syscall expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall(SB),NOSPLIT,$0
+TEXT runtime·syscall<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -667,7 +669,7 @@ ok:
 //
 // syscallX is like syscall but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscallX(SB),NOSPLIT,$0
+TEXT runtime·syscallX<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -703,7 +705,7 @@ ok:
 
 // syscallPtr is like syscallX except that the libc function reports an
 // error by returning NULL and setting errno.
-TEXT runtime·syscallPtr(SB),NOSPLIT,$0
+TEXT runtime·syscallPtr<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -756,7 +758,7 @@ ok:
 //
 // syscall6 expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall6(SB),NOSPLIT,$0
+TEXT runtime·syscall6<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -809,7 +811,7 @@ ok:
 //
 // syscall6X is like syscall6 but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscall6X(SB),NOSPLIT,$0
+TEXT runtime·syscall6X<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP
@@ -845,7 +847,7 @@ ok:
 
 // syscallNoErr is like syscall6 but does not check for errors, and
 // only returns one value, for use with standard C ABI library functions.
-TEXT runtime·syscallNoErr(SB),NOSPLIT,$0
+TEXT runtime·syscallNoErr<ABIInternal>(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
        SUBQ    $16, SP

diff --git a/src/runtime/sys_freebsd_386.s b/src/runtime/sys_freebsd_386.s
index c346e719e14fe25fb8f106a8d678a652f40e0ad7..97e6d9ab36634ced64091e5831d2d4589405824d 100644 (file)
--- a/src/runtime/sys_freebsd_386.s
+++ b/src/runtime/sys_freebsd_386.s
@@ -13,12 +13,16 @@
 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$-4
        MOVL    $454, AX
        INT     $0x80
+       JAE     2(PC)
+       NEGL    AX
        MOVL    AX, ret+20(FP)
        RET
 
 TEXT runtime·thr_new(SB),NOSPLIT,$-4
        MOVL    $455, AX
        INT     $0x80
+       JAE     2(PC)
+       NEGL    AX
        MOVL    AX, ret+8(FP)
        RET
 
@@ -120,6 +124,8 @@ TEXT runtime·pipe2(SB),NOSPLIT,$12-16
        MOVL    flags+0(FP), BX
        MOVL    BX, 8(SP)
        INT     $0x80
+       JAE     2(PC)
+       NEGL    AX
        MOVL    AX, errno+12(FP)
        RET
 

diff --git a/src/runtime/sys_freebsd_amd64.s b/src/runtime/sys_freebsd_amd64.s
index 010b2ec4d4dc2c82f1b923b1068a762c77da36f1..07734b0d7d7f71ba39d094816ff79bfa07256d6f 100644 (file)
--- a/src/runtime/sys_freebsd_amd64.s
+++ b/src/runtime/sys_freebsd_amd64.s
@@ -18,6 +18,8 @@ TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
        MOVQ ut+24(FP), R8
        MOVL $454, AX
        SYSCALL
+       JCC     2(PC)
+       NEGQ    AX
        MOVL    AX, ret+32(FP)
        RET
 
@@ -26,6 +28,8 @@ TEXT runtime·thr_new(SB),NOSPLIT,$0
        MOVL size+8(FP), SI
        MOVL $455, AX
        SYSCALL
+       JCC     2(PC)
+       NEGQ    AX
        MOVL    AX, ret+16(FP)
        RET
 
@@ -118,6 +122,8 @@ TEXT runtime·pipe2(SB),NOSPLIT,$0-20
        MOVL    flags+0(FP), SI
        MOVL    $542, AX
        SYSCALL
+       JCC     2(PC)
+       NEGQ    AX
        MOVL    AX, errno+16(FP)
        RET
 

diff --git a/src/runtime/sys_freebsd_arm.s b/src/runtime/sys_freebsd_arm.s
index 1e12f9cfcb0815c4ca0213f691404079331fc496..b12e47c576daeb8a3b3556f405e5c5fbea0d4007 100644 (file)
--- a/src/runtime/sys_freebsd_arm.s
+++ b/src/runtime/sys_freebsd_arm.s
@@ -51,6 +51,7 @@ TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
        ADD $20, R13 // arg 5 is passed on stack
        MOVW $SYS__umtx_op, R7
        SWI $0
+       RSB.CS $0, R0
        SUB $20, R13
        // BCS error
        MOVW    R0, ret+20(FP)
@@ -61,6 +62,7 @@ TEXT runtime·thr_new(SB),NOSPLIT,$0
        MOVW size+4(FP), R1
        MOVW $SYS_thr_new, R7
        SWI $0
+       RSB.CS $0, R0
        MOVW    R0, ret+8(FP)
        RET
 
@@ -144,6 +146,7 @@ TEXT runtime·pipe2(SB),NOSPLIT,$0-16
        MOVW    flags+0(FP), R1
        MOVW    $SYS_pipe2, R7
        SWI     $0
+       RSB.CS $0, R0
        MOVW    R0, errno+12(FP)
        RET
 

diff --git a/src/runtime/sys_freebsd_arm64.s b/src/runtime/sys_freebsd_arm64.s
index 8a4f9b7fa1462a024691a8e40a5895f93f8ce99b..1aa09e87ca1dc3fc304ff01f8925525a9c72dcf5 100644 (file)
--- a/src/runtime/sys_freebsd_arm64.s
+++ b/src/runtime/sys_freebsd_arm64.s
@@ -60,6 +60,9 @@ TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
        MOVD    ut+24(FP), R4
        MOVD    $SYS__umtx_op, R8
        SVC
+       BCC     ok
+       NEG     R0, R0
+ok:
        MOVW    R0, ret+32(FP)
        RET
 
@@ -69,6 +72,9 @@ TEXT runtime·thr_new(SB),NOSPLIT,$0
        MOVW    size+8(FP), R1
        MOVD    $SYS_thr_new, R8
        SVC
+       BCC     ok
+       NEG     R0, R0
+ok:
        MOVW    R0, ret+16(FP)
        RET
 

diff --git a/src/runtime/sys_libc.go b/src/runtime/sys_libc.go
new file mode 100644 (file)
index 0000000..996c032
--- /dev/null
+++ b/src/runtime/sys_libc.go
@@ -0,0 +1,53 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import "unsafe"
+
+// Call fn with arg as its argument. Return what fn returns.
+// fn is the raw pc value of the entry point of the desired function.
+// Switches to the system stack, if not already there.
+// Preserves the calling point as the location where a profiler traceback will begin.
+//go:nosplit
+func libcCall(fn, arg unsafe.Pointer) int32 {
+       // Leave caller's PC/SP/G around for traceback.
+       gp := getg()
+       var mp *m
+       if gp != nil {
+               mp = gp.m
+       }
+       if mp != nil && mp.libcallsp == 0 {
+               mp.libcallg.set(gp)
+               mp.libcallpc = getcallerpc()
+               // sp must be the last, because once async cpu profiler finds
+               // all three values to be non-zero, it will use them
+               mp.libcallsp = getcallersp()
+       } else {
+               // Make sure we don't reset libcallsp. This makes
+               // libcCall reentrant; We remember the g/pc/sp for the
+               // first call on an M, until that libcCall instance
+               // returns.  Reentrance only matters for signals, as
+               // libc never calls back into Go.  The tricky case is
+               // where we call libcX from an M and record g/pc/sp.
+               // Before that call returns, a signal arrives on the
+               // same M and the signal handling code calls another
+               // libc function.  We don't want that second libcCall
+               // from within the handler to be recorded, and we
+               // don't want that call's completion to zero
+               // libcallsp.
+               // We don't need to set libcall* while we're in a sighandler
+               // (even if we're not currently in libc) because we block all
+               // signals while we're handling a signal. That includes the
+               // profile signal, which is the one that uses the libcall* info.
+               mp = nil
+       }
+       res := asmcgocall(fn, arg)
+       if mp != nil {
+               mp.libcallsp = 0
+       }
+       return res
+}

diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 37cb8dad0369e27cef3630c4227a94adb1c80867..d48573c2c592258ee749a5cd3ec24270c2ae55a9 100644 (file)
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -215,9 +215,13 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 
        MOVQ    SP, R12 // Save old SP; R12 unchanged by C code.
 
+#ifdef GOEXPERIMENT_REGABI
+       MOVQ    g_m(R14), BX // BX unchanged by C code.
+#else
        get_tls(CX)
        MOVQ    g(CX), AX
        MOVQ    g_m(AX), BX // BX unchanged by C code.
+#endif
 
        // Set vdsoPC and vdsoSP for SIGPROF traceback.
        // Save the old values on stack and restore them on exit,
@@ -232,7 +236,11 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
        MOVQ    CX, m_vdsoPC(BX)
        MOVQ    DX, m_vdsoSP(BX)
 
+#ifdef GOEXPERIMENT_REGABI
+       CMPQ    R14, m_curg(BX) // Only switch if on curg.
+#else
        CMPQ    AX, m_curg(BX)  // Only switch if on curg.
+#endif
        JNE     noswitch
 
        MOVQ    m_g0(BX), DX
@@ -275,9 +283,13 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 
        MOVQ    SP, R12 // Save old SP; R12 unchanged by C code.
 
+#ifdef GOEXPERIMENT_REGABI
+       MOVQ    g_m(R14), BX // BX unchanged by C code.
+#else
        get_tls(CX)
        MOVQ    g(CX), AX
        MOVQ    g_m(AX), BX // BX unchanged by C code.
+#endif
 
        // Set vdsoPC and vdsoSP for SIGPROF traceback.
        // Save the old values on stack and restore them on exit,
@@ -292,7 +304,11 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
        MOVQ    CX, m_vdsoPC(BX)
        MOVQ    DX, m_vdsoSP(BX)
 
+#ifdef GOEXPERIMENT_REGABI
+       CMPQ    R14, m_curg(BX) // Only switch if on curg.
+#else
        CMPQ    AX, m_curg(BX)  // Only switch if on curg.
+#endif
        JNE     noswitch
 
        MOVQ    m_g0(BX), DX
@@ -632,6 +648,7 @@ nog1:
        get_tls(CX)
        MOVQ    R13, g_m(R9)
        MOVQ    R9, g(CX)
+       MOVQ    R9, R14 // set g register
        CALL    runtime·stackcheck(SB)
 
 nog2:

diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index afad056d06bd43edbd3f550b7b42c49706a14b7b..c3e9f37694578e140cd38c7300b60bdc4b148db0 100644 (file)
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -250,6 +250,14 @@ noswitch:
        BEQ     R25, fallback
 
        JAL     (R25)
+       // check on vdso call return for kernel compatibility
+       // see https://golang.org/issues/39046
+       // if we get any error make fallback permanent.
+       BEQ     R2, R0, finish
+       MOVV    R0, runtime·vdsoClockgettimeSym(SB)
+       MOVW    $0, R4 // CLOCK_REALTIME
+       MOVV    $0(R29), R5
+       JMP     fallback
 
 finish:
        MOVV    0(R29), R3      // sec
@@ -311,6 +319,12 @@ noswitch:
        BEQ     R25, fallback
 
        JAL     (R25)
+       // see walltime1 for detail
+       BEQ     R2, R0, finish
+       MOVV    R0, runtime·vdsoClockgettimeSym(SB)
+       MOVW    $1, R4 // CLOCK_MONOTONIC
+       MOVV    $0(R29), R5
+       JMP     fallback
 
 finish:
        MOVV    0(R29), R3      // sec

diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
new file mode 100644 (file)
index 0000000..fcddf4d
--- /dev/null
+++ b/src/runtime/sys_openbsd.go
@@ -0,0 +1,60 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import "unsafe"
+
+// The *_trampoline functions convert from the Go calling convention to the C calling convention
+// and then call the underlying libc function. These are defined in sys_openbsd_$ARCH.s.
+
+//go:nosplit
+//go:cgo_unsafe_args
+func pthread_attr_init(attr *pthreadattr) int32 {
+       return libcCall(unsafe.Pointer(funcPC(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+}
+func pthread_attr_init_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func pthread_attr_destroy(attr *pthreadattr) int32 {
+       return libcCall(unsafe.Pointer(funcPC(pthread_attr_destroy_trampoline)), unsafe.Pointer(&attr))
+}
+func pthread_attr_destroy_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
+       return libcCall(unsafe.Pointer(funcPC(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+}
+func pthread_attr_getstacksize_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
+       return libcCall(unsafe.Pointer(funcPC(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+}
+func pthread_attr_setdetachstate_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 {
+       return libcCall(unsafe.Pointer(funcPC(pthread_create_trampoline)), unsafe.Pointer(&attr))
+}
+func pthread_create_trampoline()
+
+// Tell the linker that the libc_* functions are to be found
+// in a system library, with the libc_ prefix missing.
+
+//go:cgo_import_dynamic libc_pthread_attr_init pthread_attr_init "libpthread.so"
+//go:cgo_import_dynamic libc_pthread_attr_destroy pthread_attr_destroy "libpthread.so"
+//go:cgo_import_dynamic libc_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so"
+//go:cgo_import_dynamic libc_pthread_attr_setdetachstate pthread_attr_setdetachstate "libpthread.so"
+//go:cgo_import_dynamic libc_pthread_create pthread_create "libpthread.so"
+//go:cgo_import_dynamic libc_pthread_sigmask pthread_sigmask "libpthread.so"
+
+//go:cgo_import_dynamic _ _ "libpthread.so"
+//go:cgo_import_dynamic _ _ "libc.so"

diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
new file mode 100644 (file)
index 0000000..44c7871
--- /dev/null
+++ b/src/runtime/sys_openbsd1.go
@@ -0,0 +1,39 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import "unsafe"
+
+//go:nosplit
+//go:cgo_unsafe_args
+func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(thrsleep_trampoline)), unsafe.Pointer(&ident))
+}
+func thrsleep_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func thrwakeup(ident uintptr, n int32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(thrwakeup_trampoline)), unsafe.Pointer(&ident))
+}
+func thrwakeup_trampoline()
+
+func osyield() {
+       libcCall(unsafe.Pointer(funcPC(sched_yield_trampoline)), unsafe.Pointer(nil))
+}
+func sched_yield_trampoline()
+
+//go:nosplit
+func osyield_no_g() {
+       asmcgocall_no_g(unsafe.Pointer(funcPC(sched_yield_trampoline)), unsafe.Pointer(nil))
+}
+
+//go:cgo_import_dynamic libc_thrsleep __thrsleep "libc.so"
+//go:cgo_import_dynamic libc_thrwakeup __thrwakeup "libc.so"
+//go:cgo_import_dynamic libc_sched_yield sched_yield "libc.so"
+
+//go:cgo_import_dynamic _ _ "libc.so"

diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
new file mode 100644 (file)
index 0000000..3303259
--- /dev/null
+++ b/src/runtime/sys_openbsd2.go
@@ -0,0 +1,256 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import "unsafe"
+
+// This is exported via linkname to assembly in runtime/cgo.
+//go:linkname exit
+//go:nosplit
+//go:cgo_unsafe_args
+func exit(code int32) {
+       libcCall(unsafe.Pointer(funcPC(exit_trampoline)), unsafe.Pointer(&code))
+}
+func exit_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func getthrid() (tid int32) {
+       libcCall(unsafe.Pointer(funcPC(getthrid_trampoline)), unsafe.Pointer(&tid))
+       return
+}
+func getthrid_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func raiseproc(sig uint32) {
+       libcCall(unsafe.Pointer(funcPC(raiseproc_trampoline)), unsafe.Pointer(&sig))
+}
+func raiseproc_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func thrkill(tid int32, sig int) {
+       libcCall(unsafe.Pointer(funcPC(thrkill_trampoline)), unsafe.Pointer(&tid))
+}
+func thrkill_trampoline()
+
+// mmap is used to do low-level memory allocation via mmap. Don't allow stack
+// splits, since this function (used by sysAlloc) is called in a lot of low-level
+// parts of the runtime and callers often assume it won't acquire any locks.
+// go:nosplit
+func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
+       args := struct {
+               addr            unsafe.Pointer
+               n               uintptr
+               prot, flags, fd int32
+               off             uint32
+               ret1            unsafe.Pointer
+               ret2            int
+       }{addr, n, prot, flags, fd, off, nil, 0}
+       libcCall(unsafe.Pointer(funcPC(mmap_trampoline)), unsafe.Pointer(&args))
+       return args.ret1, args.ret2
+}
+func mmap_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func munmap(addr unsafe.Pointer, n uintptr) {
+       libcCall(unsafe.Pointer(funcPC(munmap_trampoline)), unsafe.Pointer(&addr))
+}
+func munmap_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
+       libcCall(unsafe.Pointer(funcPC(madvise_trampoline)), unsafe.Pointer(&addr))
+}
+func madvise_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func open(name *byte, mode, perm int32) (ret int32) {
+       return libcCall(unsafe.Pointer(funcPC(open_trampoline)), unsafe.Pointer(&name))
+}
+func open_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func closefd(fd int32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(close_trampoline)), unsafe.Pointer(&fd))
+}
+func close_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func read(fd int32, p unsafe.Pointer, n int32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(read_trampoline)), unsafe.Pointer(&fd))
+}
+func read_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(write_trampoline)), unsafe.Pointer(&fd))
+}
+func write_trampoline()
+
+func pipe() (r, w int32, errno int32) {
+       return pipe2(0)
+}
+
+func pipe2(flags int32) (r, w int32, errno int32) {
+       var p [2]int32
+       args := struct {
+               p     unsafe.Pointer
+               flags int32
+       }{noescape(unsafe.Pointer(&p)), flags}
+       errno = libcCall(unsafe.Pointer(funcPC(pipe2_trampoline)), unsafe.Pointer(&args))
+       return p[0], p[1], errno
+}
+func pipe2_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func setitimer(mode int32, new, old *itimerval) {
+       libcCall(unsafe.Pointer(funcPC(setitimer_trampoline)), unsafe.Pointer(&mode))
+}
+func setitimer_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func usleep(usec uint32) {
+       libcCall(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+}
+func usleep_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func usleep_no_g(usec uint32) {
+       asmcgocall_no_g(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+}
+
+//go:nosplit
+//go:cgo_unsafe_args
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32 {
+       return libcCall(unsafe.Pointer(funcPC(sysctl_trampoline)), unsafe.Pointer(&mib))
+}
+func sysctl_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func fcntl(fd, cmd, arg int32) int32 {
+       return libcCall(unsafe.Pointer(funcPC(fcntl_trampoline)), unsafe.Pointer(&fd))
+}
+func fcntl_trampoline()
+
+//go:nosplit
+func nanotime1() int64 {
+       var ts timespec
+       args := struct {
+               clock_id int32
+               tp       unsafe.Pointer
+       }{_CLOCK_MONOTONIC, unsafe.Pointer(&ts)}
+       libcCall(unsafe.Pointer(funcPC(clock_gettime_trampoline)), unsafe.Pointer(&args))
+       return ts.tv_sec*1e9 + int64(ts.tv_nsec)
+}
+func clock_gettime_trampoline()
+
+//go:nosplit
+func walltime1() (int64, int32) {
+       var ts timespec
+       args := struct {
+               clock_id int32
+               tp       unsafe.Pointer
+       }{_CLOCK_REALTIME, unsafe.Pointer(&ts)}
+       libcCall(unsafe.Pointer(funcPC(clock_gettime_trampoline)), unsafe.Pointer(&args))
+       return ts.tv_sec, int32(ts.tv_nsec)
+}
+
+//go:nosplit
+//go:cgo_unsafe_args
+func kqueue() int32 {
+       return libcCall(unsafe.Pointer(funcPC(kqueue_trampoline)), nil)
+}
+func kqueue_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 {
+       return libcCall(unsafe.Pointer(funcPC(kevent_trampoline)), unsafe.Pointer(&kq))
+}
+func kevent_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func sigaction(sig uint32, new *sigactiont, old *sigactiont) {
+       libcCall(unsafe.Pointer(funcPC(sigaction_trampoline)), unsafe.Pointer(&sig))
+}
+func sigaction_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func sigprocmask(how uint32, new *sigset, old *sigset) {
+       libcCall(unsafe.Pointer(funcPC(sigprocmask_trampoline)), unsafe.Pointer(&how))
+}
+func sigprocmask_trampoline()
+
+//go:nosplit
+//go:cgo_unsafe_args
+func sigaltstack(new *stackt, old *stackt) {
+       libcCall(unsafe.Pointer(funcPC(sigaltstack_trampoline)), unsafe.Pointer(&new))
+}
+func sigaltstack_trampoline()
+
+// Not used on OpenBSD, but must be defined.
+func exitThread(wait *uint32) {
+}
+
+//go:nosplit
+func closeonexec(fd int32) {
+       fcntl(fd, _F_SETFD, _FD_CLOEXEC)
+}
+
+//go:nosplit
+func setNonblock(fd int32) {
+       flags := fcntl(fd, _F_GETFL, 0)
+       fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
+}
+
+// Tell the linker that the libc_* functions are to be found
+// in a system library, with the libc_ prefix missing.
+
+//go:cgo_import_dynamic libc_errno __errno "libc.so"
+//go:cgo_import_dynamic libc_exit exit "libc.so"
+//go:cgo_import_dynamic libc_getthrid getthrid "libc.so"
+//go:cgo_import_dynamic libc_sched_yield sched_yield "libc.so"
+//go:cgo_import_dynamic libc_thrkill thrkill "libc.so"
+
+//go:cgo_import_dynamic libc_mmap mmap "libc.so"
+//go:cgo_import_dynamic libc_munmap munmap "libc.so"
+//go:cgo_import_dynamic libc_madvise madvise "libc.so"
+
+//go:cgo_import_dynamic libc_open open "libc.so"
+//go:cgo_import_dynamic libc_close close "libc.so"
+//go:cgo_import_dynamic libc_read read "libc.so"
+//go:cgo_import_dynamic libc_write write "libc.so"
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
+
+//go:cgo_import_dynamic libc_clock_gettime clock_gettime "libc.so"
+//go:cgo_import_dynamic libc_setitimer setitimer "libc.so"
+//go:cgo_import_dynamic libc_usleep usleep "libc.so"
+//go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
+//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
+//go:cgo_import_dynamic libc_getpid getpid "libc.so"
+//go:cgo_import_dynamic libc_kill kill "libc.so"
+//go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
+//go:cgo_import_dynamic libc_kevent kevent "libc.so"
+
+//go:cgo_import_dynamic libc_sigaction sigaction "libc.so"
+//go:cgo_import_dynamic libc_sigaltstack sigaltstack "libc.so"
+
+//go:cgo_import_dynamic _ _ "libc.so"

diff --git a/src/runtime/sys_openbsd3.go b/src/runtime/sys_openbsd3.go
new file mode 100644 (file)
index 0000000..4d4c88e
--- /dev/null
+++ b/src/runtime/sys_openbsd3.go
@@ -0,0 +1,113 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package runtime
+
+import "unsafe"
+
+// The X versions of syscall expect the libc call to return a 64-bit result.
+// Otherwise (the non-X version) expects a 32-bit result.
+// This distinction is required because an error is indicated by returning -1,
+// and we need to know whether to check 32 or 64 bits of the result.
+// (Some libc functions that return 32 bits put junk in the upper 32 bits of AX.)
+
+//go:linkname syscall_syscall syscall.syscall
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscall()
+
+//go:linkname syscall_syscallX syscall.syscallX
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscallX()
+
+//go:linkname syscall_syscall6 syscall.syscall6
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscall6()
+
+//go:linkname syscall_syscall6X syscall.syscall6X
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscall6X()
+
+//go:linkname syscall_syscall10 syscall.syscall10
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscall10)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscall10()
+
+//go:linkname syscall_syscall10X syscall.syscall10X
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) {
+       entersyscall()
+       libcCall(unsafe.Pointer(funcPC(syscall10X)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscall10X()
+
+//go:linkname syscall_rawSyscall syscall.rawSyscall
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+       libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
+       return
+}
+
+//go:linkname syscall_rawSyscall6 syscall.rawSyscall6
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+       libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
+       return
+}
+
+//go:linkname syscall_rawSyscall6X syscall.rawSyscall6X
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_rawSyscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+       libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn))
+       return
+}
+
+//go:linkname syscall_rawSyscall10X syscall.rawSyscall10X
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_rawSyscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) {
+       libcCall(unsafe.Pointer(funcPC(syscall10X)), unsafe.Pointer(&fn))
+       return
+}

diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index 37d70ab9aa2d9131ea3cecd7f233a19cb486faf6..b3a76b57a3afd4a5a33cbdca7f684f3dabbd1408 100644 (file)
--- a/src/runtime/sys_openbsd_amd64.s
+++ b/src/runtime/sys_openbsd_amd64.s
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
-// System calls and other sys.stuff for AMD64, OpenBSD
-// /usr/src/sys/kern/syscalls.master for syscall numbers.
+// System calls and other sys.stuff for AMD64, OpenBSD.
+// System calls are implemented in libc/libpthread, this file
+// contains trampolines that convert from Go to C calling convention.
+// Some direct system call implementations currently remain.
 //
 
 #include "go_asm.h"
@@ -12,243 +14,50 @@
 
 #define CLOCK_MONOTONIC        $3
 
-// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),NOSPLIT,$32
+TEXT runtime·settls(SB),NOSPLIT,$0
+       // Nothing to do, pthread already set thread-local storage up.
+       RET
 
-       // Copy mp, gp and fn off parent stack for use by child.
-       MOVQ    mm+16(FP), R8
-       MOVQ    gg+24(FP), R9
-       MOVQ    fn+32(FP), R12
+// mstart_stub is the first function executed on a new thread started by pthread_create.
+// It just does some low-level setup and then calls mstart.
+// Note: called with the C calling convention.
+TEXT runtime·mstart_stub(SB),NOSPLIT,$0
+       // DI points to the m.
+       // We are already on m's g0 stack.
 
-       MOVQ    param+0(FP), DI
-       MOVQ    psize+8(FP), SI
-       MOVL    $8, AX                  // sys___tfork
-       SYSCALL
+       // Save callee-save registers.
+       SUBQ    $48, SP
+       MOVQ    BX, 0(SP)
+       MOVQ    BP, 8(SP)
+       MOVQ    R12, 16(SP)
+       MOVQ    R13, 24(SP)
+       MOVQ    R14, 32(SP)
+       MOVQ    R15, 40(SP)
 
-       // Return if tfork syscall failed.
-       JCC     4(PC)
-       NEGQ    AX
-       MOVL    AX, ret+40(FP)
-       RET
+       // Load g and save to TLS entry.
+       // See cmd/link/internal/ld/sym.go:computeTLSOffset.
+       MOVQ    m_g0(DI), DX // g
+       MOVQ    DX, -8(FS)
 
-       // In parent, return.
-       CMPL    AX, $0
-       JEQ     3(PC)
-       MOVL    AX, ret+40(FP)
-       RET
-
-       // Set FS to point at m->tls.
-       LEAQ    m_tls(R8), DI
-       CALL    runtime·settls(SB)
-
-       // In child, set up new stack.
-       get_tls(CX)
-       MOVQ    R8, g_m(R9)
-       MOVQ    R9, g(CX)
-       CALL    runtime·stackcheck(SB)
-
-       // Call fn
-       CALL    R12
-
-       // It shouldn't return. If it does, exit
-       MOVQ    $0, DI                  // arg 1 - notdead
-       MOVL    $302, AX                // sys___threxit
-       SYSCALL
-       JMP     -3(PC)                  // keep exiting
-
-TEXT runtime·osyield(SB),NOSPLIT,$0
-       MOVL    $298, AX                // sys_sched_yield
-       SYSCALL
-       RET
-
-TEXT runtime·thrsleep(SB),NOSPLIT,$0
-       MOVQ    ident+0(FP), DI         // arg 1 - ident
-       MOVL    clock_id+8(FP), SI              // arg 2 - clock_id
-       MOVQ    tsp+16(FP), DX          // arg 3 - tp
-       MOVQ    lock+24(FP), R10                // arg 4 - lock
-       MOVQ    abort+32(FP), R8                // arg 5 - abort
-       MOVL    $94, AX                 // sys___thrsleep
-       SYSCALL
-       MOVL    AX, ret+40(FP)
-       RET
-
-TEXT runtime·thrwakeup(SB),NOSPLIT,$0
-       MOVQ    ident+0(FP), DI         // arg 1 - ident
-       MOVL    n+8(FP), SI             // arg 2 - n
-       MOVL    $301, AX                // sys___thrwakeup
-       SYSCALL
-       MOVL    AX, ret+16(FP)
-       RET
-
-// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),NOSPLIT,$-8
-       MOVL    code+0(FP), DI          // arg 1 - exit status
-       MOVL    $1, AX                  // sys_exit
-       SYSCALL
-       MOVL    $0xf1, 0xf1             // crash
-       RET
-
-// func exitThread(wait *uint32)
-TEXT runtime·exitThread(SB),NOSPLIT,$0-8
-       MOVQ    wait+0(FP), DI          // arg 1 - notdead
-       MOVL    $302, AX                // sys___threxit
-       SYSCALL
-       MOVL    $0xf1, 0xf1             // crash
-       JMP     0(PC)
-
-TEXT runtime·open(SB),NOSPLIT,$-8
-       MOVQ    name+0(FP), DI          // arg 1 pathname
-       MOVL    mode+8(FP), SI          // arg 2 flags
-       MOVL    perm+12(FP), DX         // arg 3 mode
-       MOVL    $5, AX
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $-1, AX
-       MOVL    AX, ret+16(FP)
-       RET
-
-TEXT runtime·closefd(SB),NOSPLIT,$-8
-       MOVL    fd+0(FP), DI            // arg 1 fd
-       MOVL    $6, AX
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $-1, AX
-       MOVL    AX, ret+8(FP)
-       RET
-
-TEXT runtime·read(SB),NOSPLIT,$-8
-       MOVL    fd+0(FP), DI            // arg 1 fd
-       MOVQ    p+8(FP), SI             // arg 2 buf
-       MOVL    n+16(FP), DX            // arg 3 count
-       MOVL    $3, AX
-       SYSCALL
-       JCC     2(PC)
-       NEGQ    AX                      // caller expects negative errno
-       MOVL    AX, ret+24(FP)
-       RET
-
-// func pipe() (r, w int32, errno int32)
-TEXT runtime·pipe(SB),NOSPLIT,$0-12
-       LEAQ    r+0(FP), DI
-       MOVL    $263, AX
-       SYSCALL
-       MOVL    AX, errno+8(FP)
-       RET
-
-// func pipe2(flags int32) (r, w int32, errno int32)
-TEXT runtime·pipe2(SB),NOSPLIT,$0-20
-       LEAQ    r+8(FP), DI
-       MOVL    flags+0(FP), SI
-       MOVL    $101, AX
-       SYSCALL
-       MOVL    AX, errno+16(FP)
-       RET
-
-TEXT runtime·write1(SB),NOSPLIT,$-8
-       MOVQ    fd+0(FP), DI            // arg 1 - fd
-       MOVQ    p+8(FP), SI             // arg 2 - buf
-       MOVL    n+16(FP), DX            // arg 3 - nbyte
-       MOVL    $4, AX                  // sys_write
-       SYSCALL
-       JCC     2(PC)
-       NEGQ    AX                      // caller expects negative errno
-       MOVL    AX, ret+24(FP)
-       RET
-
-TEXT runtime·usleep(SB),NOSPLIT,$16
-       MOVL    $0, DX
-       MOVL    usec+0(FP), AX
-       MOVL    $1000000, CX
-       DIVL    CX
-       MOVQ    AX, 0(SP)               // tv_sec
-       MOVL    $1000, AX
-       MULL    DX
-       MOVQ    AX, 8(SP)               // tv_nsec
-
-       MOVQ    SP, DI                  // arg 1 - rqtp
-       MOVQ    $0, SI                  // arg 2 - rmtp
-       MOVL    $91, AX                 // sys_nanosleep
-       SYSCALL
-       RET
-
-TEXT runtime·getthrid(SB),NOSPLIT,$0-4
-       MOVL    $299, AX                // sys_getthrid
-       SYSCALL
-       MOVL    AX, ret+0(FP)
-       RET
-
-TEXT runtime·thrkill(SB),NOSPLIT,$0-16
-       MOVL    tid+0(FP), DI           // arg 1 - tid
-       MOVQ    sig+8(FP), SI           // arg 2 - signum
-       MOVQ    $0, DX                  // arg 3 - tcb
-       MOVL    $119, AX                // sys_thrkill
-       SYSCALL
-       RET
-
-TEXT runtime·raiseproc(SB),NOSPLIT,$16
-       MOVL    $20, AX                 // sys_getpid
-       SYSCALL
-       MOVQ    AX, DI                  // arg 1 - pid
-       MOVL    sig+0(FP), SI           // arg 2 - signum
-       MOVL    $122, AX                // sys_kill
-       SYSCALL
-       RET
-
-TEXT runtime·setitimer(SB),NOSPLIT,$-8
-       MOVL    mode+0(FP), DI          // arg 1 - which
-       MOVQ    new+8(FP), SI           // arg 2 - itv
-       MOVQ    old+16(FP), DX          // arg 3 - oitv
-       MOVL    $69, AX                 // sys_setitimer
-       SYSCALL
-       RET
-
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
-       MOVQ    $0, DI                  // arg 1 - clock_id
-       LEAQ    8(SP), SI               // arg 2 - tp
-       MOVL    $87, AX                 // sys_clock_gettime
-       SYSCALL
-       MOVQ    8(SP), AX               // sec
-       MOVQ    16(SP), DX              // nsec
-
-       // sec is in AX, nsec in DX
-       MOVQ    AX, sec+0(FP)
-       MOVL    DX, nsec+8(FP)
-       RET
-
-TEXT runtime·nanotime1(SB),NOSPLIT,$24
-       MOVQ    CLOCK_MONOTONIC, DI     // arg 1 - clock_id
-       LEAQ    8(SP), SI               // arg 2 - tp
-       MOVL    $87, AX                 // sys_clock_gettime
-       SYSCALL
-       MOVQ    8(SP), AX               // sec
-       MOVQ    16(SP), DX              // nsec
-
-       // sec is in AX, nsec in DX
-       // return nsec in AX
-       IMULQ   $1000000000, AX
-       ADDQ    DX, AX
-       MOVQ    AX, ret+0(FP)
-       RET
-
-TEXT runtime·sigaction(SB),NOSPLIT,$-8
-       MOVL    sig+0(FP), DI           // arg 1 - signum
-       MOVQ    new+8(FP), SI           // arg 2 - nsa
-       MOVQ    old+16(FP), DX          // arg 3 - osa
-       MOVL    $46, AX
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $0xf1, 0xf1             // crash
-       RET
-
-TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0
-       MOVL    how+0(FP), DI           // arg 1 - how
-       MOVL    new+4(FP), SI           // arg 2 - set
-       MOVL    $48, AX                 // sys_sigprocmask
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $0xf1, 0xf1             // crash
-       MOVL    AX, ret+8(FP)
+       // Someday the convention will be D is always cleared.
+       CLD
+
+       CALL    runtime·mstart(SB)
+
+       // Restore callee-save registers.
+       MOVQ    0(SP), BX
+       MOVQ    8(SP), BP
+       MOVQ    16(SP), R12
+       MOVQ    24(SP), R13
+       MOVQ    32(SP), R14
+       MOVQ    40(SP), R15
+
+       // Go is all done with this OS thread.
+       // Tell pthread everything is ok (we never join with this thread, so
+       // the value here doesn't really matter).
+       XORL    AX, AX
+
+       ADDQ    $48, SP
        RET
 
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
@@ -288,129 +97,692 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$72
        MOVQ    bx-8(SP),   BX
        RET
 
-TEXT runtime·mmap(SB),NOSPLIT,$0
-       MOVQ    addr+0(FP), DI          // arg 1 - addr
-       MOVQ    n+8(FP), SI             // arg 2 - len
-       MOVL    prot+16(FP), DX         // arg 3 - prot
-       MOVL    flags+20(FP), R10               // arg 4 - flags
-       MOVL    fd+24(FP), R8           // arg 5 - fd
-       MOVL    off+28(FP), R9
+//
+// These trampolines help convert from Go calling convention to C calling convention.
+// They should be called with asmcgocall.
+// A pointer to the arguments is passed in DI.
+// A single int32 result is returned in AX.
+// (For more results, make an args/results structure.)
+TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    0(DI), DI               // arg 1 - attr
+       CALL    libc_pthread_attr_init(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    0(DI), DI               // arg 1 - attr
+       CALL    libc_pthread_attr_destroy(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 - stacksize
+       MOVQ    0(DI), DI               // arg 1 - attr
+       CALL    libc_pthread_attr_getstacksize(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 - detachstate
+       MOVQ    0(DI), DI               // arg 1 - attr
+       CALL    libc_pthread_attr_setdetachstate(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
        SUBQ    $16, SP
-       MOVQ    R9, 8(SP)               // arg 7 - offset (passed on stack)
-       MOVQ    $0, R9                  // arg 6 - pad
-       MOVL    $197, AX
-       SYSCALL
-       JCC     ok
-       ADDQ    $16, SP
-       MOVQ    $0, p+32(FP)
-       MOVQ    AX, err+40(FP)
+       MOVQ    0(DI), SI               // arg 2 - attr
+       MOVQ    8(DI), DX               // arg 3 - start
+       MOVQ    16(DI), CX              // arg 4 - arg
+       MOVQ    SP, DI                  // arg 1 - &thread (discarded)
+       CALL    libc_pthread_create(SB)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 - signal
+       MOVQ    $0, DX                  // arg 3 - tcb
+       MOVL    0(DI), DI               // arg 1 - tid
+       CALL    libc_thrkill(SB)
+       POPQ    BP
        RET
+
+TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 - clock_id
+       MOVQ    16(DI), DX              // arg 3 - abstime
+       MOVQ    24(DI), CX              // arg 4 - lock
+       MOVQ    32(DI), R8              // arg 5 - abort
+       MOVQ    0(DI), DI               // arg 1 - id
+       CALL    libc_thrsleep(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 - count
+       MOVQ    0(DI), DI               // arg 1 - id
+       CALL    libc_thrwakeup(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    0(DI), DI               // arg 1 exit status
+       CALL    libc_exit(SB)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    DI, BX                  // BX is caller-save
+       CALL    libc_getthrid(SB)
+       MOVL    AX, 0(BX)               // return value
+       POPQ    BP
+       RET
+
+TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    0(DI), BX       // signal
+       CALL    libc_getpid(SB)
+       MOVL    AX, DI          // arg 1 pid
+       MOVL    BX, SI          // arg 2 signal
+       CALL    libc_kill(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       CALL    libc_sched_yield(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP                      // make a frame; keep stack aligned
+       MOVQ    SP, BP
+       MOVQ    DI, BX
+       MOVQ    0(BX), DI               // arg 1 addr
+       MOVQ    8(BX), SI               // arg 2 len
+       MOVL    16(BX), DX              // arg 3 prot
+       MOVL    20(BX), CX              // arg 4 flags
+       MOVL    24(BX), R8              // arg 5 fid
+       MOVL    28(BX), R9              // arg 6 offset
+       CALL    libc_mmap(SB)
+       XORL    DX, DX
+       CMPQ    AX, $-1
+       JNE     ok
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), DX                // errno
+       XORQ    AX, AX
 ok:
-       ADDQ    $16, SP
-       MOVQ    AX, p+32(FP)
-       MOVQ    $0, err+40(FP)
+       MOVQ    AX, 32(BX)
+       MOVQ    DX, 40(BX)
+       POPQ    BP
+       RET
+
+TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 len
+       MOVQ    0(DI), DI               // arg 1 addr
+       CALL    libc_munmap(SB)
+       TESTQ   AX, AX
+       JEQ     2(PC)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI       // arg 2 len
+       MOVL    16(DI), DX      // arg 3 advice
+       MOVQ    0(DI), DI       // arg 1 addr
+       CALL    libc_madvise(SB)
+       // ignore failure - maybe pages are locked
+       POPQ    BP
+       RET
+
+TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 - flags
+       MOVL    12(DI), DX              // arg 3 - mode
+       MOVQ    0(DI), DI               // arg 1 - path
+       XORL    AX, AX                  // vararg: say "no float args"
+       CALL    libc_open(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    0(DI), DI               // arg 1 - fd
+       CALL    libc_close(SB)
+       POPQ    BP
        RET
 
-TEXT runtime·munmap(SB),NOSPLIT,$0
-       MOVQ    addr+0(FP), DI          // arg 1 - addr
-       MOVQ    n+8(FP), SI             // arg 2 - len
-       MOVL    $73, AX                 // sys_munmap
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $0xf1, 0xf1             // crash
+TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 - buf
+       MOVL    16(DI), DX              // arg 3 - count
+       MOVL    0(DI), DI               // arg 1 - fd
+       CALL    libc_read(SB)
+       TESTL   AX, AX
+       JGE     noerr
+       CALL    libc_errno(SB)
+       MOVL    (AX), AX                // errno
+       NEGL    AX                      // caller expects negative errno value
+noerr:
+       POPQ    BP
        RET
 
-TEXT runtime·madvise(SB),NOSPLIT,$0
-       MOVQ    addr+0(FP), DI          // arg 1 - addr
-       MOVQ    n+8(FP), SI             // arg 2 - len
-       MOVL    flags+16(FP), DX        // arg 3 - behav
-       MOVQ    $75, AX                 // sys_madvise
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $-1, AX
-       MOVL    AX, ret+24(FP)
+TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 buf
+       MOVL    16(DI), DX              // arg 3 count
+       MOVL    0(DI), DI               // arg 1 fd
+       CALL    libc_write(SB)
+       TESTL   AX, AX
+       JGE     noerr
+       CALL    libc_errno(SB)
+       MOVL    (AX), AX                // errno
+       NEGL    AX                      // caller expects negative errno value
+noerr:
+       POPQ    BP
        RET
 
-TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
-       MOVQ    new+0(FP), DI           // arg 1 - nss
-       MOVQ    old+8(FP), SI           // arg 2 - oss
-       MOVQ    $288, AX                // sys_sigaltstack
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $0xf1, 0xf1             // crash
+TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 flags
+       MOVQ    0(DI), DI               // arg 1 filedes
+       CALL    libc_pipe2(SB)
+       TESTL   AX, AX
+       JEQ     3(PC)
+       CALL    libc_errno(SB)
+       MOVL    (AX), AX                // errno
+       NEGL    AX                      // caller expects negative errno value
+       POPQ    BP
        RET
 
-// set tls base to DI
-TEXT runtime·settls(SB),NOSPLIT,$0
-       // adjust for ELF: wants to use -8(FS) for g
-       ADDQ    $8, DI
-       MOVQ    $329, AX                // sys___settcb
-       SYSCALL
-       JCC     2(PC)
-       MOVL    $0xf1, 0xf1             // crash
-       RET
-
-TEXT runtime·sysctl(SB),NOSPLIT,$0
-       MOVQ    mib+0(FP), DI           // arg 1 - name
-       MOVL    miblen+8(FP), SI                // arg 2 - namelen
-       MOVQ    out+16(FP), DX          // arg 3 - oldp
-       MOVQ    size+24(FP), R10                // arg 4 - oldlenp
-       MOVQ    dst+32(FP), R8          // arg 5 - newp
-       MOVQ    ndst+40(FP), R9         // arg 6 - newlen
-       MOVQ    $202, AX                // sys___sysctl
-       SYSCALL
-       JCC     4(PC)
-       NEGQ    AX
-       MOVL    AX, ret+48(FP)
-       RET
-       MOVL    $0, AX
-       MOVL    AX, ret+48(FP)
-       RET
-
-// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),NOSPLIT,$0
-       MOVL    $269, AX
-       SYSCALL
-       JCC     2(PC)
-       NEGQ    AX
-       MOVL    AX, ret+0(FP)
-       RET
-
-// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),NOSPLIT,$0
-       MOVL    kq+0(FP), DI
-       MOVQ    ch+8(FP), SI
-       MOVL    nch+16(FP), DX
-       MOVQ    ev+24(FP), R10
-       MOVL    nev+32(FP), R8
-       MOVQ    ts+40(FP), R9
-       MOVL    $72, AX
-       SYSCALL
-       JCC     2(PC)
-       NEGQ    AX
-       MOVL    AX, ret+48(FP)
-       RET
-
-// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),NOSPLIT,$0
-       MOVL    fd+0(FP), DI    // fd
-       MOVQ    $2, SI          // F_SETFD
-       MOVQ    $1, DX          // FD_CLOEXEC
-       MOVL    $92, AX         // fcntl
-       SYSCALL
-       RET
-
-// func runtime·setNonblock(int32 fd)
-TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
-       MOVL    fd+0(FP), DI  // fd
-       MOVQ    $3, SI  // F_GETFL
-       MOVQ    $0, DX
-       MOVL    $92, AX // fcntl
-       SYSCALL
-       MOVL    fd+0(FP), DI // fd
-       MOVQ    $4, SI // F_SETFL
-       MOVQ    $4, DX // O_NONBLOCK
-       ORL     AX, DX
-       MOVL    $92, AX // fcntl
-       SYSCALL
+TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 new
+       MOVQ    16(DI), DX              // arg 3 old
+       MOVL    0(DI), DI               // arg 1 which
+       CALL    libc_setitimer(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    0(DI), DI               // arg 1 usec
+       CALL    libc_usleep(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    8(DI), SI               // arg 2 miblen
+       MOVQ    16(DI), DX              // arg 3 out
+       MOVQ    24(DI), CX              // arg 4 size
+       MOVQ    32(DI), R8              // arg 5 dst
+       MOVQ    40(DI), R9              // arg 6 ndst
+       MOVQ    0(DI), DI               // arg 1 mib
+       CALL    libc_sysctl(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       CALL    libc_kqueue(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 keventt
+       MOVL    16(DI), DX              // arg 3 nch
+       MOVQ    24(DI), CX              // arg 4 ev
+       MOVL    32(DI), R8              // arg 5 nev
+       MOVQ    40(DI), R9              // arg 6 ts
+       MOVL    0(DI), DI               // arg 1 kq
+       CALL    libc_kevent(SB)
+       CMPL    AX, $-1
+       JNE     ok
+       CALL    libc_errno(SB)
+       MOVL    (AX), AX                // errno
+       NEGL    AX                      // caller expects negative errno value
+ok:
+       POPQ    BP
+       RET
+
+TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP                      // make a frame; keep stack aligned
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 tp
+       MOVL    0(DI), DI               // arg 1 clock_id
+       CALL    libc_clock_gettime(SB)
+       TESTL   AX, AX
+       JEQ     2(PC)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVL    4(DI), SI               // arg 2 cmd
+       MOVL    8(DI), DX               // arg 3 arg
+       MOVL    0(DI), DI               // arg 1 fd
+       XORL    AX, AX                  // vararg: say "no float args"
+       CALL    libc_fcntl(SB)
+       POPQ    BP
+       RET
+
+TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 new
+       MOVQ    16(DI), DX              // arg 3 old
+       MOVL    0(DI), DI               // arg 1 sig
+       CALL    libc_sigaction(SB)
+       TESTL   AX, AX
+       JEQ     2(PC)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI       // arg 2 new
+       MOVQ    16(DI), DX      // arg 3 old
+       MOVL    0(DI), DI       // arg 1 how
+       CALL    libc_pthread_sigmask(SB)
+       TESTL   AX, AX
+       JEQ     2(PC)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       MOVQ    8(DI), SI               // arg 2 old
+       MOVQ    0(DI), DI               // arg 1 new
+       CALL    libc_sigaltstack(SB)
+       TESTQ   AX, AX
+       JEQ     2(PC)
+       MOVL    $0xf1, 0xf1  // crash
+       POPQ    BP
+       RET
+
+// syscall calls a function in libc on behalf of the syscall package.
+// syscall takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $16, SP
+       MOVQ    (0*8)(DI), CX // fn
+       MOVQ    (2*8)(DI), SI // a2
+       MOVQ    (3*8)(DI), DX // a3
+       MOVQ    DI, (SP)
+       MOVQ    (1*8)(DI), DI // a1
+       XORL    AX, AX        // vararg: say "no float args"
+
+       CALL    CX
+
+       MOVQ    (SP), DI
+       MOVQ    AX, (4*8)(DI) // r1
+       MOVQ    DX, (5*8)(DI) // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMPL    AX, $-1       // Note: high 32 bits are junk
+       JNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (SP), DI
+       MOVQ    AX, (6*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+// syscallX calls a function in libc on behalf of the syscall package.
+// syscallX takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscallX must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscallX is like syscall but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscallX(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $16, SP
+       MOVQ    (0*8)(DI), CX // fn
+       MOVQ    (2*8)(DI), SI // a2
+       MOVQ    (3*8)(DI), DX // a3
+       MOVQ    DI, (SP)
+       MOVQ    (1*8)(DI), DI // a1
+       XORL    AX, AX        // vararg: say "no float args"
+
+       CALL    CX
+
+       MOVQ    (SP), DI
+       MOVQ    AX, (4*8)(DI) // r1
+       MOVQ    DX, (5*8)(DI) // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMPQ    AX, $-1
+       JNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (SP), DI
+       MOVQ    AX, (6*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+// syscall6 calls a function in libc on behalf of the syscall package.
+// syscall6 takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall6 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6 expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall6(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $16, SP
+       MOVQ    (0*8)(DI), R11// fn
+       MOVQ    (2*8)(DI), SI // a2
+       MOVQ    (3*8)(DI), DX // a3
+       MOVQ    (4*8)(DI), CX // a4
+       MOVQ    (5*8)(DI), R8 // a5
+       MOVQ    (6*8)(DI), R9 // a6
+       MOVQ    DI, (SP)
+       MOVQ    (1*8)(DI), DI // a1
+       XORL    AX, AX        // vararg: say "no float args"
+
+       CALL    R11
+
+       MOVQ    (SP), DI
+       MOVQ    AX, (7*8)(DI) // r1
+       MOVQ    DX, (8*8)(DI) // r2
+
+       CMPL    AX, $-1
+       JNE     ok
+
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (SP), DI
+       MOVQ    AX, (9*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+// syscall6X calls a function in libc on behalf of the syscall package.
+// syscall6X takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall6X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6X is like syscall6 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall6X(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $16, SP
+       MOVQ    (0*8)(DI), R11// fn
+       MOVQ    (2*8)(DI), SI // a2
+       MOVQ    (3*8)(DI), DX // a3
+       MOVQ    (4*8)(DI), CX // a4
+       MOVQ    (5*8)(DI), R8 // a5
+       MOVQ    (6*8)(DI), R9 // a6
+       MOVQ    DI, (SP)
+       MOVQ    (1*8)(DI), DI // a1
+       XORL    AX, AX        // vararg: say "no float args"
+
+       CALL    R11
+
+       MOVQ    (SP), DI
+       MOVQ    AX, (7*8)(DI) // r1
+       MOVQ    DX, (8*8)(DI) // r2
+
+       CMPQ    AX, $-1
+       JNE     ok
+
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (SP), DI
+       MOVQ    AX, (9*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+// syscall10 calls a function in libc on behalf of the syscall package.
+// syscall10 takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     a7    uintptr
+//     a8    uintptr
+//     a9    uintptr
+//     a10   uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall10 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+TEXT runtime·syscall10(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $48, SP
+
+       // Arguments a1 to a6 get passed in registers, with a7 onwards being
+       // passed via the stack per the x86-64 System V ABI
+       // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
+       MOVQ    (7*8)(DI), R10  // a7
+       MOVQ    (8*8)(DI), R11  // a8
+       MOVQ    (9*8)(DI), R12  // a9
+       MOVQ    (10*8)(DI), R13 // a10
+       MOVQ    R10, (0*8)(SP)  // a7
+       MOVQ    R11, (1*8)(SP)  // a8
+       MOVQ    R12, (2*8)(SP)  // a9
+       MOVQ    R13, (3*8)(SP)  // a10
+       MOVQ    (0*8)(DI), R11  // fn
+       MOVQ    (2*8)(DI), SI   // a2
+       MOVQ    (3*8)(DI), DX   // a3
+       MOVQ    (4*8)(DI), CX   // a4
+       MOVQ    (5*8)(DI), R8   // a5
+       MOVQ    (6*8)(DI), R9   // a6
+       MOVQ    DI, (4*8)(SP)
+       MOVQ    (1*8)(DI), DI   // a1
+       XORL    AX, AX          // vararg: say "no float args"
+
+       CALL    R11
+
+       MOVQ    (4*8)(SP), DI
+       MOVQ    AX, (11*8)(DI) // r1
+       MOVQ    DX, (12*8)(DI) // r2
+
+       CMPL    AX, $-1
+       JNE     ok
+
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (4*8)(SP), DI
+       MOVQ    AX, (13*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
+       RET
+
+// syscall10X calls a function in libc on behalf of the syscall package.
+// syscall10X takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     a7    uintptr
+//     a8    uintptr
+//     a9    uintptr
+//     a10   uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall10X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall10X is like syscall10 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall10X(SB),NOSPLIT,$0
+       PUSHQ   BP
+       MOVQ    SP, BP
+       SUBQ    $48, SP
+
+       // Arguments a1 to a6 get passed in registers, with a7 onwards being
+       // passed via the stack per the x86-64 System V ABI
+       // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
+       MOVQ    (7*8)(DI), R10  // a7
+       MOVQ    (8*8)(DI), R11  // a8
+       MOVQ    (9*8)(DI), R12  // a9
+       MOVQ    (10*8)(DI), R13 // a10
+       MOVQ    R10, (0*8)(SP)  // a7
+       MOVQ    R11, (1*8)(SP)  // a8
+       MOVQ    R12, (2*8)(SP)  // a9
+       MOVQ    R13, (3*8)(SP)  // a10
+       MOVQ    (0*8)(DI), R11  // fn
+       MOVQ    (2*8)(DI), SI   // a2
+       MOVQ    (3*8)(DI), DX   // a3
+       MOVQ    (4*8)(DI), CX   // a4
+       MOVQ    (5*8)(DI), R8   // a5
+       MOVQ    (6*8)(DI), R9   // a6
+       MOVQ    DI, (4*8)(SP)
+       MOVQ    (1*8)(DI), DI   // a1
+       XORL    AX, AX          // vararg: say "no float args"
+
+       CALL    R11
+
+       MOVQ    (4*8)(SP), DI
+       MOVQ    AX, (11*8)(DI) // r1
+       MOVQ    DX, (12*8)(DI) // r2
+
+       CMPQ    AX, $-1
+       JNE     ok
+
+       CALL    libc_errno(SB)
+       MOVLQSX (AX), AX
+       MOVQ    (4*8)(SP), DI
+       MOVQ    AX, (13*8)(DI) // err
+
+ok:
+       XORL    AX, AX        // no error (it's ignored anyway)
+       MOVQ    BP, SP
+       POPQ    BP
        RET

diff --git a/src/runtime/sys_openbsd_arm64.s b/src/runtime/sys_openbsd_arm64.s
index 621b1b1a42580af16b79e4366e936b8b89ceb14c..9b4acc90a58c88e3abc08d18b7d476a267c67692 100644 (file)
--- a/src/runtime/sys_openbsd_arm64.s
+++ b/src/runtime/sys_openbsd_arm64.s
@@ -3,7 +3,9 @@
 // license that can be found in the LICENSE file.
 //
 // System calls and other sys.stuff for arm64, OpenBSD
-// /usr/src/sys/kern/syscalls.master for syscall numbers.
+// System calls are implemented in libc/libpthread, this file
+// contains trampolines that convert from Go to C calling convention.
+// Some direct system call implementations currently remain.
 //
 
 #include "go_asm.h"
@@ -13,239 +15,65 @@
 #define CLOCK_REALTIME $0
 #define        CLOCK_MONOTONIC $3
 
-// With OpenBSD 6.7 onwards, an arm64 syscall returns two instructions
-// after the SVC instruction, to allow for a speculative execution
-// barrier to be placed after the SVC without impacting performance.
-// For now use hardware no-ops as this works with both older and newer
-// kernels. After OpenBSD 6.8 is released this should be changed to
-// speculation barriers.
-#define        INVOKE_SYSCALL  \
-       SVC;            \
-       NOOP;           \
-       NOOP
-
-// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0
-       MOVW    code+0(FP), R0          // arg 1 - status
-       MOVD    $1, R8                  // sys_exit
-       INVOKE_SYSCALL
-       BCC     3(PC)
-       MOVD    $0, R0                  // crash on syscall failure
-       MOVD    R0, (R0)
-       RET
+// mstart_stub is the first function executed on a new thread started by pthread_create.
+// It just does some low-level setup and then calls mstart.
+// Note: called with the C calling convention.
+TEXT runtime·mstart_stub(SB),NOSPLIT,$160
+       // R0 points to the m.
+       // We are already on m's g0 stack.
+
+       // Save callee-save registers.
+       MOVD    R19, 8(RSP)
+       MOVD    R20, 16(RSP)
+       MOVD    R21, 24(RSP)
+       MOVD    R22, 32(RSP)
+       MOVD    R23, 40(RSP)
+       MOVD    R24, 48(RSP)
+       MOVD    R25, 56(RSP)
+       MOVD    R26, 64(RSP)
+       MOVD    R27, 72(RSP)
+       MOVD    g, 80(RSP)
+       MOVD    R29, 88(RSP)
+       FMOVD   F8, 96(RSP)
+       FMOVD   F9, 104(RSP)
+       FMOVD   F10, 112(RSP)
+       FMOVD   F11, 120(RSP)
+       FMOVD   F12, 128(RSP)
+       FMOVD   F13, 136(RSP)
+       FMOVD   F14, 144(RSP)
+       FMOVD   F15, 152(RSP)
+
+       MOVD    m_g0(R0), g
+       BL      runtime·save_g(SB)
+
+       BL      runtime·mstart(SB)
 
-// func exitThread(wait *uint32)
-TEXT runtime·exitThread(SB),NOSPLIT,$0
-       MOVD    wait+0(FP), R0          // arg 1 - notdead
-       MOVD    $302, R8                // sys___threxit
-       INVOKE_SYSCALL
-       MOVD    $0, R0                  // crash on syscall failure
-       MOVD    R0, (R0)
-       JMP     0(PC)
-
-TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0
-       MOVD    name+0(FP), R0          // arg 1 - path
-       MOVW    mode+8(FP), R1          // arg 2 - mode
-       MOVW    perm+12(FP), R2         // arg 3 - perm
-       MOVD    $5, R8                  // sys_open
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       MOVW    $-1, R0
-       MOVW    R0, ret+16(FP)
-       RET
-
-TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0
-       MOVW    fd+0(FP), R0            // arg 1 - fd
-       MOVD    $6, R8                  // sys_close
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       MOVW    $-1, R0
-       MOVW    R0, ret+8(FP)
-       RET
-
-TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0
-       MOVW    fd+0(FP), R0            // arg 1 - fd
-       MOVD    p+8(FP), R1             // arg 2 - buf
-       MOVW    n+16(FP), R2            // arg 3 - nbyte
-       MOVD    $3, R8                  // sys_read
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, ret+24(FP)
-       RET
-
-// func pipe() (r, w int32, errno int32)
-TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12
-       MOVD    $r+0(FP), R0
-       MOVW    $0, R1
-       MOVD    $101, R8                // sys_pipe2
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, errno+8(FP)
-       RET
-
-// func pipe2(flags int32) (r, w int32, errno int32)
-TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
-       MOVD    $r+8(FP), R0
-       MOVW    flags+0(FP), R1
-       MOVD    $101, R8                // sys_pipe2
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, errno+16(FP)
-       RET
-
-TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0
-       MOVD    fd+0(FP), R0            // arg 1 - fd
-       MOVD    p+8(FP), R1             // arg 2 - buf
-       MOVW    n+16(FP), R2            // arg 3 - nbyte
-       MOVD    $4, R8                  // sys_write
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, ret+24(FP)
-       RET
-
-TEXT runtime·usleep(SB),NOSPLIT,$24-4
-       MOVWU   usec+0(FP), R3
-       MOVD    R3, R5
-       MOVW    $1000000, R4
-       UDIV    R4, R3
-       MOVD    R3, 8(RSP)              // tv_sec
-       MUL     R3, R4
-       SUB     R4, R5
-       MOVW    $1000, R4
-       MUL     R4, R5
-       MOVD    R5, 16(RSP)             // tv_nsec
-
-       ADD     $8, RSP, R0             // arg 1 - rqtp
-       MOVD    $0, R1                  // arg 2 - rmtp
-       MOVD    $91, R8                 // sys_nanosleep
-       INVOKE_SYSCALL
-       RET
-
-TEXT runtime·getthrid(SB),NOSPLIT,$0-4
-       MOVD    $299, R8                // sys_getthrid
-       INVOKE_SYSCALL
-       MOVW    R0, ret+0(FP)
-       RET
-
-TEXT runtime·thrkill(SB),NOSPLIT,$0-16
-       MOVW    tid+0(FP), R0           // arg 1 - tid
-       MOVD    sig+8(FP), R1           // arg 2 - signum
-       MOVW    $0, R2                  // arg 3 - tcb
-       MOVD    $119, R8                // sys_thrkill
-       INVOKE_SYSCALL
-       RET
-
-TEXT runtime·raiseproc(SB),NOSPLIT,$0
-       MOVD    $20, R8                 // sys_getpid
-       INVOKE_SYSCALL
-                                       // arg 1 - pid, already in R0
-       MOVW    sig+0(FP), R1           // arg 2 - signum
-       MOVD    $122, R8                // sys_kill
-       INVOKE_SYSCALL
-       RET
-
-TEXT runtime·mmap(SB),NOSPLIT,$0
-       MOVD    addr+0(FP), R0          // arg 1 - addr
-       MOVD    n+8(FP), R1             // arg 2 - len
-       MOVW    prot+16(FP), R2         // arg 3 - prot
-       MOVW    flags+20(FP), R3        // arg 4 - flags
-       MOVW    fd+24(FP), R4           // arg 5 - fd
-       MOVW    $0, R5                  // arg 6 - pad
-       MOVW    off+28(FP), R6          // arg 7 - offset
-       MOVD    $197, R8                // sys_mmap
-       INVOKE_SYSCALL
-       MOVD    $0, R1
-       BCC     3(PC)
-       MOVD    R0, R1                  // if error, move to R1
+       // Restore callee-save registers.
+       MOVD    8(RSP), R19
+       MOVD    16(RSP), R20
+       MOVD    24(RSP), R21
+       MOVD    32(RSP), R22
+       MOVD    40(RSP), R23
+       MOVD    48(RSP), R24
+       MOVD    56(RSP), R25
+       MOVD    64(RSP), R26
+       MOVD    72(RSP), R27
+       MOVD    80(RSP), g
+       MOVD    88(RSP), R29
+       FMOVD   96(RSP), F8
+       FMOVD   104(RSP), F9
+       FMOVD   112(RSP), F10
+       FMOVD   120(RSP), F11
+       FMOVD   128(RSP), F12
+       FMOVD   136(RSP), F13
+       FMOVD   144(RSP), F14
+       FMOVD   152(RSP), F15
+
+       // Go is all done with this OS thread.
+       // Tell pthread everything is ok (we never join with this thread, so
+       // the value here doesn't really matter).
        MOVD    $0, R0
-       MOVD    R0, p+32(FP)
-       MOVD    R1, err+40(FP)
-       RET
 
-TEXT runtime·munmap(SB),NOSPLIT,$0
-       MOVD    addr+0(FP), R0          // arg 1 - addr
-       MOVD    n+8(FP), R1             // arg 2 - len
-       MOVD    $73, R8                 // sys_munmap
-       INVOKE_SYSCALL
-       BCC     3(PC)
-       MOVD    $0, R0                  // crash on syscall failure
-       MOVD    R0, (R0)
-       RET
-
-TEXT runtime·madvise(SB),NOSPLIT,$0
-       MOVD    addr+0(FP), R0          // arg 1 - addr
-       MOVD    n+8(FP), R1             // arg 2 - len
-       MOVW    flags+16(FP), R2        // arg 2 - flags
-       MOVD    $75, R8                 // sys_madvise
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       MOVW    $-1, R0
-       MOVW    R0, ret+24(FP)
-       RET
-
-TEXT runtime·setitimer(SB),NOSPLIT,$0
-       MOVW    mode+0(FP), R0          // arg 1 - mode
-       MOVD    new+8(FP), R1           // arg 2 - new value
-       MOVD    old+16(FP), R2          // arg 3 - old value
-       MOVD    $69, R8                 // sys_setitimer
-       INVOKE_SYSCALL
-       RET
-
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
-       MOVW    CLOCK_REALTIME, R0      // arg 1 - clock_id
-       MOVD    $8(RSP), R1             // arg 2 - tp
-       MOVD    $87, R8                 // sys_clock_gettime
-       INVOKE_SYSCALL
-
-       MOVD    8(RSP), R0              // sec
-       MOVD    16(RSP), R1             // nsec
-       MOVD    R0, sec+0(FP)
-       MOVW    R1, nsec+8(FP)
-
-       RET
-
-// int64 nanotime1(void) so really
-// void nanotime1(int64 *nsec)
-TEXT runtime·nanotime1(SB),NOSPLIT,$32
-       MOVW    CLOCK_MONOTONIC, R0     // arg 1 - clock_id
-       MOVD    $8(RSP), R1             // arg 2 - tp
-       MOVD    $87, R8                 // sys_clock_gettime
-       INVOKE_SYSCALL
-
-       MOVW    8(RSP), R3              // sec
-       MOVW    16(RSP), R5             // nsec
-
-       MOVD    $1000000000, R4
-       MUL     R4, R3
-       ADD     R5, R3
-       MOVD    R3, ret+0(FP)
-       RET
-
-TEXT runtime·sigaction(SB),NOSPLIT,$0
-       MOVW    sig+0(FP), R0           // arg 1 - signum
-       MOVD    new+8(FP), R1           // arg 2 - new sigaction
-       MOVD    old+16(FP), R2          // arg 3 - old sigaction
-       MOVD    $46, R8                 // sys_sigaction
-       INVOKE_SYSCALL
-       BCC     3(PC)
-       MOVD    $3, R0                  // crash on syscall failure
-       MOVD    R0, (R0)
-       RET
-
-TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0
-       MOVW    how+0(FP), R0           // arg 1 - mode
-       MOVW    new+4(FP), R1           // arg 2 - new
-       MOVD    $48, R8                 // sys_sigprocmask
-       INVOKE_SYSCALL
-       BCC     3(PC)
-       MOVD    $3, R8                  // crash on syscall failure
-       MOVD    R8, (R8)
-       MOVW    R0, ret+8(FP)
        RET
 
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
@@ -282,9 +110,6 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$192
        // If called from an external code context, g will not be set.
        // Save R0, since runtime·load_g will clobber it.
        MOVW    R0, 8(RSP)              // signum
-       MOVB    runtime·iscgo(SB), R0
-       CMP     $0, R0
-       BEQ     2(PC)
        BL      runtime·load_g(SB)
 
        MOVD    R1, 16(RSP)
@@ -314,135 +139,562 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$192
 
        RET
 
-// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),NOSPLIT,$0
+//
+// These trampolines help convert from Go calling convention to C calling convention.
+// They should be called with asmcgocall.
+// A pointer to the arguments is passed in R0.
+// A single int32 result is returned in R0.
+// (For more results, make an args/results structure.)
+TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+       MOVD    0(R0), R0               // arg 1 - attr
+       CALL    libc_pthread_attr_init(SB)
+       RET
+
+TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
+       MOVD    0(R0), R0               // arg 1 - attr
+       CALL    libc_pthread_attr_destroy(SB)
+       RET
+
+TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - size
+       MOVD    0(R0), R0               // arg 1 - attr
+       CALL    libc_pthread_attr_getstacksize(SB)
+       RET
+
+TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - state
+       MOVD    0(R0), R0               // arg 1 - attr
+       CALL    libc_pthread_attr_setdetachstate(SB)
+       RET
+
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+       MOVD    0(R0), R1               // arg 2 - attr
+       MOVD    8(R0), R2               // arg 3 - start
+       MOVD    16(R0), R3              // arg 4 - arg
+       SUB     $16, RSP
+       MOVD    RSP, R0                 // arg 1 - &threadid (discard)
+       CALL    libc_pthread_create(SB)
+       ADD     $16, RSP
+       RET
+
+TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - signal
+       MOVD    $0, R2                  // arg 3 - tcb
+       MOVW    0(R0), R0               // arg 1 - tid
+       CALL    libc_thrkill(SB)
+       RET
+
+TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - clock_id
+       MOVD    16(R0), R2              // arg 3 - abstime
+       MOVD    24(R0), R3              // arg 4 - lock
+       MOVD    32(R0), R4              // arg 5 - abort
+       MOVD    0(R0), R0               // arg 1 - id
+       CALL    libc_thrsleep(SB)
+       RET
+
+TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - count
+       MOVD    0(R0), R0               // arg 1 - id
+       CALL    libc_thrwakeup(SB)
+       RET
+
+TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
+       MOVW    0(R0), R0               // arg 1 - status
+       CALL    libc_exit(SB)
+       MOVD    $0, R0                  // crash on failure
+       MOVD    R0, (R0)
+       RET
+
+TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+       CALL    libc_getthrid(SB)
+       MOVW    R0, 0(R19)              // return value
+       RET
+
+TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+       CALL    libc_getpid(SB)         // arg 1 - pid
+       MOVW    0(R19), R1              // arg 2 - signal
+       CALL    libc_kill(SB)
+       RET
+
+TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+       CALL    libc_sched_yield(SB)
+       RET
+
+TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+       MOVD    0(R19), R0              // arg 1 - addr
+       MOVD    8(R19), R1              // arg 2 - len
+       MOVW    16(R19), R2             // arg 3 - prot
+       MOVW    20(R19), R3             // arg 4 - flags
+       MOVW    24(R19), R4             // arg 5 - fid
+       MOVW    28(R19), R5             // arg 6 - offset
+       CALL    libc_mmap(SB)
+       MOVD    $0, R1
+       CMP     $-1, R0
+       BNE     noerr
+       CALL    libc_errno(SB)
+       MOVW    (R0), R1                // errno
+       MOVD    $0, R0
+noerr:
+       MOVD    R0, 32(R19)
+       MOVD    R1, 40(R19)
+       RET
+
+TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - len
+       MOVD    0(R0), R0               // arg 1 - addr
+       CALL    libc_munmap(SB)
+       CMP     $-1, R0
+       BNE     3(PC)
+       MOVD    $0, R0                  // crash on failure
+       MOVD    R0, (R0)
+       RET
+
+TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
+       MOVD    8(R0), R1               // arg 2 - len
+       MOVW    16(R0), R2              // arg 3 - advice
+       MOVD    0(R0), R0               // arg 1 - addr
+       CALL    libc_madvise(SB)
+       // ignore failure - maybe pages are locked
+       RET
+
+TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - flags
+       MOVW    12(R0), R2              // arg 3 - mode
+       MOVD    0(R0), R0               // arg 1 - path
+       MOVD    $0, R3                  // varargs
+       CALL    libc_open(SB)
+       RET
+
+TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+       MOVD    0(R0), R0               // arg 1 - fd
+       CALL    libc_close(SB)
+       RET
+
+TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - buf
+       MOVW    16(R0), R2              // arg 3 - count
+       MOVW    0(R0), R0               // arg 1 - fd
+       CALL    libc_read(SB)
+       CMP     $-1, R0
+       BNE     noerr
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0                // errno
+       NEG     R0, R0                  // caller expects negative errno value
+noerr:
+       RET
+
+TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - buf
+       MOVW    16(R0), R2              // arg 3 - count
+       MOVW    0(R0), R0               // arg 1 - fd
+       CALL    libc_write(SB)
+       CMP     $-1, R0
+       BNE     noerr
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0                // errno
+       NEG     R0, R0                  // caller expects negative errno value
+noerr:
+       RET
+
+TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - flags
+       MOVD    0(R0), R0               // arg 1 - filedes
+       CALL    libc_pipe2(SB)
+       CMP     $-1, R0
+       BNE     noerr
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0                // errno
+       NEG     R0, R0                  // caller expects negative errno value
+noerr:
+       RET
+
+TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - new
+       MOVD    16(R0), R2              // arg 3 - old
+       MOVW    0(R0), R0               // arg 1 - which
+       CALL    libc_setitimer(SB)
+       RET
+
+TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+       MOVD    0(R0), R0               // arg 1 - usec
+       CALL    libc_usleep(SB)
+       RET
+
+TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+       MOVW    8(R0), R1               // arg 2 - miblen
+       MOVD    16(R0), R2              // arg 3 - out
+       MOVD    24(R0), R3              // arg 4 - size
+       MOVD    32(R0), R4              // arg 5 - dst
+       MOVD    40(R0), R5              // arg 6 - ndst
+       MOVD    0(R0), R0               // arg 1 - mib
+       CALL    libc_sysctl(SB)
+       RET
+
+TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+       CALL    libc_kqueue(SB)
+       RET
+
+TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - keventt
+       MOVW    16(R0), R2              // arg 3 - nch
+       MOVD    24(R0), R3              // arg 4 - ev
+       MOVW    32(R0), R4              // arg 5 - nev
+       MOVD    40(R0), R5              // arg 6 - ts
+       MOVW    0(R0), R0               // arg 1 - kq
+       CALL    libc_kevent(SB)
+       CMP     $-1, R0
+       BNE     noerr
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0                // errno
+       NEG     R0, R0                  // caller expects negative errno value
+noerr:
+       RET
+
+TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - tp
+       MOVD    0(R0), R0               // arg 1 - clock_id
+       CALL    libc_clock_gettime(SB)
+       CMP     $-1, R0
+       BNE     3(PC)
+       MOVD    $0, R0                  // crash on failure
+       MOVD    R0, (R0)
+       RET
 
-       // Copy mp, gp and fn off parent stack for use by child.
-       MOVD    mm+16(FP), R4
-       MOVD    gg+24(FP), R5
-       MOVD    fn+32(FP), R6
+TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+       MOVW    4(R0), R1               // arg 2 - cmd
+       MOVW    8(R0), R2               // arg 3 - arg
+       MOVW    0(R0), R0               // arg 1 - fd
+       MOVD    $0, R3                  // vararg
+       CALL    libc_fcntl(SB)
+       RET
+
+TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - new
+       MOVD    16(R0), R2              // arg 3 - old
+       MOVW    0(R0), R0               // arg 1 - sig
+       CALL    libc_sigaction(SB)
+       CMP     $-1, R0
+       BNE     3(PC)
+       MOVD    $0, R0                  // crash on syscall failure
+       MOVD    R0, (R0)
+       RET
+
+TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - new
+       MOVD    16(R0), R2              // arg 3 - old
+       MOVW    0(R0), R0               // arg 1 - how
+       CALL    libc_pthread_sigmask(SB)
+       CMP     $-1, R0
+       BNE     3(PC)
+       MOVD    $0, R0                  // crash on syscall failure
+       MOVD    R0, (R0)
+       RET
 
-       MOVD    param+0(FP), R0         // arg 1 - param
-       MOVD    psize+8(FP), R1         // arg 2 - psize
-       MOVD    $8, R8                  // sys___tfork
-       INVOKE_SYSCALL
-
-       // Return if syscall failed.
-       BCC     4(PC)
-       NEG     R0,  R0
-       MOVW    R0, ret+40(FP)
+TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+       MOVD    8(R0), R1               // arg 2 - old
+       MOVD    0(R0), R0               // arg 1 - new
+       CALL    libc_sigaltstack(SB)
+       CMP     $-1, R0
+       BNE     3(PC)
+       MOVD    $0, R0                  // crash on syscall failure
+       MOVD    R0, (R0)
        RET
 
-       // In parent, return.
-       CMP     $0, R0
-       BEQ     3(PC)
-       MOVW    R0, ret+40(FP)
-       RET
-
-       // Initialise m, g.
-       MOVD    R5, g
-       MOVD    R4, g_m(g)
-
-       // Call fn.
-       BL      (R6)
-
-       // fn should never return.
-       MOVD    $2, R8                  // crash if reached
-       MOVD    R8, (R8)
-       RET
-
-TEXT runtime·sigaltstack(SB),NOSPLIT,$0
-       MOVD    new+0(FP), R0           // arg 1 - new sigaltstack
-       MOVD    old+8(FP), R1           // arg 2 - old sigaltstack
-       MOVD    $288, R8                // sys_sigaltstack
-       INVOKE_SYSCALL
-       BCC     3(PC)
-       MOVD    $0, R8                  // crash on syscall failure
-       MOVD    R8, (R8)
-       RET
-
-TEXT runtime·osyield(SB),NOSPLIT,$0
-       MOVD    $298, R8                // sys_sched_yield
-       INVOKE_SYSCALL
-       RET
-
-TEXT runtime·thrsleep(SB),NOSPLIT,$0
-       MOVD    ident+0(FP), R0         // arg 1 - ident
-       MOVW    clock_id+8(FP), R1      // arg 2 - clock_id
-       MOVD    tsp+16(FP), R2          // arg 3 - tsp
-       MOVD    lock+24(FP), R3         // arg 4 - lock
-       MOVD    abort+32(FP), R4        // arg 5 - abort
-       MOVD    $94, R8                 // sys___thrsleep
-       INVOKE_SYSCALL
-       MOVW    R0, ret+40(FP)
-       RET
-
-TEXT runtime·thrwakeup(SB),NOSPLIT,$0
-       MOVD    ident+0(FP), R0         // arg 1 - ident
-       MOVW    n+8(FP), R1             // arg 2 - n
-       MOVD    $301, R8                // sys___thrwakeup
-       INVOKE_SYSCALL
-       MOVW    R0, ret+16(FP)
-       RET
-
-TEXT runtime·sysctl(SB),NOSPLIT,$0
-       MOVD    mib+0(FP), R0           // arg 1 - mib
-       MOVW    miblen+8(FP), R1        // arg 2 - miblen
-       MOVD    out+16(FP), R2          // arg 3 - out
-       MOVD    size+24(FP), R3         // arg 4 - size
-       MOVD    dst+32(FP), R4          // arg 5 - dest
-       MOVD    ndst+40(FP), R5         // arg 6 - newlen
-       MOVD    $202, R8                // sys___sysctl
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, ret+48(FP)
-       RET
-
-// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),NOSPLIT,$0
-       MOVD    $269, R8                // sys_kqueue
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, ret+0(FP)
-       RET
-
-// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),NOSPLIT,$0
-       MOVW    kq+0(FP), R0            // arg 1 - kq
-       MOVD    ch+8(FP), R1            // arg 2 - changelist
-       MOVW    nch+16(FP), R2          // arg 3 - nchanges
-       MOVD    ev+24(FP), R3           // arg 4 - eventlist
-       MOVW    nev+32(FP), R4          // arg 5 - nevents
-       MOVD    ts+40(FP), R5           // arg 6 - timeout
-       MOVD    $72, R8                 // sys_kevent
-       INVOKE_SYSCALL
-       BCC     2(PC)
-       NEG     R0, R0
-       MOVW    R0, ret+48(FP)
-       RET
-
-// func closeonexec(fd int32)
-TEXT runtime·closeonexec(SB),NOSPLIT,$0
-       MOVW    fd+0(FP), R0            // arg 1 - fd
-       MOVD    $2, R1                  // arg 2 - cmd (F_SETFD)
-       MOVD    $1, R2                  // arg 3 - arg (FD_CLOEXEC)
-       MOVD    $92, R8                 // sys_fcntl
-       INVOKE_SYSCALL
-       RET
-
-// func runtime·setNonblock(int32 fd)
-TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4
-       MOVW    fd+0(FP), R0            // arg 1 - fd
-       MOVD    $3, R1                  // arg 2 - cmd (F_GETFL)
-       MOVD    $0, R2                  // arg 3
-       MOVD    $92, R8                 // sys_fcntl
-       INVOKE_SYSCALL
-       MOVD    $4, R2                  // O_NONBLOCK
-       ORR     R0, R2                  // arg 3 - flags
-       MOVW    fd+0(FP), R0            // arg 1 - fd
-       MOVD    $4, R1                  // arg 2 - cmd (F_SETFL)
-       MOVD    $92, R8                 // sys_fcntl
-       INVOKE_SYSCALL
+// syscall calls a function in libc on behalf of the syscall package.
+// syscall takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    $0, R3                  // vararg
+
+       CALL    R11
+
+       MOVD    R0, (4*8)(R19)          // r1
+       MOVD    R1, (5*8)(R19)          // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMPW    $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (6*8)(R19)          // err
+
+ok:
+       RET
+
+// syscallX calls a function in libc on behalf of the syscall package.
+// syscallX takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscallX must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscallX is like syscall but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscallX(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    $0, R3                  // vararg
+
+       CALL    R11
+
+       MOVD    R0, (4*8)(R19)          // r1
+       MOVD    R1, (5*8)(R19)          // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMP     $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (6*8)(R19)          // err
+
+ok:
+       RET
+
+// syscall6 calls a function in libc on behalf of the syscall package.
+// syscall6 takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall6 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6 expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall6(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    (4*8)(R19), R3          // a4
+       MOVD    (5*8)(R19), R4          // a5
+       MOVD    (6*8)(R19), R5          // a6
+       MOVD    $0, R6                  // vararg
+
+       CALL    R11
+
+       MOVD    R0, (7*8)(R19)          // r1
+       MOVD    R1, (8*8)(R19)          // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMPW    $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (9*8)(R19)          // err
+
+ok:
+       RET
+
+// syscall6X calls a function in libc on behalf of the syscall package.
+// syscall6X takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall6X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6X is like syscall6 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall6X(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    (4*8)(R19), R3          // a4
+       MOVD    (5*8)(R19), R4          // a5
+       MOVD    (6*8)(R19), R5          // a6
+       MOVD    $0, R6                  // vararg
+
+       CALL    R11
+
+       MOVD    R0, (7*8)(R19)          // r1
+       MOVD    R1, (8*8)(R19)          // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMP     $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (9*8)(R19)          // err
+
+ok:
+       RET
+
+// syscall10 calls a function in libc on behalf of the syscall package.
+// syscall10 takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     a7    uintptr
+//     a8    uintptr
+//     a9    uintptr
+//     a10   uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall10 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+TEXT runtime·syscall10(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    (4*8)(R19), R3          // a4
+       MOVD    (5*8)(R19), R4          // a5
+       MOVD    (6*8)(R19), R5          // a6
+       MOVD    (7*8)(R19), R6          // a7
+       MOVD    (8*8)(R19), R7          // a8
+       MOVD    (9*8)(R19), R8          // a9
+       MOVD    (10*8)(R19), R9         // a10
+       MOVD    $0, R10                 // vararg
+
+       CALL    R11
+
+       MOVD    R0, (11*8)(R19)         // r1
+       MOVD    R1, (12*8)(R19)         // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMPW    $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (13*8)(R19)         // err
+
+ok:
+       RET
+
+// syscall10X calls a function in libc on behalf of the syscall package.
+// syscall10X takes a pointer to a struct like:
+// struct {
+//     fn    uintptr
+//     a1    uintptr
+//     a2    uintptr
+//     a3    uintptr
+//     a4    uintptr
+//     a5    uintptr
+//     a6    uintptr
+//     a7    uintptr
+//     a8    uintptr
+//     a9    uintptr
+//     a10   uintptr
+//     r1    uintptr
+//     r2    uintptr
+//     err   uintptr
+// }
+// syscall10X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall10X is like syscall10 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall10X(SB),NOSPLIT,$0
+       MOVD    R0, R19                 // pointer to args
+
+       MOVD    (0*8)(R19), R11         // fn
+       MOVD    (1*8)(R19), R0          // a1
+       MOVD    (2*8)(R19), R1          // a2
+       MOVD    (3*8)(R19), R2          // a3
+       MOVD    (4*8)(R19), R3          // a4
+       MOVD    (5*8)(R19), R4          // a5
+       MOVD    (6*8)(R19), R5          // a6
+       MOVD    (7*8)(R19), R6          // a7
+       MOVD    (8*8)(R19), R7          // a8
+       MOVD    (9*8)(R19), R8          // a9
+       MOVD    (10*8)(R19), R9         // a10
+       MOVD    $0, R10                 // vararg
+
+       CALL    R11
+
+       MOVD    R0, (11*8)(R19)         // r1
+       MOVD    R1, (12*8)(R19)         // r2
+
+       // Standard libc functions return -1 on error
+       // and set errno.
+       CMP     $-1, R0
+       BNE     ok
+
+       // Get error code from libc.
+       CALL    libc_errno(SB)
+       MOVW    (R0), R0
+       MOVD    R0, (13*8)(R19)         // err
+
+ok:
        RET

diff --git a/src/runtime/sys_wasm.go b/src/runtime/sys_wasm.go
index 9bf710ba0e799d3213eb865e1a0f0106e59ceb12..057ed4ccd90a7513ff8211f00a7685d450bfeef5 100644 (file)
--- a/src/runtime/sys_wasm.go
+++ b/src/runtime/sys_wasm.go
@@ -27,13 +27,9 @@ func wasmTruncU()
 func wasmExit(code int32)
 
 // adjust Gobuf as it if executed a call to fn with context ctxt
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
        sp := buf.sp
-       if sys.RegSize > sys.PtrSize {
-               sp -= sys.PtrSize
-               *(*uintptr)(unsafe.Pointer(sp)) = 0
-       }
        sp -= sys.PtrSize
        *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
        buf.sp = sp

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index ef8a3dd3c27d67a2358c2d8f931ea9326abb719b..4f00c58c16862006411e0b725e16e8f6c8c0a794 100644 (file)
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -66,11 +66,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
        MOVL    AX, ret+0(FP)
        RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT,$0
-       MOVL    err+0(FP), AX
-       MOVL    AX, 0x34(FS)
-       RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
@@ -99,7 +94,7 @@ TEXT sigtramp<>(SB),NOSPLIT,$0-0
        JNE     2(PC)
        CALL    runtime·badsignal2(SB)
 
-       // save g and SP in case of stack switch
+       // save g in case of stack switch
        MOVL    DX, 32(SP)      // g
        MOVL    SP, 36(SP)
 
@@ -113,13 +108,9 @@ TEXT sigtramp<>(SB),NOSPLIT,$0-0
        get_tls(BP)
        MOVL    BX, g(BP)
        MOVL    (g_sched+gobuf_sp)(BX), DI
-       // make it look like mstart called us on g0, to stop traceback
-       SUBL    $4, DI
-       MOVL    $runtime·mstart(SB), 0(DI)
-       // traceback will think that we've done SUBL
-       // on this stack, so subtract them here to match.
-       // (we need room for sighandler arguments anyway).
+       // make room for sighandler arguments
        // and re-save old SP for restoring later.
+       // (note that the 36(DI) here must match the 36(SP) above.)
        SUBL    $40, DI
        MOVL    SP, 36(DI)
        MOVL    DI, SP
@@ -137,7 +128,7 @@ g0:
        // switch back to original stack and g
        // no-op if we never left.
        MOVL    36(SP), SP
-       MOVL    32(SP), DX
+       MOVL    32(SP), DX      // note: different SP
        get_tls(BP)
        MOVL    DX, g(BP)
 
@@ -183,7 +174,7 @@ TEXT runtime·profileloop(SB),NOSPLIT,$0
        ADDL    $12, SP
        JMP     CX
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$0
        PUSHL   BP
        MOVL    SP, BP
        PUSHL   BX
@@ -347,60 +338,11 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
        MOVL    CX, 0x14(FS)
        RET
 
-// onosstack calls fn on OS stack.
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-       MOVL    fn+0(FP), AX            // to hide from 8l
-       MOVL    arg+4(FP), BX
-
-       // Execute call on m->g0 stack, in case we are not actually
-       // calling a system call wrapper, like when running under WINE.
-       get_tls(CX)
-       CMPL    CX, $0
-       JNE     3(PC)
-       // Not a Go-managed thread. Do not switch stack.
-       CALL    AX
-       RET
-
-       MOVL    g(CX), BP
-       MOVL    g_m(BP), BP
-
-       // leave pc/sp for cpu profiler
-       MOVL    (SP), SI
-       MOVL    SI, m_libcallpc(BP)
-       MOVL    g(CX), SI
-       MOVL    SI, m_libcallg(BP)
-       // sp must be the last, because once async cpu profiler finds
-       // all three values to be non-zero, it will use them
-       LEAL    fn+0(FP), SI
-       MOVL    SI, m_libcallsp(BP)
-
-       MOVL    m_g0(BP), SI
-       CMPL    g(CX), SI
-       JNE     switch
-       // executing on m->g0 already
-       CALL    AX
-       JMP     ret
-
-switch:
-       // Switch to m->g0 stack and back.
-       MOVL    (g_sched+gobuf_sp)(SI), SI
-       MOVL    SP, -4(SI)
-       LEAL    -4(SI), SP
-       CALL    AX
-       MOVL    0(SP), SP
-
-ret:
-       get_tls(CX)
-       MOVL    g(CX), BP
-       MOVL    g_m(BP), BP
-       MOVL    $0, m_libcallsp(BP)
-       RET
-
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2(SB),NOSPLIT,$20
-       // Want negative 100ns units.
-       NEGL    BX
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT,$20-4
+       MOVL    dt+0(FP), BX
        MOVL    $-1, hi-4(SP)
        MOVL    BX, lo-8(SP)
        LEAL    lo-8(SP), BX
@@ -413,17 +355,15 @@ TEXT runtime·usleep2(SB),NOSPLIT,$20
        MOVL    BP, SP
        RET
 
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36
-       get_tls(CX)
-       CMPL    CX, $0
-       JE      gisnotset
-
-       // Want negative 100ns units.
-       NEGL    BX
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36-4
+       MOVL    dt+0(FP), BX
        MOVL    $-1, hi-4(SP)
        MOVL    BX, lo-8(SP)
 
+       get_tls(CX)
        MOVL    g(CX), CX
        MOVL    g_m(CX), CX
        MOVL    (m_mOS+mOS_highResTimer)(CX), CX
@@ -452,12 +392,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36
 
        RET
 
-gisnotset:
-       // TLS is not configured. Call usleep2 instead.
-       MOVL    $runtime·usleep2(SB), AX
-       CALL    AX
-       RET
-
 // Runs on OS stack.
 TEXT runtime·switchtothread(SB),NOSPLIT,$0
        MOVL    SP, BP

diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index d1690cad587ba844094ab3bcfabad6406ebae0ea..aba2811e5978078b7af2ebe27aa8a225bb9571a7 100644 (file)
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -103,12 +103,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
        MOVL    AX, ret+0(FP)
        RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT,$0
-       MOVL    err+0(FP), AX
-       MOVQ    0x30(GS),       CX
-       MOVL    AX, 0x68(CX)
-       RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
@@ -157,16 +151,10 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
        get_tls(BP)
        MOVQ    BX, g(BP)
        MOVQ    (g_sched+gobuf_sp)(BX), DI
-       // make it look like mstart called us on g0, to stop traceback
-       SUBQ    $8, DI
-       MOVQ    $runtime·mstart(SB), SI
-       MOVQ    SI, 0(DI)
-       // traceback will think that we've done PUSHFQ and SUBQ
-       // on this stack, so subtract them here to match.
-       // (we need room for sighandler arguments anyway).
+       // make room for sighandler arguments
        // and re-save old SP for restoring later.
-       SUBQ    $(112+8), DI
-       // save g, save old stack pointer.
+       // (note that the 104(DI) here must match the 104(SP) above.)
+       SUBQ    $120, DI
        MOVQ    SP, 104(DI)
        MOVQ    DI, SP
 
@@ -227,7 +215,7 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$8
        CALL    runtime·externalthreadhandler(SB)
        RET
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
        PUSHQ   BP
        MOVQ    SP, BP
        PUSHQ   BX
@@ -388,61 +376,16 @@ TEXT runtime·settls(SB),NOSPLIT,$0
        MOVQ    DI, 0x28(GS)
        RET
 
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-       MOVQ    fn+0(FP), AX            // to hide from 6l
-       MOVL    arg+8(FP), BX
-
-       // Execute call on m->g0 stack, in case we are not actually
-       // calling a system call wrapper, like when running under WINE.
-       get_tls(R15)
-       CMPQ    R15, $0
-       JNE     3(PC)
-       // Not a Go-managed thread. Do not switch stack.
-       CALL    AX
-       RET
-
-       MOVQ    g(R15), R13
-       MOVQ    g_m(R13), R13
-
-       // leave pc/sp for cpu profiler
-       MOVQ    (SP), R12
-       MOVQ    R12, m_libcallpc(R13)
-       MOVQ    g(R15), R12
-       MOVQ    R12, m_libcallg(R13)
-       // sp must be the last, because once async cpu profiler finds
-       // all three values to be non-zero, it will use them
-       LEAQ    fn+0(FP), R12
-       MOVQ    R12, m_libcallsp(R13)
-
-       MOVQ    m_g0(R13), R14
-       CMPQ    g(R15), R14
-       JNE     switch
-       // executing on m->g0 already
-       CALL    AX
-       JMP     ret
-
-switch:
-       // Switch to m->g0 stack and back.
-       MOVQ    (g_sched+gobuf_sp)(R14), R14
-       MOVQ    SP, -8(R14)
-       LEAQ    -8(R14), SP
-       CALL    AX
-       MOVQ    0(SP), SP
-
-ret:
-       MOVQ    $0, m_libcallsp(R13)
-       RET
-
-// Runs on OS stack. duration (in 100ns units) is in BX.
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
 // The function leaves room for 4 syscall parameters
 // (as per windows amd64 calling convention).
-TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
+TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48-4
+       MOVLQSX dt+0(FP), BX
        MOVQ    SP, AX
        ANDQ    $~15, SP        // alignment as per Windows requirement
        MOVQ    AX, 40(SP)
-       // Want negative 100ns units.
-       NEGQ    BX
        LEAQ    32(SP), R8  // ptime
        MOVQ    BX, (R8)
        MOVQ    $-1, CX // handle
@@ -452,11 +395,11 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
        MOVQ    40(SP), SP
        RET
 
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
+// Runs on OS stack. duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72-4
+       MOVLQSX dt+0(FP), BX
        get_tls(CX)
-       CMPQ    CX, $0
-       JE      gisnotset
 
        MOVQ    SP, AX
        ANDQ    $~15, SP        // alignment as per Windows requirement
@@ -466,8 +409,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
        MOVQ    g_m(CX), CX
        MOVQ    (m_mOS+mOS_highResTimer)(CX), CX        // hTimer
        MOVQ    CX, 48(SP)                              // save hTimer for later
-       // Want negative 100ns units.
-       NEGQ    BX
        LEAQ    56(SP), DX                              // lpDueTime
        MOVQ    BX, (DX)
        MOVQ    $0, R8                                  // lPeriod
@@ -487,12 +428,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
        MOVQ    64(SP), SP
        RET
 
-gisnotset:
-       // TLS is not configured. Call usleep2 instead.
-       MOVQ    $runtime·usleep2(SB), AX
-       CALL    AX
-       RET
-
 // Runs on OS stack.
 TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
        MOVQ    SP, AX

diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index fe267080ccab8e1e7593d0e3a46408a5bf2a362f..cd230ccffd42b6e6958a366a75594e48d87e56cb 100644 (file)
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -6,6 +6,8 @@
 #include "go_tls.h"
 #include "textflag.h"
 
+// Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
+
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
        MOVM.DB.W [R4, R5, R14], (R13)  // push {r4, r5, lr}
@@ -103,11 +105,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
        MOVW    R0, ret+0(FP)
        RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT|NOFRAME,$0
-       MRC     15, 0, R1, C13, C0, 2
-       MOVW    R0, 0x34(R1)
-       RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
@@ -144,11 +141,10 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
        MOVW    (g_sched+gobuf_sp)(g), R3       // R3 = g->gobuf.sp
        BL      runtime·save_g(SB)
 
-       // traceback will think that we've done PUSH and SUB
-       // on this stack, so subtract them here to match.
-       // (we need room for sighandler arguments anyway).
+       // make room for sighandler arguments
        // and re-save old SP for restoring later.
-       SUB     $(40+8+20), R3
+       // (note that the 24(R3) here must match the 24(R13) above.)
+       SUB     $40, R3
        MOVW    R13, 24(R3)             // save old stack pointer
        MOVW    R3, R13                 // switch stack
 
@@ -156,22 +152,14 @@ g0:
        MOVW    0(R6), R2       // R2 = ExceptionPointers->ExceptionRecord
        MOVW    4(R6), R3       // R3 = ExceptionPointers->ContextRecord
 
-       // make it look like mstart called us on g0, to stop traceback
-       MOVW    $runtime·mstart(SB), R4
-
-       MOVW    R4, 0(R13)      // Save link register for traceback
+       MOVW    $0, R4
+       MOVW    R4, 0(R13)      // No saved link register.
        MOVW    R2, 4(R13)      // Move arg0 (ExceptionRecord) into position
        MOVW    R3, 8(R13)      // Move arg1 (ContextRecord) into position
        MOVW    R5, 12(R13)     // Move arg2 (original g) into position
        BL      (R7)            // Call the go routine
        MOVW    16(R13), R4     // Fetch return value from stack
 
-       // Compute the value of the g0 stack pointer after deallocating
-       // this frame, then allocating 8 bytes. We may need to store
-       // the resume SP and PC on the g0 stack to work around
-       // control flow guard when we resume from the exception.
-       ADD     $(40+20), R13, R12
-
        // switch back to original stack and g
        MOVW    24(R13), R13
        MOVW    20(R13), g
@@ -188,42 +176,45 @@ done:
        BEQ     return
 
        // Check if we need to set up the control flow guard workaround.
-       // On Windows/ARM, the stack pointer must lie within system
-       // stack limits when we resume from exception.
+       // On Windows, the stack pointer in the context must lie within
+       // system stack limits when we resume from exception.
        // Store the resume SP and PC on the g0 stack,
-       // and return to returntramp on the g0 stack. returntramp
+       // and return to sigresume on the g0 stack. sigresume
        // pops the saved PC and SP from the g0 stack, resuming execution
        // at the desired location.
-       // If returntramp has already been set up by a previous exception
+       // If sigresume has already been set up by a previous exception
        // handler, don't clobber the stored SP and PC on the stack.
        MOVW    4(R3), R3                       // PEXCEPTION_POINTERS->Context
-       MOVW    0x40(R3), R2                    // load PC from context record
-       MOVW    $returntramp<>(SB), R1
+       MOVW    context_pc(R3), R2              // load PC from context record
+       MOVW    $sigresume<>(SB), R1
        CMP     R1, R2
        B.EQ    return                          // do not clobber saved SP/PC
 
-       // Save resume SP and PC on g0 stack
-       MOVW    0x38(R3), R2                    // load SP from context record
-       MOVW    R2, 0(R12)                      // Store resume SP on g0 stack
-       MOVW    0x40(R3), R2                    // load PC from context record
-       MOVW    R2, 4(R12)                      // Store resume PC on g0 stack
+       // Save resume SP and PC into R0, R1.
+       MOVW    context_spr(R3), R2
+       MOVW    R2, context_r0(R3)
+       MOVW    context_pc(R3), R2
+       MOVW    R2, context_r1(R3)
 
-       // Set up context record to return to returntramp on g0 stack
-       MOVW    R12, 0x38(R3)                   // save g0 stack pointer
-                                               // in context record
-       MOVW    $returntramp<>(SB), R2  // save resume address
-       MOVW    R2, 0x40(R3)                    // in context record
+       // Set up context record to return to sigresume on g0 stack
+       MOVW    R12, context_spr(R3)
+       MOVW    $sigresume<>(SB), R2
+       MOVW    R2, context_pc(R3)
 
 return:
        B       (R14)                           // return
 
-//
 // Trampoline to resume execution from exception handler.
 // This is part of the control flow guard workaround.
 // It switches stacks and jumps to the continuation address.
-//
-TEXT returntramp<>(SB),NOSPLIT|NOFRAME,$0
-       MOVM.IA (R13), [R13, R15]               // ldm sp, [sp, pc]
+// R0 and R1 are set above at the end of sigtramp<>
+// in the context that starts executing at sigresume<>.
+TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
+       // Important: do not smash LR,
+       // which is set to a live value when handling
+       // a signal by pushing a call to sigpanic onto the stack.
+       MOVW    R0, R13
+       B       (R1)
 
 TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
        MOVW    $runtime·exceptionhandler(SB), R1
@@ -259,16 +250,17 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
 //   +----------------+
 // 12| argument (r0)  |
 //---+----------------+
-// 8 | param1         |
+// 8 | param1         | (also return value for called Go function)
 //   +----------------+
 // 4 | param0         |
 //   +----------------+
-// 0 | retval         |
+// 0 | slot for LR    |
 //   +----------------+
 //
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
        MOVM.DB.W [R4-R11, R14], (R13)          // push {r4-r11, lr}
        SUB     $(m__size + g__size + 20), R13  // space for locals
+       MOVW    R14, 0(R13)                     // push LR again for anything unwinding the stack
        MOVW    R0, 12(R13)
        MOVW    R1, 16(R13)
 
@@ -307,7 +299,7 @@ TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
        MOVW    $0, g
        BL      runtime·save_g(SB)
 
-       MOVW    0(R13), R0                      // load return value
+       MOVW    8(R13), R0                      // load return value
        ADD     $(m__size + g__size + 20), R13  // free locals
        MOVM.IA.W (R13), [R4-R11, R15]          // pop {r4-r11, pc}
 
@@ -359,9 +351,6 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
        MOVW    R0, g_m(g)
        BL      runtime·save_g(SB)
 
-       // do per-thread TLS initialization
-       BL      init_thread_tls<>(SB)
-
        // Layout new m scheduler stack on os stack.
        MOVW    R13, R0
        MOVW    R0, g_stack+stack_hi(g)
@@ -377,79 +366,11 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
        MOVW    $0, R0
        MOVM.IA.W (R13), [R4-R11, R15]          // pop {r4-r11, pc}
 
-// onosstack calls fn on OS stack.
-// adapted from asm_arm.s : systemstack
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-       MOVW    fn+0(FP), R5            // R5 = fn
-       MOVW    arg+4(FP), R6           // R6 = arg
-
-       // This function can be called when there is no g,
-       // for example, when we are handling a callback on a non-go thread.
-       // In this case we're already on the system stack.
-       CMP     $0, g
-       BEQ     noswitch
-
-       MOVW    g_m(g), R1              // R1 = m
-
-       MOVW    m_gsignal(R1), R2       // R2 = gsignal
-       CMP     g, R2
-       B.EQ    noswitch
-
-       MOVW    m_g0(R1), R2            // R2 = g0
-       CMP     g, R2
-       B.EQ    noswitch
-
-       MOVW    m_curg(R1), R3
-       CMP     g, R3
-       B.EQ    switch
-
-       // Bad: g is not gsignal, not g0, not curg. What is it?
-       // Hide call from linker nosplit analysis.
-       MOVW    $runtime·badsystemstack(SB), R0
-       BL      (R0)
-       B       runtime·abort(SB)
-
-switch:
-       // save our state in g->sched. Pretend to
-       // be systemstack_switch if the G stack is scanned.
-       MOVW    $runtime·systemstack_switch(SB), R3
-       ADD     $4, R3, R3 // get past push {lr}
-       MOVW    R3, (g_sched+gobuf_pc)(g)
-       MOVW    R13, (g_sched+gobuf_sp)(g)
-       MOVW    LR, (g_sched+gobuf_lr)(g)
-       MOVW    g, (g_sched+gobuf_g)(g)
-
-       // switch to g0
-       MOVW    R2, g
-       MOVW    (g_sched+gobuf_sp)(R2), R3
-       // make it look like mstart called systemstack on g0, to stop traceback
-       SUB     $4, R3, R3
-       MOVW    $runtime·mstart(SB), R4
-       MOVW    R4, 0(R3)
-       MOVW    R3, R13
-
-       // call target function
-       MOVW    R6, R0          // arg
-       BL      (R5)
-
-       // switch back to g
-       MOVW    g_m(g), R1
-       MOVW    m_curg(R1), g
-       MOVW    (g_sched+gobuf_sp)(g), R13
-       MOVW    $0, R3
-       MOVW    R3, (g_sched+gobuf_sp)(g)
-       RET
-
-noswitch:
-       // Using a tail call here cleans up tracebacks since we won't stop
-       // at an intermediate systemstack.
-       MOVW.P  4(R13), R14     // restore LR
-       MOVW    R6, R0          // arg
-       B       (R5)
-
-// Runs on OS stack. Duration (in 100ns units) is in R0.
-TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
+       MOVW    dt+0(FP), R0
        MOVM.DB.W [R4, R14], (R13)      // push {r4, lr}
        MOVW    R13, R4                 // Save SP
        SUB     $8, R13                 // R13 = R13 - 8
@@ -465,9 +386,11 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0
        MOVW    R4, R13                 // Restore SP
        MOVM.IA.W (R13), [R4, R15]      // pop {R4, pc}
 
-// Runs on OS stack. Duration (in 100ns units) is in R0.
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
 // TODO: neeeds to be implemented properly.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0-4
        B       runtime·abort(SB)
 
 // Runs on OS stack.
@@ -497,7 +420,7 @@ TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 #define time_hi1 4
 #define time_hi2 8
 
-TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
+TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
        MOVW    $0, R0
        MOVB    runtime·useQPCTime(SB), R0
        CMP     $0, R0
@@ -521,9 +444,8 @@ loop:
        RET
 useQPC:
        B       runtime·nanotimeQPC(SB)                // tail call
-       RET
 
-TEXT time·now(SB),NOSPLIT,$0-20
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
        MOVW    $0, R0
        MOVB    runtime·useQPCTime(SB), R0
        CMP     $0, R0
@@ -597,8 +519,7 @@ wall:
        MOVW    R1,nsec+8(FP)
        RET
 useQPC:
-       B       runtime·nanotimeQPC(SB)                // tail call
-       RET
+       B       runtime·nowQPC(SB)             // tail call
 
 // save_g saves the g register (R10) into thread local memory
 // so that we can call externally compiled
@@ -656,39 +577,8 @@ TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
        MOVW    $runtime·tls_g(SB), R1
        MOVW    R0, (R1)
 
-       BL      init_thread_tls<>(SB)
-
        MOVW    R4, R13
        MOVM.IA.W (R13), [R4, R15]      // pop {r4, pc}
 
-// void init_thread_tls()
-//
-// Does per-thread TLS initialization. Saves a pointer to the TLS slot
-// holding G, in the current m.
-//
-//     g->m->tls[0] = &_TEB->TlsSlots[tls_g]
-//
-// The purpose of this is to enable the profiling handler to get the
-// current g associated with the thread. We cannot use m->curg because curg
-// only holds the current user g. If the thread is executing system code or
-// external code, m->curg will be NULL. The thread's TLS slot always holds
-// the current g, so save a reference to this location so the profiling
-// handler can get the real g from the thread's m.
-//
-// Clobbers R0-R3
-TEXT init_thread_tls<>(SB),NOSPLIT|NOFRAME,$0
-       // compute &_TEB->TlsSlots[tls_g]
-       MRC     15, 0, R0, C13, C0, 2
-       ADD     $0xe10, R0
-       MOVW    $runtime·tls_g(SB), R1
-       MOVW    (R1), R1
-       MOVW    R1<<2, R1
-       ADD     R1, R0
-
-       // save in g->m->tls[0]
-       MOVW    g_m(g), R1
-       MOVW    R0, m_tls(R1)
-       RET
-
 // Holds the TLS Slot, which was allocated by TlsAlloc()
 GLOBL runtime·tls_g+0(SB), NOPTR, $4

diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
new file mode 100644 (file)
index 0000000..5396048
--- /dev/null
+++ b/src/runtime/sys_windows_arm64.s
@@ -0,0 +1,579 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+#include "funcdata.h"
+
+// Offsets into Thread Environment Block (pointer in R18)
+#define TEB_error 0x68
+#define TEB_TlsSlots 0x1480
+
+// Note: R0-R7 are args, R8 is indirect return value address,
+// R9-R15 are caller-save, R19-R29 are callee-save.
+//
+// load_g and save_g (in tls_arm64.s) clobber R27 (REGTMP) and R0.
+
+// void runtime·asmstdcall(void *c);
+TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
+       STP.W   (R29, R30), -32(RSP)    // allocate C ABI stack frame
+       STP     (R19, R20), 16(RSP) // save old R19, R20
+       MOVD    R0, R19 // save libcall pointer
+       MOVD    RSP, R20        // save stack pointer
+
+       // SetLastError(0)
+       MOVD    $0,     TEB_error(R18_PLATFORM)
+       MOVD    libcall_args(R19), R12  // libcall->args
+
+       // Do we have more than 8 arguments?
+       MOVD    libcall_n(R19), R0
+       CMP     $0,     R0; BEQ _0args
+       CMP     $1,     R0; BEQ _1args
+       CMP     $2,     R0; BEQ _2args
+       CMP     $3,     R0; BEQ _3args
+       CMP     $4,     R0; BEQ _4args
+       CMP     $5,     R0; BEQ _5args
+       CMP     $6,     R0; BEQ _6args
+       CMP     $7,     R0; BEQ _7args
+       CMP     $8,     R0; BEQ _8args
+
+       // Reserve stack space for remaining args
+       SUB     $8, R0, R2
+       ADD     $1, R2, R3 // make even number of words for stack alignment
+       AND     $~1, R3
+       LSL     $3, R3
+       SUB     R3, RSP
+
+       // R4: size of stack arguments (n-8)*8
+       // R5: &args[8]
+       // R6: loop counter, from 0 to (n-8)*8
+       // R7: scratch
+       // R8: copy of RSP - (R2)(RSP) assembles as (R2)(ZR)
+       SUB     $8, R0, R4
+       LSL     $3, R4
+       ADD     $(8*8), R12, R5
+       MOVD    $0, R6
+       MOVD    RSP, R8
+stackargs:
+       MOVD    (R6)(R5), R7
+       MOVD    R7, (R6)(R8)
+       ADD     $8, R6
+       CMP     R6, R4
+       BNE     stackargs
+
+_8args:
+       MOVD    (7*8)(R12), R7
+_7args:
+       MOVD    (6*8)(R12), R6
+_6args:
+       MOVD    (5*8)(R12), R5
+_5args:
+       MOVD    (4*8)(R12), R4
+_4args:
+       MOVD    (3*8)(R12), R3
+_3args:
+       MOVD    (2*8)(R12), R2
+_2args:
+       MOVD    (1*8)(R12), R1
+_1args:
+       MOVD    (0*8)(R12), R0
+_0args:
+
+       MOVD    libcall_fn(R19), R12    // branch to libcall->fn
+       BL      (R12)
+
+       MOVD    R20, RSP                        // free stack space
+       MOVD    R0, libcall_r1(R19)             // save return value to libcall->r1
+       // TODO(rsc) floating point like amd64 in libcall->r2?
+
+       // GetLastError
+       MOVD    TEB_error(R18_PLATFORM), R0
+       MOVD    R0, libcall_err(R19)
+
+       // Restore callee-saved registers.
+       LDP     16(RSP), (R19, R20)
+       LDP.P   32(RSP), (R29, R30)
+       RET
+
+TEXT runtime·badsignal2(SB),NOSPLIT,$16-0
+       NO_LOCAL_POINTERS
+
+       // stderr
+       MOVD    runtime·_GetStdHandle(SB), R1
+       MOVD    $-12, R0
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R1)
+       ADD     $16, RSP
+
+       // handle in R0 already
+       MOVD    $runtime·badsignalmsg(SB), R1  // lpBuffer
+       MOVD    $runtime·badsignallen(SB), R2  // lpNumberOfBytesToWrite
+       MOVD    (R2), R2
+       MOVD    R13, R3         // lpNumberOfBytesWritten
+       MOVD    $0, R4                  // lpOverlapped
+       MOVD    runtime·_WriteFile(SB), R12
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R12)
+       ADD     $16, RSP
+
+       RET
+
+TEXT runtime·getlasterror(SB),NOSPLIT|NOFRAME,$0
+       MOVD    TEB_error(R18_PLATFORM), R0
+       MOVD    R0, ret+0(FP)
+       RET
+
+#define SAVE_R19_TO_R28(offset) \
+       MOVD    R19, savedR19+((offset)+0*8)(SP); \
+       MOVD    R20, savedR20+((offset)+1*8)(SP); \
+       MOVD    R21, savedR21+((offset)+2*8)(SP); \
+       MOVD    R22, savedR22+((offset)+3*8)(SP); \
+       MOVD    R23, savedR23+((offset)+4*8)(SP); \
+       MOVD    R24, savedR24+((offset)+5*8)(SP); \
+       MOVD    R25, savedR25+((offset)+6*8)(SP); \
+       MOVD    R26, savedR26+((offset)+7*8)(SP); \
+       MOVD    R27, savedR27+((offset)+8*8)(SP); \
+       MOVD    g, savedR28+((offset)+9*8)(SP);
+
+#define RESTORE_R19_TO_R28(offset) \
+       MOVD    savedR19+((offset)+0*8)(SP), R19; \
+       MOVD    savedR20+((offset)+1*8)(SP), R20; \
+       MOVD    savedR21+((offset)+2*8)(SP), R21; \
+       MOVD    savedR22+((offset)+3*8)(SP), R22; \
+       MOVD    savedR23+((offset)+4*8)(SP), R23; \
+       MOVD    savedR24+((offset)+5*8)(SP), R24; \
+       MOVD    savedR25+((offset)+6*8)(SP), R25; \
+       MOVD    savedR26+((offset)+7*8)(SP), R26; \
+       MOVD    savedR27+((offset)+8*8)(SP), R27; \
+       MOVD    savedR28+((offset)+9*8)(SP), g; /* R28 */
+
+// Called by Windows as a Vectored Exception Handler (VEH).
+// First argument is pointer to struct containing
+// exception record and context pointers.
+// Handler function is stored in R1
+// Return 0 for 'not handled', -1 for handled.
+// int32_t sigtramp(
+//     PEXCEPTION_POINTERS ExceptionInfo,
+//     func *GoExceptionHandler);
+TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
+       // Save R0, R1 (args) as well as LR, R27, R28 (callee-save).
+       MOVD    R0, R5
+       MOVD    R1, R6
+       MOVD    LR, R7
+       MOVD    R27, R16                // saved R27 (callee-save)
+       MOVD    g, R17                  // saved R28 (callee-save from Windows, not really g)
+
+       BL      runtime·load_g(SB)     // smashes R0, R27, R28 (g)
+       CMP     $0, g                   // is there a current g?
+       BNE     2(PC)
+       BL      runtime·badsignal2(SB)
+
+       // Do we need to switch to the g0 stack?
+       MOVD    g, R3                   // R3 = oldg (for sigtramp_g0)
+       MOVD    g_m(g), R2              // R2 = m
+       MOVD    m_g0(R2), R2            // R2 = g0
+       CMP     g, R2                   // if curg == g0
+       BNE     switch
+
+       // No: on g0 stack already, tail call to sigtramp_g0.
+       // Restore all the callee-saves so sigtramp_g0 can return to our caller.
+       // We also pass R2 = g0, R3 = oldg, both set above.
+       MOVD    R5, R0
+       MOVD    R6, R1
+       MOVD    R7, LR
+       MOVD    R16, R27                // restore R27
+       MOVD    R17, g                  // restore R28
+       B       sigtramp_g0<>(SB)
+
+switch:
+       // switch to g0 stack (but do not update g - that's sigtramp_g0's job)
+       MOVD    RSP, R8
+       MOVD    (g_sched+gobuf_sp)(R2), R4      // R4 = g->gobuf.sp
+       SUB     $(6*8), R4                      // alloc space for saves - 2 words below SP for frame pointer, 3 for us to use, 1 for alignment
+       MOVD    R4, RSP                         // switch to g0 stack
+
+       MOVD    $0, (0*8)(RSP)  // fake saved LR
+       MOVD    R7, (1*8)(RSP)  // saved LR
+       MOVD    R8, (2*8)(RSP)  // saved SP
+
+       MOVD    R5, R0          // original args
+       MOVD    R6, R1          // original args
+       MOVD    R16, R27
+       MOVD    R17, g          // R28
+       BL      sigtramp_g0<>(SB)
+
+       // switch back to original stack; g already updated
+       MOVD    (1*8)(RSP), R7  // saved LR
+       MOVD    (2*8)(RSP), R8  // saved SP
+       MOVD    R7, LR
+       MOVD    R8, RSP
+       RET
+
+// sigtramp_g0 is running on the g0 stack, with R2 = g0, R3 = oldg.
+// But g itself is not set - that's R28, a callee-save register,
+// and it still holds the value from the Windows DLL caller.
+TEXT sigtramp_g0<>(SB),NOSPLIT,$128
+       NO_LOCAL_POINTERS
+
+       // Push C callee-save registers R19-R28. LR, FP already saved.
+       SAVE_R19_TO_R28(-10*8)
+
+       MOVD    0(R0), R5       // R5 = ExceptionPointers->ExceptionRecord
+       MOVD    8(R0), R6       // R6 = ExceptionPointers->ContextRecord
+       MOVD    R6, context-(11*8)(SP)
+
+       MOVD    R2, g                   // g0
+       BL      runtime·save_g(SB)     // smashes R0
+
+       MOVD    R5, (1*8)(RSP)  // arg0 (ExceptionRecord)
+       MOVD    R6, (2*8)(RSP)  // arg1 (ContextRecord)
+       MOVD    R3, (3*8)(RSP)  // arg2 (original g)
+       MOVD    R3, oldg-(12*8)(SP)
+       BL      (R1)
+       MOVD    oldg-(12*8)(SP), g
+       BL      runtime·save_g(SB)     // smashes R0
+       MOVW    (4*8)(RSP), R0  // return value (0 or -1)
+
+       // if return value is CONTINUE_SEARCH, do not set up control
+       // flow guard workaround
+       CMP     $0, R0
+       BEQ     return
+
+       // Check if we need to set up the control flow guard workaround.
+       // On Windows, the stack pointer in the context must lie within
+       // system stack limits when we resume from exception.
+       // Store the resume SP and PC in alternate registers
+       // and return to sigresume on the g0 stack.
+       // sigresume makes no use of the stack at all,
+       // loading SP from R0 and jumping to R1.
+       // Note that smashing R0 and R1 is only safe because we know sigpanic
+       // will not actually return to the original frame, so the registers
+       // are effectively dead. But this does mean we can't use the
+       // same mechanism for async preemption.
+       MOVD    context-(11*8)(SP), R6
+       MOVD    context_pc(R6), R2              // load PC from context record
+       MOVD    $sigresume<>(SB), R1
+
+       CMP     R1, R2
+       BEQ     return                          // do not clobber saved SP/PC
+
+       // Save resume SP and PC into R0, R1.
+       MOVD    context_xsp(R6), R2
+       MOVD    R2, (context_x+0*8)(R6)
+       MOVD    context_pc(R6), R2
+       MOVD    R2, (context_x+1*8)(R6)
+
+       // Set up context record to return to sigresume on g0 stack
+       MOVD    RSP, R2
+       MOVD    R2, context_xsp(R6)
+       MOVD    $sigresume<>(SB), R2
+       MOVD    R2, context_pc(R6)
+
+return:
+       RESTORE_R19_TO_R28(-10*8)               // smashes g
+       RET
+
+// Trampoline to resume execution from exception handler.
+// This is part of the control flow guard workaround.
+// It switches stacks and jumps to the continuation address.
+// R0 and R1 are set above at the end of sigtramp<>
+// in the context that starts executing at sigresume<>.
+TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
+       // Important: do not smash LR,
+       // which is set to a live value when handling
+       // a signal by pushing a call to sigpanic onto the stack.
+       MOVD    R0, RSP
+       B       (R1)
+
+TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·exceptionhandler(SB), R1
+       B       sigtramp<>(SB)
+
+TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·firstcontinuehandler(SB), R1
+       B       sigtramp<>(SB)
+
+TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·lastcontinuehandler(SB), R1
+       B       sigtramp<>(SB)
+
+TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·ctrlhandler1(SB), R1
+       B       runtime·externalthreadhandler(SB)
+
+TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $runtime·profileloop1(SB), R1
+       B       runtime·externalthreadhandler(SB)
+
+// externalthreadhander called with R0 = uint32 arg, R1 = Go function f.
+// Need to call f(arg), which returns a uint32, and return it in R0.
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$96-0
+       NO_LOCAL_POINTERS
+
+       // Push C callee-save registers R19-R28. LR, FP already saved.
+       SAVE_R19_TO_R28(-10*8)
+
+       // Allocate space for args, saved R0+R1, g, and m structures.
+       // Hide from nosplit check.
+       #define extra ((64+g__size+m__size+15)&~15)
+       SUB     $extra, RSP, R2 // hide from nosplit overflow check
+       MOVD    R2, RSP
+
+       // Save R0 and R1 (our args).
+       MOVD    R0, 32(RSP)
+       MOVD    R1, 40(RSP)
+
+       // Zero out m and g structures.
+       MOVD    $64(RSP), R0
+       MOVD    R0, 8(RSP)
+       MOVD    $(m__size + g__size), R0
+       MOVD    R0, 16(RSP)
+       MOVD    $0, 0(RSP)      // not-saved LR
+       BL      runtime·memclrNoHeapPointers(SB)
+
+       // Initialize m and g structures.
+       MOVD    $64(RSP), g
+       MOVD    $g__size(g), R3         // m
+       MOVD    R3, g_m(g)              // g->m = m
+       MOVD    g, m_g0(R3)             // m->g0 = g
+       MOVD    g, m_curg(R3)           // m->curg = g
+       MOVD    RSP, R0
+       MOVD    R0, g_stack+stack_hi(g)
+       SUB     $(32*1024), R0
+       MOVD    R0, (g_stack+stack_lo)(g)
+       MOVD    R0, g_stackguard0(g)
+       MOVD    R0, g_stackguard1(g)
+       BL      runtime·save_g(SB)
+
+       // Call function.
+       MOVD    32(RSP), R0
+       MOVD    40(RSP), R1
+       MOVW    R0, 8(RSP)
+       BL      (R1)
+
+       // Clear g.
+       MOVD    $0, g
+       BL      runtime·save_g(SB)
+
+       // Load return value (save_g would have smashed)
+       MOVW    (2*8)(RSP), R0
+
+       ADD     $extra, RSP, R2
+       MOVD    R2, RSP
+       #undef extra
+
+       RESTORE_R19_TO_R28(-10*8)
+       RET
+
+GLOBL runtime·cbctxts(SB), NOPTR, $4
+
+TEXT runtime·callbackasm1(SB),NOSPLIT,$208-0
+       NO_LOCAL_POINTERS
+
+       // On entry, the trampoline in zcallback_windows_arm64.s left
+       // the callback index in R12 (which is volatile in the C ABI).
+
+       // Save callback register arguments R0-R7.
+       // We do this at the top of the frame so they're contiguous with stack arguments.
+       MOVD    R0, arg0-(8*8)(SP)
+       MOVD    R1, arg1-(7*8)(SP)
+       MOVD    R2, arg2-(6*8)(SP)
+       MOVD    R3, arg3-(5*8)(SP)
+       MOVD    R4, arg4-(4*8)(SP)
+       MOVD    R5, arg5-(3*8)(SP)
+       MOVD    R6, arg6-(2*8)(SP)
+       MOVD    R7, arg7-(1*8)(SP)
+
+       // Push C callee-save registers R19-R28.
+       // LR, FP already saved.
+       SAVE_R19_TO_R28(-18*8)
+
+       // Create a struct callbackArgs on our stack.
+       MOVD    $cbargs-(18*8+callbackArgs__size)(SP), R13
+       MOVD    R12, callbackArgs_index(R13)    // callback index
+       MOVD    $arg0-(8*8)(SP), R0
+       MOVD    R0, callbackArgs_args(R13)              // address of args vector
+       MOVD    $0, R0
+       MOVD    R0, callbackArgs_result(R13)    // result
+
+       // Call cgocallback, which will call callbackWrap(frame).
+       MOVD    $·callbackWrap(SB), R0 // PC of function to call
+       MOVD    R13, R1 // frame (&callbackArgs{...})
+       MOVD    $0, R2  // context
+       MOVD    R0, (1*8)(RSP)
+       MOVD    R1, (2*8)(RSP)
+       MOVD    R2, (3*8)(RSP)
+       BL      runtime·cgocallback(SB)
+
+       // Get callback result.
+       MOVD    $cbargs-(18*8+callbackArgs__size)(SP), R13
+       MOVD    callbackArgs_result(R13), R0
+
+       RESTORE_R19_TO_R28(-18*8)
+
+       RET
+
+// uint32 tstart_stdcall(M *newm);
+TEXT runtime·tstart_stdcall(SB),NOSPLIT,$96-0
+       SAVE_R19_TO_R28(-10*8)
+
+       MOVD    m_g0(R0), g
+       MOVD    R0, g_m(g)
+       BL      runtime·save_g(SB)
+
+       // Set up stack guards for OS stack.
+       MOVD    RSP, R0
+       MOVD    R0, g_stack+stack_hi(g)
+       SUB     $(64*1024), R0
+       MOVD    R0, (g_stack+stack_lo)(g)
+       MOVD    R0, g_stackguard0(g)
+       MOVD    R0, g_stackguard1(g)
+
+       BL      runtime·emptyfunc(SB)  // fault if stack check is wrong
+       BL      runtime·mstart(SB)
+
+       RESTORE_R19_TO_R28(-10*8)
+
+       // Exit the thread.
+       MOVD    $0, R0
+       RET
+
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT,$32-4
+       MOVW    dt+0(FP), R0
+       MOVD    $16(RSP), R2            // R2 = pTime
+       MOVD    R0, 0(R2)               // *pTime = -dt
+       MOVD    $-1, R0                 // R0 = handle
+       MOVD    $0, R1                  // R1 = FALSE (alertable)
+       MOVD    runtime·_NtWaitForSingleObject(SB), R3
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R3)
+       ADD     $16, RSP
+       RET
+
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+// TODO: neeeds to be implemented properly.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT,$0-4
+       B       runtime·abort(SB)
+
+// Runs on OS stack.
+TEXT runtime·switchtothread(SB),NOSPLIT,$16-0
+       MOVD    runtime·_SwitchToThread(SB), R0
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R0)
+       ADD     $16, RSP
+       RET
+
+// See http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
+#define _INTERRUPT_TIME 0x7ffe0008
+#define _SYSTEM_TIME 0x7ffe0014
+#define time_lo 0
+#define time_hi1 4
+#define time_hi2 8
+
+TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
+       MOVB    runtime·useQPCTime(SB), R0
+       CMP     $0, R0
+       BNE     useQPC
+       MOVD    $_INTERRUPT_TIME, R3
+loop:
+       MOVWU   time_hi1(R3), R1
+       MOVWU   time_lo(R3), R0
+       MOVWU   time_hi2(R3), R2
+       CMP     R1, R2
+       BNE     loop
+
+       // wintime = R1:R0, multiply by 100
+       ORR     R1<<32, R0
+       MOVD    $100, R1
+       MUL     R1, R0
+       MOVD    R0, ret+0(FP)
+       RET
+useQPC:
+       B       runtime·nanotimeQPC(SB)                // tail call
+
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-24
+       MOVB    runtime·useQPCTime(SB), R0
+       CMP     $0, R0
+       BNE     useQPC
+       MOVD    $_INTERRUPT_TIME, R3
+loop:
+       MOVWU   time_hi1(R3), R1
+       MOVWU   time_lo(R3), R0
+       MOVWU   time_hi2(R3), R2
+       CMP     R1, R2
+       BNE     loop
+
+       // wintime = R1:R0, multiply by 100
+       ORR     R1<<32, R0
+       MOVD    $100, R1
+       MUL     R1, R0
+       MOVD    R0, mono+16(FP)
+
+       MOVD    $_SYSTEM_TIME, R3
+wall:
+       MOVWU   time_hi1(R3), R1
+       MOVWU   time_lo(R3), R0
+       MOVWU   time_hi2(R3), R2
+       CMP     R1, R2
+       BNE     wall
+
+       // w = R1:R0 in 100ns units
+       // convert to Unix epoch (but still 100ns units)
+       #define delta 116444736000000000
+       ORR     R1<<32, R0
+       SUB     $delta, R0
+
+       // Convert to nSec
+       MOVD    $100, R1
+       MUL     R1, R0
+
+       // Code stolen from compiler output for:
+       //
+       //      var x uint64
+       //      func f() (sec uint64, nsec uint32) { return x / 1000000000, uint32(x % 100000000) }
+       //
+       LSR     $1, R0, R1
+       MOVD    $-8543223759426509416, R2
+       UMULH   R2, R1, R1
+       LSR     $28, R1, R1
+       MOVD    R1, sec+0(FP)
+       MOVD    $-6067343680855748867, R1
+       UMULH   R0, R1, R1
+       LSR     $26, R1, R1
+       MOVD    $100000000, R2
+       MSUB    R1, R0, R2, R0
+       MOVW    R0, nsec+8(FP)
+       RET
+useQPC:
+       B       runtime·nowQPC(SB)             // tail call
+
+// This is called from rt0_go, which runs on the system stack
+// using the initial stack allocated by the OS.
+// It calls back into standard C using the BL below.
+TEXT runtime·wintls(SB),NOSPLIT,$0
+       // Allocate a TLS slot to hold g across calls to external code
+       MOVD    runtime·_TlsAlloc(SB), R0
+       SUB     $16, RSP        // skip over saved frame pointer below RSP
+       BL      (R0)
+       ADD     $16, RSP
+
+       // Assert that slot is less than 64 so we can use _TEB->TlsSlots
+       CMP     $64, R0
+       BLT     ok
+       MOVD    $runtime·abort(SB), R1
+       BL      (R1)
+ok:
+
+       // Save offset from R18 into tls_g.
+       LSL     $3, R1
+       ADD     $TEB_TlsSlots, R1
+       MOVD    R1, runtime·tls_g(SB)
+       RET

diff --git a/src/runtime/sys_x86.go b/src/runtime/sys_x86.go
index f917cb8bd7a52d821c4859347316c1aad2f20dbc..8f21585d28b0f221a26664f693a969a797634e3e 100644 (file)
--- a/src/runtime/sys_x86.go
+++ b/src/runtime/sys_x86.go
@@ -12,13 +12,9 @@ import (
 )
 
 // adjust Gobuf as if it executed a call to fn with context ctxt
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
        sp := buf.sp
-       if sys.RegSize > sys.PtrSize {
-               sp -= sys.PtrSize
-               *(*uintptr)(unsafe.Pointer(sp)) = 0
-       }
        sp -= sys.PtrSize
        *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
        buf.sp = sp

diff --git a/src/runtime/syscall2_solaris.go b/src/runtime/syscall2_solaris.go
index e098e8006a6816c15d1466a29c87900c646f27e5..331048920212230704c5c74cfd5069d12b220c86 100644 (file)
--- a/src/runtime/syscall2_solaris.go
+++ b/src/runtime/syscall2_solaris.go
@@ -15,7 +15,6 @@ import _ "unsafe" // for go:linkname
 //go:cgo_import_dynamic libc_gethostname gethostname "libc.so"
 //go:cgo_import_dynamic libc_getpid getpid "libc.so"
 //go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
-//go:cgo_import_dynamic libc_pipe pipe "libc.so"
 //go:cgo_import_dynamic libc_setgid setgid "libc.so"
 //go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
 //go:cgo_import_dynamic libc_setsid setsid "libc.so"
@@ -33,7 +32,6 @@ import _ "unsafe" // for go:linkname
 //go:linkname libc_gethostname libc_gethostname
 //go:linkname libc_getpid libc_getpid
 //go:linkname libc_ioctl libc_ioctl
-//go:linkname libc_pipe libc_pipe
 //go:linkname libc_setgid libc_setgid
 //go:linkname libc_setgroups libc_setgroups
 //go:linkname libc_setsid libc_setsid

diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 7835b492f78146f49a6b9fe4719298ccf03ff6d4..7cf9318bdbf8964427a871da995fe7e4c6f71223 100644 (file)
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+       "internal/abi"
        "runtime/internal/sys"
        "unsafe"
 )
@@ -70,8 +71,8 @@ func callbackasmAddr(i int) uintptr {
                panic("unsupported architecture")
        case "386", "amd64":
                entrySize = 5
-       case "arm":
-               // On ARM, each entry is a MOV instruction
+       case "arm", "arm64":
+               // On ARM and ARM64, each entry is a MOV instruction
                // followed by a branch instruction
                entrySize = 8
        }
@@ -115,13 +116,14 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
                        // registers and the stack.
                        panic("compileCallback: argument size is larger than uintptr")
                }
-               if k := t.kind & kindMask; (GOARCH == "amd64" || GOARCH == "arm") && (k == kindFloat32 || k == kindFloat64) {
+               if k := t.kind & kindMask; GOARCH != "386" && (k == kindFloat32 || k == kindFloat64) {
                        // In fastcall, floating-point arguments in
                        // the first four positions are passed in
                        // floating-point registers, which we don't
                        // currently spill. arm passes floating-point
                        // arguments in VFP registers, which we also
                        // don't support.
+                       // So basically we only support 386.
                        panic("compileCallback: float arguments not supported")
                }
 
@@ -146,6 +148,7 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
                }
 
                // cdecl, stdcall, fastcall, and arm pad arguments to word size.
+               // TODO(rsc): On arm and arm64 do we need to skip the caller's saved LR?
                src += sys.PtrSize
                // The Go ABI packs arguments.
                dst += t.size
@@ -242,7 +245,11 @@ func callbackWrap(a *callbackArgs) {
 
        // Even though this is copying back results, we can pass a nil
        // type because those results must not require write barriers.
-       reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.retOffset)+sys.PtrSize, uint32(c.retOffset))
+       //
+       // Pass a dummy RegArgs for now.
+       // TODO(mknyszek): Pass arguments in registers.
+       var regs abi.RegArgs
+       reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.retOffset)+sys.PtrSize, uint32(c.retOffset), uint32(c.retOffset)+sys.PtrSize, &regs)
 
        // Extract the result.
        a.result = *(*uintptr)(unsafe.Pointer(&frame[c.retOffset]))

diff --git a/src/runtime/testdata/testprog/deadlock.go b/src/runtime/testdata/testprog/deadlock.go
index 105d6a5faae0cf78d4badfa926e903f7ab20d110..781acbd7706ac68627f3962bfd9d11f6c8953f41 100644 (file)
--- a/src/runtime/testdata/testprog/deadlock.go
+++ b/src/runtime/testdata/testprog/deadlock.go
@@ -25,6 +25,7 @@ func init() {
        register("RecursivePanic2", RecursivePanic2)
        register("RecursivePanic3", RecursivePanic3)
        register("RecursivePanic4", RecursivePanic4)
+       register("RecursivePanic5", RecursivePanic5)
        register("GoexitExit", GoexitExit)
        register("GoNil", GoNil)
        register("MainGoroutineID", MainGoroutineID)
@@ -160,6 +161,44 @@ func RecursivePanic4() {
        panic("first panic")
 }
 
+// Test case where we have an open-coded defer higher up the stack (in two), and
+// in the current function (three) we recover in a defer while we still have
+// another defer to be processed.
+func RecursivePanic5() {
+       one()
+       panic("third panic")
+}
+
+//go:noinline
+func one() {
+       two()
+}
+
+//go:noinline
+func two() {
+       defer func() {
+       }()
+
+       three()
+}
+
+//go:noinline
+func three() {
+       defer func() {
+       }()
+
+       defer func() {
+               fmt.Println(recover())
+       }()
+
+       defer func() {
+               fmt.Println(recover())
+               panic("second panic")
+       }()
+
+       panic("first panic")
+}
+
 func GoexitExit() {
        println("t1")
        go func() {

diff --git a/src/runtime/testdata/testwinsignal/main.go b/src/runtime/testdata/testwinsignal/main.go
new file mode 100644 (file)
index 0000000..d8cd884
--- /dev/null
+++ b/src/runtime/testdata/testwinsignal/main.go
@@ -0,0 +1,19 @@
+package main\r
+\r
+import (\r
+       "fmt"\r
+       "os"\r
+       "os/signal"\r
+       "time"\r
+)\r
+\r
+func main() {\r
+       c := make(chan os.Signal, 1)\r
+       signal.Notify(c)\r
+\r
+       fmt.Println("ready")\r
+       sig := <-c\r
+\r
+       time.Sleep(time.Second)\r
+       fmt.Println(sig)\r
+}\r

diff --git a/src/runtime/textflag.h b/src/runtime/textflag.h
index daca36d9483302dab985fb66a3b5198f48ea5e90..e727208cd03a0b5f693edaedb4861da5b85add2c 100644 (file)
--- a/src/runtime/textflag.h
+++ b/src/runtime/textflag.h
@@ -35,3 +35,5 @@
 // Function is the top of the call stack. Call stack unwinders should stop
 // at this function.
 #define TOPFRAME 2048
+// Function is an ABI wrapper.
+#define ABIWRAPPER 4096

diff --git a/src/runtime/time.go b/src/runtime/time.go
index d338705b7c4c5ab9f90a7a23324c9653bbf1c7ed..8ab2a0343011d20022dcd0eff406bfb42e2d579e 100644 (file)
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -609,8 +609,14 @@ func moveTimers(pp *p, timers []*timer) {
                for {
                        switch s := atomic.Load(&t.status); s {
                        case timerWaiting:
+                               if !atomic.Cas(&t.status, s, timerMoving) {
+                                       continue
+                               }
                                t.pp = 0
                                doaddtimer(pp, t)
+                               if !atomic.Cas(&t.status, timerMoving, timerWaiting) {
+                                       badTimer()
+                               }
                                break loop
                        case timerModifiedEarlier, timerModifiedLater:
                                if !atomic.Cas(&t.status, s, timerMoving) {

diff --git a/src/runtime/timestub2.go b/src/runtime/timestub2.go
index 6d73aabc3507b9c5cb4fa1de9dcae688cfca630e..68777ee4a90c752d1537a1a3b718d5b11fa8c85e 100644 (file)
--- a/src/runtime/timestub2.go
+++ b/src/runtime/timestub2.go
@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build !aix
 // +build !darwin
-// +build !windows
 // +build !freebsd
-// +build !aix
+// +build !openbsd
 // +build !solaris
+// +build !windows
 
 package runtime
 

diff --git a/src/runtime/tls_arm64.h b/src/runtime/tls_arm64.h
index 0804fa35026fc3b9326e227f22a408634e9045c8..fe5e4cee12db92cf234a5a6c1cade9f6f5843066 100644 (file)
--- a/src/runtime/tls_arm64.h
+++ b/src/runtime/tls_arm64.h
@@ -41,8 +41,16 @@
 #define MRS_TPIDR_R0 WORD $0xd53bd040 // MRS TPIDR_EL0, R0
 #endif
 
+#ifdef GOOS_windows
+#define TLS_windows
+#endif
+#ifdef TLS_windows
+#define TLSG_IS_VARIABLE
+#define MRS_TPIDR_R0 MOVD R18_PLATFORM, R0
+#endif
+
 // Define something that will break the build if
 // the GOOS is unknown.
-#ifndef TPIDR
-#define MRS_TPIDR_R0 TPIDR_UNKNOWN
+#ifndef MRS_TPIDR_R0
+#define MRS_TPIDR_R0 unknown_TLS_implementation_in_tls_arm64_h
 #endif

diff --git a/src/runtime/tls_arm64.s b/src/runtime/tls_arm64.s
index 3f02974d5b7e6f1eef82e8cd4f35648f486f6bc8..52b3e8f2228e8078c8ae6b1c0a54ac283c1274b7 100644 (file)
--- a/src/runtime/tls_arm64.s
+++ b/src/runtime/tls_arm64.s
@@ -9,9 +9,13 @@
 #include "tls_arm64.h"
 
 TEXT runtime·load_g(SB),NOSPLIT,$0
-#ifndef TLS_darwin
+#ifndef GOOS_darwin
+#ifndef GOOS_openbsd
+#ifndef GOOS_windows
        MOVB    runtime·iscgo(SB), R0
        CBZ     R0, nocgo
+#endif
+#endif
 #endif
 
        MRS_TPIDR_R0
@@ -26,9 +30,13 @@ nocgo:
        RET
 
 TEXT runtime·save_g(SB),NOSPLIT,$0
-#ifndef TLS_darwin
+#ifndef GOOS_darwin
+#ifndef GOOS_openbsd
+#ifndef GOOS_windows
        MOVB    runtime·iscgo(SB), R0
        CBZ     R0, nocgo
+#endif
+#endif
 #endif
 
        MRS_TPIDR_R0

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 0825e9e70761130ccdc83ec7d97adb5425d3d192..eb185eecd36c238b666e26c0cfec27ec9a2a1d5d 100644 (file)
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -15,24 +15,9 @@ import (
 // The most important fact about a given architecture is whether it uses a link register.
 // On systems with link registers, the prologue for a non-leaf function stores the
 // incoming value of LR at the bottom of the newly allocated stack frame.
-// On systems without link registers, the architecture pushes a return PC during
+// On systems without link registers (x86), the architecture pushes a return PC during
 // the call instruction, so the return PC ends up above the stack frame.
 // In this file, the return PC is always called LR, no matter how it was found.
-//
-// To date, the opposite of a link register architecture is an x86 architecture.
-// This code may need to change if some other kind of non-link-register
-// architecture comes along.
-//
-// The other important fact is the size of a pointer: on 32-bit systems the LR
-// takes up only 4 bytes on the stack, while on 64-bit systems it takes up 8 bytes.
-// Typically this is ptrSize.
-//
-// As an exception, amd64p32 had ptrSize == 4 but the CALL instruction still
-// stored an 8-byte return PC onto the stack. To accommodate this, we used regSize
-// as the size of the architecture-pushed return PC.
-//
-// usesLR is defined below in terms of minFrameSize, which is defined in
-// arch_$GOARCH.go. ptrSize and regSize are defined in stubs.go.
 
 const usesLR = sys.MinFrameSize > 0
 
@@ -144,8 +129,8 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                        frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
                        frame.lr = 0
                } else {
-                       frame.pc = uintptr(*(*sys.Uintreg)(unsafe.Pointer(frame.sp)))
-                       frame.sp += sys.RegSize
+                       frame.pc = uintptr(*(*uintptr)(unsafe.Pointer(frame.sp)))
+                       frame.sp += sys.PtrSize
                }
        }
 
@@ -180,6 +165,16 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                        break
                }
 
+               // Compute function info flags.
+               flag := f.flag
+               if f.funcID == funcID_cgocallback {
+                       // cgocallback does write SP to switch from the g0 to the curg stack,
+                       // but it carefully arranges that during the transition BOTH stacks
+                       // have cgocallback frame valid for unwinding through.
+                       // So we don't need to exclude it with the other SP-writing functions.
+                       flag &^= funcFlag_SPWRITE
+               }
+
                // Found an actual function.
                // Derive frame pointer and link register.
                if frame.fp == 0 {
@@ -196,6 +191,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                                        frame.pc = gp.m.curg.sched.pc
                                        frame.fn = findfunc(frame.pc)
                                        f = frame.fn
+                                       flag = f.flag
                                        frame.sp = gp.m.curg.sched.sp
                                        cgoCtxt = gp.m.curg.cgoCtxt
                                case funcID_systemstack:
@@ -203,29 +199,37 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                                        // stack transition.
                                        frame.sp = gp.m.curg.sched.sp
                                        cgoCtxt = gp.m.curg.cgoCtxt
+                                       flag &^= funcFlag_SPWRITE
                                }
                        }
                        frame.fp = frame.sp + uintptr(funcspdelta(f, frame.pc, &cache))
                        if !usesLR {
                                // On x86, call instruction pushes return PC before entering new function.
-                               frame.fp += sys.RegSize
+                               frame.fp += sys.PtrSize
                        }
                }
                var flr funcInfo
-               if topofstack(f, gp.m != nil && gp == gp.m.g0) {
+               if flag&funcFlag_TOPFRAME != 0 {
+                       // This function marks the top of the stack. Stop the traceback.
                        frame.lr = 0
                        flr = funcInfo{}
-               } else if usesLR && f.funcID == funcID_jmpdefer {
-                       // jmpdefer modifies SP/LR/PC non-atomically.
-                       // If a profiling interrupt arrives during jmpdefer,
-                       // the stack unwind may see a mismatched register set
-                       // and get confused. Stop if we see PC within jmpdefer
-                       // to avoid that confusion.
-                       // See golang.org/issue/8153.
+               } else if flag&funcFlag_SPWRITE != 0 {
+                       // The function we are in does a write to SP that we don't know
+                       // how to encode in the spdelta table. Examples include context
+                       // switch routines like runtime.gogo but also any code that switches
+                       // to the g0 stack to run host C code. Since we can't reliably unwind
+                       // the SP (we might not even be on the stack we think we are),
+                       // we stop the traceback here.
                        if callback != nil {
-                               throw("traceback_arm: found jmpdefer when tracing with callback")
+                               // Finding an SPWRITE should only happen for a profiling signal, which can
+                               // arrive at any time. For a GC stack traversal (callback != nil),
+                               // we shouldn't see this case, and we must be sure to walk the
+                               // entire stack or the GC is invalid. So crash.
+                               println("traceback: unexpected SPWRITE function", funcname(f))
+                               throw("traceback")
                        }
                        frame.lr = 0
+                       flr = funcInfo{}
                } else {
                        var lrPtr uintptr
                        if usesLR {
@@ -235,8 +239,8 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                                }
                        } else {
                                if frame.lr == 0 {
-                                       lrPtr = frame.fp - sys.RegSize
-                                       frame.lr = uintptr(*(*sys.Uintreg)(unsafe.Pointer(lrPtr)))
+                                       lrPtr = frame.fp - sys.PtrSize
+                                       frame.lr = uintptr(*(*uintptr)(unsafe.Pointer(lrPtr)))
                                }
                        }
                        flr = findfunc(frame.lr)
@@ -266,13 +270,28 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                frame.varp = frame.fp
                if !usesLR {
                        // On x86, call instruction pushes return PC before entering new function.
-                       frame.varp -= sys.RegSize
+                       frame.varp -= sys.PtrSize
                }
 
                // For architectures with frame pointers, if there's
                // a frame, then there's a saved frame pointer here.
-               if frame.varp > frame.sp && (GOARCH == "amd64" || GOARCH == "arm64") {
-                       frame.varp -= sys.RegSize
+               //
+               // NOTE: This code is not as general as it looks.
+               // On x86, the ABI is to save the frame pointer word at the
+               // top of the stack frame, so we have to back down over it.
+               // On arm64, the frame pointer should be at the bottom of
+               // the stack (with R29 (aka FP) = RSP), in which case we would
+               // not want to do the subtraction here. But we started out without
+               // any frame pointer, and when we wanted to add it, we didn't
+               // want to break all the assembly doing direct writes to 8(RSP)
+               // to set the first parameter to a called function.
+               // So we decided to write the FP link *below* the stack pointer
+               // (with R29 = RSP - 8 in Go functions).
+               // This is technically ABI-compatible but not standard.
+               // And it happens to end up mimicking the x86 layout.
+               // Other architectures may make different decisions.
+               if frame.varp > frame.sp && framepointer_enabled {
+                       frame.varp -= sys.PtrSize
                }
 
                // Derive size of arguments.
@@ -490,11 +509,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
                // before faking a call.
                if usesLR && injectedCall {
                        x := *(*uintptr)(unsafe.Pointer(frame.sp))
-                       frame.sp += sys.MinFrameSize
-                       if GOARCH == "arm64" {
-                               // arm64 needs 16-byte aligned SP, always
-                               frame.sp += sys.PtrSize
-                       }
+                       frame.sp += alignUp(sys.MinFrameSize, sys.StackAlign)
                        f = findfunc(frame.pc)
                        frame.fn = f
                        if !f.valid() {
@@ -917,17 +932,25 @@ func tracebackothers(me *g) {
        level, _, _ := gotraceback()
 
        // Show the current goroutine first, if we haven't already.
-       g := getg()
-       gp := g.m.curg
-       if gp != nil && gp != me {
+       curgp := getg().m.curg
+       if curgp != nil && curgp != me {
                print("\n")
-               goroutineheader(gp)
-               traceback(^uintptr(0), ^uintptr(0), 0, gp)
+               goroutineheader(curgp)
+               traceback(^uintptr(0), ^uintptr(0), 0, curgp)
        }
 
-       lock(&allglock)
-       for _, gp := range allgs {
-               if gp == me || gp == g.m.curg || readgstatus(gp) == _Gdead || isSystemGoroutine(gp, false) && level < 2 {
+       // We can't take allglock here because this may be during fatal
+       // throw/panic, where locking allglock could be out-of-order or a
+       // direct deadlock.
+       //
+       // Instead, use atomic access to allgs which requires no locking. We
+       // don't lock against concurrent creation of new Gs, but even with
+       // allglock we may miss Gs created after this loop.
+       ptr, length := atomicAllG()
+       for i := uintptr(0); i < length; i++ {
+               gp := atomicAllGIndex(ptr, i)
+
+               if gp == me || gp == curgp || readgstatus(gp) == _Gdead || isSystemGoroutine(gp, false) && level < 2 {
                        continue
                }
                print("\n")
@@ -936,14 +959,13 @@ func tracebackothers(me *g) {
                // called from a signal handler initiated during a
                // systemstack call. The original G is still in the
                // running state, and we want to print its stack.
-               if gp.m != g.m && readgstatus(gp)&^_Gscan == _Grunning {
+               if gp.m != getg().m && readgstatus(gp)&^_Gscan == _Grunning {
                        print("\tgoroutine running on other thread; stack unavailable\n")
                        printcreatedby(gp)
                } else {
                        traceback(^uintptr(0), ^uintptr(0), 0, gp)
                }
        }
-       unlock(&allglock)
 }
 
 // tracebackHexdump hexdumps part of stk around frame.sp and frame.fp
@@ -993,22 +1015,6 @@ func tracebackHexdump(stk stack, frame *stkframe, bad uintptr) {
        })
 }
 
-// Does f mark the top of a goroutine stack?
-func topofstack(f funcInfo, g0 bool) bool {
-       return f.funcID == funcID_goexit ||
-               f.funcID == funcID_mstart ||
-               f.funcID == funcID_mcall ||
-               f.funcID == funcID_morestack ||
-               f.funcID == funcID_rt0_go ||
-               f.funcID == funcID_externalthreadhandler ||
-               // asmcgocall is TOS on the system stack because it
-               // switches to the system stack, but in this case we
-               // can come back to the regular stack and still want
-               // to be able to unwind through the call that appeared
-               // on the regular stack.
-               (g0 && f.funcID == funcID_asmcgocall)
-}
-
 // isSystemGoroutine reports whether the goroutine g must be omitted
 // in stack dumps and deadlock detector. This is any goroutine that
 // starts at a runtime.* entry point, except for runtime.main,

diff --git a/src/runtime/type.go b/src/runtime/type.go
index 81455f3532db83ed481d0c55afa54a2dc088271c..18fc4bbfad7546a7a78b58a0c2e2259665a864f7 100644 (file)
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -383,7 +383,7 @@ type maptype struct {
 }
 
 // Note: flag values must match those used in the TMAP case
-// in ../cmd/compile/internal/gc/reflect.go:dtypesym.
+// in ../cmd/compile/internal/gc/reflect.go:writeType.
 func (mt *maptype) indirectkey() bool { // store ptr to key instead of key itself
        return mt.flags&1 != 0
 }

diff --git a/src/runtime/wincallback.go b/src/runtime/wincallback.go
index fb452222da29af6163d79fc95bf8bd5ecb58ad44..cf3327c6fe78c43d4412fd645368e374cbac24e7 100644 (file)
--- a/src/runtime/wincallback.go
+++ b/src/runtime/wincallback.go
@@ -72,6 +72,34 @@ TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
        }
 }
 
+func genasmArm64() {
+       var buf bytes.Buffer
+
+       buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
+
+// External code calls into callbackasm at an offset corresponding
+// to the callback index. Callbackasm is a table of MOV and B instructions.
+// The MOV instruction loads R12 with the callback index, and the
+// B instruction branches to callbackasm1.
+// callbackasm1 takes the callback index from R12 and
+// indexes into an array that stores information about each callback.
+// It then calls the Go implementation for that callback.
+#include "textflag.h"
+
+TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+`)
+       for i := 0; i < maxCallback; i++ {
+               buf.WriteString(fmt.Sprintf("\tMOVD\t$%d, R12\n", i))
+               buf.WriteString("\tB\truntime·callbackasm1(SB)\n")
+       }
+
+       err := os.WriteFile("zcallback_windows_arm64.s", buf.Bytes(), 0666)
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
+               os.Exit(2)
+       }
+}
+
 func gengo() {
        var buf bytes.Buffer
 
@@ -91,5 +119,6 @@ const cb_max = %d // maximum number of windows callbacks allowed
 func main() {
        genasm386Amd64()
        genasmArm()
+       genasmArm64()
        gengo()
 }

diff --git a/src/runtime/zcallback_windows_arm64.s b/src/runtime/zcallback_windows_arm64.s
new file mode 100644 (file)
index 0000000..69fb057
--- /dev/null
+++ b/src/runtime/zcallback_windows_arm64.s
@@ -0,0 +1,4012 @@
+// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
+
+// External code calls into callbackasm at an offset corresponding
+// to the callback index. Callbackasm is a table of MOV and B instructions.
+// The MOV instruction loads R12 with the callback index, and the
+// B instruction branches to callbackasm1.
+// callbackasm1 takes the callback index from R12 and
+// indexes into an array that stores information about each callback.
+// It then calls the Go implementation for that callback.
+#include "textflag.h"
+
+TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+       MOVD    $0, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $2, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $3, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $4, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $5, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $6, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $7, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $8, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $9, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $10, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $11, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $12, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $13, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $14, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $15, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $16, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $17, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $18, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $19, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $20, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $21, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $22, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $23, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $24, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $25, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $26, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $27, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $28, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $29, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $30, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $31, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $32, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $33, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $34, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $35, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $36, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $37, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $38, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $39, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $40, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $41, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $42, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $43, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $44, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $45, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $46, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $47, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $48, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $49, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $50, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $51, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $52, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $53, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $54, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $55, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $56, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $57, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $58, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $59, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $60, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $61, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $62, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $63, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $64, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $65, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $66, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $67, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $68, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $69, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $70, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $71, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $72, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $73, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $74, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $75, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $76, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $77, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $78, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $79, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $80, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $81, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $82, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $83, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $84, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $85, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $86, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $87, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $88, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $89, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $90, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $91, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $92, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $93, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $94, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $95, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $96, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $97, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $98, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $99, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $100, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $101, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $102, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $103, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $104, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $105, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $106, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $107, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $108, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $109, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $110, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $111, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $112, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $113, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $114, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $115, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $116, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $117, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $118, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $119, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $120, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $121, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $122, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $123, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $124, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $125, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $126, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $127, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $128, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $129, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $130, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $131, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $132, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $133, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $134, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $135, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $136, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $137, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $138, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $139, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $140, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $141, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $142, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $143, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $144, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $145, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $146, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $147, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $148, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $149, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $150, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $151, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $152, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $153, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $154, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $155, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $156, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $157, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $158, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $159, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $160, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $161, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $162, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $163, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $164, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $165, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $166, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $167, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $168, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $169, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $170, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $171, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $172, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $173, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $174, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $175, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $176, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $177, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $178, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $179, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $180, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $181, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $182, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $183, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $184, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $185, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $186, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $187, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $188, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $189, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $190, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $191, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $192, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $193, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $194, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $195, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $196, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $197, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $198, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $199, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $200, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $201, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $202, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $203, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $204, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $205, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $206, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $207, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $208, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $209, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $210, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $211, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $212, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $213, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $214, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $215, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $216, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $217, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $218, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $219, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $220, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $221, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $222, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $223, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $224, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $225, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $226, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $227, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $228, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $229, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $230, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $231, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $232, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $233, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $234, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $235, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $236, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $237, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $238, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $239, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $240, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $241, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $242, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $243, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $244, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $245, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $246, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $247, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $248, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $249, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $250, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $251, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $252, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $253, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $254, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $255, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $256, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $257, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $258, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $259, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $260, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $261, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $262, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $263, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $264, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $265, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $266, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $267, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $268, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $269, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $270, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $271, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $272, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $273, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $274, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $275, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $276, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $277, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $278, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $279, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $280, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $281, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $282, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $283, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $284, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $285, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $286, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $287, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $288, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $289, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $290, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $291, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $292, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $293, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $294, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $295, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $296, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $297, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $298, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $299, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $300, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $301, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $302, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $303, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $304, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $305, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $306, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $307, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $308, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $309, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $310, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $311, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $312, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $313, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $314, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $315, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $316, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $317, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $318, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $319, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $320, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $321, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $322, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $323, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $324, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $325, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $326, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $327, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $328, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $329, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $330, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $331, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $332, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $333, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $334, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $335, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $336, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $337, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $338, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $339, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $340, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $341, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $342, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $343, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $344, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $345, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $346, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $347, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $348, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $349, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $350, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $351, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $352, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $353, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $354, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $355, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $356, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $357, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $358, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $359, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $360, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $361, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $362, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $363, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $364, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $365, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $366, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $367, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $368, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $369, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $370, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $371, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $372, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $373, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $374, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $375, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $376, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $377, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $378, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $379, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $380, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $381, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $382, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $383, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $384, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $385, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $386, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $387, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $388, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $389, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $390, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $391, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $392, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $393, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $394, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $395, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $396, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $397, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $398, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $399, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $400, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $401, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $402, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $403, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $404, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $405, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $406, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $407, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $408, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $409, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $410, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $411, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $412, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $413, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $414, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $415, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $416, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $417, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $418, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $419, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $420, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $421, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $422, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $423, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $424, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $425, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $426, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $427, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $428, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $429, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $430, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $431, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $432, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $433, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $434, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $435, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $436, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $437, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $438, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $439, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $440, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $441, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $442, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $443, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $444, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $445, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $446, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $447, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $448, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $449, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $450, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $451, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $452, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $453, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $454, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $455, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $456, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $457, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $458, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $459, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $460, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $461, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $462, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $463, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $464, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $465, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $466, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $467, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $468, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $469, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $470, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $471, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $472, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $473, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $474, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $475, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $476, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $477, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $478, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $479, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $480, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $481, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $482, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $483, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $484, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $485, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $486, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $487, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $488, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $489, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $490, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $491, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $492, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $493, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $494, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $495, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $496, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $497, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $498, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $499, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $500, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $501, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $502, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $503, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $504, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $505, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $506, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $507, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $508, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $509, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $510, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $511, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $512, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $513, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $514, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $515, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $516, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $517, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $518, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $519, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $520, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $521, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $522, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $523, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $524, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $525, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $526, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $527, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $528, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $529, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $530, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $531, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $532, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $533, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $534, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $535, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $536, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $537, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $538, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $539, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $540, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $541, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $542, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $543, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $544, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $545, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $546, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $547, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $548, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $549, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $550, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $551, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $552, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $553, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $554, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $555, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $556, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $557, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $558, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $559, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $560, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $561, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $562, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $563, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $564, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $565, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $566, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $567, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $568, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $569, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $570, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $571, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $572, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $573, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $574, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $575, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $576, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $577, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $578, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $579, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $580, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $581, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $582, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $583, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $584, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $585, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $586, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $587, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $588, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $589, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $590, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $591, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $592, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $593, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $594, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $595, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $596, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $597, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $598, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $599, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $600, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $601, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $602, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $603, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $604, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $605, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $606, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $607, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $608, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $609, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $610, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $611, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $612, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $613, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $614, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $615, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $616, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $617, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $618, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $619, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $620, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $621, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $622, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $623, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $624, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $625, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $626, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $627, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $628, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $629, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $630, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $631, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $632, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $633, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $634, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $635, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $636, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $637, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $638, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $639, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $640, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $641, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $642, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $643, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $644, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $645, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $646, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $647, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $648, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $649, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $650, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $651, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $652, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $653, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $654, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $655, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $656, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $657, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $658, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $659, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $660, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $661, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $662, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $663, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $664, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $665, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $666, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $667, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $668, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $669, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $670, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $671, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $672, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $673, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $674, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $675, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $676, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $677, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $678, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $679, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $680, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $681, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $682, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $683, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $684, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $685, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $686, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $687, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $688, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $689, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $690, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $691, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $692, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $693, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $694, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $695, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $696, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $697, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $698, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $699, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $700, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $701, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $702, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $703, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $704, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $705, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $706, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $707, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $708, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $709, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $710, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $711, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $712, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $713, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $714, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $715, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $716, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $717, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $718, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $719, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $720, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $721, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $722, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $723, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $724, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $725, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $726, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $727, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $728, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $729, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $730, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $731, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $732, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $733, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $734, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $735, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $736, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $737, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $738, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $739, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $740, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $741, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $742, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $743, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $744, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $745, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $746, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $747, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $748, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $749, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $750, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $751, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $752, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $753, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $754, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $755, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $756, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $757, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $758, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $759, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $760, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $761, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $762, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $763, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $764, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $765, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $766, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $767, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $768, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $769, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $770, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $771, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $772, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $773, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $774, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $775, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $776, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $777, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $778, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $779, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $780, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $781, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $782, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $783, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $784, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $785, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $786, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $787, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $788, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $789, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $790, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $791, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $792, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $793, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $794, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $795, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $796, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $797, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $798, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $799, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $800, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $801, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $802, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $803, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $804, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $805, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $806, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $807, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $808, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $809, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $810, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $811, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $812, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $813, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $814, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $815, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $816, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $817, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $818, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $819, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $820, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $821, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $822, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $823, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $824, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $825, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $826, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $827, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $828, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $829, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $830, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $831, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $832, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $833, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $834, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $835, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $836, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $837, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $838, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $839, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $840, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $841, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $842, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $843, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $844, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $845, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $846, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $847, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $848, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $849, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $850, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $851, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $852, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $853, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $854, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $855, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $856, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $857, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $858, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $859, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $860, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $861, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $862, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $863, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $864, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $865, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $866, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $867, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $868, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $869, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $870, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $871, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $872, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $873, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $874, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $875, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $876, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $877, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $878, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $879, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $880, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $881, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $882, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $883, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $884, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $885, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $886, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $887, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $888, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $889, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $890, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $891, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $892, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $893, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $894, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $895, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $896, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $897, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $898, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $899, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $900, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $901, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $902, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $903, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $904, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $905, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $906, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $907, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $908, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $909, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $910, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $911, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $912, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $913, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $914, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $915, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $916, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $917, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $918, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $919, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $920, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $921, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $922, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $923, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $924, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $925, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $926, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $927, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $928, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $929, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $930, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $931, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $932, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $933, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $934, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $935, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $936, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $937, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $938, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $939, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $940, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $941, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $942, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $943, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $944, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $945, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $946, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $947, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $948, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $949, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $950, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $951, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $952, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $953, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $954, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $955, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $956, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $957, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $958, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $959, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $960, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $961, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $962, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $963, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $964, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $965, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $966, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $967, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $968, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $969, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $970, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $971, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $972, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $973, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $974, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $975, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $976, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $977, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $978, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $979, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $980, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $981, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $982, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $983, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $984, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $985, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $986, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $987, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $988, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $989, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $990, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $991, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $992, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $993, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $994, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $995, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $996, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $997, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $998, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $999, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1000, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1001, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1002, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1003, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1004, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1005, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1006, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1007, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1008, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1009, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1010, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1011, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1012, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1013, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1014, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1015, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1016, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1017, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1018, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1019, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1020, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1021, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1022, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1023, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1024, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1025, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1026, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1027, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1028, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1029, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1030, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1031, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1032, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1033, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1034, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1035, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1036, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1037, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1038, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1039, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1040, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1041, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1042, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1043, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1044, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1045, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1046, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1047, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1048, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1049, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1050, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1051, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1052, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1053, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1054, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1055, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1056, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1057, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1058, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1059, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1060, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1061, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1062, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1063, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1064, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1065, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1066, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1067, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1068, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1069, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1070, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1071, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1072, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1073, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1074, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1075, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1076, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1077, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1078, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1079, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1080, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1081, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1082, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1083, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1084, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1085, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1086, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1087, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1088, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1089, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1090, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1091, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1092, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1093, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1094, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1095, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1096, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1097, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1098, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1099, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1100, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1101, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1102, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1103, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1104, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1105, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1106, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1107, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1108, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1109, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1110, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1111, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1112, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1113, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1114, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1115, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1116, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1117, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1118, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1119, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1120, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1121, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1122, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1123, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1124, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1125, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1126, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1127, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1128, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1129, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1130, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1131, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1132, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1133, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1134, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1135, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1136, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1137, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1138, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1139, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1140, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1141, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1142, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1143, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1144, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1145, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1146, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1147, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1148, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1149, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1150, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1151, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1152, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1153, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1154, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1155, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1156, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1157, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1158, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1159, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1160, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1161, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1162, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1163, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1164, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1165, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1166, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1167, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1168, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1169, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1170, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1171, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1172, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1173, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1174, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1175, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1176, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1177, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1178, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1179, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1180, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1181, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1182, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1183, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1184, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1185, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1186, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1187, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1188, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1189, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1190, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1191, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1192, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1193, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1194, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1195, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1196, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1197, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1198, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1199, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1200, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1201, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1202, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1203, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1204, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1205, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1206, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1207, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1208, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1209, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1210, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1211, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1212, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1213, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1214, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1215, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1216, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1217, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1218, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1219, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1220, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1221, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1222, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1223, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1224, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1225, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1226, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1227, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1228, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1229, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1230, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1231, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1232, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1233, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1234, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1235, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1236, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1237, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1238, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1239, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1240, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1241, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1242, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1243, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1244, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1245, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1246, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1247, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1248, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1249, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1250, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1251, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1252, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1253, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1254, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1255, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1256, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1257, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1258, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1259, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1260, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1261, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1262, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1263, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1264, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1265, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1266, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1267, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1268, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1269, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1270, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1271, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1272, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1273, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1274, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1275, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1276, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1277, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1278, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1279, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1280, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1281, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1282, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1283, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1284, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1285, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1286, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1287, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1288, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1289, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1290, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1291, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1292, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1293, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1294, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1295, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1296, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1297, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1298, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1299, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1300, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1301, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1302, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1303, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1304, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1305, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1306, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1307, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1308, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1309, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1310, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1311, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1312, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1313, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1314, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1315, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1316, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1317, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1318, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1319, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1320, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1321, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1322, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1323, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1324, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1325, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1326, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1327, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1328, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1329, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1330, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1331, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1332, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1333, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1334, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1335, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1336, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1337, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1338, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1339, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1340, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1341, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1342, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1343, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1344, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1345, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1346, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1347, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1348, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1349, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1350, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1351, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1352, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1353, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1354, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1355, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1356, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1357, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1358, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1359, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1360, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1361, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1362, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1363, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1364, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1365, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1366, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1367, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1368, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1369, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1370, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1371, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1372, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1373, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1374, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1375, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1376, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1377, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1378, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1379, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1380, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1381, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1382, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1383, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1384, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1385, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1386, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1387, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1388, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1389, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1390, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1391, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1392, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1393, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1394, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1395, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1396, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1397, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1398, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1399, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1400, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1401, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1402, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1403, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1404, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1405, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1406, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1407, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1408, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1409, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1410, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1411, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1412, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1413, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1414, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1415, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1416, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1417, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1418, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1419, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1420, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1421, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1422, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1423, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1424, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1425, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1426, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1427, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1428, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1429, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1430, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1431, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1432, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1433, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1434, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1435, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1436, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1437, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1438, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1439, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1440, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1441, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1442, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1443, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1444, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1445, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1446, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1447, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1448, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1449, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1450, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1451, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1452, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1453, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1454, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1455, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1456, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1457, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1458, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1459, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1460, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1461, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1462, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1463, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1464, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1465, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1466, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1467, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1468, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1469, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1470, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1471, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1472, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1473, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1474, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1475, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1476, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1477, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1478, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1479, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1480, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1481, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1482, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1483, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1484, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1485, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1486, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1487, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1488, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1489, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1490, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1491, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1492, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1493, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1494, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1495, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1496, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1497, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1498, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1499, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1500, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1501, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1502, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1503, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1504, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1505, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1506, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1507, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1508, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1509, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1510, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1511, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1512, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1513, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1514, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1515, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1516, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1517, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1518, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1519, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1520, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1521, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1522, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1523, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1524, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1525, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1526, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1527, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1528, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1529, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1530, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1531, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1532, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1533, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1534, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1535, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1536, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1537, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1538, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1539, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1540, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1541, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1542, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1543, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1544, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1545, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1546, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1547, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1548, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1549, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1550, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1551, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1552, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1553, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1554, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1555, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1556, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1557, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1558, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1559, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1560, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1561, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1562, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1563, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1564, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1565, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1566, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1567, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1568, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1569, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1570, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1571, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1572, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1573, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1574, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1575, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1576, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1577, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1578, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1579, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1580, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1581, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1582, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1583, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1584, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1585, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1586, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1587, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1588, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1589, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1590, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1591, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1592, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1593, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1594, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1595, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1596, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1597, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1598, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1599, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1600, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1601, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1602, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1603, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1604, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1605, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1606, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1607, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1608, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1609, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1610, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1611, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1612, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1613, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1614, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1615, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1616, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1617, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1618, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1619, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1620, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1621, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1622, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1623, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1624, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1625, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1626, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1627, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1628, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1629, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1630, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1631, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1632, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1633, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1634, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1635, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1636, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1637, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1638, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1639, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1640, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1641, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1642, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1643, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1644, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1645, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1646, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1647, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1648, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1649, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1650, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1651, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1652, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1653, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1654, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1655, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1656, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1657, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1658, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1659, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1660, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1661, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1662, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1663, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1664, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1665, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1666, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1667, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1668, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1669, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1670, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1671, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1672, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1673, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1674, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1675, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1676, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1677, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1678, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1679, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1680, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1681, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1682, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1683, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1684, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1685, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1686, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1687, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1688, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1689, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1690, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1691, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1692, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1693, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1694, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1695, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1696, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1697, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1698, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1699, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1700, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1701, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1702, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1703, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1704, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1705, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1706, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1707, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1708, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1709, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1710, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1711, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1712, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1713, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1714, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1715, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1716, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1717, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1718, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1719, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1720, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1721, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1722, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1723, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1724, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1725, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1726, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1727, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1728, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1729, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1730, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1731, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1732, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1733, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1734, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1735, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1736, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1737, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1738, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1739, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1740, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1741, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1742, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1743, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1744, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1745, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1746, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1747, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1748, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1749, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1750, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1751, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1752, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1753, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1754, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1755, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1756, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1757, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1758, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1759, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1760, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1761, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1762, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1763, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1764, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1765, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1766, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1767, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1768, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1769, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1770, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1771, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1772, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1773, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1774, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1775, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1776, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1777, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1778, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1779, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1780, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1781, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1782, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1783, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1784, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1785, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1786, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1787, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1788, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1789, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1790, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1791, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1792, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1793, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1794, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1795, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1796, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1797, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1798, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1799, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1800, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1801, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1802, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1803, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1804, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1805, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1806, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1807, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1808, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1809, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1810, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1811, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1812, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1813, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1814, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1815, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1816, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1817, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1818, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1819, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1820, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1821, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1822, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1823, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1824, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1825, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1826, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1827, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1828, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1829, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1830, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1831, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1832, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1833, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1834, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1835, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1836, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1837, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1838, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1839, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1840, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1841, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1842, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1843, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1844, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1845, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1846, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1847, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1848, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1849, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1850, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1851, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1852, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1853, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1854, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1855, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1856, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1857, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1858, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1859, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1860, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1861, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1862, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1863, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1864, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1865, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1866, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1867, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1868, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1869, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1870, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1871, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1872, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1873, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1874, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1875, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1876, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1877, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1878, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1879, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1880, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1881, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1882, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1883, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1884, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1885, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1886, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1887, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1888, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1889, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1890, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1891, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1892, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1893, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1894, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1895, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1896, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1897, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1898, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1899, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1900, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1901, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1902, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1903, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1904, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1905, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1906, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1907, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1908, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1909, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1910, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1911, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1912, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1913, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1914, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1915, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1916, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1917, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1918, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1919, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1920, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1921, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1922, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1923, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1924, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1925, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1926, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1927, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1928, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1929, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1930, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1931, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1932, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1933, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1934, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1935, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1936, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1937, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1938, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1939, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1940, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1941, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1942, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1943, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1944, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1945, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1946, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1947, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1948, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1949, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1950, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1951, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1952, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1953, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1954, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1955, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1956, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1957, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1958, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1959, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1960, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1961, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1962, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1963, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1964, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1965, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1966, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1967, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1968, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1969, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1970, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1971, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1972, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1973, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1974, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1975, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1976, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1977, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1978, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1979, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1980, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1981, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1982, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1983, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1984, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1985, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1986, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1987, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1988, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1989, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1990, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1991, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1992, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1993, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1994, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1995, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1996, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1997, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1998, R12
+       B       runtime·callbackasm1(SB)
+       MOVD    $1999, R12
+       B       runtime·callbackasm1(SB)

diff --git a/src/strconv/bytealg.go b/src/strconv/bytealg.go
new file mode 100644 (file)
index 0000000..7f66f2a
--- /dev/null
+++ b/src/strconv/bytealg.go
@@ -0,0 +1,14 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !compiler_bootstrap
+
+package strconv
+
+import "internal/bytealg"
+
+// contains reports whether the string contains the byte c.
+func contains(s string, c byte) bool {
+       return bytealg.IndexByteString(s, c) != -1
+}

diff --git a/src/strconv/bytealg_bootstrap.go b/src/strconv/bytealg_bootstrap.go
new file mode 100644 (file)
index 0000000..a3a547d
--- /dev/null
+++ b/src/strconv/bytealg_bootstrap.go
@@ -0,0 +1,17 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build compiler_bootstrap
+
+package strconv
+
+// contains reports whether the string contains the byte c.
+func contains(s string, c byte) bool {
+       for i := 0; i < len(s); i++ {
+               if s[i] == c {
+                       return true
+               }
+       }
+       return false
+}

diff --git a/src/strconv/eisel_lemire.go b/src/strconv/eisel_lemire.go
index 6c7f852eba8061efb18e83aa2741816279ca8064..fecd1b93451d0794af39198efc42462aa41bece1 100644 (file)
--- a/src/strconv/eisel_lemire.go
+++ b/src/strconv/eisel_lemire.go
@@ -29,7 +29,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
        // Exp10 Range.
        if man == 0 {
                if neg {
-                       f = math.Float64frombits(0x80000000_00000000) // Negative zero.
+                       f = math.Float64frombits(0x8000000000000000) // Negative zero.
                }
                return f, true
        }
@@ -39,7 +39,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 
        // Normalization.
        clz := bits.LeadingZeros64(man)
-       man <<= clz
+       man <<= uint(clz)
        const float64ExponentBias = 1023
        retExp2 := uint64(217706*exp10>>16+64+float64ExponentBias) - uint64(clz)
 
@@ -84,9 +84,9 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
        if retExp2-1 >= 0x7FF-1 {
                return 0, false
        }
-       retBits := retExp2<<52 | retMantissa&0x000FFFFF_FFFFFFFF
+       retBits := retExp2<<52 | retMantissa&0x000FFFFFFFFFFFFF
        if neg {
-               retBits |= 0x80000000_00000000
+               retBits |= 0x8000000000000000
        }
        return math.Float64frombits(retBits), true
 }
@@ -114,7 +114,7 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 
        // Normalization.
        clz := bits.LeadingZeros64(man)
-       man <<= clz
+       man <<= uint(clz)
        const float32ExponentBias = 127
        retExp2 := uint64(217706*exp10>>16+64+float32ExponentBias) - uint64(clz)
 
@@ -122,13 +122,13 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
        xHi, xLo := bits.Mul64(man, detailedPowersOfTen[exp10-detailedPowersOfTenMinExp10][1])
 
        // Wider Approximation.
-       if xHi&0x3F_FFFFFFFF == 0x3F_FFFFFFFF && xLo+man < man {
+       if xHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && xLo+man < man {
                yHi, yLo := bits.Mul64(man, detailedPowersOfTen[exp10-detailedPowersOfTenMinExp10][0])
                mergedHi, mergedLo := xHi, xLo+yHi
                if mergedLo < xLo {
                        mergedHi++
                }
-               if mergedHi&0x3F_FFFFFFFF == 0x3F_FFFFFFFF && mergedLo+1 == 0 && yLo+man < man {
+               if mergedHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && mergedLo+1 == 0 && yLo+man < man {
                        return 0, false
                }
                xHi, xLo = mergedHi, mergedLo
@@ -140,7 +140,7 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
        retExp2 -= 1 ^ msb
 
        // Half-way Ambiguity.
-       if xLo == 0 && xHi&0x3F_FFFFFFFF == 0 && retMantissa&3 == 1 {
+       if xLo == 0 && xHi&0x3FFFFFFFFF == 0 && retMantissa&3 == 1 {
                return 0, false
        }
 

diff --git a/src/strconv/quote.go b/src/strconv/quote.go
index bcbdbc514d21a8b72f8f83fecd5cc8cb5b9d4c49..4ffa10b72efc9d163640401c76092f47a16c125b 100644 (file)
--- a/src/strconv/quote.go
+++ b/src/strconv/quote.go
@@ -7,7 +7,6 @@
 package strconv
 
 import (
-       "internal/bytealg"
        "unicode/utf8"
 )
 
@@ -436,11 +435,6 @@ func Unquote(s string) (string, error) {
        return string(buf), nil
 }
 
-// contains reports whether the string contains the byte c.
-func contains(s string, c byte) bool {
-       return bytealg.IndexByteString(s, c) != -1
-}
-
 // bsearch16 returns the smallest i such that a[i] >= x.
 // If there is no such i, bsearch16 returns len(a).
 func bsearch16(a []uint16, x uint16) int {

diff --git a/src/syscall/asm9_unix1_amd64.s b/src/syscall/asm9_unix1_amd64.s
index 29af78c801cbdd46e31b1fb371b53155994f444f..f2ae87d623e765737b4e232cdf4e82f499d3b591 100644 (file)
--- a/src/syscall/asm9_unix1_amd64.s
+++ b/src/syscall/asm9_unix1_amd64.s
@@ -1,4 +1,4 @@
-// +build netbsd openbsd
+// +build netbsd
 
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -8,7 +8,7 @@
 #include "funcdata.h"
 
 //
-// Syscall9 support for AMD64, NetBSD and OpenBSD
+// Syscall9 support for AMD64, NetBSD
 //
 
 // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64);

diff --git a/src/syscall/asm_openbsd_amd64.s b/src/syscall/asm_openbsd_amd64.s
new file mode 100644 (file)
index 0000000..8d2ffd1
--- /dev/null
+++ b/src/syscall/asm_openbsd_amd64.s
@@ -0,0 +1,32 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "textflag.h"
+
+//
+// System call support for AMD64, OpenBSD
+//
+
+// Provide these function names via assembly so they are provided as ABI0,
+// rather than ABIInternal.
+
+// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall(SB),NOSPLIT,$0-56
+       JMP     ·syscallInternal(SB)
+
+// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall6(SB),NOSPLIT,$0-80
+       JMP     ·syscall6Internal(SB)
+
+// func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·RawSyscall(SB),NOSPLIT,$0-56
+       JMP     ·rawSyscallInternal(SB)
+
+// func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·RawSyscall6(SB),NOSPLIT,$0-80
+       JMP     ·rawSyscall6Internal(SB)
+
+// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall9(SB),NOSPLIT,$0-104
+       JMP     ·syscall9Internal(SB)

diff --git a/src/syscall/asm_openbsd_arm64.s b/src/syscall/asm_openbsd_arm64.s
index dcbed10cbea39d20a13f2ab270654720af8a3046..61595a11a37303466db4f0440485037f51f609f1 100644 (file)
--- a/src/syscall/asm_openbsd_arm64.s
+++ b/src/syscall/asm_openbsd_arm64.s
@@ -4,127 +4,29 @@
 
 #include "textflag.h"
 
-// See comment in runtime/sys_openbsd_arm64.s re this construction.
-#define        INVOKE_SYSCALL  \
-       SVC;            \
-       NOOP;           \
-       NOOP
+//
+// System call support for ARM64, OpenBSD
+//
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-       BL      runtime·entersyscall(SB)
-       MOVD    a1+8(FP), R0
-       MOVD    a2+16(FP), R1
-       MOVD    a3+24(FP), R2
-       MOVD    $0, R3
-       MOVD    $0, R4
-       MOVD    $0, R5
-       MOVD    trap+0(FP), R8  // syscall number
-       INVOKE_SYSCALL
-       BCC     ok
-       MOVD    $-1, R4
-       MOVD    R4, r1+32(FP)   // r1
-       MOVD    ZR, r2+40(FP)   // r2
-       MOVD    R0, err+48(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
-ok:
-       MOVD    R0, r1+32(FP)   // r1
-       MOVD    R1, r2+40(FP)   // r2
-       MOVD    ZR, err+48(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
+// Provide these function names via assembly so they are provided as ABI0,
+// rather than ABIInternal.
 
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-       BL      runtime·entersyscall(SB)
-       MOVD    a1+8(FP), R0
-       MOVD    a2+16(FP), R1
-       MOVD    a3+24(FP), R2
-       MOVD    a4+32(FP), R3
-       MOVD    a5+40(FP), R4
-       MOVD    a6+48(FP), R5
-       MOVD    trap+0(FP), R8  // syscall number
-       INVOKE_SYSCALL
-       BCC     ok
-       MOVD    $-1, R4
-       MOVD    R4, r1+56(FP)   // r1
-       MOVD    ZR, r2+64(FP)   // r2
-       MOVD    R0, err+72(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
-ok:
-       MOVD    R0, r1+56(FP)   // r1
-       MOVD    R1, r2+64(FP)   // r2
-       MOVD    ZR, err+72(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
+// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall(SB),NOSPLIT,$0-56
+       JMP     ·syscallInternal(SB)
 
-TEXT ·Syscall9(SB),NOSPLIT,$0-104
-       BL      runtime·entersyscall(SB)
-       MOVD    a1+8(FP), R0
-       MOVD    a2+16(FP), R1
-       MOVD    a3+24(FP), R2
-       MOVD    a4+32(FP), R3
-       MOVD    a5+40(FP), R4
-       MOVD    a6+48(FP), R5
-       MOVD    a7+56(FP), R6
-       MOVD    a8+64(FP), R7
-       MOVD    a9+72(FP), R8   // on stack
-       MOVD    R8, 8(RSP)
-       MOVD    num+0(FP), R8   // syscall number
-       INVOKE_SYSCALL
-       BCC     ok
-       MOVD    $-1, R4
-       MOVD    R4, r1+80(FP)   // r1
-       MOVD    ZR, r2+88(FP)   // r2
-       MOVD    R0, err+96(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
-ok:
-       MOVD    R0, r1+80(FP)   // r1
-       MOVD    R1, r2+88(FP)   // r2
-       MOVD    ZR, err+96(FP)  // errno
-       BL      runtime·exitsyscall(SB)
-       RET
+// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall6(SB),NOSPLIT,$0-80
+       JMP     ·syscall6Internal(SB)
 
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-       MOVD    a1+8(FP), R0
-       MOVD    a2+16(FP), R1
-       MOVD    a3+24(FP), R2
-       MOVD    $0, R3
-       MOVD    $0, R4
-       MOVD    $0, R5
-       MOVD    trap+0(FP), R8  // syscall number
-       INVOKE_SYSCALL
-       BCC     ok
-       MOVD    $-1, R4
-       MOVD    R4, r1+32(FP)   // r1
-       MOVD    ZR, r2+40(FP)   // r2
-       MOVD    R0, err+48(FP)  // errno
-       RET
-ok:
-       MOVD    R0, r1+32(FP)   // r1
-       MOVD    R1, r2+40(FP)   // r2
-       MOVD    ZR, err+48(FP)  // errno
-       RET
+// func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·RawSyscall(SB),NOSPLIT,$0-56
+       JMP     ·rawSyscallInternal(SB)
 
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-       MOVD    a1+8(FP), R0
-       MOVD    a2+16(FP), R1
-       MOVD    a3+24(FP), R2
-       MOVD    a4+32(FP), R3
-       MOVD    a5+40(FP), R4
-       MOVD    a6+48(FP), R5
-       MOVD    trap+0(FP), R8  // syscall number
-       INVOKE_SYSCALL
-       BCC     ok
-       MOVD    $-1, R4
-       MOVD    R4, r1+56(FP)   // r1
-       MOVD    ZR, r2+64(FP)   // r2
-       MOVD    R0, err+72(FP)  // errno
-       RET
-ok:
-       MOVD    R0, r1+56(FP)   // r1
-       MOVD    R1, r2+64(FP)   // r2
-       MOVD    ZR, err+72(FP)  // errno
-       RET
+// func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·RawSyscall6(SB),NOSPLIT,$0-80
+       JMP     ·rawSyscall6Internal(SB)
+
+// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+TEXT   ·Syscall9(SB),NOSPLIT,$0-104
+       JMP     ·syscall9Internal(SB)

diff --git a/src/syscall/asm_unix_amd64.s b/src/syscall/asm_unix_amd64.s
index 9cf3fe0d358fb4f72b4b65ce6ed6dbd7589ec8f8..aa03eb96a0ad900b0b0e7e28ba07f9c1c70bd835 100644 (file)
--- a/src/syscall/asm_unix_amd64.s
+++ b/src/syscall/asm_unix_amd64.s
@@ -1,4 +1,4 @@
-// +build netbsd freebsd openbsd dragonfly
+// +build netbsd freebsd dragonfly
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index b297db96cc4fa899cdc747e3931f508167ffa5a6..940a81b58ee90fbad19aa9b5c475004d60183364 100644 (file)
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build dragonfly freebsd netbsd openbsd
+// +build dragonfly freebsd netbsd openbsd,!amd64,!arm64
 
 package syscall
 

diff --git a/src/syscall/exec_darwin.go b/src/syscall/exec_libc2.go
similarity index 99%
rename from src/syscall/exec_darwin.go
rename to src/syscall/exec_libc2.go
index f035d555535609a98b1e8ca9f60ca12212666620..45d3f85baff9ac3c74adec26cc5df145eee89708 100644 (file)
--- a/src/syscall/exec_darwin.go
+++ b/src/syscall/exec_libc2.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build darwin openbsd,amd64 openbsd,arm64
+
 package syscall
 
 import (

diff --git a/src/syscall/exec_plan9.go b/src/syscall/exec_plan9.go
index 47ccbdc384e93a8f826cf0de3b19f5f0e349aa5b..12c4237f69e4e7ed6a8d05257b594c84d276a477 100644 (file)
--- a/src/syscall/exec_plan9.go
+++ b/src/syscall/exec_plan9.go
@@ -320,14 +320,15 @@ func cexecPipe(p []int) error {
                return e
        }
 
-       fd, e := Open("#d/"+itoa(p[1]), O_CLOEXEC)
+       fd, e := Open("#d/"+itoa(p[1]), O_RDWR|O_CLOEXEC)
        if e != nil {
                Close(p[0])
                Close(p[1])
                return e
        }
 
-       Close(fd)
+       Close(p[1])
+       p[1] = fd
        return nil
 }
 

diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go
index 725c2bc1f92195252f056c47c98c55da7eb144fa..1f49c78ef9d7e276621e59f3cf596f62565a5a8d 100644 (file)
--- a/src/syscall/exec_unix.go
+++ b/src/syscall/exec_unix.go
@@ -272,6 +272,7 @@ func runtime_AfterExec()
 // avoids a build dependency for other platforms.
 var execveLibc func(path uintptr, argv uintptr, envp uintptr) Errno
 var execveDarwin func(path *byte, argv **byte, envp **byte) error
+var execveOpenBSD func(path *byte, argv **byte, envp **byte) error
 
 // Exec invokes the execve(2) system call.
 func Exec(argv0 string, argv []string, envv []string) (err error) {
@@ -299,6 +300,9 @@ func Exec(argv0 string, argv []string, envv []string) (err error) {
        } else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
                // Similarly on Darwin.
                err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
+       } else if runtime.GOOS == "openbsd" && runtime.GOARCH == "amd64" {
+               // Similarly on OpenBSD.
+               err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
        } else {
                _, _, err1 = RawSyscall(SYS_EXECVE,
                        uintptr(unsafe.Pointer(argv0p)),

diff --git a/src/syscall/mkall.sh b/src/syscall/mkall.sh
index 8f1111dafbf49787f0f52e07c9f2c4b7b666e5ae..d1e28efa8c0cd0b5742e6a64562497680ef913a3 100755 (executable)
--- a/src/syscall/mkall.sh
+++ b/src/syscall/mkall.sh
@@ -125,13 +125,13 @@ darwin_amd64)
        mkerrors="$mkerrors -m64"
        mksyscall="./mksyscall.pl -darwin"
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-       mkasm="go run mkasm_darwin.go"
+       mkasm="go run mkasm.go"
        ;;
 darwin_arm64)
        mkerrors="$mkerrors -m64"
        mksyscall="./mksyscall.pl -darwin"
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-       mkasm="go run mkasm_darwin.go"
+       mkasm="go run mkasm.go"
        ;;
 dragonfly_amd64)
        mkerrors="$mkerrors -m64"
@@ -283,6 +283,7 @@ netbsd_arm64)
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
        ;;
 openbsd_386)
+       GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
        mkerrors="$mkerrors -m32"
        mksyscall="./mksyscall.pl -l32 -openbsd"
        mksysctl="./mksysctl_openbsd.pl"
@@ -291,14 +292,17 @@ openbsd_386)
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
        ;;
 openbsd_amd64)
+       GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
        mkerrors="$mkerrors -m64"
-       mksyscall="./mksyscall.pl -openbsd"
+       mksyscall="./mksyscall.pl -openbsd -libc"
        mksysctl="./mksysctl_openbsd.pl"
        zsysctl="zsysctl_openbsd.go"
        mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
+       mkasm="go run mkasm.go"
        ;;
 openbsd_arm)
+       GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
        mkerrors="$mkerrors"
        mksyscall="./mksyscall.pl -l32 -openbsd -arm"
        mksysctl="./mksysctl_openbsd.pl"
@@ -309,16 +313,19 @@ openbsd_arm)
        mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
        ;;
 openbsd_arm64)
+       GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
        mkerrors="$mkerrors -m64"
-       mksyscall="./mksyscall.pl -openbsd"
+       mksyscall="./mksyscall.pl -openbsd -libc"
        mksysctl="./mksysctl_openbsd.pl"
        zsysctl="zsysctl_openbsd.go"
        mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
        # Let the type of C char be signed to make the bare syscall
        # API consistent between platforms.
        mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
+       mkasm="go run mkasm.go"
        ;;
 openbsd_mips64)
+       GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
        mkerrors="$mkerrors -m64"
        mksyscall="./mksyscall.pl -openbsd"
        mksysctl="./mksysctl_openbsd.pl"
@@ -327,7 +334,6 @@ openbsd_mips64)
        # Let the type of C char be signed to make the bare syscall
        # API consistent between platforms.
        mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
-       GOOSARCH_in=syscall_openbsd_mips64.go
        ;;
 plan9_386)
        mkerrors=
@@ -367,5 +373,5 @@ esac
                # Therefore, "go run" tries to recompile syscall package but ztypes is empty and it fails.
                echo "$mktypes types_$GOOS.go |go run mkpost.go >ztypes_$GOOSARCH.go.NEW && mv ztypes_$GOOSARCH.go.NEW ztypes_$GOOSARCH.go";
        fi
-       if [ -n "$mkasm" ]; then echo "$mkasm $GOARCH"; fi
+       if [ -n "$mkasm" ]; then echo "$mkasm $GOOS $GOARCH"; fi
 ) | $run

diff --git a/src/syscall/mkasm.go b/src/syscall/mkasm.go
new file mode 100644 (file)
index 0000000..e53d14b
--- /dev/null
+++ b/src/syscall/mkasm.go
@@ -0,0 +1,65 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// mkasm.go generates assembly trampolines to call library routines from Go.
+// This program must be run after mksyscall.pl.
+package main
+
+import (
+       "bytes"
+       "fmt"
+       "log"
+       "os"
+       "strings"
+)
+
+func main() {
+       if len(os.Args) != 3 {
+               log.Fatalf("Usage: %s <goos> <arch>", os.Args[0])
+       }
+       goos, arch := os.Args[1], os.Args[2]
+
+       syscallFilename := fmt.Sprintf("syscall_%s.go", goos)
+       syscallArchFilename := fmt.Sprintf("syscall_%s_%s.go", goos, arch)
+
+       in1, err := os.ReadFile(syscallFilename)
+       if err != nil {
+               log.Fatalf("can't open syscall file: %s", err)
+       }
+       in2, err := os.ReadFile(syscallArchFilename)
+       if err != nil {
+               log.Fatalf("can't open syscall file: %s", err)
+       }
+       in3, err := os.ReadFile("z" + syscallArchFilename)
+       if err != nil {
+               log.Fatalf("can't open syscall file: %s", err)
+       }
+       in := string(in1) + string(in2) + string(in3)
+
+       trampolines := map[string]bool{}
+
+       var out bytes.Buffer
+
+       fmt.Fprintf(&out, "// go run mkasm.go %s\n", strings.Join(os.Args[1:], " "))
+       fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
+       fmt.Fprintf(&out, "#include \"textflag.h\"\n")
+       for _, line := range strings.Split(in, "\n") {
+               if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
+                       continue
+               }
+               fn := line[5 : len(line)-13]
+               if !trampolines[fn] {
+                       trampolines[fn] = true
+                       // The trampolines are ABIInternal as they are address-taken in Go code.
+                       fmt.Fprintf(&out, "TEXT ·%s_trampoline<ABIInternal>(SB),NOSPLIT,$0-0\n", fn)
+                       fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
+               }
+       }
+       err = os.WriteFile(fmt.Sprintf("zsyscall_%s_%s.s", goos, arch), out.Bytes(), 0644)
+       if err != nil {
+               log.Fatalf("can't write syscall file: %s", err)
+       }
+}

diff --git a/src/syscall/mkasm_darwin.go b/src/syscall/mkasm_darwin.go
deleted file mode 100644 (file)
index 1783387..0000000
--- a/src/syscall/mkasm_darwin.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// mkasm_darwin.go generates assembly trampolines to call libSystem routines from Go.
-//This program must be run after mksyscall.pl.
-package main
-
-import (
-       "bytes"
-       "fmt"
-       "log"
-       "os"
-       "strings"
-)
-
-func main() {
-       in1, err := os.ReadFile("syscall_darwin.go")
-       if err != nil {
-               log.Fatalf("can't open syscall_darwin.go: %s", err)
-       }
-       arch := os.Args[1]
-       in2, err := os.ReadFile(fmt.Sprintf("syscall_darwin_%s.go", arch))
-       if err != nil {
-               log.Fatalf("can't open syscall_darwin_%s.go: %s", arch, err)
-       }
-       in3, err := os.ReadFile(fmt.Sprintf("zsyscall_darwin_%s.go", arch))
-       if err != nil {
-               log.Fatalf("can't open zsyscall_darwin_%s.go: %s", arch, err)
-       }
-       in := string(in1) + string(in2) + string(in3)
-
-       trampolines := map[string]bool{}
-
-       var out bytes.Buffer
-
-       fmt.Fprintf(&out, "// go run mkasm_darwin.go %s\n", strings.Join(os.Args[1:], " "))
-       fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
-       fmt.Fprintf(&out, "#include \"textflag.h\"\n")
-       for _, line := range strings.Split(in, "\n") {
-               if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
-                       continue
-               }
-               fn := line[5 : len(line)-13]
-               if !trampolines[fn] {
-                       trampolines[fn] = true
-                       fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
-                       fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
-               }
-       }
-       err = os.WriteFile(fmt.Sprintf("zsyscall_darwin_%s.s", arch), out.Bytes(), 0644)
-       if err != nil {
-               log.Fatalf("can't write zsyscall_darwin_%s.s: %s", arch, err)
-       }
-}

diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl
index 25b40d7ba23cff69f8875c4741df58583d586c24..c1ed3a35d97705be137057129000cc13aaadf3ae 100755 (executable)
--- a/src/syscall/mksyscall.pl
+++ b/src/syscall/mksyscall.pl
@@ -30,6 +30,7 @@ my $openbsd = 0;
 my $netbsd = 0;
 my $dragonfly = 0;
 my $arm = 0; # 64-bit value should use (even, odd)-pair
+my $libc = 0;
 my $tags = "";  # build tags
 
 if($ARGV[0] eq "-b32") {
@@ -45,6 +46,7 @@ if($ARGV[0] eq "-plan9") {
 }
 if($ARGV[0] eq "-darwin") {
        $darwin = 1;
+       $libc = 1;
        shift;
 }
 if($ARGV[0] eq "-openbsd") {
@@ -63,6 +65,10 @@ if($ARGV[0] eq "-arm") {
        $arm = 1;
        shift;
 }
+if($ARGV[0] eq "-libc") {
+       $libc = 1;
+       shift;
+}
 if($ARGV[0] eq "-tags") {
        shift;
        $tags = $ARGV[0];
@@ -125,7 +131,7 @@ while(<>) {
        # without reading the header.
        $text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
 
-       if ($darwin && $func eq "ptrace") {
+       if (($darwin || ($openbsd && $libc)) && $func eq "ptrace") {
                # The ptrace function is called from forkAndExecInChild where stack
                # growth is forbidden.
                $text .= "//go:nosplit\n"
@@ -176,7 +182,9 @@ while(<>) {
                        push @args, "uintptr(_p$n)", "uintptr(len($name))";
                        $n++;
                } elsif($type eq "int64" && ($openbsd || $netbsd)) {
-                       push @args, "0";
+                       if (!$libc) {
+                               push @args, "0";
+                       }
                        if($_32bit eq "big-endian") {
                                push @args, "uintptr($name>>32)", "uintptr($name)";
                        } elsif($_32bit eq "little-endian") {
@@ -220,7 +228,7 @@ while(<>) {
                        $asm = "RawSyscall";
                }
        }
-       if ($darwin) {
+       if ($libc) {
                # Call unexported syscall functions (which take
                # libc functions instead of syscall numbers).
                $asm = lcfirst($asm);
@@ -243,7 +251,7 @@ while(<>) {
                print STDERR "$ARGV:$.: too many arguments to system call\n";
        }
 
-       if ($darwin) {
+       if ($darwin || ($openbsd && $libc)) {
                # Use extended versions for calls that generate a 64-bit result.
                my ($name, $type) = parseparam($out[0]);
                if ($type eq "int64" || ($type eq "uintptr" && $_32bit eq "")) {
@@ -257,13 +265,13 @@ while(<>) {
                $sysname = "SYS_$func";
                $sysname =~ s/([a-z])([A-Z])/${1}_$2/g; # turn FooBar into Foo_Bar
                $sysname =~ y/a-z/A-Z/;
-               if($darwin) {
+               if($libc) {
                        $sysname =~ y/A-Z/a-z/;
                        $sysname = substr $sysname, 4;
                        $funcname = "libc_$sysname";
                }
        }
-       if($darwin) {
+       if($libc) {
                if($funcname eq "") {
                        $sysname = substr $sysname, 4;
                        $funcname = "libc_$sysname";
@@ -338,17 +346,18 @@ while(<>) {
        }
        $text .= "\treturn\n";
        $text .= "}\n\n";
-       if($darwin) {
+       if($libc) {
                if (not exists $trampolines{$funcname}) {
                        $trampolines{$funcname} = 1;
                        # The assembly trampoline that jumps to the libc routine.
                        $text .= "func ${funcname}_trampoline()\n";
-                       # Map syscall.funcname to just plain funcname.
-                       # (The jump to this function is in the assembly trampoline, generated by mksyscallasm_darwin.go.)
-                       $text .= "//go:linkname $funcname $funcname\n";
                        # Tell the linker that funcname can be found in libSystem using varname without the libc_ prefix.
                        my $basename = substr $funcname, 5;
-                       $text .= "//go:cgo_import_dynamic $funcname $basename \"/usr/lib/libSystem.B.dylib\"\n\n";
+                       my $libc = "libc.so";
+                       if ($darwin) {
+                               $libc = "/usr/lib/libSystem.B.dylib";
+                       }
+                       $text .= "//go:cgo_import_dynamic $funcname $basename \"$libc\"\n\n";
                }
        }
 }

diff --git a/src/syscall/ptrace_darwin.go b/src/syscall/ptrace_darwin.go
new file mode 100644 (file)
index 0000000..a873d82
--- /dev/null
+++ b/src/syscall/ptrace_darwin.go
@@ -0,0 +1,14 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !ios
+
+package syscall
+
+// Nosplit because it is called from forkAndExecInChild.
+//
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) error {
+       return ptrace1(request, pid, addr, data)
+}

diff --git a/src/syscall/ptrace_ios.go b/src/syscall/ptrace_ios.go
new file mode 100644 (file)
index 0000000..2f61a88
--- /dev/null
+++ b/src/syscall/ptrace_ios.go
@@ -0,0 +1,12 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package syscall
+
+// Nosplit because it is called from forkAndExecInChild.
+//
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+       panic("unimplemented")
+}

diff --git a/src/syscall/syscall_darwin.go b/src/syscall/syscall_darwin.go
index afdadbf89468d728cc94613ab3c7f0d6c6afb529..162e94479fa3143a2c4cf4edcef65cfccaae92f9 100644 (file)
--- a/src/syscall/syscall_darwin.go
+++ b/src/syscall/syscall_darwin.go
@@ -115,7 +115,6 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 
 func libc_getfsstat_trampoline()
 
-//go:linkname libc_getfsstat libc_getfsstat
 //go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
 
 func setattrlistTimes(path string, times []Timespec) error {
@@ -148,7 +147,6 @@ func setattrlistTimes(path string, times []Timespec) error {
 
 func libc_setattrlist_trampoline()
 
-//go:linkname libc_setattrlist libc_setattrlist
 //go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 
 func utimensat(dirfd int, path string, times *[2]Timespec, flag int) error {
@@ -276,7 +274,6 @@ func fdopendir(fd int) (dir uintptr, err error) {
 
 func libc_fdopendir_trampoline()
 
-//go:linkname libc_fdopendir libc_fdopendir
 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {

diff --git a/src/syscall/syscall_darwin_amd64.go b/src/syscall/syscall_darwin_amd64.go
index 23a4e5f9962634ecb13d1abb21753ee9dea7dcb3..687efff77073f15714d7389ee1dff48594cf77fe 100644 (file)
--- a/src/syscall/syscall_darwin_amd64.go
+++ b/src/syscall/syscall_darwin_amd64.go
@@ -21,7 +21,7 @@ func setTimeval(sec, usec int64) Timeval {
 //sys  Stat(path string, stat *Stat_t) (err error) = SYS_stat64
 //sys  Statfs(path string, stat *Statfs_t) (err error) = SYS_statfs64
 //sys   fstatat(fd int, path string, stat *Stat_t, flags int) (err error) = SYS_fstatat64
-//sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys   ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 
 func SetKevent(k *Kevent_t, fd, mode, flags int) {
        k.Ident = uint64(fd)
@@ -56,7 +56,6 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 
 func libc_sendfile_trampoline()
 
-//go:linkname libc_sendfile libc_sendfile
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
 // Implemented in the runtime package (runtime/sys_darwin_64.go)

diff --git a/src/syscall/syscall_darwin_arm64.go b/src/syscall/syscall_darwin_arm64.go
index c824f6d89d8392300d4e5d61010009fb000e0d98..ab57117475824041ec095193d06e4fa415df5c34 100644 (file)
--- a/src/syscall/syscall_darwin_arm64.go
+++ b/src/syscall/syscall_darwin_arm64.go
@@ -21,7 +21,7 @@ func setTimeval(sec, usec int64) Timeval {
 //sys  Stat(path string, stat *Stat_t) (err error)
 //sys  Statfs(path string, stat *Statfs_t) (err error)
 //sys  fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
-//sys  ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys  ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 
 func SetKevent(k *Kevent_t, fd, mode, flags int) {
        k.Ident = uint64(fd)
@@ -56,7 +56,6 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 
 func libc_sendfile_trampoline()
 
-//go:linkname libc_sendfile libc_sendfile
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
 // Implemented in the runtime package (runtime/sys_darwin_64.go)

diff --git a/src/syscall/syscall_linux_test.go b/src/syscall/syscall_linux_test.go
index 153d0efef11f89917f037dc11d84a961a9af94b4..adeb7c9ebbf20d61114a59e74b16c593eb129279 100644 (file)
--- a/src/syscall/syscall_linux_test.go
+++ b/src/syscall/syscall_linux_test.go
@@ -597,6 +597,14 @@ func compareStatus(filter, expect string) error {
        return nil
 }
 
+// killAThread locks the goroutine to an OS thread and exits; this
+// causes an OS thread to terminate.
+func killAThread(c <-chan struct{}) {
+       runtime.LockOSThread()
+       <-c
+       return
+}
+
 // TestSetuidEtc performs tests on all of the wrapped system calls
 // that mirror to the 9 glibc syscalls with POSIX semantics. The test
 // here is considered authoritative and should compile and run
@@ -647,6 +655,11 @@ func TestSetuidEtc(t *testing.T) {
        }
 
        for i, v := range vs {
+               // Generate some thread churn as we execute the tests.
+               c := make(chan struct{})
+               go killAThread(c)
+               close(c)
+
                if err := v.fn(); err != nil {
                        t.Errorf("[%d] %q failed: %v", i, v.call, err)
                        continue

diff --git a/src/syscall/syscall_openbsd.go b/src/syscall/syscall_openbsd.go
index eebb5ceb1a8609d1792e4e80593effd200b9448e..5a5ba5a51b07b7d7f908b74a2831c2ab57c338c7 100644 (file)
--- a/src/syscall/syscall_openbsd.go
+++ b/src/syscall/syscall_openbsd.go
@@ -182,7 +182,6 @@ func setattrlistTimes(path string, times []Timespec) error {
 //sys  Rename(from string, to string) (err error)
 //sys  Revoke(path string) (err error)
 //sys  Rmdir(path string) (err error)
-//sys  Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK
 //sys  Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error)
 //sysnb        Setegid(egid int) (err error)
 //sysnb        Seteuid(euid int) (err error)
@@ -207,8 +206,4 @@ func setattrlistTimes(path string, times []Timespec) error {
 //sys  write(fd int, p []byte) (n int, err error)
 //sys  mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
 //sys  munmap(addr uintptr, length uintptr) (err error)
-//sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
-//sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 //sys  utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
-//sys  getcwd(buf []byte) (n int, err error) = SYS___GETCWD
-//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL

diff --git a/src/syscall/syscall_openbsd1.go b/src/syscall/syscall_openbsd1.go
new file mode 100644 (file)
index 0000000..2c7d0f8
--- /dev/null
+++ b/src/syscall/syscall_openbsd1.go
@@ -0,0 +1,13 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,!amd64,!arm64
+
+package syscall
+
+//sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
+//sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
+//sys  Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK
+//sys  getcwd(buf []byte) (n int, err error) = SYS___GETCWD
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL

diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
new file mode 100644 (file)
index 0000000..042615b
--- /dev/null
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -0,0 +1,77 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build openbsd,amd64 openbsd,arm64
+
+package syscall
+
+import "unsafe"
+
+func init() {
+       execveOpenBSD = execve
+}
+
+//sys directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) = SYS_syscall
+
+func syscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
+       return syscall6X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
+}
+
+func syscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
+       return syscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
+}
+
+func rawSyscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
+       return rawSyscall6X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
+}
+
+func rawSyscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
+       return rawSyscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
+}
+
+func syscall9Internal(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+       return rawSyscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+}
+
+// Implemented in the runtime package (runtime/sys_openbsd3.go)
+func syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscallX(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+func syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+
+func syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+       return syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0)
+}
+func syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+       return syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0)
+}
+
+// Find the entry point for f. See comments in runtime/proc.go for the
+// function of the same name.
+//go:nosplit
+func funcPC(f func()) uintptr {
+       return **(**uintptr)(unsafe.Pointer(&f))
+}
+
+//sys  readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_read
+//sys  writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_write
+//sys  Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_lseek
+//sys  getcwd(buf []byte) (n int, err error)
+//sys  sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error)
+//sysnb fork() (pid int, err error)
+//sysnb ioctl(fd int, req int, arg int) (err error)
+//sysnb execve(path *byte, argv **byte, envp **byte) (err error)
+//sysnb exit(res int) (err error)
+//sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sysnb getentropy(p []byte) (err error)
+//sys   fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
+//sys  fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) = SYS_fcntl
+//sys   unlinkat(fd int, path string, flags int) (err error)
+//sys   openat(fd int, path string, flags int, perm uint32) (fdret int, err error)

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index c1a12ccba362f0fab46d75ffe0d27344338900bc..4a576486d11d6db18ec526b3e19b391f7719680b 100644 (file)
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -234,7 +234,6 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys  CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) = advapi32.CryptAcquireContextW
 //sys  CryptReleaseContext(provhandle Handle, flags uint32) (err error) = advapi32.CryptReleaseContext
 //sys  CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) = advapi32.CryptGenRandom
-//sys  RtlGenRandom(buf *uint8, bytes uint32) (err error) = advapi32.SystemFunction036
 //sys  GetEnvironmentStrings() (envs *uint16, err error) [failretval==nil] = kernel32.GetEnvironmentStringsW
 //sys  FreeEnvironmentStrings(envs *uint16) (err error) = kernel32.FreeEnvironmentStringsW
 //sys  GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) = kernel32.GetEnvironmentVariableW
@@ -415,19 +414,22 @@ const ptrSize = unsafe.Sizeof(uintptr(0))
 // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa365542(v=vs.85).aspx
 func setFilePointerEx(handle Handle, distToMove int64, newFilePointer *int64, whence uint32) error {
        var e1 Errno
-       switch runtime.GOARCH {
-       default:
-               panic("unsupported architecture")
-       case "amd64":
+       if unsafe.Sizeof(uintptr(0)) == 8 {
                _, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 4, uintptr(handle), uintptr(distToMove), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0, 0)
-       case "386":
-               // distToMove is a LARGE_INTEGER:
-               // https://msdn.microsoft.com/en-us/library/windows/desktop/aa383713(v=vs.85).aspx
-               _, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 5, uintptr(handle), uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0)
-       case "arm":
-               // distToMove must be 8-byte aligned per ARM calling convention
-               // https://msdn.microsoft.com/en-us/library/dn736986.aspx#Anchor_7
-               _, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 6, uintptr(handle), 0, uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence))
+       } else {
+               // Different 32-bit systems disgaree about whether distToMove starts 8-byte aligned.
+               switch runtime.GOARCH {
+               default:
+                       panic("unsupported 32-bit architecture")
+               case "386":
+                       // distToMove is a LARGE_INTEGER:
+                       // https://msdn.microsoft.com/en-us/library/windows/desktop/aa383713(v=vs.85).aspx
+                       _, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 5, uintptr(handle), uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0)
+               case "arm":
+                       // distToMove must be 8-byte aligned per ARM calling convention
+                       // https://msdn.microsoft.com/en-us/library/dn736986.aspx#Anchor_7
+                       _, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 6, uintptr(handle), 0, uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence))
+               }
        }
        if e1 != 0 {
                return errnoErr(e1)

diff --git a/src/syscall/types_windows_arm64.go b/src/syscall/types_windows_arm64.go
new file mode 100644 (file)
index 0000000..7d45ddb
--- /dev/null
+++ b/src/syscall/types_windows_arm64.go
@@ -0,0 +1,22 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package syscall
+
+type WSAData struct {
+       Version      uint16
+       HighVersion  uint16
+       MaxSockets   uint16
+       MaxUdpDg     uint16
+       VendorInfo   *byte
+       Description  [WSADESCRIPTION_LEN + 1]byte
+       SystemStatus [WSASYS_STATUS_LEN + 1]byte
+}
+
+type Servent struct {
+       Name    *byte
+       Aliases **byte
+       Proto   *byte
+       Port    uint16
+}

diff --git a/src/syscall/zsyscall_darwin_amd64.go b/src/syscall/zsyscall_darwin_amd64.go
index 093739ebc77e7fa34ed793cbe76c39f049113d35..4f2cdf861e2464c76510ba7473cff8354a38cdcd 100644 (file)
--- a/src/syscall/zsyscall_darwin_amd64.go
+++ b/src/syscall/zsyscall_darwin_amd64.go
@@ -20,7 +20,6 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -35,7 +34,6 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -51,7 +49,6 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -67,7 +64,6 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -82,7 +78,6 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -97,7 +92,6 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -113,7 +107,6 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -128,7 +121,6 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -143,7 +135,6 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -158,7 +149,6 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -173,7 +163,6 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -188,7 +177,6 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -203,7 +191,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -225,7 +212,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -246,7 +232,6 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -262,7 +247,6 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -278,7 +262,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -294,7 +277,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -314,7 +296,6 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -329,7 +310,6 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -345,7 +325,6 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -360,7 +339,6 @@ func pipe(p *[2]int32) (err error) {
 
 func libc_pipe_trampoline()
 
-//go:linkname libc_pipe libc_pipe
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -375,7 +353,6 @@ func kill(pid int, signum int, posix int) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -395,7 +372,6 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +386,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -430,7 +405,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -450,7 +424,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -470,7 +443,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -490,7 +462,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -510,7 +481,6 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +495,6 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -540,7 +509,6 @@ func closedir(dir uintptr) (err error) {
 
 func libc_closedir_trampoline()
 
-//go:linkname libc_closedir libc_closedir
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -556,7 +524,6 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -571,7 +538,6 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -596,7 +562,6 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 
 func libc_exchangedata_trampoline()
 
-//go:linkname libc_exchangedata libc_exchangedata
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -611,7 +576,6 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -626,7 +590,6 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -641,7 +604,6 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -656,7 +618,6 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -671,7 +632,6 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -687,7 +647,6 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -702,7 +661,6 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -717,7 +675,6 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -730,7 +687,6 @@ func Getdtablesize() (size int) {
 
 func libc_getdtablesize_trampoline()
 
-//go:linkname libc_getdtablesize libc_getdtablesize
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -743,7 +699,6 @@ func Getegid() (egid int) {
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -756,7 +711,6 @@ func Geteuid() (uid int) {
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -769,7 +723,6 @@ func Getgid() (gid int) {
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -785,7 +738,6 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -798,7 +750,6 @@ func Getpgrp() (pgrp int) {
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -811,7 +762,6 @@ func Getpid() (pid int) {
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -824,7 +774,6 @@ func Getppid() (ppid int) {
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -840,7 +789,6 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -855,7 +803,6 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -870,7 +817,6 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -886,7 +832,6 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -899,7 +844,6 @@ func Getuid() (uid int) {
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -912,7 +856,6 @@ func Issetugid() (tainted bool) {
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -928,7 +871,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -948,7 +890,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -973,7 +914,6 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -988,7 +928,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1008,7 +947,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1028,7 +966,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1048,7 +985,6 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1069,7 +1005,6 @@ func Mlock(b []byte) (err error) {
 
 func libc_mlock_trampoline()
 
-//go:linkname libc_mlock libc_mlock
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1084,7 +1019,6 @@ func Mlockall(flags int) (err error) {
 
 func libc_mlockall_trampoline()
 
-//go:linkname libc_mlockall libc_mlockall
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1105,7 +1039,6 @@ func Mprotect(b []byte, prot int) (err error) {
 
 func libc_mprotect_trampoline()
 
-//go:linkname libc_mprotect libc_mprotect
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1126,7 +1059,6 @@ func Munlock(b []byte) (err error) {
 
 func libc_munlock_trampoline()
 
-//go:linkname libc_munlock libc_munlock
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1141,7 +1073,6 @@ func Munlockall() (err error) {
 
 func libc_munlockall_trampoline()
 
-//go:linkname libc_munlockall libc_munlockall
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1162,7 +1093,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1183,7 +1113,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1205,7 +1134,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1227,7 +1155,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1249,7 +1176,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1262,7 +1188,6 @@ func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
 
 func libc_readdir_r_trampoline()
 
-//go:linkname libc_readdir_r libc_readdir_r
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1289,7 +1214,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1314,7 +1238,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1334,7 +1257,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1354,7 +1276,6 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1370,7 +1291,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,6 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1400,7 +1319,6 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1415,7 +1333,6 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1430,7 +1347,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1450,7 +1366,6 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1465,7 +1380,6 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1480,7 +1394,6 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1495,7 +1408,6 @@ func Setprivexec(flag int) (err error) {
 
 func libc_setprivexec_trampoline()
 
-//go:linkname libc_setprivexec libc_setprivexec
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1510,7 +1422,6 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1525,7 +1436,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1540,7 +1450,6 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1556,7 +1465,6 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1479,6 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1586,7 +1493,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1611,7 +1517,6 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1626,7 +1531,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1646,7 +1550,6 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1562,6 @@ func Umask(newmask int) (oldmask int) {
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1679,7 +1581,6 @@ func Undelete(path string) (err error) {
 
 func libc_undelete_trampoline()
 
-//go:linkname libc_undelete libc_undelete
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1699,7 +1600,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1719,7 +1619,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1741,7 +1640,6 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1763,7 +1661,6 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 
 func libc_writev_trampoline()
 
-//go:linkname libc_writev libc_writev
 //go:cgo_import_dynamic libc_writev writev "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1779,7 +1676,6 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1794,7 +1690,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1810,7 +1705,6 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1825,7 +1719,6 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1850,7 +1743,6 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1865,7 +1757,6 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1886,7 +1777,6 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1917,7 +1807,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1938,7 +1827,6 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1960,7 +1848,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1975,7 +1862,6 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat64_trampoline()
 
-//go:linkname libc_fstat64 libc_fstat64
 //go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1990,7 +1876,6 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs64_trampoline()
 
-//go:linkname libc_fstatfs64 libc_fstatfs64
 //go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2005,7 +1890,6 @@ func Gettimeofday(tp *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2025,7 +1909,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat64_trampoline()
 
-//go:linkname libc_lstat64 libc_lstat64
 //go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2045,7 +1928,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat64_trampoline()
 
-//go:linkname libc_stat64 libc_stat64
 //go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2065,7 +1947,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs64_trampoline()
 
-//go:linkname libc_statfs64 libc_statfs64
 //go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2085,13 +1966,12 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat64_trampoline()
 
-//go:linkname libc_fstatat64 libc_fstatat64
 //go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 //go:nosplit
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
        _, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -2101,5 +1981,4 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"

diff --git a/src/syscall/zsyscall_darwin_amd64.s b/src/syscall/zsyscall_darwin_amd64.s
index d99656d0282da2584b7fa3b1dd1f5bd2f9b121a0..5eb48cee447a3023aa65323d19ec8dc5514cf18a 100644 (file)
--- a/src/syscall/zsyscall_darwin_amd64.s
+++ b/src/syscall/zsyscall_darwin_amd64.s
@@ -1,253 +1,253 @@
-// go run mkasm_darwin.go amd64
+// go run mkasm.go darwin amd64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pipe(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kill(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_close(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_closedir(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsid(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mknod(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munlockall(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_read(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_write(SB)
-TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_writev(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munmap(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_exit(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_openat(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getcwd(SB)
-TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstat64(SB)
-TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstatfs64(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_gettimeofday(SB)
-TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lstat64(SB)
-TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_stat64(SB)
-TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_statfs64(SB)
-TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstatat64(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ptrace(SB)

diff --git a/src/syscall/zsyscall_darwin_arm64.go b/src/syscall/zsyscall_darwin_arm64.go
index 7698b2503e85e711593396d30c9b2a5912cd2d67..0d8598d8165e24907303a5630e19c9f278ad55bd 100644 (file)
--- a/src/syscall/zsyscall_darwin_arm64.go
+++ b/src/syscall/zsyscall_darwin_arm64.go
@@ -20,7 +20,6 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -35,7 +34,6 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -51,7 +49,6 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -67,7 +64,6 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -82,7 +78,6 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -97,7 +92,6 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -113,7 +107,6 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -128,7 +121,6 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -143,7 +135,6 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -158,7 +149,6 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -173,7 +163,6 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -188,7 +177,6 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -203,7 +191,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -225,7 +212,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -246,7 +232,6 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -262,7 +247,6 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -278,7 +262,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -294,7 +277,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -314,7 +296,6 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -329,7 +310,6 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -345,7 +325,6 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -360,7 +339,6 @@ func pipe(p *[2]int32) (err error) {
 
 func libc_pipe_trampoline()
 
-//go:linkname libc_pipe libc_pipe
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -375,7 +353,6 @@ func kill(pid int, signum int, posix int) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -395,7 +372,6 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +386,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -430,7 +405,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -450,7 +424,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -470,7 +443,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -490,7 +462,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -510,7 +481,6 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +495,6 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -540,7 +509,6 @@ func closedir(dir uintptr) (err error) {
 
 func libc_closedir_trampoline()
 
-//go:linkname libc_closedir libc_closedir
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -556,7 +524,6 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -571,7 +538,6 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -596,7 +562,6 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 
 func libc_exchangedata_trampoline()
 
-//go:linkname libc_exchangedata libc_exchangedata
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -611,7 +576,6 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -626,7 +590,6 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -641,7 +604,6 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -656,7 +618,6 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -671,7 +632,6 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -687,7 +647,6 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -702,7 +661,6 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -717,7 +675,6 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -730,7 +687,6 @@ func Getdtablesize() (size int) {
 
 func libc_getdtablesize_trampoline()
 
-//go:linkname libc_getdtablesize libc_getdtablesize
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -743,7 +699,6 @@ func Getegid() (egid int) {
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -756,7 +711,6 @@ func Geteuid() (uid int) {
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -769,7 +723,6 @@ func Getgid() (gid int) {
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -785,7 +738,6 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -798,7 +750,6 @@ func Getpgrp() (pgrp int) {
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -811,7 +762,6 @@ func Getpid() (pid int) {
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -824,7 +774,6 @@ func Getppid() (ppid int) {
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -840,7 +789,6 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -855,7 +803,6 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -870,7 +817,6 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -886,7 +832,6 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -899,7 +844,6 @@ func Getuid() (uid int) {
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -912,7 +856,6 @@ func Issetugid() (tainted bool) {
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -928,7 +871,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -948,7 +890,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -973,7 +914,6 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -988,7 +928,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1008,7 +947,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1028,7 +966,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1048,7 +985,6 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1069,7 +1005,6 @@ func Mlock(b []byte) (err error) {
 
 func libc_mlock_trampoline()
 
-//go:linkname libc_mlock libc_mlock
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1084,7 +1019,6 @@ func Mlockall(flags int) (err error) {
 
 func libc_mlockall_trampoline()
 
-//go:linkname libc_mlockall libc_mlockall
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1105,7 +1039,6 @@ func Mprotect(b []byte, prot int) (err error) {
 
 func libc_mprotect_trampoline()
 
-//go:linkname libc_mprotect libc_mprotect
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1126,7 +1059,6 @@ func Munlock(b []byte) (err error) {
 
 func libc_munlock_trampoline()
 
-//go:linkname libc_munlock libc_munlock
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1141,7 +1073,6 @@ func Munlockall() (err error) {
 
 func libc_munlockall_trampoline()
 
-//go:linkname libc_munlockall libc_munlockall
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1162,7 +1093,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1183,7 +1113,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1205,7 +1134,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1227,7 +1155,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1249,7 +1176,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1262,7 +1188,6 @@ func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
 
 func libc_readdir_r_trampoline()
 
-//go:linkname libc_readdir_r libc_readdir_r
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1289,7 +1214,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1314,7 +1238,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1334,7 +1257,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1354,7 +1276,6 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1370,7 +1291,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,6 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1400,7 +1319,6 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1415,7 +1333,6 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1430,7 +1347,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1450,7 +1366,6 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1465,7 +1380,6 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1480,7 +1394,6 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1495,7 +1408,6 @@ func Setprivexec(flag int) (err error) {
 
 func libc_setprivexec_trampoline()
 
-//go:linkname libc_setprivexec libc_setprivexec
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1510,7 +1422,6 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1525,7 +1436,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1540,7 +1450,6 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1556,7 +1465,6 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1479,6 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1586,7 +1493,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1611,7 +1517,6 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1626,7 +1531,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1646,7 +1550,6 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1562,6 @@ func Umask(newmask int) (oldmask int) {
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1679,7 +1581,6 @@ func Undelete(path string) (err error) {
 
 func libc_undelete_trampoline()
 
-//go:linkname libc_undelete libc_undelete
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1699,7 +1600,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1719,7 +1619,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1741,7 +1640,6 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1763,7 +1661,6 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 
 func libc_writev_trampoline()
 
-//go:linkname libc_writev libc_writev
 //go:cgo_import_dynamic libc_writev writev "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1779,7 +1676,6 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1794,7 +1690,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1810,7 +1705,6 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1825,7 +1719,6 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1850,7 +1743,6 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1865,7 +1757,6 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1886,7 +1777,6 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1917,7 +1807,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1938,7 +1827,6 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1960,7 +1848,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1975,7 +1862,6 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat_trampoline()
 
-//go:linkname libc_fstat libc_fstat
 //go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1990,7 +1876,6 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs_trampoline()
 
-//go:linkname libc_fstatfs libc_fstatfs
 //go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2005,7 +1890,6 @@ func Gettimeofday(tp *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2025,7 +1909,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat_trampoline()
 
-//go:linkname libc_lstat libc_lstat
 //go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2045,7 +1928,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat_trampoline()
 
-//go:linkname libc_stat libc_stat
 //go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2065,7 +1947,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs_trampoline()
 
-//go:linkname libc_statfs libc_statfs
 //go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2085,13 +1966,12 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat_trampoline()
 
-//go:linkname libc_fstatat libc_fstatat
 //go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 //go:nosplit
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
        _, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -2101,5 +1981,4 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"

diff --git a/src/syscall/zsyscall_darwin_arm64.s b/src/syscall/zsyscall_darwin_arm64.s
index 0a8879d1c36990f1c603ab87032089cc3ca8e803..73e4a3fd8dff254827822e583e5f1dd407fc3398 100644 (file)
--- a/src/syscall/zsyscall_darwin_arm64.s
+++ b/src/syscall/zsyscall_darwin_arm64.s
@@ -1,253 +1,253 @@
-// go run mkasm_darwin.go arm64
+// go run mkasm.go darwin arm64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pipe(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kill(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_close(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_closedir(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getsid(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mknod(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munlockall(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_read(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_write(SB)
-TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_writev(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_munmap(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_exit(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_openat(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_getcwd(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstatfs(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_gettimeofday(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_lstat(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_statfs(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_fstatat(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
        JMP     libc_ptrace(SB)

diff --git a/src/syscall/zsyscall_openbsd_amd64.go b/src/syscall/zsyscall_openbsd_amd64.go
index f7390390e094778f64b26e09a8a0f34d42d6a3a0..733050ad1d8279d11dc18d7e397ad15339f83ced 100644 (file)
--- a/src/syscall/zsyscall_openbsd_amd64.go
+++ b/src/syscall/zsyscall_openbsd_amd64.go
@@ -1,4 +1,4 @@
-// mksyscall.pl -openbsd -tags openbsd,amd64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_amd64.go
+// mksyscall.pl -openbsd -libc -tags openbsd,amd64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
 // +build openbsd,amd64
@@ -10,7 +10,7 @@ import "unsafe"
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -18,20 +18,30 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
        return
 }
 
+func libc_getgroups_trampoline()
+
+//go:linkname libc_getgroups libc_getgroups
+//go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setgroups_trampoline()
+
+//go:linkname libc_setgroups libc_setgroups
+//go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-       r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+       r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
        wpid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -39,10 +49,15 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
        return
 }
 
+func libc_wait4_trampoline()
+
+//go:linkname libc_wait4 libc_wait4
+//go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-       r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -50,30 +65,45 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
        return
 }
 
+func libc_accept_trampoline()
+
+//go:linkname libc_accept libc_accept
+//go:cgo_import_dynamic libc_accept accept "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-       _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+       _, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_bind_trampoline()
+
+//go:linkname libc_bind libc_bind
+//go:cgo_import_dynamic libc_bind bind "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-       _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
+       _, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_connect_trampoline()
+
+//go:linkname libc_connect libc_connect
+//go:cgo_import_dynamic libc_connect connect "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-       r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+       r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -81,66 +111,101 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
        return
 }
 
+func libc_socket_trampoline()
+
+//go:linkname libc_socket libc_socket
+//go:cgo_import_dynamic libc_socket socket "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-       _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+       _, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getsockopt_trampoline()
+
+//go:linkname libc_getsockopt libc_getsockopt
+//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-       _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+       _, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setsockopt_trampoline()
+
+//go:linkname libc_setsockopt libc_setsockopt
+//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       _, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getpeername_trampoline()
+
+//go:linkname libc_getpeername libc_getpeername
+//go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       _, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getsockname_trampoline()
+
+//go:linkname libc_getsockname libc_getsockname
+//go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-       _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
+       _, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_shutdown_trampoline()
+
+//go:linkname libc_shutdown libc_shutdown
+//go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-       _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+       _, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_socketpair_trampoline()
+
+//go:linkname libc_socketpair libc_socketpair
+//go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
@@ -150,7 +215,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+       r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -158,6 +223,11 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
        return
 }
 
+func libc_recvfrom_trampoline()
+
+//go:linkname libc_recvfrom libc_recvfrom
+//go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
@@ -167,17 +237,22 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+       _, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_sendto_trampoline()
+
+//go:linkname libc_sendto libc_sendto
+//go:cgo_import_dynamic libc_sendto sendto "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+       r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -185,10 +260,15 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
        return
 }
 
+func libc_recvmsg_trampoline()
+
+//go:linkname libc_recvmsg libc_recvmsg
+//go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+       r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -196,10 +276,15 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
        return
 }
 
+func libc_sendmsg_trampoline()
+
+//go:linkname libc_sendmsg libc_sendmsg
+//go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-       r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+       r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -207,21 +292,10 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
        return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_kevent_trampoline()
 
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
-       var _p0 unsafe.Pointer
-       if len(mib) > 0 {
-               _p0 = unsafe.Pointer(&mib[0])
-       } else {
-               _p0 = unsafe.Pointer(&_zero)
-       }
-       _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
-       if e1 != 0 {
-               err = errnoErr(e1)
-       }
-       return
-}
+//go:linkname libc_kevent libc_kevent
+//go:cgo_import_dynamic libc_kevent kevent "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
@@ -231,27 +305,37 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+       _, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_utimes_trampoline()
+
+//go:linkname libc_utimes libc_utimes
+//go:cgo_import_dynamic libc_utimes utimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-       _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+       _, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_futimes_trampoline()
+
+//go:linkname libc_futimes libc_futimes
+//go:cgo_import_dynamic libc_futimes futimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-       r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+       r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -259,20 +343,30 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
        return
 }
 
+func libc_fcntl_trampoline()
+
+//go:linkname libc_fcntl libc_fcntl
+//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_pipe2_trampoline()
+
+//go:linkname libc_pipe2 libc_pipe2
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-       r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+       r0, _, e1 := syscall6(funcPC(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
        nfd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -280,6 +374,11 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
        return
 }
 
+func libc_accept4_trampoline()
+
+//go:linkname libc_accept4 libc_accept4
+//go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getdents(fd int, buf []byte) (n int, err error) {
@@ -289,7 +388,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+       r0, _, e1 := syscall(funcPC(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -297,6 +396,11 @@ func getdents(fd int, buf []byte) (n int, err error) {
        return
 }
 
+func libc_getdents_trampoline()
+
+//go:linkname libc_getdents libc_getdents
+//go:cgo_import_dynamic libc_getdents getdents "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Access(path string, mode uint32) (err error) {
@@ -305,23 +409,33 @@ func Access(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_access_trampoline()
+
+//go:linkname libc_access libc_access
+//go:cgo_import_dynamic libc_access access "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-       _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+       _, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_adjtime_trampoline()
+
+//go:linkname libc_adjtime libc_adjtime
+//go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chdir(path string) (err error) {
@@ -330,13 +444,18 @@ func Chdir(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chdir_trampoline()
+
+//go:linkname libc_chdir libc_chdir
+//go:cgo_import_dynamic libc_chdir chdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chflags(path string, flags int) (err error) {
@@ -345,13 +464,18 @@ func Chflags(path string, flags int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chflags_trampoline()
+
+//go:linkname libc_chflags libc_chflags
+//go:cgo_import_dynamic libc_chflags chflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chmod(path string, mode uint32) (err error) {
@@ -360,13 +484,18 @@ func Chmod(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chmod_trampoline()
+
+//go:linkname libc_chmod libc_chmod
+//go:cgo_import_dynamic libc_chmod chmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chown(path string, uid int, gid int) (err error) {
@@ -375,13 +504,18 @@ func Chown(path string, uid int, gid int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chown_trampoline()
+
+//go:linkname libc_chown libc_chown
+//go:cgo_import_dynamic libc_chown chown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chroot(path string) (err error) {
@@ -390,27 +524,37 @@ func Chroot(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chroot_trampoline()
+
+//go:linkname libc_chroot libc_chroot
+//go:cgo_import_dynamic libc_chroot chroot "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_close_trampoline()
+
+//go:linkname libc_close libc_close
+//go:cgo_import_dynamic libc_close close "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-       r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
+       r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
        nfd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -418,70 +562,105 @@ func Dup(fd int) (nfd int, err error) {
        return
 }
 
+func libc_dup_trampoline()
+
+//go:linkname libc_dup libc_dup
+//go:cgo_import_dynamic libc_dup dup "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-       _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
+       _, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_dup2_trampoline()
+
+//go:linkname libc_dup2 libc_dup2
+//go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchdir_trampoline()
+
+//go:linkname libc_fchdir libc_fchdir
+//go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchflags_trampoline()
+
+//go:linkname libc_fchflags libc_fchflags
+//go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-       _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchmod_trampoline()
+
+//go:linkname libc_fchmod libc_fchmod
+//go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchown_trampoline()
+
+//go:linkname libc_fchown libc_fchown
+//go:cgo_import_dynamic libc_fchown fchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-       _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
+       _, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_flock_trampoline()
+
+//go:linkname libc_flock libc_flock
+//go:cgo_import_dynamic libc_flock flock "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-       r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
+       r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -489,74 +668,114 @@ func Fpathconf(fd int, name int) (val int, err error) {
        return
 }
 
+func libc_fpathconf_trampoline()
+
+//go:linkname libc_fpathconf libc_fpathconf
+//go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-       _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fstat_trampoline()
+
+//go:linkname libc_fstat libc_fstat
+//go:cgo_import_dynamic libc_fstat fstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-       _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fstatfs_trampoline()
+
+//go:linkname libc_fstatfs libc_fstatfs
+//go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fsync_trampoline()
+
+//go:linkname libc_fsync libc_fsync
+//go:cgo_import_dynamic libc_fsync fsync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-       _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length))
+       _, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_ftruncate_trampoline()
+
+//go:linkname libc_ftruncate libc_ftruncate
+//go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-       r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
        egid = int(r0)
        return
 }
 
+func libc_getegid_trampoline()
+
+//go:linkname libc_getegid libc_getegid
+//go:cgo_import_dynamic libc_getegid getegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-       r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
        uid = int(r0)
        return
 }
 
+func libc_geteuid_trampoline()
+
+//go:linkname libc_geteuid libc_geteuid
+//go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-       r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
        gid = int(r0)
        return
 }
 
+func libc_getgid_trampoline()
+
+//go:linkname libc_getgid libc_getgid
+//go:cgo_import_dynamic libc_getgid getgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
        pgid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -564,34 +783,54 @@ func Getpgid(pid int) (pgid int, err error) {
        return
 }
 
+func libc_getpgid_trampoline()
+
+//go:linkname libc_getpgid libc_getpgid
+//go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-       r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
        pgrp = int(r0)
        return
 }
 
+func libc_getpgrp_trampoline()
+
+//go:linkname libc_getpgrp libc_getpgrp
+//go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-       r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
        pid = int(r0)
        return
 }
 
+func libc_getpid_trampoline()
+
+//go:linkname libc_getpid libc_getpid
+//go:cgo_import_dynamic libc_getpid getpid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-       r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
        ppid = int(r0)
        return
 }
 
+func libc_getppid_trampoline()
+
+//go:linkname libc_getppid libc_getppid
+//go:cgo_import_dynamic libc_getppid getppid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-       r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
+       r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
        prio = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -599,30 +838,45 @@ func Getpriority(which int, who int) (prio int, err error) {
        return
 }
 
+func libc_getpriority_trampoline()
+
+//go:linkname libc_getpriority libc_getpriority
+//go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getrlimit_trampoline()
+
+//go:linkname libc_getrlimit libc_getrlimit
+//go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getrusage_trampoline()
+
+//go:linkname libc_getrusage libc_getrusage
+//go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
        sid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -630,46 +884,71 @@ func Getsid(pid int) (sid int, err error) {
        return
 }
 
+func libc_getsid_trampoline()
+
+//go:linkname libc_getsid libc_getsid
+//go:cgo_import_dynamic libc_getsid getsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_gettimeofday_trampoline()
+
+//go:linkname libc_gettimeofday libc_gettimeofday
+//go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-       r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
        uid = int(r0)
        return
 }
 
+func libc_getuid_trampoline()
+
+//go:linkname libc_getuid libc_getuid
+//go:cgo_import_dynamic libc_getuid getuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-       r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0)
+       r0, _, _ := syscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
        tainted = bool(r0 != 0)
        return
 }
 
+func libc_issetugid_trampoline()
+
+//go:linkname libc_issetugid libc_issetugid
+//go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-       _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
+       _, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_kill_trampoline()
+
+//go:linkname libc_kill libc_kill
+//go:cgo_import_dynamic libc_kill kill "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-       r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
+       r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -677,6 +956,11 @@ func Kqueue() (fd int, err error) {
        return
 }
 
+func libc_kqueue_trampoline()
+
+//go:linkname libc_kqueue libc_kqueue
+//go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lchown(path string, uid int, gid int) (err error) {
@@ -685,13 +969,18 @@ func Lchown(path string, uid int, gid int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lchown_trampoline()
+
+//go:linkname libc_lchown libc_lchown
+//go:cgo_import_dynamic libc_lchown lchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Link(path string, link string) (err error) {
@@ -705,23 +994,33 @@ func Link(path string, link string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_link_trampoline()
+
+//go:linkname libc_link libc_link
+//go:cgo_import_dynamic libc_link link "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-       _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
+       _, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_listen_trampoline()
+
+//go:linkname libc_listen libc_listen
+//go:cgo_import_dynamic libc_listen listen "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lstat(path string, stat *Stat_t) (err error) {
@@ -730,13 +1029,18 @@ func Lstat(path string, stat *Stat_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lstat_trampoline()
+
+//go:linkname libc_lstat libc_lstat
+//go:cgo_import_dynamic libc_lstat lstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkdir(path string, mode uint32) (err error) {
@@ -745,13 +1049,18 @@ func Mkdir(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mkdir_trampoline()
+
+//go:linkname libc_mkdir libc_mkdir
+//go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkfifo(path string, mode uint32) (err error) {
@@ -760,13 +1069,18 @@ func Mkfifo(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mkfifo_trampoline()
+
+//go:linkname libc_mkfifo libc_mkfifo
+//go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mknod(path string, mode uint32, dev int) (err error) {
@@ -775,23 +1089,33 @@ func Mknod(path string, mode uint32, dev int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+       _, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mknod_trampoline()
+
+//go:linkname libc_mknod libc_mknod
+//go:cgo_import_dynamic libc_mknod mknod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-       _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+       _, _, e1 := syscall(funcPC(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_nanosleep_trampoline()
+
+//go:linkname libc_nanosleep libc_nanosleep
+//go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Open(path string, mode int, perm uint32) (fd int, err error) {
@@ -800,7 +1124,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
        if err != nil {
                return
        }
-       r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+       r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -808,6 +1132,11 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
        return
 }
 
+func libc_open_trampoline()
+
+//go:linkname libc_open libc_open
+//go:cgo_import_dynamic libc_open open "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pathconf(path string, name int) (val int, err error) {
@@ -816,7 +1145,7 @@ func Pathconf(path string, name int) (val int, err error) {
        if err != nil {
                return
        }
-       r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+       r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -824,6 +1153,11 @@ func Pathconf(path string, name int) (val int, err error) {
        return
 }
 
+func libc_pathconf_trampoline()
+
+//go:linkname libc_pathconf libc_pathconf
+//go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
@@ -833,7 +1167,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
+       r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -841,6 +1175,11 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
        return
 }
 
+func libc_pread_trampoline()
+
+//go:linkname libc_pread libc_pread
+//go:cgo_import_dynamic libc_pread pread "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
@@ -850,7 +1189,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
+       r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -858,6 +1197,11 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
        return
 }
 
+func libc_pwrite_trampoline()
+
+//go:linkname libc_pwrite libc_pwrite
+//go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func read(fd int, p []byte) (n int, err error) {
@@ -867,7 +1211,7 @@ func read(fd int, p []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+       r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -875,6 +1219,11 @@ func read(fd int, p []byte) (n int, err error) {
        return
 }
 
+func libc_read_trampoline()
+
+//go:linkname libc_read libc_read
+//go:cgo_import_dynamic libc_read read "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Readlink(path string, buf []byte) (n int, err error) {
@@ -889,7 +1238,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
        } else {
                _p1 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+       r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -897,6 +1246,11 @@ func Readlink(path string, buf []byte) (n int, err error) {
        return
 }
 
+func libc_readlink_trampoline()
+
+//go:linkname libc_readlink libc_readlink
+//go:cgo_import_dynamic libc_readlink readlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rename(from string, to string) (err error) {
@@ -910,13 +1264,18 @@ func Rename(from string, to string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_rename_trampoline()
+
+//go:linkname libc_rename libc_rename
+//go:cgo_import_dynamic libc_rename rename "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Revoke(path string) (err error) {
@@ -925,13 +1284,18 @@ func Revoke(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_revoke_trampoline()
+
+//go:linkname libc_revoke libc_revoke
+//go:cgo_import_dynamic libc_revoke revoke "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rmdir(path string) (err error) {
@@ -940,64 +1304,78 @@ func Rmdir(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_rmdir_trampoline()
 
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-       r0, _, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(whence), 0, 0)
-       newoffset = int64(r0)
-       if e1 != 0 {
-               err = errnoErr(e1)
-       }
-       return
-}
+//go:linkname libc_rmdir libc_rmdir
+//go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-       _, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+       _, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_select_trampoline()
+
+//go:linkname libc_select libc_select
+//go:cgo_import_dynamic libc_select select "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setegid_trampoline()
+
+//go:linkname libc_setegid libc_setegid
+//go:cgo_import_dynamic libc_setegid setegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_seteuid_trampoline()
+
+//go:linkname libc_seteuid libc_seteuid
+//go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setgid_trampoline()
+
+//go:linkname libc_setgid libc_setgid
+//go:cgo_import_dynamic libc_setgid setgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setlogin(name string) (err error) {
@@ -1006,67 +1384,97 @@ func Setlogin(name string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setlogin_trampoline()
+
+//go:linkname libc_setlogin libc_setlogin
+//go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setpgid_trampoline()
+
+//go:linkname libc_setpgid libc_setpgid
+//go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-       _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
+       _, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setpriority_trampoline()
+
+//go:linkname libc_setpriority libc_setpriority
+//go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setregid_trampoline()
+
+//go:linkname libc_setregid libc_setregid
+//go:cgo_import_dynamic libc_setregid setregid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setreuid_trampoline()
+
+//go:linkname libc_setreuid libc_setreuid
+//go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setrlimit_trampoline()
+
+//go:linkname libc_setrlimit libc_setrlimit
+//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
        pid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1074,26 +1482,41 @@ func Setsid() (pid int, err error) {
        return
 }
 
+func libc_setsid_trampoline()
+
+//go:linkname libc_setsid libc_setsid
+//go:cgo_import_dynamic libc_setsid setsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_settimeofday_trampoline()
+
+//go:linkname libc_settimeofday libc_settimeofday
+//go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setuid_trampoline()
+
+//go:linkname libc_setuid libc_setuid
+//go:cgo_import_dynamic libc_setuid setuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Stat(path string, stat *Stat_t) (err error) {
@@ -1102,13 +1525,18 @@ func Stat(path string, stat *Stat_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_stat_trampoline()
+
+//go:linkname libc_stat libc_stat
+//go:cgo_import_dynamic libc_stat stat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Statfs(path string, stat *Statfs_t) (err error) {
@@ -1117,13 +1545,18 @@ func Statfs(path string, stat *Statfs_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_statfs_trampoline()
+
+//go:linkname libc_statfs libc_statfs
+//go:cgo_import_dynamic libc_statfs statfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Symlink(path string, link string) (err error) {
@@ -1137,23 +1570,33 @@ func Symlink(path string, link string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_symlink_trampoline()
+
+//go:linkname libc_symlink libc_symlink
+//go:cgo_import_dynamic libc_symlink symlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-       _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
+       _, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_sync_trampoline()
+
+//go:linkname libc_sync libc_sync
+//go:cgo_import_dynamic libc_sync sync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Truncate(path string, length int64) (err error) {
@@ -1162,21 +1605,31 @@ func Truncate(path string, length int64) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length))
+       _, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_truncate_trampoline()
+
+//go:linkname libc_truncate libc_truncate
+//go:cgo_import_dynamic libc_truncate truncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-       r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
+       r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
        oldmask = int(r0)
        return
 }
 
+func libc_umask_trampoline()
+
+//go:linkname libc_umask libc_umask
+//go:cgo_import_dynamic libc_umask umask "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unlink(path string) (err error) {
@@ -1185,13 +1638,18 @@ func Unlink(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_unlink_trampoline()
+
+//go:linkname libc_unlink libc_unlink
+//go:cgo_import_dynamic libc_unlink unlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unmount(path string, flags int) (err error) {
@@ -1200,13 +1658,18 @@ func Unmount(path string, flags int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_unmount_trampoline()
+
+//go:linkname libc_unmount libc_unmount
+//go:cgo_import_dynamic libc_unmount unmount "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func write(fd int, p []byte) (n int, err error) {
@@ -1216,7 +1679,7 @@ func write(fd int, p []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+       r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1224,10 +1687,15 @@ func write(fd int, p []byte) (n int, err error) {
        return
 }
 
+func libc_write_trampoline()
+
+//go:linkname libc_write libc_write
+//go:cgo_import_dynamic libc_write write "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-       r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), 0, 0)
+       r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
        ret = uintptr(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1235,20 +1703,66 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
        return
 }
 
+func libc_mmap_trampoline()
+
+//go:linkname libc_mmap libc_mmap
+//go:cgo_import_dynamic libc_mmap mmap "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-       _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
+       _, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_munmap_trampoline()
+
+//go:linkname libc_munmap libc_munmap
+//go:cgo_import_dynamic libc_munmap munmap "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall6(funcPC(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_utimensat_trampoline()
+
+//go:linkname libc_utimensat libc_utimensat
+//go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
+       r0, _, e1 := syscall6X(funcPC(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+       ret = uintptr(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_syscall_trampoline()
+
+//go:linkname libc_syscall libc_syscall
+//go:cgo_import_dynamic libc_syscall syscall "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+       r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1259,7 +1773,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+       r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1269,19 +1783,20 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
-       var _p0 *byte
-       _p0, err = BytePtrFromString(path)
-       if err != nil {
-               return
-       }
-       _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+       r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+       newoffset = int64(r0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lseek_trampoline()
+
+//go:linkname libc_lseek libc_lseek
+//go:cgo_import_dynamic libc_lseek lseek "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getcwd(buf []byte) (n int, err error) {
@@ -1291,10 +1806,206 @@ func getcwd(buf []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
+       r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
+
+func libc_getcwd_trampoline()
+
+//go:linkname libc_getcwd libc_getcwd
+//go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
+       var _p0 unsafe.Pointer
+       if len(mib) > 0 {
+               _p0 = unsafe.Pointer(&mib[0])
+       } else {
+               _p0 = unsafe.Pointer(&_zero)
+       }
+       _, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_sysctl_trampoline()
+
+//go:linkname libc_sysctl libc_sysctl
+//go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fork() (pid int, err error) {
+       r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+       pid = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_fork_trampoline()
+
+//go:linkname libc_fork libc_fork
+//go:cgo_import_dynamic libc_fork fork "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ioctl(fd int, req int, arg int) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_ioctl_trampoline()
+
+//go:linkname libc_ioctl libc_ioctl
+//go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func execve(path *byte, argv **byte, envp **byte) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_execve_trampoline()
+
+//go:linkname libc_execve libc_execve
+//go:cgo_import_dynamic libc_execve execve "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func exit(res int) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_exit_trampoline()
+
+//go:linkname libc_exit libc_exit
+//go:cgo_import_dynamic libc_exit exit "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+       _, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_ptrace_trampoline()
+
+//go:linkname libc_ptrace libc_ptrace
+//go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getentropy(p []byte) (err error) {
+       var _p0 unsafe.Pointer
+       if len(p) > 0 {
+               _p0 = unsafe.Pointer(&p[0])
+       } else {
+               _p0 = unsafe.Pointer(&_zero)
+       }
+       _, _, e1 := rawSyscall(funcPC(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_getentropy_trampoline()
+
+//go:linkname libc_getentropy libc_getentropy
+//go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_fstatat_trampoline()
+
+//go:linkname libc_fstatat libc_fstatat
+//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+       r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+       val = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func unlinkat(fd int, path string, flags int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_unlinkat_trampoline()
+
+//go:linkname libc_unlinkat libc_unlinkat
+//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func openat(fd int, path string, flags int, perm uint32) (fdret int, err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+       fdret = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_openat_trampoline()
+
+//go:linkname libc_openat libc_openat
+//go:cgo_import_dynamic libc_openat openat "libc.so"

diff --git a/src/syscall/zsyscall_openbsd_amd64.s b/src/syscall/zsyscall_openbsd_amd64.s
new file mode 100644 (file)
index 0000000..8256a45
--- /dev/null
+++ b/src/syscall/zsyscall_openbsd_amd64.s
@@ -0,0 +1,233 @@
+// go run mkasm.go openbsd amd64
+// Code generated by the command above; DO NOT EDIT.
+#include "textflag.h"
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getgroups(SB)
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setgroups(SB)
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_wait4(SB)
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_accept(SB)
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_bind(SB)
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_connect(SB)
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_socket(SB)
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsockopt(SB)
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setsockopt(SB)
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpeername(SB)
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsockname(SB)
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_shutdown(SB)
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_socketpair(SB)
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_recvfrom(SB)
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sendto(SB)
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_recvmsg(SB)
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sendmsg(SB)
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kevent(SB)
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_utimes(SB)
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_futimes(SB)
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fcntl(SB)
+TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pipe2(SB)
+TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_accept4(SB)
+TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getdents(SB)
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_access(SB)
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_adjtime(SB)
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chdir(SB)
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chflags(SB)
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chmod(SB)
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chown(SB)
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chroot(SB)
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_close(SB)
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_dup(SB)
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_dup2(SB)
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchdir(SB)
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchflags(SB)
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchmod(SB)
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchown(SB)
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_flock(SB)
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fpathconf(SB)
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstat(SB)
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstatfs(SB)
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fsync(SB)
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ftruncate(SB)
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getegid(SB)
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_geteuid(SB)
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getgid(SB)
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpgid(SB)
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpgrp(SB)
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpid(SB)
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getppid(SB)
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpriority(SB)
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getrlimit(SB)
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getrusage(SB)
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsid(SB)
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_gettimeofday(SB)
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getuid(SB)
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_issetugid(SB)
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kill(SB)
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kqueue(SB)
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lchown(SB)
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_link(SB)
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_listen(SB)
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lstat(SB)
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mkdir(SB)
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mkfifo(SB)
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mknod(SB)
+TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_nanosleep(SB)
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_open(SB)
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pathconf(SB)
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pread(SB)
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pwrite(SB)
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_read(SB)
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_readlink(SB)
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_rename(SB)
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_revoke(SB)
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_rmdir(SB)
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_select(SB)
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setegid(SB)
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_seteuid(SB)
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setgid(SB)
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setlogin(SB)
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setpgid(SB)
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setpriority(SB)
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setregid(SB)
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setreuid(SB)
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setrlimit(SB)
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setsid(SB)
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_settimeofday(SB)
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setuid(SB)
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_stat(SB)
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_statfs(SB)
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_symlink(SB)
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sync(SB)
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_truncate(SB)
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_umask(SB)
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unlink(SB)
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unmount(SB)
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_write(SB)
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mmap(SB)
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_munmap(SB)
+TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_utimensat(SB)
+TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_syscall(SB)
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lseek(SB)
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getcwd(SB)
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sysctl(SB)
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fork(SB)
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ioctl(SB)
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_execve(SB)
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_exit(SB)
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ptrace(SB)
+TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getentropy(SB)
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstatat(SB)
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unlinkat(SB)
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_openat(SB)

diff --git a/src/syscall/zsyscall_openbsd_arm64.go b/src/syscall/zsyscall_openbsd_arm64.go
index 626ce177033ebcf13acdd3ff9bc16863e653ef4f..2093eb74e57f9699595f944181759f04fcb77e11 100644 (file)
--- a/src/syscall/zsyscall_openbsd_arm64.go
+++ b/src/syscall/zsyscall_openbsd_arm64.go
@@ -1,4 +1,4 @@
-// mksyscall.pl -openbsd -tags openbsd,arm64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_arm64.go
+// mksyscall.pl -openbsd -libc -tags openbsd,arm64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
 // +build openbsd,arm64
@@ -10,7 +10,7 @@ import "unsafe"
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -18,20 +18,30 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
        return
 }
 
+func libc_getgroups_trampoline()
+
+//go:linkname libc_getgroups libc_getgroups
+//go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setgroups_trampoline()
+
+//go:linkname libc_setgroups libc_setgroups
+//go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-       r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+       r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
        wpid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -39,10 +49,15 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
        return
 }
 
+func libc_wait4_trampoline()
+
+//go:linkname libc_wait4 libc_wait4
+//go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-       r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -50,30 +65,45 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
        return
 }
 
+func libc_accept_trampoline()
+
+//go:linkname libc_accept libc_accept
+//go:cgo_import_dynamic libc_accept accept "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-       _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+       _, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_bind_trampoline()
+
+//go:linkname libc_bind libc_bind
+//go:cgo_import_dynamic libc_bind bind "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-       _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
+       _, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_connect_trampoline()
+
+//go:linkname libc_connect libc_connect
+//go:cgo_import_dynamic libc_connect connect "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-       r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+       r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -81,66 +111,101 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
        return
 }
 
+func libc_socket_trampoline()
+
+//go:linkname libc_socket libc_socket
+//go:cgo_import_dynamic libc_socket socket "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-       _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+       _, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getsockopt_trampoline()
+
+//go:linkname libc_getsockopt libc_getsockopt
+//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-       _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+       _, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setsockopt_trampoline()
+
+//go:linkname libc_setsockopt libc_setsockopt
+//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       _, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getpeername_trampoline()
+
+//go:linkname libc_getpeername libc_getpeername
+//go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+       _, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getsockname_trampoline()
+
+//go:linkname libc_getsockname libc_getsockname
+//go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-       _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
+       _, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_shutdown_trampoline()
+
+//go:linkname libc_shutdown libc_shutdown
+//go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-       _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+       _, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_socketpair_trampoline()
+
+//go:linkname libc_socketpair libc_socketpair
+//go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
@@ -150,7 +215,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+       r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -158,6 +223,11 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
        return
 }
 
+func libc_recvfrom_trampoline()
+
+//go:linkname libc_recvfrom libc_recvfrom
+//go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
@@ -167,17 +237,22 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+       _, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_sendto_trampoline()
+
+//go:linkname libc_sendto libc_sendto
+//go:cgo_import_dynamic libc_sendto sendto "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+       r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -185,10 +260,15 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
        return
 }
 
+func libc_recvmsg_trampoline()
+
+//go:linkname libc_recvmsg libc_recvmsg
+//go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+       r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -196,10 +276,15 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
        return
 }
 
+func libc_sendmsg_trampoline()
+
+//go:linkname libc_sendmsg libc_sendmsg
+//go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-       r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+       r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -207,6 +292,11 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
        return
 }
 
+func libc_kevent_trampoline()
+
+//go:linkname libc_kevent libc_kevent
+//go:cgo_import_dynamic libc_kevent kevent "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func utimes(path string, timeval *[2]Timeval) (err error) {
@@ -215,27 +305,37 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+       _, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_utimes_trampoline()
+
+//go:linkname libc_utimes libc_utimes
+//go:cgo_import_dynamic libc_utimes utimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-       _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+       _, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_futimes_trampoline()
+
+//go:linkname libc_futimes libc_futimes
+//go:cgo_import_dynamic libc_futimes futimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-       r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+       r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -243,20 +343,30 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
        return
 }
 
+func libc_fcntl_trampoline()
+
+//go:linkname libc_fcntl libc_fcntl
+//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-       _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_pipe2_trampoline()
+
+//go:linkname libc_pipe2 libc_pipe2
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-       r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+       r0, _, e1 := syscall6(funcPC(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
        nfd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -264,6 +374,11 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
        return
 }
 
+func libc_accept4_trampoline()
+
+//go:linkname libc_accept4 libc_accept4
+//go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getdents(fd int, buf []byte) (n int, err error) {
@@ -273,7 +388,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+       r0, _, e1 := syscall(funcPC(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -281,6 +396,11 @@ func getdents(fd int, buf []byte) (n int, err error) {
        return
 }
 
+func libc_getdents_trampoline()
+
+//go:linkname libc_getdents libc_getdents
+//go:cgo_import_dynamic libc_getdents getdents "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Access(path string, mode uint32) (err error) {
@@ -289,23 +409,33 @@ func Access(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_access_trampoline()
+
+//go:linkname libc_access libc_access
+//go:cgo_import_dynamic libc_access access "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-       _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+       _, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_adjtime_trampoline()
+
+//go:linkname libc_adjtime libc_adjtime
+//go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chdir(path string) (err error) {
@@ -314,13 +444,18 @@ func Chdir(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chdir_trampoline()
+
+//go:linkname libc_chdir libc_chdir
+//go:cgo_import_dynamic libc_chdir chdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chflags(path string, flags int) (err error) {
@@ -329,13 +464,18 @@ func Chflags(path string, flags int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chflags_trampoline()
+
+//go:linkname libc_chflags libc_chflags
+//go:cgo_import_dynamic libc_chflags chflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chmod(path string, mode uint32) (err error) {
@@ -344,13 +484,18 @@ func Chmod(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chmod_trampoline()
+
+//go:linkname libc_chmod libc_chmod
+//go:cgo_import_dynamic libc_chmod chmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chown(path string, uid int, gid int) (err error) {
@@ -359,13 +504,18 @@ func Chown(path string, uid int, gid int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chown_trampoline()
+
+//go:linkname libc_chown libc_chown
+//go:cgo_import_dynamic libc_chown chown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chroot(path string) (err error) {
@@ -374,27 +524,37 @@ func Chroot(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_chroot_trampoline()
+
+//go:linkname libc_chroot libc_chroot
+//go:cgo_import_dynamic libc_chroot chroot "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_close_trampoline()
+
+//go:linkname libc_close libc_close
+//go:cgo_import_dynamic libc_close close "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-       r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
+       r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
        nfd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -402,70 +562,105 @@ func Dup(fd int) (nfd int, err error) {
        return
 }
 
+func libc_dup_trampoline()
+
+//go:linkname libc_dup libc_dup
+//go:cgo_import_dynamic libc_dup dup "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-       _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
+       _, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_dup2_trampoline()
+
+//go:linkname libc_dup2 libc_dup2
+//go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchdir_trampoline()
+
+//go:linkname libc_fchdir libc_fchdir
+//go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchflags_trampoline()
+
+//go:linkname libc_fchflags libc_fchflags
+//go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-       _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchmod_trampoline()
+
+//go:linkname libc_fchmod libc_fchmod
+//go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-       _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fchown_trampoline()
+
+//go:linkname libc_fchown libc_fchown
+//go:cgo_import_dynamic libc_fchown fchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-       _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
+       _, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_flock_trampoline()
+
+//go:linkname libc_flock libc_flock
+//go:cgo_import_dynamic libc_flock flock "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-       r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
+       r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -473,74 +668,114 @@ func Fpathconf(fd int, name int) (val int, err error) {
        return
 }
 
+func libc_fpathconf_trampoline()
+
+//go:linkname libc_fpathconf libc_fpathconf
+//go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-       _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fstat_trampoline()
+
+//go:linkname libc_fstat libc_fstat
+//go:cgo_import_dynamic libc_fstat fstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-       _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fstatfs_trampoline()
+
+//go:linkname libc_fstatfs libc_fstatfs
+//go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-       _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_fsync_trampoline()
+
+//go:linkname libc_fsync libc_fsync
+//go:cgo_import_dynamic libc_fsync fsync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-       _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length))
+       _, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_ftruncate_trampoline()
+
+//go:linkname libc_ftruncate libc_ftruncate
+//go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-       r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
        egid = int(r0)
        return
 }
 
+func libc_getegid_trampoline()
+
+//go:linkname libc_getegid libc_getegid
+//go:cgo_import_dynamic libc_getegid getegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-       r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
        uid = int(r0)
        return
 }
 
+func libc_geteuid_trampoline()
+
+//go:linkname libc_geteuid libc_geteuid
+//go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-       r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
        gid = int(r0)
        return
 }
 
+func libc_getgid_trampoline()
+
+//go:linkname libc_getgid libc_getgid
+//go:cgo_import_dynamic libc_getgid getgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
        pgid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -548,34 +783,54 @@ func Getpgid(pid int) (pgid int, err error) {
        return
 }
 
+func libc_getpgid_trampoline()
+
+//go:linkname libc_getpgid libc_getpgid
+//go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-       r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
        pgrp = int(r0)
        return
 }
 
+func libc_getpgrp_trampoline()
+
+//go:linkname libc_getpgrp libc_getpgrp
+//go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-       r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
        pid = int(r0)
        return
 }
 
+func libc_getpid_trampoline()
+
+//go:linkname libc_getpid libc_getpid
+//go:cgo_import_dynamic libc_getpid getpid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-       r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
        ppid = int(r0)
        return
 }
 
+func libc_getppid_trampoline()
+
+//go:linkname libc_getppid libc_getppid
+//go:cgo_import_dynamic libc_getppid getppid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-       r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
+       r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
        prio = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -583,30 +838,45 @@ func Getpriority(which int, who int) (prio int, err error) {
        return
 }
 
+func libc_getpriority_trampoline()
+
+//go:linkname libc_getpriority libc_getpriority
+//go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getrlimit_trampoline()
+
+//go:linkname libc_getrlimit libc_getrlimit
+//go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_getrusage_trampoline()
+
+//go:linkname libc_getrusage libc_getrusage
+//go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
        sid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -614,46 +884,71 @@ func Getsid(pid int) (sid int, err error) {
        return
 }
 
+func libc_getsid_trampoline()
+
+//go:linkname libc_getsid libc_getsid
+//go:cgo_import_dynamic libc_getsid getsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-       _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_gettimeofday_trampoline()
+
+//go:linkname libc_gettimeofday libc_gettimeofday
+//go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-       r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
+       r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
        uid = int(r0)
        return
 }
 
+func libc_getuid_trampoline()
+
+//go:linkname libc_getuid libc_getuid
+//go:cgo_import_dynamic libc_getuid getuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-       r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0)
+       r0, _, _ := syscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
        tainted = bool(r0 != 0)
        return
 }
 
+func libc_issetugid_trampoline()
+
+//go:linkname libc_issetugid libc_issetugid
+//go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-       _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
+       _, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_kill_trampoline()
+
+//go:linkname libc_kill libc_kill
+//go:cgo_import_dynamic libc_kill kill "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-       r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
+       r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -661,6 +956,11 @@ func Kqueue() (fd int, err error) {
        return
 }
 
+func libc_kqueue_trampoline()
+
+//go:linkname libc_kqueue libc_kqueue
+//go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lchown(path string, uid int, gid int) (err error) {
@@ -669,13 +969,18 @@ func Lchown(path string, uid int, gid int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+       _, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lchown_trampoline()
+
+//go:linkname libc_lchown libc_lchown
+//go:cgo_import_dynamic libc_lchown lchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Link(path string, link string) (err error) {
@@ -689,23 +994,33 @@ func Link(path string, link string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_link_trampoline()
+
+//go:linkname libc_link libc_link
+//go:cgo_import_dynamic libc_link link "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-       _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
+       _, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_listen_trampoline()
+
+//go:linkname libc_listen libc_listen
+//go:cgo_import_dynamic libc_listen listen "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lstat(path string, stat *Stat_t) (err error) {
@@ -714,13 +1029,18 @@ func Lstat(path string, stat *Stat_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lstat_trampoline()
+
+//go:linkname libc_lstat libc_lstat
+//go:cgo_import_dynamic libc_lstat lstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkdir(path string, mode uint32) (err error) {
@@ -729,13 +1049,18 @@ func Mkdir(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mkdir_trampoline()
+
+//go:linkname libc_mkdir libc_mkdir
+//go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkfifo(path string, mode uint32) (err error) {
@@ -744,13 +1069,18 @@ func Mkfifo(path string, mode uint32) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+       _, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mkfifo_trampoline()
+
+//go:linkname libc_mkfifo libc_mkfifo
+//go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mknod(path string, mode uint32, dev int) (err error) {
@@ -759,23 +1089,33 @@ func Mknod(path string, mode uint32, dev int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+       _, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_mknod_trampoline()
+
+//go:linkname libc_mknod libc_mknod
+//go:cgo_import_dynamic libc_mknod mknod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-       _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+       _, _, e1 := syscall(funcPC(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_nanosleep_trampoline()
+
+//go:linkname libc_nanosleep libc_nanosleep
+//go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Open(path string, mode int, perm uint32) (fd int, err error) {
@@ -784,7 +1124,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
        if err != nil {
                return
        }
-       r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+       r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
        fd = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -792,6 +1132,11 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
        return
 }
 
+func libc_open_trampoline()
+
+//go:linkname libc_open libc_open
+//go:cgo_import_dynamic libc_open open "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pathconf(path string, name int) (val int, err error) {
@@ -800,7 +1145,7 @@ func Pathconf(path string, name int) (val int, err error) {
        if err != nil {
                return
        }
-       r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+       r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
        val = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -808,6 +1153,11 @@ func Pathconf(path string, name int) (val int, err error) {
        return
 }
 
+func libc_pathconf_trampoline()
+
+//go:linkname libc_pathconf libc_pathconf
+//go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
@@ -817,7 +1167,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
+       r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -825,6 +1175,11 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
        return
 }
 
+func libc_pread_trampoline()
+
+//go:linkname libc_pread libc_pread
+//go:cgo_import_dynamic libc_pread pread "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
@@ -834,7 +1189,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
+       r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -842,6 +1197,11 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
        return
 }
 
+func libc_pwrite_trampoline()
+
+//go:linkname libc_pwrite libc_pwrite
+//go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func read(fd int, p []byte) (n int, err error) {
@@ -851,7 +1211,7 @@ func read(fd int, p []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+       r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -859,6 +1219,11 @@ func read(fd int, p []byte) (n int, err error) {
        return
 }
 
+func libc_read_trampoline()
+
+//go:linkname libc_read libc_read
+//go:cgo_import_dynamic libc_read read "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Readlink(path string, buf []byte) (n int, err error) {
@@ -873,7 +1238,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
        } else {
                _p1 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+       r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -881,6 +1246,11 @@ func Readlink(path string, buf []byte) (n int, err error) {
        return
 }
 
+func libc_readlink_trampoline()
+
+//go:linkname libc_readlink libc_readlink
+//go:cgo_import_dynamic libc_readlink readlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rename(from string, to string) (err error) {
@@ -894,13 +1264,18 @@ func Rename(from string, to string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_rename_trampoline()
+
+//go:linkname libc_rename libc_rename
+//go:cgo_import_dynamic libc_rename rename "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Revoke(path string) (err error) {
@@ -909,13 +1284,18 @@ func Revoke(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_revoke_trampoline()
+
+//go:linkname libc_revoke libc_revoke
+//go:cgo_import_dynamic libc_revoke revoke "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rmdir(path string) (err error) {
@@ -924,64 +1304,78 @@ func Rmdir(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_rmdir_trampoline()
 
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-       r0, _, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(whence), 0, 0)
-       newoffset = int64(r0)
-       if e1 != 0 {
-               err = errnoErr(e1)
-       }
-       return
-}
+//go:linkname libc_rmdir libc_rmdir
+//go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-       _, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+       _, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_select_trampoline()
+
+//go:linkname libc_select libc_select
+//go:cgo_import_dynamic libc_select select "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setegid_trampoline()
+
+//go:linkname libc_setegid libc_setegid
+//go:cgo_import_dynamic libc_setegid setegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_seteuid_trampoline()
+
+//go:linkname libc_seteuid libc_seteuid
+//go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setgid_trampoline()
+
+//go:linkname libc_setgid libc_setgid
+//go:cgo_import_dynamic libc_setgid setgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setlogin(name string) (err error) {
@@ -990,67 +1384,97 @@ func Setlogin(name string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setlogin_trampoline()
+
+//go:linkname libc_setlogin libc_setlogin
+//go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setpgid_trampoline()
+
+//go:linkname libc_setpgid libc_setpgid
+//go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-       _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
+       _, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setpriority_trampoline()
+
+//go:linkname libc_setpriority libc_setpriority
+//go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setregid_trampoline()
+
+//go:linkname libc_setregid libc_setregid
+//go:cgo_import_dynamic libc_setregid setregid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setreuid_trampoline()
+
+//go:linkname libc_setreuid libc_setreuid
+//go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setrlimit_trampoline()
+
+//go:linkname libc_setrlimit libc_setrlimit
+//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-       r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
+       r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
        pid = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1058,26 +1482,41 @@ func Setsid() (pid int, err error) {
        return
 }
 
+func libc_setsid_trampoline()
+
+//go:linkname libc_setsid libc_setsid
+//go:cgo_import_dynamic libc_setsid setsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_settimeofday_trampoline()
+
+//go:linkname libc_settimeofday libc_settimeofday
+//go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-       _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
+       _, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_setuid_trampoline()
+
+//go:linkname libc_setuid libc_setuid
+//go:cgo_import_dynamic libc_setuid setuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Stat(path string, stat *Stat_t) (err error) {
@@ -1086,13 +1525,18 @@ func Stat(path string, stat *Stat_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_stat_trampoline()
+
+//go:linkname libc_stat libc_stat
+//go:cgo_import_dynamic libc_stat stat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Statfs(path string, stat *Statfs_t) (err error) {
@@ -1101,13 +1545,18 @@ func Statfs(path string, stat *Statfs_t) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+       _, _, e1 := syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_statfs_trampoline()
+
+//go:linkname libc_statfs libc_statfs
+//go:cgo_import_dynamic libc_statfs statfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Symlink(path string, link string) (err error) {
@@ -1121,23 +1570,33 @@ func Symlink(path string, link string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+       _, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_symlink_trampoline()
+
+//go:linkname libc_symlink libc_symlink
+//go:cgo_import_dynamic libc_symlink symlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-       _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
+       _, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_sync_trampoline()
+
+//go:linkname libc_sync libc_sync
+//go:cgo_import_dynamic libc_sync sync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Truncate(path string, length int64) (err error) {
@@ -1146,21 +1605,31 @@ func Truncate(path string, length int64) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length))
+       _, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_truncate_trampoline()
+
+//go:linkname libc_truncate libc_truncate
+//go:cgo_import_dynamic libc_truncate truncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-       r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
+       r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
        oldmask = int(r0)
        return
 }
 
+func libc_umask_trampoline()
+
+//go:linkname libc_umask libc_umask
+//go:cgo_import_dynamic libc_umask umask "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unlink(path string) (err error) {
@@ -1169,13 +1638,18 @@ func Unlink(path string) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
+       _, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_unlink_trampoline()
+
+//go:linkname libc_unlink libc_unlink
+//go:cgo_import_dynamic libc_unlink unlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unmount(path string, flags int) (err error) {
@@ -1184,13 +1658,18 @@ func Unmount(path string, flags int) (err error) {
        if err != nil {
                return
        }
-       _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+       _, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_unmount_trampoline()
+
+//go:linkname libc_unmount libc_unmount
+//go:cgo_import_dynamic libc_unmount unmount "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func write(fd int, p []byte) (n int, err error) {
@@ -1200,7 +1679,7 @@ func write(fd int, p []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+       r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1208,10 +1687,15 @@ func write(fd int, p []byte) (n int, err error) {
        return
 }
 
+func libc_write_trampoline()
+
+//go:linkname libc_write libc_write
+//go:cgo_import_dynamic libc_write write "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-       r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), 0, 0)
+       r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
        ret = uintptr(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1219,20 +1703,66 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
        return
 }
 
+func libc_mmap_trampoline()
+
+//go:linkname libc_mmap libc_mmap
+//go:cgo_import_dynamic libc_mmap mmap "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-       _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
+       _, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_munmap_trampoline()
+
+//go:linkname libc_munmap libc_munmap
+//go:cgo_import_dynamic libc_munmap munmap "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall6(funcPC(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_utimensat_trampoline()
+
+//go:linkname libc_utimensat libc_utimensat
+//go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
+       r0, _, e1 := syscall6X(funcPC(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+       ret = uintptr(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_syscall_trampoline()
+
+//go:linkname libc_syscall libc_syscall
+//go:cgo_import_dynamic libc_syscall syscall "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+       r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1243,7 +1773,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-       r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+       r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1253,19 +1783,20 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
-       var _p0 *byte
-       _p0, err = BytePtrFromString(path)
-       if err != nil {
-               return
-       }
-       _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+       r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+       newoffset = int64(r0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
 
+func libc_lseek_trampoline()
+
+//go:linkname libc_lseek libc_lseek
+//go:cgo_import_dynamic libc_lseek lseek "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getcwd(buf []byte) (n int, err error) {
@@ -1275,7 +1806,7 @@ func getcwd(buf []byte) (n int, err error) {
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
+       r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
        n = int(r0)
        if e1 != 0 {
                err = errnoErr(e1)
@@ -1283,6 +1814,11 @@ func getcwd(buf []byte) (n int, err error) {
        return
 }
 
+func libc_getcwd_trampoline()
+
+//go:linkname libc_getcwd libc_getcwd
+//go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
@@ -1292,9 +1828,184 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
        } else {
                _p0 = unsafe.Pointer(&_zero)
        }
-       _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+       _, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_sysctl_trampoline()
+
+//go:linkname libc_sysctl libc_sysctl
+//go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fork() (pid int, err error) {
+       r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+       pid = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_fork_trampoline()
+
+//go:linkname libc_fork libc_fork
+//go:cgo_import_dynamic libc_fork fork "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ioctl(fd int, req int, arg int) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_ioctl_trampoline()
+
+//go:linkname libc_ioctl libc_ioctl
+//go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func execve(path *byte, argv **byte, envp **byte) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
+
+func libc_execve_trampoline()
+
+//go:linkname libc_execve libc_execve
+//go:cgo_import_dynamic libc_execve execve "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func exit(res int) (err error) {
+       _, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_exit_trampoline()
+
+//go:linkname libc_exit libc_exit
+//go:cgo_import_dynamic libc_exit exit "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+       _, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_ptrace_trampoline()
+
+//go:linkname libc_ptrace libc_ptrace
+//go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getentropy(p []byte) (err error) {
+       var _p0 unsafe.Pointer
+       if len(p) > 0 {
+               _p0 = unsafe.Pointer(&p[0])
+       } else {
+               _p0 = unsafe.Pointer(&_zero)
+       }
+       _, _, e1 := rawSyscall(funcPC(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_getentropy_trampoline()
+
+//go:linkname libc_getentropy libc_getentropy
+//go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_fstatat_trampoline()
+
+//go:linkname libc_fstatat libc_fstatat
+//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+       r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+       val = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func unlinkat(fd int, path string, flags int) (err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       _, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_unlinkat_trampoline()
+
+//go:linkname libc_unlinkat libc_unlinkat
+//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func openat(fd int, path string, flags int, perm uint32) (fdret int, err error) {
+       var _p0 *byte
+       _p0, err = BytePtrFromString(path)
+       if err != nil {
+               return
+       }
+       r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+       fdret = int(r0)
+       if e1 != 0 {
+               err = errnoErr(e1)
+       }
+       return
+}
+
+func libc_openat_trampoline()
+
+//go:linkname libc_openat libc_openat
+//go:cgo_import_dynamic libc_openat openat "libc.so"

diff --git a/src/syscall/zsyscall_openbsd_arm64.s b/src/syscall/zsyscall_openbsd_arm64.s
new file mode 100644 (file)
index 0000000..f6e0a8d
--- /dev/null
+++ b/src/syscall/zsyscall_openbsd_arm64.s
@@ -0,0 +1,233 @@
+// go run mkasm.go openbsd arm64
+// Code generated by the command above; DO NOT EDIT.
+#include "textflag.h"
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getgroups(SB)
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setgroups(SB)
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_wait4(SB)
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_accept(SB)
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_bind(SB)
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_connect(SB)
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_socket(SB)
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsockopt(SB)
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setsockopt(SB)
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpeername(SB)
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsockname(SB)
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_shutdown(SB)
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_socketpair(SB)
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_recvfrom(SB)
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sendto(SB)
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_recvmsg(SB)
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sendmsg(SB)
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kevent(SB)
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_utimes(SB)
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_futimes(SB)
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fcntl(SB)
+TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pipe2(SB)
+TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_accept4(SB)
+TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getdents(SB)
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_access(SB)
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_adjtime(SB)
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chdir(SB)
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chflags(SB)
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chmod(SB)
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chown(SB)
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_chroot(SB)
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_close(SB)
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_dup(SB)
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_dup2(SB)
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchdir(SB)
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchflags(SB)
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchmod(SB)
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fchown(SB)
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_flock(SB)
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fpathconf(SB)
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstat(SB)
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstatfs(SB)
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fsync(SB)
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ftruncate(SB)
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getegid(SB)
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_geteuid(SB)
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getgid(SB)
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpgid(SB)
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpgrp(SB)
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpid(SB)
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getppid(SB)
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getpriority(SB)
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getrlimit(SB)
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getrusage(SB)
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getsid(SB)
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_gettimeofday(SB)
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getuid(SB)
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_issetugid(SB)
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kill(SB)
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_kqueue(SB)
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lchown(SB)
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_link(SB)
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_listen(SB)
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lstat(SB)
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mkdir(SB)
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mkfifo(SB)
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mknod(SB)
+TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_nanosleep(SB)
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_open(SB)
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pathconf(SB)
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pread(SB)
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_pwrite(SB)
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_read(SB)
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_readlink(SB)
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_rename(SB)
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_revoke(SB)
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_rmdir(SB)
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_select(SB)
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setegid(SB)
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_seteuid(SB)
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setgid(SB)
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setlogin(SB)
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setpgid(SB)
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setpriority(SB)
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setregid(SB)
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setreuid(SB)
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setrlimit(SB)
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setsid(SB)
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_settimeofday(SB)
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_setuid(SB)
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_stat(SB)
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_statfs(SB)
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_symlink(SB)
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sync(SB)
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_truncate(SB)
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_umask(SB)
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unlink(SB)
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unmount(SB)
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_write(SB)
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_mmap(SB)
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_munmap(SB)
+TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_utimensat(SB)
+TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_syscall(SB)
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_lseek(SB)
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getcwd(SB)
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_sysctl(SB)
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fork(SB)
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ioctl(SB)
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_execve(SB)
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_exit(SB)
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_ptrace(SB)
+TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_getentropy(SB)
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_fstatat(SB)
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_unlinkat(SB)
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+       JMP     libc_openat(SB)

diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index 86c4cac2ade20b5146ea25d38e94306b8544cb9d..2166be595bf018be3a8041eb3e2f19f394be6e70 100644 (file)
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -65,7 +65,6 @@ var (
        procRegOpenKeyExW                      = modadvapi32.NewProc("RegOpenKeyExW")
        procRegQueryInfoKeyW                   = modadvapi32.NewProc("RegQueryInfoKeyW")
        procRegQueryValueExW                   = modadvapi32.NewProc("RegQueryValueExW")
-       procSystemFunction036                  = modadvapi32.NewProc("SystemFunction036")
        procCertAddCertificateContextToStore   = modcrypt32.NewProc("CertAddCertificateContextToStore")
        procCertCloseStore                     = modcrypt32.NewProc("CertCloseStore")
        procCertCreateCertificateContext       = modcrypt32.NewProc("CertCreateCertificateContext")
@@ -333,14 +332,6 @@ func RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32
        return
 }
 
-func RtlGenRandom(buf *uint8, bytes uint32) (err error) {
-       r1, _, e1 := Syscall(procSystemFunction036.Addr(), 2, uintptr(unsafe.Pointer(buf)), uintptr(bytes), 0)
-       if r1 == 0 {
-               err = errnoErr(e1)
-       }
-       return
-}
-
 func CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) {
        r1, _, e1 := Syscall6(procCertAddCertificateContextToStore.Addr(), 4, uintptr(store), uintptr(unsafe.Pointer(certContext)), uintptr(addDisposition), uintptr(unsafe.Pointer(storeContext)), 0, 0)
        if r1 == 0 {

diff --git a/src/syscall/zsysnum_windows_386.go b/src/syscall/zsysnum_windows_386.go
deleted file mode 100644 (file)
index 36bf065..0000000
--- a/src/syscall/zsysnum_windows_386.go
+++ /dev/null
@@ -1,3 +0,0 @@
-// nothing to see here
-
-package syscall

diff --git a/src/syscall/zsysnum_windows_amd64.go b/src/syscall/zsysnum_windows_amd64.go
deleted file mode 100644 (file)
index 36bf065..0000000
--- a/src/syscall/zsysnum_windows_amd64.go
+++ /dev/null
@@ -1,3 +0,0 @@
-// nothing to see here
-
-package syscall

diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 2602bdf0cc283cd8db007fdc1d6f6514f3647766..8fc8acaaf3bf1bb88fda7138002f5678a8266178 100644 (file)
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -24,6 +24,7 @@ import (
 // It also checks that the file system contains at least the expected files.
 // As a special case, if no expected files are listed, fsys must be empty.
 // Otherwise, fsys must only contain at least the listed files: it can also contain others.
+// The contents of fsys must not change concurrently with TestFS.
 //
 // If TestFS finds any misbehaviors, it returns an error reporting all of them.
 // The error text spans multiple lines, one per detected misbehavior.
@@ -121,7 +122,7 @@ func (t *fsTester) openDir(dir string) fs.ReadDirFile {
        d, ok := f.(fs.ReadDirFile)
        if !ok {
                f.Close()
-               t.errorf("%s: Open returned File type %T, not a io.ReadDirFile", dir, f)
+               t.errorf("%s: Open returned File type %T, not a fs.ReadDirFile", dir, f)
                return nil
        }
        return d
@@ -402,9 +403,10 @@ func (t *fsTester) checkStat(path string, entry fs.DirEntry) {
                return
        }
        fentry := formatEntry(entry)
-       finfo := formatInfoEntry(info)
-       if fentry != finfo {
-               t.errorf("%s: mismatch:\n\tentry = %s\n\tfile.Stat() = %s", path, fentry, finfo)
+       fientry := formatInfoEntry(info)
+       // Note: mismatch here is OK for symlink, because Open dereferences symlink.
+       if fentry != fientry && entry.Type()&fs.ModeSymlink == 0 {
+               t.errorf("%s: mismatch:\n\tentry = %s\n\tfile.Stat() = %s", path, fentry, fientry)
        }
 
        einfo, err := entry.Info()
@@ -412,12 +414,22 @@ func (t *fsTester) checkStat(path string, entry fs.DirEntry) {
                t.errorf("%s: entry.Info: %v", path, err)
                return
        }
-       fentry = formatInfo(einfo)
-       finfo = formatInfo(info)
-       if fentry != finfo {
-               t.errorf("%s: mismatch:\n\tentry.Info() = %s\n\tfile.Stat() = %s\n", path, fentry, finfo)
+       finfo := formatInfo(info)
+       if entry.Type()&fs.ModeSymlink != 0 {
+               // For symlink, just check that entry.Info matches entry on common fields.
+               // Open deferences symlink, so info itself may differ.
+               feentry := formatInfoEntry(einfo)
+               if fentry != feentry {
+                       t.errorf("%s: mismatch\n\tentry = %s\n\tentry.Info() = %s\n", path, fentry, feentry)
+               }
+       } else {
+               feinfo := formatInfo(einfo)
+               if feinfo != finfo {
+                       t.errorf("%s: mismatch:\n\tentry.Info() = %s\n\tfile.Stat() = %s\n", path, feinfo, finfo)
+               }
        }
 
+       // Stat should be the same as Open+Stat, even for symlinks.
        info2, err := fs.Stat(t.fsys, path)
        if err != nil {
                t.errorf("%s: fs.Stat: %v", path, err)

diff --git a/src/testing/fstest/testfs_test.go b/src/testing/fstest/testfs_test.go
new file mode 100644 (file)
index 0000000..5b8813c
--- /dev/null
+++ b/src/testing/fstest/testfs_test.go
@@ -0,0 +1,31 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fstest
+
+import (
+       "internal/testenv"
+       "os"
+       "path/filepath"
+       "testing"
+)
+
+func TestSymlink(t *testing.T) {
+       testenv.MustHaveSymlink(t)
+
+       tmp := t.TempDir()
+       tmpfs := os.DirFS(tmp)
+
+       if err := os.WriteFile(filepath.Join(tmp, "hello"), []byte("hello, world\n"), 0644); err != nil {
+               t.Fatal(err)
+       }
+
+       if err := os.Symlink(filepath.Join(tmp, "hello"), filepath.Join(tmp, "hello.link")); err != nil {
+               t.Fatal(err)
+       }
+
+       if err := TestFS(tmpfs, "hello", "hello.link"); err != nil {
+               t.Fatal(err)
+       }
+}

diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index 7ac51750069ea1c209d0515a35bcde6da6dfa911..19154fc6405cc1096d5c0e8730172d7acd016cdb 100644 (file)
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -373,6 +373,10 @@ func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
                if val.IsNil() {
                        break
                }
+               if val.Type().ChanDir() == reflect.SendDir {
+                       s.errorf("range over send-only channel %v", val)
+                       break
+               }
                i := 0
                for ; ; i++ {
                        elem, ok := val.Recv()

diff --git a/src/text/template/exec_test.go b/src/text/template/exec_test.go
index 1611ee054fc1ed1beba0d168ac48938028d31a16..1a129ed5afdf71b7493d4fff03607858573fe2da 100644 (file)
--- a/src/text/template/exec_test.go
+++ b/src/text/template/exec_test.go
@@ -1697,3 +1697,16 @@ func TestIssue31810(t *testing.T) {
                t.Errorf("%s got %q, expected %q", textCall, b.String(), "result")
        }
 }
+
+// Issue 43065, range over send only channel
+func TestIssue43065(t *testing.T) {
+       var b bytes.Buffer
+       tmp := Must(New("").Parse(`{{range .}}{{end}}`))
+       ch := make(chan<- int)
+       err := tmp.Execute(&b, ch)
+       if err == nil {
+               t.Error("expected err got nil")
+       } else if !strings.Contains(err.Error(), "range over send-only channel") {
+               t.Errorf("%s", err)
+       }
+}

diff --git a/src/time/sleep.go b/src/time/sleep.go
index 90d8a18a6832b8bf308ae0b720460f7f16956fce..4f4579941469cd978ef39c0b01e0f281e3ed39f3 100644 (file)
--- a/src/time/sleep.go
+++ b/src/time/sleep.go
@@ -101,7 +101,9 @@ func NewTimer(d Duration) *Timer {
 // It returns true if the timer had been active, false if the timer had
 // expired or been stopped.
 //
-// Reset should be invoked only on stopped or expired timers with drained channels.
+// For a Timer created with NewTimer, Reset should be invoked only on
+// stopped or expired timers with drained channels.
+//
 // If a program has already received a value from t.C, the timer is known
 // to have expired and the channel drained, so t.Reset can be used directly.
 // If a program has not yet received a value from t.C, however,
@@ -120,6 +122,15 @@ func NewTimer(d Duration) *Timer {
 // is a race condition between draining the channel and the new timer expiring.
 // Reset should always be invoked on stopped or expired channels, as described above.
 // The return value exists to preserve compatibility with existing programs.
+//
+// For a Timer created with AfterFunc(d, f), Reset either reschedules
+// when f will run, in which case Reset returns true, or schedules f
+// to run again, in which case it returns false.
+// When Reset returns false, Reset neither waits for the prior f to
+// complete before returning nor does it guarantee that the subsequent
+// goroutine running f does not run concurrently with the prior
+// one. If the caller needs to know whether the prior execution of
+// f is completed, it must coordinate with f explicitly.
 func (t *Timer) Reset(d Duration) bool {
        if t.r.f == nil {
                panic("time: Reset called on uninitialized Timer")

diff --git a/src/time/tzdata/zipdata.go b/src/time/tzdata/zipdata.go
index 2128a537c48fcc395756b75e5e19abc57204e5ff..03b59720e27eb9b3add26ed883138bf3e200cb8b 100644 (file)
--- a/src/time/tzdata/zipdata.go
+++ b/src/time/tzdata/zipdata.go
@@ -16,1790 +16,1372 @@
 
 package tzdata
 
-const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Africa/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc1\n\x8a\x84\xad\x00\x00\x00\xad\x00\x00\x00\x0f\x00\x1c\x00Africa/Sao_TomeUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff^<\xfd" +
-       "0\xff\xff\xff\xff\x92掀\x00\x00\x00\x00ZI\x88\x10\x00\x00\x00\x00\\*\xbb\x90\x01\x02\x03\x02\x00\x00\x06P\x00\x00\xff\xff\xf7c\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x00\bLMT\x00GMT" +
-       "\x00WAT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x1c\x00Africa/ConakryUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff" +
-       "\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f" +
-       "\x00\x1c\x00Africa/DakarUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x1c\x00Africa/NdjamenaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x92\xe6\x80d\x00\x00\x00\x00\x12fqp\x00\x00\x00" +
-       "\x00\x13&\xde`\x01\x02\x01\x00\x00\x0e\x1c\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00WAT\x00WAST\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "d\x01\x05\x89\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x1c\x00Africa/CasablancaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
+const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Africa/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Africa/NairobiUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc" +
+       "\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00" +
+       "\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Af" +
+       "rica/FreetownUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\x9f\x1b\xeb\xdd2\x02\x00\x002\x02\x00\x00\f\x00\x1c\x00Africa/CeutaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
        "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x00\x00\x00\x05\x00\x00\x00\f\xff\xff\xff\xff\x96Q\xf9\x9c\xff\xff\xff\xff\xc6\xff\x14\x80\xff\xff\xff\xff\xc7X\xacp" +
-       "\xff\xff\xff\xff\xc7\xd9\xed\x80\xff\xff\xff\xffҡ2\xf0\xff\xff\xff\xff\xdb5\xa4\x00\xff\xff\xff\xff\xdb\xee'\xf0\xff\xff\xff\xff\xfb%r@\xff\xff\xff\xff\xfb\xc2\xefp\x00\x00\x00\x00\bk\x84\x80\x00\x00\x00\x00" +
-       "\b\xc6m\xf0\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0e\x8e\xf2p\x00\x00\x00\x00\x0f\xd3Q\x80\x00\x00\x00\x00\x10'\xa3p\x00\x00\x00\x00\x1a\xb7\xa6\x00" +
-       "\x00\x00\x00\x00\x1e\x18o\xf0\x00\x00\x00\x00HA\xe6\x80\x00\x00\x00\x00H\xbb\"p\x00\x00\x00\x00J#\x1a\x00\x00\x00\x00\x00J\x8d\xd5p\x00\x00\x00\x00K\xdc\xc0\x80\x00\x00\x00\x00L]\xe5p\x00\x00\x00\x00" +
-       "M\x97\xb8\x80\x00\x00\x00\x00N4\x8c\xf0\x00\x00\x00\x00O\x9c\xa0\xa0\x00\x00\x00\x00P\b\xbb\xa0\x00\x00\x00\x00P1\x9a \x00\x00\x00\x00Pg\xa7\xa0\x00\x00\x00\x00Q|\x82\xa0\x00\x00\x00\x00Q\xd8ˠ" +
-       "\x00\x00\x00\x00R\x05\x9e\xa0\x00\x00\x00\x00Rls\xa0\x00\x00\x00\x00S7z\xa0\x00\x00\x00\x00S\xae!\xa0\x00\x00\x00\x00S\xdcF \x00\x00\x00\x00TLU\xa0\x00\x00\x00\x00U\x17\\\xa0\x00\x00\x00\x00" +
-       "U|\xe0 \x00\x00\x00\x00U\xab\x04\xa0\x00\x00\x00\x00V,7\xa0\x00\x00\x00\x00V\xf7>\xa0\x00\x00\x00\x00WS\x87\xa0\x00\x00\x00\x00W\x81\xac \x00\x00\x00\x00X\x15T \x00\x00\x00\x00X\xd7 \xa0" +
-       "\x00\x00\x00\x00Y \xf4\xa0\x00\x00\x00\x00YXS\xa0\x00\x00\x00\x00Y\xf56 \x00\x00\x00\x00Z\xb7\x02\xa0\x00\x00\x00\x00Z\xf7\x9c \x00\x00\x00\x00[%\xc0\xa0\x00\x00\x00\x00[\xd5\x18 \x00\x00\x00\x00" +
-       "\\\xceC\xa0\x00\x00\x00\x00\\\xfch \x00\x00\x00\x00^\x9b\xb0\xa0\x00\x00\x00\x00^\xd3\x0f\xa0\x00\x00\x00\x00`rX \x00\x00\x00\x00`\xa0|\xa0\x00\x00\x00\x00b?\xc5 \x00\x00\x00\x00bw$ " +
-       "\x00\x00\x00\x00d\x16l\xa0\x00\x00\x00\x00dMˠ\x00\x00\x00\x00e\xed\x14 \x00\x00\x00\x00f\x1b8\xa0\x00\x00\x00\x00g\xba\x81 \x00\x00\x00\x00g\xf1\xe0 \x00\x00\x00\x00i\x91(\xa0\x00\x00\x00\x00" +
-       "i\xbfM \x00\x00\x00\x00kg\xd0 \x00\x00\x00\x00k\x95\xf4\xa0\x00\x00\x00\x00m5= \x00\x00\x00\x00ml\x9c \x00\x00\x00\x00o\v\xe4\xa0\x00\x00\x00\x00o:\t \x00\x00\x00\x00p\xd9Q\xa0" +
-       "\x00\x00\x00\x00q\x10\xb0\xa0\x00\x00\x00\x00r\xaf\xf9 \x00\x00\x00\x00r\xe7X \x00\x00\x00\x00t\x86\xa0\xa0\x00\x00\x00\x00t\xb4\xc5 \x00\x00\x00\x00vT\r\xa0\x00\x00\x00\x00v\x8bl\xa0\x00\x00\x00\x00" +
-       "x*\xb5 \x00\x00\x00\x00xX٠\x00\x00\x00\x00y\xf8\" \x00\x00\x00\x00z/\x81 \x00\x00\x00\x00{\xceɠ\x00\x00\x00\x00|\x06(\xa0\x00\x00\x00\x00}\xa5q \x00\x00\x00\x00}ӕ\xa0" +
-       "\x00\x00\x00\x00\u007fr\xde \x00\x00\x00\x00\u007f\xaa= \x00\x00\x00\x00\x81I\x85\xa0\x00\x00\x00\x00\x81\x80\xe4\xa0\x00\x00\x00\x00\x83 - \x00\x00\x00\x00\x83NQ\xa0\x00\x00\x00\x00\x84\xed\x9a \x00\x00\x00\x00" +
-       "\x85$\xf9 \x00\x00\x00\x00\x86\xc4A\xa0\x00\x00\x00\x00\x86\xf2f \x00\x00\x00\x00\x88\x91\xae\xa0\x00\x00\x00\x00\x88\xc9\r\xa0\x00\x00\x00\x00\x8ahV \x00\x00\x00\x00\x8a\x9f\xb5 \x00\x00\x00\x00\x8c>\xfd\xa0" +
-       "\x00\x00\x00\x00\x8cm\" \x00\x00\x00\x00\x8e\fj\xa0\x00\x00\x00\x00\x8eCɠ\x00\x00\x00\x00\x8f\xe3\x12 \x00\x00\x00\x00\x90\x1aq \x00\x00\x00\x00\x91\xb9\xb9\xa0\x00\x00\x00\x00\x91\xe7\xde \x00\x00\x00\x00" +
-       "\x93\x87&\xa0\x00\x00\x00\x00\x93\xbe\x85\xa0\x00\x00\x00\x00\x95]\xce \x00\x00\x00\x00\x95\x8b\xf2\xa0\x00\x00\x00\x00\x97+; \x00\x00\x00\x00\x97b\x9a \x00\x00\x00\x00\x99\x01\xe2\xa0\x00\x00\x00\x00\x999A\xa0" +
-       "\x00\x00\x00\x00\x9a؊ \x00\x00\x00\x00\x9b\x06\xae\xa0\x00\x00\x00\x00\x9c\xa5\xf7 \x00\x00\x00\x00\x9c\xddV \x00\x00\x00\x00\x9e|\x9e\xa0\x00\x00\x00\x00\x9e\xb3\xfd\xa0\x00\x00\x00\x00\xa0SF \x00\x00\x00\x00" +
-       "\xa0\x81j\xa0\x00\x00\x00\x00\xa2 \xb3 \x00\x00\x00\x00\xa2X\x12 \x00\x00\x00\x00\xa3\xf7Z\xa0\x00\x00\x00\x00\xa4%\u007f \x00\x00\x00\x00\xa5\xc4Ǡ\x00\x00\x00\x00\xa5\xfc&\xa0\x00\x00\x00\x00\xa7\x9bo " +
-       "\x00\x00\x00\x00\xa7\xd2\xce \x00\x00\x00\x00\xa9r\x16\xa0\x00\x00\x00\x00\xa9\xa0; \x00\x00\x00\x00\xab?\x83\xa0\x00\x00\x00\x00\xabv\xe2\xa0\x00\x00\x00\x00\xad\x16+ \x00\x00\x00\x00\xadM\x8a \x00\x00\x00\x00" +
-       "\xae\xecҠ\x00\x00\x00\x00\xaf\x1a\xf7 \x00\x00\x00\x00\xb0\xba?\xa0\x00\x00\x00\x00\xb0\xf1\x9e\xa0\x00\x00\x00\x00\xb2\x90\xe7 \x00\x00\x00\x00\xb2\xbf\v\xa0\x00\x00\x00\x00\xb4^T \x00\x00\x00\x00\xb4\x95\xb3 " +
-       "\x00\x00\x00\x00\xb64\xfb\xa0\x00\x00\x00\x00\xb6lZ\xa0\x00\x00\x00\x00\xb8\v\xa3 \x00\x00\x00\x00\xb89Ǡ\x00\x00\x00\x00\xb9\xd9\x10 \x00\x00\x00\x00\xba\x10o \x00\x00\x00\x00\xbb\xaf\xb7\xa0\x00\x00\x00\x00" +
-       "\xbb\xe7\x16\xa0\x00\x00\x00\x00\xbd\x86_ \x00\x00\x00\x00\xbd\xb4\x83\xa0\x00\x00\x00\x00\xbfS\xcc \x00\x00\x00\x00\xbf\x8b+ \x00\x00\x00\x00\xc1*s\xa0\x00\x00\x00\x00\xc1X\x98 \x00\x00\x00\x00\xc2\xf7\xe0\xa0" +
-       "\x00\x00\x00\x00\xc3/?\xa0\x00\x00\x00\x00\xc4Έ \x00\x00\x00\x00\xc5\x05\xe7 \x00\x00\x00\x00ƥ/\xa0\x00\x00\x00\x00\xc6\xd3T \x00\x00\x00\x00\xc8r\x9c\xa0\x00\x00\x00\x00ȩ\xfb\xa0\x00\x00\x00\x00" +
-       "\xcaID \x00\x00\x00\x00ʀ\xa3 \x00\x00\x00\x00\xcc\x1f\xeb\xa0\x00\x00\x00\x00\xccN\x10 \x00\x00\x00\x00\xcd\xedX\xa0\x00\x00\x00\x00\xce$\xb7\xa0\x00\x00\x00\x00\xcf\xc4\x00 \x00\x00\x00\x00\xcf\xf2$\xa0" +
-       "\x00\x00\x00\x00ёm \x00\x00\x00\x00\xd1\xc8\xcc \x00\x00\x00\x00\xd3h\x14\xa0\x00\x00\x00\x00ӟs\xa0\x00\x00\x00\x00\xd5>\xbc \x00\x00\x00\x00\xd5l\xe0\xa0\x00\x00\x00\x00\xd7\f) \x00\x00\x00\x00" +
-       "\xd7C\x88 \x00\x00\x00\x00\xd8\xe2Р\x00\x00\x00\x00\xd9\x1a/\xa0\x00\x00\x00\x00ڹx \x00\x00\x00\x00\xda眠\x00\x00\x00\x00܆\xe5 \x00\x00\x00\x00ܾD \x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\xff\xff\xf8\xe4\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x00\x04\x00\x00\x00\x00\x01\bLMT\x00+01\x00+00\x00\n<+01>-1\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\v\x00\x1c\x00Africa/LomeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00" +
-       "\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x1c\x00Africa/Algi" +
-       "ersUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00" +
-       "\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffkɛ$\xff\xff\xff\xff\x91`PO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89" +
-       "\xfep\xff\xff\xff\xff\x9f\xa0*\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa4\xb8\x06p\xff\xff" +
-       "\xff\xff\xc6\xff\x06p\xff\xff\xff\xff\xc7X\xba\x80\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЊ\x00\x00\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N$p\xff\xff\xff\xff\xd4K" +
-       "\ap\xff\xff\xff\xff\xe5\xce\xd3\x00\xff\xff\xff\xff\xf3\\\xb0\xf0\x00\x00\x00\x00\x02x\xc1\xf0\x00\x00\x00\x00\x03C\xc8\xf0\x00\x00\x00\x00\r\xcf\xd7\x00\x00\x00\x00\x00\x0e\xadD\xf0\x00\x00\x00\x00\x0fxZ\x00\x00\x00" +
-       "\x00\x00\x10hY\x10\x00\x00\x00\x00\x12vCp\x00\x00\x00\x00\x13fB\x80\x00\x00\x00\x00\x14_|\x10\x00\x00\x00\x00\x15O_\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x03" +
-       "\x05\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x05\x00\x00\x02\xdc\x00\x00\x00\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\r\x00\x00\x1c \x01\x11\x00\x00\x0e\x10\x00\x16LMT\x00PMT\x00WEST" +
-       "\x00WET\x00CEST\x00CET\x00\nCET-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x10\x00\x1c\x00Africa/Mo" +
-       "gadishuUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00" +
-       "#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83" +
-       "\x00\x00\x00\f\x00\x1c\x00Africa/LagosUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x12\x00\x1c\x00Africa/BrazzavilleUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00" +
-       "\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Afric" +
-       "a/TimbuktuUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x1c\x00Africa/NouakchottUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04L" +
-       "MT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Africa/MaseruUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff" +
-       "\xff\xff\xffm{A@\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff̮\x8c\x80\xff\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00" +
-       "\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00\x00\x1c \x00\x04LMT\x00SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00" +
-       "\x11\x00\x1c\x00Africa/LibrevilleUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/HarareUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00" +
-       "\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/M" +
-       "alaboUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11" +
-       "=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/BanguiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\n" +
-       "WAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0e\x00\x1c\x00Africa/NairobiUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda" +
-       "\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT" +
-       "\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x1c\x00Africa/Kin" +
-       "shasaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11" +
-       "=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x1c\x00Africa/Porto-NovoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff~6\xb5\x00\xff\xff\xff\xff\x9e\xd6up\xff\xff\xff\xff\x9f\xa1n`" +
+       "\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff\xff\xff" +
+       "\xb2p0\x80\xff\xff\xff\xff\xfb%r@\xff\xff\xff\xff\xfb\xc2\xefp\x00\x00\x00\x00\bk\x84\x80\x00\x00\x00\x00\b\xc6m\xf0\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80" +
+       "\x00\x00\x00\x00\x0e\x8e\xf2p\x00\x00\x00\x00\x0f\xd3Q\x80\x00\x00\x00\x00\x10'\xa3p\x00\x00\x00\x00\x1a\xb7\xa6\x00\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00" +
+       "!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90" +
+       "\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00" +
+       "/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\xff\xff\xfb\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x1c \x01\x11LMT\x00WET\x00WEST\x00CET\x00CEST\x00\nCET-" +
+       "1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x1c\x00Africa/" +
+       "AsmeraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00" +
+       "\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7" +
+       "\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/LuandaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1" +
+       "Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\x14\xcf\x10n\xca\x01\x00\x00\xca\x01\x00\x00\v\x00\x1c\x00Africa/JubaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xb6\xa3\xda\xdc\x00\x00\x00\x00\x00\x9e\x17\xe0\x00\x00\x00\x00" +
+       "\x01z4P\x00\x00\x00\x00\x02}\xf9\xe0\x00\x00\x00\x00\x03[g\xd0\x00\x00\x00\x00\x04`~\xe0\x00\x00\x00\x00\x05=\xec\xd0\x00\x00\x00\x00\x06@`\xe0\x00\x00\x00\x00\a\x1f P\x00\x00\x00\x00\b B\xe0" +
+       "\x00\x00\x00\x00\t\x00S\xd0\x00\x00\x00\x00\n\x00$\xe0\x00\x00\x00\x00\n\xe1\x87P\x00\x00\x00\x00\v\xe0\x06\xe0\x00\x00\x00\x00\f\xc4\fP\x00\x00\x00\x00\r\xbf\xe8\xe0\x00\x00\x00\x00\x0e\xa5?\xd0\x00\x00\x00\x00" +
+       "\x0f\xa9\x05`\x00\x00\x00\x00\x10\x86sP\x00\x00\x00\x00\x11\x88\xe7`\x00\x00\x00\x00\x12g\xa6\xd0\x00\x00\x00\x00\x13h\xc9`\x00\x00\x00\x00\x14J+\xd0\x00\x00\x00\x00\x15H\xab`\x00\x00\x00\x00\x16+_P" +
+       "\x00\x00\x00\x00\x17(\x8d`\x00\x00\x00\x00\x18\f\x92\xd0\x00\x00\x00\x00\x19\bo`\x00\x00\x00\x00\x19\xed\xc6P\x00\x00\x00\x00\x1a\xf1\x8b\xe0\x00\x00\x00\x00\x1b\xd0KP\x00\x00\x00\x00\x1c\xd1m\xe0\x00\x00\x00\x00" +
+       "\x1d\xb1~\xd0\x00\x00\x00\x008\x80E \x00\x00\x00\x00`\x17\x1aP\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x00\x00\x1d\xa4\x00" +
+       "\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00CAST\x00CAT\x00EAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcc\fT" +
+       "ξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x1c\x00Africa/JohannesburgUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff\xff\xff\xffm{A@\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff̮\x8c\x80\xff" +
+       "\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00\x00\x1c \x00\x04LMT\x00SAS" +
+       "T\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x1c\x00Africa/BujumburaUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff" +
+       "\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x12tnj\xfc\x04\x00\x00\xfc\x04\x00" +
+       "\x00\f\x00\x1c\x00Africa/CairoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u007f\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff}\xbdM\xab\xff\xff\xff\xffȓ\xb4\xe0\xff\xff\xff\xff\xc8\xfa{\xd0\xff\xff\xff\xff\xc9\xfc\xef\xe0\xff\xff\xff\xff\xca\xc7\xe8\xd0" +
+       "\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xcc\xdf)\xd0\xff\xff\xff\xffͬ\xe1\xe0\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xff" +
+       "Ҋ\xadP\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0" +
+       "\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff" +
+       "\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb\xc2\xfd\x80" +
+       "\xff\xff\xff\xff\xfc۾\xf0\xff\xff\xff\xff\xfd\xa5\x82\x80\xff\xff\xff\xff\xfe\xbc\xf2p\xff\xff\xff\xff\xff\x86\xb6\x00\x00\x00\x00\x00\x00\x9e%\xf0\x00\x00\x00\x00\x01g\xe9\x80\x00\x00\x00\x00\x02\u007fYp\x00\x00\x00\x00" +
+       "\x03I\x1d\x00\x00\x00\x00\x00\x04a\xdep\x00\x00\x00\x00\x05+\xa2\x00\x00\x00\x00\x00\x06C\x11\xf0\x00\x00\x00\x00\a\fՀ\x00\x00\x00\x00\b$Ep\x00\x00\x00\x00\b\xee\t\x00\x00\x00\x00\x00\n\x05x\xf0" +
+       "\x00\x00\x00\x00\n\xcf<\x80\x00\x00\x00\x00\v\xe7\xfd\xf0\x00\x00\x00\x00\f\xb1\xc1\x80\x00\x00\x00\x00\r\xc91p\x00\x00\x00\x00\x0e\x92\xf5\x00\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00" +
+       "\x11\x8b\x98p\x00\x00\x00\x00\x12U\\\x00\x00\x00\x00\x00\x13n\x1dp\x00\x00\x00\x00\x147\xe1\x00\x00\x00\x00\x00\x15OP\xf0\x00\x00\x00\x00\x16\x19\x14\x80\x00\x00\x00\x00\x17\xa0\x93\xf0\x00\x00\x00\x00\x17\xfaH\x00" +
+       "\x00\x00\x00\x00\x19p\xa3\xf0\x00\x00\x00\x00\x19\xdb{\x80\x00\x00\x00\x00\x1a\xf4<\xf0\x00\x00\x00\x00\x1b\xbe\x00\x80\x00\x00\x00\x00\x1c\xd5pp\x00\x00\x00\x00\x1d\x9f4\x00\x00\x00\x00\x00\x1e\xb6\xa3\xf0\x00\x00\x00\x00" +
+       "\x1f\x80g\x80\x00\x00\x00\x00 \x97\xd7p\x00\x00\x00\x00!a\x9b\x00\x00\x00\x00\x00\"z\\p\x00\x00\x00\x00#D \x00\x00\x00\x00\x00$b'p\x00\x00\x00\x00%%S\x80\x00\x00\x00\x00&<\xc3p" +
+       "\x00\x00\x00\x00'\x06\x87\x00\x00\x00\x00\x00(\x1d\xf6\xf0\x00\x00\x00\x00(纀\x00\x00\x00\x00*\x00{\xf0\x00\x00\x00\x00*\xca?\x80\x00\x00\x00\x00+\xe1\xafp\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00" +
+       "-\xc2\xe2\xf0\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/\xa0\x13\xe0\x00\x00\x00\x000k\f\xd0\x00\x00\x00\x001\u007f\xf5\xe0\x00\x00\x00\x002J\xee\xd0\x00\x00\x00\x003_\xd7\xe0\x00\x00\x00\x004*\xd0\xd0" +
+       "\x00\x00\x00\x005?\xb9\xe0\x00\x00\x00\x006\n\xb2\xd0\x00\x00\x00\x007(\xd6`\x00\x00\x00\x007\xf3\xcfP\x00\x00\x00\x009\b\xb8`\x00\x00\x00\x009ӱP\x00\x00\x00\x00:\xe8\x9a`\x00\x00\x00\x00" +
+       ";\xb3\x93P\x00\x00\x00\x00<\xc8|`\x00\x00\x00\x00=\x93uP\x00\x00\x00\x00>\xa8^`\x00\x00\x00\x00?sWP\x00\x00\x00\x00@\x91z\xe0\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00Bq\\\xe0" +
+       "\x00\x00\x00\x00C<U\xd0\x00\x00\x00\x00DQ>\xe0\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F1 \xe0\x00\x00\x00\x00F\xe0jP\x00\x00\x00\x00H\x11\x02\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00" +
+       "I\xf0\xe4\xe0\x00\x00\x00\x00J\x8d\xb9P\x00\x00\x00\x00K\xda\x01`\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00L\x89X\xe0\x00\x00\x00\x00L\xa4\xfaP\x00\x00\x00\x00Su8\xe0\x00\x00\x00\x00S\xac\x89\xd0" +
+       "\x00\x00\x00\x00Sڼ`\x00\x00\x00\x00T$\x82P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x1dU\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RV\xadD\xef\xca\x01\x00\x00\xca\x01\x00\x00\x0f\x00\x1c\x00Africa/KhartoumUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xb6\xa3\xda\x00\x00\x00\x00" +
+       "\x00\x00\x9e\x17\xe0\x00\x00\x00\x00\x01z4P\x00\x00\x00\x00\x02}\xf9\xe0\x00\x00\x00\x00\x03[g\xd0\x00\x00\x00\x00\x04`~\xe0\x00\x00\x00\x00\x05=\xec\xd0\x00\x00\x00\x00\x06@`\xe0\x00\x00\x00\x00\a\x1f " +
+       "P\x00\x00\x00\x00\b B\xe0\x00\x00\x00\x00\t\x00S\xd0\x00\x00\x00\x00\n\x00$\xe0\x00\x00\x00\x00\n\xe1\x87P\x00\x00\x00\x00\v\xe0\x06\xe0\x00\x00\x00\x00\f\xc4\fP\x00\x00\x00\x00\r\xbf\xe8\xe0\x00\x00\x00" +
+       "\x00\x0e\xa5?\xd0\x00\x00\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10\x86sP\x00\x00\x00\x00\x11\x88\xe7`\x00\x00\x00\x00\x12g\xa6\xd0\x00\x00\x00\x00\x13h\xc9`\x00\x00\x00\x00\x14J+\xd0\x00\x00\x00\x00\x15H\xab" +
+       "`\x00\x00\x00\x00\x16+_P\x00\x00\x00\x00\x17(\x8d`\x00\x00\x00\x00\x18\f\x92\xd0\x00\x00\x00\x00\x19\bo`\x00\x00\x00\x00\x19\xed\xc6P\x00\x00\x00\x00\x1a\xf1\x8b\xe0\x00\x00\x00\x00\x1b\xd0KP\x00\x00\x00" +
+       "\x00\x1c\xd1m\xe0\x00\x00\x00\x00\x1d\xb1~\xd0\x00\x00\x00\x008\x80E \x00\x00\x00\x00Y\xf8\xe4P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x03\x02\x00\x00\x1e\x80\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00CAST\x00CAT\x00EAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x1c\x00Africa/MbabaneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff\xff\xff\xffm{A@\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff\xcc" +
+       "\xae\x8c\x80\xff\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00\x00\x1c \x00\x04LMT" +
+       "\x00SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R)\xae\x8eo&\a\x00\x00&\a\x00\x00\x0f\x00\x1c\x00Africa/El_AaiunU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x06\x00\x00" +
+       "\x00\x10\xff\xff\xff\xff\xbcH\xf0\xe0\x00\x00\x00\x00\vѰ\x90\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0e\x8e\xf2p\x00\x00\x00\x00\x0f\xd3Q\x80\x00\x00" +
+       "\x00\x00\x10'\xa3p\x00\x00\x00\x00HA\xe6\x80\x00\x00\x00\x00H\xbb\"p\x00\x00\x00\x00J#\x1a\x00\x00\x00\x00\x00J\x8d\xd5p\x00\x00\x00\x00K\xdc\xc0\x80\x00\x00\x00\x00L]\xe5p\x00\x00\x00\x00M\x97" +
+       "\xb8\x80\x00\x00\x00\x00N4\x8c\xf0\x00\x00\x00\x00O\x9c\xa0\xa0\x00\x00\x00\x00P\b\xbb\xa0\x00\x00\x00\x00P1\x9a \x00\x00\x00\x00Pg\xa7\xa0\x00\x00\x00\x00Q|\x82\xa0\x00\x00\x00\x00Q\xd8ˠ\x00\x00" +
+       "\x00\x00R\x05\x9e\xa0\x00\x00\x00\x00Rls\xa0\x00\x00\x00\x00S7z\xa0\x00\x00\x00\x00S\xae!\xa0\x00\x00\x00\x00S\xdcF \x00\x00\x00\x00TLU\xa0\x00\x00\x00\x00U\x17\\\xa0\x00\x00\x00\x00U|" +
+       "\xe0 \x00\x00\x00\x00U\xab\x04\xa0\x00\x00\x00\x00V,7\xa0\x00\x00\x00\x00V\xf7>\xa0\x00\x00\x00\x00WS\x87\xa0\x00\x00\x00\x00W\x81\xac \x00\x00\x00\x00X\x15T \x00\x00\x00\x00X\xd7 \xa0\x00\x00" +
+       "\x00\x00Y \xf4\xa0\x00\x00\x00\x00YXS\xa0\x00\x00\x00\x00Y\xf56 \x00\x00\x00\x00Z\xb7\x02\xa0\x00\x00\x00\x00Z\xf7\x9c \x00\x00\x00\x00[%\xc0\xa0\x00\x00\x00\x00[\xd5\x18 \x00\x00\x00\x00\\\xce" +
+       "C\xa0\x00\x00\x00\x00\\\xfch \x00\x00\x00\x00^\x9b\xb0\xa0\x00\x00\x00\x00^\xd3\x0f\xa0\x00\x00\x00\x00`rX \x00\x00\x00\x00`\xa0|\xa0\x00\x00\x00\x00b?\xc5 \x00\x00\x00\x00bw$ \x00\x00" +
+       "\x00\x00d\x16l\xa0\x00\x00\x00\x00dMˠ\x00\x00\x00\x00e\xed\x14 \x00\x00\x00\x00f\x1b8\xa0\x00\x00\x00\x00g\xba\x81 \x00\x00\x00\x00g\xf1\xe0 \x00\x00\x00\x00i\x91(\xa0\x00\x00\x00\x00i\xbf" +
+       "M \x00\x00\x00\x00kg\xd0 \x00\x00\x00\x00k\x95\xf4\xa0\x00\x00\x00\x00m5= \x00\x00\x00\x00ml\x9c \x00\x00\x00\x00o\v\xe4\xa0\x00\x00\x00\x00o:\t \x00\x00\x00\x00p\xd9Q\xa0\x00\x00" +
+       "\x00\x00q\x10\xb0\xa0\x00\x00\x00\x00r\xaf\xf9 \x00\x00\x00\x00r\xe7X \x00\x00\x00\x00t\x86\xa0\xa0\x00\x00\x00\x00t\xb4\xc5 \x00\x00\x00\x00vT\r\xa0\x00\x00\x00\x00v\x8bl\xa0\x00\x00\x00\x00x*" +
+       "\xb5 \x00\x00\x00\x00xX٠\x00\x00\x00\x00y\xf8\" \x00\x00\x00\x00z/\x81 \x00\x00\x00\x00{\xceɠ\x00\x00\x00\x00|\x06(\xa0\x00\x00\x00\x00}\xa5q \x00\x00\x00\x00}ӕ\xa0\x00\x00" +
+       "\x00\x00\u007fr\xde \x00\x00\x00\x00\u007f\xaa= \x00\x00\x00\x00\x81I\x85\xa0\x00\x00\x00\x00\x81\x80\xe4\xa0\x00\x00\x00\x00\x83 - \x00\x00\x00\x00\x83NQ\xa0\x00\x00\x00\x00\x84\xed\x9a \x00\x00\x00\x00\x85$" +
+       "\xf9 \x00\x00\x00\x00\x86\xc4A\xa0\x00\x00\x00\x00\x86\xf2f \x00\x00\x00\x00\x88\x91\xae\xa0\x00\x00\x00\x00\x88\xc9\r\xa0\x00\x00\x00\x00\x8ahV \x00\x00\x00\x00\x8a\x9f\xb5 \x00\x00\x00\x00\x8c>\xfd\xa0\x00\x00" +
+       "\x00\x00\x8cm\" \x00\x00\x00\x00\x8e\fj\xa0\x00\x00\x00\x00\x8eCɠ\x00\x00\x00\x00\x8f\xe3\x12 \x00\x00\x00\x00\x90\x1aq \x00\x00\x00\x00\x91\xb9\xb9\xa0\x00\x00\x00\x00\x91\xe7\xde \x00\x00\x00\x00\x93\x87" +
+       "&\xa0\x00\x00\x00\x00\x93\xbe\x85\xa0\x00\x00\x00\x00\x95]\xce \x00\x00\x00\x00\x95\x8b\xf2\xa0\x00\x00\x00\x00\x97+; \x00\x00\x00\x00\x97b\x9a \x00\x00\x00\x00\x99\x01\xe2\xa0\x00\x00\x00\x00\x999A\xa0\x00\x00" +
+       "\x00\x00\x9a؊ \x00\x00\x00\x00\x9b\x06\xae\xa0\x00\x00\x00\x00\x9c\xa5\xf7 \x00\x00\x00\x00\x9c\xddV \x00\x00\x00\x00\x9e|\x9e\xa0\x00\x00\x00\x00\x9e\xb3\xfd\xa0\x00\x00\x00\x00\xa0SF \x00\x00\x00\x00\xa0\x81" +
+       "j\xa0\x00\x00\x00\x00\xa2 \xb3 \x00\x00\x00\x00\xa2X\x12 \x00\x00\x00\x00\xa3\xf7Z\xa0\x00\x00\x00\x00\xa4%\u007f \x00\x00\x00\x00\xa5\xc4Ǡ\x00\x00\x00\x00\xa5\xfc&\xa0\x00\x00\x00\x00\xa7\x9bo \x00\x00" +
+       "\x00\x00\xa7\xd2\xce \x00\x00\x00\x00\xa9r\x16\xa0\x00\x00\x00\x00\xa9\xa0; \x00\x00\x00\x00\xab?\x83\xa0\x00\x00\x00\x00\xabv\xe2\xa0\x00\x00\x00\x00\xad\x16+ \x00\x00\x00\x00\xadM\x8a \x00\x00\x00\x00\xae\xec" +
+       "Ҡ\x00\x00\x00\x00\xaf\x1a\xf7 \x00\x00\x00\x00\xb0\xba?\xa0\x00\x00\x00\x00\xb0\xf1\x9e\xa0\x00\x00\x00\x00\xb2\x90\xe7 \x00\x00\x00\x00\xb2\xbf\v\xa0\x00\x00\x00\x00\xb4^T \x00\x00\x00\x00\xb4\x95\xb3 \x00\x00" +
+       "\x00\x00\xb64\xfb\xa0\x00\x00\x00\x00\xb6lZ\xa0\x00\x00\x00\x00\xb8\v\xa3 \x00\x00\x00\x00\xb89Ǡ\x00\x00\x00\x00\xb9\xd9\x10 \x00\x00\x00\x00\xba\x10o \x00\x00\x00\x00\xbb\xaf\xb7\xa0\x00\x00\x00\x00\xbb\xe7" +
+       "\x16\xa0\x00\x00\x00\x00\xbd\x86_ \x00\x00\x00\x00\xbd\xb4\x83\xa0\x00\x00\x00\x00\xbfS\xcc \x00\x00\x00\x00\xbf\x8b+ \x00\x00\x00\x00\xc1*s\xa0\x00\x00\x00\x00\xc1X\x98 \x00\x00\x00\x00\xc2\xf7\xe0\xa0\x00\x00" +
+       "\x00\x00\xc3/?\xa0\x00\x00\x00\x00\xc4Έ \x00\x00\x00\x00\xc5\x05\xe7 \x00\x00\x00\x00ƥ/\xa0\x00\x00\x00\x00\xc6\xd3T \x00\x00\x00\x00\xc8r\x9c\xa0\x00\x00\x00\x00ȩ\xfb\xa0\x00\x00\x00\x00\xcaI" +
+       "D \x00\x00\x00\x00ʀ\xa3 \x00\x00\x00\x00\xcc\x1f\xeb\xa0\x00\x00\x00\x00\xccN\x10 \x00\x00\x00\x00\xcd\xedX\xa0\x00\x00\x00\x00\xce$\xb7\xa0\x00\x00\x00\x00\xcf\xc4\x00 \x00\x00\x00\x00\xcf\xf2$\xa0\x00\x00" +
+       "\x00\x00ёm \x00\x00\x00\x00\xd1\xc8\xcc \x00\x00\x00\x00\xd3h\x14\xa0\x00\x00\x00\x00ӟs\xa0\x00\x00\x00\x00\xd5>\xbc \x00\x00\x00\x00\xd5l\xe0\xa0\x00\x00\x00\x00\xd7\f) \x00\x00\x00\x00\xd7C" +
+       "\x88 \x00\x00\x00\x00\xd8\xe2Р\x00\x00\x00\x00\xd9\x1a/\xa0\x00\x00\x00\x00ڹx \x00\x00\x00\x00\xda眠\x00\x00\x00\x00܆\xe5 \x00\x00\x00\x00ܾD \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\xff\xff\xf3\xa0" +
+       "\x00\x00\xff\xff\xf1\xf0\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x01\f\x00\x00\x0e\x10\x00\bLMT\x00-01\x00+01\x00+00\x00\n<+01>-1\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R6\x99rU\xa4\x00\x00\x00\xa4\x00\x00\x00\x0f\x00\x1c\x00Africa/MonroviaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xffZz\xa6\x9c\xff\xff\xff\xff\xa0_l" +
+       "\x9c\x00\x00\x00\x00\x03\xcaZn\x01\x02\x03\xff\xff\xf5\xe4\x00\x00\xff\xff\xf5\xe4\x00\x04\xff\xff\xf5\x92\x00\x04\x00\x00\x00\x00\x00\bLMT\x00MMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/LusakaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00" +
+       "\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x1c\x00Africa/BamakoU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00" +
+       "\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4" +
+       "\x00\x00\x00\r\x00\x1c\x00Africa/NiameyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00" +
+       "\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/KigaliUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
        "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00W" +
-       "AT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\f\x00\x1c\x00Africa/CairoUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u007f\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff}" +
-       "\xbdM\xab\xff\xff\xff\xffȓ\xb4\xe0\xff\xff\xff\xff\xc8\xfa{\xd0\xff\xff\xff\xff\xc9\xfc\xef\xe0\xff\xff\xff\xff\xca\xc7\xe8\xd0\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xcc\xdf)\xd0\xff\xff\xff\xffͬ\xe1\xe0\xff" +
-       "\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xadP\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea" +
-       "\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff" +
-       "\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7" +
-       "\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb\xc2\xfd\x80\xff\xff\xff\xff\xfc۾\xf0\xff\xff\xff\xff\xfd\xa5\x82\x80\xff\xff\xff\xff\xfe\xbc\xf2p\xff" +
-       "\xff\xff\xff\xff\x86\xb6\x00\x00\x00\x00\x00\x00\x9e%\xf0\x00\x00\x00\x00\x01g\xe9\x80\x00\x00\x00\x00\x02\u007fYp\x00\x00\x00\x00\x03I\x1d\x00\x00\x00\x00\x00\x04a\xdep\x00\x00\x00\x00\x05+\xa2\x00\x00\x00\x00\x00\x06" +
-       "C\x11\xf0\x00\x00\x00\x00\a\fՀ\x00\x00\x00\x00\b$Ep\x00\x00\x00\x00\b\xee\t\x00\x00\x00\x00\x00\n\x05x\xf0\x00\x00\x00\x00\n\xcf<\x80\x00\x00\x00\x00\v\xe7\xfd\xf0\x00\x00\x00\x00\f\xb1\xc1\x80\x00" +
-       "\x00\x00\x00\r\xc91p\x00\x00\x00\x00\x0e\x92\xf5\x00\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11\x8b\x98p\x00\x00\x00\x00\x12U\\\x00\x00\x00\x00\x00\x13n\x1dp\x00\x00\x00\x00\x14" +
-       "7\xe1\x00\x00\x00\x00\x00\x15OP\xf0\x00\x00\x00\x00\x16\x19\x14\x80\x00\x00\x00\x00\x17\xa0\x93\xf0\x00\x00\x00\x00\x17\xfaH\x00\x00\x00\x00\x00\x19p\xa3\xf0\x00\x00\x00\x00\x19\xdb{\x80\x00\x00\x00\x00\x1a\xf4<\xf0\x00" +
-       "\x00\x00\x00\x1b\xbe\x00\x80\x00\x00\x00\x00\x1c\xd5pp\x00\x00\x00\x00\x1d\x9f4\x00\x00\x00\x00\x00\x1e\xb6\xa3\xf0\x00\x00\x00\x00\x1f\x80g\x80\x00\x00\x00\x00 \x97\xd7p\x00\x00\x00\x00!a\x9b\x00\x00\x00\x00\x00\"" +
-       "z\\p\x00\x00\x00\x00#D \x00\x00\x00\x00\x00$b'p\x00\x00\x00\x00%%S\x80\x00\x00\x00\x00&<\xc3p\x00\x00\x00\x00'\x06\x87\x00\x00\x00\x00\x00(\x1d\xf6\xf0\x00\x00\x00\x00(纀\x00" +
-       "\x00\x00\x00*\x00{\xf0\x00\x00\x00\x00*\xca?\x80\x00\x00\x00\x00+\xe1\xafp\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00-\xc2\xe2\xf0\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/\xa0\x13\xe0\x00\x00\x00\x000" +
-       "k\f\xd0\x00\x00\x00\x001\u007f\xf5\xe0\x00\x00\x00\x002J\xee\xd0\x00\x00\x00\x003_\xd7\xe0\x00\x00\x00\x004*\xd0\xd0\x00\x00\x00\x005?\xb9\xe0\x00\x00\x00\x006\n\xb2\xd0\x00\x00\x00\x007(\xd6`\x00" +
-       "\x00\x00\x007\xf3\xcfP\x00\x00\x00\x009\b\xb8`\x00\x00\x00\x009ӱP\x00\x00\x00\x00:\xe8\x9a`\x00\x00\x00\x00;\xb3\x93P\x00\x00\x00\x00<\xc8|`\x00\x00\x00\x00=\x93uP\x00\x00\x00\x00>" +
-       "\xa8^`\x00\x00\x00\x00?sWP\x00\x00\x00\x00@\x91z\xe0\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00Bq\\\xe0\x00\x00\x00\x00C<U\xd0\x00\x00\x00\x00DQ>\xe0\x00\x00\x00\x00E\x12\xfdP\x00" +
-       "\x00\x00\x00F1 \xe0\x00\x00\x00\x00F\xe0jP\x00\x00\x00\x00H\x11\x02\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xf0\xe4\xe0\x00\x00\x00\x00J\x8d\xb9P\x00\x00\x00\x00K\xda\x01`\x00\x00\x00\x00L" +
-       "a\xbd\xd0\x00\x00\x00\x00L\x89X\xe0\x00\x00\x00\x00L\xa4\xfaP\x00\x00\x00\x00Su8\xe0\x00\x00\x00\x00S\xac\x89\xd0\x00\x00\x00\x00Sڼ`\x00\x00\x00\x00T$\x82P\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00" +
-       "\x1dU\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00" +
-       "\x00\x00\r\x00\x1c\x00Africa/DoualaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ%JO\xdf\xc1\x01\x00\x00\xc1\x01\x00\x00\v\x00\x1c\x00Africa/JubaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xb6\xa3\xda\xdc\x00\x00\x00\x00\x00\x9e\x17\xe0\x00\x00" +
-       "\x00\x00\x01z4P\x00\x00\x00\x00\x02}\xf9\xe0\x00\x00\x00\x00\x03[g\xd0\x00\x00\x00\x00\x04`~\xe0\x00\x00\x00\x00\x05=\xec\xd0\x00\x00\x00\x00\x06@`\xe0\x00\x00\x00\x00\a\x1f P\x00\x00\x00\x00\b " +
-       "B\xe0\x00\x00\x00\x00\t\x00S\xd0\x00\x00\x00\x00\n\x00$\xe0\x00\x00\x00\x00\n\xe1\x87P\x00\x00\x00\x00\v\xe0\x06\xe0\x00\x00\x00\x00\f\xc4\fP\x00\x00\x00\x00\r\xbf\xe8\xe0\x00\x00\x00\x00\x0e\xa5?\xd0\x00\x00" +
-       "\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10\x86sP\x00\x00\x00\x00\x11\x88\xe7`\x00\x00\x00\x00\x12g\xa6\xd0\x00\x00\x00\x00\x13h\xc9`\x00\x00\x00\x00\x14J+\xd0\x00\x00\x00\x00\x15H\xab`\x00\x00\x00\x00\x16+" +
-       "_P\x00\x00\x00\x00\x17(\x8d`\x00\x00\x00\x00\x18\f\x92\xd0\x00\x00\x00\x00\x19\bo`\x00\x00\x00\x00\x19\xed\xc6P\x00\x00\x00\x00\x1a\xf1\x8b\xe0\x00\x00\x00\x00\x1b\xd0KP\x00\x00\x00\x00\x1c\xd1m\xe0\x00\x00" +
-       "\x00\x00\x1d\xb1~\xd0\x00\x00\x00\x008\x80E \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x00\x00\x1d\xa4\x00\x00\x00\x00*0\x01\x04" +
-       "\x00\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00CAST\x00CAT\x00EAT\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00" +
-       "\x00\x00\x0f\x00\x1c\x00Africa/GaboroneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x1c\x00Africa/TunisUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffYF\x13\xf4\xff\xff\xff\xff\x91`P" +
-       "O\xff\xff\xff\xff\xc6:\x88\xe0\xff\xff\xff\xff\xc7X\x9e`\xff\xff\xff\xff\xc7\xdb\"\xe0\xff\xff\xff\xff\xca\xe2T\xe0\xff\xff\xff\xff˭i\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff" +
-       "\xff\xcd\xc2\x16\x00\xff\xff\xff\xff\xcd̰\x10\xff\xff\xff\xff\u03a25\x00\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЉ\xe3\xe0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N\x16`\x00\x00\x00\x00\r\xc7\xdf" +
-       "\xf0\x00\x00\x00\x00\x0e\x89\xacp\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00\"\xa3:\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00" +
-       "\x00&<\xc3p\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00Bt\r\xf0\x00\x00\x00\x00C<\x80\x00\x00\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf" +
-       "\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\t\x8c\x00\x00\x00\x00\x02" +
-       "1\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00PMT\x00CEST\x00CET\x00\nCET-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00" +
-       "\x00\xb6\x00\x00\x00\x0e\x00\x1c\x00Africa/KampalaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00C" +
+       "AT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r\x00\x1c\x00Africa/BissauUT\t\x00\x03\x15\xac" +
+       "\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff" +
+       "\x92朐\x00\x00\x00\x00\tga\x10\x01\x02\xff\xff\xf1d\x00\x00\xff\xff\xf1\xf0\x00\x04\x00\x00\x00\x00\x00\bLMT\x00-01\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x0f\x00\x1c\x00Africa/KinshasaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaa" +
+       "C\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT" +
+       "-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x12\x00\x1c\x00Africa/Addis_AbabaUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff" +
+       "\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&" +
+       "\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x1c\x00" +
+       "Africa/TunisUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffYF\x13\xf4\xff\xff\xff\xff\x91`PO\xff\xff\xff\xff\xc6:\x88\xe0\xff\xff\xff\xff\xc7X\x9e`\xff\xff\xff\xff\xc7\xdb\"\xe0\xff\xff\xff\xff\xca" +
+       "\xe2T\xe0\xff\xff\xff\xff˭i\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\xcd\xc2\x16\x00\xff\xff\xff\xff\xcd̰\x10\xff\xff\xff\xff\u03a25\x00\xff\xff\xff\xffϒ4\x10\xff" +
+       "\xff\xff\xffЉ\xe3\xe0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N\x16`\x00\x00\x00\x00\r\xc7\xdf\xf0\x00\x00\x00\x00\x0e\x89\xacp\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00\"" +
+       "\xa3:\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&<\xc3p\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00Bt\r\xf0\x00\x00\x00\x00C<\x80\x00\x00" +
+       "\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\t\x8c\x00\x00\x00\x00\x021\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00PMT\x00CEST\x00CE" +
+       "T\x00\nCET-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x1c\x00Africa/BanjulUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92" +
+       "\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00" +
+       "Africa/OuagadougouUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x1c\x00Africa/LibrevilleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP" +
+       "`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00" +
+       "WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x12\x00\x1c\x00Africa/BrazzavilleU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00" +
+       "\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10" +
+       "\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Afr" +
+       "ica/BanguiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00" +
+       "\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00" +
+       "\x82\x00\x00\x00\x0e\x00\x1c\x00Africa/AbidjanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x1c\x00Africa/AlgiersUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffkɛ$\xff\xff\xff\xff\x91" +
+       "`PO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0*\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff" +
+       "\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa4\xb8\x06p\xff\xff\xff\xff\xc6\xff\x06p\xff\xff\xff\xff\xc7X\xba\x80\xff\xff\xff\xff\xc7" +
+       "\xda\t\xa0\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЊ\x00\x00\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N$p\xff\xff\xff\xff\xd4K\ap\xff\xff\xff\xff\xe5\xce\xd3\x00\xff\xff\xff\xff\xf3\\\xb0\xf0\x00" +
+       "\x00\x00\x00\x02x\xc1\xf0\x00\x00\x00\x00\x03C\xc8\xf0\x00\x00\x00\x00\r\xcf\xd7\x00\x00\x00\x00\x00\x0e\xadD\xf0\x00\x00\x00\x00\x0fxZ\x00\x00\x00\x00\x00\x10hY\x10\x00\x00\x00\x00\x12vCp\x00\x00\x00\x00\x13" +
+       "fB\x80\x00\x00\x00\x00\x14_|\x10\x00\x00\x00\x00\x15O_\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x03\x05\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x05\x00\x00\x02\xdc\x00\x00\x00" +
+       "\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\r\x00\x00\x1c \x01\x11\x00\x00\x0e\x10\x00\x16LMT\x00PMT\x00WEST\x00WET\x00CEST\x00CET\x00\nCET-" +
+       "1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x1c\x00Africa/NouakchottUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H" +
+       "\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc1\n\x8a\x84\xad\x00\x00\x00\xad\x00\x00\x00\x0f\x00\x1c\x00Afr" +
+       "ica/Sao_TomeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff^<\xfd0\xff\xff\xff\xff\x92掀\x00\x00\x00\x00ZI\x88\x10\x00\x00\x00\x00\\*\xbb\x90\x01\x02\x03\x02\x00\x00\x06P\x00\x00\xff\xff\xf7" +
+       "c\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x00\bLMT\x00GMT\x00WAT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x14" +
+       "\x00\x1c\x00Africa/Dar_es_SalaamUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02" +
-       "\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x1c\x00Africa/MbabaneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff\xff\xff\xffm{A@\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff" +
-       "̮\x8c\x80\xff\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00\x00\x1c \x00\x04LM" +
-       "T\x00SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x12\x00\x1c\x00Africa/Addis_Ab" +
-       "abaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00" +
-       "\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b" +
-       "\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r" +
-       "\x00\x1c\x00Africa/MaputoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r\x00\x1c\x00Africa/BissauUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x92朐\x00\x00\x00\x00\tga\x10\x01\x02\xff" +
-       "\xff\xf1d\x00\x00\xff\xff\xf1\xf0\x00\x04\x00\x00\x00\x00\x00\bLMT\x00-01\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00" +
-       "\x00\x0f\x00\x1c\x00Africa/BlantyreUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/NiameyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00" +
-       "\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x1c\x00Africa/Ba" +
-       "njulUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff" +
+       "\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-" +
+       "3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x1c\x00Africa/LubumbashiUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4" +
+       "\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Af" +
+       "rica/KampalaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02" +
+       "\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x1c\x00Africa/BlantyreUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04" +
+       "LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/MalaboUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00" +
+       "\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00" +
+       "\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x1c\x00Afri" +
+       "ca/NdjamenaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x92\xe6\x80d\x00\x00\x00\x00\x12fqp\x00\x00\x00\x00\x13&\xde`\x01\x02\x01\x00\x00\x0e\x1c\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bL" +
+       "MT\x00WAT\x00WAST\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Africa/Timb" +
+       "uktuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87" +
-       "\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x1c\x00Africa/AbidjanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nG" +
-       "MT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x1c\x00Africa/AsmaraUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff" +
-       "\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0" +
-       "230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x1c\x00Africa/Bamako" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00" +
-       "\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00" +
-       "\x82\x00\x00\x00\x12\x00\x1c\x00Africa/OuagadougouUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nG" +
-       "MT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/LusakaUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00" +
-       "\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Afri" +
-       "ca/LuandaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1Q\xf3P\x01\x00\x00\x030\x00\x00\x00\x00\x0e\x10\x00\x04LMT\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x1c\x00Africa/AsmeraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff" +
-       "\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x1c\x00Africa/LubumbashiUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01" +
-       "\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ9\x0f߁,\x02\x00\x00,\x02\x00\x00\f\x00\x1c\x00Afr" +
-       "ica/AccraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00/\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x9e0f\xb4\xff\xff\xff\xff\xa34{\x80\xff\xff\xff\xff\xa3\xd3\xfcP\xff\xff\xff\xff\xa5\x15\xaf\x00\xff\xff\xff\xff\xa5\xb5/\xd0\xff\xff\xff\xff\xa6\xf6\xe2\x80" +
-       "\xff\xff\xff\xff\xa7\x96cP\xff\xff\xff\xff\xa8\xd8\x16\x00\xff\xff\xff\xff\xa9w\x96\xd0\xff\xff\xff\xff\xaa\xba\x9b\x00\xff\xff\xff\xff\xabZ\x1b\xd0\xff\xff\xff\xff\xac\x9b\u0380\xff\xff\xff\xff\xad;OP\xff\xff\xff\xff" +
-       "\xae}\x02\x00\xff\xff\xff\xff\xaf\x1c\x82\xd0\xff\xff\xff\xff\xb0^5\x80\xff\xff\xff\xff\xb0\xfd\xb6P\xff\xff\xff\xff\xb2@\xba\x80\xff\xff\xff\xff\xb2\xe0;P\xff\xff\xff\xff\xb4!\xee\x00\xff\xff\xff\xff\xb4\xc1n\xd0" +
-       "\xff\xff\xff\xff\xb6\x03!\x80\xff\xff\xff\xff\xb6\xa2\xa2P\xff\xff\xff\xff\xb7\xe4U\x00\xff\xff\xff\xff\xb8\x83\xd5\xd0\xff\xff\xff\xff\xb9\xc6\xda\x00\xff\xff\xff\xff\xbafZ\xd0\xff\xff\xff\xff\xbb\xa8\r\x80\xff\xff\xff\xff" +
-       "\xbcG\x8eP\xff\xff\xff\xff\xbd\x89A\x00\xff\xff\xff\xff\xbe(\xc1\xd0\xff\xff\xff\xff\xbfjt\x80\xff\xff\xff\xff\xc0\t\xf5P\xff\xff\xff\xff\xc1L\xf9\x80\xff\xff\xff\xff\xc1\xeczP\xff\xff\xff\xff\xc3.-\x00" +
-       "\xff\xff\xff\xff\xc3ͭ\xd0\xff\xff\xff\xff\xc5\x0f`\x80\xff\xff\xff\xffŮ\xe1P\xff\xff\xff\xff\xc6\xf0\x94\x00\xff\xff\xff\xffǐ\x14\xd0\xff\xff\xff\xff\xc8\xd3\x19\x00\xff\xff\xff\xff\xc9r\x99\xd0\xff\xff\xff\xff" +
-       "ʴL\x80\xff\xff\xff\xff\xcbS\xcdP\xff\xff\xff\xff̕\x80\x00\xff\xff\xff\xff\xcd5\x00\xd0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xff\xcc\x00\x00\x00\x00\x04\xb0\x01\x04\x00\x00\x00\x00\x00\nLMT\x00+0020\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQV\xadD\xef\xca\x01\x00\x00\xca\x01\x00\x00\x0f\x00\x1c\x00Africa/KhartoumUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xb6\xa3\xda\x00\x00\x00\x00\x00\x00\x9e\x17\xe0\x00\x00\x00" +
-       "\x00\x01z4P\x00\x00\x00\x00\x02}\xf9\xe0\x00\x00\x00\x00\x03[g\xd0\x00\x00\x00\x00\x04`~\xe0\x00\x00\x00\x00\x05=\xec\xd0\x00\x00\x00\x00\x06@`\xe0\x00\x00\x00\x00\a\x1f P\x00\x00\x00\x00\b B" +
-       "\xe0\x00\x00\x00\x00\t\x00S\xd0\x00\x00\x00\x00\n\x00$\xe0\x00\x00\x00\x00\n\xe1\x87P\x00\x00\x00\x00\v\xe0\x06\xe0\x00\x00\x00\x00\f\xc4\fP\x00\x00\x00\x00\r\xbf\xe8\xe0\x00\x00\x00\x00\x0e\xa5?\xd0\x00\x00\x00" +
-       "\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10\x86sP\x00\x00\x00\x00\x11\x88\xe7`\x00\x00\x00\x00\x12g\xa6\xd0\x00\x00\x00\x00\x13h\xc9`\x00\x00\x00\x00\x14J+\xd0\x00\x00\x00\x00\x15H\xab`\x00\x00\x00\x00\x16+_" +
-       "P\x00\x00\x00\x00\x17(\x8d`\x00\x00\x00\x00\x18\f\x92\xd0\x00\x00\x00\x00\x19\bo`\x00\x00\x00\x00\x19\xed\xc6P\x00\x00\x00\x00\x1a\xf1\x8b\xe0\x00\x00\x00\x00\x1b\xd0KP\x00\x00\x00\x00\x1c\xd1m\xe0\x00\x00\x00" +
-       "\x00\x1d\xb1~\xd0\x00\x00\x00\x008\x80E \x00\x00\x00\x00Y\xf8\xe4P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x00\x00\x1e\x80" +
-       "\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00CAST\x00CAT\x00EAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f\x1b" +
-       "\xeb\xdd2\x02\x00\x002\x02\x00\x00\f\x00\x1c\x00Africa/CeutaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_" +
+       "\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x1c\x00Africa/GaboroneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\n" +
+       "CAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rd\x01\x05\x89\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x1c\x00Africa/CasablancaUT\t\x00\x03\x15\xac" +
+       "\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x00\x00\x00\x05\x00\x00\x00\f\xff\xff\xff\xff" +
+       "\x96Q\xf9\x9c\xff\xff\xff\xff\xc6\xff\x14\x80\xff\xff\xff\xff\xc7X\xacp\xff\xff\xff\xff\xc7\xd9\xed\x80\xff\xff\xff\xffҡ2\xf0\xff\xff\xff\xff\xdb5\xa4\x00\xff\xff\xff\xff\xdb\xee'\xf0\xff\xff\xff\xff\xfb%r@" +
+       "\xff\xff\xff\xff\xfb\xc2\xefp\x00\x00\x00\x00\bk\x84\x80\x00\x00\x00\x00\b\xc6m\xf0\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0e\x8e\xf2p\x00\x00\x00\x00" +
+       "\x0f\xd3Q\x80\x00\x00\x00\x00\x10'\xa3p\x00\x00\x00\x00\x1a\xb7\xa6\x00\x00\x00\x00\x00\x1e\x18o\xf0\x00\x00\x00\x00HA\xe6\x80\x00\x00\x00\x00H\xbb\"p\x00\x00\x00\x00J#\x1a\x00\x00\x00\x00\x00J\x8d\xd5p" +
+       "\x00\x00\x00\x00K\xdc\xc0\x80\x00\x00\x00\x00L]\xe5p\x00\x00\x00\x00M\x97\xb8\x80\x00\x00\x00\x00N4\x8c\xf0\x00\x00\x00\x00O\x9c\xa0\xa0\x00\x00\x00\x00P\b\xbb\xa0\x00\x00\x00\x00P1\x9a \x00\x00\x00\x00" +
+       "Pg\xa7\xa0\x00\x00\x00\x00Q|\x82\xa0\x00\x00\x00\x00Q\xd8ˠ\x00\x00\x00\x00R\x05\x9e\xa0\x00\x00\x00\x00Rls\xa0\x00\x00\x00\x00S7z\xa0\x00\x00\x00\x00S\xae!\xa0\x00\x00\x00\x00S\xdcF " +
+       "\x00\x00\x00\x00TLU\xa0\x00\x00\x00\x00U\x17\\\xa0\x00\x00\x00\x00U|\xe0 \x00\x00\x00\x00U\xab\x04\xa0\x00\x00\x00\x00V,7\xa0\x00\x00\x00\x00V\xf7>\xa0\x00\x00\x00\x00WS\x87\xa0\x00\x00\x00\x00" +
+       "W\x81\xac \x00\x00\x00\x00X\x15T \x00\x00\x00\x00X\xd7 \xa0\x00\x00\x00\x00Y \xf4\xa0\x00\x00\x00\x00YXS\xa0\x00\x00\x00\x00Y\xf56 \x00\x00\x00\x00Z\xb7\x02\xa0\x00\x00\x00\x00Z\xf7\x9c " +
+       "\x00\x00\x00\x00[%\xc0\xa0\x00\x00\x00\x00[\xd5\x18 \x00\x00\x00\x00\\\xceC\xa0\x00\x00\x00\x00\\\xfch \x00\x00\x00\x00^\x9b\xb0\xa0\x00\x00\x00\x00^\xd3\x0f\xa0\x00\x00\x00\x00`rX \x00\x00\x00\x00" +
+       "`\xa0|\xa0\x00\x00\x00\x00b?\xc5 \x00\x00\x00\x00bw$ \x00\x00\x00\x00d\x16l\xa0\x00\x00\x00\x00dMˠ\x00\x00\x00\x00e\xed\x14 \x00\x00\x00\x00f\x1b8\xa0\x00\x00\x00\x00g\xba\x81 " +
+       "\x00\x00\x00\x00g\xf1\xe0 \x00\x00\x00\x00i\x91(\xa0\x00\x00\x00\x00i\xbfM \x00\x00\x00\x00kg\xd0 \x00\x00\x00\x00k\x95\xf4\xa0\x00\x00\x00\x00m5= \x00\x00\x00\x00ml\x9c \x00\x00\x00\x00" +
+       "o\v\xe4\xa0\x00\x00\x00\x00o:\t \x00\x00\x00\x00p\xd9Q\xa0\x00\x00\x00\x00q\x10\xb0\xa0\x00\x00\x00\x00r\xaf\xf9 \x00\x00\x00\x00r\xe7X \x00\x00\x00\x00t\x86\xa0\xa0\x00\x00\x00\x00t\xb4\xc5 " +
+       "\x00\x00\x00\x00vT\r\xa0\x00\x00\x00\x00v\x8bl\xa0\x00\x00\x00\x00x*\xb5 \x00\x00\x00\x00xX٠\x00\x00\x00\x00y\xf8\" \x00\x00\x00\x00z/\x81 \x00\x00\x00\x00{\xceɠ\x00\x00\x00\x00" +
+       "|\x06(\xa0\x00\x00\x00\x00}\xa5q \x00\x00\x00\x00}ӕ\xa0\x00\x00\x00\x00\u007fr\xde \x00\x00\x00\x00\u007f\xaa= \x00\x00\x00\x00\x81I\x85\xa0\x00\x00\x00\x00\x81\x80\xe4\xa0\x00\x00\x00\x00\x83 - " +
+       "\x00\x00\x00\x00\x83NQ\xa0\x00\x00\x00\x00\x84\xed\x9a \x00\x00\x00\x00\x85$\xf9 \x00\x00\x00\x00\x86\xc4A\xa0\x00\x00\x00\x00\x86\xf2f \x00\x00\x00\x00\x88\x91\xae\xa0\x00\x00\x00\x00\x88\xc9\r\xa0\x00\x00\x00\x00" +
+       "\x8ahV \x00\x00\x00\x00\x8a\x9f\xb5 \x00\x00\x00\x00\x8c>\xfd\xa0\x00\x00\x00\x00\x8cm\" \x00\x00\x00\x00\x8e\fj\xa0\x00\x00\x00\x00\x8eCɠ\x00\x00\x00\x00\x8f\xe3\x12 \x00\x00\x00\x00\x90\x1aq " +
+       "\x00\x00\x00\x00\x91\xb9\xb9\xa0\x00\x00\x00\x00\x91\xe7\xde \x00\x00\x00\x00\x93\x87&\xa0\x00\x00\x00\x00\x93\xbe\x85\xa0\x00\x00\x00\x00\x95]\xce \x00\x00\x00\x00\x95\x8b\xf2\xa0\x00\x00\x00\x00\x97+; \x00\x00\x00\x00" +
+       "\x97b\x9a \x00\x00\x00\x00\x99\x01\xe2\xa0\x00\x00\x00\x00\x999A\xa0\x00\x00\x00\x00\x9a؊ \x00\x00\x00\x00\x9b\x06\xae\xa0\x00\x00\x00\x00\x9c\xa5\xf7 \x00\x00\x00\x00\x9c\xddV \x00\x00\x00\x00\x9e|\x9e\xa0" +
+       "\x00\x00\x00\x00\x9e\xb3\xfd\xa0\x00\x00\x00\x00\xa0SF \x00\x00\x00\x00\xa0\x81j\xa0\x00\x00\x00\x00\xa2 \xb3 \x00\x00\x00\x00\xa2X\x12 \x00\x00\x00\x00\xa3\xf7Z\xa0\x00\x00\x00\x00\xa4%\u007f \x00\x00\x00\x00" +
+       "\xa5\xc4Ǡ\x00\x00\x00\x00\xa5\xfc&\xa0\x00\x00\x00\x00\xa7\x9bo \x00\x00\x00\x00\xa7\xd2\xce \x00\x00\x00\x00\xa9r\x16\xa0\x00\x00\x00\x00\xa9\xa0; \x00\x00\x00\x00\xab?\x83\xa0\x00\x00\x00\x00\xabv\xe2\xa0" +
+       "\x00\x00\x00\x00\xad\x16+ \x00\x00\x00\x00\xadM\x8a \x00\x00\x00\x00\xae\xecҠ\x00\x00\x00\x00\xaf\x1a\xf7 \x00\x00\x00\x00\xb0\xba?\xa0\x00\x00\x00\x00\xb0\xf1\x9e\xa0\x00\x00\x00\x00\xb2\x90\xe7 \x00\x00\x00\x00" +
+       "\xb2\xbf\v\xa0\x00\x00\x00\x00\xb4^T \x00\x00\x00\x00\xb4\x95\xb3 \x00\x00\x00\x00\xb64\xfb\xa0\x00\x00\x00\x00\xb6lZ\xa0\x00\x00\x00\x00\xb8\v\xa3 \x00\x00\x00\x00\xb89Ǡ\x00\x00\x00\x00\xb9\xd9\x10 " +
+       "\x00\x00\x00\x00\xba\x10o \x00\x00\x00\x00\xbb\xaf\xb7\xa0\x00\x00\x00\x00\xbb\xe7\x16\xa0\x00\x00\x00\x00\xbd\x86_ \x00\x00\x00\x00\xbd\xb4\x83\xa0\x00\x00\x00\x00\xbfS\xcc \x00\x00\x00\x00\xbf\x8b+ \x00\x00\x00\x00" +
+       "\xc1*s\xa0\x00\x00\x00\x00\xc1X\x98 \x00\x00\x00\x00\xc2\xf7\xe0\xa0\x00\x00\x00\x00\xc3/?\xa0\x00\x00\x00\x00\xc4Έ \x00\x00\x00\x00\xc5\x05\xe7 \x00\x00\x00\x00ƥ/\xa0\x00\x00\x00\x00\xc6\xd3T " +
+       "\x00\x00\x00\x00\xc8r\x9c\xa0\x00\x00\x00\x00ȩ\xfb\xa0\x00\x00\x00\x00\xcaID \x00\x00\x00\x00ʀ\xa3 \x00\x00\x00\x00\xcc\x1f\xeb\xa0\x00\x00\x00\x00\xccN\x10 \x00\x00\x00\x00\xcd\xedX\xa0\x00\x00\x00\x00" +
+       "\xce$\xb7\xa0\x00\x00\x00\x00\xcf\xc4\x00 \x00\x00\x00\x00\xcf\xf2$\xa0\x00\x00\x00\x00ёm \x00\x00\x00\x00\xd1\xc8\xcc \x00\x00\x00\x00\xd3h\x14\xa0\x00\x00\x00\x00ӟs\xa0\x00\x00\x00\x00\xd5>\xbc " +
+       "\x00\x00\x00\x00\xd5l\xe0\xa0\x00\x00\x00\x00\xd7\f) \x00\x00\x00\x00\xd7C\x88 \x00\x00\x00\x00\xd8\xe2Р\x00\x00\x00\x00\xd9\x1a/\xa0\x00\x00\x00\x00ڹx \x00\x00\x00\x00\xda眠\x00\x00\x00\x00" +
+       "܆\xe5 \x00\x00\x00\x00ܾD \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\xff\xff\xf8\xe4\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x00\x04\x00\x00\x00\x00\x01\bL" +
+       "MT\x00+01\x00+00\x00\n<+01>-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/Map" +
+       "utoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c" +
+       "\xb4\x00\x00\x00\xb4\x00\x00\x00\f\x00\x1c\x00Africa/LagosUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01" +
+       "\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Africa/MaseruUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff\xff\xff\xffm{A@\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff̮" +
+       "\x8c\x80\xff\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00\x00\x1c \x00\x04LMT\x00" +
+       "SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x1c\x00Africa/Porto-Novo" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00" +
+       "\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e" +
+       "\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x1c\x00Af" +
+       "rica/ConakryUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/DoualaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x86\xabp\xd1\xff\xff\xff\xff\x8cP`\x00\xff\xff\xff\xff\x96\xaaC\xd1" +
+       "\xff\xff\xff\xff\xa1Q\xefx\x01\x00\x02\x03\x00\x00\x03/\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\a\b\x00\b\x00\x00\x0e\x10\x00\x0eLMT\x00GMT\x00+0030\x00WAT\x00\nWAT-1" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x10\x00\x1c\x00Africa/MogadishuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff" +
+       "\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eL" +
+       "MT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x1c\x00Afri" +
+       "ca/DakarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x0e\x00\x1c\x00Africa/TripoliUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa1\xf2\xc1$\xff\xff\xff\xffݻ\xb1\x10\xff\xff\xff\xff\xde#\xad`\xff\xff\xff" +
+       "\xff\xe1x\xd2\x10\xff\xff\xff\xff\xe1\xe7e\xe0\xff\xff\xff\xff\xe5/?p\xff\xff\xff\xff\xe5\xa9\xcc\xe0\xff\xff\xff\xff\xebN\xc6\xf0\x00\x00\x00\x00\x16\x92B`\x00\x00\x00\x00\x17\b\xf7p\x00\x00\x00\x00\x17\xfa+" +
+       "\xe0\x00\x00\x00\x00\x18\xea*\xf0\x00\x00\x00\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbd\xe4`\x00\x00\x00\x00\x1c\xb4z\xf0\x00\x00\x00\x00\x1d\x9f\x17\xe0\x00\x00\x00\x00\x1e\x93\vp\x00\x00\x00" +
+       "\x00\x1f\x82\xee`\x00\x00\x00\x00 pJp\x00\x00\x00\x00!a~\xe0\x00\x00\x00\x00\"R\xcfp\x00\x00\x00\x00#D\x03\xe0\x00\x00\x00\x00$4\x02\xf0\x00\x00\x00\x00%%7`\x00\x00\x00\x00&@\xb7" +
+       "\xf0\x00\x00\x00\x002N\xf1`\x00\x00\x00\x003D6p\x00\x00\x00\x0045j\xe0\x00\x00\x00\x00P\x9d\x99\x00\x00\x00\x00\x00QTـ\x00\x00\x00\x00Ri\xb4\x80\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x03\x02\x01\x03\x00\x00\f\\\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00\x1c \x00\rLMT\x00CEST\x00CET\x00EE" +
+       "T\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/HarareUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82" +
+       "F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x1c" +
+       "\x00Africa/AsmaraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01" +
+       "\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9Rm)\xb8P~\x02\x00\x00~\x02\x00\x00\x0f\x00\x1c\x00Africa/WindhoekUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x06\x00\x00\x00\x17\xff\xff\xff\xffm{Kx\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff" +
+       "\xff̮\x8c\x80\xff\xff\xff\xff͞op\x00\x00\x00\x00&\x06\xa7\xe0\x00\x00\x00\x00-\x8c\xc7`\x00\x00\x00\x00.i\x1c\x10\x00\x00\x00\x00/}\xe9\x00\x00\x00\x00\x000H\xfe\x10\x00\x00\x00\x001g\x05" +
+       "\x80\x00\x00\x00\x002(\xe0\x10\x00\x00\x00\x003F\xe7\x80\x00\x00\x00\x004\x11\xfc\x90\x00\x00\x00\x005&ɀ\x00\x00\x00\x005\xf1ސ\x00\x00\x00\x007\x06\xab\x80\x00\x00\x00\x007\xd1\xc0\x90\x00\x00\x00" +
+       "\x008捀\x00\x00\x00\x009\xb1\xa2\x90\x00\x00\x00\x00:\xc6o\x80\x00\x00\x00\x00;\x91\x84\x90\x00\x00\x00\x00<\xaf\x8c\x00\x00\x00\x00\x00=qf\x90\x00\x00\x00\x00>\x8fn\x00\x00\x00\x00\x00?Z\x83" +
+       "\x10\x00\x00\x00\x00@oP\x00\x00\x00\x00\x00A:e\x10\x00\x00\x00\x00BO2\x00\x00\x00\x00\x00C\x1aG\x10\x00\x00\x00\x00D/\x14\x00\x00\x00\x00\x00D\xfa)\x10\x00\x00\x00\x00F\x0e\xf6\x00\x00\x00\x00" +
+       "\x00F\xda\v\x10\x00\x00\x00\x00G\xf8\x12\x80\x00\x00\x00\x00H\xc3'\x90\x00\x00\x00\x00I\xd7\xf4\x80\x00\x00\x00\x00J\xa3\t\x90\x00\x00\x00\x00K\xb7ր\x00\x00\x00\x00L\x82\xeb\x90\x00\x00\x00\x00M\x97\xb8" +
+       "\x80\x00\x00\x00\x00Nb͐\x00\x00\x00\x00Ow\x9a\x80\x00\x00\x00\x00PB\xaf\x90\x00\x00\x00\x00Q`\xb7\x00\x00\x00\x00\x00R\"\x91\x90\x00\x00\x00\x00S@\x99\x00\x00\x00\x00\x00T\v\xae\x10\x00\x00\x00" +
+       "\x00U {\x00\x00\x00\x00\x00U\xeb\x90\x10\x00\x00\x00\x00W\x00]\x00\x00\x00\x00\x00W\xcbr\x10\x00\x00\x00\x00X\xe0?\x00\x00\x00\x00\x00Y\xabT\x10\x01\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x00\x00\x10\b\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00\x1c \x00\n\x00\x00*0" +
+       "\x01\n\x00\x00\x0e\x10\x01\x0f\x00\x00\x1c \x00\x13LMT\x00+0130\x00SAST\x00WAT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xee\xc4" +
+       "h2\xbc\x02\x00\x00\xbc\x02\x00\x00\f\x00\x1c\x00Africa/AccraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff~6\xb5\x00\xff\xff\xff\xff\x9e\xd6up\xff\xff\xff\xff\x9f\xa1n`\xff\xff\xff\xff\xaa\x05\xef" +
-       "p\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff" +
-       "\xff\xfb%r@\xff\xff\xff\xff\xfb\xc2\xefp\x00\x00\x00\x00\bk\x84\x80\x00\x00\x00\x00\b\xc6m\xf0\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0e\x8e\xf2" +
-       "p\x00\x00\x00\x00\x0f\xd3Q\x80\x00\x00\x00\x00\x10'\xa3p\x00\x00\x00\x00\x1a\xb7\xa6\x00\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00" +
-       "\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%" +
-       "\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00" +
-       "\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xff\xfb\x04" +
-       "\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x1c \x01\x11LMT\x00WET\x00WEST\x00CET\x00CEST\x00\nCET-1CEST,M" +
-       "3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x1c\x00Africa/Bujumbu" +
-       "raUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQm)\xb8P~" +
-       "\x02\x00\x00~\x02\x00\x00\x0f\x00\x1c\x00Africa/WindhoekUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x9a\x1d\x944\xff\xff\xff\xff\xa1\xc0\xb4\x80\xff\xff\xff\xff\xa1\xf2\xe4\xf0\xff\xff\xff\xff\xa34\x97" +
+       "\xa0\xff\xff\xff\xff\xa3\xd5i\xf0\xff\xff\xff\xff\xa5\x15\xcb \xff\xff\xff\xff\xa5\xb6\x9dp\xff\xff\xff\xff\xa6\xf6\xfe\xa0\xff\xff\xff\xff\xa7\x97\xd0\xf0\xff\xff\xff\xff\xa8\xd82 \xff\xff\xff\xff\xa9y\x04p\xff\xff\xff" +
+       "\xff\xaa\xba\xb7 \xff\xff\xff\xff\xab[\x89p\xff\xff\xff\xff\xac\x9b\xea\xa0\xff\xff\xff\xff\xad<\xbc\xf0\xff\xff\xff\xff\xae}\x1e \xff\xff\xff\xff\xaf\x1d\xf0p\xff\xff\xff\xff\xb0^Q\xa0\xff\xff\xff\xff\xb0\xff#" +
+       "\xf0\xff\xff\xff\xff\xb2@֠\xff\xff\xff\xff\xb2\xe1\xa8\xf0\xff\xff\xff\xff\xb4\"\n \xff\xff\xff\xff\xb4\xc2\xdcp\xff\xff\xff\xff\xb6\x03=\xa0\xff\xff\xff\xff\xb6\xa4\x0f\xf0\xff\xff\xff\xff\xb7\xe4q \xff\xff\xff" +
+       "\xff\xb8\x85Cp\xff\xff\xff\xff\xb9\xc6\xf6 \xff\xff\xff\xff\xbag\xc8p\xff\xff\xff\xff\xbb\xa8)\xa0\xff\xff\xff\xff\xbcH\xfb\xf0\xff\xff\xff\xff\xbd\x89] \xff\xff\xff\xff\xbe*/p\xff\xff\xff\xff\xbfj\x90" +
+       "\xa0\xff\xff\xff\xff\xc0\vb\xf0\xff\xff\xff\xff\xc1M\x15\xa0\xff\xff\xff\xff\xc1\xed\xe7\xf0\xff\xff\xff\xff\xc3.I \xff\xff\xff\xff\xc3\xcf\x1bp\xff\xff\xff\xff\xc5\x0f|\xa0\xff\xff\xff\xffŰN\xf0\xff\xff\xff" +
+       "\xff\xc6\xf0\xb0 \xff\xff\xff\xffǑ\x82p\xff\xff\xff\xff\xc81\f\xa0\xff\xff\xff\xff\xc9t\ap\xff\xff\xff\xff\xca\x12@ \xff\xff\xff\xff\xcbU:\xf0\xff\xff\xff\xffˇ<\x80\xff\xff\xff\xff\xd2\xe1\xd3" +
+       "x\xff\xff\xff\xffۡ\xdb \xff\xff\xff\xff\xdcB\xab\x18\xff\xff\xff\xff݃\x0e\xa0\xff\xff\xff\xff\xde#ޘ\xff\xff\xff\xff\xdfe\x93\xa0\xff\xff\xff\xff\xe0\x06c\x98\xff\xff\xff\xff\xe1F\xc7 \xff\xff\xff" +
+       "\xff\xe1\xe7\x97\x18\xff\xff\xff\xff\xe3'\xfa\xa0\xff\xff\xff\xff\xe3\xc8ʘ\xff\xff\xff\xff\xe5\t. \xff\xff\xff\xff\xe5\xa9\xfe\x18\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\xff\xff\xff\xcc\x00\x00\x00\x00\x04\xb0\x01\x04\x00\x00\x00\x00\x00\n\x00\x00\a\b" +
+       "\x00\x0e\x00\x00\a\b\x01\x0eLMT\x00+0020\x00GMT\x00+0030\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00" +
+       "\v\x00\x1c\x00Africa/LomeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0f\x00\x1c\x00Africa/DjiboutiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff" +
+       "\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00" +
+       "EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00America/UT\t\x00\x03" +
+       "\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x82\x13z\xe2\xc2\x00\x00\x00\xc2\x00\x00\x00\x13\x00\x1c\x00America" +
+       "/TegucigalpaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa4LKD\x00\x00\x00\x00 \x9a\xdc\xe0\x00\x00\x00\x00!\\\x9bP\x00\x00\x00\x00\"z\xbe\xe0\x00\x00\x00\x00#<}P\x00\x00\x00\x00D" +
+       "]\x8c\xe0\x00\x00\x00\x00D\xd6\xc8\xd0\x02\x01\x02\x01\x02\x01\x02\xff\xff\xae<\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00CST\x00\nCST6\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x1c\x00America/St_KittsUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff" +
+       "\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x13\x00\x1c\x00America/Puer" +
+       "to_RicoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffz敹\xff\xff\xff\xff\xcb\xf62\xc0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\x01\x03\x02\x01\xff\xff\xc2\a\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff" +
+       "\xd5\xd0\x01\b\xff\xff\xd5\xd0\x01\fLMT\x00AST\x00APT\x00AWT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xdf\b\x9c\x9f\xe7\x00\x00\x00\xe7\x00\x00\x00\x10\x00" +
+       "\x1c\x00America/BarbadosUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\xa9y$\xe5\xff\xff\xff\xff\xb8\x85c\xe5\x00\x00\x00\x00\x0e\x00\xf2\xe0\x00\x00\x00\x00\x0e\x94\x8c\xd0\x00\x00\x00\x00\x0f\x97\x00" +
+       "\xe0\x00\x00\x00\x00\x10tn\xd0\x00\x00\x00\x00\x11v\xe2\xe0\x00\x00\x00\x00\x12TP\xd0\x00\x00\x00\x00\x13_\xff`\x00\x00\x00\x00\x140>P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xc8\x1b\x00\x00\xff\xff\xc8" +
+       "\x1b\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\fLMT\x00BMT\x00ADT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x14\xc1r8\xe0\x00\x00\x00\xe0" +
+       "\x00\x00\x00\x10\x00\x1c\x00America/AtikokanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x84d\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xc8\xf8W`\xff\xff" +
+       "\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\x02\x01\x02\x01\x03\x04\x05\xff\xff\xaa\x1c\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff" +
+       "\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00" +
+       "\x00\x10\x00\x1c\x00America/DominicaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xac\x8a\x83S\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x1c\x00America/GuatemalaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9f\x9d\xea\xdc\x00\x00\x00" +
+       "\x00\aU\xac`\x00\x00\x00\x00\a͖\xd0\x00\x00\x00\x00\x19,x`\x00\x00\x00\x00\x19\xcf\xe4P\x00\x00\x00\x00'\xea\xee\xe0\x00\x00\x00\x00(\xc8\\\xd0\x00\x00\x00\x00DTR`\x00\x00\x00\x00E\x1fK" +
+       "P\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xab$\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\x1e+}\x15\xb4\x02\x00\x00\xb4\x02\x00\x00\x14\x00\x1c\x00America/Rankin_InletUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xe7\x8cn\x00\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8" +
+       "(w\xe0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00" +
+       "\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 " +
+       "v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00" +
+       "\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00." +
+       "\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00" +
+       "\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<" +
+       "\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00" +
+       "\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xab\xa0\x00\t\xff\xff\xb9\xb0\x01\r\xff\xff\xb9\xb0\x00\x11-00\x00CDDT\x00" +
+       "CST\x00CDT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00" +
+       "\x00\x00\x0f\x00\x1c\x00America/TortolaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x1c\x00America/IqaluitUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\b\x00\x00\x00!\xff\xff\xff\xff\xccl\xa1\x80\xff\xff\xff\xff\xd2" +
+       "#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xf7/>P\xff\xff\xff\xff\xf8(i\xd0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00" +
+       "\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d" +
+       "\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00" +
+       "\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+" +
+       "\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00" +
+       "\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009" +
+       "\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00" +
+       "\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x05\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02" +
+       "\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x06\a\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff" +
+       "\xff\xb9\xb0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xc7\xc0\x01\x11\xff\xff\xc7\xc0\x01\x15\xff\xff\xab\xa0\x00\x19\xff\xff\xb9\xb0\x01\x1d-00\x00EPT\x00EST\x00EDDT\x00EDT\x00EWT\x00" +
+       "CST\x00CDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd7\b\\\xc6&\x02\x00\x00&\x02\x00\x00\x10\x00" +
+       "\x1c\x00America/MiquelonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x91\xb68\xa8\x00\x00\x00\x00\x13nc\xc0\x00\x00\x00\x00 u\xe4\xd0\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"U\xc6" +
+       "\xd0\x00\x00\x00\x00#j\x93\xc0\x00\x00\x00\x00$5\xa8\xd0\x00\x00\x00\x00%Ju\xc0\x00\x00\x00\x00&\x15\x8a\xd0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xfe\xa7P\x00\x00\x00\x00)\n9\xc0\x00\x00\x00" +
+       "\x00)މP\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+\xbekP\x00\x00\x00\x00,\xd38@\x00\x00\x00\x00-\x9eMP\x00\x00\x00\x00.\xb3\x1a@\x00\x00\x00\x00/~/P\x00\x00\x00\x000\x92\xfc" +
+       "@\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002r\xde@\x00\x00\x00\x003G-\xd0\x00\x00\x00\x004R\xc0@\x00\x00\x00\x005'\x0f\xd0\x00\x00\x00\x0062\xa2@\x00\x00\x00\x007\x06\xf1\xd0\x00\x00\x00" +
+       "\x008\x1b\xbe\xc0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00\x009\xfb\xa0\xc0\x00\x00\x00\x00:Ƶ\xd0\x00\x00\x00\x00;ۂ\xc0\x00\x00\x00\x00<\xaf\xd2P\x00\x00\x00\x00=\xbbd\xc0\x00\x00\x00\x00>\x8f\xb4" +
+       "P\x00\x00\x00\x00?\x9bF\xc0\x00\x00\x00\x00@o\x96P\x00\x00\x00\x00A\x84c@\x00\x00\x00\x00BOxP\x00\x00\x00\x00CdE@\x00\x00\x00\x00D/ZP\x00\x00\x00\x00ED'@\x00\x00\x00" +
+       "\x00E\xf3\x8c\xd0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xcbX\x00\x00\xff\xff\xc7\xc0\x00\x04" +
+       "\xff\xff\xd5\xd0\x00\b\xff\xff\xe3\xe0\x01\fLMT\x00AST\x00-03\x00-02\x00\n<-03>3<-02>,M3.2.0,M11.1.0\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x11Z\xde\xe4\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x1c\x00America/FortalezaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaak\x18\xff\xff\xff\xff\xb8\x0f" +
+       "I\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff" +
+       "\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e" +
+       "\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00" +
+       "\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7" +
+       "\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x009\xf2J \x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xdb\xe8\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-" +
+       "02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd6\xfe\xf3%\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x1c\x00America/Resolut" +
+       "eUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x05" +
+       "\x00\x00\x00\x15\xff\xff\xff\xff\xd5\xfb\x81\x80\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(w\xe0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0" +
+       "\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00" +
+       "\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00" +
+       "\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00" +
+       "+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp" +
+       "\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x00" +
+       "9\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80" +
+       "\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff" +
+       "\xab\xa0\x00\t\xff\xff\xb9\xb0\x01\r\xff\xff\xb9\xb0\x00\x11-00\x00CDDT\x00CST\x00CDT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x1c\x00America/St_ThomasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01" +
+       "\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xbf\x03u\xf3\xe4\x01\x00\x00\xe4\x01\x00\x00\x0e\x00\x1c\x00Amer" +
+       "ica/RecifeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaag\xb8\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae" +
+       "0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff" +
+       "\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8" +
+       "\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00" +
+       "\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe3" +
+       "0\x00\x00\x00\x009\xe9\x0f\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\xff\xff\xdfH\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0" +
+       "\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x1c\x00America/CuracaoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04" +
+       "\xff\xff\xc7\xc0\x00\nLMT\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x1c\x00Amer" +
+       "ica/MartiniqueUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x87\x14\xc4\xff\xff\xff\xff\x91\xa3\xc8D\x00\x00\x00\x00\x13Mn@\x00\x00\x00\x00\x144\x16\xb0\x01\x02\x03\x02\xff\xffƼ\x00\x00\xff" +
+       "\xffƼ\x00\x04\xff\xff\xc7\xc0\x00\t\xff\xff\xd5\xd0\x01\rLMT\x00FFMT\x00AST\x00ADT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?\xc9\x1c\xd4\xc6\x03" +
+       "\x00\x00\xc6\x03\x00\x00\x0e\x00\x1c\x00America/JuneauUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\n\x00\x00\x00&\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x872\xc5\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff" +
+       "\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04" +
+       "a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00" +
+       "\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12" +
+       "ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00" +
+       "\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f" +
+       "\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00" +
+       "\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-" +
+       "\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00" +
+       "\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;" +
+       "\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00" +
+       "\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x06\x02" +
+       "\x05\x02\x05\x02\x05\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xd3{\x00\x00" +
+       "\xff\xff\x81\xfb\x00\x00\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x8f\x80\x01\x14\xff\xff\x81p\x00\x18\xff\xff\x8f\x80\x01\x1c\xff\xff\x81p\x00!LMT\x00PS" +
+       "T\x00PWT\x00PPT\x00PDT\x00YDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00\x00\r\x00\x1c\x00America/BoiseUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Z\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0" +
+       "\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xff\xa8FL \xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff" +
+       "\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00" +
+       "\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\xb2\x1f\x90\x00\x00\x00\x00" +
+       "\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10" +
+       "\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00" +
+       "\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80" +
+       "\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00" +
+       "%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90" +
+       "\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x00" +
+       "3Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00" +
+       "\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00" +
+       "A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x05\x03\x04\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\x93\x0f\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\x9d\x90\x00\x14\xff\xff\xab\xa0\x01\x18LMT\x00" +
+       "PDT\x00PST\x00MWT\x00MPT\x00MST\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xaaʂA\xcd\x00\x00\x00\xcd\x00\x00\x00\x14\x00\x1c\x00America/Blanc-SablonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=9\f\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff" +
+       "\xff\x9f\xba\xddP\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\x02\x01\x02\x03\x04\x02\xff\xff\xcat\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff" +
+       "\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x1c" +
+       "\x00America/CuiabaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa{\x94\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff" +
+       "\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0T" +
+       "A0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff" +
+       "\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81" +
+       "w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00#X\x1e\xc0\x00\x00\x00\x00#\xe2~0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xd4\xd50\x00\x00\x00\x00'!\x1d@\x00\x00\x00\x00'\xbd\xf1\xb0\x00\x00" +
+       "\x00\x00)\x00\xff@\x00\x00\x00\x00)\x94\x990\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+k@\xb0\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x00\x00\x00\x00.\xa0\xa5@\x00\x00\x00\x00/F" +
+       "\xb40\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001\x1d[\xb0\x00\x00\x00\x002W.\xc0\x00\x00\x00\x003\x06x0\x00\x00\x00\x0048b@\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006 -@\x00\x00" +
+       "\x00\x006\xcfv\xb0\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x00:\x8f:\xb0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<o\x1c\xb0\x00\x00\x00\x00=\xc4" +
+       "\x9f@\x00\x00\x00\x00>N\xfe\xb0\x00\x00\x00\x00A\x87\x06@\x00\x00\x00\x00B\x17\xfd0\x00\x00\x00\x00CQ\xd0@\x00\x00\x00\x00C\xf7\xdf0\x00\x00\x00\x00EMa\xc0\x00\x00\x00\x00E\xe0\xfb\xb0\x00\x00" +
+       "\x00\x00G\x11\x94@\x00\x00\x00\x00G\xb7\xa30\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\x97\x850\x00\x00\x00\x00Jڒ\xc0\x00\x00\x00\x00K\x80\xa1\xb0\x00\x00\x00\x00L\xbat\xc0\x00\x00\x00\x00M`" +
+       "\x83\xb0\x00\x00\x00\x00N\x9aV\xc0\x00\x00\x00\x00OI\xa00\x00\x00\x00\x00P\x83s@\x00\x00\x00\x00Q G\xb0\x00\x00\x00\x00RcU@\x00\x00\x00\x00S\x00)\xb0\x00\x00\x00\x00TC7@\x00\x00" +
+       "\x00\x00T\xe9F0\x00\x00\x00\x00V#\x19@\x00\x00\x00\x00V\xc9(0\x00\x00\x00\x00X\x02\xfb@\x00\x00\x00\x00X\xa9\n0\x00\x00\x00\x00Y\xe2\xdd@\x00\x00\x00\x00Z\x88\xec0\x00\x00\x00\x00[\xde" +
+       "n\xc0\x00\x00\x00\x00\\h\xce0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xcbl\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT" +
+       "\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf7\xe9 y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e\x00\x1c\x00America/Inuvi" +
+       "kUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x05" +
+       "\x00\x00\x00\x15\xff\xff\xff\xff\xe0\x06N\x80\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x94\x00\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10" +
+       "\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00" +
+       "\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00" +
+       "\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00" +
+       "*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10" +
+       "\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x00" +
+       "8\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00" +
+       "\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x00\x00\x00" +
+       "\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x8f\x80\x00\t\xff\xff\x9d\x90\x00\r\xff\xff\xab\xa0\x01\x11-00\x00PDDT\x00PST\x00MST\x00MDT\x00\nMST7MDT,M3.2." +
+       "0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x1c\x00America/YellowknifeU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00" +
+       "\x00\x19\xff\xff\xff\xff\xbe*\x18\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(\x85\xf0\x00\x00\x00\x00\x13id\x10\x00\x00" +
+       "\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2" +
+       "&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00" +
+       "\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\n" +
+       "r\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00" +
+       "\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a" +
+       "*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00" +
+       "\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED" +
+       "_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x03\x01\x02\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x00\x00\x00\x00\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xab\xa0\x01\x15-00\x00MWT\x00MPT\x00M" +
+       "ST\x00MDDT\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x10\x00\x1c\x00America/Indiana/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x14\x00\x1c\x00America/Indiana/KnoxUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff" +
+       "\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6" +
+       " \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff" +
+       "\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4" +
+       "^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff" +
+       "\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4" +
+       "_\x87p\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00" +
+       "\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a" +
+       "\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00" +
+       "\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x16" +
+       "9\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00" +
+       "\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$" +
+       "5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00" +
+       "\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff" +
+       "\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11." +
+       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x01\xd8N\x8c\xab\x02\x00\x00\xab\x02\x00\x00\x1a\x00\x1c\x00America/Indiana/Petersburg" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x06\x00" +
+       "\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff" +
+       "\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xe4g=\xe0\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea" +
+       "\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff" +
+       "\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xfa" +
+       "\bg\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00" +
+       "\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a" +
+       "\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00" +
+       "\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x00\x00\x00\x00G-m\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\x05\xff\xff\xae-\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9" +
+       "\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x1c\x00\x1c\x00America/Indiana/IndianapolisUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0" +
+       "\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff" +
+       "\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0" +
+       "\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff" +
+       "߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00" +
+       "\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01" +
+       "\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff" +
+       "\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0," +
+       "M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RصK\xa6\n\x02\x00\x00\n\x02\x00\x00\x19\x00\x1c\x00America/Indiana/Tell_C" +
+       "ityUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00" +
+       "\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#" +
+       "\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xe4g=\xe0\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff" +
+       "\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f" +
+       "\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff" +
+       "\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3" +
+       "\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x06\x05\x06\x05\x01\x02\x01\xff\xff\xae\xa9\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9" +
+       "\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nCST6CDT,M3" +
+       ".2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R \x17\x89}q\x01\x00\x00q\x01\x00\x00\x15\x00\x1c\x00America/Indiana/V" +
+       "evayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00" +
+       "\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2" +
+       "#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00" +
+       "\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05" +
+       "\x06\x05\x06\x05\x06\x05\x06\xff\xff\xb0@\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST" +
+       "\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RK-E\xfad" +
+       "\x02\x00\x00d\x02\x00\x00\x17\x00\x1c\x00America/Indiana/WinamacUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9" +
+       "p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff" +
+       "\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s" +
+       "\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff" +
+       "\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00" +
+       "\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff" +
+       "\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x00\x00\x00\x00G-_\xe0\x02\x01\x02\x01\x02\x03\x04" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x06\x05\x06\x05\x01\x02\x06\x05\xff\xff\xae\xcf\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff" +
+       "\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M" +
+       "3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RM/U\x9f7\x02\x00\x007\x02\x00\x00\x17\x00\x1c\x00America/Indiana/" +
+       "MarengoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00*\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff" +
+       "\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)" +
+       "\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff" +
+       "\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87" +
+       "\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00" +
+       "\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x01\x05\x06\x05\x06\x05\x06\xff\xff\xaf\r\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff" +
+       "\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1." +
+       "0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x1c\x00America/Indiana/VincennesUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)\x00\x00\x00\a\x00\x00\x00\x1c" +
+       "\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff" +
+       "\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4g=\xe0" +
+       "\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff" +
+       "\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0q\x9e\xf0\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2\u007f\xa5p" +
+       "\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00" +
+       "D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x00\x00\x00\x00G-m\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x05\x06\x05\x06\x05\x01\x02\x01\x05\xff\xff\xad\xf1\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00C" +
+       "ST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rc)\xf6" +
+       ")\xb3\x00\x00\x00\xb3\x00\x00\x00\x0e\x00\x1c\x00America/BogotaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff^\x9c4\xf0\xff\xff\xff\xff\x98XUp\x00\x00\x00\x00*\x03sP\x00\x00\x00\x00+\xbe" +
+       "]@\x01\x03\x02\x03\xff\xff\xba\x90\x00\x00\xff\xff\xba\x90\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00BMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R.\xf9\xc0\x1e\xd5\x05\x00\x00\xd5\x05\x00\x00\x0f\x00\x1c\x00America/MonctonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x1e\xed\xbc\xff\xff\xff\xff\x80\xf1\xb6P\xff\xff" +
+       "\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xff\xbb<8\xd0\xff\xff\xff\xff\xbb\xb4#@\xff\xff\xff\xff\xbd\x1c\x1a\xd0\xff\xff\xff\xff\xbd\x94\x05@\xff\xff\xff\xff\xbe\xfb\xfc\xd0\xff\xff\xff\xff\xbfs" +
+       "\xe7@\xff\xff\xff\xff\xc0\xdb\xde\xd0\xff\xff\xff\xff\xc1S\xc9@\xff\xff\xff\xff»\xc0\xd0\xff\xff\xff\xff\xc33\xab@\xff\xff\xff\xffě\xa2\xd0\xff\xff\xff\xff\xc5\x13\x8d@\xff\xff\xff\xff\xc6p\xf8\xd0\xff\xff" +
+       "\xff\xff\xc7\r\xcd@\xff\xff\xff\xff\xc8H\xf1\xd0\xff\xff\xff\xff\xc8\xed\xaf@\xff\xff\xff\xff\xca\x16^\xd0\xff\xff\xff\xff\xca\xd6\xcb\xc0\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`" +
+       "\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@\xcf\xd0\xff\xff\xff\xff\xd5U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9\x15|\xe0\xff\xff" +
+       "\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xda\xfe\x99`\xff\xff\xff\xff\xdb\xc0W\xd0\xff\xff\xff\xff\xdc\xde{`\xff\xff\xff\xffݩtP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e" +
+       "?`\xff\xff\xff\xff\xe1i8P\xff\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3I\x1aP\xff\xff\xff\xff\xe4^\x03`\xff\xff\xff\xff\xe5(\xfcP\xff\xff\xff\xff\xe6G\x1f\xe0\xff\xff\xff\xff\xe7\x12\x18\xd0\xff\xff" +
+       "\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe9\x16\xe4\xd0\xff\xff\xff\xff\xea\x06\xe3\xe0\xff\xff\xff\xff\xea\xf6\xc6\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff\xec֨\xd0\xff\xff\xff\xff\xedƧ\xe0\xff\xff\xff\xff\xee\xbf" +
+       "\xc5P\xff\xff\xff\xff\xef\xaf\xc4`\xff\xff\xff\xff\xf0\x9f\xa7P\xff\xff\xff\xff\xf1\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_kP\xff\xff\xff\xff\xf5Oj`\xff\xff" +
+       "\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(i\xd0\xff\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8" +
+       ",\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00" +
+       "\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\f\xd9" +
+       "\x94\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00" +
+       "\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1" +
+       "\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00" +
+       "\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\n" +
+       "G\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbe]|\x00\x00\x00\x00,\xd3*l\x00\x00\x00\x00-\x9e?|\x00\x00\x00\x00.\xb3\fl\x00\x00\x00\x00/~!|\x00\x00" +
+       "\x00\x000\x92\xeel\x00\x00\x00\x001g=\xfc\x00\x00\x00\x002r\xd0l\x00\x00\x00\x003G\x1f\xfc\x00\x00\x00\x004R\xb2l\x00\x00\x00\x005'\x01\xfc\x00\x00\x00\x0062\x94l\x00\x00\x00\x007\x06" +
+       "\xe3\xfc\x00\x00\x00\x008\x1b\xb0\xec\x00\x00\x00\x008\xe6\xc5\xfc\x00\x00\x00\x009\xfb\x92\xec\x00\x00\x00\x00:Ƨ\xfc\x00\x00\x00\x00;\xdbt\xec\x00\x00\x00\x00<\xaf\xc4|\x00\x00\x00\x00=\xbbV\xec\x00\x00" +
+       "\x00\x00>\x8f\xa6|\x00\x00\x00\x00?\x9b8\xec\x00\x00\x00\x00@o\x88|\x00\x00\x00\x00A\x84Ul\x00\x00\x00\x00BOj|\x00\x00\x00\x00Cd7l\x00\x00\x00\x00D/L|\x00\x00\x00\x00ED" +
+       "\x19l\x00\x00\x00\x00E\xf3\x9a\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xc3D\x00\x00\xff\xff\xb9\xb0\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\f" +
+       "\xff\xff\xd5\xd0\x01\x10\xff\xff\xd5\xd0\x01\x14LMT\x00EST\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11.1.0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00America/MarigotUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6" +
+       "T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R挋\x92\xf6\x01\x00\x00\xf6\x01\x00\x00\x0e\x00\x1c\x00America" +
+       "/MaceioUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00)\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaah|\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff" +
+       "\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97" +
+       "\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff" +
+       "\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\v" +
+       "Ƞ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x007\xf6ư\x00\x00" +
+       "\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x009\xf2J \x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffބ\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x1c\x00America/PanamaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffi\x87&\x10\xff\xff\xff\xff\x8b\xf4a\xe8" +
+       "\x01\x02\xff\xff\xb5p\x00\x00\xff\xff\xb5\x18\x00\x04\xff\xff\xb9\xb0\x00\bLMT\x00CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa2\x81\xbfyS\x02\x00\x00" +
+       "S\x02\x00\x00\x12\x00\x1c\x00America/MetlakatlaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x06\x00\x00\x00\x17\xff\xff\xff\xffm{Kx\xff\xff\xff\xff\x82F\xcfh\xff\xff\xff\xff̮\x8c\x80\xff\xff\xff\xff͞o" +
-       "p\x00\x00\x00\x00&\x06\xa7\xe0\x00\x00\x00\x00-\x8c\xc7`\x00\x00\x00\x00.i\x1c\x10\x00\x00\x00\x00/}\xe9\x00\x00\x00\x00\x000H\xfe\x10\x00\x00\x00\x001g\x05\x80\x00\x00\x00\x002(\xe0\x10\x00\x00\x00" +
-       "\x003F\xe7\x80\x00\x00\x00\x004\x11\xfc\x90\x00\x00\x00\x005&ɀ\x00\x00\x00\x005\xf1ސ\x00\x00\x00\x007\x06\xab\x80\x00\x00\x00\x007\xd1\xc0\x90\x00\x00\x00\x008捀\x00\x00\x00\x009\xb1\xa2" +
-       "\x90\x00\x00\x00\x00:\xc6o\x80\x00\x00\x00\x00;\x91\x84\x90\x00\x00\x00\x00<\xaf\x8c\x00\x00\x00\x00\x00=qf\x90\x00\x00\x00\x00>\x8fn\x00\x00\x00\x00\x00?Z\x83\x10\x00\x00\x00\x00@oP\x00\x00\x00\x00" +
-       "\x00A:e\x10\x00\x00\x00\x00BO2\x00\x00\x00\x00\x00C\x1aG\x10\x00\x00\x00\x00D/\x14\x00\x00\x00\x00\x00D\xfa)\x10\x00\x00\x00\x00F\x0e\xf6\x00\x00\x00\x00\x00F\xda\v\x10\x00\x00\x00\x00G\xf8\x12" +
-       "\x80\x00\x00\x00\x00H\xc3'\x90\x00\x00\x00\x00I\xd7\xf4\x80\x00\x00\x00\x00J\xa3\t\x90\x00\x00\x00\x00K\xb7ր\x00\x00\x00\x00L\x82\xeb\x90\x00\x00\x00\x00M\x97\xb8\x80\x00\x00\x00\x00Nb͐\x00\x00\x00" +
-       "\x00Ow\x9a\x80\x00\x00\x00\x00PB\xaf\x90\x00\x00\x00\x00Q`\xb7\x00\x00\x00\x00\x00R\"\x91\x90\x00\x00\x00\x00S@\x99\x00\x00\x00\x00\x00T\v\xae\x10\x00\x00\x00\x00U {\x00\x00\x00\x00\x00U\xeb\x90" +
-       "\x10\x00\x00\x00\x00W\x00]\x00\x00\x00\x00\x00W\xcbr\x10\x00\x00\x00\x00X\xe0?\x00\x00\x00\x00\x00Y\xabT\x10\x01\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x00\x00\x10\b\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00\x1c \x00\n\x00\x00*0\x01\n\x00\x00\x0e\x10\x01\x0f\x00\x00\x1c " +
-       "\x00\x13LMT\x00+0130\x00SAST\x00WAT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ)\xae\x8eo&\a\x00\x00&\a\x00\x00\x0f\x00" +
-       "\x1c\x00Africa/El_AaiunUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00,\x00\x00\x00\b\x00\x00\x00\x1e\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x870\x1a\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4" +
+       "p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00" +
+       "\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0" +
+       "\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00" +
+       "\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18" +
+       " \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00V5\xe2\xa0\x00\x00\x00\x00V\xe5H0\x00\x00\x00\x00X\x1e\xff \x00\x00\x00\x00X\xc5*0\x00\x00\x00\x00Y\xfe\xe1 \x00\x00\x00\x00Z\xa5\f0\x00\x00\x00" +
+       "\x00[\xde\xc3 \x00\x00\x00\x00\\DF\xa0\x00\x00\x00\x00\\\x84\xee0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x06\a\x06\a" +
+       "\x06\a\x02\x06\a\x00\x00\xd6&\x00\x00\xff\xff\x84\xa6\x00\x00\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x81p\x00\x14\xff\xff\x8f\x80\x01\x19LMT\x00PST" +
+       "\x00PWT\x00PPT\x00PDT\x00AKST\x00AKDT\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\xfe\xe6\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x1c\x00America/DawsonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff\xff}\x86\x8e\xb4\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0" +
+       "\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2Ҁ\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\x00\x00\x00\x00" +
+       "\a0\xec\x90\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 " +
+       "\x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00" +
+       " v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10" +
+       "\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00" +
+       ".\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V " +
+       "\x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00" +
+       "<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90" +
+       "\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00" +
+       "J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0" +
+       "\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00V5Ԑ\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00" +
+       "X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00\x00Z\xa4\xfe \x00\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 \x00\x00\x00\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0" +
+       "\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a" +
+       "\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff}L\x00\x00\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f" +
+       "\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19\xff\xff\x9d\x90\x01\x1d\xff\xff\x9d\x90\x00!LMT\x00YDT\x00YST\x00YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00" +
+       "MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x11\x00\x1c\x00America/CatamarcaUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14" +
+       "\xff\xff\xff\xffr\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff" +
+       "\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@" +
+       "\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xff" +
+       "ȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0" +
+       "\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff" +
+       "\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0" +
+       "\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00" +
+       ")\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0" +
+       "\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04" +
+       "\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03" +
+       "\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00America/AntiguaUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00" +
+       "\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x11\x00\x1c\x00America/Kentucky/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x1b\x00\x1c\x00America/Kentucky/LouisvilleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00u\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff" +
+       "\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa4s\xf7\x00\xff\xff\xff\xff\xa5\x16\x11p\xff\xff\xff\xff\xca\rN\x80\xff\xff\xff\xff\xca" +
+       "\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xd7\x1c\xff\xff\xff\xffӤ\tp\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff" +
+       "\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3" +
+       "I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff" +
+       "\xff\xff\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x1e\x90p\xff\xff\xff\xff\xfc" +
+       "\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00" +
+       "\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n" +
+       "\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00" +
+       "\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19" +
+       "\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00" +
+       "\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'" +
+       "*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00" +
+       "\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005" +
+       "'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00" +
+       "\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00C" +
+       "da`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf\x9a\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14" +
+       "\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00\x1b\x00\x1c\x00America/Kentucky/MonticelloUT\t\x00\x03" +
+       "\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff" +
+       "\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a" +
+       "\t\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00" +
+       "\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad" +
+       "\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00" +
+       "\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"" +
+       "7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00" +
+       "\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15" +
+       "\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00" +
+       "\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R" +
+       "\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00" +
+       "\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO" +
+       "\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\xff\xff\xb0t\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xc7\xc0\x01\x14\xff\xff\xb9\xb0\x00\x18LMT\x00CDT\x00CST\x00CWT\x00C" +
+       "PT\x00EDT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00" +
+       "\x00\x0f\x00\x1c\x00America/OjinagaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8" +
+       "\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00" +
+       "\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=" +
+       "\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00" +
+       "\x00\x00\x00ED_\x80\x00\x00\x00\x00F\x0ft\x90\x00\x00\x00\x00G$A\x80\x00\x00\x00\x00G\xf8\x91\x10\x00\x00\x00\x00I\x04#\x80\x00\x00\x00\x00I\xd8s\x10\x00\x00\x00\x00J\xe4\x05\x80\x00\x00\x00\x00K" +
+       "\x9c\xa5\x90\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff\xff\x9e\x1c\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0" +
+       "\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00CDT\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\r\x00\x1c\x00America/ArubaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]" +
+       "\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\nLMT\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x81{\xc1\x92\xbc\x03\x00\x00\xbc\x03\x00\x00" +
+       "\r\x00\x1c\x00America/SitkaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xbcH\xf0\xe0\x00\x00\x00\x00\vѰ\x90\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\faG\xf0\x00\x00\x00\x00\r\xc9?\x80" +
-       "\x00\x00\x00\x00\x0e\x8e\xf2p\x00\x00\x00\x00\x0f\xd3Q\x80\x00\x00\x00\x00\x10'\xa3p\x00\x00\x00\x00HA\xe6\x80\x00\x00\x00\x00H\xbb\"p\x00\x00\x00\x00J#\x1a\x00\x00\x00\x00\x00J\x8d\xd5p\x00\x00\x00\x00" +
-       "K\xdc\xc0\x80\x00\x00\x00\x00L]\xe5p\x00\x00\x00\x00M\x97\xb8\x80\x00\x00\x00\x00N4\x8c\xf0\x00\x00\x00\x00O\x9c\xa0\xa0\x00\x00\x00\x00P\b\xbb\xa0\x00\x00\x00\x00P1\x9a \x00\x00\x00\x00Pg\xa7\xa0" +
-       "\x00\x00\x00\x00Q|\x82\xa0\x00\x00\x00\x00Q\xd8ˠ\x00\x00\x00\x00R\x05\x9e\xa0\x00\x00\x00\x00Rls\xa0\x00\x00\x00\x00S7z\xa0\x00\x00\x00\x00S\xae!\xa0\x00\x00\x00\x00S\xdcF \x00\x00\x00\x00" +
-       "TLU\xa0\x00\x00\x00\x00U\x17\\\xa0\x00\x00\x00\x00U|\xe0 \x00\x00\x00\x00U\xab\x04\xa0\x00\x00\x00\x00V,7\xa0\x00\x00\x00\x00V\xf7>\xa0\x00\x00\x00\x00WS\x87\xa0\x00\x00\x00\x00W\x81\xac " +
-       "\x00\x00\x00\x00X\x15T \x00\x00\x00\x00X\xd7 \xa0\x00\x00\x00\x00Y \xf4\xa0\x00\x00\x00\x00YXS\xa0\x00\x00\x00\x00Y\xf56 \x00\x00\x00\x00Z\xb7\x02\xa0\x00\x00\x00\x00Z\xf7\x9c \x00\x00\x00\x00" +
-       "[%\xc0\xa0\x00\x00\x00\x00[\xd5\x18 \x00\x00\x00\x00\\\xceC\xa0\x00\x00\x00\x00\\\xfch \x00\x00\x00\x00^\x9b\xb0\xa0\x00\x00\x00\x00^\xd3\x0f\xa0\x00\x00\x00\x00`rX \x00\x00\x00\x00`\xa0|\xa0" +
-       "\x00\x00\x00\x00b?\xc5 \x00\x00\x00\x00bw$ \x00\x00\x00\x00d\x16l\xa0\x00\x00\x00\x00dMˠ\x00\x00\x00\x00e\xed\x14 \x00\x00\x00\x00f\x1b8\xa0\x00\x00\x00\x00g\xba\x81 \x00\x00\x00\x00" +
-       "g\xf1\xe0 \x00\x00\x00\x00i\x91(\xa0\x00\x00\x00\x00i\xbfM \x00\x00\x00\x00kg\xd0 \x00\x00\x00\x00k\x95\xf4\xa0\x00\x00\x00\x00m5= \x00\x00\x00\x00ml\x9c \x00\x00\x00\x00o\v\xe4\xa0" +
-       "\x00\x00\x00\x00o:\t \x00\x00\x00\x00p\xd9Q\xa0\x00\x00\x00\x00q\x10\xb0\xa0\x00\x00\x00\x00r\xaf\xf9 \x00\x00\x00\x00r\xe7X \x00\x00\x00\x00t\x86\xa0\xa0\x00\x00\x00\x00t\xb4\xc5 \x00\x00\x00\x00" +
-       "vT\r\xa0\x00\x00\x00\x00v\x8bl\xa0\x00\x00\x00\x00x*\xb5 \x00\x00\x00\x00xX٠\x00\x00\x00\x00y\xf8\" \x00\x00\x00\x00z/\x81 \x00\x00\x00\x00{\xceɠ\x00\x00\x00\x00|\x06(\xa0" +
-       "\x00\x00\x00\x00}\xa5q \x00\x00\x00\x00}ӕ\xa0\x00\x00\x00\x00\u007fr\xde \x00\x00\x00\x00\u007f\xaa= \x00\x00\x00\x00\x81I\x85\xa0\x00\x00\x00\x00\x81\x80\xe4\xa0\x00\x00\x00\x00\x83 - \x00\x00\x00\x00" +
-       "\x83NQ\xa0\x00\x00\x00\x00\x84\xed\x9a \x00\x00\x00\x00\x85$\xf9 \x00\x00\x00\x00\x86\xc4A\xa0\x00\x00\x00\x00\x86\xf2f \x00\x00\x00\x00\x88\x91\xae\xa0\x00\x00\x00\x00\x88\xc9\r\xa0\x00\x00\x00\x00\x8ahV " +
-       "\x00\x00\x00\x00\x8a\x9f\xb5 \x00\x00\x00\x00\x8c>\xfd\xa0\x00\x00\x00\x00\x8cm\" \x00\x00\x00\x00\x8e\fj\xa0\x00\x00\x00\x00\x8eCɠ\x00\x00\x00\x00\x8f\xe3\x12 \x00\x00\x00\x00\x90\x1aq \x00\x00\x00\x00" +
-       "\x91\xb9\xb9\xa0\x00\x00\x00\x00\x91\xe7\xde \x00\x00\x00\x00\x93\x87&\xa0\x00\x00\x00\x00\x93\xbe\x85\xa0\x00\x00\x00\x00\x95]\xce \x00\x00\x00\x00\x95\x8b\xf2\xa0\x00\x00\x00\x00\x97+; \x00\x00\x00\x00\x97b\x9a " +
-       "\x00\x00\x00\x00\x99\x01\xe2\xa0\x00\x00\x00\x00\x999A\xa0\x00\x00\x00\x00\x9a؊ \x00\x00\x00\x00\x9b\x06\xae\xa0\x00\x00\x00\x00\x9c\xa5\xf7 \x00\x00\x00\x00\x9c\xddV \x00\x00\x00\x00\x9e|\x9e\xa0\x00\x00\x00\x00" +
-       "\x9e\xb3\xfd\xa0\x00\x00\x00\x00\xa0SF \x00\x00\x00\x00\xa0\x81j\xa0\x00\x00\x00\x00\xa2 \xb3 \x00\x00\x00\x00\xa2X\x12 \x00\x00\x00\x00\xa3\xf7Z\xa0\x00\x00\x00\x00\xa4%\u007f \x00\x00\x00\x00\xa5\xc4Ǡ" +
-       "\x00\x00\x00\x00\xa5\xfc&\xa0\x00\x00\x00\x00\xa7\x9bo \x00\x00\x00\x00\xa7\xd2\xce \x00\x00\x00\x00\xa9r\x16\xa0\x00\x00\x00\x00\xa9\xa0; \x00\x00\x00\x00\xab?\x83\xa0\x00\x00\x00\x00\xabv\xe2\xa0\x00\x00\x00\x00" +
-       "\xad\x16+ \x00\x00\x00\x00\xadM\x8a \x00\x00\x00\x00\xae\xecҠ\x00\x00\x00\x00\xaf\x1a\xf7 \x00\x00\x00\x00\xb0\xba?\xa0\x00\x00\x00\x00\xb0\xf1\x9e\xa0\x00\x00\x00\x00\xb2\x90\xe7 \x00\x00\x00\x00\xb2\xbf\v\xa0" +
-       "\x00\x00\x00\x00\xb4^T \x00\x00\x00\x00\xb4\x95\xb3 \x00\x00\x00\x00\xb64\xfb\xa0\x00\x00\x00\x00\xb6lZ\xa0\x00\x00\x00\x00\xb8\v\xa3 \x00\x00\x00\x00\xb89Ǡ\x00\x00\x00\x00\xb9\xd9\x10 \x00\x00\x00\x00" +
-       "\xba\x10o \x00\x00\x00\x00\xbb\xaf\xb7\xa0\x00\x00\x00\x00\xbb\xe7\x16\xa0\x00\x00\x00\x00\xbd\x86_ \x00\x00\x00\x00\xbd\xb4\x83\xa0\x00\x00\x00\x00\xbfS\xcc \x00\x00\x00\x00\xbf\x8b+ \x00\x00\x00\x00\xc1*s\xa0" +
-       "\x00\x00\x00\x00\xc1X\x98 \x00\x00\x00\x00\xc2\xf7\xe0\xa0\x00\x00\x00\x00\xc3/?\xa0\x00\x00\x00\x00\xc4Έ \x00\x00\x00\x00\xc5\x05\xe7 \x00\x00\x00\x00ƥ/\xa0\x00\x00\x00\x00\xc6\xd3T \x00\x00\x00\x00" +
-       "\xc8r\x9c\xa0\x00\x00\x00\x00ȩ\xfb\xa0\x00\x00\x00\x00\xcaID \x00\x00\x00\x00ʀ\xa3 \x00\x00\x00\x00\xcc\x1f\xeb\xa0\x00\x00\x00\x00\xccN\x10 \x00\x00\x00\x00\xcd\xedX\xa0\x00\x00\x00\x00\xce$\xb7\xa0" +
-       "\x00\x00\x00\x00\xcf\xc4\x00 \x00\x00\x00\x00\xcf\xf2$\xa0\x00\x00\x00\x00ёm \x00\x00\x00\x00\xd1\xc8\xcc \x00\x00\x00\x00\xd3h\x14\xa0\x00\x00\x00\x00ӟs\xa0\x00\x00\x00\x00\xd5>\xbc \x00\x00\x00\x00" +
-       "\xd5l\xe0\xa0\x00\x00\x00\x00\xd7\f) \x00\x00\x00\x00\xd7C\x88 \x00\x00\x00\x00\xd8\xe2Р\x00\x00\x00\x00\xd9\x1a/\xa0\x00\x00\x00\x00ڹx \x00\x00\x00\x00\xda眠\x00\x00\x00\x00܆\xe5 " +
-       "\x00\x00\x00\x00ܾD \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\xff\xff\xf3\xa0\x00\x00\xff\xff\xf1\xf0\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x01\f\x00\x00\x0e\x10\x00\bLMT\x00-01\x00+0" +
-       "1\x00+00\x00\n<+01>-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x0e\x00\x1c\x00Africa/TripoliU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x04\x00\x00" +
-       "\x00\x11\xff\xff\xff\xff\xa1\xf2\xc1$\xff\xff\xff\xffݻ\xb1\x10\xff\xff\xff\xff\xde#\xad`\xff\xff\xff\xff\xe1x\xd2\x10\xff\xff\xff\xff\xe1\xe7e\xe0\xff\xff\xff\xff\xe5/?p\xff\xff\xff\xff\xe5\xa9\xcc\xe0\xff\xff" +
-       "\xff\xff\xebN\xc6\xf0\x00\x00\x00\x00\x16\x92B`\x00\x00\x00\x00\x17\b\xf7p\x00\x00\x00\x00\x17\xfa+\xe0\x00\x00\x00\x00\x18\xea*\xf0\x00\x00\x00\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbd" +
-       "\xe4`\x00\x00\x00\x00\x1c\xb4z\xf0\x00\x00\x00\x00\x1d\x9f\x17\xe0\x00\x00\x00\x00\x1e\x93\vp\x00\x00\x00\x00\x1f\x82\xee`\x00\x00\x00\x00 pJp\x00\x00\x00\x00!a~\xe0\x00\x00\x00\x00\"R\xcfp\x00\x00" +
-       "\x00\x00#D\x03\xe0\x00\x00\x00\x00$4\x02\xf0\x00\x00\x00\x00%%7`\x00\x00\x00\x00&@\xb7\xf0\x00\x00\x00\x002N\xf1`\x00\x00\x00\x003D6p\x00\x00\x00\x0045j\xe0\x00\x00\x00\x00P\x9d" +
-       "\x99\x00\x00\x00\x00\x00QTـ\x00\x00\x00\x00Ri\xb4\x80\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x03\x02\x01\x03\x00\x00\f\\\x00\x00\x00\x00\x1c " +
-       "\x01\x04\x00\x00\x0e\x10\x00\t\x00\x00\x1c \x00\rLMT\x00CEST\x00CET\x00EET\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ6\x99rU\xa4\x00\x00\x00" +
-       "\xa4\x00\x00\x00\x0f\x00\x1c\x00Africa/MonroviaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xffZz\xa6\x9c\xff\xff\xff\xff\xa0_l\x9c\x00\x00\x00\x00\x03\xcaZn\x01\x02\x03\xff\xff\xf5\xe4\x00\x00\xff" +
-       "\xff\xf5\xe4\x00\x04\xff\xff\xf5\x92\x00\x04\x00\x00\x00\x00\x00\bLMT\x00MMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00" +
-       "\x00\x14\x00\x1c\x00Africa/Dar_es_SalaamUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\t\x00\x00\x00\"\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x873\x99\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10" +
+       "\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00" +
+       "\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0" +
+       "\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00" +
+       "\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90" +
+       "\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00" +
+       " v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac " +
+       "\x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00" +
+       ".\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0" +
+       "\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00" +
+       "<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0" +
+       "\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x06\b" +
+       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x00\x00ҧ\x00\x00\xff\xff\x81'\x00\x00\xff" +
+       "\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x81p\x00\x14\xff\xff\x8f\x80\x01\x18\xff\xff\x81p\x00\x1dLMT\x00PST\x00PWT\x00PPT\x00PDT" +
+       "\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rѱ\x86b\xee" +
+       "\x03\x00\x00\xee\x03\x00\x00\x0e\x00\x1c\x00America/NassauUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4" +
-       "\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x1c\x00Africa/JohannesburgUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\t\xff\xff\xff\xffm{A@\xff\xff\xff\xff\x82" +
-       "F\xcfh\xff\xff\xff\xff̮\x8c\x80\xff\xff\xff\xff͞op\xff\xff\xff\xffΎn\x80\xff\xff\xff\xff\xcf~Qp\x01\x03\x02\x03\x02\x03\x00\x00\x1a@\x00\x00\x00\x00\x15\x18\x00\x04\x00\x00*0\x01\x04\x00" +
-       "\x00\x1c \x00\x04LMT\x00SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/K" +
-       "igaliUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x82F\xc5\xf4\x01\x00\x00\x1e\x8c\x00\x00\x00\x00\x1c \x00\x04LMT\x00CAT\x00\nCAT-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE" +
-       "1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0f\x00\x1c\x00Africa/DjiboutiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff" +
-       "\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Africa/FreetownUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8" +
-       "\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00America/" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x13\x00\x1c\x00Am" +
-       "erica/Puerto_RicoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffz敹\xff\xff\xff\xff\xcb\xf62\xc0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\x01\x03\x02\x01\xff\xff\xc2\a" +
-       "\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xd5\xd0\x01\fLMT\x00AST\x00APT\x00AWT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xbf\x03u\xf3" +
-       "\xe4\x01\x00\x00\xe4\x01\x00\x00\x0e\x00\x1c\x00America/RecifeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x937B\x8a\xff\xff\xff\xff\xcb\xf4\xefP\xff\xff\xff\xff\xd0\xfaG\xc0\xff\xff\xff\xff\xd1#4P" +
+       "\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2x\x9a\xc0\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff" +
+       "\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0" +
+       "\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00" +
+       "\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0" +
+       "\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00" +
+       "\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp" +
+       "\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00" +
+       "$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0" +
+       "\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x00" +
+       "2r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0" +
+       "\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00" +
+       "@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x03\x02\x04\x02" +
+       "\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02" +
+       "\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\xff\xff\xb7v\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00E" +
+       "WT\x00EST\x00EPT\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9d?\xdfڸ\x03\x00" +
+       "\x00\xb8\x03\x00\x00\x11\x00\x1c\x00America/Sao_PauloUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaag\xb8\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf14" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaar\xb4\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf14" +
        "0\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff" +
-       "\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5" +
+       "\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4Z\t0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5" +
        " \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00" +
-       "\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x007\xf6\xc6" +
-       "\xb0\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x009\xe9\x0f\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xdfH\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd6\xfe\xf3%\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x1c\x00America/ResoluteUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xd5\xfb\x81\x80\xff\xff\xff\xff\xf7" +
-       "/L`\xff\xff\xff\xff\xf8(w\xe0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00" +
-       "\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f" +
-       "\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00" +
-       "\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-" +
-       "\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00" +
-       "\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;" +
-       "۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00" +
-       "\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xab\xa0\x00\t\xff\xff\xb9\xb0\x01\r\xff\xff\xb9\xb0\x00\x11-" +
-       "00\x00CDDT\x00CST\x00CDT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQa\xcb" +
-       "'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x1c\x00America/ManausUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\u007fD\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9" +
-       "\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff" +
-       "\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8" +
-       "\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00" +
-       "\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffǼ\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\x10\x00\x1c\x00America/New_YorkUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
+       "\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x00'!\x0f" +
+       "0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00,\xc0\xb50\x00\x00\x00\x00-f\xc4 \x00\x00\x00" +
+       "\x00.\xa0\x970\x00\x00\x00\x00/F\xa6 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00\x00\x004\xf8\xc1" +
+       " \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00" +
+       "\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00?\x91\xfe0\x00\x00\x00\x00@.Ҡ\x00\x00\x00\x00A\x86\xf80\x00\x00\x00\x00B\x17\xef \x00\x00\x00\x00CQ\xc2" +
+       "0\x00\x00\x00\x00C\xf7\xd1 \x00\x00\x00\x00EMS\xb0\x00\x00\x00\x00E\xe0\xed\xa0\x00\x00\x00\x00G\x11\x860\x00\x00\x00\x00G\xb7\x95 \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\x97w \x00\x00\x00" +
+       "\x00Jڄ\xb0\x00\x00\x00\x00K\x80\x93\xa0\x00\x00\x00\x00L\xbaf\xb0\x00\x00\x00\x00M`u\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x00\x00\x00\x00P\x83e0\x00\x00\x00\x00Q 9" +
+       "\xa0\x00\x00\x00\x00RcG0\x00\x00\x00\x00S\x00\x1b\xa0\x00\x00\x00\x00TC)0\x00\x00\x00\x00T\xe98 \x00\x00\x00\x00V#\v0\x00\x00\x00\x00V\xc9\x1a \x00\x00\x00\x00X\x02\xed0\x00\x00\x00" +
+       "\x00X\xa8\xfc \x00\x00\x00\x00Y\xe2\xcf0\x00\x00\x00\x00Z\x88\xde \x00\x00\x00\x00[\xde`\xb0\x00\x00\x00\x00\\h\xc0 \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd4L\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "g\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/Rio_BrancoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
        "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x03\xf0\x90\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff\xff\xff\x9f\xba\xeb" +
-       "`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1\x9a\xcd`\xff\xff\xff\xff\xa2e\xe2p\xff\xff\xff\xff\xa3\x83\xe9\xe0\xff\xff\xff\xff\xa4j\xaep\xff\xff\xff\xff\xa55\xa7`\xff\xff\xff\xff\xa6S\xca\xf0\xff\xff\xff" +
-       "\xff\xa7\x15\x89`\xff\xff\xff\xff\xa83\xac\xf0\xff\xff\xff\xff\xa8\xfe\xa5\xe0\xff\xff\xff\xff\xaa\x13\x8e\xf0\xff\xff\xff\xff\xaaއ\xe0\xff\xff\xff\xff\xab\xf3p\xf0\xff\xff\xff\xff\xac\xbei\xe0\xff\xff\xff\xff\xad\xd3R" +
-       "\xf0\xff\xff\xff\xff\xae\x9eK\xe0\xff\xff\xff\xff\xaf\xb34\xf0\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff" +
-       "\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9\x1b\xd9p\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbbƴ" +
-       "`\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff" +
-       "\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xff\xca\r@" +
-       "p\xff\xff\xff\xff\xca\xd89`\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U\xc6\xf0\xff\xff\xff" +
-       "\xff\xd6 \xbf\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xd9\x15\x8a\xf0\xff\xff\xff\xff\xd9\xe0\x83\xe0\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdb\xc0e\xe0\xff\xff\xff\xff\xdcމ" +
-       "p\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I(`\xff\xff\xff" +
-       "\xff\xe4^\x11p\xff\xff\xff\xff\xe5W.\xe0\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe77\x10\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4" +
-       "\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff" +
-       "\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<" +
-       "p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00" +
-       "\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2" +
-       "`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00" +
-       "\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)" +
-       "\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00" +
-       "\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf" +
-       "\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00" +
-       "\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\" +
+       "\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff" +
+       "\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QH" +
+       "P\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00" +
+       "\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12\x00\x1c\x00America/Costa_RicaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x87*M\xff" +
+       "\xff\xff\xff\xa3\xe8\x16M\x00\x00\x00\x00\x116I`\x00\x00\x00\x00\x11\xb7nP\x00\x00\x00\x00\x13\x16+`\x00\x00\x00\x00\x13\x97PP\x00\x00\x00\x00'\x97\xe0`\x00\x00\x00\x00(n\xb6\xd0\x00\x00\x00\x00)" +
+       "w\xc2`\x00\x00\x00\x00)\xc2\xd9\xd0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb13\x00\x00\xff\xff\xb13\x00\x04\xff\xff\xb9\xb0\x01\t\xff\xff\xab\xa0\x00\rLMT\x00SJMT\x00CDT\x00CS" +
+       "T\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1b\x81-\xa9\x8a\x01\x00\x00\x8a\x01\x00\x00\x13\x00\x1c\x00America/Porto_VelhoUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f" +
+       "\xff\xff\xff\xff\x96\xaa\x82\xe8\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff" +
+       "\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0" +
+       "\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff" +
+       "\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xc4\x18\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x14\x00\x1c\x00America/IndianapolisUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0" +
+       "\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff" +
+       "\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0" +
+       "\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff" +
+       "߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00" +
+       "\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01" +
+       "\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff" +
+       "\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0," +
+       "M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4T\xbd\xeb5\x02\x00\x005\x02\x00\x00\x16\x00\x1c\x00America/Port-au-Prince" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00-\x00\x00\x00\x04\x00" +
+       "\x00\x00\x11\xff\xff\xff\xffi\x87\x1fP\xff\xff\xff\xff\x9cnq\xfc\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00\x00\x1a\x01\xef@\x00\x00\x00\x00\x1a\xf1\xeeP\x00\x00\x00\x00\x1b\xe1\xd1@\x00\x00\x00\x00\x1c\xd1\xd0P\x00" +
+       "\x00\x00\x00\x1d\xc1\xb3@\x00\x00\x00\x00\x1e\xb1\xb2P\x00\x00\x00\x00\x1f\xa1\x95@\x00\x00\x00\x00 \x91\x94P\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$" +
+       "5\xb6\xe0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea7\xe0\x00" +
+       "\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002" +
+       "r\xfa`\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x00BOxP\x00\x00\x00\x00CdE@\x00\x00\x00\x00D/ZP\x00\x00\x00\x00ED'@\x00\x00\x00\x00O\\Mp\x00" +
+       "\x00\x00\x00P\x96\x04`\x00\x00\x00\x00Q</p\x00\x00\x00\x00Ru\xe6`\x00\x00\x00\x00S\x1c\x11p\x00\x00\x00\x00TU\xc8`\x00\x00\x00\x00T\xfb\xf3p\x00\x00\x00\x00V5\xaa`\x00\x00\x00\x00X" +
+       "\xc4\xf1\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xbc0\x00\x00\xff\xff\xbcD\x00\x04" +
+       "\xff\xff\xc7\xc0\x01\t\xff\xff\xb9\xb0\x00\rLMT\x00PPMT\x00EDT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x1c\x00America/El_SalvadorUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa3զ \x00\x00\x00\x00 \x9a\xdc" +
+       "\xe0\x00\x00\x00\x00!\\\x9bP\x00\x00\x00\x00\"z\xbe\xe0\x00\x00\x00\x00#<}P\x02\x01\x02\x01\x02\xff\xff\xac`\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00CST\x00" +
+       "\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AdakUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff?\xc2\xfd\xd1\xff" +
+       "\xff\xff\xff}\x87Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00" +
+       "\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00" +
+       "\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e" +
+       "\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00" +
+       "\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00\x1a\xf2P\xc0\x00\x00\x00\x00\x1b" +
+       "\xe23\xb0\x00\x00\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00 vG@\x00\x00\x00\x00!\x81ٰ\x00\x00\x00\x00\"V)@\x00" +
+       "\x00\x00\x00#j\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15\xed@\x00\x00\x00\x00'*\xba0\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00)\n\x9c0\x00\x00\x00\x00)" +
+       "\xde\xeb\xc0\x00\x00\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00.\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0\x00\x00\x00\x000\x93^\xb0\x00" +
+       "\x00\x00\x001g\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S\"\xb0\x00\x00\x00\x005'r@\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x007\aT@\x00\x00\x00\x008" +
+       "\x1c!0\x00\x00\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00\x00\x00;\xdb\xe50\x00\x00\x00\x00<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70\x00\x00\x00\x00>\x90\x16\xc0\x00" +
+       "\x00\x00\x00?\x9b\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00ED\x89\xb0\x00\x00\x00\x00E" +
+       "\xf3\xef@\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
+       "\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xab\xe2\x00\x00\xff\xffZb\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffe" +
+       "P\x00\x10\xff\xffs`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00" +
+       "\nHST10HDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x1c\x00Ameri" +
+       "ca/St_JohnsUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xbb\x00\x00\x00\b\x00\x00\x00\x19\xff\xff\xff\xff^=4\xec\xff\xff\xff\xff\x9c\xcfb\f\xff\xff\xff\xff\x9d\xa4\xe6\xfc\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff\xff\xff\x9f\xba\xd6|\xff\xff\xff\xff\xa0\xb6" +
+       "\x88\xdc\xff\xff\xff\xff\xa18\xffL\xff\xff\xff\xff\xa2\x95\x19\\\xff\xff\xff\xff\xa3\x84\xfcL\xff\xff\xff\xff\xa4t\xfb\\\xff\xff\xff\xff\xa5d\xdeL\xff\xff\xff\xff\xa6^\x17\xdc\xff\xff\xff\xff\xa7D\xc0L\xff\xff" +
+       "\xff\xff\xa8=\xf9\xdc\xff\xff\xff\xff\xa9$\xa2L\xff\xff\xff\xff\xaa\x1d\xdb\xdc\xff\xff\xff\xff\xab\x04\x84L\xff\xff\xff\xff\xab\xfd\xbd\xdc\xff\xff\xff\xff\xac\xe4fL\xff\xff\xff\xff\xadݟ\xdc\xff\xff\xff\xff\xae\xcd" +
+       "\x82\xcc\xff\xff\xff\xff\xaf\xbd\x81\xdc\xff\xff\xff\xff\xb0\xadd\xcc\xff\xff\xff\xff\xb1\xa6\x9e\\\xff\xff\xff\xff\xb2\x8dF\xcc\xff\xff\xff\xff\xb3\x86\x80\\\xff\xff\xff\xff\xb4m(\xcc\xff\xff\xff\xff\xb5fb\\\xff\xff" +
+       "\xff\xff\xb6M\n\xcc\xff\xff\xff\xff\xb7FD\\\xff\xff\xff\xff\xb8,\xec\xcc\xff\xff\xff\xff\xb9&&\\\xff\xff\xff\xff\xba\x16\tL\xff\xff\xff\xff\xbb\x0fB\xdc\xff\xff\xff\xff\xbb\xf5\xebL\xff\xff\xff\xff\xbc\xef" +
+       "$\xdc\xff\xff\xff\xff\xbd\xd5\xcdL\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xbe\xcf\x06\xa8\xff\xff\xff\xff\xbf\xb5\xaf\x18\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff\xff\u0098\x138\xff\xff" +
+       "\xff\xff\xc3YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2(\xff\xff\xff\xff\xca " +
+       "ո\xff\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff\xff\xd5h&\xd8\xff\xff" +
+       "\xff\xff\xd6)\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5\xc8\xff\xff\xff\xff\xdc\xde" +
+       "tX\xff\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff\xff\xe3I\x13H\xff\xff" +
+       "\xff\xff\xe4]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc\xd8\xff\xff\xff\xff\xea\xd1" +
+       "\xd5\xc8\xff\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffeH\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff\xff\xf1\x8f\x9fX\xff\xff" +
+       "\xff\xff\xf2\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b\xc8\xff\xff\xff\xff\xf9\x0f" +
+       "'X\xff\xff\xff\xff\xfa\bD\xc8\xff\xff\xff\xff\xfa\xf8C\xd8\xff\xff\xff\xff\xfb\xe8&\xc8\xff\xff\xff\xff\xfc\xd8%\xd8\xff\xff\xff\xff\xfd\xc8\b\xc8\xff\xff\xff\xff\xfe\xb8\a\xd8\xff\xff\xff\xff\xff\xa7\xea\xc8\x00\x00" +
+       "\x00\x00\x00\x97\xe9\xd8\x00\x00\x00\x00\x01\x87\xcc\xc8\x00\x00\x00\x00\x02w\xcb\xd8\x00\x00\x00\x00\x03p\xe9H\x00\x00\x00\x00\x04`\xe8X\x00\x00\x00\x00\x05P\xcbH\x00\x00\x00\x00\x06@\xcaX\x00\x00\x00\x00\a0" +
+       "\xadH\x00\x00\x00\x00\b \xacX\x00\x00\x00\x00\t\x10\x8fH\x00\x00\x00\x00\n\x00\x8eX\x00\x00\x00\x00\n\xf0qH\x00\x00\x00\x00\v\xe0pX\x00\x00\x00\x00\fٍ\xc8\x00\x00\x00\x00\r\xc0RX\x00\x00" +
+       "\x00\x00\x0e\xb9o\xc8\x00\x00\x00\x00\x0f\xa9n\xd8\x00\x00\x00\x00\x10\x99Q\xc8\x00\x00\x00\x00\x11\x89P\xd8\x00\x00\x00\x00\x12y3\xc8\x00\x00\x00\x00\x13i2\xd8\x00\x00\x00\x00\x14Y\x15\xc8\x00\x00\x00\x00\x15I" +
+       "\x14\xd8\x00\x00\x00\x00\x168\xf7\xc8\x00\x00\x00\x00\x17(\xf6\xd8\x00\x00\x00\x00\x18\"\x14H\x00\x00\x00\x00\x19\b\xd8\xd8\x00\x00\x00\x00\x1a\x01\xf6H\x00\x00\x00\x00\x1a\xf1\xf5X\x00\x00\x00\x00\x1b\xe1\xd8H\x00\x00" +
+       "\x00\x00\x1c\xd1\xd7X\x00\x00\x00\x00\x1d\xc1\xbaH\x00\x00\x00\x00\x1e\xb1\xb9X\x00\x00\x00\x00\x1f\xa1\x9cH\x00\x00\x00\x00 u\xcf\xf4\x00\x00\x00\x00!\x81bd\x00\x00\x00\x00\"U\xb1\xf4\x00\x00\x00\x00#j" +
+       "p\xd4\x00\x00\x00\x00$5\x93\xf4\x00\x00\x00\x00%J`\xe4\x00\x00\x00\x00&\x15u\xf4\x00\x00\x00\x00'*B\xe4\x00\x00\x00\x00'\xfe\x92t\x00\x00\x00\x00)\n$\xe4\x00\x00\x00\x00)\xdett\x00\x00" +
+       "\x00\x00*\xea\x06\xe4\x00\x00\x00\x00+\xbeVt\x00\x00\x00\x00,\xd3#d\x00\x00\x00\x00-\x9e8t\x00\x00\x00\x00.\xb3\x05d\x00\x00\x00\x00/~\x1at\x00\x00\x00\x000\x92\xe7d\x00\x00\x00\x001g" +
+       "6\xf4\x00\x00\x00\x002r\xc9d\x00\x00\x00\x003G\x18\xf4\x00\x00\x00\x004R\xabd\x00\x00\x00\x005&\xfa\xf4\x00\x00\x00\x0062\x8dd\x00\x00\x00\x007\x06\xdc\xf4\x00\x00\x00\x008\x1b\xa9\xe4\x00\x00" +
+       "\x00\x008\xe6\xbe\xf4\x00\x00\x00\x009\xfb\x8b\xe4\x00\x00\x00\x00:Ơ\xf4\x00\x00\x00\x00;\xdbm\xe4\x00\x00\x00\x00<\xaf\xbdt\x00\x00\x00\x00=\xbbO\xe4\x00\x00\x00\x00>\x8f\x9ft\x00\x00\x00\x00?\x9b" +
+       "1\xe4\x00\x00\x00\x00@o\x81t\x00\x00\x00\x00A\x84Nd\x00\x00\x00\x00BOct\x00\x00\x00\x00Cd0d\x00\x00\x00\x00D/Et\x00\x00\x00\x00ED\x12d\x00\x00\x00\x00E\xf3w\xf4\x00\x00" +
+       "\x00\x00G-.\xe4\x00\x00\x00\x00G\xd3Y\xf4\x00\x00\x00\x00I\r\x10\xe4\x00\x00\x00\x00I\xb3;\xf4\x00\x00\x00\x00J\xec\xf2\xe4\x00\x00\x00\x00K\x9cXt\x00\x00\x00\x00L\xd6\x0fd\x00\x00\x00\x00M|" +
+       ":t\x00\x00\x00\x00N\xb6\rH\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x06\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xffΔ\x00\x00\xff\xffܤ\x01\x04\xff\xffΔ\x00\b\xff\xff\xdc\xd8\x01\x04\xff\xff\xce\xc8\x00\b\xff\xff\xdc\xd8\x01\f\xff\xff\xdc\xd8\x01\x10\xff" +
+       "\xff\xea\xe8\x01\x14LMT\x00NDT\x00NST\x00NPT\x00NWT\x00NDDT\x00\nNST3:30NDT,M3.2.0,M11.1.0\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RJtZ\x8c\x01\x03\x00\x00\x01\x03\x00\x00\x13\x00\x1c\x00America/PangnirtungUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\n\x00\x00\x00)\xff\xff\xff\xff\xa3\xd5R\x80\xff\xff\xff" +
+       "\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xf7/0@\xff\xff\xff\xff\xf8([\xc0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b" +
+       "\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00" +
+       "\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1" +
+       "\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00" +
+       "\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg" +
        "\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00" +
-       "\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb" +
-       "\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xba\x9e\x00\x00\xff\xff" +
-       "\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M1" +
-       "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1e+}\x15\xb4\x02\x00\x00\xb4\x02\x00\x00\x14\x00\x1c\x00America/Rankin_InletUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x05\x00\x00\x00\x15\xff" +
-       "\xff\xff\xff\xe7\x8cn\x00\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(w\xe0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17" +
-       ")\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00" +
-       "\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%" +
-       "J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00" +
-       "\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003" +
-       "GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00" +
-       "\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A" +
-       "\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xab\xa0\x00\t\xff" +
-       "\xff\xb9\xb0\x01\r\xff\xff\xb9\xb0\x00\x11-00\x00CDDT\x00CST\x00CDT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xfe7\xa1\x87\x1b\x01\x00\x00\x1b\x01\x00\x00\f\x00\x1c\x00America/LimaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xffi\x87#\xbc\xff\xff\xff\xff\x8ct@\xd4\xff\xff\xff" +
-       "\xff\xc3\xcfJP\xff\xff\xff\xff\xc4E\xe3@\xff\xff\xff\xff\xc5/J\xd0\xff\xff\xff\xff\xc6\x1f-\xc0\xff\xff\xff\xff\xc7\x0f,\xd0\xff\xff\xff\xff\xc7\xff\x0f\xc0\x00\x00\x00\x00\x1e\x18\xc4P\x00\x00\x00\x00\x1e\x8f]" +
-       "@\x00\x00\x00\x00\x1f\xf9\xf7\xd0\x00\x00\x00\x00 p\x90\xc0\x00\x00\x00\x00%\x9e\xe3\xd0\x00\x00\x00\x00&\x15|\xc0\x00\x00\x00\x00-%\x03P\x00\x00\x00\x00-\x9b\x9c@\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\xff\xff\xb7\xc4\x00\x00\xff\xff\xb7\xac\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\bLMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x1c\x00America/St_BarthelemyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff" +
-       "\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP\x0f(\b=\x01\x00\x00=\x01\x00\x00\x15\x00\x1c\x00America/Sant" +
-       "o_DomingoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x11\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xffi\x87\x1d\b\xff\xff\xff\xff\xba\xdfB`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xa7\xc3@\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00C{\xc8" +
-       "\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x01\xfa\u007fH\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x03\xdd\x04H\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x05\xbf\x89H\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00" +
-       "\a\xa0\xbc\xc8\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:)\xe1`\x01\x03\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05\x03\x05\xff\xff\xbex\x00\x00\xff\xff\xbe`\x00\x04\xff\xff\xc7" +
-       "\xc0\x01\t\xff\xff\xb9\xb0\x00\r\xff\xff\xc0\xb8\x01\x11\xff\xff\xc7\xc0\x00\x17LMT\x00SDMT\x00EDT\x00EST\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x1c\x00America/DetroitUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x85\xbd\"[\xff\xff\xff\xff\x99<\x94\x00\xff\xff" +
-       "\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xfb3\x90\x8c\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8" +
-       ":\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00" +
-       "\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12y" +
-       "H\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00" +
-       "\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v" +
-       "\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00" +
-       "\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb3" +
-       "6`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00" +
-       "\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf" +
-       "\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00" +
-       "\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
-       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\xff\xff\xb2%\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b" +
-       "\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00EST\x00EWT\x00EPT\x00EDT\x00\nEST5EDT,M3.2.0,M1" +
-       "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\xf9\x1dɻ\x00\x00\x00\xbb\x00\x00\x00\x12\x00\x1c\x00America/ParamariboUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x12\xff\xff\xff" +
-       "\xff\x91\x05\x8e\xb8\xff\xff\xff\xff\xbe*K\xc4\xff\xff\xff\xff\xd2b,\xb4\x00\x00\x00\x00\x1b\xbe1\xb8\x01\x02\x03\x04\xff\xff\xccH\x00\x00\xff\xff\xcc<\x00\x04\xff\xff\xccL\x00\x04\xff\xff\xce\xc8\x00\b\xff\xff\xd5" +
-       "\xd0\x00\x0eLMT\x00PMT\x00-0330\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00\x00\x0f\x00\x1c\x00A" +
-       "merica/YakutatUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\b\x00\x00\x00\x1e\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x877\xbf\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff" +
-       "\xff\xfe\xb8U0\xff\xff\xff\xff\xff\xa88 \x00\x00\x00\x00\x00\x9870\x00\x00\x00\x00\x01\x88\x1a \x00\x00\x00\x00\x02x\x190\x00\x00\x00\x00\x03q6\xa0\x00\x00\x00\x00\x04a5\xb0\x00\x00\x00\x00\x05Q\x18" +
-       "\xa0\x00\x00\x00\x00\x06A\x17\xb0\x00\x00\x00\x00\a0\xfa\xa0\x00\x00\x00\x00\a\x8dQ\xb0\x00\x00\x00\x00\t\x10ܠ\x00\x00\x00\x00\t\xad\xcd0\x00\x00\x00\x00\n\xf0\xbe\xa0\x00\x00\x00\x00\v\u0f70\x00\x00\x00" +
-       "\x00\f\xd9\xdb \x00\x00\x00\x00\r\xc0\x9f\xb0\x00\x00\x00\x00\x0e\xb9\xbd \x00\x00\x00\x00\x0f\xa9\xbc0\x00\x00\x00\x00\x10\x99\x9f \x00\x00\x00\x00\x11\x89\x9e0\x00\x00\x00\x00\x12y\x81 \x00\x00\x00\x00\x13i\x80" +
-       "0\x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x15Ib0\x00\x00\x00\x00\x169E \x00\x00\x00\x00\x17)D0\x00\x00\x00\x00\x18\"a\xa0\x00\x00\x00\x00\x19\t&0\x00\x00\x00\x00\x1a\x02C\xa0\x00\x00\x00" +
-       "\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v9" +
-       "0\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00" +
-       "\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n" +
-       "\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00" +
-       "\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&" +
-       "\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00" +
-       "\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\a\x06\a\x06" +
-       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\x00\x00\u0381\x00\x00\xff\xff}\x01\x00\x00\xff\xff\x81p" +
-       "\x00\x04\xff\xff\x8f\x80\x01\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x8f\x80\x01\x14\xff\xff\x81p\x00\x19LMT\x00YST\x00YWT\x00YPT\x00YDT\x00AKDT\x00AKS" +
-       "T\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x04,2h\x99\x01\x00\x00\x99\x01\x00\x00\x10\x00\x1c\x00Am" +
-       "erica/SantaremUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaazH\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff" +
-       "\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA" +
-       "0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff" +
-       "\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w" +
-       "@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00H`q@\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\xff\xff̸\x00\x00\xff\xff\xd5\xd0\x01\x04\xff" +
-       "\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x00\x04LMT\x00-03\x00-04\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk^2S\xb9\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x1c" +
-       "\x00America/Punta_ArenasUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb" +
+       "\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x03\x01\x02" +
+       "\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\a\x06\a\x06\a\x06\a\x06\b\t\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\x00\x00" +
+       "\x00\x00\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x01\x15\xff\xff\xc7\xc0\x01\x19\xff\xff\xb9\xb0\x00\x1d\xff\xff\xab\xa0\x00!\xff\xff\xb9\xb0\x01%-0" +
+       "0\x00AWT\x00APT\x00AST\x00ADDT\x00ADT\x00EDT\x00EST\x00CST\x00CDT\x00\nEST5EDT,M3.2.0,M11.1" +
+       ".0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RU\xactA\xb5\x01\x00\x00\xb5\x01\x00\x00\x11\x00\x1c\x00America/MatamorosUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa5\xb6\xda" +
+       "`\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00" +
+       "\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc" +
+       "\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00" +
+       "\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00F\x0ff\x80\x00\x00\x00\x00G$3p\x00\x00\x00\x00G\xf8\x83\x00\x00\x00\x00\x00I\x04\x15p\x00\x00\x00\x00I\xd8e\x00\x00\x00\x00\x00J\xe3\xf7" +
+       "p\x00\x00\x00\x00K\x9c\x97\x80\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xa2@\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x01\bL" +
+       "MT\x00CST\x00CDT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rs\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00" +
+       "\x00\x10\x00\x1c\x00America/EirunepeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00t\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1d\xfc\xff\xff\xff\xff\x8f0GF\xff\xff\xff\xff\x9b\\\xe5P\xff\xff\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff" +
-       "\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@\xff\xff\xff\xff\xb2A\x00\xd0\xff\xff\xff\xff\xb3Xp\xc0\xff\xff\xff\xff\xb4\"4P\xff\xff\xff\xff\xb59\xa4@\xff\xff\xff\xff\xb6\x03g\xd0" +
-       "\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xc7 P\xff\xff\xff\xff\xcc\x1cn@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff\xff\xff\xd53U\xc0\xff\xff\xff\xff" +
-       "\xd5v\x92@\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0" +
-       "\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00" +
-       "\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940" +
-       "\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00" +
-       "\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @" +
-       "\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00" +
-       "&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0" +
-       "\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x00" +
-       "5\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0" +
-       "\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00" +
-       "CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0" +
-       "\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00" +
-       "Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00XC\x86\xb0\x01\x02\x01\x03\x01\x04\x02\x04" +
-       "\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
-       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x06\xff\xff\xbd\x84\x00\x00\xff\xff\xbd\xba\x00\x04" +
-       "\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10\xff\xff\xd5\xd0\x00\x10LMT\x00SMT\x00-05\x00-04\x00-03\x00\n<-03>3\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00\x00\x14\x00\x1c\x00America/ScoresbysundUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x9b\x80L\x18\x00" +
-       "\x00\x00\x00\x13Mn@\x00\x00\x00\x00\x144$\xc0\x00\x00\x00\x00\x15#\xf9\xa0\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19" +
-       "Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00" +
-       "\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'" +
-       "\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00" +
-       "\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xff\xeb" +
-       "h\x00\x00\xff\xff\xe3\xe0\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x01\fLMT\x00-02\x00-01\x00+00\x00\n<-01>1<+00>,M3.5" +
-       ".0/0,M10.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x10\x00\x1c\x00America/Santiag" +
-       "oUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x00\x00\x00\x06" +
-       "\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1d\xc6\xff\xff\xff\xff\x8f0GF\xff\xff\xff\xff\x9b\\\xe5P\xff\xff\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@" +
-       "\xff\xff\xff\xff\xb2A\x00\xd0\xff\xff\xff\xff\xb3Xp\xc0\xff\xff\xff\xff\xb4\"4P\xff\xff\xff\xff\xb59\xa4@\xff\xff\xff\xff\xb6\x03g\xd0\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff" +
-       "\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xc7 P\xff\xff\xff\xff\xcc\x1cn@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff\xff\xff\xd3\u070f\xc0\xff\xff\xff\xff\xd4\x1bɰ\xff\xff\xff\xff\xd53U\xc0\xff\xff\xff\xff\xd5v\x92@" +
-       "\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00" +
-       "\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@" +
-       "\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00" +
-       "\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0" +
-       "\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00" +
-       " \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0" +
-       "\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00" +
-       ".\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0" +
-       "\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00" +
-       "<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0" +
-       "\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00" +
-       "J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0" +
-       "\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00" +
-       "Z\xf7\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x02\x01\x03\x01\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x05\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
-       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
-       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\xff\xff\xbd\xba\x00\x00\xff\xff\xbd\xba\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10LM" +
-       "T\x00SMT\x00-05\x00-04\x00-03\x00\n<-04>4<-03>,M9.1.6/24,M4.1.6/24\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x15\xc8\xcb\x00\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x1c\x00America/GuyanaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x98\xd9y\x88\x00\x00\x00\x00\n}\xb4<\x00\x00\x00\x00'\u007f" +
-       "\xfb0\x01\x02\x03\xff\xff\xc9x\x00\x00\xff\xff\xcbD\x00\x04\xff\xff\xd5\xd0\x00\n\xff\xff\xc7\xc0\x00\x0eLMT\x00-0345\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x15\x00\x1c\x00America/Coral_HarbourUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x84d\xff\xff\xff" +
-       "\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\x02\x01\x02\x01\x03\x04\x05\xff\xff\xaa\x1c\x00\x00\xff\xff" +
-       "\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/Rio_BrancoUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff" +
-       "\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu" +
-       "@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff" +
-       "\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪ" +
-       "P\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00" +
-       "-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/Porto_Acre" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x04\x00" +
-       "\x00\x00\f\xff\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff" +
-       "\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5" +
-       "\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff" +
-       "\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00H" +
-       "`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b" +
-       "\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQp\x1b\xceRC\x03\x00\x00C\x03\x00\x00\x0f\x00\x1c\x00Amer" +
-       "ica/NipigonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00J\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xee\x81@\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xc8\xf8IP\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#" +
-       "\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00" +
-       "\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y" +
-       "*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00" +
-       "\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U" +
-       "\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00" +
-       "\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93" +
-       "\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00" +
-       "\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f" +
-       "\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00" +
-       "\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad@\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00ES" +
-       "T\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00" +
-       "\x10\x00\x1c\x00America/EdmontonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x88\x80\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff" +
+       "\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP" +
+       "\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff" +
+       "\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0" +
+       "\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00,\xc0\xd1P\x00\x00\x00\x00-f\xe0@\x00\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xbe\x80\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-" +
+       "05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x10\x00\x1c\x00America/ShiprockUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04" +
+       "\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff" +
+       "\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b" +
+       "v\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00" +
+       "\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d" +
+       "5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00" +
+       "\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169" +
+       ")\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00" +
+       "\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5" +
+       "\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00" +
+       "\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s" +
+       "\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00" +
+       "\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o" +
+       "ΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03" +
+       "\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT" +
+       "\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe90T\x16\xd1" +
+       "\x01\x00\x00\xd1\x01\x00\x00\x0f\x00\x1c\x00America/GodthabUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb" +
+       "\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00" +
+       "\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E" +
+       "\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00" +
+       "\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9" +
+       "\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00-03" +
+       "\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RU\r\xf7\xd3\xc7\x01\x00" +
+       "\x00\xc7\x01\x00\x00\r\x00\x1c\x00America/ThuleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80w\xfc\x00\x00\x00\x00'\xf5z\xe0\x00\x00\x00\x00(\xe5]\xd0\x00\x00\x00\x00)\xd5\\\xe0\x00\x00\x00" +
+       "\x00*\xc5?\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001gY" +
+       "\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00" +
+       "\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT" +
+       "\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xbf\x84\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00ADT\x00AST" +
+       "\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe5s\xb3\\'\x01\x00\x00'\x01\x00\x00\x0f\x00\x1c\x00Ameri" +
+       "ca/ManaguaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x10\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffi\x87,d\xff\xff\xff\xff\xbd-H\xe8\x00\x00\x00\x00\x06Ct`\x00\x00\x00\x00\t\xa4>P\x00\x00\x00\x00\x11Q\xf8\xe0\x00\x00\x00\x00\x11\xd4o" +
+       "P\x00\x00\x00\x00\x131\xda\xe0\x00\x00\x00\x00\x13\xb4QP\x00\x00\x00\x00)a\x91 \x00\x00\x00\x00*\xc1KP\x00\x00\x00\x00+C\xdd\xe0\x00\x00\x00\x002\xc9\xefP\x00\x00\x00\x00BX\xc0\xe0\x00\x00\x00" +
+       "\x00C?iP\x00\x00\x00\x00DTn\x80\x00\x00\x00\x00E\x1fY`\x01\x02\x03\x02\x04\x02\x04\x02\x03\x02\x03\x02\x04\x02\x04\x02\xff\xff\xaf\x1c\x00\x00\xff\xff\xaf\x18\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x00" +
+       "\f\xff\xff\xb9\xb0\x01\x10LMT\x00MMT\x00CST\x00EST\x00CDT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RM\x94\xc7Kp\x03\x00\x00p\x03\x00\x00\x11" +
+       "\x00\x1c\x00America/Glace_BayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x88\xde\xce\xe0\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x98\x91\x90\xff\xff\xff\xff\xa0" +
-       "҅\x80\xff\xff\xff\xff\xa2\x8a\xe8\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4jʐ\xff\xff\xff\xff\xa55À\xff\xff\xff\xff\xa6S\xe7\x10\xff\xff\xff\xff\xa7\x15\xa5\x80\xff\xff\xff\xff\xa83\xc9\x10\xff" +
-       "\xff\xff\xff\xa8\xfe\xc2\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05" +
-       "P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b ݐ\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\n\x00\xbf\x90\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00" +
-       "\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13" +
-       "id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00" +
-       "\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!" +
-       "\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00" +
-       "\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/" +
-       "~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00" +
-       "\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=" +
-       "\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00" +
-       "\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x95\xa0\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90" +
-       "\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x1c\x00America/Port_of_SpainUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac" +
-       "\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x15\x00\x1c\x00Ame" +
-       "rica/Lower_PrincesUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\nLMT" +
-       "\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x1c\x00America/St_Th" +
-       "omasUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xac\x8a\x83S" +
-       "\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x1c\x00America/GuatemalaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9f\x9d\xea\xdc\x00\x00\x00\x00\aU\xac`\x00\x00\x00\x00\a͖\xd0\x00\x00\x00\x00" +
-       "\x19,x`\x00\x00\x00\x00\x19\xcf\xe4P\x00\x00\x00\x00'\xea\xee\xe0\x00\x00\x00\x00(\xc8\\\xd0\x00\x00\x00\x00DTR`\x00\x00\x00\x00E\x1fKP\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xab$\x00\x00\xff" +
-       "\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x11\x00\x1c\x00A" +
-       "merica/CatamarcaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff" +
-       "\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf" +
-       "\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff" +
-       "\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3" +
-       ")5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff" +
-       "\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff" +
-       "\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00" +
-       "\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@" +
-       "\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff" +
-       "\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00" +
-       "\x1c\x00America/AntiguaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\x1b\x81-\xa9\x8a\x01\x00\x00\x8a\x01\x00\x00\x13\x00\x1c\x00America/Porto_VelhoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x82\xe8\xff\xff\xff\xff\xb8" +
-       "\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff" +
-       "\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7" +
-       "\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00" +
-       "\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xc4\x18\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/RosarioUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff" +
-       "\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9" +
-       "\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff" +
-       "\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM" +
-       "\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff" +
-       "\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xac" +
-       "R@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00" +
-       "\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6" +
-       "ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00" +
-       "\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00\x1c\x00America/ChicagoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff" +
-       "\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa2\xcbt\x00\xff\xff\xff\xff\xa3\x83\xf7\xf0\xff\xff\xff\xff\xa4EҀ\xff\xff\xff\xff\xa5c\xd9\xf0\xff\xff\xff\xff\xa6S\xd9\x00\xff\xff\xff\xff\xa7" +
-       "\x15\x97p\xff\xff\xff\xff\xa83\xbb\x00\xff\xff\xff\xff\xa8\xfe\xb3\xf0\xff\xff\xff\xff\xaa\x13\x9d\x00\xff\xff\xff\xff\xaaޕ\xf0\xff\xff\xff\xff\xab\xf3\u007f\x00\xff\xff\xff\xff\xac\xbew\xf0\xff\xff\xff\xff\xad\xd3a\x00\xff" +
-       "\xff\xff\xff\xae\x9eY\xf0\xff\xff\xff\xff\xaf\xb3C\x00\xff\xff\xff\xff\xb0~;\xf0\xff\xff\xff\xff\xb1\x9c_\x80\xff\xff\xff\xff\xb2gXp\xff\xff\xff\xff\xb3|A\x80\xff\xff\xff\xff\xb4G:p\xff\xff\xff\xff\xb5" +
-       "\\#\x80\xff\xff\xff\xff\xb6'\x1cp\xff\xff\xff\xff\xb7<\x05\x80\xff\xff\xff\xff\xb8\x06\xfep\xff\xff\xff\xff\xb9\x1b\xe7\x80\xff\xff\xff\xff\xb9\xe6\xe0p\xff\xff\xff\xff\xbb\x05\x04\x00\xff\xff\xff\xff\xbb\xc6\xc2p\xff" +
-       "\xff\xff\xff\xbc\xe4\xe6\x00\xff\xff\xff\xff\xbd\xaf\xde\xf0\xff\xff\xff\xff\xbe\xc4\xc8\x00\xff\xff\xff\xff\xbf\x8f\xc0\xf0\xff\xff\xff\xff\xc0Z\xd6\x00\xff\xff\xff\xff\xc1\xb0<p\xff\xff\xff\xff\u0084\x8c\x00\xff\xff\xff\xff\xc3" +
-       "O\x84\xf0\xff\xff\xff\xff\xc4dn\x00\xff\xff\xff\xff\xc5/f\xf0\xff\xff\xff\xff\xc6M\x8a\x80\xff\xff\xff\xff\xc7\x0fH\xf0\xff\xff\xff\xff\xc8-l\x80\xff\xff\xff\xff\xc8\xf8ep\xff\xff\xff\xff\xca\rN\x80\xff" +
-       "\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6" +
-       " \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff" +
-       "\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4" +
-       "^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xf6\xe2\xf0\xff" +
-       "\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2" +
-       "\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x85\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff" +
-       "\xff\xff\xff\xfa\bg\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00" +
-       "\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00" +
-       "\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e" +
-       "\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00" +
-       "\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c" +
-       "\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00" +
-       "\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*" +
-       "\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00" +
-       "\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008" +
-       "\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00" +
-       "\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xa84\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2" +
+       "#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00\x00\x00\x00\a0\xb4P\x00" +
+       "\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e" +
+       "\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00" +
+       "\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c" +
+       "\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00" +
+       "\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*" +
+       "\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001gY\xe0\x00" +
+       "\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008" +
+       "\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00" +
+       "\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x03\x04" +
        "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad\xd4\x00\x00\xff\xff\xb9\xb0" +
-       "\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00CDT\x00CST\x00EST\x00CWT\x00CPT\x00\nCST6CDT,M" +
-       "3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ⚵\xfb\x9e\x00\x00\x00\x9e\x00\x00\x00\x0f\x00\x1c\x00America/CrestonU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00" +
-       "\x00\f\xff\xff\xff\xff^=p\xbc\xff\xff\xff\xff\x9b\xd6Kp\xff\xff\xff\xff\x9e\xf9;\x00\x01\x02\x01\xff\xff\x92\xc4\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\bLMT\x00MST\x00PST\x00\n" +
-       "MST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe5s\xb3\\'\x01\x00\x00'\x01\x00\x00\x0f\x00\x1c\x00America/ManaguaUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffi\x87," +
-       "d\xff\xff\xff\xff\xbd-H\xe8\x00\x00\x00\x00\x06Ct`\x00\x00\x00\x00\t\xa4>P\x00\x00\x00\x00\x11Q\xf8\xe0\x00\x00\x00\x00\x11\xd4oP\x00\x00\x00\x00\x131\xda\xe0\x00\x00\x00\x00\x13\xb4QP\x00\x00\x00" +
-       "\x00)a\x91 \x00\x00\x00\x00*\xc1KP\x00\x00\x00\x00+C\xdd\xe0\x00\x00\x00\x002\xc9\xefP\x00\x00\x00\x00BX\xc0\xe0\x00\x00\x00\x00C?iP\x00\x00\x00\x00DTn\x80\x00\x00\x00\x00E\x1fY" +
-       "`\x01\x02\x03\x02\x04\x02\x04\x02\x03\x02\x03\x02\x04\x02\x04\x02\xff\xff\xaf\x1c\x00\x00\xff\xff\xaf\x18\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10LMT\x00MMT\x00CST\x00E" +
-       "ST\x00CDT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x05{w\xe9\xad\x03\x00\x00\xad\x03\x00\x00\x0e\x00\x1c\x00America/NassauUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x03\x00\x00\x00\f" +
-       "\xff\xff\xff\xff\x937B\x8a\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff" +
-       "\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0" +
-       "\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00" +
-       "\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0" +
-       "\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00" +
-       "\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`" +
-       "\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00" +
-       "%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p" +
-       "\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x00" +
-       "3GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0" +
-       "\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00" +
-       "A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xb7v\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\bLMT\x00EDT\x00EST\x00\nEST5EDT,M3.2.0,M1" +
-       "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQc)\xf6)\xb3\x00\x00\x00\xb3\x00\x00\x00\x0e\x00\x1c\x00America/BogotaUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff^\x9c4" +
-       "\xf0\xff\xff\xff\xff\x98XUp\x00\x00\x00\x00*\x03sP\x00\x00\x00\x00+\xbe]@\x01\x03\x02\x03\xff\xff\xba\x90\x00\x00\xff\xff\xba\x90\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00BMT" +
-       "\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf2\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00\x00\x0e\x00\x1c\x00America/Cancu" +
-       "nUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00*\x00\x00\x00\x05" +
-       "\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\x16\x86\xd5`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0" +
-       "\x00\x00\x00\x005\xc4\x00`\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00" +
-       ";\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80" +
-       "\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00F\x0ff\x80\x00\x00\x00\x00G$3p\x00\x00\x00\x00G\xf8\x83\x00\x00\x00\x00\x00I\x04\x15p\x00\x00\x00\x00" +
-       "I\xd8e\x00\x00\x00\x00\x00J\xe3\xf7p\x00\x00\x00\x00K\xb8G\x00\x00\x00\x00\x00L\xcd\x13\xf0\x00\x00\x00\x00M\x98)\x00\x00\x00\x00\x00N\xac\xf5\xf0\x00\x00\x00\x00Ox\v\x00\x00\x00\x00\x00P\x8c\xd7\xf0" +
-       "\x00\x00\x00\x00Qa'\x80\x00\x00\x00\x00Rl\xb9\xf0\x00\x00\x00\x00SA\t\x80\x00\x00\x00\x00TL\x9b\xf0\x00\x00\x00\x00T\xcd\xdd\x00\x01\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
-       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\xff\xff\xae\xa8\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10LMT\x00CST\x00" +
-       "EDT\x00EST\x00CDT\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x1c\x00America/Chih" +
-       "uahuaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13" +
-       "\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\x00\x00\x00\x00" +
-       "1gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00" +
-       "\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff" +
-       "\xff\x9c\x8c\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00CDT\x00MDT\x00\nMST7MDT,M4" +
-       ".1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00\x00\x14\x00\x1c\x00America/Campo_Gra" +
-       "ndeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00" +
-       "\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaaz4\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec" +
-       "\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff" +
-       "\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec" +
-       "\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00" +
-       "\x00\x00#X\x1e\xc0\x00\x00\x00\x00#\xe2~0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xd4\xd50\x00\x00\x00\x00'!\x1d@\x00\x00\x00\x00'\xbd\xf1\xb0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\x94" +
-       "\x990\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+k@\xb0\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x00\x00\x00\x00.\xa0\xa5@\x00\x00\x00\x00/F\xb40\x00\x00\x00\x000\x80\x87@\x00\x00" +
-       "\x00\x001\x1d[\xb0\x00\x00\x00\x002W.\xc0\x00\x00\x00\x003\x06x0\x00\x00\x00\x0048b@\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006 -@\x00\x00\x00\x006\xcfv\xb0\x00\x00\x00\x007\xf6" +
-       "\xd4\xc0\x00\x00\x00\x008\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x00:\x8f:\xb0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<o\x1c\xb0\x00\x00\x00\x00=ğ@\x00\x00\x00\x00>N\xfe\xb0\x00\x00" +
-       "\x00\x00?\x92\f@\x00\x00\x00\x00@.\xe0\xb0\x00\x00\x00\x00A\x87\x06@\x00\x00\x00\x00B\x17\xfd0\x00\x00\x00\x00CQ\xd0@\x00\x00\x00\x00C\xf7\xdf0\x00\x00\x00\x00EMa\xc0\x00\x00\x00\x00E\xe0" +
-       "\xfb\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xb7\xa30\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\x97\x850\x00\x00\x00\x00Jڒ\xc0\x00\x00\x00\x00K\x80\xa1\xb0\x00\x00\x00\x00L\xbat\xc0\x00\x00" +
-       "\x00\x00M`\x83\xb0\x00\x00\x00\x00N\x9aV\xc0\x00\x00\x00\x00OI\xa00\x00\x00\x00\x00P\x83s@\x00\x00\x00\x00Q G\xb0\x00\x00\x00\x00RcU@\x00\x00\x00\x00S\x00)\xb0\x00\x00\x00\x00TC" +
-       "7@\x00\x00\x00\x00T\xe9F0\x00\x00\x00\x00V#\x19@\x00\x00\x00\x00V\xc9(0\x00\x00\x00\x00X\x02\xfb@\x00\x00\x00\x00X\xa9\n0\x00\x00\x00\x00Y\xe2\xdd@\x00\x00\x00\x00Z\x88\xec0\x00\x00" +
-       "\x00\x00[\xden\xc0\x00\x00\x00\x00\\h\xce0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xcc\xcc\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7" +
-       "\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x1c\x00America" +
-       "/HalifaxUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa7\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xab\xa0\xff\xff\xff\xff\x9a\xe4\xde\xc0\xff\xff\xff\xff\x9b\xd6\x130\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xff\xa2\x9d\x17@\xff" +
-       "\xff\xff\xff\xa30\xb10\xff\xff\xff\xff\xa4zV@\xff\xff\xff\xff\xa5\x1b\x1f0\xff\xff\xff\xff\xa6S\xa0\xc0\xff\xff\xff\xff\xa6\xfcR\xb0\xff\xff\xff\xff\xa8<\xbd@\xff\xff\xff\xff\xa8\xdc4\xb0\xff\xff\xff\xff\xaa" +
-       "\x1c\x9f@\xff\xff\xff\xff\xaa\xcd:0\xff\xff\xff\xff\xab\xfc\x81@\xff\xff\xff\xff\xac\xbf\x910\xff\xff\xff\xff\xad\xee\xd8@\xff\xff\xff\xff\xae\x8c\xfe0\xff\xff\xff\xff\xaf\xbcE@\xff\xff\xff\xff\xb0\u007fU0\xff" +
-       "\xff\xff\xff\xb1\xae\x9c@\xff\xff\xff\xff\xb2Kp\xb0\xff\xff\xff\xff\xb3\x8e~@\xff\xff\xff\xff\xb4$\xbb0\xff\xff\xff\xff\xb5n`@\xff\xff\xff\xff\xb6\x15\xc0\xb0\xff\xff\xff\xff\xb7NB@\xff\xff\xff\xff\xb8" +
-       "\b\x17\xb0\xff\xff\xff\xff\xb9$\xe9\xc0\xff\xff\xff\xff\xb9\xe7\xf9\xb0\xff\xff\xff\xff\xbb\x04\xcb\xc0\xff\xff\xff\xff\xbb\xd1\x160\xff\xff\xff\xff\xbd\x00]@\xff\xff\xff\xff\xbd\x9d1\xb0\xff\xff\xff\xff\xbe\xf2\xb4@\xff" +
-       "\xff\xff\xff\xbf\x90\xda0\xff\xff\xff\xff\xc0\xd3\xe7\xc0\xff\xff\xff\xff\xc1^G0\xff\xff\xff\xff\u008d\x8e@\xff\xff\xff\xff\xc3P\x9e0\xff\xff\xff\xff\xc4mp@\xff\xff\xff\xff\xc50\x800\xff\xff\xff\xff\xc6" +
-       "r<@\xff\xff\xff\xff\xc7\x10b0\xff\xff\xff\xff\xc86n\xc0\xff\xff\xff\xff\xc8\xf9~\xb0\xff\xff\xff\xff\xca\x16P\xc0\xff\xff\xff\xff\xca\xd9`\xb0\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff" +
-       "\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@\xcf\xd0\xff\xff\xff\xff\xd5U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9" +
-       "\x15|\xe0\xff\xff\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xdc\xde{`\xff\xff\xff\xffݩtP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\xff" +
-       "\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3I\x1aP\xff\xff\xff\xff\xe6G\x1f\xe0\xff\xff\xff\xff\xe7\x12\x18\xd0\xff\xff\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe8\xf1\xfa\xd0\xff\xff\xff\xff\xea\x06\xe3\xe0\xff\xff\xff\xff\xea" +
-       "\xd1\xdc\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff챾\xd0\xff\xff\xff\xff\xf1\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_kP\xff\xff\xff\xff\xf5Oj`\xff" +
-       "\xff\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(i\xd0\xff\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc" +
-       "\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00" +
-       "\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n" +
-       "\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00" +
-       "\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19" +
-       "\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00" +
-       "\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'" +
-       "*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00" +
-       "\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005" +
-       "'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00" +
-       "\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00C" +
-       "dSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc4`\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00" +
-       "APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00\x00\r\x00\x1c\x00Am" +
-       "erica/BoiseUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc7\xcc\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00" +
+       "APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R⚵\xfb\x9e\x00\x00\x00\x9e\x00\x00\x00\x0f\x00\x1c\x00Am" +
+       "erica/CrestonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff^=p\xbc\xff\xff\xff\xff\x9b\xd6Kp\xff\xff\xff\xff\x9e\xf9;\x00\x01\x02\x01\xff\xff\x92\xc4\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00" +
+       "\bLMT\x00MST\x00PST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x1c\x00America/Her" +
+       "mosilloUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x0f\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff" +
+       "\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'" +
+       "H\x10\x00\x00\x00\x0062ڀ\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\xff\xff\x97\xf8\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00M" +
+       "ST\x00CST\x00PST\x00MDT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x14\x00\x1c\x00America/S" +
+       "anta_IsabelUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00Z\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xff\xa8F" +
-       "L \xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff" +
-       "\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P" +
-       "\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\xb2\x1f\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00" +
-       "\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13i" +
-       "d\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00" +
-       "\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81" +
-       "\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00" +
-       "\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~" +
-       "g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00" +
-       "\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb" +
-       "\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00" +
-       "\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x05\x03\x04\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\x93\x0f\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80" +
-       "\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\x9d\x90\x00\x14\xff\xff\xab\xa0\x01\x18LMT\x00PDT\x00PST\x00MWT\x00MPT\x00MST\x00MDT\x00\nMST7M" +
-       "DT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x1c\x00America/Mont" +
-       "realUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00" +
-       "\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06\xf0\xff\xff\xff\xff\xa3" +
-       "U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff\xff\xaa\x1c\xc9p\xff" +
-       "\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad܍p\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1" +
-       "\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff" +
-       "\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf" +
-       "\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|p\xff" +
-       "\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5" +
-       "U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdc\x13t`\xff" +
-       "\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3" +
-       "I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff" +
-       "\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1" +
-       "\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff" +
-       "\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff" +
-       "\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00" +
-       "\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r" +
-       "\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00" +
-       "\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b" +
-       "\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00" +
-       "\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)" +
-       "ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00" +
-       "\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008" +
-       "\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00" +
-       "\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E" +
-       "\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xb5\x94\x00" +
-       "\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0" +
-       ",M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x1c\x00America/Goose_BayUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\n\x00\x00\x00!\xff" +
-       "\xff\xff\xff^=<$\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff\xff\xff\x9f\xba\xd6|\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff\xff\u0098\x138\xff\xff\xff\xff\xc3" +
-       "YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2(\xff\xff\xff\xff\xca ո\xff" +
-       "\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff\xff\xd5h&\xd8\xff\xff\xff\xff\xd6" +
-       ")\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5\xc8\xff\xff\xff\xff\xdc\xdetX\xff" +
-       "\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff\xff\xe3I\x13H\xff\xff\xff\xff\xe4" +
-       "]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc\xd8\xff\xff\xff\xff\xea\xd1\xd5\xc8\xff" +
-       "\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffeH\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff\xff\xf1\x8f\x9fX\xff\xff\xff\xff\xf2" +
-       "\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b\xc8\xff\xff\xff\xff\xf8\xdakX\xff" +
-       "\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff" +
-       "\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00" +
-       "\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r" +
-       "\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00" +
-       "\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b" +
-       "\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xd6\xfc\x00\x00\x00\x00!\x81il\x00\x00\x00\x00\"U\xb8\xfc\x00" +
-       "\x00\x00\x00#jw\xdc\x00\x00\x00\x00$5\x9a\xfc\x00\x00\x00\x00%Jg\xec\x00\x00\x00\x00&\x15|\xfc\x00\x00\x00\x00'*I\xec\x00\x00\x00\x00'\xfe\x99|\x00\x00\x00\x00)\n+\xec\x00\x00\x00\x00)" +
-       "\xde{|\x00\x00\x00\x00*\xea\r\xec\x00\x00\x00\x00+\xbe]|\x00\x00\x00\x00,\xd3*l\x00\x00\x00\x00-\x9e?|\x00\x00\x00\x00.\xb3\fl\x00\x00\x00\x00/~!|\x00\x00\x00\x000\x92\xeel\x00" +
-       "\x00\x00\x001g=\xfc\x00\x00\x00\x002r\xd0l\x00\x00\x00\x003G\x1f\xfc\x00\x00\x00\x004R\xb2l\x00\x00\x00\x005'\x01\xfc\x00\x00\x00\x0062\x94l\x00\x00\x00\x007\x06\xe3\xfc\x00\x00\x00\x008" +
-       "\x1b\xb0\xec\x00\x00\x00\x008\xe6\xc5\xfc\x00\x00\x00\x009\xfb\x92\xec\x00\x00\x00\x00:Ƨ\xfc\x00\x00\x00\x00;\xdbt\xec\x00\x00\x00\x00<\xaf\xc4|\x00\x00\x00\x00=\xbbV\xec\x00\x00\x00\x00>\x8f\xa6|\x00" +
-       "\x00\x00\x00?\x9b8\xec\x00\x00\x00\x00@o\x88|\x00\x00\x00\x00A\x84Ul\x00\x00\x00\x00BOj|\x00\x00\x00\x00Cd7l\x00\x00\x00\x00D/L|\x00\x00\x00\x00ED\x19l\x00\x00\x00\x00E" +
-       "\xf3~\xfc\x00\x00\x00\x00G-5\xec\x00\x00\x00\x00G\xd3`\xfc\x00\x00\x00\x00I\r\x17\xec\x00\x00\x00\x00I\xb3B\xfc\x00\x00\x00\x00J\xec\xf9\xec\x00\x00\x00\x00K\x9c_|\x00\x00\x00\x00L\xd6\x16l\x00" +
-       "\x00\x00\x00M|A|\x00\x00\x00\x00N\xb6\x14P\x01\x02\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\t" +
-       "\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\xff\xff\xc7\\\x00\x00\xff\xffΔ\x00\x04\xff" +
-       "\xffܤ\x01\b\xff\xff\xce\xc8\x00\x04\xff\xff\xdc\xd8\x01\b\xff\xff\xdc\xd8\x01\f\xff\xff\xdc\xd8\x01\x10\xff\xff\xd5\xd0\x01\x14\xff\xff\xc7\xc0\x00\x18\xff\xff\xe3\xe0\x01\x1cLMT\x00NST\x00NDT\x00N" +
-       "PT\x00NWT\x00ADT\x00AST\x00ADDT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9d?" +
-       "\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\x11\x00\x1c\x00America/Sao_PauloUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaar\xb4\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff" +
-       "\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ" +
-       "\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4Z\t0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff" +
-       "\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa0" +
-       "5\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00" +
-       "\x00\x00'!\x0f0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00,\xc0\xb50\x00\x00\x00\x00-f" +
-       "\xc4 \x00\x00\x00\x00.\xa0\x970\x00\x00\x00\x00/F\xa6 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00" +
-       "\x00\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8" +
-       "\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00?\x91\xfe0\x00\x00\x00\x00@.Ҡ\x00\x00\x00\x00A\x86\xf80\x00\x00\x00\x00B\x17\xef \x00\x00" +
-       "\x00\x00CQ\xc20\x00\x00\x00\x00C\xf7\xd1 \x00\x00\x00\x00EMS\xb0\x00\x00\x00\x00E\xe0\xed\xa0\x00\x00\x00\x00G\x11\x860\x00\x00\x00\x00G\xb7\x95 \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\x97" +
-       "w \x00\x00\x00\x00Jڄ\xb0\x00\x00\x00\x00K\x80\x93\xa0\x00\x00\x00\x00L\xbaf\xb0\x00\x00\x00\x00M`u\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x00\x00\x00\x00P\x83e0\x00\x00" +
-       "\x00\x00Q 9\xa0\x00\x00\x00\x00RcG0\x00\x00\x00\x00S\x00\x1b\xa0\x00\x00\x00\x00TC)0\x00\x00\x00\x00T\xe98 \x00\x00\x00\x00V#\v0\x00\x00\x00\x00V\xc9\x1a \x00\x00\x00\x00X\x02" +
-       "\xed0\x00\x00\x00\x00X\xa8\xfc \x00\x00\x00\x00Y\xe2\xcf0\x00\x00\x00\x00Z\x88\xde \x00\x00\x00\x00[\xde`\xb0\x00\x00\x00\x00\\h\xc0 \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd4L\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xaaʂA\xcd\x00\x00\x00\xcd\x00\x00\x00\x14\x00\x1c\x00America/Blanc-SablonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=9\f\xff\xff\xff\xff\x9e\xb8\x85`" +
-       "\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\x02\x01\x02\x03\x04\x02\xff\xff\xcat\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0" +
-       "\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00" +
-       "\x0f\x00\x1c\x00America/PhoenixUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a" +
-       "\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xcf\x17\xdf\x1c\xff\xff\xff\xffϏ\xe5\xac\xff\xff\xff\xffЁ\x1a\x1c\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\x02\x01\x02\x01\x02\x03\x02\x03\x02\x01" +
-       "\x02\xff\xff\x96\xee\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\fLMT\x00MDT\x00MST\x00MWT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x10\x00\x1c\x00America/AtikokanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x84d\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p" +
-       "\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\x02\x01\x02\x01\x03\x04\x05\xff\xff\xaa\x1c\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9" +
-       "\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa1" +
-       "'\a\xbd\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x1c\x00America/CayenneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x91\xf4+\x90\xff\xff\xff\xff\xfb\xc35\xc0\x01\x02\xff\xff\xce\xf0\x00\x00\xff\xff\xc7" +
-       "\xc0\x00\x04\xff\xff\xd5\xd0\x00\bLMT\x00-04\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\f\x00\x1c\x00A" +
-       "merica/NuukUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03" +
-       "͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00" +
-       "\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c" +
-       "'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00" +
-       "\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00-03\x00-02\x00\n<-03>3<-0" +
-       "2>,M3.5.0/-2,M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x14\x00\x1c\x00Americ" +
-       "a/Santa_IsabelUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff" +
-       "\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR" +
-       "\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff" +
-       "\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91" +
-       "\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00" +
-       "\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17" +
-       "\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00" +
-       "\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xde\xcf" +
-       "\xa0\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00" +
-       "\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05" +
-       "\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00" +
-       "\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00F\x0f\x82" +
-       "\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14L" +
-       "MT\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xf8Dz\x97\xae\x01\x00\x00\xae\x01\x00\x00\x11\x00\x1c\x00America/Boa_VistaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\u007f\xe0\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN" +
-       "\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff" +
-       "\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:" +
-       "@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00" +
-       "\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x009\xe9\x1d" +
-       "\xb0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xc7 \x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00" +
-       "-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x1c\x00America/Bahia_Band" +
-       "erasUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00" +
-       "\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb" +
-       "\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00" +
-       "\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<" +
-       "\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00" +
-       "\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00F\x0ft\x90\x00\x00\x00\x00G$A\x80\x00\x00\x00\x00G\xf8\x91\x10\x00\x00\x00\x00I\x04#\x80\x00\x00\x00\x00I\xd8s\x10\x00\x00\x00\x00J" +
-       "\xe4\x05\x80\x00\x00\x00\x00K\xb8U\x10\x00\x00\x00\x00L\xcd\x13\xf0\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x02\xff\xff" +
-       "\x9dT\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00MST\x00CST\x00PST\x00MDT\x00CDT\x00\nC" +
-       "ST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x1c\x00America/" +
-       "Indiana/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ \x17\x89}q\x01\x00\x00q\x01" +
-       "\x00\x00\x15\x00\x1c\x00America/Indiana/VevayUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86" +
-       "\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00" +
-       "\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00D/vp\x00\x00\x00\x00ED" +
-       "C`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xb0@\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10" +
-       "\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11." +
-       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x1c\x00\x1c\x00America/Indiana/Indianapol" +
-       "isUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00" +
-       "\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8G" +
-       "p\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff" +
-       "\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90" +
-       "p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff" +
-       "\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC" +
-       "`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff" +
-       "\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nES" +
-       "T5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQK-E\xfad\x02\x00\x00d\x02\x00\x00\x17\x00\x1c\x00America/I" +
-       "ndiana/WinamacUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff" +
-       "\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7" +
-       "\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff" +
-       "\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<" +
-       "\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff" +
-       "\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1" +
-       "\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x00\x00\x00\x00G-_\xe0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x06\x05\x06\x05\x01\x02\x06\x05\xff\xff\xae\xcf\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0" +
-       "\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQصK\xa6\n\x02\x00\x00\n\x02\x00\x00\x19\x00\x1c\x00America/Indiana/Tell_CityUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0" +
-       "\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff" +
-       "\xe4g=\xe0\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0" +
-       "\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff" +
-       "\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00" +
-       "\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x06\x05\x06\x05\x01\x02\x01\xff\xff\xae\xa9\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00" +
-       "\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nCST6CDT,M3.2.0,M11.1.0\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x01\xd8N\x8c\xab\x02\x00\x00\xab\x02\x00\x00\x1a\x00\x1c\x00America/Indiana/PetersburgUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff" +
-       "\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a" +
-       "\t\xf0\xff\xff\xff\xff\xe4g=\xe0\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff" +
-       "\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f" +
-       "\u0080\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xfa\bg\xf0\xff\xff" +
-       "\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87" +
-       "\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00" +
-       "\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00D/" +
-       "vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x00\x00\x00\x00G-m\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\x05\xff\xff\xae-\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LM" +
-       "T\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x1c\x00America/Indiana/VincennesUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80" +
-       "\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff" +
-       "\xd4@\xeb\xf0\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4g=\xe0\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00" +
-       "\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff" +
-       "\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0q\x9e\xf0\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p" +
-       "\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00" +
-       "E\xf3\xb7\x00\x00\x00\x00\x00G-m\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x06\x05\x06\x05\x01\x02\x01\x05\xff\xff\xad\xf1\x00\x00\xff" +
-       "\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00E" +
-       "DT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x14\x00\x1c\x00Ame" +
-       "rica/Indiana/KnoxUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp" +
-       "\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff" +
-       "\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp" +
-       "\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff" +
-       "\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00" +
-       "\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff" +
-       "\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp" +
-       "\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00" +
-       "\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00" +
-       "\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00" +
-       "\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp" +
-       "\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00" +
-       "'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT" +
-       "\x00CST\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQM/U\x9f7" +
-       "\x02\x00\x007\x02\x00\x00\x17\x00\x1c\x00America/Indiana/MarengoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00*\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9" +
-       "p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff" +
-       "\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16" +
-       "\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xb1\xda\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff" +
-       "\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0" +
-       "`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00D/vp\x00\x00\x00" +
-       "\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x01\x05\x06\x05\x06\x05\x06\xff\xff\xaf\r\x00" +
-       "\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST" +
-       "\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x14\x00\x1c\x00A" +
-       "merica/IndianapolisUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a" +
-       "\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff" +
-       "\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0" +
-       "s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff" +
-       "\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87" +
-       "\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CW" +
-       "T\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00" +
-       "\x82\x00\x00\x00\x10\x00\x1c\x00America/DominicaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST" +
-       "4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x1c\x00America/Argentina/UT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQt*\x9b!\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x1c\x00America/Arge" +
-       "ntina/SaltaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n" +
+       "\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff" +
+       "\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2" +
+       "\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00" +
+       "\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15I" +
+       "T \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00" +
+       "\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j" +
+       "\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00" +
+       "\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g" +
+       "\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00" +
+       "\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b" +
+       "\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00" +
+       "\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14LMT\x00" +
+       "MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\x0f" +
+       "(\b=\x01\x00\x00=\x01\x00\x00\x15\x00\x1c\x00America/Santo_DomingoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xffi\x87\x1d\b\xff\xff\xff\xff\xba\xdfB`\xff\xff\xff\xff\xfa\b" +
+       "K\xd0\xff\xff\xff\xff\xfa\xa7\xc3@\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00C{\xc8\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x01\xfa\u007fH\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x03\xdd\x04H\x00\x00" +
+       "\x00\x00\x05P\xd2P\x00\x00\x00\x00\x05\xbf\x89H\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\a\xa0\xbc\xc8\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:)\xe1`\x01\x03\x02\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x05\x03\x05\xff\xff\xbex\x00\x00\xff\xff\xbe`\x00\x04\xff\xff\xc7\xc0\x01\t\xff\xff\xb9\xb0\x00\r\xff\xff\xc0\xb8\x01\x11\xff\xff\xc7\xc0\x00\x17LMT\x00SDMT\x00EDT\x00" +
+       "EST\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/St" +
+       "_VincentUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x13\x00\x1c\x00America/Mexico_CityUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6f" +
+       "V`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xc5ް`\xff\xff\xff\xffƗ4P\xff\xff\xff\xff\xc9U\xf1\xe0\xff\xff\xff\xff\xc9\xea\xddP\xff\xff" +
+       "\xff\xff\xcf\x02\xc6\xe0\xff\xff\xff\xffϷVP\xff\xff\xff\xffڙ\x15\xe0\xff\xff\xff\xff\xdbv\x83\xd0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R" +
+       "\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00" +
+       "\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xa3\f\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff" +
+       "\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00MST\x00CST\x00CDT\x00CWT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x15\xc8\xcb\x00\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x1c\x00America/GuyanaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x98\xd9y\x88\x00\x00\x00\x00\n}\xb4<\x00\x00" +
+       "\x00\x00'\u007f\xfb0\x01\x02\x03\xff\xff\xc9x\x00\x00\xff\xff\xcbD\x00\x04\xff\xff\xd5\xd0\x00\n\xff\xff\xc7\xc0\x00\x0eLMT\x00-0345\x00-03\x00-04\x00\n<-04>4\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x1c\x00America/Port_of_SpainUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373" +
+       "\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x1c\x00Am" +
+       "erica/DetroitUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x85\xbd\"[\xff\xff\xff\xff\x99<\x94\x00\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff" +
+       "\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xfb3\x90\x8c\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`" +
+       "\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00" +
+       "\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0" +
+       "\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00" +
+       "\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0" +
+       "\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00" +
+       "*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0" +
+       "\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x00" +
+       "8\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0" +
+       "\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\xff\xff\xb2%\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00" +
+       "EST\x00EWT\x00EPT\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x12\x00\x1c\x00America/Argentina/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x1b\x00\x1c\x00America/Argentina/CatamarcaUT\t\x00\x03\x15\xac" +
+       "\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff" +
+       "r\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0" +
+       "\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff" +
+       "\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@" +
+       "\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff" +
+       "\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0" +
+       "\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00" +
+       "#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0" +
+       "\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00" +
+       "G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03" +
+       "\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02" +
+       "\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 \x00\x1c\x00America/Argentina/Com" +
+       "odRivadaviaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xd4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4" +
+       "\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4" +
        "p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff" +
        "\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A" +
        "7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff" +
        "\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7" +
        "\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00" +
        "\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0" +
-       "X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00" +
-       "\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04" +
-       "\x05\x03\x05\x04\x05\xff\xff¬\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02" +
-       "\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00America/Argentina/Ush" +
-       "uaiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00" +
-       "\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb1\x88\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba" +
-       "\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff" +
-       "\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7" +
-       "\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff" +
-       "\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9" +
-       "\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00" +
-       "\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)" +
-       "\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xb9N0\x00\x00\x00\x00@\xd5\v\xc0\x00" +
-       "\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\xf8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00" +
-       "-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x1b\x00\x1c\x00America/Ar" +
-       "gentina/CatamarcaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@" +
-       "\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff" +
-       "\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0" +
-       "\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff" +
-       "\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0" +
-       "\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff" +
-       "\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0" +
-       "\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00" +
-       "@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff" +
-       "\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 " +
-       "\x00\x1c\x00America/Argentina/ComodRivadaviaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{" +
-       "R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff" +
-       "\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c" +
-       "\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff" +
-       "\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62" +
-       "\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff" +
-       "\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7" +
-       "\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00" +
-       "\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff" +
-       "\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xfcz=\xe1\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/San_JuanUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb1\xbc\xff\xff" +
-       "\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8" +
-       "\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff" +
-       "\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM" +
-       "\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff" +
-       "\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc3" +
-       "5\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00" +
-       "\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'͵\xa0\x00\x00\x00\x00(&&@\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0" +
-       ":\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xba\x9f\xb0\x00\x00\x00\x00A\x030@\x00\x00\x00\x00Gw\t\xb0\x00\x00" +
-       "\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x05\x04\x05" +
-       "\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\xc4\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00" +
-       "-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1c\x80\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/" +
-       "San_LuisUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00>\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf\xb4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff" +
-       "\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0" +
-       "Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff" +
-       "\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4" +
-       "Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff" +
-       "\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a" +
-       "\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xfd\xa5\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00" +
-       "\x00\x00\x00(G\x1b\xc0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xba\x9f\xb0\x00\x00\x00\x00A\x030@\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\x93\xfc\xa0\x00\x00\x00\x00G" +
-       "\xd3R\xb0\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xb34\xb0\x00\x00\x00\x00J\xd1X@\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x05\x03\x05\x02\x05\x04\x03\x02\x03\x02\x05\xff\xff\xc1\xcc\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff" +
-       "\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8ep\xb4c\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e" +
-       "\x00\x1c\x00America/Argentina/Rio_GallegosUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
+       "X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00" +
+       "\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc2T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fL" +
+       "MT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00Ame" +
+       "rica/Argentina/UshuaiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb1\x88\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff" +
+       "\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n" +
+       "\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff" +
+       "\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed" +
+       "\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff" +
+       "\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c5" +
+       "0\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00" +
+       "\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*" +
+       "\xb0\x00\x00\x00\x00@\xb9N0\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\xf8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff" +
+       "\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RŒZ\x8c\xc4\x02\x00\x00" +
+       "\xc4\x02\x00\x00\x19\x00\x1c\x00America/Argentina/MendozaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
        "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb2d\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb2\x04\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@" +
        "\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff" +
        "\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0" +
        "\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff" +
        "\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@" +
        "\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff" +
        "\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0" +
-       "\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x00" +
-       "7\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\x1c\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7" +
-       "\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x1c\x00America/Argentina/JujuyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xb8\xff\xff\xff\xff\xa2\x92\x8f" +
-       "0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff" +
-       "\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0" +
-       "\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff" +
-       "\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l" +
-       "0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff" +
-       "\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94" +
-       "\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xe2۰\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00" +
-       "\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x04\x05\x04\x05\x03\x05\x04\x05\xff\xff\xc2\xc8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f" +
-       "\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQY\xd8֭\xd6\x02" +
-       "\x00\x00\xd6\x02\x00\x00\x19\x00\x1c\x00America/Argentina/TucumanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00?\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xa4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{" +
+       "\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00\x00\x00\x00(\xfag\xc0\x00\x00\x00\x00)\xb0H\xb0\x00\x00\x00\x00*\xe0\xe1@\x00\x00\x00\x00+\x99W \x00\x00\x00\x00" +
+       "7\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xb0\x13\xb0\x00\x00\x00\x00AV>\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x03\x02\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf|\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7" +
+       "\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x1c\x00America/Argentina/Buenos_AiresUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xa8L" +
+       "\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff" +
+       "\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30" +
+       "\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff" +
+       "\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0" +
+       "\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff" +
+       "\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0" +
+       "\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00" +
+       "*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca " +
+       "\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x04\x05\x04" +
+       "\x05\xff\xff\xc94\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-" +
+       "03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rm\aD\x0e\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/La_Rioj" +
+       "aUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x06" +
+       "\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb0,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0" +
+       "\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff" +
+       "\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0" +
+       "\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff" +
+       "\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@" +
+       "\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00" +
+       "\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'͵\xa0\x00\x00\x00\x00(&&@" +
+       "\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00" +
+       "@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc1T\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLM" +
+       "T\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8ep\xb4c\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x1c\x00Amer" +
+       "ica/Argentina/Rio_GallegosUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb2d\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1a\xc9" +
+       "\xb0\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff" +
+       "\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04" +
+       "@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff" +
+       "\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6\xe6\x9f" +
+       "\xb0\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff" +
+       "\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v" +
+       "\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00" +
+       "\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\x1c\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0" +
+       "\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RutZ\x1a" +
+       "\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x1c\x00America/Argentina/JujuyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xb8\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{" +
        "R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff" +
        "\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c" +
        "\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff" +
        "\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62" +
        "\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff" +
        "\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7" +
-       "\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00" +
-       "\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xcb\xd1@\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbc" +
-       "a \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02" +
-       "\x05\x04\x05\x04\x05\xff\xff\xc2\xdc\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02" +
-       "\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x1c\x00America/Argentina/Bue" +
-       "nos_AiresUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xa8L\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0" +
-       "\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff" +
-       "\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0" +
-       "\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff" +
-       "\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30" +
-       "\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00" +
-       "\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0" +
-       "\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00" +
-       "G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc94\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT" +
-       "\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00Ameri" +
-       "ca/Argentina/CordobaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8" +
-       "\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff" +
-       "\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5" +
-       "\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff" +
-       "\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8" +
-       "\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff" +
-       "\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'" +
-       "!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00" +
-       "\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0" +
-       "\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQm\aD\x0e\xcd\x02\x00\x00\xcd\x02" +
-       "\x00\x00\x1a\x00\x1c\x00America/Argentina/La_RiojaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb0,\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff" +
-       "\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd" +
-       "\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff" +
-       "\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xce" +
-       "M\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff" +
-       "\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd" +
-       "\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00" +
-       "\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'͵\xa0\x00\x00\x00\x00(&&@\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+" +
-       "\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xd5\v\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xc1T\x00\x00\xff" +
-       "\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00America/Argentina/MendozaUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr" +
-       "\x9c\xb2\x04\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff" +
-       "\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2" +
-       ";\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff" +
-       "\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4" +
-       "\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff" +
-       "\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#" +
-       "\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00\x00\x00\x00(\xfag\xc0\x00\x00\x00\x00)\xb0H\xb0\x00" +
-       "\x00\x00\x00*\xe0\xe1@\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xb0\x13\xb0\x00\x00\x00\x00AV>\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G" +
-       "\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x03\x02\x04\x05\x03\x05" +
-       "\x02\x05\x04\x05\xff\xff\xbf|\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00" +
-       "\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xad`\x12\xe9\xaa\x00\x00\x00\xaa\x00\x00\x00\x0e\x00\x1c\x00America/La_PazUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi" +
-       "\x87\x1bd\xff\xff\xff\xff\xb8\x1e\x96\xe4\xff\xff\xff\xff\xb8\xee\xd5\xd4\x01\x02\x03\xff\xff\xc0\x1c\x00\x00\xff\xff\xc0\x1c\x00\x04\xff\xff\xce,\x01\b\xff\xff\xc7\xc0\x00\fLMT\x00CMT\x00BST\x00-0" +
-       "4\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xfe\xe6\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x1c\x00America/DawsonUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff" +
-       "\xff}\x86\x8e\xb4\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2Ҁ\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4" +
-       " \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00" +
-       "\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9" +
-       "\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00" +
-       "\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1" +
-       "\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00" +
-       "\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7" +
-       "\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00" +
-       "\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ" +
-       " \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00" +
-       "\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00V5\xd4" +
-       "\x90\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00\x00Z\xa4\xfe \x00\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 \x00\x00\x00" +
-       "\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
-       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff}L\x00\x00" +
-       "\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19\xff\xff\x9d\x90\x01\x1d\xff\xff\x9d\x90\x00!LMT\x00YDT\x00YST\x00" +
-       "YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ.\xf9\xc0\x1e\xd5\x05\x00\x00\xd5\x05\x00\x00\x0f\x00\x1c" +
-       "\x00America/MonctonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x1e\xed\xbc\xff\xff\xff\xff\x80\xf1\xb6P\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xff\xbb<8\xd0\xff" +
-       "\xff\xff\xff\xbb\xb4#@\xff\xff\xff\xff\xbd\x1c\x1a\xd0\xff\xff\xff\xff\xbd\x94\x05@\xff\xff\xff\xff\xbe\xfb\xfc\xd0\xff\xff\xff\xff\xbfs\xe7@\xff\xff\xff\xff\xc0\xdb\xde\xd0\xff\xff\xff\xff\xc1S\xc9@\xff\xff\xff\xff\xc2" +
-       "\xbb\xc0\xd0\xff\xff\xff\xff\xc33\xab@\xff\xff\xff\xffě\xa2\xd0\xff\xff\xff\xff\xc5\x13\x8d@\xff\xff\xff\xff\xc6p\xf8\xd0\xff\xff\xff\xff\xc7\r\xcd@\xff\xff\xff\xff\xc8H\xf1\xd0\xff\xff\xff\xff\xc8\xed\xaf@\xff" +
-       "\xff\xff\xff\xca\x16^\xd0\xff\xff\xff\xff\xca\xd6\xcb\xc0\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@\xcf\xd0\xff\xff\xff\xff\xd5" +
-       "U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9\x15|\xe0\xff\xff\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xda\xfe\x99`\xff\xff\xff\xff\xdb\xc0W\xd0\xff" +
-       "\xff\xff\xff\xdc\xde{`\xff\xff\xff\xffݩtP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\xff\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3" +
-       "I\x1aP\xff\xff\xff\xff\xe4^\x03`\xff\xff\xff\xff\xe5(\xfcP\xff\xff\xff\xff\xe6G\x1f\xe0\xff\xff\xff\xff\xe7\x12\x18\xd0\xff\xff\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe9\x16\xe4\xd0\xff\xff\xff\xff\xea\x06\xe3\xe0\xff" +
-       "\xff\xff\xff\xea\xf6\xc6\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff\xec֨\xd0\xff\xff\xff\xff\xedƧ\xe0\xff\xff\xff\xff\xee\xbf\xc5P\xff\xff\xff\xff\xef\xaf\xc4`\xff\xff\xff\xff\xf0\x9f\xa7P\xff\xff\xff\xff\xf1" +
-       "\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_kP\xff\xff\xff\xff\xf5Oj`\xff\xff\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(i\xd0\xff" +
-       "\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff" +
-       "\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\b \xb3`\x00" +
-       "\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f" +
-       "\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00" +
-       "\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d" +
-       "\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00" +
-       "\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+" +
-       "\xbe]|\x00\x00\x00\x00,\xd3*l\x00\x00\x00\x00-\x9e?|\x00\x00\x00\x00.\xb3\fl\x00\x00\x00\x00/~!|\x00\x00\x00\x000\x92\xeel\x00\x00\x00\x001g=\xfc\x00\x00\x00\x002r\xd0l\x00" +
-       "\x00\x00\x003G\x1f\xfc\x00\x00\x00\x004R\xb2l\x00\x00\x00\x005'\x01\xfc\x00\x00\x00\x0062\x94l\x00\x00\x00\x007\x06\xe3\xfc\x00\x00\x00\x008\x1b\xb0\xec\x00\x00\x00\x008\xe6\xc5\xfc\x00\x00\x00\x009" +
-       "\xfb\x92\xec\x00\x00\x00\x00:Ƨ\xfc\x00\x00\x00\x00;\xdbt\xec\x00\x00\x00\x00<\xaf\xc4|\x00\x00\x00\x00=\xbbV\xec\x00\x00\x00\x00>\x8f\xa6|\x00\x00\x00\x00?\x9b8\xec\x00\x00\x00\x00@o\x88|\x00" +
-       "\x00\x00\x00A\x84Ul\x00\x00\x00\x00BOj|\x00\x00\x00\x00Cd7l\x00\x00\x00\x00D/L|\x00\x00\x00\x00ED\x19l\x00\x00\x00\x00E\xf3\x9a\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xc3D\x00\x00\xff\xff\xb9\xb0\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\f\xff\xff\xd5\xd0\x01\x10\xff\xff\xd5\xd0\x01\x14LMT\x00EST\x00ADT" +
-       "\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQU\xactA\xb5\x01\x00\x00\xb5" +
-       "\x01\x00\x00\x11\x00\x1c\x00America/MatamorosUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x001gv\x00\x00" +
-       "\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008" +
-       "\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00" +
-       "\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00F\x0ff\x80\x00\x00\x00\x00G" +
-       "$3p\x00\x00\x00\x00G\xf8\x83\x00\x00\x00\x00\x00I\x04\x15p\x00\x00\x00\x00I\xd8e\x00\x00\x00\x00\x00J\xe3\xf7p\x00\x00\x00\x00K\x9c\x97\x80\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xa2@\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x01\bLMT\x00CST\x00CDT\x00\nCST6CDT,M3.2.0" +
-       ",M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/St_VincentUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b" +
-       "\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\u0096dK~\x02\x00\x00~\x02\x00" +
-       "\x00\x0e\x00\x1c\x00America/ReginaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x86\xfd\x93\x1c\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xb5eO\xf0\xff\xff\xff\xff\xb60" +
-       "H\xe0\xff\xff\xff\xff\xb7E1\xf0\xff\xff\xff\xff\xb8\x10*\xe0\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xbb\x0e0p\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xee\x12p\xff\xff" +
-       "\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xc2r\b\xf0\xff\xff\xff\xff\xc3a\xeb\xe0\xff\xff\xff\xff\xc4Q\xea\xf0\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc61\xcc\xf0\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff\xff\xff\xc8\x1a" +
-       "\xe9p\xff\xff\xff\xff\xc9\n\xcc`\xff\xff\xff\xff\xc9\xfa\xcbp\xff\xff\xff\xff\xca\xea\xae`\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3c\x8c\x10\xff\xff" +
-       "\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\xff\xff\xff\xff\xd75\xc5\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff\xff\xff\xda\xfe" +
-       "Ð\xff\xff\xff\xff\xdb\xc0\x82\x00\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\x9e\x80\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff߉\x80\x80\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ib\x80\xff\xff" +
-       "\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3ID\x80\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)&\x80\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12C\x00\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf2" +
-       "%\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xd6\xd3\x00\xff\xff\xff\xff\xed\xc6\xd2\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\xff\xff\x9d\xe4\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14LMT\x00M" +
-       "DT\x00MST\x00MWT\x00MPT\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x1c\x00Ameri" +
-       "ca/YellowknifeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x19\xff\xff\xff\xff\xbe*\x18\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/Zp\xff\xff\xff" +
-       "\xff\xf8(\x85\xf0\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n" +
-       "\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00" +
-       "\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90" +
-       "\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00" +
-       "\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H" +
-       "\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00" +
-       "\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}" +
-       "\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x03\x01\x02\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
-       "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x00\x00\x00\x00\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xab\xa0" +
-       "\x01\x15-00\x00MWT\x00MPT\x00MST\x00MDDT\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x1c\x00America/Rainy_RiverUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00J\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xee\x87(\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff" +
-       "\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\x00\x00\x00\x00\b π\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\n" +
-       "\x00\xb1\x80\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00" +
-       "\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18" +
-       "\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00" +
-       "\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&" +
-       "\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00" +
-       "\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004" +
-       "R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00" +
-       "\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00B" +
-       "O\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa7X\x00\x00\xff\xff\xb9\xb0\x01" +
-       "\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1" +
-       ".0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x12\x00\x1c\x00America/KralendijkUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e" +
-       ".#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\nLMT\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQMv\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x1c\x00America/MonterreyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00" +
-       "#j\xbd\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00" +
-       "\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\xff\xff\xa1\xf4\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x01\bLMT\x00CST\x00CDT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x1c\x00America/JamaicaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87#~\xff\xff\xff\xff\x93\x0f" +
-       "\xb4\xfe\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00" +
-       "\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I" +
-       ")\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\xff\xff\xb8\x02\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\fLMT\x00KMT\x00EST\x00EDT\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x0e\x00\x1c\x00America/HavanaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
+       "\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xe2۰\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00" +
+       "\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x04\x05\x04\x05\x03\x05\x04\x05\xff\xff\xc2\xc8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff" +
+       "\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfcz=\xe1\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a" +
+       "\x00\x1c\x00America/Argentina/San_JuanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb1\xbc\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff" +
+       "\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0" +
+       "\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff" +
+       "\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0" +
+       "\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff" +
+       "\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@" +
+       "\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00" +
+       "%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'͵\xa0\x00\x00\x00\x00(&&@\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W " +
+       "\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xba\x9f\xb0\x00\x00\x00\x00A\x030@\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x05\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf\xc4\x00\x00\xff\xff\xc3\xd0" +
+       "\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\x1c\x80\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/San_LuisUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xaf" +
+       "\xb4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff" +
+       "\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc3" +
+       "0\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff" +
+       "\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6" +
+       "\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff" +
+       "\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5" +
+       "\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xfd\xa5\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00\x00\x00\x00(G\x1b\xc0\x00\x00\x00\x007\xf6ư\x00\x00\x00" +
+       "\x008\xbf*\xb0\x00\x00\x00\x00@\xba\x9f\xb0\x00\x00\x00\x00A\x030@\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\x93\xfc\xa0\x00\x00\x00\x00G\xd3R\xb0\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xb34" +
+       "\xb0\x00\x00\x00\x00J\xd1X@\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02" +
+       "\x05\x03\x05\x02\x05\x04\x03\x02\x03\x02\x05\xff\xff\xc1\xcc\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-" +
+       "03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rt*\x9b!\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x1c\x00America/Argenti" +
+       "na/SaltaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xd4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff" +
+       "\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0" +
+       "Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff" +
+       "\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4" +
+       "Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff" +
+       "\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a" +
+       "\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00" +
+       "\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G" +
+       "\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05" +
+       "\x04\x05\xff\xff¬\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<" +
+       "-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RY\xd8֭\xd6\x02\x00\x00\xd6\x02\x00\x00\x19\x00\x1c\x00America/Argentina/Tucuma" +
+       "nUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00?\x00\x00\x00\x06" +
+       "\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xa4\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0" +
+       "\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff" +
+       "\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0" +
+       "\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff" +
+       "\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@" +
+       "\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00" +
+       "\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@" +
+       "\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xbb\xf10\x00\x00\x00\x00@\xcb\xd1@\x00\x00\x00\x00" +
+       "Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x02\x05\x04\x05\x04\x05\xff\xff\xc2\xdc\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01" +
+       "\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00" +
+       "\x00\x19\x00\x1c\x00America/Argentina/CordobaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff" +
+       "\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4" +
+       "\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff" +
+       "\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff" +
+       "0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff" +
+       "\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR" +
+       "@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00" +
+       "\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6\xc6" +
+       "\xb0\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b" +
+       "\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\xe3\xc9I\xd0U\x03\x00\x00U\x03\x00\x00\x12\x00\x1c\x00America/Grand_TurkUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
        "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00j\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87(\xb8\xff\xff\xff\xff\xacb\u0080\xff\xff\xff\xff\xb1Ӕ" +
-       "P\xff\xff\xff\xff\xb2t]@\xff\xff\xff\xff\xc8[f\xd0\xff\xff\xff\xff\xc8\xd3Q@\xff\xff\xff\xff\xca;H\xd0\xff\xff\xff\xffʼm\xc0\xff\xff\xff\xff\xcc$eP\xff\xff\xff\xff̜O\xc0\xff\xff\xff" +
-       "\xff\xd1\xc4\vP\xff\xff\xff\xff\xd2;\xf5\xc0\xff\xff\xff\xffӣ\xedP\xff\xff\xff\xff\xd4\x1b\xd7\xc0\xff\xff\xff\xff\xf7`\x05\xd0\xff\xff\xff\xff\xf7\xff}@\xff\xff\xff\xff\xf9=D\xd0\xff\xff\xff\xff\xf9\xe3S" +
-       "\xc0\xff\xff\xff\xff\xfa\xdb;\xd0\xff\xff\xff\xff\xfb\xa7\x86@\xff\xff\xff\xff\xfcũ\xd0\xff\xff\xff\xff\xfd\x87h@\xff\xff\xff\xff\xfe\xb8\x00\xd0\xff\xff\xff\xff\xff\xa7\xe3\xc0\x00\x00\x00\x00\x00\x97\xe2\xd0\x00\x00\x00" +
-       "\x00\x01\x87\xc5\xc0\x00\x00\x00\x00\x02w\xc4\xd0\x00\x00\x00\x00\x03p\xe2@\x00\x00\x00\x00\x04`\xe1P\x00\x00\x00\x00\x055\x14\xc0\x00\x00\x00\x00\x06@\xc3P\x00\x00\x00\x00\a\x16H@\x00\x00\x00\x00\b \xa5" +
-       "P\x00\x00\x00\x00\b\xf7{\xc0\x00\x00\x00\x00\n\x00\x87P\x00\x00\x00\x00\n\xf0j@\x00\x00\x00\x00\v\xe0iP\x00\x00\x00\x00\fن\xc0\x00\x00\x00\x00\r\xc0KP\x00\x00\x00\x00\x0e\xb9h\xc0\x00\x00\x00" +
-       "\x00\x0f\xb2\xa2P\x00\x00\x00\x00\x10}\x9b@\x00\x00\x00\x00\x11Q\xea\xd0\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x131\xcc\xd0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15[\x82\xd0\x00\x00\x00\x00\x16&{" +
-       "\xc0\x00\x00\x00\x00\x17;d\xd0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xfb(\xd0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\xdb\n\xd0\x00\x00\x00" +
-       "\x00\x1d\xaf>@\x00\x00\x00\x00\x1ezSP\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 Z5P\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"CQ\xd0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$#3" +
-       "\xd0\x00\x00\x00\x00%.\xc6@\x00\x00\x00\x00&\x15\x8a\xd0\x00\x00\x00\x00'\x17\xe2\xc0\x00\x00\x00\x00'\xfe\xa7P\x00\x00\x00\x00(\xf7\xd2\xd0\x00\x00\x00\x00)މP\x00\x00\x00\x00*״\xd0\x00\x00\x00" +
-       "\x00+\xbekP\x00\x00\x00\x00,\xb7\x96\xd0\x00\x00\x00\x00-\x9eMP\x00\x00\x00\x00.\x97x\xd0\x00\x00\x00\x00/~/P\x00\x00\x00\x000wZ\xd0\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002W<" +
-       "\xd0\x00\x00\x00\x003G-\xd0\x00\x00\x00\x004@YP\x00\x00\x00\x005\x1d\xd5P\x00\x00\x00\x0062\xb0P\x00\x00\x00\x006\xfd\xb7P\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00" +
-       "\x009\xfb\xae\xd0\x00\x00\x00\x00:Ƶ\xd0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xd2P\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xb4P\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@f[" +
-       "\xd0\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x8c\xd0\x00\x00\x00\x00G$\x17P\x00\x00\x00\x00GܩP\x00\x00\x00\x00I\x03\xf9P\x00\x00\x00\x00I\xb3P\xd0\x00\x00\x00\x00J\xe3\xdbP\x00\x00\x00" +
-       "\x00K\x9cmP\x00\x00\x00\x00L\xcc\xf7\xd0\x00\x00\x00\x00M\x85\x89\xd0\x00\x00\x00\x00N\xbfN\xd0\x00\x00\x00\x00Ow\xe0\xd0\x00\x00\x00\x00P\x95\xf6P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb2\xc8\x00\x00\xff\xff\xb2\xc0\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00H" +
-       "MT\x00CDT\x00CST\x00\nCST5CDT,M3.2.0/0,M11.1.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x82\x13z\xe2\xc2\x00\x00" +
-       "\x00\xc2\x00\x00\x00\x13\x00\x1c\x00America/TegucigalpaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00L\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1e0\xff\xff\xff\xff\x93\x0f\xb4\xfe\x00\x00\x00\x00\x11\x89e" +
+       "\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00" +
+       "\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1" +
+       "`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00" +
+       "\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9ei" +
+       "p\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00" +
+       "\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞" +
+       "\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00" +
+       "\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x00\x00\x00\x00G-_\xe0\x00\x00\x00\x00Gӊ\xf0\x00\x00\x00\x00I\rA\xe0\x00\x00\x00\x00I\xb3l" +
+       "\xf0\x00\x00\x00\x00J\xed#\xe0\x00\x00\x00\x00K\x9c\x89p\x00\x00\x00\x00L\xd6@`\x00\x00\x00\x00M|kp\x00\x00\x00\x00N\xb6\"`\x00\x00\x00\x00O\\Mp\x00\x00\x00\x00P\x96\x04`\x00\x00\x00" +
+       "\x00Q</p\x00\x00\x00\x00Ru\xe6`\x00\x00\x00\x00S\x1c\x11p\x00\x00\x00\x00TU\xc8`\x00\x00\x00\x00T\xfb\xf3p\x00\x00\x00\x00Z\xa4\xd3\xf0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04" +
+       "\x03\xff\xff\xbdP\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x00\x10LMT\x00KMT\x00EST\x00EDT\x00AST\x00\nEST5EDT," +
+       "M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x1c\x00America/Knox_IN" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00" +
+       "\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff" +
+       "\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda" +
+       "\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff" +
+       "\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8" +
+       "\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff" +
+       "\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe" +
+       "\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00" +
+       "\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\f" +
+       "ٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00" +
+       "\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a" +
+       "\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00" +
+       "\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)" +
+       "\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01" +
+       "\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00" +
+       "\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x1c\x00Americ" +
+       "a/Bahia_BanderasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff" +
+       "\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004" +
+       "R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00" +
+       "\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00B" +
+       "O\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00F\x0ft\x90\x00\x00\x00\x00G$A\x80\x00\x00\x00\x00G\xf8\x91\x10\x00\x00\x00\x00I\x04#\x80\x00" +
+       "\x00\x00\x00I\xd8s\x10\x00\x00\x00\x00J\xe4\x05\x80\x00\x00\x00\x00K\xb8U\x10\x00\x00\x00\x00L\xcd\x13\xf0\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
+       "\x04\x01\x04\x01\x04\x01\x04\x01\x05\x02\xff\xff\x9dT\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00MST\x00CST\x00PS" +
+       "T\x00MDT\x00CDT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00" +
+       "\x0e\x00\x1c\x00America/VirginUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xa1'\a\xbd\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x1c\x00America/CayenneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x91\xf4+\x90\xff\xff\xff\xff\xfb\xc35\xc0" +
+       "\x01\x02\xff\xff\xce\xf0\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x00\bLMT\x00-04\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00" +
+       "\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/MontserratUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa4LKD\x00\x00\x00\x00 \x9a\xdc\xe0\x00\x00\x00\x00!\\\x9bP\x00\x00\x00\x00\"" +
-       "z\xbe\xe0\x00\x00\x00\x00#<}P\x00\x00\x00\x00D]\x8c\xe0\x00\x00\x00\x00D\xd6\xc8\xd0\x02\x01\x02\x01\x02\x01\x02\xff\xff\xae<\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00" +
-       "CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcd\xc3v\xe3\xb3\x00\x00\x00\xb3\x00\x00\x00\x11\x00\x1c\x00America/GuayaquilUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10" +
-       "\xff\xff\xff\xffi\x87&X\xff\xff\xff\xff\xb6\xa4B\x18\x00\x00\x00\x00+\x16\xfc\xd0\x00\x00\x00\x00+q\xe6@\x01\x03\x02\x03\xff\xff\xb5(\x00\x00\xff\xff\xb6h\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\f" +
-       "LMT\x00QMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa2\x81\xbfyS\x02\x00\x00S\x02\x00\x00\x12\x00\x1c\x00Americ" +
-       "a/MetlakatlaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00,\x00\x00\x00\b\x00\x00\x00\x1e\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x870\x1a\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfe" +
-       "\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00" +
-       "\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f" +
-       "\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00" +
-       "\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00V" +
-       "5\xe2\xa0\x00\x00\x00\x00V\xe5H0\x00\x00\x00\x00X\x1e\xff \x00\x00\x00\x00X\xc5*0\x00\x00\x00\x00Y\xfe\xe1 \x00\x00\x00\x00Z\xa5\f0\x00\x00\x00\x00[\xde\xc3 \x00\x00\x00\x00\\DF\xa0\x00" +
-       "\x00\x00\x00\\\x84\xee0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x06\a\x06\a\x06\a\x02\x06\a\x00\x00\xd6&\x00\x00\xff\xff\x84" +
-       "\xa6\x00\x00\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x81p\x00\x14\xff\xff\x8f\x80\x01\x19LMT\x00PST\x00PWT\x00PPT\x00PDT\x00A" +
-       "KST\x00AKDT\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ8\xcdZ\x05o\x01\x00\x00o\x01\x00" +
-       "\x00\x10\x00\x1c\x00America/MazatlanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff" +
-       "\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10" +
-       "\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00" +
-       ":\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff\xff\x9c<\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b" +
-       "\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00PST\x00MDT\x00\nMST7MDT,M4.1.0,M10.5.0\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQHQ(\x9a~\x02\x00\x00~\x02\x00\x00\x0e\x00\x1c\x00America/BelizeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x007\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\x93^ٰ\xff\xff\xff\xff\x9f\x9f;\xe0\xff" +
-       "\xff\xff\xff\xa0EQ\xd8\xff\xff\xff\xff\xa1\u007f\x1d\xe0\xff\xff\xff\xff\xa2.nX\xff\xff\xff\xff\xa3^\xff\xe0\xff\xff\xff\xff\xa4\x0ePX\xff\xff\xff\xff\xa5>\xe1\xe0\xff\xff\xff\xff\xa5\xee2X\xff\xff\xff\xff\xa7" +
-       "'\xfe`\xff\xff\xff\xff\xa7\xce\x14X\xff\xff\xff\xff\xa9\a\xe0`\xff\xff\xff\xff\xa9\xad\xf6X\xff\xff\xff\xff\xaa\xe7\xc2`\xff\xff\xff\xff\xab\x97\x12\xd8\xff\xff\xff\xff\xacǤ`\xff\xff\xff\xff\xadv\xf4\xd8\xff" +
-       "\xff\xff\xff\xae\xa7\x86`\xff\xff\xff\xff\xafV\xd6\xd8\xff\xff\xff\xff\xb0\x87h`\xff\xff\xff\xff\xb16\xb8\xd8\xff\xff\xff\xff\xb2p\x84\xe0\xff\xff\xff\xff\xb3\x16\x9a\xd8\xff\xff\xff\xff\xb4Pf\xe0\xff\xff\xff\xff\xb4" +
-       "\xf6|\xd8\xff\xff\xff\xff\xb60H\xe0\xff\xff\xff\xff\xb6ߙX\xff\xff\xff\xff\xb8\x10*\xe0\xff\xff\xff\xff\xb8\xbf{X\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xba\x9f]X\xff\xff\xff\xff\xbb\xd9)`\xff" +
-       "\xff\xff\xff\xbc\u007f?X\xff\xff\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xbe_!X\xff\xff\xff\xff\xbf\x98\xed`\xff\xff\xff\xff\xc0?\x03X\xff\xff\xff\xff\xc1x\xcf`\xff\xff\xff\xff\xc2(\x1f\xd8\xff\xff\xff\xff\xc3" +
-       "X\xb1`\xff\xff\xff\xff\xc4\b\x01\xd8\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc5\xe7\xe3\xd8\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff\xff\xff\xc7\xc7\xc5\xd8\xff\xff\xff\xff\xc9\x01\x91\xe0\xff\xff\xff\xffɧ\xa7\xd8\xff" +
-       "\xff\xff\xff\xca\xe1s\xe0\xff\xff\xff\xffː\xc4X\xff\xff\xff\xff\xcc\xc1U\xe0\xff\xff\xff\xff\xcdp\xa6X\x00\x00\x00\x00\ab\xdb`\x00\x00\x00\x00\a\xb9\xd0P\x00\x00\x00\x00\x18aq`\x00\x00\x00\x00\x18" +
-       "\xab7P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\xff\xff" +
-       "\xadP\x00\x00\xff\xff\xb2\xa8\x01\x04\xff\xff\xab\xa0\x00\n\xff\xff\xb9\xb0\x01\x0eLMT\x00-0530\x00CST\x00CDT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x1c\x00America/Knox_INUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff" +
-       "\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75" +
-       "\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff" +
-       "\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W" +
-       "<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff" +
-       "\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xfa\xf8" +
-       "g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00" +
-       "\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10" +
-       "\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00" +
-       "\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)" +
-       "\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00" +
-       "\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J" +
-       "\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01" +
-       "\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01" +
-       "\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x1c\x00America/CuiabaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa{\x94\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff" +
-       "\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb" +
-       "#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff" +
-       "\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex" +
-       "\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00#X\x1e\xc0\x00\x00\x00\x00#\xe2~0\x00\x00\x00\x00%8\x00\xc0\x00\x00" +
-       "\x00\x00%\xd4\xd50\x00\x00\x00\x00'!\x1d@\x00\x00\x00\x00'\xbd\xf1\xb0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\x94\x990\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+k@\xb0\x00\x00\x00\x00,\xc0" +
-       "\xc3@\x00\x00\x00\x00-f\xd20\x00\x00\x00\x00.\xa0\xa5@\x00\x00\x00\x00/F\xb40\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001\x1d[\xb0\x00\x00\x00\x002W.\xc0\x00\x00\x00\x003\x06x0\x00\x00" +
-       "\x00\x0048b@\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006 -@\x00\x00\x00\x006\xcfv\xb0\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x00:\x8f" +
-       ":\xb0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<o\x1c\xb0\x00\x00\x00\x00=ğ@\x00\x00\x00\x00>N\xfe\xb0\x00\x00\x00\x00A\x87\x06@\x00\x00\x00\x00B\x17\xfd0\x00\x00\x00\x00CQ\xd0@\x00\x00" +
-       "\x00\x00C\xf7\xdf0\x00\x00\x00\x00EMa\xc0\x00\x00\x00\x00E\xe0\xfb\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xb7\xa30\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\x97\x850\x00\x00\x00\x00J\xda" +
-       "\x92\xc0\x00\x00\x00\x00K\x80\xa1\xb0\x00\x00\x00\x00L\xbat\xc0\x00\x00\x00\x00M`\x83\xb0\x00\x00\x00\x00N\x9aV\xc0\x00\x00\x00\x00OI\xa00\x00\x00\x00\x00P\x83s@\x00\x00\x00\x00Q G\xb0\x00\x00" +
-       "\x00\x00RcU@\x00\x00\x00\x00S\x00)\xb0\x00\x00\x00\x00TC7@\x00\x00\x00\x00T\xe9F0\x00\x00\x00\x00V#\x19@\x00\x00\x00\x00V\xc9(0\x00\x00\x00\x00X\x02\xfb@\x00\x00\x00\x00X\xa9" +
-       "\n0\x00\x00\x00\x00Y\xe2\xdd@\x00\x00\x00\x00Z\x88\xec0\x00\x00\x00\x00[\xden\xc0\x00\x00\x00\x00\\h\xce0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00" +
+       "\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x1c\x00America/WinnipegUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffd" +
+       "䰔\xff\xff\xff\xff\x9b\x01\xfb\xe0\xff\xff\xff\xff\x9búP\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\u00a0;\x80\xff\xff\xff\xff\xc3O\x84\xf0\xff\xff\xff\xffˈ\xfe\x80\xff" +
+       "\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xffӈh\x00\xff\xff\xff\xff\xd4S`\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8" +
+       "\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xdb\x00\a\x00\xff\xff\xff\xff\xdb\xc8\\\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff" +
+       "\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6" +
+       "G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff" +
+       "\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf41b\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb" +
+       "\xe8X\x00\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xef\x00\x00" +
+       "\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b π\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\n" +
+       "\x00\xb1\x80\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99\x83\x00\x00" +
+       "\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18" +
+       "\"E\x80\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1܀\x00" +
+       "\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&" +
+       "\x15\xb5\x00\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3p\x80\x00" +
+       "\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003GX\x00\x00\x00\x00\x004" +
+       "R\xf8\x80\x00\x00\x00\x005':\x00\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xe0\x00\x00" +
+       "\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00B" +
+       "O\xa2\x80\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
        "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\xff\xff\xcbl\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQo_\x00v/" +
-       "\x01\x00\x00/\x01\x00\x00\x0e\x00\x1c\x00America/MeridaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\x16\x86\xd5`\x00\x00\x00\x00\x18LKP\x00\x00\x00\x001gv\x00" +
-       "\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x00" +
-       "8\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\xff\xff\xab\xfc\x00\x00\xff\xff" +
-       "\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xb9\xb0\x01\fLMT\x00CST\x00EST\x00CDT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\r\x00\x1c\x00America/JujuyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xb8\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff" +
-       "\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96" +
-       "\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff" +
-       "\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee" +
-       "\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff" +
-       "\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbc" +
-       "S0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00" +
-       "\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xe2۰\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99" +
-       "W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x04\x05\x04\x05\x03\x05\x04\x05\xff\xff\xc2\xc8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3" +
-       "\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQԾ\xe7#\x95\x00\x00\x00\x95" +
-       "\x00\x00\x00\x0e\x00\x1c\x00America/CaymanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffi\x87&\x10\xff\xff\xff\xff\x8b\xf4a\xe8\x01\x02\xff\xff\xb5p\x00\x00\xff\xff\xb5\x18\x00\x04\xff\xff\xb9\xb0\x00\b" +
-       "LMT\x00CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x85-\xb9\xf8\x8a\x01\x00\x00\x8a\x01\x00\x00\r\x00\x1c\x00America/Bele" +
-       "mUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03" +
-       "\x00\x00\x00\f\xff\xff\xff\xff\x96\xaatt\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0" +
-       "\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff" +
-       "\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060" +
-       "\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffҌ\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03" +
-       ">3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQs\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00\x00\x10\x00\x1c\x00America/EirunepeUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x88\x80" +
-       "\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xff" +
-       "ܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P" +
-       "\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00" +
-       "\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00,\xc0\xd1P\x00\x00\x00\x00-f\xe0@" +
-       "\x00\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xbe\x80\x00\x00\xff\xff\xc7\xc0\x01" +
-       "\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10" +
-       "\x00\x1c\x00America/St_LuciaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQOKjǪ\x02\x00\x00\xaa\x02\x00\x00\r\x00\x1c\x00America/BahiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaak\x1c\xff\xff\xff\xff\xb8\x0fI\xe0\xff" +
-       "\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd" +
-       "\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff" +
-       "\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1e" +
-       "xנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00" +
-       "\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00," +
-       "\xc0\xb50\x00\x00\x00\x00-f\xc4 \x00\x00\x00\x00.\xa0\x970\x00\x00\x00\x00/F\xa6 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00" +
-       "\x00\x00\x0048T0\x00\x00\x00\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:" +
-       "\x8f,\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xdb\xe4\x00\x00\xff\xff" +
-       "\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x1c\x00" +
-       "America/WhitehorseUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff\xff}\x86\x8a\x9c\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2\xd2" +
-       "\x80\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xfb\x1d_\x10\x00\x00\x00\x00\x13ir \x00\x00\x00" +
-       "\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24" +
-       "\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00" +
-       "\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80" +
-       "\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00" +
-       "\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8" +
-       " \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00" +
-       "\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm" +
-       "\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00" +
-       "\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;" +
-       "\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00V5Ԑ\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00" +
-       "\x00Z\xa4\xfe \x00\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 \x00\x00\x00\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06" +
-       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
-       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff\x81d\x00\x00\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19" +
-       "\xff\xff\x9d\x90\x01\x1d\xff\xff\x9d\x90\x00!LMT\x00YDT\x00YST\x00YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00MST\x00\nMST7\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00America/TortolaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa4\xec\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff" +
+       "\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x1c\x00America/AnguillaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
        "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff" +
-       "\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQU9#\xbe2\x05\x00\x002\x05\x00\x00\x11\x00\x1c\x00America/Vanc" +
-       "ouverUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81" +
-       "\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=v\xec\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff" +
-       "\xd3v\x0f \xff\xff\xff\xff\xd4A\b\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10" +
-       "\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff" +
-       "\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': " +
-       "\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff" +
-       "\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90" +
-       "\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff" +
-       "\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0" +
-       "\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\b \xeb\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00" +
-       "\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10" +
-       "\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00" +
-       "\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ " +
-       "\x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00" +
-       "'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90" +
-       "\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x00" +
-       "62\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0" +
-       "\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00" +
-       "D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x8c\x94\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10L" +
-       "MT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf7\xe9 " +
-       "y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e\x00\x1c\x00America/InuvikUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xe0\x06N\x80\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x94\x00\x00\x00\x00\x00\x11\x89" +
-       "\x90 \x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00" +
-       "\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v" +
-       "\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00" +
-       "\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3" +
-       "R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00" +
-       "\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0" +
-       "\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00" +
-       "\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x00\x00\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x8f\x80\x00\t\xff\xff\x9d\x90\x00\r\xff\xff\xab\xa0\x01\x11-00\x00PDDT\x00" +
-       "PST\x00MST\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb4T\xbd\xeb5\x02\x00\x005\x02" +
-       "\x00\x00\x16\x00\x1c\x00America/Port-au-PrinceUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00-\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x87\x1fP\xff\xff\xff\xff\x9cnq\xfc\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00\x00\x1a" +
-       "\x01\xef@\x00\x00\x00\x00\x1a\xf1\xeeP\x00\x00\x00\x00\x1b\xe1\xd1@\x00\x00\x00\x00\x1c\xd1\xd0P\x00\x00\x00\x00\x1d\xc1\xb3@\x00\x00\x00\x00\x1e\xb1\xb2P\x00\x00\x00\x00\x1f\xa1\x95@\x00\x00\x00\x00 \x91\x94P\x00" +
-       "\x00\x00\x00!\x81w@\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'" +
-       "\xfe\xb5`\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb36`\x00" +
-       "\x00\x00\x00/~=`\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x00BOxP\x00\x00\x00\x00C" +
-       "dE@\x00\x00\x00\x00D/ZP\x00\x00\x00\x00ED'@\x00\x00\x00\x00O\\Mp\x00\x00\x00\x00P\x96\x04`\x00\x00\x00\x00Q</p\x00\x00\x00\x00Ru\xe6`\x00\x00\x00\x00S\x1c\x11p\x00" +
-       "\x00\x00\x00TU\xc8`\x00\x00\x00\x00T\xfb\xf3p\x00\x00\x00\x00V5\xaa`\x00\x00\x00\x00X\xc4\xf1\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xbc0\x00\x00\xff\xff\xbcD\x00\x04\xff\xff\xc7\xc0\x01\t\xff\xff\xb9\xb0\x00\rLMT\x00PPMT\x00EDT\x00EST\x00\nES" +
-       "T5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb4\x11Z\xde\xe4\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x1c\x00America/F" +
-       "ortalezaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/Mend" +
+       "ozaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00" +
+       "\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb2\x04\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17" +
+       "}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff" +
+       "\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0" +
+       "\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff" +
+       "\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4" +
+       "w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00" +
+       "\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00\x00\x00\x00(\xfa" +
+       "g\xc0\x00\x00\x00\x00)\xb0H\xb0\x00\x00\x00\x00*\xe0\xe1@\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xb0\x13\xb0\x00\x00\x00\x00AV>\xc0\x00\x00" +
+       "\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04" +
+       "\x05\x04\x02\x03\x02\x03\x02\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff\xbf|\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-" +
+       "04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x04,2h\x99\x01\x00\x00\x99\x01\x00\x00\x10\x00\x1c\x00America/San" +
+       "taremUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e" +
+       "\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaazH\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff" +
+       "\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0" +
+       "\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff" +
+       "\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ" +
+       "\x00\x00\x00\x00H`q@\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\xff\xff̸\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0" +
+       "\x00\x04LMT\x00-03\x00-04\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x1c\x00America/" +
+       "St_LuciaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaak\x18\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff" +
-       "\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4" +
-       "\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff" +
-       "\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"" +
-       "\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00" +
-       "\x00\x00\x009\xf2J \x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\xff\xff\xdb\xe8\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb7-2f\xe4\x01" +
-       "\x00\x00\xe4\x01\x00\x00\x0f\x00\x1c\x00America/NoronhaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaaed\xff\xff\xff\xff\xb8\x0f;\xd0\xff\xff\xff\xff\xb8\xfd2\x90\xff\xff\xff\xff\xb9\xf1& " +
-       "\xff\xff\xff\xff\xba\xdef\x10\xff\xff\xff\xff\xda8\xa0 \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdc\x19Ӡ\xff\xff\xff\xffܹK\x10\xff\xff\xff\xff\xdd\xfb\a \xff\xff\xff\xffޛ\xd0\x10\xff\xff\xff\xff" +
-       "\xdf\u074c \xff\xff\xff\xff\xe0T%\x10\xff\xff\xff\xff\xf4\x97\xf1\xa0\xff\xff\xff\xff\xf5\x05P\x10\xff\xff\xff\xff\xf6\xc0V \xff\xff\xff\xff\xf7\x0e\x10\x90\xff\xff\xff\xff\xf8Q\x1e \xff\xff\xff\xff\xf8Ƿ\x10" +
-       "\xff\xff\xff\xff\xfa\nĠ\xff\xff\xff\xff\xfa\xa8\xea\x90\xff\xff\xff\xff\xfb\xeb\xf8 \xff\xff\xff\xff\xfc\x8bo\x90\x00\x00\x00\x00\x1dɀ \x00\x00\x00\x00\x1exɐ\x00\x00\x00\x00\x1f\xa0'\xa0\x00\x00\x00\x00" +
-       " 3\xc1\x90\x00\x00\x00\x00!\x81[ \x00\x00\x00\x00\"\v\xba\x90\x00\x00\x00\x00#X\x02\xa0\x00\x00\x00\x00#\xe2b\x10\x00\x00\x00\x00%7\xe4\xa0\x00\x00\x00\x00%Թ\x10\x00\x00\x00\x007\xf6\xb8\xa0" +
-       "\x00\x00\x00\x008\xb8w\x10\x00\x00\x00\x009\xdf\xd5 \x00\x00\x00\x009\xe9\x01\x90\x00\x00\x00\x00;\xc8\xf1\xa0\x00\x00\x00\x00<o\x00\x90\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xe1\x9c\x00\x00\xff\xff\xf1\xf0\x01\x04\xff\xff\xe3\xe0\x00\bLMT\x00-01\x00-02\x00\n<-02>2\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x1c\x00America/Buenos_AiresUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xa8L\xff\xff" +
-       "\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8" +
-       "\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff" +
-       "\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM" +
-       "\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff" +
-       "\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc3" +
-       "5\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00" +
-       "\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0" +
-       "\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff" +
-       "\xff\xc94\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03" +
-       ">3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\x13\x00\x1c\x00America/Los_AngelesUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^" +
-       "\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff" +
-       "\xff\xff\xff\xd6\xfet\\\xff\xff\xff\xff\u0600\xad\x90\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff\xdf" +
-       "\x89\x8e\x90\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff" +
-       "\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed" +
-       "\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fА\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xb2\x90\xff\xff\xff\xff\xf4_\xa3\x90\xff" +
-       "\xff\xff\xff\xf5O\x94\x90\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb" +
-       "\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00" +
-       "\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t" +
-       "\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00" +
-       "\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18" +
-       "\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00" +
-       "\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&" +
-       "\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00" +
-       "\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004" +
-       "S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00" +
-       "\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00B" +
-       "O\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x91&\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff" +
-       "\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x1c\x00America/El_SalvadorUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa3զ \x00\x00\x00\x00 \x9a" +
-       "\xdc\xe0\x00\x00\x00\x00!\\\x9bP\x00\x00\x00\x00\"z\xbe\xe0\x00\x00\x00\x00#<}P\x02\x01\x02\x01\x02\xff\xff\xac`\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00CDT\x00CST" +
-       "\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x0e\x00\x1c\x00America/DenverUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04" +
-       "\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff" +
-       "\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b" +
-       "v\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00" +
-       "\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d" +
-       "5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00" +
-       "\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169" +
-       ")\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00" +
-       "\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5" +
-       "\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00" +
-       "\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s" +
-       "\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00" +
-       "\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o" +
-       "ΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03" +
-       "\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT" +
-       "\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13" +
-       "\x02\x00\x00\x13\x02\x00\x00\x12\x00\x1c\x00America/Fort_WayneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff" +
-       "\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00" +
-       "\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff" +
-       "\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp" +
-       "\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00" +
-       "\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00" +
-       "CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x1c\x00America/Kentucky/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x1b\x00\x1c\x00America/Kentucky/Louisville" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00u\x00\x00\x00\a\x00" +
-       "\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa4s\xf7\x00\xff\xff\xff\xff\xa5\x16\x11p\xff" +
-       "\xff\xff\xff\xca\rN\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xd7\x1c\xff\xff\xff\xffӤ\tp\xff\xff\xff\xff\xda" +
-       "\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff" +
-       "\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9" +
-       "\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff" +
-       "\xff\xff\xff\xf0\x1e\x90p\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02" +
-       "w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xb2p\x00" +
-       "\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10" +
-       "\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00" +
-       "\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e" +
-       "\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00" +
-       "\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00," +
-       "\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00" +
-       "\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:" +
-       "\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00" +
-       "\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf\x9a\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f" +
-       "\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2." +
-       "0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00\x1b\x00\x1c\x00America/Kentucky/Mon" +
-       "ticelloUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00W\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff" +
-       "\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87" +
-       "\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00" +
-       "\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9" +
-       "\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00" +
-       "\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1" +
-       "\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00" +
-       "\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe" +
-       "\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00" +
-       "\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb" +
-       "\xca\xf0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00" +
-       "\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xb0t\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xc7\xc0\x01\x14\xff\xff\xb9\xb0\x00\x18LMT\x00C" +
-       "DT\x00CST\x00CWT\x00CPT\x00EDT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x1c\x00America/North_Dakota/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQR\x1b\x8b(\xde\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x1c\x00America/North_Dakota/New" +
-       "_SalemUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "Y\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff" +
-       "\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c" +
-       "\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00" +
-       "\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83" +
-       "\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00" +
-       "\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t" +
-       "\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00" +
-       "\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1" +
-       "\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00" +
-       "\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7" +
-       "\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00" +
-       "\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7" +
-       "\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xa0\xed\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10" +
-       "\xff\xff\xb9\xb0\x01\x14\xff\xff\xab\xa0\x00\x18LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CDT\x00CST\x00\nCST6CDT,M3.2.0,M11." +
-       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x1c\x00America/North_Dakota/Cente" +
-       "rUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\a" +
-       "\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p" +
-       "\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00" +
-       "\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ" +
-       "\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00" +
-       "\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10" +
-       "\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00" +
-       "\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00" +
-       "\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00" +
-       "*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00" +
-       "\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x00" +
-       "8\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0" +
-       "\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01" +
-       "\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xa1\b\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xb9\xb0\x01" +
-       "\x14\xff\xff\xab\xa0\x00\x18LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CDT\x00CST\x00\nCST6CDT,M3.2.0,M11.1.0\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb7.\xb6*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x1c\x00America/North_Dakota/BeulahUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x18\xff" +
-       "\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2" +
-       "a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00" +
-       "\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a" +
-       "\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00" +
-       "\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x16" +
-       "9)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00" +
-       "\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$" +
-       "5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00" +
-       "\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002" +
-       "s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00" +
-       "\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@" +
-       "oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x00\x00\x00\x00G-|\x00\x00" +
-       "\x00\x00\x00Gӧ\x10\x00\x00\x00\x00I\r^\x00\x00\x00\x00\x00I\xb3\x89\x10\x00\x00\x00\x00J\xed@\x00\x00\x00\x00\x00K\x9c\xa5\x90\x00\x00\x00\x00L\xd6\\\x80\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\xff\xff\xa0\x95\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14L" +
-       "MT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "QM\x94\xc7Kp\x03\x00\x00p\x03\x00\x00\x11\x00\x1c\x00America/Glace_BayUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xa84\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xdd" +
-       "P\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00" +
-       "\x00\x06@\xd1`\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ" +
-       "\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00" +
-       "\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc" +
-       "`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00" +
-       "\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG" +
-       "\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00" +
-       "\x000\x93\nP\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff" +
-       "\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00" +
-       "\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5" +
-       "P\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc7\xcc\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LM" +
-       "T\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7" +
-       "\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/MontserratUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
+       "\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "Ծ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x1c\x00America/CaymanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
        "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AS" +
-       "T\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x1c\x00America/TorontoUT\t\x00\x03\xec," +
-       "\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff" +
-       "r\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06\xf0\xff\xff\xff\xff\xa3U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0" +
-       "\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff\xff\xaa\x1c\xc9p\xff\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff" +
-       "\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad܍p\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`" +
-       "\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff" +
-       "\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0" +
-       "\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff" +
-       "\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0" +
-       "\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdc\x13t`\xff\xff\xff\xff\xdcމp\xff\xff\xff\xff" +
-       "ݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p" +
-       "\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff" +
-       "\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`" +
-       "\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff" +
-       "\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0" +
-       "\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00" +
-       "\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0" +
-       "\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00" +
-       "\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp" +
-       "\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00" +
-       "$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0" +
-       "\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x00" +
-       "2r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0" +
-       "\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00" +
-       "@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xb5\x94\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0" +
-       "\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x1c\x00America/PanamaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffi\x87&\x10\xff\xff\xff\xff\x8b\xf4a" +
-       "\xe8\x01\x02\xff\xff\xb5p\x00\x00\xff\xff\xb5\x18\x00\x04\xff\xff\xb9\xb0\x00\bLMT\x00CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xef\xf0R\x8a\xc4\x02\x00" +
-       "\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/CordobaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff" +
-       "\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbe" +
-       "x\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff" +
-       "\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xff\xce" +
-       "\xb0\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff" +
-       "\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe" +
-       "\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00" +
-       "\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008" +
-       "\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f" +
-       "\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdf\xe5\x8d\xc4\xda\x04" +
-       "\x00\x00\xda\x04\x00\x00\x12\x00\x1c\x00America/LouisvilleUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00u\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0" +
-       "\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa4s\xf7\x00\xff\xff\xff\xff\xa5\x16\x11p\xff\xff\xff\xff\xca\rN\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff" +
-       "\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xd7\x1c\xff\xff\xff\xffӤ\tp\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\xde" +
-       "\xbey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff" +
-       "\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec" +
-       "\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x1e\x90p\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff" +
-       "\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06" +
-       "@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffi\x87&\x10\xff\xff\xff\xff\x8b\xf4a\xe8\x01\x02\xff\xff\xb5p\x00\x00\xff\xff\xb5" +
+       "\x18\x00\x04\xff\xff\xb9\xb0\x00\bLMT\x00CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rp\x1b\xceRC\x03\x00\x00C\x03\x00\x00\x0f\x00\x1c\x00Ame" +
+       "rica/NipigonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00J\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xee\x81@\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xc8\xf8IP\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2" +
+       "#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00" +
        "\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14" +
        "Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00" +
        "\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"" +
@@ -1808,777 +1390,1370 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00" +
        "\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>" +
        "\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00" +
-       "\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x01\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\xff\xff\xaf\x9a\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CW" +
-       "T\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00" +
-       "\x01\x04\x00\x00\x10\x00\x1c\x00America/EnsenadaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad@\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00E" +
+       "ST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00" +
+       "\x00\x0e\x00\x1c\x00America/DenverUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a" +
+       "\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff" +
+       "\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8" +
+       ":\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00" +
+       "\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\v\xe0" +
+       "\xa1\x90\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00" +
+       "\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02" +
+       "'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00" +
+       "\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfe" +
+       "ߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00" +
+       "\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062" +
+       "ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00" +
+       "\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/" +
+       "\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00" +
+       "\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0" +
+       ",M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R+\x10`ȫ\x02\x00\x00\xab\x02\x00\x00\x14\x00\x1c\x00America/Dawson_CreekU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x06\x00\x00" +
+       "\x00\x18\xff\xff\xff\xff^=t8\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff" +
+       "\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\xde" +
+       "\xb3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff" +
+       "\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2" +
+       "\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff" +
+       "\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0f" +
+       "f\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00" +
+       "\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05\x01\xf0\x90\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\xff\xff\x8fH\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80" +
+       "\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x00\x14LMT\x00PDT\x00PST\x00PWT\x00PPT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\f\x00\x1c\x00America/NuukUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00" +
+       "\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b" +
+       "\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00" +
+       "\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)" +
+       "\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00" +
+       "\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bL" +
+       "MT\x00-03\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf2" +
+       "\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00\x00\x0e\x00\x1c\x00America/CancunUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00*\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\x16\x86\xd5`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x00" +
+       "2r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x005\xc4\x00`\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0" +
+       "\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00" +
+       "?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00F\x0ff\x80" +
+       "\x00\x00\x00\x00G$3p\x00\x00\x00\x00G\xf8\x83\x00\x00\x00\x00\x00I\x04\x15p\x00\x00\x00\x00I\xd8e\x00\x00\x00\x00\x00J\xe3\xf7p\x00\x00\x00\x00K\xb8G\x00\x00\x00\x00\x00L\xcd\x13\xf0\x00\x00\x00\x00" +
+       "M\x98)\x00\x00\x00\x00\x00N\xac\xf5\xf0\x00\x00\x00\x00Ox\v\x00\x00\x00\x00\x00P\x8c\xd7\xf0\x00\x00\x00\x00Qa'\x80\x00\x00\x00\x00Rl\xb9\xf0\x00\x00\x00\x00SA\t\x80\x00\x00\x00\x00TL\x9b\xf0" +
+       "\x00\x00\x00\x00T\xcd\xdd\x00\x01\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\xff\xff\xae\xa8\x00\x00\xff\xff\xab\xa0" +
+       "\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10LMT\x00CST\x00EDT\x00EST\x00CDT\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "n\xab\xd5\xf9\xcf\x03\x00\x00\xcf\x03\x00\x00\f\x00\x1c\x00America/NomeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00&\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87O\xd2\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2" +
+       "#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00" +
+       "\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t" +
+       "\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00" +
+       "\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18" +
+       "\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00" +
+       "\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%" +
+       "J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00" +
+       "\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003" +
+       "G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00" +
+       "\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A" +
+       "\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
+       "\b\t\b\t\b\t\b\x00\x00\xb6n\x00\x00\xff\xffd\xee\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xffs`\x01\x14\xff\xff\x81p\x00\x18\xff\xff\x8f\x80\x01" +
+       "\x1c\xff\xff\x81p\x00!LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2" +
+       ".0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00\x00\x0f\x00\x1c\x00America/YakutatUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\b\x00\x00\x00\x1e\xff" +
+       "\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x877\xbf\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff\xff\xfe\xb8U0\xff\xff\xff\xff\xff\xa88 \x00\x00\x00\x00\x00" +
+       "\x9870\x00\x00\x00\x00\x01\x88\x1a \x00\x00\x00\x00\x02x\x190\x00\x00\x00\x00\x03q6\xa0\x00\x00\x00\x00\x04a5\xb0\x00\x00\x00\x00\x05Q\x18\xa0\x00\x00\x00\x00\x06A\x17\xb0\x00\x00\x00\x00\a0\xfa\xa0\x00" +
+       "\x00\x00\x00\a\x8dQ\xb0\x00\x00\x00\x00\t\x10ܠ\x00\x00\x00\x00\t\xad\xcd0\x00\x00\x00\x00\n\xf0\xbe\xa0\x00\x00\x00\x00\v\u0f70\x00\x00\x00\x00\f\xd9\xdb \x00\x00\x00\x00\r\xc0\x9f\xb0\x00\x00\x00\x00\x0e" +
+       "\xb9\xbd \x00\x00\x00\x00\x0f\xa9\xbc0\x00\x00\x00\x00\x10\x99\x9f \x00\x00\x00\x00\x11\x89\x9e0\x00\x00\x00\x00\x12y\x81 \x00\x00\x00\x00\x13i\x800\x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x15Ib0\x00" +
+       "\x00\x00\x00\x169E \x00\x00\x00\x00\x17)D0\x00\x00\x00\x00\x18\"a\xa0\x00\x00\x00\x00\x19\t&0\x00\x00\x00\x00\x1a\x02C\xa0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b" +
+       "\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00" +
+       "\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)" +
+       "\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00" +
+       "\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008" +
+       "\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00" +
+       "\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E" +
+       "\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
+       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\x00\x00\u0381\x00\x00\xff\xff}\x01\x00\x00\xff\xff\x81p\x00\x04\xff\xff\x8f\x80\x01\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80" +
+       "\x01\x10\xff\xff\x8f\x80\x01\x14\xff\xff\x81p\x00\x19LMT\x00YST\x00YWT\x00YPT\x00YDT\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2." +
+       "0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00America/GrenadaUT\t\x00\x03" +
+       "\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff" +
+       "\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f" +
+       "\x00\x1c\x00America/RosarioUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f" +
+       "@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff" +
+       "\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*" +
+       "0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff" +
+       "\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C" +
+       "\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff" +
+       "\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f" +
+       "0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00" +
+       "\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10" +
+       "\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe\x00\x00\x00" +
+       "\x0f\x00\x1c\x00America/CaracasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffi\x87\x1a@\xff\xff\xff\xff\x93\x1e,<\xff\xff\xff\xff\xf6\x98\xecH\x00\x00\x00\x00G[\x92p\x00\x00\x00\x00W%" +
+       "\xa9p\x01\x02\x03\x02\x03\xff\xff\xc1@\x00\x00\xff\xff\xc1D\x00\x04\xff\xff\xc0\xb8\x00\b\xff\xff\xc7\xc0\x00\x0eLMT\x00CMT\x00-0430\x00-04\x00\n<-04>4\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9Ro_\x00v/\x01\x00\x00/\x01\x00\x00\x0e\x00\x1c\x00America/MeridaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\x16\x86\xd5`" +
+       "\x00\x00\x00\x00\x18LKP\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x00" +
+       "7\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x03\x01\x03\x01\x03" +
+       "\x01\x03\x01\x03\x01\x03\x01\x03\xff\xff\xab\xfc\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xb9\xb0\x01\fLMT\x00CST\x00EST\x00CDT\x00\nCST6CDT,M4." +
+       "1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x1c\x00America/Buenos_Air" +
+       "esUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00" +
+       "\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xa8L\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}" +
+       "\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff" +
+       "\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf" +
+       "0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff" +
+       "\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w" +
+       "@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00" +
+       "\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xf1" +
+       "0\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00" +
+       "\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc94\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-0" +
+       "4\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x1c\x00America/Rain" +
+       "y_RiverUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00J\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xee\x87(\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff" +
+       "\xff\xff\xd2a\t\xf0\x00\x00\x00\x00\b π\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\n\x00\xb1\x80\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0" +
+       "u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00" +
+       "\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1" +
+       "\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00" +
+       "\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\xde" +
+       "\xb3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00" +
+       "\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b" +
+       "\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00" +
+       "\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3" +
+       "\xb7\x00\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa7X\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CW" +
+       "T\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x1c\x00" +
+       "America/PhoenixUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff" +
+       "\xff\xffˉ\f\x90\xff\xff\xff\xff\xcf\x17\xdf\x1c\xff\xff\xff\xffϏ\xe5\xac\xff\xff\xff\xffЁ\x1a\x1c\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\x02\x01\x02\x01\x02\x03\x02\x03\x02\x01\x02\xff\xff\x96" +
+       "\xee\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\fLMT\x00MDT\x00MST\x00MWT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xdf\xe5\x8d" +
+       "\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x12\x00\x1c\x00America/LouisvilleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00u\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff" +
+       "\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa4s\xf7\x00\xff\xff\xff\xff\xa5\x16\x11p\xff\xff\xff\xff\xca\rN\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#" +
+       "\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xd7\x1c\xff\xff\xff\xffӤ\tp\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff" +
+       "\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)" +
+       "\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff" +
+       "\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x1e\x90p\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8" +
+       "\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00" +
+       "\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f\xd9" +
+       "\xa2\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00" +
+       "\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2" +
+       "\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00" +
+       "\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\n" +
+       "U\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00" +
+       "\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a" +
+       "\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00" +
+       "\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00ED" +
+       "C`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05" +
+       "\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05" +
+       "\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf\x9a\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST" +
+       "\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk^2S\xb9" +
+       "\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x1c\x00America/Punta_ArenasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00t\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1d\xfc\xff\xff\xff\xff\x8f0GF\xff\xff\xff\xff\x9b\\\xe5P\xff\xff" +
+       "\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@\xff\xff\xff\xff\xb2A\x00\xd0\xff\xff\xff\xff\xb3Xp\xc0\xff\xff\xff\xff\xb4\"4P\xff\xff\xff\xff\xb59" +
+       "\xa4@\xff\xff\xff\xff\xb6\x03g\xd0\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xc7 P\xff\xff\xff\xff\xcc\x1cn@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff" +
+       "\xff\xff\xd53U\xc0\xff\xff\xff\xff\xd5v\x92@\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@" +
+       "I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00" +
+       "\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86" +
+       "\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00" +
+       "\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep" +
+       "\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00" +
+       "\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7" +
+       "\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00" +
+       "\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa" +
+       "\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00" +
+       "\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1" +
+       "v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00" +
+       "\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00XC" +
+       "\x86\xb0\x01\x02\x01\x03\x01\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x06\xff\xff" +
+       "\xbd\x84\x00\x00\xff\xff\xbd\xba\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10\xff\xff\xd5\xd0\x00\x10LMT\x00SMT\x00-05\x00-04\x00-03\x00" +
+       "\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/Porto_AcreUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x04\x00\x00\x00\f\xff" +
+       "\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc" +
+       "\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff" +
+       "\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc" +
+       "\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00\x00\x00\x00H`\u007fP\x00" +
+       "\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0" +
+       "\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\x10\x00\x1c\x00America/" +
+       "New_YorkUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xaf\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x03\xf0\x90\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1\x9a\xcd`\xff\xff\xff\xff\xa2e\xe2p\xff" +
+       "\xff\xff\xff\xa3\x83\xe9\xe0\xff\xff\xff\xff\xa4j\xaep\xff\xff\xff\xff\xa55\xa7`\xff\xff\xff\xff\xa6S\xca\xf0\xff\xff\xff\xff\xa7\x15\x89`\xff\xff\xff\xff\xa83\xac\xf0\xff\xff\xff\xff\xa8\xfe\xa5\xe0\xff\xff\xff\xff\xaa" +
+       "\x13\x8e\xf0\xff\xff\xff\xff\xaaއ\xe0\xff\xff\xff\xff\xab\xf3p\xf0\xff\xff\xff\xff\xac\xbei\xe0\xff\xff\xff\xff\xad\xd3R\xf0\xff\xff\xff\xff\xae\x9eK\xe0\xff\xff\xff\xff\xaf\xb34\xf0\xff\xff\xff\xff\xb0~-\xe0\xff" +
+       "\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8" +
+       "\x06\xf0`\xff\xff\xff\xff\xb9\x1b\xd9p\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbbƴ`\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff" +
+       "\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6" +
+       "M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xff\xca\r@p\xff\xff\xff\xff\xca\xd89`\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff" +
+       "\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U\xc6\xf0\xff\xff\xff\xff\xd6 \xbf\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xd9" +
+       "\x15\x8a\xf0\xff\xff\xff\xff\xd9\xe0\x83\xe0\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdb\xc0e\xe0\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff" +
+       "\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5W.\xe0\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7" +
+       "7\x10\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff" +
+       "\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5" +
+       "Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff" +
+       "\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03" +
+       "p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00" +
+       "\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11" +
+       "\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00" +
+       "\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f" +
+       "\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00" +
+       "\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-" +
+       "\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00" +
+       "\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;" +
+       "۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00" +
+       "\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xba\x9e\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00" +
+       "EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xad`\x12\xe9\xaa\x00" +
+       "\x00\x00\xaa\x00\x00\x00\x0e\x00\x1c\x00America/La_PazUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff" +
-       "\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2" +
-       "~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff" +
-       "\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f" +
-       "\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00" +
-       "\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a" +
-       "\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00" +
-       "\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)" +
-       "\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00" +
-       "\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007" +
-       "\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00" +
-       "\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00E" +
-       "Dm\x90\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01" +
-       "\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d" +
-       "\x90\x01\x10\xff\xff\x9d\x90\x01\x14LMT\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x10\x00\x1c\x00America/ShiprockUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6" +
-       ":\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff\xff\xff\xa4\x8f\xa6\x80\xff\xff" +
-       "\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8" +
-       "u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00" +
-       "\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10" +
-       "\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00" +
-       "\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)" +
-       "(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00" +
-       "\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J" +
-       "\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00" +
-       "\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003G" +
-       "f\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00" +
-       "\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84" +
-       "\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87\x1bd\xff\xff\xff\xff\xb8\x1e\x96\xe4\xff\xff\xff\xff\xb8\xee\xd5\xd4\x01\x02\x03\xff\xff\xc0\x1c\x00\x00" +
+       "\xff\xff\xc0\x1c\x00\x04\xff\xff\xce,\x01\b\xff\xff\xc7\xc0\x00\fLMT\x00CMT\x00BST\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb7-2f" +
+       "\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x1c\x00America/NoronhaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaaed\xff\xff\xff\xff\xb8\x0f;\xd0\xff\xff\xff\xff\xb8\xfd2\x90\xff\xff\xff\xff\xb9\xf1" +
+       "& \xff\xff\xff\xff\xba\xdef\x10\xff\xff\xff\xff\xda8\xa0 \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdc\x19Ӡ\xff\xff\xff\xffܹK\x10\xff\xff\xff\xff\xdd\xfb\a \xff\xff\xff\xffޛ\xd0\x10\xff\xff" +
+       "\xff\xff\xdf\u074c \xff\xff\xff\xff\xe0T%\x10\xff\xff\xff\xff\xf4\x97\xf1\xa0\xff\xff\xff\xff\xf5\x05P\x10\xff\xff\xff\xff\xf6\xc0V \xff\xff\xff\xff\xf7\x0e\x10\x90\xff\xff\xff\xff\xf8Q\x1e \xff\xff\xff\xff\xf8\xc7" +
+       "\xb7\x10\xff\xff\xff\xff\xfa\nĠ\xff\xff\xff\xff\xfa\xa8\xea\x90\xff\xff\xff\xff\xfb\xeb\xf8 \xff\xff\xff\xff\xfc\x8bo\x90\x00\x00\x00\x00\x1dɀ \x00\x00\x00\x00\x1exɐ\x00\x00\x00\x00\x1f\xa0'\xa0\x00\x00" +
+       "\x00\x00 3\xc1\x90\x00\x00\x00\x00!\x81[ \x00\x00\x00\x00\"\v\xba\x90\x00\x00\x00\x00#X\x02\xa0\x00\x00\x00\x00#\xe2b\x10\x00\x00\x00\x00%7\xe4\xa0\x00\x00\x00\x00%Թ\x10\x00\x00\x00\x007\xf6" +
+       "\xb8\xa0\x00\x00\x00\x008\xb8w\x10\x00\x00\x00\x009\xdf\xd5 \x00\x00\x00\x009\xe9\x01\x90\x00\x00\x00\x00;\xc8\xf1\xa0\x00\x00\x00\x00<o\x00\x90\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xe1\x9c\x00\x00\xff\xff\xf1\xf0\x01\x04\xff\xff\xe3\xe0\x00\bLMT\x00-01\x00-02\x00\n<-02>2\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/GuadeloupeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff" +
+       "\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00\x00\x14\x00\x1c\x00Ameri" +
+       "ca/Campo_GrandeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaaz4\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff" +
+       "\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0T" +
+       "A0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff" +
+       "\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81" +
+       "w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00#X\x1e\xc0\x00\x00\x00\x00#\xe2~0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xd4\xd50\x00\x00\x00\x00'!\x1d@\x00\x00\x00\x00'\xbd\xf1\xb0\x00\x00" +
+       "\x00\x00)\x00\xff@\x00\x00\x00\x00)\x94\x990\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+k@\xb0\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x00\x00\x00\x00.\xa0\xa5@\x00\x00\x00\x00/F" +
+       "\xb40\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001\x1d[\xb0\x00\x00\x00\x002W.\xc0\x00\x00\x00\x003\x06x0\x00\x00\x00\x0048b@\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006 -@\x00\x00" +
+       "\x00\x006\xcfv\xb0\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x00:\x8f:\xb0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<o\x1c\xb0\x00\x00\x00\x00=\xc4" +
+       "\x9f@\x00\x00\x00\x00>N\xfe\xb0\x00\x00\x00\x00?\x92\f@\x00\x00\x00\x00@.\xe0\xb0\x00\x00\x00\x00A\x87\x06@\x00\x00\x00\x00B\x17\xfd0\x00\x00\x00\x00CQ\xd0@\x00\x00\x00\x00C\xf7\xdf0\x00\x00" +
+       "\x00\x00EMa\xc0\x00\x00\x00\x00E\xe0\xfb\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xb7\xa30\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\x97\x850\x00\x00\x00\x00Jڒ\xc0\x00\x00\x00\x00K\x80" +
+       "\xa1\xb0\x00\x00\x00\x00L\xbat\xc0\x00\x00\x00\x00M`\x83\xb0\x00\x00\x00\x00N\x9aV\xc0\x00\x00\x00\x00OI\xa00\x00\x00\x00\x00P\x83s@\x00\x00\x00\x00Q G\xb0\x00\x00\x00\x00RcU@\x00\x00" +
+       "\x00\x00S\x00)\xb0\x00\x00\x00\x00TC7@\x00\x00\x00\x00T\xe9F0\x00\x00\x00\x00V#\x19@\x00\x00\x00\x00V\xc9(0\x00\x00\x00\x00X\x02\xfb@\x00\x00\x00\x00X\xa9\n0\x00\x00\x00\x00Y\xe2" +
+       "\xdd@\x00\x00\x00\x00Z\x88\xec0\x00\x00\x00\x00[\xden\xc0\x00\x00\x00\x00\\h\xce0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xcc" +
+       "\xcc\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00" +
+       "\x00\x14\x00\x1c\x00America/ScoresbysundUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x9b\x80L\x18\x00\x00\x00\x00\x13Mn@\x00\x00\x00\x00\x144$\xc0\x00\x00\x00\x00\x15#\xf9\xa0" +
+       "\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00" +
+       "\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10" +
+       "\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00" +
+       "*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10" +
+       "\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xff\xebh\x00\x00\xff\xff\xe3\xe0\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xf1\xf0\x00\b\x00\x00" +
+       "\x00\x00\x01\fLMT\x00-02\x00-01\x00+00\x00\n<-01>1<+00>,M3.5.0/0,M10.5.0/1\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x1c\x00America/North_Dakota/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x1c\x00America/North_Dakot" +
+       "a/CenterUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00Y\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff" +
+       "\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff" +
+       "\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00" +
+       "\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r" +
+       "\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00" +
+       "\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b" +
+       "\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00" +
+       "\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)" +
+       "\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00" +
+       "\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008" +
+       "\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00" +
+       "\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E" +
+       "\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xa1\b\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0" +
+       "\x01\x10\xff\xff\xb9\xb0\x01\x14\xff\xff\xab\xa0\x00\x18LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CDT\x00CST\x00\nCST6CDT,M3.2.0,M1" +
+       "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RR\x1b\x8b(\xde\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x1c\x00America/North_Dakota/New" +
+       "_SalemUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "Y\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff" +
+       "\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c" +
+       "\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00" +
+       "\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83" +
+       "\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00" +
+       "\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t" +
+       "\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00" +
+       "\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1" +
+       "\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00" +
+       "\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7" +
+       "\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00" +
+       "\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7" +
+       "\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xa0\xed\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10" +
+       "\xff\xff\xb9\xb0\x01\x14\xff\xff\xab\xa0\x00\x18LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CDT\x00CST\x00\nCST6CDT,M3.2.0,M11." +
+       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb7.\xb6*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x1c\x00America/North_Dakota/Beula" +
+       "hUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06" +
+       "\x00\x00\x00\x18\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p" +
+       "\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00" +
+       "\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ" +
+       "\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00" +
+       "\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10" +
+       "\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00" +
+       "\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00" +
+       "\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00" +
+       "*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10" +
+       "\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x00" +
+       "8\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00" +
+       "\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x00\x00\x00\x00" +
+       "G-|\x00\x00\x00\x00\x00Gӧ\x10\x00\x00\x00\x00I\r^\x00\x00\x00\x00\x00I\xb3\x89\x10\x00\x00\x00\x00J\xed@\x00\x00\x00\x00\x00K\x9c\xa5\x90\x00\x00\x00\x00L\xd6\\\x80\x02\x01\x02\x01\x02\x03\x04\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST" +
-       "\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f" +
-       "\x00\x1c\x00America/OjinagaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6" +
-       "`\xff\xff\xff\xff\xb8\xfd\x86\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00" +
-       "\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d" +
-       "\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00" +
-       "\x00ED_\x80\x00\x00\x00\x00F\x0ft\x90\x00\x00\x00\x00G$A\x80\x00\x00\x00\x00G\xf8\x91\x10\x00\x00\x00\x00I\x04#\x80\x00\x00\x00\x00I\xd8s\x10\x00\x00\x00\x00J\xe4\x05\x80\x00\x00\x00\x00K\x9c\xa5" +
-       "\x90\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff\xff\x9e\x1c\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f" +
-       "\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00CDT\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQU\r\xf7\xd3\xc7\x01\x00\x00\xc7\x01\x00\x00\r\x00\x1c\x00America/ThuleUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80w\xfc\x00\x00\x00\x00'\xf5z\xe0\x00\x00\x00\x00(\xe5]\xd0" +
-       "\x00\x00\x00\x00)\xd5\\\xe0\x00\x00\x00\x00*\xc5?\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x00" +
-       "0\x93\nP\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0" +
-       "\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00" +
-       ">\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P" +
-       "\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xbf\x84\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b" +
-       "LMT\x00ADT\x00AST\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe\x00" +
-       "\x00\x00\x0f\x00\x1c\x00America/CaracasUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffi\x87\x1a@\xff\xff\xff\xff\x93\x1e,<\xff\xff\xff\xff\xf6\x98\xecH\x00\x00\x00\x00G[\x92p\x00\x00\x00\x00" +
-       "W%\xa9p\x01\x02\x03\x02\x03\xff\xff\xc1@\x00\x00\xff\xff\xc1D\x00\x04\xff\xff\xc0\xb8\x00\b\xff\xff\xc7\xc0\x00\x0eLMT\x00CMT\x00-0430\x00-04\x00\n<-04>4\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x1c\x00America/AraguainaUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaat0\xff\xff\xff" +
-       "\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY" +
-       " \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff" +
-       "\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ" +
-       "0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00" +
-       "\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00\x00\x004\xf8\xc1" +
-       " \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00" +
-       "\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00P\x83e0\x00\x00\x00\x00Q 9\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd2\xd0\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<" +
-       "-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1d`̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x1c\x00America/Cambridge_BayUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\t\x00\x00\x00%" +
-       "\xff\xff\xff\xff\xa1\xf2̀\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(\x85\xf0\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00" +
-       "\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90" +
-       "\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00" +
-       "\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00" +
-       "\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x00" +
-       "0\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10" +
-       "\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\x04\xe9P\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00" +
-       "=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90" +
-       "\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x03\x01\x02\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
-       "\x05\a\x06\b\a\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x00\x00\x00\x00\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xab\xa0\x01\x15\xff\xff\xb9\xb0\x01\x19" +
-       "\xff\xff\xab\xa0\x00\x1d\xff\xff\xb9\xb0\x00!-00\x00MWT\x00MPT\x00MST\x00MDDT\x00MDT\x00CDT\x00CST\x00EST\x00\nMST7MDT,M3" +
-       ".2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x1c\x00America/WinnipegU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00" +
-       "\x00\x14\xff\xff\xff\xffd䰔\xff\xff\xff\xff\x9b\x01\xfb\xe0\xff\xff\xff\xff\x9búP\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\u00a0;\x80\xff\xff\xff\xff\xc3O\x84\xf0\xff\xff" +
-       "\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xffӈh\x00\xff\xff\xff\xff\xd4S`\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75" +
-       "\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xdb\x00\a\x00\xff\xff\xff\xff\xdb\xc8\\\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff" +
-       "\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)" +
-       "\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff" +
-       "\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf41b\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8" +
-       "g\x00\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00" +
-       "\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b π\x00\x00\x00\x00\t\x10" +
-       "\xc0\x80\x00\x00\x00\x00\n\x00\xb1\x80\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00" +
-       "\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)" +
-       "\x1a\x00\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00" +
-       "\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J" +
-       "\xae\x00\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00\x00" +
-       "\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003G" +
-       "X\x00\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005':\x00\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xd9\x00\x00\x00" +
-       "\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84" +
-       "\x9b\x80\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\xff\xff\xa0\x95\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff" +
+       "\xab\xa0\x00\x14LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x1c\x00America/Goose_BayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff^=<$\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff" +
+       "\xff\xff\x9f\xba\xd6|\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff\xff\u0098\x138\xff\xff\xff\xff\xc3YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59" +
+       "\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2(\xff\xff\xff\xff\xca ո\xff\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff" +
+       "\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff\xff\xd5h&\xd8\xff\xff\xff\xff\xd6)\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t" +
+       "\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5\xc8\xff\xff\xff\xff\xdc\xdetX\xff\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff" +
+       "\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff\xff\xe3I\x13H\xff\xff\xff\xff\xe4]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G" +
+       "\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc\xd8\xff\xff\xff\xff\xea\xd1\xd5\xc8\xff\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff" +
+       "\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffeH\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff\xff\xf1\x8f\x9fX\xff\xff\xff\xff\xf2\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_" +
+       "dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b\xc8\xff\xff\xff\xff\xf8\xdakX\xff\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff" +
+       "\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87" +
+       "\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00" +
+       "\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9" +
+       "u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00" +
+       "\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1" +
+       "\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xd6\xfc\x00\x00\x00\x00!\x81il\x00\x00\x00\x00\"U\xb8\xfc\x00\x00\x00\x00#jw\xdc\x00\x00\x00\x00$5\x9a\xfc\x00\x00" +
+       "\x00\x00%Jg\xec\x00\x00\x00\x00&\x15|\xfc\x00\x00\x00\x00'*I\xec\x00\x00\x00\x00'\xfe\x99|\x00\x00\x00\x00)\n+\xec\x00\x00\x00\x00)\xde{|\x00\x00\x00\x00*\xea\r\xec\x00\x00\x00\x00+\xbe" +
+       "]|\x00\x00\x00\x00,\xd3*l\x00\x00\x00\x00-\x9e?|\x00\x00\x00\x00.\xb3\fl\x00\x00\x00\x00/~!|\x00\x00\x00\x000\x92\xeel\x00\x00\x00\x001g=\xfc\x00\x00\x00\x002r\xd0l\x00\x00" +
+       "\x00\x003G\x1f\xfc\x00\x00\x00\x004R\xb2l\x00\x00\x00\x005'\x01\xfc\x00\x00\x00\x0062\x94l\x00\x00\x00\x007\x06\xe3\xfc\x00\x00\x00\x008\x1b\xb0\xec\x00\x00\x00\x008\xe6\xc5\xfc\x00\x00\x00\x009\xfb" +
+       "\x92\xec\x00\x00\x00\x00:Ƨ\xfc\x00\x00\x00\x00;\xdbt\xec\x00\x00\x00\x00<\xaf\xc4|\x00\x00\x00\x00=\xbbV\xec\x00\x00\x00\x00>\x8f\xa6|\x00\x00\x00\x00?\x9b8\xec\x00\x00\x00\x00@o\x88|\x00\x00" +
+       "\x00\x00A\x84Ul\x00\x00\x00\x00BOj|\x00\x00\x00\x00Cd7l\x00\x00\x00\x00D/L|\x00\x00\x00\x00ED\x19l\x00\x00\x00\x00E\xf3~\xfc\x00\x00\x00\x00G-5\xec\x00\x00\x00\x00G\xd3" +
+       "`\xfc\x00\x00\x00\x00I\r\x17\xec\x00\x00\x00\x00I\xb3B\xfc\x00\x00\x00\x00J\xec\xf9\xec\x00\x00\x00\x00K\x9c_|\x00\x00\x00\x00L\xd6\x16l\x00\x00\x00\x00M|A|\x00\x00\x00\x00N\xb6\x14P\x01\x02" +
+       "\x01\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\b\a\b" +
+       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\t\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b" +
+       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\xff\xff\xc7\\\x00\x00\xff\xffΔ\x00\x04\xff\xffܤ\x01\b\xff\xff\xce\xc8\x00\x04\xff\xff\xdc\xd8\x01\b" +
+       "\xff\xff\xdc\xd8\x01\f\xff\xff\xdc\xd8\x01\x10\xff\xff\xd5\xd0\x01\x14\xff\xff\xc7\xc0\x00\x18\xff\xff\xe3\xe0\x01\x1cLMT\x00NST\x00NDT\x00NPT\x00NWT\x00ADT\x00AST\x00AD" +
+       "DT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x12\x00\x1c\x00Ame" +
+       "rica/Fort_WayneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff" +
+       "\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U" +
+       "\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff" +
+       "\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I" +
+       "6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00" +
+       "\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00CDT\x00CST\x00CWT\x00CP" +
+       "T\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R):\x17-\x88\x06\x00\x00\x88\x06\x00\x00" +
+       "\x0f\x00\x1c\x00America/HalifaxUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xab\xa0\xff\xff\xff\xff\x9a\xe4\xde\xc0\xff\xff\xff\xff\x9b\xd6\x130\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba" +
+       "\xddP\xff\xff\xff\xff\xa2\x9d\x17@\xff\xff\xff\xff\xa30\xb10\xff\xff\xff\xff\xa4zV@\xff\xff\xff\xff\xa5\x1b\x1f0\xff\xff\xff\xff\xa6S\xa0\xc0\xff\xff\xff\xff\xa6\xfcR\xb0\xff\xff\xff\xff\xa8<\xbd@\xff\xff" +
+       "\xff\xff\xa8\xdc4\xb0\xff\xff\xff\xff\xaa\x1c\x9f@\xff\xff\xff\xff\xaa\xcd:0\xff\xff\xff\xff\xab\xfc\x81@\xff\xff\xff\xff\xac\xbf\x910\xff\xff\xff\xff\xad\xee\xd8@\xff\xff\xff\xff\xae\x8c\xfe0\xff\xff\xff\xff\xaf\xbc" +
+       "E@\xff\xff\xff\xff\xb0\u007fU0\xff\xff\xff\xff\xb1\xae\x9c@\xff\xff\xff\xff\xb2Kp\xb0\xff\xff\xff\xff\xb3\x8e~@\xff\xff\xff\xff\xb4$\xbb0\xff\xff\xff\xff\xb5n`@\xff\xff\xff\xff\xb6\x15\xc0\xb0\xff\xff" +
+       "\xff\xff\xb7NB@\xff\xff\xff\xff\xb8\b\x17\xb0\xff\xff\xff\xff\xb9$\xe9\xc0\xff\xff\xff\xff\xb9\xe7\xf9\xb0\xff\xff\xff\xff\xbb\x04\xcb\xc0\xff\xff\xff\xff\xbb\xd1\x160\xff\xff\xff\xff\xbd\x00]@\xff\xff\xff\xff\xbd\x9d" +
+       "1\xb0\xff\xff\xff\xff\xbe\xf2\xb4@\xff\xff\xff\xff\xbf\x90\xda0\xff\xff\xff\xff\xc0\xd3\xe7\xc0\xff\xff\xff\xff\xc1^G0\xff\xff\xff\xff\u008d\x8e@\xff\xff\xff\xff\xc3P\x9e0\xff\xff\xff\xff\xc4mp@\xff\xff" +
+       "\xff\xff\xc50\x800\xff\xff\xff\xff\xc6r<@\xff\xff\xff\xff\xc7\x10b0\xff\xff\xff\xff\xc86n\xc0\xff\xff\xff\xff\xc8\xf9~\xb0\xff\xff\xff\xff\xca\x16P\xc0\xff\xff\xff\xff\xca\xd9`\xb0\xff\xff\xff\xffˈ" +
+       "\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@\xcf\xd0\xff\xff\xff\xff\xd5U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff" +
+       "\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9\x15|\xe0\xff\xff\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xdc\xde{`\xff\xff\xff\xffݩtP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e" +
+       "?`\xff\xff\xff\xff\xe1i8P\xff\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3I\x1aP\xff\xff\xff\xff\xe6G\x1f\xe0\xff\xff\xff\xff\xe7\x12\x18\xd0\xff\xff\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe8\xf1\xfa\xd0\xff\xff" +
+       "\xff\xff\xea\x06\xe3\xe0\xff\xff\xff\xff\xea\xd1\xdc\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff챾\xd0\xff\xff\xff\xff\xf1\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_" +
+       "kP\xff\xff\xff\xff\xf5Oj`\xff\xff\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(i\xd0\xff\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff" +
+       "\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w" +
+       "\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00" +
+       "\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99" +
+       "X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00" +
+       "\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1" +
+       "\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00" +
+       "\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3" +
+       "FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00" +
+       "\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6" +
+       "\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00" +
+       "\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa4\xec\x00\x00\xff\xff\xb9\xb0\x01\x04\xff" +
-       "\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ8\xa4]Q^\x03\x00\x00^\x03\x00\x00\x12\x00\x1c\x00America/Grand_TurkUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00M\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1e0" +
-       "\xff\xff\xff\xff\x93\x0f\xb4\xfe\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00" +
-       "\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`" +
-       "\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00" +
-       "%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p" +
-       "\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x00" +
-       "3GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0" +
-       "\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00" +
-       "A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x00\x00\x00\x00G-_\xe0\x00\x00\x00\x00Gӊ\xf0" +
-       "\x00\x00\x00\x00I\rA\xe0\x00\x00\x00\x00I\xb3l\xf0\x00\x00\x00\x00J\xed#\xe0\x00\x00\x00\x00K\x9c\x89p\x00\x00\x00\x00L\xd6@`\x00\x00\x00\x00M|kp\x00\x00\x00\x00N\xb6\"`\x00\x00\x00\x00" +
-       "O\\Mp\x00\x00\x00\x00P\x96\x04`\x00\x00\x00\x00Q</p\x00\x00\x00\x00Ru\xe6`\x00\x00\x00\x00S\x1c\x11p\x00\x00\x00\x00TU\xc8`\x00\x00\x00\x00T\xfb\xf3p\x00\x00\x00\x00V5\xaa`" +
-       "\x00\x00\x00\x00Z\xa4\xd3\xf0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\xff\xff\xbdP\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x00\x10LMT\x00K" +
-       "MT\x00EST\x00EDT\x00AST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00" +
-       "\x00\x82\x00\x00\x00\x0e\x00\x1c\x00America/VirginUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11\x00\x1c\x00America/AnchorageUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00(\xff\xff\xff\xff?\xc2\xfd\xd1\xff" +
-       "\xff\xff\xff}\x87AH\xff\xff\xff\xffˉ6\xc0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aB0\xff\xff\xff\xff\xfa\xd2G\xa0\xff\xff\xff\xff\xfe\xb8c@\xff\xff\xff\xff\xff\xa8F0\x00\x00\x00\x00\x00" +
-       "\x98E@\x00\x00\x00\x00\x01\x88(0\x00\x00\x00\x00\x02x'@\x00\x00\x00\x00\x03qD\xb0\x00\x00\x00\x00\x04aC\xc0\x00\x00\x00\x00\x05Q&\xb0\x00\x00\x00\x00\x06A%\xc0\x00\x00\x00\x00\a1\b\xb0\x00" +
-       "\x00\x00\x00\a\x8d_\xc0\x00\x00\x00\x00\t\x10\xea\xb0\x00\x00\x00\x00\t\xad\xdb@\x00\x00\x00\x00\n\xf0̰\x00\x00\x00\x00\v\xe0\xcb\xc0\x00\x00\x00\x00\f\xd9\xe90\x00\x00\x00\x00\r\xc0\xad\xc0\x00\x00\x00\x00\x0e" +
-       "\xb9\xcb0\x00\x00\x00\x00\x0f\xa9\xca@\x00\x00\x00\x00\x10\x99\xad0\x00\x00\x00\x00\x11\x89\xac@\x00\x00\x00\x00\x12y\x8f0\x00\x00\x00\x00\x13i\x8e@\x00\x00\x00\x00\x14Yq0\x00\x00\x00\x00\x15Ip@\x00" +
-       "\x00\x00\x00\x169S0\x00\x00\x00\x00\x17)R@\x00\x00\x00\x00\x18\"o\xb0\x00\x00\x00\x00\x19\t4@\x00\x00\x00\x00\x1a\x02Q\xb0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b" +
-       "\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00" +
-       "\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)" +
-       "\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00" +
-       "\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008" +
-       "\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00" +
-       "\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E" +
-       "\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
-       "\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xc4\xf8\x00\x00\xff\xffsx\x00\x00\xff\xffs`\x00\x04\xff\xff\x81p\x01\b\xff\xff\x81p\x01\f\xff\xffs" +
-       "`\x00\x10\xff\xff\x81p\x01\x15\xff\xff\x81p\x00\x1a\xff\xff\x8f\x80\x01\x1e\xff\xff\x81p\x00#LMT\x00AST\x00AWT\x00APT\x00AHST\x00AHDT\x00YST\x00AKD" +
-       "T\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12" +
-       "\x00\x1c\x00America/Costa_RicaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x87*M\xff\xff\xff\xff\xa3\xe8\x16M\x00\x00\x00\x00\x116I`\x00\x00\x00\x00\x11\xb7nP\x00\x00\x00\x00" +
-       "\x13\x16+`\x00\x00\x00\x00\x13\x97PP\x00\x00\x00\x00'\x97\xe0`\x00\x00\x00\x00(n\xb6\xd0\x00\x00\x00\x00)w\xc2`\x00\x00\x00\x00)\xc2\xd9\xd0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb13\x00\x00" +
-       "\xff\xff\xb13\x00\x04\xff\xff\xb9\xb0\x01\t\xff\xff\xab\xa0\x00\rLMT\x00SJMT\x00CDT\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQn\xab\xd5\xf9\xcf" +
-       "\x03\x00\x00\xcf\x03\x00\x00\f\x00\x1c\x00America/NomeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc4`\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00A" +
+       "DT\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1c\xd8\x19\x9dp\x01\x00" +
+       "\x00p\x01\x00\x00\x15\x00\x1c\x00America/Swift_CurrentUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x86\xfd\x96\x18\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff" +
+       "\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3v\x01\x10\xff\xff\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\xff\xff\xff\xff\xd75\xc5" +
+       "\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe9\x17\x0f\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xd6\xd3\x00\xff\xff\xff" +
+       "\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xcb\x00\xff\xff\xff\xff\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xad\x00\x00\x00\x00\x00\x04a\x19\x90\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05" +
+       "\xff\xff\x9a\xe8\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00" +
+       "\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x10\x00\x1c\x00America/SantiagoUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi" +
+       "\x87\x1d\xc6\xff\xff\xff\xff\x8f0GF\xff\xff\xff\xff\x9b\\\xe5P\xff\xff\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@\xff\xff\xff\xff\xb2A\x00\xd0\xff" +
+       "\xff\xff\xff\xb3Xp\xc0\xff\xff\xff\xff\xb4\"4P\xff\xff\xff\xff\xb59\xa4@\xff\xff\xff\xff\xb6\x03g\xd0\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9" +
+       "\xc7 P\xff\xff\xff\xff\xcc\x1cn@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff\xff\xff\xd3\u070f\xc0\xff\xff\xff\xff\xd4\x1bɰ\xff\xff\xff\xff\xd53U\xc0\xff\xff\xff\xff\xd5v\x92@\xff\xff\xff\xff\xfd\xd1<@\xff" +
+       "\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05" +
+       ">O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00" +
+       "\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13" +
+       "(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00" +
+       "\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!" +
+       "o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00" +
+       "\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/" +
+       "bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00" +
+       "\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=" +
+       "\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00" +
+       "\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K" +
+       "\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00" +
+       "\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7\xaa0\x00\x00\x00\x00[" +
+       "o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x02\x01\x03\x01\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x05\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
+       "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
+       "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\xff\xff\xbd\xba\x00\x00\xff\xff\xbd\xba\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00SMT\x00-05" +
+       "\x00-04\x00-03\x00\n<-04>4<-03>,M9.1.6/24,M4.1.6/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R8\xcdZ\x05" +
+       "o\x01\x00\x00o\x01\x00\x00\x10\x00\x1c\x00America/MazatlanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7" +
+       "C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00" +
+       "\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009" +
+       "\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff\xff\x9c<\x00\x00\xff\xff\x9d\x90\x00" +
+       "\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00PST\x00MDT\x00\nMST7MDT,M4.1.0,M10.5" +
+       ".0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x1c\x00America/St_BarthelemyUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff" +
+       "\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x89غ\xee\x15\x04\x00\x00\x15\x04\x00\x00\x0e\x00" +
+       "\x1c\x00America/BelizeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00b\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xff\x93^ٰ\xff\xff\xff\xff\x9f\x9f;\xe0\xff\xff\xff\xff\xa0EQ\xd8\xff\xff\xff\xff\xa1\u007f\x1d\xe0\xff\xff\xff\xff\xa2.nX\xff" +
+       "\xff\xff\xff\xa3^\xff\xe0\xff\xff\xff\xff\xa4\x0ePX\xff\xff\xff\xff\xa5>\xe1\xe0\xff\xff\xff\xff\xa5\xee2X\xff\xff\xff\xff\xa7'\xfe`\xff\xff\xff\xff\xa7\xce\x14X\xff\xff\xff\xff\xa9\a\xe0`\xff\xff\xff\xff\xa9" +
+       "\xad\xf6X\xff\xff\xff\xff\xaa\xe7\xc2`\xff\xff\xff\xff\xab\x97\x12\xd8\xff\xff\xff\xff\xacǤ`\xff\xff\xff\xff\xadv\xf4\xd8\xff\xff\xff\xff\xae\xa7\x86`\xff\xff\xff\xff\xafV\xd6\xd8\xff\xff\xff\xff\xb0\x87h`\xff" +
+       "\xff\xff\xff\xb16\xb8\xd8\xff\xff\xff\xff\xb2p\x84\xe0\xff\xff\xff\xff\xb3\x16\x9a\xd8\xff\xff\xff\xff\xb4Pf\xe0\xff\xff\xff\xff\xb4\xf6|\xd8\xff\xff\xff\xff\xb60H\xe0\xff\xff\xff\xff\xb6ߙX\xff\xff\xff\xff\xb8" +
+       "\x10*\xe0\xff\xff\xff\xff\xb8\xbf{X\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xba\x9f]X\xff\xff\xff\xff\xbb\xd9)`\xff\xff\xff\xff\xbc\u007f?X\xff\xff\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xbe_!X\xff" +
+       "\xff\xff\xff\xbf\x98\xed`\xff\xff\xff\xff\xc0?\x03X\xff\xff\xff\xff\xc1x\xcf`\xff\xff\xff\xff\xc2(\x1f\xd8\xff\xff\xff\xff\xc3X\xb1`\xff\xff\xff\xff\xc4\b\x01\xd8\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc5" +
+       "\xe7\xe3\xd8\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff\xff\xff\xc7\xc7\xc5\xd8\xff\xff\xff\xff\xc9\x01\x91\xe0\xff\xff\xff\xffɧ\xa7\xd8\xff\xff\xff\xff\xca\xe1s\xe0\xff\xff\xff\xffː\xc4X\xff\xff\xff\xff\xcc@\"\xe0\xff" +
+       "\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2\xc6qP\xff\xff\xff\xff\xd6)\xfa`\xff\xff\xff\xff\xd6\xd9J\xd8\xff\xff\xff\xff\xd8\t\xdc`\xff\xff\xff\xffع,\xd8\xff\xff\xff\xff\xd9\xe9\xbe`\xff\xff\xff\xff\xda" +
+       "\x99\x0e\xd8\xff\xff\xff\xff\xdb\xd2\xda\xe0\xff\xff\xff\xff\xdcx\xf0\xd8\xff\xff\xff\xffݲ\xbc\xe0\xff\xff\xff\xff\xdeX\xd2\xd8\xff\xff\xff\xffߒ\x9e\xe0\xff\xff\xff\xff\xe0A\xefX\xff\xff\xff\xff\xe1r\x80\xe0\xff" +
+       "\xff\xff\xff\xe2!\xd1X\xff\xff\xff\xff\xe3Rb\xe0\xff\xff\xff\xff\xe4\x01\xb3X\xff\xff\xff\xff\xe52D\xe0\xff\xff\xff\xff\xe5\xe1\x95X\xff\xff\xff\xff\xe7\x1ba`\xff\xff\xff\xff\xe7\xc1wX\xff\xff\xff\xff\xe8" +
+       "\xfbC`\xff\xff\xff\xff\xe9\xa1YX\xff\xff\xff\xff\xea\xdb%`\xff\xff\xff\xff\xeb\x8au\xd8\xff\xff\xff\xff\xec\xbb\a`\xff\xff\xff\xff\xedjW\xd8\xff\xff\xff\xff\xee\x9a\xe9`\xff\xff\xff\xff\xefJ9\xd8\xff" +
+       "\xff\xff\xff\xf0\x84\x05\xe0\xff\xff\xff\xff\xf1*\x1b\xd8\xff\xff\xff\xff\xf2c\xe7\xe0\xff\xff\xff\xff\xf3\t\xfd\xd8\xff\xff\xff\xff\xf4C\xc9\xe0\xff\xff\xff\xff\xf4\xe9\xdf\xd8\xff\xff\xff\xff\xf6#\xab\xe0\xff\xff\xff\xff\xf6" +
+       "\xd2\xfcX\xff\xff\xff\xff\xf8\x03\x8d\xe0\xff\xff\xff\xff\xf8\xb2\xdeX\xff\xff\xff\xff\xf9\xe3o\xe0\xff\xff\xff\xff\xfa\x92\xc0X\xff\xff\xff\xff\xfb̌`\xff\xff\xff\xff\xfcr\xa2X\x00\x00\x00\x00\ab\xdb`\x00" +
+       "\x00\x00\x00\a\xb9\xd0P\x00\x00\x00\x00\x18aq`\x00\x00\x00\x00\x18\xab7P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x05" +
+       "\x02\xff\xff\xadP\x00\x00\xff\xff\xb2\xa8\x01\x04\xff\xff\xab\xa0\x00\n\xff\xff\xb9\xb0\x01\x0e\xff\xff\xb9\xb0\x01\x12\xff\xff\xb9\xb0\x01\x16LMT\x00-0530\x00CST\x00CWT\x00CPT\x00C" +
+       "DT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcd\xc3v\xe3\xb3\x00\x00\x00\xb3\x00\x00\x00\x11\x00\x1c\x00America/GuayaquilUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x10\xff" +
+       "\xff\xff\xffi\x87&X\xff\xff\xff\xff\xb6\xa4B\x18\x00\x00\x00\x00+\x16\xfc\xd0\x00\x00\x00\x00+q\xe6@\x01\x03\x02\x03\xff\xff\xb5(\x00\x00\xff\xff\xb6h\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fL" +
+       "MT\x00QMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc0\x98\x00\b\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x1c\x00America" +
+       "/MontevideoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00V\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xff\x8c4\xe53\xff\xff\xff\xff\xa2\x92\x87\xb3\xff\xff\xff\xff\xa8\xff\xdb@\xff\xff\xff\xff\xa9\xf1\x0f\xb0\xff\xff\xff\xff\xaa\xe2Y8\xff\xff\xff\xff\xab\xd2" +
+       "C0\xff\xff\xff\xff\xacÌ\xb8\xff\xff\xff\xff\xad\xb3v\xb0\xff\xff\xff\xff\xbb\xf4\xb5\xb8\xff\xff\xff\xff\xbc\xbf\xb5\xb0\xff\xff\xff\xff\xbdԗ\xb8\xff\xff\xff\xff\xbe\x9f\x97\xb0\xff\xff\xff\xff\xbf\xb4y\xb8\xff\xff" +
+       "\xff\xff\xc0\u007fy\xb0\xff\xff\xff\xff\xc1\x94[\xb8\xff\xff\xff\xff\xc2_[\xb0\xff\xff\xff\xff\xc3}x8\xff\xff\xff\xff\xc4?=\xb0\xff\xff\xff\xff\xc5]Z8\xff\xff\xff\xff\xc6\x1f\x1f\xb0\xff\xff\xff\xff\xc7\x18" +
+       "R8\xff\xff\xff\xff\xc8\b<0\xff\xff\xff\xff\xc9\x1d\x1e8\xff\xff\xff\xff\xc9\xe8\x1e0\xff\xff\xff\xffʋ\x9f8\xff\xff\xff\xff\xcd\x1e\xc60\xff\xff\xff\xff͕f(\xff\xff\xff\xff\xec\v\x85\xb0\xff\xff" +
+       "\xff\xff\xec\xf25(\xff\xff\xff\xff\xedEJ\xb0\xff\xff\xff\xff\xed\x85\xd6 \xff\xff\xff\xff\xf7\x13r\xb0\xff\xff\xff\xff\xf7\xfa\x1b \xff\xff\xff\xff\xfc\xfe>0\xff\xff\xff\xff\xfd\xf6\x11(\x00\x00\x00\x00\x00\x96" +
+       "u0\x00\x00\x00\x00\x00\xd8R \x00\x00\x00\x00\x04W\x8a\xb0\x00\x00\x00\x00\x04\xc6:\xa0\x00\x00\x00\x00\a\x96\x1b\xb0\x00\x00\x00\x00\a\xdfژ\x00\x00\x00\x00\bƟ(\x00\x00\x00\x00\tZN0\x00\x00" +
+       "\x00\x00\t\xdbs \x00\x00\x00\x00\r\x1a\x120\x00\x00\x00\x00\r\u007f\x87\xa0\x00\x00\x00\x00\x0e\xe7\u007f0\x00\x00\x00\x00\x0f_i\xa0\x00\x00\x00\x00\x10\xd9\xd60\x00\x00\x00\x00\x11?K\xa0\x00\x00\x00\x00\x11\x89" +
+       "-\xb0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00!\xc3T0\x00\x00\x00\x00\"'x \x00\x00\x00\x00#\xa1\xe4\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%Jg\xb0\x00\x00\x00\x00%\xe7< \x00\x00" +
+       "\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\n+\xb0\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x90\x1c\xa0\x00\x00\x00\x00AL\xf60\x00\x00\x00\x00BF" +
+       "/\xc0\x00\x00\x00\x00CH\xa3\xd0\x00\x00\x00\x00D\x13\x9c\xc0\x00\x00\x00\x00E\x1fKP\x00\x00\x00\x00E\xf3~\xc0\x00\x00\x00\x00G\bg\xd0\x00\x00\x00\x00G\xd3`\xc0\x00\x00\x00\x00H\xe8I\xd0\x00\x00" +
+       "\x00\x00I\xb3B\xc0\x00\x00\x00\x00J\xc8+\xd0\x00\x00\x00\x00K\x9c_@\x00\x00\x00\x00L\xa8\r\xd0\x00\x00\x00\x00M|A@\x00\x00\x00\x00N\x87\xef\xd0\x00\x00\x00\x00O\\#@\x00\x00\x00\x00Pq" +
+       "\fP\x00\x00\x00\x00Q<\x05@\x00\x00\x00\x00RP\xeeP\x00\x00\x00\x00S\x1b\xe7@\x00\x00\x00\x00T0\xd0P\x00\x00\x00\x00T\xfb\xc9@\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x06\x05\x06\x05\a\x05\a\x05\x06\x05\a\x05\a\x05\b\x06\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05" +
+       "\a\x05\a\x05\a\x05\a\x05\xff\xff\xcbM\x00\x00\xff\xff\xcbM\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xce\xc8\x00\f\xff\xff\xd5\xd0\x01\x12\xff\xff\xd5\xd0\x00\x12\xff\xff\xdc\xd8\x01\x16\xff\xff\xe3\xe0\x01\x1c\xff\xff\xea\xe8" +
+       "\x01 LMT\x00MMT\x00-04\x00-0330\x00-03\x00-0230\x00-02\x00-0130\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\x13\x00\x1c\x00America/Los_AngelesUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff" +
+       "\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd6\xfet\\\xff\xff\xff\xff\u0600\xad\x90" +
+       "\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff" +
+       "\xe1ip\x90\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10" +
+       "\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff" +
+       "\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fА\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xb2\x90\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\x94\x90\xff\xff\xff\xff\xf6?\x85\x90" +
+       "\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff" +
+       "\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0" +
+       "\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00" +
+       "\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10" +
+       "\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00" +
+       "\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ " +
+       "\x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00" +
+       "'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90" +
+       "\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x00" +
+       "62\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0" +
+       "\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00" +
+       "D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x91&\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00P" +
+       "DT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\a\x1c\x9e\x9a]\x04\x00" +
+       "\x00]\x04\x00\x00\x0e\x00\x1c\x00America/HavanaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00&\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87O\xd2\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff" +
-       "\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03q" +
-       "R\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00" +
-       "\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89" +
-       "\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00" +
-       "\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2" +
-       "\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00" +
-       "\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,\xd3" +
-       "\x8c\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00" +
-       "\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7" +
-       "\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00" +
-       "\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05" +
-       "\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b" +
-       "\t\b\x00\x00\xb6n\x00\x00\xff\xffd\xee\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xffs`\x01\x14\xff\xff\x81p\x00\x18\xff\xff\x8f\x80\x01\x1c\xff\xff\x81p" +
-       "\x00!LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M1" +
-       "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00America/GrenadaUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x937" +
-       "3\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x1c\x00A" +
-       "merica/St_JohnsUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00j\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87(\xb8\xff\xff\xff\xff\xacb\u0080\xff\xff\xff\xff\xb1ӔP\xff\xff\xff\xff\xb2t]@\xff\xff" +
+       "\xff\xff\xc8[f\xd0\xff\xff\xff\xff\xc8\xd3Q@\xff\xff\xff\xff\xca;H\xd0\xff\xff\xff\xffʼm\xc0\xff\xff\xff\xff\xcc$eP\xff\xff\xff\xff̜O\xc0\xff\xff\xff\xff\xd1\xc4\vP\xff\xff\xff\xff\xd2;" +
+       "\xf5\xc0\xff\xff\xff\xffӣ\xedP\xff\xff\xff\xff\xd4\x1b\xd7\xc0\xff\xff\xff\xff\xf7`\x05\xd0\xff\xff\xff\xff\xf7\xff}@\xff\xff\xff\xff\xf9=D\xd0\xff\xff\xff\xff\xf9\xe3S\xc0\xff\xff\xff\xff\xfa\xdb;\xd0\xff\xff" +
+       "\xff\xff\xfb\xa7\x86@\xff\xff\xff\xff\xfcũ\xd0\xff\xff\xff\xff\xfd\x87h@\xff\xff\xff\xff\xfe\xb8\x00\xd0\xff\xff\xff\xff\xff\xa7\xe3\xc0\x00\x00\x00\x00\x00\x97\xe2\xd0\x00\x00\x00\x00\x01\x87\xc5\xc0\x00\x00\x00\x00\x02w" +
+       "\xc4\xd0\x00\x00\x00\x00\x03p\xe2@\x00\x00\x00\x00\x04`\xe1P\x00\x00\x00\x00\x055\x14\xc0\x00\x00\x00\x00\x06@\xc3P\x00\x00\x00\x00\a\x16H@\x00\x00\x00\x00\b \xa5P\x00\x00\x00\x00\b\xf7{\xc0\x00\x00" +
+       "\x00\x00\n\x00\x87P\x00\x00\x00\x00\n\xf0j@\x00\x00\x00\x00\v\xe0iP\x00\x00\x00\x00\fن\xc0\x00\x00\x00\x00\r\xc0KP\x00\x00\x00\x00\x0e\xb9h\xc0\x00\x00\x00\x00\x0f\xb2\xa2P\x00\x00\x00\x00\x10}" +
+       "\x9b@\x00\x00\x00\x00\x11Q\xea\xd0\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x131\xcc\xd0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15[\x82\xd0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x17;d\xd0\x00\x00" +
+       "\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xfb(\xd0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\xdb\n\xd0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ez" +
+       "SP\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 Z5P\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"CQ\xd0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$#3\xd0\x00\x00\x00\x00%.\xc6@\x00\x00" +
+       "\x00\x00&\x15\x8a\xd0\x00\x00\x00\x00'\x17\xe2\xc0\x00\x00\x00\x00'\xfe\xa7P\x00\x00\x00\x00(\xf7\xd2\xd0\x00\x00\x00\x00)މP\x00\x00\x00\x00*״\xd0\x00\x00\x00\x00+\xbekP\x00\x00\x00\x00,\xb7" +
+       "\x96\xd0\x00\x00\x00\x00-\x9eMP\x00\x00\x00\x00.\x97x\xd0\x00\x00\x00\x00/~/P\x00\x00\x00\x000wZ\xd0\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002W<\xd0\x00\x00\x00\x003G-\xd0\x00\x00" +
+       "\x00\x004@YP\x00\x00\x00\x005\x1d\xd5P\x00\x00\x00\x0062\xb0P\x00\x00\x00\x006\xfd\xb7P\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6" +
+       "\xb5\xd0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xd2P\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xb4P\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@f[\xd0\x00\x00\x00\x00ED5P\x00\x00" +
+       "\x00\x00E\xf3\x8c\xd0\x00\x00\x00\x00G$\x17P\x00\x00\x00\x00GܩP\x00\x00\x00\x00I\x03\xf9P\x00\x00\x00\x00I\xb3P\xd0\x00\x00\x00\x00J\xe3\xdbP\x00\x00\x00\x00K\x9cmP\x00\x00\x00\x00L\xcc" +
+       "\xf7\xd0\x00\x00\x00\x00M\x85\x89\xd0\x00\x00\x00\x00N\xbfN\xd0\x00\x00\x00\x00Ow\xe0\xd0\x00\x00\x00\x00P\x95\xf6P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb2\xc8\x00\x00\xff\xff\xb2\xc0\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00HMT\x00CDT\x00CST\x00" +
+       "\nCST5CDT,M3.2.0/0,M11.1.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R8O:\xbf\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x1c\x00Am" +
+       "erica/MenomineeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\b\x00\x00\x00\x19\xff\xff\xff\xff^=4\xec\xff\xff\xff\xff\x9c\xcfb\f\xff\xff\xff\xff\x9d\xa4\xe6\xfc\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff\xff\xff\x9f\xba\xd6|\xff\xff" +
-       "\xff\xff\xa0\xb6\x88\xdc\xff\xff\xff\xff\xa18\xffL\xff\xff\xff\xff\xa2\x95\x19\\\xff\xff\xff\xff\xa3\x84\xfcL\xff\xff\xff\xff\xa4t\xfb\\\xff\xff\xff\xff\xa5d\xdeL\xff\xff\xff\xff\xa6^\x17\xdc\xff\xff\xff\xff\xa7D" +
-       "\xc0L\xff\xff\xff\xff\xa8=\xf9\xdc\xff\xff\xff\xff\xa9$\xa2L\xff\xff\xff\xff\xaa\x1d\xdb\xdc\xff\xff\xff\xff\xab\x04\x84L\xff\xff\xff\xff\xab\xfd\xbd\xdc\xff\xff\xff\xff\xac\xe4fL\xff\xff\xff\xff\xadݟ\xdc\xff\xff" +
-       "\xff\xff\xae͂\xcc\xff\xff\xff\xff\xaf\xbd\x81\xdc\xff\xff\xff\xff\xb0\xadd\xcc\xff\xff\xff\xff\xb1\xa6\x9e\\\xff\xff\xff\xff\xb2\x8dF\xcc\xff\xff\xff\xff\xb3\x86\x80\\\xff\xff\xff\xff\xb4m(\xcc\xff\xff\xff\xff\xb5f" +
-       "b\\\xff\xff\xff\xff\xb6M\n\xcc\xff\xff\xff\xff\xb7FD\\\xff\xff\xff\xff\xb8,\xec\xcc\xff\xff\xff\xff\xb9&&\\\xff\xff\xff\xff\xba\x16\tL\xff\xff\xff\xff\xbb\x0fB\xdc\xff\xff\xff\xff\xbb\xf5\xebL\xff\xff" +
-       "\xff\xff\xbc\xef$\xdc\xff\xff\xff\xff\xbd\xd5\xcdL\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xbe\xcf\x06\xa8\xff\xff\xff\xff\xbf\xb5\xaf\x18\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff\xff\u0098" +
-       "\x138\xff\xff\xff\xff\xc3YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2(\xff\xff" +
-       "\xff\xff\xca ո\xff\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff\xff\xd5h" +
-       "&\xd8\xff\xff\xff\xff\xd6)\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5\xc8\xff\xff" +
-       "\xff\xff\xdc\xdetX\xff\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff\xff\xe3I" +
-       "\x13H\xff\xff\xff\xff\xe4]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc\xd8\xff\xff" +
-       "\xff\xff\xea\xd1\xd5\xc8\xff\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffeH\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff\xff\xf1\x8f" +
-       "\x9fX\xff\xff\xff\xff\xf2\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b\xc8\xff\xff" +
-       "\xff\xff\xf9\x0f'X\xff\xff\xff\xff\xfa\bD\xc8\xff\xff\xff\xff\xfa\xf8C\xd8\xff\xff\xff\xff\xfb\xe8&\xc8\xff\xff\xff\xff\xfc\xd8%\xd8\xff\xff\xff\xff\xfd\xc8\b\xc8\xff\xff\xff\xff\xfe\xb8\a\xd8\xff\xff\xff\xff\xff\xa7" +
-       "\xea\xc8\x00\x00\x00\x00\x00\x97\xe9\xd8\x00\x00\x00\x00\x01\x87\xcc\xc8\x00\x00\x00\x00\x02w\xcb\xd8\x00\x00\x00\x00\x03p\xe9H\x00\x00\x00\x00\x04`\xe8X\x00\x00\x00\x00\x05P\xcbH\x00\x00\x00\x00\x06@\xcaX\x00\x00" +
-       "\x00\x00\a0\xadH\x00\x00\x00\x00\b \xacX\x00\x00\x00\x00\t\x10\x8fH\x00\x00\x00\x00\n\x00\x8eX\x00\x00\x00\x00\n\xf0qH\x00\x00\x00\x00\v\xe0pX\x00\x00\x00\x00\fٍ\xc8\x00\x00\x00\x00\r\xc0" +
-       "RX\x00\x00\x00\x00\x0e\xb9o\xc8\x00\x00\x00\x00\x0f\xa9n\xd8\x00\x00\x00\x00\x10\x99Q\xc8\x00\x00\x00\x00\x11\x89P\xd8\x00\x00\x00\x00\x12y3\xc8\x00\x00\x00\x00\x13i2\xd8\x00\x00\x00\x00\x14Y\x15\xc8\x00\x00" +
-       "\x00\x00\x15I\x14\xd8\x00\x00\x00\x00\x168\xf7\xc8\x00\x00\x00\x00\x17(\xf6\xd8\x00\x00\x00\x00\x18\"\x14H\x00\x00\x00\x00\x19\b\xd8\xd8\x00\x00\x00\x00\x1a\x01\xf6H\x00\x00\x00\x00\x1a\xf1\xf5X\x00\x00\x00\x00\x1b\xe1" +
-       "\xd8H\x00\x00\x00\x00\x1c\xd1\xd7X\x00\x00\x00\x00\x1d\xc1\xbaH\x00\x00\x00\x00\x1e\xb1\xb9X\x00\x00\x00\x00\x1f\xa1\x9cH\x00\x00\x00\x00 u\xcf\xf4\x00\x00\x00\x00!\x81bd\x00\x00\x00\x00\"U\xb1\xf4\x00\x00" +
-       "\x00\x00#jp\xd4\x00\x00\x00\x00$5\x93\xf4\x00\x00\x00\x00%J`\xe4\x00\x00\x00\x00&\x15u\xf4\x00\x00\x00\x00'*B\xe4\x00\x00\x00\x00'\xfe\x92t\x00\x00\x00\x00)\n$\xe4\x00\x00\x00\x00)\xde" +
-       "tt\x00\x00\x00\x00*\xea\x06\xe4\x00\x00\x00\x00+\xbeVt\x00\x00\x00\x00,\xd3#d\x00\x00\x00\x00-\x9e8t\x00\x00\x00\x00.\xb3\x05d\x00\x00\x00\x00/~\x1at\x00\x00\x00\x000\x92\xe7d\x00\x00" +
-       "\x00\x001g6\xf4\x00\x00\x00\x002r\xc9d\x00\x00\x00\x003G\x18\xf4\x00\x00\x00\x004R\xabd\x00\x00\x00\x005&\xfa\xf4\x00\x00\x00\x0062\x8dd\x00\x00\x00\x007\x06\xdc\xf4\x00\x00\x00\x008\x1b" +
-       "\xa9\xe4\x00\x00\x00\x008\xe6\xbe\xf4\x00\x00\x00\x009\xfb\x8b\xe4\x00\x00\x00\x00:Ơ\xf4\x00\x00\x00\x00;\xdbm\xe4\x00\x00\x00\x00<\xaf\xbdt\x00\x00\x00\x00=\xbbO\xe4\x00\x00\x00\x00>\x8f\x9ft\x00\x00" +
-       "\x00\x00?\x9b1\xe4\x00\x00\x00\x00@o\x81t\x00\x00\x00\x00A\x84Nd\x00\x00\x00\x00BOct\x00\x00\x00\x00Cd0d\x00\x00\x00\x00D/Et\x00\x00\x00\x00ED\x12d\x00\x00\x00\x00E\xf3" +
-       "w\xf4\x00\x00\x00\x00G-.\xe4\x00\x00\x00\x00G\xd3Y\xf4\x00\x00\x00\x00I\r\x10\xe4\x00\x00\x00\x00I\xb3;\xf4\x00\x00\x00\x00J\xec\xf2\xe4\x00\x00\x00\x00K\x9cXt\x00\x00\x00\x00L\xd6\x0fd\x00\x00" +
-       "\x00\x00M|:t\x00\x00\x00\x00N\xb6\rH\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x06\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xffΔ\x00\x00\xff\xffܤ\x01\x04\xff\xffΔ\x00\b\xff\xff\xdc\xd8\x01\x04\xff\xff\xce\xc8\x00\b\xff\xff\xdc\xd8\x01\f\xff\xff\xdc" +
-       "\xd8\x01\x10\xff\xff\xea\xe8\x01\x14LMT\x00NDT\x00NST\x00NPT\x00NWT\x00NDDT\x00\nNST3:30NDT,M3.2.0,M11.1.0" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AtkaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87" +
-       "Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00" +
-       "\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8d" +
-       "m\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00" +
-       "\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169" +
-       "a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00\x1a\xf2P\xc0\x00\x00\x00\x00\x1b\xe23\xb0\x00\x00" +
-       "\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00 vG@\x00\x00\x00\x00!\x81ٰ\x00\x00\x00\x00\"V)@\x00\x00\x00\x00#j" +
-       "\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15\xed@\x00\x00\x00\x00'*\xba0\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00)\n\x9c0\x00\x00\x00\x00)\xde\xeb\xc0\x00\x00" +
-       "\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00.\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0\x00\x00\x00\x000\x93^\xb0\x00\x00\x00\x001g" +
-       "\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S\"\xb0\x00\x00\x00\x005'r@\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x007\aT@\x00\x00\x00\x008\x1c!0\x00\x00" +
-       "\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00\x00\x00;\xdb\xe50\x00\x00\x00\x00<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70\x00\x00\x00\x00>\x90\x16\xc0\x00\x00\x00\x00?\x9b" +
-       "\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00ED\x89\xb0\x00\x00\x00\x00E\xf3\xef@\x01\x02" +
-       "\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b" +
-       "\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xab\xe2\x00\x00\xff\xffZb\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xff" +
-       "s`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST1" +
-       "0HDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x1c\x00America/As" +
-       "uncionUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "O\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xffi\x87\x11\x90\xff\xff\xff\xff\xb8\x17\xf5\x90\x00\x00\x00\x00\x05+\xda@\x00\x00\x00\x00\a\xfc\xf0\xb0\x00\x00\x00\x00\n\xcft\xc0\x00\x00\x00\x00\v\x97ʰ\x00\x00\x00" +
-       "\x00\f\xb1\xf9\xc0\x00\x00\x00\x00\rx\xfe0\x00\x00\x00\x00\x0e\x93-@\x00\x00\x00\x00\x0fZ1\xb0\x00\x00\x00\x00\x10t`\xc0\x00\x00\x00\x00\x11dC\xb0\x00\x00\x00\x00\x12U\x94@\x00\x00\x00\x00\x13F\xc8" +
-       "\xb0\x00\x00\x00\x00\x148\x19@\x00\x00\x00\x00\x15'\xfc0\x00\x00\x00\x00\x16\x19L\xc0\x00\x00\x00\x00\x17\t/\xb0\x00\x00\x00\x00\x17\xfa\x80@\x00\x00\x00\x00\x18\xeac0\x00\x00\x00\x00\x19۳\xc0\x00\x00\x00" +
-       "\x00\x1a\xcc\xe80\x00\x00\x00\x00\x1b\xbe8\xc0\x00\x00\x00\x00\x1c\xae\x1b\xb0\x00\x00\x00\x00\x1d\x9fl@\x00\x00\x00\x00\x1e\x8fO0\x00\x00\x00\x00\x1f\x80\x9f\xc0\x00\x00\x00\x00 p\x82\xb0\x00\x00\x00\x00!a\xd3" +
-       "@\x00\x00\x00\x00\"S\a\xb0\x00\x00\x00\x00#DX@\x00\x00\x00\x00$4;0\x00\x00\x00\x00%A;@\x00\x00\x00\x00&\x15n\xb0\x00\x00\x00\x00'\x06\xbf@\x00\x00\x00\x00'\xf6\xa20\x00\x00\x00" +
-       "\x00(\xee\x8a@\x00\x00\x00\x00)\xb0H\xb0\x00\x00\x00\x00*Ͻ\xc0\x00\x00\x00\x00+\xb9\t0\x00\x00\x00\x00,\xab\xab@\x00\x00\x00\x00-p\f\xb0\x00\x00\x00\x00.\x8c\xde\xc0\x00\x00\x00\x00/O\xee" +
-       "\xb0\x00\x00\x00\x000n\x12@\x00\x00\x00\x0016h0\x00\x00\x00\x002W.\xc0\x00\x00\x00\x003\x0f\xb2\xb0\x00\x00\x00\x0047\x10\xc0\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006\x16\xf2\xc0\x00\x00\x00" +
-       "\x006\xe1\xeb\xb0\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xc1Ͱ\x00\x00\x00\x009ֶ\xc0\x00\x00\x00\x00:\xa1\xaf\xb0\x00\x00\x00\x00;\xbf\xd3@\x00\x00\x00\x00<\xaf\xb60\x00\x00\x00\x00=q\x90" +
-       "\xc0\x00\x00\x00\x00>\x8f\x980\x00\x00\x00\x00?Z\xad@\x00\x00\x00\x00@oz0\x00\x00\x00\x00Aq\xee@\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CQ\xd0@\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00" +
-       "\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x1a\xce\xc0\x00\x00\x00\x00G\xd3R\xb0\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\xb34\xb0\x00\x00\x00\x00Jڒ\xc0\x00\x00\x00\x00K\xc1;" +
-       "0\x00\x00\x00\x00L\xa7\xff\xc0\x00\x00\x00\x00M\xa1\x1d0\x00\x00\x00\x00N\x87\xe1\xc0\x00\x00\x00\x00O\x80\xff0\x00\x00\x00\x00Pp\xfe@\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04" +
-       "\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04" +
-       "\xff\xff\xc9\xf0\x00\x00\xff\xff\xc9\xf0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x00\f\xff\xff\xd5\xd0\x01\fLMT\x00AMT\x00-04\x00-03\x00\n<-04>4<-03>,M" +
-       "10.1.0/0,M3.4.0/0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x1c\x00America/Herm" +
-       "osilloUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffawIc\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff" +
+       "\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bg\xf0\xff\xff\xff\xff\xfe\xb8" +
+       "+\x00\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00" +
+       "\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13i" +
+       "V\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00" +
+       "\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81" +
+       "\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00" +
+       "\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~" +
+       "Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00" +
+       "\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb" +
+       "\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00" +
+       "\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x05\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad\xdd\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f" +
+       "\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\r\x00\x1c\x00America/JujuyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xae\xb8\xff\xff\xff\xff\xa2\x92" +
+       "\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff" +
+       "\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~" +
+       "\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff" +
+       "\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05" +
+       "l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff" +
+       "\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10" +
+       "\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xe2۰\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00" +
+       "\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x04\x05\x04\x05\x03\x05\x04\x05\xff\xff\xc2\xc8\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01" +
+       "\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01" +
+       "\x04\x00\x00\x01\x04\x00\x00\x0f\x00\x1c\x00America/TijuanaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fd" +
+       "p\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff" +
+       "\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23" +
+       "\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00" +
+       "\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir" +
+       " \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00" +
+       "\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd" +
+       "\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00" +
+       "\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u" +
+       "\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00" +
+       "\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab" +
+       "\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00" +
+       "\x00EDm\x90\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3" +
+       "\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff" +
+       "\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14LMT\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x10\x00\x1c\x00America/EdmontonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x88\xde\xce\xe0\xff\xff\xff\xff" +
+       "\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x98\x91\x90\xff\xff\xff\xff\xa0҅\x80\xff\xff\xff\xff\xa2\x8a\xe8\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4jʐ\xff\xff\xff\xff\xa55À" +
+       "\xff\xff\xff\xff\xa6S\xe7\x10\xff\xff\xff\xff\xa7\x15\xa5\x80\xff\xff\xff\xff\xa83\xc9\x10\xff\xff\xff\xff\xa8\xfe\xc2\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff" +
+       "\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b ݐ\x00\x00\x00\x00\t\x10\xc0\x80" +
+       "\x00\x00\x00\x00\n\x00\xbf\x90\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00" +
+       "\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10" +
+       "\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00" +
+       "\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00" +
+       "\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00" +
+       ",\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10" +
+       "\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00" +
+       ":\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80" +
+       "\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x95\xa0\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00MPT\x00\n" +
+       "MST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x1c\x00America" +
+       "/ChihuahuaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x13\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86" +
+       "\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00" +
+       "\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04" +
+       "\x01\x04\x01\x04\xff\xff\x9c\x8c\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00CDT\x00MDT\x00\nMST7M" +
+       "DT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1d`̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x1c\x00America/Camb" +
+       "ridge_BayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00>\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff\xff\xa1\xf2̀\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(\x85\xf0" +
+       "\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00" +
+       "\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10" +
+       "\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00" +
+       "'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80" +
+       "\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x00" +
+       "62ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\x04\xe9P\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00" +
+       "\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00" +
+       "Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x03\x01\x02\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\a\x06\b\a\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x00\x00\x00\x00\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xb9\xb0\x01\x10" +
+       "\xff\xff\xab\xa0\x01\x15\xff\xff\xb9\xb0\x01\x19\xff\xff\xab\xa0\x00\x1d\xff\xff\xb9\xb0\x00!-00\x00MWT\x00MPT\x00MST\x00MDDT\x00MDT\x00CDT\x00CST\x00EST" +
+       "\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x1c\x00Ameri" +
+       "ca/WhitehorseUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff\xff}\x86\x8a\x9c\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2Ҁ\xff\xff\xff\xff" +
+       "ˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xfb\x1d_\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10" +
+       "\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00" +
+       "\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r " +
+       "\x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00" +
+       ")\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90" +
+       "\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x00" +
+       "8\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0" +
+       "\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00" +
+       "E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90" +
+       "\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00" +
+       "TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00V5Ԑ\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00\x00Z\xa4\xfe " +
+       "\x00\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 \x00\x00\x00\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06\a\x06\a\x06\a" +
+       "\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a" +
+       "\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff\x81d\x00\x00\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19\xff\xff\x9d\x90\x01" +
+       "\x1d\xff\xff\x9d\x90\x00!LMT\x00YDT\x00YST\x00YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xf6@\rm\xa8\x05\x00\x00\xa8\x05\x00\x00\x13\x00\x1c\x00America/Fort_NelsonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^=v\x87\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff" +
+       "\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00" +
+       "\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff" +
+       "\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6G" +
+       "X \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff" +
+       "\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_" +
+       "\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff" +
+       "\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x" +
+       "\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\b \xeb\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00" +
+       "\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99" +
+       "\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00" +
+       "\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1" +
+       "\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00" +
+       "\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3" +
+       "~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00" +
+       "\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6" +
+       "\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00" +
+       "\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ \x00\x00\x00\x00I\r" +
+       "l\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00\x00O\\w\xa0\x00\x00" +
+       "\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x05\xff\xff\x8c\xf9\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x00\x14LMT\x00PDT\x00PST\x00PWT" +
+       "\x00PPT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AtkaUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!" +
+       "\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff" +
+       "\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0" +
+       "\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00" +
+       "\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@" +
+       "\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00" +
+       "\x1a\xf2P\xc0\x00\x00\x00\x00\x1b\xe23\xb0\x00\x00\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00 vG@\x00\x00\x00\x00!\x81ٰ" +
+       "\x00\x00\x00\x00\"V)@\x00\x00\x00\x00#j\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15\xed@\x00\x00\x00\x00'*\xba0\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00" +
+       ")\n\x9c0\x00\x00\x00\x00)\xde\xeb\xc0\x00\x00\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00.\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0" +
+       "\x00\x00\x00\x000\x93^\xb0\x00\x00\x00\x001g\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S\"\xb0\x00\x00\x00\x005'r@\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x00" +
+       "7\aT@\x00\x00\x00\x008\x1c!0\x00\x00\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00\x00\x00;\xdb\xe50\x00\x00\x00\x00<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70" +
+       "\x00\x00\x00\x00>\x90\x16\xc0\x00\x00\x00\x00?\x9b\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00" +
+       "ED\x89\xb0\x00\x00\x00\x00E\xf3\xef@\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b" +
+       "\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xab\xe2\x00\x00\xff\xffZb\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b" +
+       "\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xffs`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00" +
+       "AHST\x00HDT\x00\nHST10HDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Ra\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00" +
+       "\x0e\x00\x1c\x00America/ManausUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\u007fD\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ" +
+       "0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff" +
+       "\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0" +
+       "\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00" +
+       "\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\xff\xffǼ\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf1\xf9\x1dɻ\x00\x00\x00" +
+       "\xbb\x00\x00\x00\x12\x00\x1c\x00America/ParamariboUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x12\xff\xff\xff\xff\x91\x05\x8e\xb8\xff\xff\xff\xff\xbe*K\xc4\xff\xff\xff\xff\xd2b,\xb4\x00\x00\x00\x00\x1b\xbe1" +
+       "\xb8\x01\x02\x03\x04\xff\xff\xccH\x00\x00\xff\xff\xcc<\x00\x04\xff\xff\xccL\x00\x04\xff\xff\xce\xc8\x00\b\xff\xff\xd5\xd0\x00\x0eLMT\x00PMT\x00-0330\x00-03\x00\n<-03>3" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfe7\xa1\x87\x1b\x01\x00\x00\x1b\x01\x00\x00\f\x00\x1c\x00America/LimaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xffi\x87#\xbc\xff\xff\xff\xff\x8ct" +
+       "@\xd4\xff\xff\xff\xff\xc3\xcfJP\xff\xff\xff\xff\xc4E\xe3@\xff\xff\xff\xff\xc5/J\xd0\xff\xff\xff\xff\xc6\x1f-\xc0\xff\xff\xff\xff\xc7\x0f,\xd0\xff\xff\xff\xff\xc7\xff\x0f\xc0\x00\x00\x00\x00\x1e\x18\xc4P\x00\x00" +
+       "\x00\x00\x1e\x8f]@\x00\x00\x00\x00\x1f\xf9\xf7\xd0\x00\x00\x00\x00 p\x90\xc0\x00\x00\x00\x00%\x9e\xe3\xd0\x00\x00\x00\x00&\x15|\xc0\x00\x00\x00\x00-%\x03P\x00\x00\x00\x00-\x9b\x9c@\x01\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb7\xc4\x00\x00\xff\xff\xb7\xac\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\bLMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9Rd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x1c\x00America/AsuncionUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xffi\x87\x11\x90\xff\xff\xff\xff\xb8\x17\xf5\x90\x00" +
+       "\x00\x00\x00\x05+\xda@\x00\x00\x00\x00\a\xfc\xf0\xb0\x00\x00\x00\x00\n\xcft\xc0\x00\x00\x00\x00\v\x97ʰ\x00\x00\x00\x00\f\xb1\xf9\xc0\x00\x00\x00\x00\rx\xfe0\x00\x00\x00\x00\x0e\x93-@\x00\x00\x00\x00\x0f" +
+       "Z1\xb0\x00\x00\x00\x00\x10t`\xc0\x00\x00\x00\x00\x11dC\xb0\x00\x00\x00\x00\x12U\x94@\x00\x00\x00\x00\x13FȰ\x00\x00\x00\x00\x148\x19@\x00\x00\x00\x00\x15'\xfc0\x00\x00\x00\x00\x16\x19L\xc0\x00" +
+       "\x00\x00\x00\x17\t/\xb0\x00\x00\x00\x00\x17\xfa\x80@\x00\x00\x00\x00\x18\xeac0\x00\x00\x00\x00\x19۳\xc0\x00\x00\x00\x00\x1a\xcc\xe80\x00\x00\x00\x00\x1b\xbe8\xc0\x00\x00\x00\x00\x1c\xae\x1b\xb0\x00\x00\x00\x00\x1d" +
+       "\x9fl@\x00\x00\x00\x00\x1e\x8fO0\x00\x00\x00\x00\x1f\x80\x9f\xc0\x00\x00\x00\x00 p\x82\xb0\x00\x00\x00\x00!a\xd3@\x00\x00\x00\x00\"S\a\xb0\x00\x00\x00\x00#DX@\x00\x00\x00\x00$4;0\x00" +
+       "\x00\x00\x00%A;@\x00\x00\x00\x00&\x15n\xb0\x00\x00\x00\x00'\x06\xbf@\x00\x00\x00\x00'\xf6\xa20\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0H\xb0\x00\x00\x00\x00*Ͻ\xc0\x00\x00\x00\x00+" +
+       "\xb9\t0\x00\x00\x00\x00,\xab\xab@\x00\x00\x00\x00-p\f\xb0\x00\x00\x00\x00.\x8c\xde\xc0\x00\x00\x00\x00/O\xee\xb0\x00\x00\x00\x000n\x12@\x00\x00\x00\x0016h0\x00\x00\x00\x002W.\xc0\x00" +
+       "\x00\x00\x003\x0f\xb2\xb0\x00\x00\x00\x0047\x10\xc0\x00\x00\x00\x004\xf8\xcf0\x00\x00\x00\x006\x16\xf2\xc0\x00\x00\x00\x006\xe1\xeb\xb0\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008\xc1Ͱ\x00\x00\x00\x009" +
+       "ֶ\xc0\x00\x00\x00\x00:\xa1\xaf\xb0\x00\x00\x00\x00;\xbf\xd3@\x00\x00\x00\x00<\xaf\xb60\x00\x00\x00\x00=q\x90\xc0\x00\x00\x00\x00>\x8f\x980\x00\x00\x00\x00?Z\xad@\x00\x00\x00\x00@oz0\x00" +
+       "\x00\x00\x00Aq\xee@\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CQ\xd0@\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x1a\xce\xc0\x00\x00\x00\x00G" +
+       "\xd3R\xb0\x00\x00\x00\x00H\xfa\xb0\xc0\x00\x00\x00\x00I\xb34\xb0\x00\x00\x00\x00Jڒ\xc0\x00\x00\x00\x00K\xc1;0\x00\x00\x00\x00L\xa7\xff\xc0\x00\x00\x00\x00M\xa1\x1d0\x00\x00\x00\x00N\x87\xe1\xc0\x00" +
+       "\x00\x00\x00O\x80\xff0\x00\x00\x00\x00Pp\xfe@\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04" +
+       "\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\xff\xff\xc9\xf0\x00\x00\xff\xff\xc9\xf0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x00\f\xff\xff" +
+       "\xd5\xd0\x01\fLMT\x00AMT\x00-04\x00-03\x00\n<-04>4<-03>,M10.1.0/0,M3.4.0/0\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00\x1c\x00America/ChicagoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff" +
+       "\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa2\xcbt\x00\xff\xff\xff\xff\xa3\x83\xf7\xf0\xff\xff\xff\xff\xa4EҀ\xff\xff\xff\xff\xa5c\xd9\xf0\xff\xff\xff\xff\xa6S\xd9\x00" +
+       "\xff\xff\xff\xff\xa7\x15\x97p\xff\xff\xff\xff\xa83\xbb\x00\xff\xff\xff\xff\xa8\xfe\xb3\xf0\xff\xff\xff\xff\xaa\x13\x9d\x00\xff\xff\xff\xff\xaaޕ\xf0\xff\xff\xff\xff\xab\xf3\u007f\x00\xff\xff\xff\xff\xac\xbew\xf0\xff\xff\xff\xff" +
+       "\xad\xd3a\x00\xff\xff\xff\xff\xae\x9eY\xf0\xff\xff\xff\xff\xaf\xb3C\x00\xff\xff\xff\xff\xb0~;\xf0\xff\xff\xff\xff\xb1\x9c_\x80\xff\xff\xff\xff\xb2gXp\xff\xff\xff\xff\xb3|A\x80\xff\xff\xff\xff\xb4G:p" +
+       "\xff\xff\xff\xff\xb5\\#\x80\xff\xff\xff\xff\xb6'\x1cp\xff\xff\xff\xff\xb7<\x05\x80\xff\xff\xff\xff\xb8\x06\xfep\xff\xff\xff\xff\xb9\x1b\xe7\x80\xff\xff\xff\xff\xb9\xe6\xe0p\xff\xff\xff\xff\xbb\x05\x04\x00\xff\xff\xff\xff" +
+       "\xbb\xc6\xc2p\xff\xff\xff\xff\xbc\xe4\xe6\x00\xff\xff\xff\xff\xbd\xaf\xde\xf0\xff\xff\xff\xff\xbe\xc4\xc8\x00\xff\xff\xff\xff\xbf\x8f\xc0\xf0\xff\xff\xff\xff\xc0Z\xd6\x00\xff\xff\xff\xff\xc1\xb0<p\xff\xff\xff\xff\u0084\x8c\x00" +
+       "\xff\xff\xff\xff\xc3O\x84\xf0\xff\xff\xff\xff\xc4dn\x00\xff\xff\xff\xff\xc5/f\xf0\xff\xff\xff\xff\xc6M\x8a\x80\xff\xff\xff\xff\xc7\x0fH\xf0\xff\xff\xff\xff\xc8-l\x80\xff\xff\xff\xff\xc8\xf8ep\xff\xff\xff\xff" +
+       "\xca\rN\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00" +
+       "\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff" +
+       "\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p" +
+       "\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff" +
+       "\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080" +
+       "\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x85\xf0\xff\xff\xff\xff" +
+       "\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bg\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0" +
+       "\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00" +
+       "\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80" +
+       "\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00" +
+       "\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp" +
+       "\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00" +
+       "#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80" +
+       "\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x00" +
+       "1gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0" +
+       "\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00" +
+       "?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad\xd4\x00" +
+       "\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00CDT\x00CST\x00EST\x00CWT\x00CPT\x00\nCST6" +
+       "CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RMv\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x1c\x00America/Mon" +
+       "terreyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x0f\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff" +
-       "\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H" +
-       "\x10\x00\x00\x00\x0062ڀ\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\xff\xff\x97\xf8\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00MS" +
-       "T\x00CST\x00PST\x00MDT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x0f\x00\x1c\x00America/Ti" +
-       "juanaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^" +
-       "\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n\xf2\xf0\xff\xff\xff\xff" +
-       "\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90" +
-       "\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff" +
-       "\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10" +
-       "\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00" +
-       "\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0" +
-       "\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00" +
-       "$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10" +
-       "\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x00" +
-       "2s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a " +
-       "\x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00" +
-       "@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00\x00\x00G$O\x90" +
-       "\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14LMT\x00MST\x00PS" +
-       "T\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00" +
-       "\x82\x00\x00\x00\x0f\x00\x1c\x00America/MarigotUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?\xc9\x1c\xd4\xc6\x03\x00\x00\xc6\x03\x00\x00\x0e\x00\x1c\x00America/JuneauUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\n\x00\x00\x00&\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff" +
-       "}\x872\xc5\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10" +
-       "\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00" +
-       "\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae " +
-       "\x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00" +
-       "\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0" +
-       "\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00" +
-       "$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap " +
-       "\x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x00" +
-       "2s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0" +
-       "\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00" +
-       "@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05" +
-       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x06\x02\x05\x02\x05\x02\x05\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
-       "\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xd3{\x00\x00\xff\xff\x81\xfb\x00\x00\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x8f\x80\x01\x14\xff\xff\x81" +
-       "p\x00\x18\xff\xff\x8f\x80\x01\x1c\xff\xff\x81p\x00!LMT\x00PST\x00PWT\x00PPT\x00PDT\x00YDT\x00YST\x00AKDT\x00AKST\x00\nAKST9A" +
-       "KDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc0\x98\x00\b\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x1c\x00America/Mon" +
-       "tevideoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00V\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xff\x8c4\xe53\xff\xff\xff\xff\xa2\x92\x87\xb3\xff\xff\xff\xff\xa8\xff\xdb@\xff\xff\xff\xff\xa9\xf1\x0f\xb0\xff\xff\xff\xff\xaa\xe2Y8\xff\xff\xff\xff\xab\xd2C0\xff\xff" +
-       "\xff\xff\xacÌ\xb8\xff\xff\xff\xff\xad\xb3v\xb0\xff\xff\xff\xff\xbb\xf4\xb5\xb8\xff\xff\xff\xff\xbc\xbf\xb5\xb0\xff\xff\xff\xff\xbdԗ\xb8\xff\xff\xff\xff\xbe\x9f\x97\xb0\xff\xff\xff\xff\xbf\xb4y\xb8\xff\xff\xff\xff\xc0\u007f" +
-       "y\xb0\xff\xff\xff\xff\xc1\x94[\xb8\xff\xff\xff\xff\xc2_[\xb0\xff\xff\xff\xff\xc3}x8\xff\xff\xff\xff\xc4?=\xb0\xff\xff\xff\xff\xc5]Z8\xff\xff\xff\xff\xc6\x1f\x1f\xb0\xff\xff\xff\xff\xc7\x18R8\xff\xff" +
-       "\xff\xff\xc8\b<0\xff\xff\xff\xff\xc9\x1d\x1e8\xff\xff\xff\xff\xc9\xe8\x1e0\xff\xff\xff\xffʋ\x9f8\xff\xff\xff\xff\xcd\x1e\xc60\xff\xff\xff\xff͕f(\xff\xff\xff\xff\xec\v\x85\xb0\xff\xff\xff\xff\xec\xf2" +
-       "5(\xff\xff\xff\xff\xedEJ\xb0\xff\xff\xff\xff\xed\x85\xd6 \xff\xff\xff\xff\xf7\x13r\xb0\xff\xff\xff\xff\xf7\xfa\x1b \xff\xff\xff\xff\xfc\xfe>0\xff\xff\xff\xff\xfd\xf6\x11(\x00\x00\x00\x00\x00\x96u0\x00\x00" +
-       "\x00\x00\x00\xd8R \x00\x00\x00\x00\x04W\x8a\xb0\x00\x00\x00\x00\x04\xc6:\xa0\x00\x00\x00\x00\a\x96\x1b\xb0\x00\x00\x00\x00\a\xdfژ\x00\x00\x00\x00\bƟ(\x00\x00\x00\x00\tZN0\x00\x00\x00\x00\t\xdb" +
-       "s \x00\x00\x00\x00\r\x1a\x120\x00\x00\x00\x00\r\u007f\x87\xa0\x00\x00\x00\x00\x0e\xe7\u007f0\x00\x00\x00\x00\x0f_i\xa0\x00\x00\x00\x00\x10\xd9\xd60\x00\x00\x00\x00\x11?K\xa0\x00\x00\x00\x00\x11\x89-\xb0\x00\x00" +
-       "\x00\x00\x131\xa2\xa0\x00\x00\x00\x00!\xc3T0\x00\x00\x00\x00\"'x \x00\x00\x00\x00#\xa1\xe4\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%Jg\xb0\x00\x00\x00\x00%\xe7< \x00\x00\x00\x00'!" +
-       "\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\n+\xb0\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x90\x1c\xa0\x00\x00\x00\x00AL\xf60\x00\x00\x00\x00BF/\xc0\x00\x00" +
-       "\x00\x00CH\xa3\xd0\x00\x00\x00\x00D\x13\x9c\xc0\x00\x00\x00\x00E\x1fKP\x00\x00\x00\x00E\xf3~\xc0\x00\x00\x00\x00G\bg\xd0\x00\x00\x00\x00G\xd3`\xc0\x00\x00\x00\x00H\xe8I\xd0\x00\x00\x00\x00I\xb3" +
-       "B\xc0\x00\x00\x00\x00J\xc8+\xd0\x00\x00\x00\x00K\x9c_@\x00\x00\x00\x00L\xa8\r\xd0\x00\x00\x00\x00M|A@\x00\x00\x00\x00N\x87\xef\xd0\x00\x00\x00\x00O\\#@\x00\x00\x00\x00Pq\fP\x00\x00" +
-       "\x00\x00Q<\x05@\x00\x00\x00\x00RP\xeeP\x00\x00\x00\x00S\x1b\xe7@\x00\x00\x00\x00T0\xd0P\x00\x00\x00\x00T\xfb\xc9@\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x06\x05\x06\x05\a\x05\a\x05\x06\x05\a\x05\a\x05\b\x06\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05" +
-       "\a\x05\a\x05\xff\xff\xcbM\x00\x00\xff\xff\xcbM\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xce\xc8\x00\f\xff\xff\xd5\xd0\x01\x12\xff\xff\xd5\xd0\x00\x12\xff\xff\xdc\xd8\x01\x16\xff\xff\xe3\xe0\x01\x1c\xff\xff\xea\xe8\x01 LM" +
-       "T\x00MMT\x00-04\x00-0330\x00-03\x00-0230\x00-02\x00-0130\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe90" +
-       "T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\x0f\x00\x1c\x00America/GodthabUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00" +
-       "\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10" +
-       "\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00" +
-       "#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90" +
-       "\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x00" +
-       "1]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00" +
-       "-03\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7" +
-       "\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00America/GuadeloupeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
+       "\x10\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa5\xb6\xda`\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00" +
+       "\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04" +
+       "\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xa1\xf4\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x01\bLMT\x00CST\x00C" +
+       "DT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x15\x00\x1c\x00Ame" +
+       "rica/Coral_HarbourUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x84d\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xffˈ\xfe" +
+       "\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\x02\x01\x02\x01\x03\x04\x05\xff\xff\xaa\x1c\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14" +
+       "LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R錴$q\x03\x00\x00q\x03\x00\x00\x13\x00\x1c\x00" +
+       "America/Thunder_BayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00N\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x82,\xff\xff\xff\xff\x8f${\xe0\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`" +
+       "\xfb\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\b \xc1p\x00\x00" +
+       "\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9" +
+       "\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00" +
+       "\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1" +
+       "\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00" +
+       "\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe" +
+       "\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00" +
+       "\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb" +
+       "\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00" +
+       "\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\xff\xff\xacT\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00EST\x00EWT\x00EPT\x00" +
+       "EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x1c\x00Am" +
+       "erica/EnsenadaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff" +
+       "\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR" +
+       "\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff" +
+       "\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91" +
+       "\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00" +
+       "\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17" +
+       "\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00" +
+       "\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xde\xcf" +
+       "\xa0\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00" +
+       "\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05" +
+       "\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00" +
+       "\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00F\x0f\x82" +
+       "\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14L" +
+       "MT\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "ROKjǪ\x02\x00\x00\xaa\x02\x00\x00\r\x00\x1c\x00America/BahiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
        "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AS" +
-       "T\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ挋\x92\xf6\x01\x00\x00\xf6\x01\x00\x00\x0e\x00\x1c\x00America/MaceioUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96" +
-       "\xaah|\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff" +
-       "\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6" +
-       "\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00" +
-       "\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#" +
-       "\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00" +
-       "\x00\x00\x009\xf2J \x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\xff\xffބ\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQJtZ\x8c" +
-       "\x01\x03\x00\x00\x01\x03\x00\x00\x13\x00\x1c\x00America/PangnirtungUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\n\x00\x00\x00)\xff\xff\xff\xff\xa3\xd5R\x80\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff" +
-       "\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xf7/0@\xff\xff\xff\xff\xf8([\xc0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(" +
-       "\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00" +
-       "\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J" +
-       "\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00" +
-       "\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003G" +
-       "I\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00" +
-       "\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84" +
-       "\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x03\x01\x02\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
-       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\a\x06\a\x06\a\x06\a\x06\b\t\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\x00\x00\x00\x00\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xd5\xd0\x01" +
-       "\b\xff\xff\xc7\xc0\x00\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x01\x15\xff\xff\xc7\xc0\x01\x19\xff\xff\xb9\xb0\x00\x1d\xff\xff\xab\xa0\x00!\xff\xff\xb9\xb0\x01%-00\x00AWT\x00APT\x00AST\x00A" +
-       "DDT\x00ADT\x00EDT\x00EST\x00CST\x00CDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x1c\x00America/St_KittsUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LM" +
-       "T\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdf\b\x9c\x9f\xe7\x00\x00\x00\xe7\x00\x00\x00\x10\x00\x1c\x00America/BarbadosUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00" +
-       "\x10\xff\xff\xff\xff\xa9y$\xe5\xff\xff\xff\xff\xb8\x85c\xe5\x00\x00\x00\x00\x0e\x00\xf2\xe0\x00\x00\x00\x00\x0e\x94\x8c\xd0\x00\x00\x00\x00\x0f\x97\x00\xe0\x00\x00\x00\x00\x10tn\xd0\x00\x00\x00\x00\x11v\xe2\xe0\x00\x00\x00" +
-       "\x00\x12TP\xd0\x00\x00\x00\x00\x13_\xff`\x00\x00\x00\x00\x140>P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xc8\x1b\x00\x00\xff\xff\xc8\x1b\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\fLMT\x00B" +
-       "MT\x00ADT\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x1c\x00America/Iqalu" +
-       "itUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00" +
-       "\b\x00\x00\x00!\xff\xff\xff\xff\xccl\xa1\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xf7/>P\xff\xff\xff\xff\xf8(i\xd0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaak\x1c\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff" +
+       "\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde" +
+       " \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff" +
+       "\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05" +
+       "\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00" +
+       "\x00'!\x0f0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00,\xc0\xb50\x00\x00\x00\x00-f\xc4" +
+       " \x00\x00\x00\x00.\xa0\x970\x00\x00\x00\x00/F\xa6 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00\x00" +
+       "\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8\xff" +
+       "\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xdb\xe4\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\b" +
+       "LMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x1c\x00America/Mo" +
+       "ntrealUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xac\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06\xf0\xff\xff\xff" +
+       "\xff\xa3U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff\xff\xaa\x1c\xc9" +
+       "p\xff\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad܍p\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff" +
+       "\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0" +
+       "`\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff" +
+       "\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|" +
+       "p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff" +
+       "\xff\xd5U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdc\x13t" +
+       "`\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff" +
+       "\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1" +
+       "\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff" +
+       "\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w" +
+       "\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff" +
+       "\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdf" +
+       "p\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00" +
+       "\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*" +
        "\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00" +
        "\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2" +
        "\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00" +
        "\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18" +
        "`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00" +
-       "\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0" +
+       "\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0" +
        "p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00" +
-       "\x00E\xf3\xa8\xf0\x05\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x06\a\x02\x04\x02\x04\x02\x04\x02\x04\x02" +
-       "\x04\x02\x04\x02\x04\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xc7\xc0\x01\x11\xff\xff\xc7\xc0\x01\x15\xff\xff\xab\xa0\x00\x19\xff\xff\xb9\xb0\x01\x1d-00\x00EPT" +
-       "\x00EST\x00EDDT\x00EDT\x00EWT\x00CST\x00CDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ8O:\xbf\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x1c\x00America/MenomineeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffawIc\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff" +
-       "\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0" +
-       "\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bg\xf0\xff\xff\xff\xff\xfe\xb8+\x00\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00" +
-       "\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0" +
-       "\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00" +
-       "\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀" +
-       "\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00" +
-       "&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp" +
-       "\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x00" +
-       "4R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00" +
-       "\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00" +
-       "BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x05\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff" +
-       "\xad\xdd\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nC" +
-       "ST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x1c\x00America/" +
-       "MartiniqueUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x87\x14\xc4\xff\xff\xff\xff\x91\xa3\xc8D\x00\x00\x00\x00\x13Mn@\x00\x00\x00\x00\x144\x16\xb0\x01\x02\x03\x02\xff\xffƼ\x00\x00\xff\xffƼ\x00" +
-       "\x04\xff\xff\xc7\xc0\x00\t\xff\xff\xd5\xd0\x01\rLMT\x00FFMT\x00AST\x00ADT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01" +
-       "\x00\x00\x13\x00\x1c\x00America/Mexico_CityUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
+       "\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xb5" +
+       "\x94\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2" +
+       ".0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x1c\x00America/JamaicaUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00\x10\xff" +
+       "\xff\xff\xffi\x87#~\xff\xff\xff\xff\x93\x0f\xb4\xfe\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f" +
+       "٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00" +
+       "\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x01\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xb8\x02\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\fLMT\x00KMT\x00EST\x00EDT\x00\nES" +
+       "T5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11\x00\x1c\x00America/AnchorageUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00(\xff\xff\xff\xff?\xc2\xfd" +
+       "\xd1\xff\xff\xff\xff}\x87AH\xff\xff\xff\xffˉ6\xc0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aB0\xff\xff\xff\xff\xfa\xd2G\xa0\xff\xff\xff\xff\xfe\xb8c@\xff\xff\xff\xff\xff\xa8F0\x00\x00\x00" +
+       "\x00\x00\x98E@\x00\x00\x00\x00\x01\x88(0\x00\x00\x00\x00\x02x'@\x00\x00\x00\x00\x03qD\xb0\x00\x00\x00\x00\x04aC\xc0\x00\x00\x00\x00\x05Q&\xb0\x00\x00\x00\x00\x06A%\xc0\x00\x00\x00\x00\a1\b" +
+       "\xb0\x00\x00\x00\x00\a\x8d_\xc0\x00\x00\x00\x00\t\x10\xea\xb0\x00\x00\x00\x00\t\xad\xdb@\x00\x00\x00\x00\n\xf0̰\x00\x00\x00\x00\v\xe0\xcb\xc0\x00\x00\x00\x00\f\xd9\xe90\x00\x00\x00\x00\r\xc0\xad\xc0\x00\x00\x00" +
+       "\x00\x0e\xb9\xcb0\x00\x00\x00\x00\x0f\xa9\xca@\x00\x00\x00\x00\x10\x99\xad0\x00\x00\x00\x00\x11\x89\xac@\x00\x00\x00\x00\x12y\x8f0\x00\x00\x00\x00\x13i\x8e@\x00\x00\x00\x00\x14Yq0\x00\x00\x00\x00\x15Ip" +
+       "@\x00\x00\x00\x00\x169S0\x00\x00\x00\x00\x17)R@\x00\x00\x00\x00\x18\"o\xb0\x00\x00\x00\x00\x19\t4@\x00\x00\x00\x00\x1a\x02Q\xb0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00" +
+       "\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b" +
+       "0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00" +
+       "\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P" +
+       "\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00" +
+       "\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b" +
+       "\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00" +
+       "\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
+       "\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xc4\xf8\x00\x00\xff\xffsx\x00\x00\xff\xffs`\x00\x04\xff\xff\x81p\x01\b\xff\xff\x81p\x01\f\xff" +
+       "\xffs`\x00\x10\xff\xff\x81p\x01\x15\xff\xff\x81p\x00\x1a\xff\xff\x8f\x80\x01\x1e\xff\xff\x81p\x00#LMT\x00AST\x00AWT\x00APT\x00AHST\x00AHDT\x00YST\x00A" +
+       "KDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00" +
+       "\x00\x14\x00\x1c\x00America/DanmarkshavnUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`" +
-       "\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xc5ް`\xff\xff\xff\xffƗ4P\xff\xff\xff\xff\xc9U\xf1\xe0\xff\xff\xff\xff\xc9\xea\xddP\xff\xff\xff\xff\xcf\x02\xc6\xe0\xff\xff\xff\xff" +
-       "ϷVP\xff\xff\xff\xffڙ\x15\xe0\xff\xff\xff\xff\xdbv\x83\xd0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00" +
-       "\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00" +
-       "<\xaf\xfc\x80\x01\x02\x01\x02\x01\x02\x03\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xa3\f\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01" +
-       "\x10LMT\x00MST\x00CST\x00CDT\x00CWT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1c" +
-       "\xd8\x19\x9dp\x01\x00\x00p\x01\x00\x00\x15\x00\x1c\x00America/Swift_CurrentUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x86\xfd\x96\x18\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f" +
-       "\xbb\a\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3v\x01\x10\xff\xff\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\xff" +
-       "\xff\xff\xff\xd75\xc5\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe9\x17\x0f\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec" +
-       "\xd6\xd3\x00\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xcb\x00\xff\xff\xff\xff\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xad\x00\x00\x00\x00\x00\x04a\x19\x90\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x05\xff\xff\x9a\xe8\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14LMT\x00MDT\x00MST\x00MWT\x00MP" +
-       "T\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd7\b\\\xc6&\x02\x00\x00&\x02\x00\x00\x10\x00\x1c\x00America/MiquelonUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00\x04\x00\x00\x00" +
-       "\x10\xff\xff\xff\xff\x91\xb68\xa8\x00\x00\x00\x00\x13nc\xc0\x00\x00\x00\x00 u\xe4\xd0\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"U\xc6\xd0\x00\x00\x00\x00#j\x93\xc0\x00\x00\x00\x00$5\xa8\xd0\x00\x00\x00" +
-       "\x00%Ju\xc0\x00\x00\x00\x00&\x15\x8a\xd0\x00\x00\x00\x00'*W\xc0\x00\x00\x00\x00'\xfe\xa7P\x00\x00\x00\x00)\n9\xc0\x00\x00\x00\x00)މP\x00\x00\x00\x00*\xea\x1b\xc0\x00\x00\x00\x00+\xbek" +
-       "P\x00\x00\x00\x00,\xd38@\x00\x00\x00\x00-\x9eMP\x00\x00\x00\x00.\xb3\x1a@\x00\x00\x00\x00/~/P\x00\x00\x00\x000\x92\xfc@\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002r\xde@\x00\x00\x00" +
-       "\x003G-\xd0\x00\x00\x00\x004R\xc0@\x00\x00\x00\x005'\x0f\xd0\x00\x00\x00\x0062\xa2@\x00\x00\x00\x007\x06\xf1\xd0\x00\x00\x00\x008\x1b\xbe\xc0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00\x009\xfb\xa0" +
-       "\xc0\x00\x00\x00\x00:Ƶ\xd0\x00\x00\x00\x00;ۂ\xc0\x00\x00\x00\x00<\xaf\xd2P\x00\x00\x00\x00=\xbbd\xc0\x00\x00\x00\x00>\x8f\xb4P\x00\x00\x00\x00?\x9bF\xc0\x00\x00\x00\x00@o\x96P\x00\x00\x00" +
-       "\x00A\x84c@\x00\x00\x00\x00BOxP\x00\x00\x00\x00CdE@\x00\x00\x00\x00D/ZP\x00\x00\x00\x00ED'@\x00\x00\x00\x00E\xf3\x8c\xd0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xcbX\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x00\b\xff\xff\xe3\xe0\x01\fLMT\x00AST\x00" +
-       "-03\x00-02\x00\n<-03>3<-02>,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00" +
-       "\x00\x00\x0f\x00\x1c\x00America/CuracaoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9b\x80I\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90" +
+       "\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00" +
+       "\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10" +
+       "\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00" +
+       "*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x000\xe7N0" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\xff\xff\xee\x80\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\b\x00\x00\x00\x00\x00\fLM" +
+       "T\x00-03\x00-02\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x12\x00\x1c\x00America/Kr" +
+       "alendijkUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\nLMT\x00-0430\x00AST" +
+       "\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x1c\x00America/AraguainaUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff" +
+       "\xff\x96\xaat0\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1" +
+       "\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff" +
+       "\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}" +
+       "\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00" +
+       "\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T" +
+       "0\x00\x00\x00\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00" +
+       "\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00P\x83e0\x00\x00\x00\x00Q 9\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd2\xd0\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-0" +
+       "2\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/CordobaU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00" +
+       "\x00\x14\xff\xff\xff\xffr\x9c\xad\xb0\xff\xff\xff\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff" +
+       "\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d" +
+       "\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff" +
+       "\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=" +
+       "\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff" +
+       "\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$" +
+       "o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xd0X\xa0\x00\x00\x00\x00)\x00\xff@\x00\x00" +
+       "\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd30\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x00\x00\x00\x00H\xfa" +
+       "\xa2\xb0\x00\x00\x00\x00I\xbca \x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x02\x04\x05\x04\x05\x03\x05\x04\x05\x04\x05\xff\xff\xc3\xd0\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-" +
+       "03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\u0096dK~\x02\x00\x00~\x02\x00\x00\x0e\x00\x1c\x00America/ReginaU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x06\x00\x00" +
+       "\x00\x18\xff\xff\xff\xff\x86\xfd\x93\x1c\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xb5eO\xf0\xff\xff\xff\xff\xb60H\xe0\xff\xff\xff\xff\xb7E1\xf0\xff\xff\xff\xff\xb8\x10*\xe0\xff\xff" +
+       "\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xbb\x0e0p\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xee\x12p\xff\xff\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xc2r\b\xf0\xff\xff\xff\xff\xc3a" +
+       "\xeb\xe0\xff\xff\xff\xff\xc4Q\xea\xf0\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc61\xcc\xf0\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff\xff\xff\xc8\x1a\xe9p\xff\xff\xff\xff\xc9\n\xcc`\xff\xff\xff\xff\xc9\xfa\xcbp\xff\xff" +
+       "\xff\xff\xca\xea\xae`\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3c\x8c\x10\xff\xff\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 " +
+       "\xdc\x00\xff\xff\xff\xff\xd75\xc5\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x82\x00\xff\xff\xff\xff\xdcޥ\x90\xff\xff" +
+       "\xff\xffݩ\x9e\x80\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff߉\x80\x80\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ib\x80\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3ID\x80\xff\xff\xff\xff\xe4^" +
+       "-\x90\xff\xff\xff\xff\xe5)&\x80\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12C\x00\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf2%\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xd6\xd3\x00\xff\xff" +
+       "\xff\xff\xed\xc6\xd2\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\xff" +
+       "\xff\x9d\xe4\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00\n" +
+       "CST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x85-\xb9\xf8\x8a\x01\x00\x00\x8a\x01\x00\x00\r\x00\x1c\x00America/BelemUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaatt\xff" +
+       "\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xff\xdc" +
+       "\xb9Y \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4\x97\xff\xb0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff" +
+       "\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1d" +
+       "Ɏ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffҌ\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x1c\x00America/TorontoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba" +
+       "\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06\xf0\xff\xff\xff\xff\xa3U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff" +
+       "\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff\xff\xaa\x1c\xc9p\xff\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad\xdc" +
+       "\x8dp\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff" +
+       "\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf" +
+       "\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff" +
+       "\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#" +
+       "\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff" +
+       "\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdc\x13t`\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉" +
+       "d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff" +
+       "\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xed\xc6" +
+       "\xb5\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff" +
+       "\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8" +
+       ";\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00" +
+       "\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00" +
+       "\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00" +
+       "\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\"" +
+       ")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00" +
+       "\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15" +
+       "\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00" +
+       "\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R" +
+       "\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00" +
+       "\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO" +
+       "\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xb5\x94\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00" +
+       "EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RU9#\xbe2\x05" +
+       "\x00\x002\x05\x00\x00\x11\x00\x1c\x00America/VancouverUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=v\xec\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ" +
+       "\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd3v\x0f \xff\xff\xff\xff\xd4A\b\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff" +
+       "\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be" +
+       "\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff" +
+       "\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1" +
+       "\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff" +
+       "\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8" +
+       "\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00" +
+       "\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\b \xeb\xa0\x00\x00\x00\x00\t\x10" +
+       "ΐ\x00\x00\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00" +
+       "\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)" +
+       "6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00" +
+       "\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J" +
+       "\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00" +
+       "\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003G" +
+       "t \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00" +
+       "\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84" +
+       "\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x8c\x94\x00\x00\xff\xff\x9d" +
+       "\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11" +
+       ".1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf8Dz\x97\xae\x01\x00\x00\xae\x01\x00\x00\x11\x00\x1c\x00America/Boa_VistaUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96" +
+       "\xaa\u007f\xe0\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff" +
+       "\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6" +
+       "\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00" +
+       "\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x007\xf6\xd4\xc0\x00\x00\x00\x008" +
+       "\xb8\x930\x00\x00\x00\x009\xdf\xf1@\x00\x00\x00\x009\xe9\x1d\xb0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xc7 \x00\x00\xff\xff" +
+       "\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x15\x00\x1c\x00" +
+       "America/Lower_PrincesUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\n" +
-       "LMT\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ+\x10`ȫ\x02\x00\x00\xab\x02\x00\x00\x14\x00\x1c\x00America/Da" +
-       "wson_CreekUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00:\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^=t8\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&" +
-       "\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff" +
-       "\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y" +
-       "\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff" +
-       "\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb" +
-       "\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff" +
-       "\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G" +
-       " \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05\x01\xf0\x90\x02\x01\x02" +
-       "\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\xff\xff\x8fH\x00" +
-       "\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x00\x14LMT\x00PDT\x00PST\x00PWT\x00PPT\x00MST\x00\nMST7" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/MendozaUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffr\x9c\xb2\x04\xff\xff\xff" +
-       "\xff\xa2\x92\x8f0\xff\xff\xff\xff\xb6{R@\xff\xff\xff\xff\xb7\x1aɰ\xff\xff\xff\xff\xb8\x1e\x8f@\xff\xff\xff\xff\xb8\xd4p0\xff\xff\xff\xff\xba\x17}\xc0\xff\xff\xff\xff\xba\xb5\xa3\xb0\xff\xff\xff\xff\xbb\xf8\xb1" +
-       "@\xff\xff\xff\xff\xbc\x96\xd70\xff\xff\xff\xff\xbd\xd9\xe4\xc0\xff\xff\xff\xff\xbex\n\xb0\xff\xff\xff\xff\xbf\xbb\x18@\xff\xff\xff\xff\xc0Z\x8f\xb0\xff\xff\xff\xff\xc1\x9d\x9d@\xff\xff\xff\xff\xc2;\xc30\xff\xff\xff" +
-       "\xff\xc3~\xd0\xc0\xff\xff\xff\xff\xc4\x1c\xf6\xb0\xff\xff\xff\xff\xc5`\x04@\xff\xff\xff\xff\xc5\xfe*0\xff\xff\xff\xff\xc7A7\xc0\xff\xff\xff\xff\xc7\xe0\xaf0\xff\xff\xff\xffȁ\x94@\xff\xff\xff\xff\xcaM\xa1" +
-       "\xb0\xff\xff\xff\xff\xca\xee\x86\xc0\xff\xff\xff\xff\xceM\xff0\xff\xff\xff\xffΰ\xed\xc0\xff\xff\xff\xff\xd3)5\xb0\xff\xff\xff\xff\xd4Cd\xc0\xff\xff\xff\xff\xf4=\b0\xff\xff\xff\xff\xf4\x9f\xf6\xc0\xff\xff\xff" +
-       "\xff\xf5\x05l0\xff\xff\xff\xff\xf62\x10@\xff\xff\xff\xff\xf6柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35" +
-       "\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00#\x94\xb5\xb0\x00\x00\x00" +
-       "\x00$\x10\x94\xa0\x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xf0v\xa0\x00\x00\x00\x00'\x194@\x00\x00\x00\x00'\xcdð\x00\x00\x00\x00(\xfag\xc0\x00\x00\x00\x00)\xb0H\xb0\x00\x00\x00\x00*\xe0\xe1" +
-       "@\x00\x00\x00\x00+\x99W \x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xbf*\xb0\x00\x00\x00\x00@\xb0\x13\xb0\x00\x00\x00\x00AV>\xc0\x00\x00\x00\x00Gw\t\xb0\x00\x00\x00\x00G\xdc\u007f \x01\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x04\x02\x03\x02\x03\x02\x04\x05\x03\x05\x02\x05\x04\x05\xff\xff" +
-       "\xbf|\x00\x00\xff\xff\xc3\xd0\x00\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>" +
-       "3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AdakUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}" +
-       "\x87Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00" +
-       "\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a" +
-       "\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00" +
-       "\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x16" +
-       "9a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00\x1a\xf2P\xc0\x00\x00\x00\x00\x1b\xe23\xb0\x00" +
-       "\x00\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00 vG@\x00\x00\x00\x00!\x81ٰ\x00\x00\x00\x00\"V)@\x00\x00\x00\x00#" +
-       "j\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15\xed@\x00\x00\x00\x00'*\xba0\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00)\n\x9c0\x00\x00\x00\x00)\xde\xeb\xc0\x00" +
-       "\x00\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00.\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0\x00\x00\x00\x000\x93^\xb0\x00\x00\x00\x001" +
-       "g\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S\"\xb0\x00\x00\x00\x005'r@\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x007\aT@\x00\x00\x00\x008\x1c!0\x00" +
-       "\x00\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00\x00\x00;\xdb\xe50\x00\x00\x00\x00<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70\x00\x00\x00\x00>\x90\x16\xc0\x00\x00\x00\x00?" +
-       "\x9b\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00ED\x89\xb0\x00\x00\x00\x00E\xf3\xef@\x01" +
-       "\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
-       "\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xab\xe2\x00\x00\xff\xffZb\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff" +
-       "\xffs`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST" +
-       "10HDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ錴$q\x03\x00\x00q\x03\x00\x00\x13\x00\x1c\x00America/T" +
-       "hunder_BayUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00N\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xffr\xee\x82,\xff\xff\xff\xff\x8f${\xe0\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\x00\x00\x00\x00\x00\x97\xfe" +
-       "\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00" +
-       "\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f" +
-       "\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00" +
-       "\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xce" +
-       "p\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00" +
-       "\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T" +
-       "`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00" +
-       "\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1" +
-       "\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00" +
-       "\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\xff\xff\xacT\x00" +
-       "\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00EST\x00EWT\x00EPT\x00EDT\x00\nEST5" +
-       "EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\r\x00\x1c\x00America/Aru" +
-       "baUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00" +
-       "\x03\x00\x00\x00\x0e\xff\xff\xff\xff\x93\x1e.#\xff\xff\xff\xff\xf6\x98\xecH\x01\x02\xff\xff\xbf]\x00\x00\xff\xff\xc0\xb8\x00\x04\xff\xff\xc7\xc0\x00\nLMT\x00-0430\x00AST\x00\nAST4" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf6@\rm\xa8\x05\x00\x00\xa8\x05\x00\x00\x13\x00\x1c\x00America/Fort_NelsonUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^=v" +
-       "\x87\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff" +
-       "\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac" +
-       "\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff" +
-       "\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe" +
-       " \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff" +
-       "\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84" +
-       "\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00" +
-       "\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\b \xeb" +
-       "\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00" +
-       "\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697" +
-       "\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00" +
-       "\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef" +
-       " \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00" +
-       "\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$" +
-       "\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00" +
-       "\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@o\xdc" +
-       "\xa0\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00" +
-       "\x00Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L" +
-       "\x90\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x02\x01\x02" +
-       "\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\xff\xff\x8c\xf9\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x00\x14LMT\x00" +
-       "PDT\x00PST\x00PWT\x00PPT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x81{\xc1\x92\xbc\x03\x00\x00\xbc\x03\x00\x00\r\x00\x1c\x00Amer" +
-       "ica/SitkaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00S\x00\x00\x00\t\x00\x00\x00\"\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x873\x99\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfe\xb8G " +
-       "\xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00" +
-       "\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10" +
-       "\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00" +
-       "\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a+\x14\x10" +
-       "\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00" +
-       "!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0" +
-       "\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00" +
-       "/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0" +
-       "\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00" +
-       "=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0" +
-       "\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x06\b\a\b\a\b\a\b\a\b" +
-       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x00\x00ҧ\x00\x00\xff\xff\x81'\x00\x00\xff\xff\x8f\x80\x00\x04\xff\xff\x9d" +
-       "\x90\x01\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x81p\x00\x14\xff\xff\x8f\x80\x01\x18\xff\xff\x81p\x00\x1dLMT\x00PST\x00PWT\x00PPT\x00PDT\x00YST\x00AKD" +
-       "T\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10" +
-       "\x00\x1c\x00America/AnguillaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x9373\xac\x01\xff\xff\xc6T\x00\x00\xff\xff\xc7\xc0\x00\x04LMT\x00AST\x00\nAST4\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00\x00\x14\x00\x1c\x00America/DanmarkshavnUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9b\x80I\x00\x00\x00" +
-       "\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xd3" +
-       "\xa0\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00" +
-       "\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf5" +
-       "4\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00" +
-       "\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x000\xe7N0\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\xff\xff\xee\x80" +
-       "\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\b\x00\x00\x00\x00\x00\fLMT\x00-03\x00-02\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x1c\x00Antarctica/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x95{\xf3\xa9w\x03\x00\x00w\x03\x00\x00\x11\x00\x1c\x00Antarctica/PalmerUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xf6\x98\xad\x00\xff\xff\xff\xff\xf6柰\xff\xff\xff" +
-       "\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff\xff\xff\xff\xfe\x9c5" +
-       "0\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00\x170\xbc\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00" +
-       "\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02" +
-       "@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00" +
-       "\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc" +
-       "\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00" +
-       "\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef" +
-       "\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00" +
-       "\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00" +
-       "\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00" +
-       "\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00XC\x86\xb0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x00" +
-       "\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xe3\xe0\x01\f\xff\xff\xd5\xd0\x00\b-00\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\x95\xea\x06\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00\x10\x00\x1c\x00Antarctica/DavisUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xe7\x9c@\x00\xff\xff\xff\xff\xf6G\xdf\x10\xff\xff" +
-       "\xff\xff\xfeG\xab\x00\x00\x00\x00\x00J\xda\x140\x00\x00\x00\x00K\x97\xfa@\x00\x00\x00\x00N\xa9\xaa0\x00\x00\x00\x00OC\xf7\xc0\x01\x00\x01\x02\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00bp\x00\x04\x00\x00F" +
-       "P\x00\b-00\x00+07\x00+05\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQƉ\xf71\x84\x00\x00\x00\x84\x00\x00\x00\x12\x00\x1c\x00Antarc" +
-       "tica/RotheraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\x00\x00\x00\x00\r\x02-\x00\x01\x00\x00\x00\x00\x00\x00\xff\xff\xd5\xd0\x00\x04-00\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x1c\x00Antarctica/VostokUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xe9X\x89\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00T" +
-       "`\x00\x04-00\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\r\x0e\xf20\x85\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Antarctica" +
-       "/SyowaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "LMT\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x1c\x00Antarctica" +
+       "/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x1c\x00A" +
+       "ntarctica/VostokUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xe9X\x89\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00T`\x00\x04-00\x00+06\x00\n<+06>-6\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\x95{\xf3\xa9w\x03\x00\x00w\x03\x00\x00\x11\x00\x1c\x00Antarctica/PalmerUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xf6\x98\xad\x00\xff\xff\xff\xff\xf6" +
+       "柰\xff\xff\xff\xff\xf8\x13C\xc0\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xf9\xf4w@\xff\xff\xff\xff\xfa\xd36\xb0\xff\xff\xff\xff\xfb\xc35\xc0\xff\xff\xff\xff\xfc\xbcS0\xff\xff\xff\xff\xfd\xacR@\xff" +
+       "\xff\xff\xff\xfe\x9c50\xff\xff\xff\xff\xff\x8c4@\x00\x00\x00\x00\a\xa3J\xb0\x00\x00\x00\x00\b$o\xa0\x00\x00\x00\x00\x170\xbc\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19" +
+       "\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00" +
+       "\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'" +
+       "١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00" +
+       "\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006" +
+       "\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00" +
+       "\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D" +
+       "\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00" +
+       "\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R" +
+       "+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00XC\x86\xb0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x04\x00\x00\x00\x00\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xe3\xe0\x01\f\xff\xff\xd5\xd0\x00\b-00\x00-04\x00-03\x00-02\x00\n<-03>3\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R:\xc8P7\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x1c\x00Antarctica/TrollUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\x00\x00\x00\x00B\rG\x00\x00\x00\x00\x00" +
+       "BF\x05\x90\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x00\x00\x00\b-00\x00+02\x00+00\x00\n<+00>0<+02>-2,M3.5.0/1," +
+       "M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x12\x00\x1c\x00Antarctica/McMurdoUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00" +
+       "\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff" +
+       "\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8" +
+       "\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff" +
+       "\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd" +
+       "\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00" +
+       "\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83" +
+       "`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00" +
+       "\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01" +
+       "`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00" +
+       "\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab" +
+       "`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00" +
+       "\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4" +
+       "`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00" +
+       "\x04LMT\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\x95\xea\x06\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00\x10\x00\x1c\x00Antarctica/DavisUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xe7\x9c@\x00\xff\xff\xff\xff\xf6G\xdf\x10\xff\xff\xff\xff\xfeG" +
+       "\xab\x00\x00\x00\x00\x00J\xda\x140\x00\x00\x00\x00K\x97\xfa@\x00\x00\x00\x00N\xa9\xaa0\x00\x00\x00\x00OC\xf7\xc0\x01\x00\x01\x02\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00bp\x00\x04\x00\x00FP\x00\b-" +
+       "00\x00+07\x00+05\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\r\x0e\xf20\x85\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Antarctica" +
+       "/SyowaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xe7\xb1X\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00*0\x00\x04-00\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xc8\x14\xdcA\x98\x00\x00\x00\x98\x00\x00\x00\x19\x00\x1c\x00Antarctica/DumontDUrvilleUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xe7\xb1X\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00*0\x00\x04-00\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xc8\x14\xdcA\x98\x00\x00\x00\x98\x00\x00\x00\x19\x00\x1c\x00Antarctica/DumontDUrvilleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
        "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xffԼv\x80\xff\xff\xff\xff\xde4`" +
-       "`\xff\xff\xff\xff\xe7<\x02\x80\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xa0\x00\x04-00\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7" +
-       "\x13\x04\x00\x00\x13\x04\x00\x00\x12\x00\x1c\x00Antarctica/McMurdoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff" +
-       "\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5" +
-       "\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff" +
-       "\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`" +
-       "\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00" +
-       "\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84" +
-       "\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00" +
-       "\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2" +
-       "`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00" +
-       "\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7" +
-       "`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00" +
-       "\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0" +
-       "`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00" +
-       "\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3" +
-       "\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LMT\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12" +
-       "NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x97\xd4#\xed\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x1c\x00Antarctic" +
-       "a/MacquarieUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00[\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff|\x05\x16\x00\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xa0\x87\xb4`\xff\xff\xff\xff\xd7\fh\x00\xff\xff\xff\xff\xfb\xc2" +
-       "\x8d\x00\xff\xff\xff\xff\xfc\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00" +
-       "\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5" +
-       "\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00" +
-       "\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!" +
-       "d\x80\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00" +
-       "\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02" +
-       "_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00" +
-       "\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046" +
-       "h\x00\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00" +
-       "\x00\x00;\xbf*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE" +
-       "\x87\x00\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x00\x00\x00\x00G\xf7\xa2\x00\x00\x00\x00\x00H\xe7\x93\x00\x00\x00" +
-       "\x00\x00Iׄ\x00\x00\x00\x00\x00J\xc7u\x00\x00\x00\x00\x00M\x97H\x00\x01\x02\x01\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x8c\xa0\x00\x04\x00\x00\x9a\xb0\x01\t-00\x00AEST\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15\x00\x1c\x00Antarctica/South_PoleUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff" +
-       "\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9" +
-       "`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff" +
-       "\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~" +
-       "\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00" +
-       "\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2" +
-       "\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00" +
-       "\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0" +
-       "`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00" +
-       "\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05" +
-       "`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00" +
-       "\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e" +
-       "`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00" +
-       "\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LMT\x00NZST\x00NZ" +
-       "MT\x00NZDT\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ:\xc8P7\xb1\x00\x00\x00\xb1" +
-       "\x00\x00\x00\x10\x00\x1c\x00Antarctica/TrollUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\x00\x00\x00\x00B\rG\x00\x00\x00\x00\x00BF\x05\x90\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x00\x00" +
-       "\x00\b-00\x00+02\x00+00\x00\n<+00>0<+02>-2,M3.5.0/1,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xd7N\xab\x8b\x98\x00\x00\x00\x98\x00\x00\x00\x11\x00\x1c\x00Antarctica/MawsonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xe2 2\x80\x00\x00\x00\x00J\xda\"@\x01\x02\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00T`\x00\x04\x00\x00FP\x00\b-00\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xddzAh\xf3\x00\x00\x00\xf3\x00\x00" +
-       "\x00\x10\x00\x1c\x00Antarctica/CaseyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xfe\x1è\x00\x00\x00\x00J\xda\x06 \x00\x00\x00\x00K\x8f\xca\xf0\x00\x00\x00\x00N\xa9\x9c \x00\x00\x00\x00" +
-       "OC͐\x00\x00\x00\x00X\n;\x80\x00\x00\x00\x00Z\xa4\x0f\x10\x00\x00\x00\x00[\xb9\x14@\x00\x00\x00\x00\\\x8d\x1d\x80\x00\x00\x00\x00]\x96E0\x00\x00\x00\x00^c\xc5\x00\x00\x00\x00\x00_x\xa0<" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x9a\xb0\x00\b-00\x00+08\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Arctic/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x13\x00\x1c\x00Arctic/LongyearbyenUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff" +
-       "\xff\x9b'\xe3\x00\xff\xff\xff\xff\x9b\xd4{`\xff\xff\xff\xffȷM`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%" +
-       "\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff\xed\x98=\x10\xff\xff\xff\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff" +
-       "\xff\xf0h\x10\x10\xff\xff\xff\xff\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10\xff\xff\xff\xff\xf5\x17\xc5\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06" +
-       "\x10\xff\xff\xff\xff\xf7\xf0Ґ\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00" +
-       "\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81" +
-       "\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00" +
-       "\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94\xda" +
-       "\x90\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CE" +
-       "T\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x1c\x00" +
-       "Asia/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ's\x96\x1en\x01\x00\x00n\x01\x00\x00\r" +
-       "\x00\x1c\x00Asia/DushanbeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x83\x80\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00" +
-       "\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e" +
-       "\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00" +
-       "\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(ʏP\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x00\x00@\x80\x00" +
-       "\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLMT\x00+05\x00+07\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xa1\xfax\x98g\x02\x00\x00g\x02\x00\x00\r\x00\x1c\x00Asia/QostanayUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x88\\\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0" +
-       "\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00" +
-       "\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0" +
-       "\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00" +
-       ")\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP" +
-       "\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x00" +
-       "8\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP" +
-       "\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x00\x00;\xa4\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+" +
-       "05\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\r\x00\x1c\x00Asia/CalcuttaU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00" +
-       "\x00\x16\xff\xff\xff\xff&\xba\x18(\xff\xff\xff\xffC\xe7\xeb0\xff\xff\xff\xff\x87\x9d\xbc\xba\xff\xff\xff\xff\xcaی(\xff\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\x01\x02" +
-       "\x03\x04\x03\x04\x03\x00\x00R\xd8\x00\x00\x00\x00R\xd0\x00\x04\x00\x00KF\x00\b\x00\x00MX\x00\f\x00\x00[h\x01\x10LMT\x00HMT\x00MMT\x00IST\x00+0630\x00\nIS" +
-       "T-5:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/UrumqiUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xb0\xfe\xbad\x01" +
-       "\x00\x00R\x1c\x00\x00\x00\x00T`\x00\x04LMT\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x1c\x00A" +
-       "sia/KarachiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\v\x00\x00\x00\x06\x00\x00\x00\x1d\xff\xff\xff\xff\x89~\xfc\xa4\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\xff\xff\xff\xffݨ\xe0\xa8\x00\x00\x00\x00\x02O\xab0\x00\x00\x00\x00<\xaf" +
-       "E\xb0\x00\x00\x00\x00=\x9f(\xa0\x00\x00\x00\x00HA\xa00\x00\x00\x00\x00I\vG\xa0\x00\x00\x00\x00I\xe4\xdd0\x00\x00\x00\x00J\xec{ \x01\x02\x01\x03\x05\x04\x05\x04\x05\x04\x05\x00\x00>\xdc\x00\x00\x00" +
-       "\x00MX\x00\x04\x00\x00[h\x01\n\x00\x00FP\x00\x10\x00\x00T`\x01\x14\x00\x00FP\x00\x19LMT\x00+0530\x00+0630\x00+05\x00PKST\x00PKT\x00\nP" +
-       "KT-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00\x1c\x00Asia/KhandygaUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xff\xa1\xdb\xe4\xeb\xff" +
-       "\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18\x87\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00\x00\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a" +
-       "\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00" +
-       "\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xb6\x90\x00\x00\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(" +
-       "\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00)Ԧ\x10\x00\x00\x00\x00*ė\x10\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00" +
-       "\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10\x00\x00\x00\x001]h\x90\x00\x00\x00\x002rC\x90\x00\x00\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x006" +
-       "2\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x008\x1b$\x10\x00\x00\x00\x008\xdc\xf0\x90\x00\x00\x00\x009\xfb\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00" +
-       "\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10\x00\x00\x00\x00?\x9a\xac\x10\x00\x00\x00\x00?\xf2\xe4p\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C" +
-       "c\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00I\x03B\x80\x00\x00\x00\x00I\xceI\x80\x00" +
-       "\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00\x00\x00\x00Nn\x02P\x00\x00\x00\x00TK\xc9\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\x06\x03\x00\x00\u007f\x15\x00\x00" +
-       "\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x9a\xb0\x01\x10\x00\x00\x8c\xa0\x00\b\x00\x00\x9a\xb0\x00\x10LMT\x00+08\x00+10\x00+09\x00+1" +
-       "1\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/ThimbuUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\xd5" +
-       "\xe6\x15t\x00\x00\x00\x00!aM\xa8\x01\x02\x00\x00T\f\x00\x00\x00\x00MX\x00\x04\x00\x00T`\x00\nLMT\x00+0530\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x1c\x00Asia/ThimphuUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\xd5\xe6\x15t\x00\x00\x00\x00!aM\xa8\x01\x02\x00\x00T" +
-       "\f\x00\x00\x00\x00MX\x00\x04\x00\x00T`\x00\nLMT\x00+0530\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQd%\x05\xd8\xe6\x02\x00\x00" +
-       "\xe6\x02\x00\x00\x10\x00\x1c\x00Asia/VladivostokUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
+       "`\xff\xff\xff\xff\xe7<\x02\x80\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xa0\x00\x04-00\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd7N\xab\x8b" +
+       "\x98\x00\x00\x00\x98\x00\x00\x00\x11\x00\x1c\x00Antarctica/MawsonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xe2 2\x80\x00\x00\x00\x00J\xda\"@\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00T`" +
+       "\x00\x04\x00\x00FP\x00\b-00\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RƉ\xf71\x84\x00\x00\x00\x84\x00\x00\x00\x12\x00\x1c\x00A" +
+       "ntarctica/RotheraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\x00\x00\x00\x00\r\x02-\x00\x01\x00\x00\x00\x00\x00\x00\xff\xff\xd5\xd0\x00\x04-00\x00-03\x00\n<-03>3\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\xddzAh\xf3\x00\x00\x00\xf3\x00\x00\x00\x10\x00\x1c\x00Antarctica/CaseyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xfe\x1è\x00\x00\x00\x00J\xda" +
+       "\x06 \x00\x00\x00\x00K\x8f\xca\xf0\x00\x00\x00\x00N\xa9\x9c \x00\x00\x00\x00OC͐\x00\x00\x00\x00X\n;\x80\x00\x00\x00\x00Z\xa4\x0f\x10\x00\x00\x00\x00[\xb9\x14@\x00\x00\x00\x00\\\x8d\x1d\x80\x00\x00" +
+       "\x00\x00]\x96E0\x00\x00\x00\x00^c\xc5\x00\x00\x00\x00\x00_x\xa0<\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x9a\xb0\x00\b-00\x00+08\x00" +
+       "+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb2\x84J]\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x1c\x00Antarctica/Macqu" +
+       "arieUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00" +
+       "\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff|\x05\x16\x00\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xa0\x87\xb4`\xff\xff\xff\xff\xd7\fh\x00\xff\xff\xff\xff\xfb\u008d\x00\xff\xff\xff\xff\xfc" +
+       "\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p9\x80\x00" +
+       "\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n" +
+       "\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00" +
+       "\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18" +
+       "\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00" +
+       "\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00'" +
+       ")\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94\\\x00\x00" +
+       "\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00\x00\x005" +
+       "\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf*\x80\x00" +
+       "\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C" +
+       ">\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x00\x00\x00\x00G\xf7\xa2\x00\x00\x00\x00\x00H\xe7\x93\x00\x00\x00\x00\x00Iׄ\x00\x00" +
+       "\x00\x00\x00J\xc7u\x00\x00\x00\x00\x00M\x97H\x00\x01\x02\x01\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00" +
+       "\x9a\xb0\x01\t-00\x00AEST\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15\x00\x1c\x00Antarctica/South_PoleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff" +
+       "\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18" +
+       "\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff" +
+       "\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L" +
+       "\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00" +
+       "\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12x" +
+       "g\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00" +
+       "\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F" +
+       "\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00" +
+       "\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8d" +
+       "k`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00" +
+       "\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93" +
+       "O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00" +
+       "\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LMT\x00NZST\x00NZMT\x00NZDT" +
+       "\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00" +
+       "Arctic/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00" +
+       "\x00\x13\x00\x1c\x00Arctic/LongyearbyenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa7YG]\xff\xff\xff\xff\xb5\xa3\xb6\xf0\x00\x00\x00\x00\x15'E`\x00\x00\x00\x00\x16\x18y\xd0\x00" +
-       "\x00\x00\x00\x17\bx\xe0\x00\x00\x00\x00\x17\xf9\xadP\x00\x00\x00\x00\x18\xe9\xac`\x00\x00\x00\x00\x19\xda\xe0\xd0\x00\x00\x00\x00\x1a\xcc1`\x00\x00\x00\x00\x1b\xbc>\x80\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d" +
-       "\x9c \x80\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00\x1f|\x02\x80\x00\x00\x00\x00 k\xf3\x80\x00\x00\x00\x00![\xe4\x80\x00\x00\x00\x00\"KՀ\x00\x00\x00\x00#;ƀ\x00\x00\x00\x00$+\xb7\x80\x00" +
-       "\x00\x00\x00%\x1b\xa8\x80\x00\x00\x00\x00&\v\x99\x80\x00\x00\x00\x00'\x04\xc5\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xe4\xb5\x10\x00\x00\x00\x00)x]\x10\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*" +
-       "ĉ\x00\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xa4k\x00\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84M\x00\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000d/\x00\x00\x00\x00\x001]Z\x80\x00" +
-       "\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008" +
-       "\xdc\xe2\x80\x00\x00\x00\x009\xfa\xf8\x00\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00" +
-       "\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G" +
-       "#`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00I\x03B\x80\x00\x00\x00\x00I\xceI\x80\x00\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00" +
-       "\x00\x00\x00TK\xba\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00{\xa3\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x9a\xb0\x01\b\x00\x00\x8c\xa0\x00\f\x00\x00\x8c\xa0\x01\f\x00\x00\x9a\xb0\x00\bLMT\x00+09\x00+11\x00" +
-       "+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x1c\x00Asia/VientianeUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00" +
-       "\f\xff\xff\xff\xffV\xb6\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00BMT\x00+07\x00\n<+07>-7\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\r\x00\x1c\x00Asia/ShanghaiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80" +
-       "\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xff" +
-       "Ӌ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0" +
-       "\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00" +
-       "%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xb9\xf4\xb6" +
-       "R\x02\x00\x00R\x02\x00\x00\x0f\x00\x1c\x00Asia/Ulan_BatorUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xeeL\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda" +
-       "\xfc\xf0\x00\x00\x00\x00\x1a\xccM\x80\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xf3\x80\x00\x00" +
-       "\x00\x00![\xd6p\x00\x00\x00\x00\"KՀ\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xb7\x80\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x99\x80\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4" +
-       "\xb6\x00\x00\x00\x00\x00(\xe4\x98\xf0\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84>\xf0\x00\x00" +
-       "\x00\x00/t>\x00\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002M=p\x00\x00\x00\x003=<\x80\x00\x00\x00\x004-\x1fp\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\r" +
-       "\x01p\x00\x00\x00\x00:鳠\x00\x00\x00\x00;\xb4\xac\x90\x00\x00\x00\x00<\xa4\xab\xa0\x00\x00\x00\x00=\x94\x8e\x90\x00\x00\x00\x00>\x84\x8d\xa0\x00\x00\x00\x00?tp\x90\x00\x00\x00\x00@do\xa0\x00\x00" +
-       "\x00\x00ATR\x90\x00\x00\x00\x00BDQ\xa0\x00\x00\x00\x00C44\x90\x00\x00\x00\x00D$3\xa0\x00\x00\x00\x00E\x1dQ\x10\x00\x00\x00\x00U\x15\x9a\xa0\x00\x00\x00\x00V\x05ap\x00\x00\x00\x00V\xf5" +
-       "|\xa0\x00\x00\x00\x00W\xe5Cp\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x00\x00d4\x00\x00\x00\x00bp\x00\x04\x00\x00~\x90\x01\b\x00\x00p\x80\x00\fLMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x1c\x00Asia/AdenUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*0\x00\x04LMT\x00+03\x00" +
-       "\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/MuscatUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1\xf2\x99" +
-       "\xa8\x01\x00\x003\xd8\x00\x00\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xef\\\xf4q\x17\x04\x00\x00\x17\x04\x00\x00\r\x00\x1c" +
-       "\x00Asia/DamascusUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00c\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xa1\xf2\xabx\xff\xff\xff\xff\xa2\x81/\x80\xff\xff\xff\xff\xa3^\x9dp\xff\xff\xff\xff\xa4a\x11\x80\xff\xff\xff\xff\xa5>\u007fp\xff\xff\xff" +
-       "\xff\xa6@\xf3\x80\xff\xff\xff\xff\xa7\x1eap\xff\xff\xff\xff\xa8 Հ\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xf1\x8fR\x00\xff\xff\xff\xff\xf2[\x9cp\xff\xff\xff\xff\xf3s(\x80\xff\xff\xff\xff\xf4;~" +
-       "p\xff\xff\xff\xff\xf5U\xad\x80\xff\xff\xff\xff\xf6\x1fT\xf0\xff\xff\xff\xff\xf76\xe1\x00\xff\xff\xff\xff\xf7\xff6\xf0\xff\xff\xff\xff\xf9\x0e\xda\x00\xff\xff\xff\xff\xf9\xe1\xbb\xf0\xff\xff\xff\xff\xfa\xf9H\x00\xff\xff\xff" +
-       "\xff\xfb\xc2\xefp\xff\xff\xff\xff\xfc\xdb\xcd\x00\xff\xff\xff\xff\xfd\xa5tp\xff\xff\xff\xff\xfe\xbd\x00\x80\xff\xff\xff\xff\xff\x86\xa7\xf0\x00\x00\x00\x00\x00\x9e4\x00\x00\x00\x00\x00\x01g\xdbp\x00\x00\x00\x00\x02\u007fg" +
-       "\x80\x00\x00\x00\x00\x03I\x0e\xf0\x00\x00\x00\x00\x04a\xec\x80\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06C \x00\x00\x00\x00\x00\a\f\xc7p\x00\x00\x00\x00\b$S\x80\x00\x00\x00\x00\b\xed\xfa\xf0\x00\x00\x00" +
-       "\x00\n\x05\x87\x00\x00\x00\x00\x00\n\xcf.p\x00\x00\x00\x00\v\xe8\f\x00\x00\x00\x00\x00\f\xb1\xb3p\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0ekY\xf0\x00\x00\x00\x00\x0f\xaas\x00\x00\x00\x00\x00\x10L\x8d" +
-       "p\x00\x00\x00\x00\x18\xf4\xc5\x00\x00\x00\x00\x00\x19\xdbmp\x00\x00\x00\x00\x1a\xd7J\x00\x00\x00\x00\x00\x1b\xbd\xf2p\x00\x00\x00\x00\x1eU#\x00\x00\x00\x00\x00\x1f\x8a\xe5p\x00\x00\x00\x00 Gz\x00\x00\x00\x00" +
-       "\x00!\x89\x19\xf0\x00\x00\x00\x00\"<t\x00\x00\x00\x00\x00#k\x9e\xf0\x00\x00\x00\x00$2\xbf\x80\x00\x00\x00\x00%%Ep\x00\x00\x00\x00&\x15D\x80\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf6[" +
-       "\xe0\x00\x00\x00\x00(\xe7\x90P\x00\x00\x00\x00)\xe2\x1b`\x00\x00\x00\x00*\xca\x15P\x00\x00\x00\x00+\xb2+`\x00\x00\x00\x00,\xa3_\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00.\x8c|P\x00\x00\x00" +
-       "\x00/|{`\x00\x00\x00\x000m\xaf\xd0\x00\x00\x00\x001_\x00`\x00\x00\x00\x002P4\xd0\x00\x00\x00\x003>\xe2`\x00\x00\x00\x0041hP\x00\x00\x00\x005\x1e\xc4`\x00\x00\x00\x006\x12\x9b" +
-       "\xd0\x00\x00\x00\x007\x02\x9a\xe0\x00\x00\x00\x007\xf3\xcfP\x00\x00\x00\x008\xe5\x1f\xe0\x00\x00\x00\x009\xd6TP\x00\x00\x00\x00:\xc6S`\x00\x00\x00\x00;\xb7\x87\xd0\x00\x00\x00\x00<\xa7\x86\xe0\x00\x00\x00" +
-       "\x00=\x98\xbbP\x00\x00\x00\x00>\x88\xba`\x00\x00\x00\x00?y\xee\xd0\x00\x00\x00\x00@k?`\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00BLr\xe0\x00\x00\x00\x00C=\xa7P\x00\x00\x00\x00D-\xa6" +
-       "`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\f6\xe0\x00\x00\x00\x00G*>P\x00\x00\x00\x00G\xf5S`\x00\x00\x00\x00I\vq\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xea\x02P\x00\x00\x00" +
-       "\x00K\xb5\x17`\x00\x00\x00\x00L\xc9\xe4P\x00\x00\x00\x00M\x94\xf9`\x00\x00\x00\x00N\xa9\xc6P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\"\b\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.5/0,M" +
-       "10.5.5/0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\x0e\x00\x1c\x00Asia/JerusalemUT\t\x00\x03\xec," +
-       "\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00b\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff" +
-       "V\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff\xc8Y\xb2\xe0\xff\xff\xff\xff\xcc\xe5\xc1P\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0" +
-       "\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xc9p\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4k\xe0\xd0\xff\xff\xff\xff\xd7Z\x14`\xff\xff\xff\xff\xd7\xdf\x1f\xc0\xff\xff\xff\xff\xd8/\xb5p\xff\xff\xff\xff" +
-       "\xd9\x1eF\xe0\xff\xff\xff\xff\xda\x10\xe8\xf0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ \xe0\xff\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80" +
-       "\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}\x00\xff\xff\xff\xff\xe2\xbeJ`\xff\xff\xff\xff\xe364\xd0\xff\xff\xff\xff\xe4\x9c\xf7\x00\xff\xff\xff\xff\xe5\x16\x16\xd0\xff\xff\xff\xff\xe6t\xd3\xe0\xff\xff\xff\xff" +
-       "\xe7\x11Ҁ\xff\xff\xff\xff\xe8'\xff\x00\xff\xff\xff\xff\xe8\xe8O\xd0\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe8\xaa\xe0" +
-       "\x00\x00\x00\x00\x14 \t\xe0\x00\x00\x00\x00\x1a\xf9t\xe0\x00\x00\x00\x00\x1b\x8d\x1c\xe0\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1d\x89\xf1\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff\xff\x9b'\xe3\x00\xff\xff\xff\xff\x9b\xd4{`\xff\xff\xff\xffȷM`\xff" +
+       "\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb" +
+       "\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff\xed\x98=\x10\xff\xff\xff\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff\xff\xf0h\x10\x10\xff\xff\xff\xff\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff" +
+       "\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10\xff\xff\xff\xff\xf5\x17\xc5\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06\x10\xff\xff\xff\xff\xf7\xf0Ґ\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x14" +
+       "3\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00" +
+       "\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"" +
+       "LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00" +
+       "\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000" +
+       "d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M1" +
+       "0.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x1c\x00Asia/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x1c\x00Asia/TomskUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xe5" +
+       "N\xd9\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00" +
+       "\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\" +
+       "\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00" +
+       "\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84" +
+       "w0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY0\x00\x00\x00\x001]\x84\xb0\x00\x00\x00\x002r_\xb0\x00\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00" +
+       "\x00\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00\x008\x1b@0\x00\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6" +
+       "\v0\x00\x00\x00\x00<\xce\xe9\xb0\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00" +
+       "\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0\x00\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\xce" +
+       "\x81\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00\x00\x00WI\xf8\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00O" +
+       "\xa7\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x81z&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x1c\x00Asia/ChoibalsanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff\x86\xd3\xe7(\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00" +
+       "\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x04`\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xe6`" +
+       "\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xc8`\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00" +
+       "'\x04\xa8\xe0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\x8a\xe0\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4l\xe0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94M\xf0" +
+       "\x00\x00\x00\x00.\x840\xe0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]Lp\x00\x00\x00\x002M/`\x00\x00\x00\x003=.p\x00\x00\x00\x004-\x11`\x00\x00\x00\x00" +
+       "5\x1d\x10p\x00\x00\x00\x006\f\xf3`\x00\x00\x00\x00:饐\x00\x00\x00\x00;\xb4\x9e\x80\x00\x00\x00\x00<\xa4\x9d\x90\x00\x00\x00\x00=\x94\x80\x80\x00\x00\x00\x00>\x84\u007f\x90\x00\x00\x00\x00?tb\x80" +
+       "\x00\x00\x00\x00@da\x90\x00\x00\x00\x00ATD\x80\x00\x00\x00\x00BDC\x90\x00\x00\x00\x00C4&\x80\x00\x00\x00\x00D$%\x90\x00\x00\x00\x00E\x1dC\x00\x00\x00\x00\x00G\xef\xaa\xf0\x00\x00\x00\x00" +
+       "U\x15\x9a\xa0\x00\x00\x00\x00V\x05ap\x00\x00\x00\x00V\xf5|\xa0\x00\x00\x00\x00W\xe5Cp\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x00\x00kX\x00\x00\x00\x00bp\x00\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\f\x00\x00\x8c\xa0\x01\x10\x00\x00~\x90\x01\fLMT\x00+" +
+       "07\x00+08\x00+09\x00+10\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/T" +
+       "himbuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02" +
+       "\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\xd5\xe6\x15t\x00\x00\x00\x00!aM\xa8\x01\x02\x00\x00T\f\x00\x00\x00\x00MX\x00\x04\x00\x00T`\x00\nLMT\x00+0530\x00+06\x00\n<" +
+       "+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x1c\x00Asia/VientianeUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffV\xb6" +
+       "\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00BMT\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9Rʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x1c\x00Asia/YangonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffV\xb6\x89\xd1\xff\xff\xff\xff\xa1\xf2sQ\xff\xff\xff\xff\xcb\xf2\xfc\x18\xff" +
+       "\xff\xff\xffњg\xf0\x01\x02\x03\x02\x00\x00Z/\x00\x00\x00\x00Z/\x00\x04\x00\x00[h\x00\b\x00\x00~\x90\x00\x0eLMT\x00RMT\x00+0630\x00+09\x00\n<+0630" +
+       ">-6:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R6j\\J\xcf\x04\x00\x00\xcf\x04\x00\x00\v\x00\x1c\x00Asia/HebronUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00u\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\x19\xff" +
+       "\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xff\xd0" +
+       "\xa9\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff" +
+       "\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1" +
+       "\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff" +
+       "\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n" +
+       "\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00" +
+       "\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&" +
+       "\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00" +
+       "\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003" +
+       "D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00" +
+       "\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A" +
+       "\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00" +
+       "\x00\x00\x00H\xbb\x06P\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xa0<`\x00\x00\x00\x00K\xab\xdc\xe0\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00N" +
+       "\\\v\xe0\x00\x00\x00\x00N\x84\xdcP\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00" +
+       "\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[" +
+       "ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 \xe7\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EE" +
+       "ST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.4.4/49\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00Asia/ChongqingUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff" +
+       "\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B" +
+       "\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00" +
+       "\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'" +
+       "e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00" +
+       "\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00" +
+       "\x1c\x00Asia/KabulUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffi\x86\x9a\xa0\xff\xff\xff\xff\xd0\xf9\xd7@\x01\x02\x00\x00@\xe0\x00\x00\x00\x008@\x00\x04\x00\x00?H\x00\bLMT\x00+04\x00+" +
+       "0430\x00\n<+0430>-4:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x1c\x00Asia/Bahrai" +
+       "nUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03" +
+       "\x00\x00\x00\f\xff\xff\xff\xff\xa1\xf2\x9d0\x00\x00\x00\x00\x04\x8a\x92\xc0\x01\x02\x00\x000P\x00\x00\x00\x008@\x00\x04\x00\x00*0\x00\bLMT\x00+04\x00+03\x00\n<+03>-3" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf9l\x03\x12\xf8\x02\x00\x00\xf8\x02\x00\x00\f\x00\x1c\x00Asia/IrkutskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xffV\xb6\x82?\xff\xff\xff\xff\xa2\x12" +
+       "\x0f\xbf\xff\xff\xff\xff\xb5\xa3\xd3\x10\x00\x00\x00\x00\x15'a\x80\x00\x00\x00\x00\x16\x18\x95\xf0\x00\x00\x00\x00\x17\b\x95\x00\x00\x00\x00\x00\x17\xf9\xc9p\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xfc\xf0\x00\x00" +
+       "\x00\x00\x1a\xccM\x80\x00\x00\x00\x00\x1b\xbcZ\xa0\x00\x00\x00\x00\x1c\xacK\xa0\x00\x00\x00\x00\x1d\x9c<\xa0\x00\x00\x00\x00\x1e\x8c-\xa0\x00\x00\x00\x00\x1f|\x1e\xa0\x00\x00\x00\x00 l\x0f\xa0\x00\x00\x00\x00!\\" +
+       "\x00\xa0\x00\x00\x00\x00\"K\xf1\xa0\x00\x00\x00\x00#;\xe2\xa0\x00\x00\x00\x00$+Ӡ\x00\x00\x00\x00%\x1bĠ\x00\x00\x00\x00&\v\xb5\xa0\x00\x00\x00\x00'\x04\xe1 \x00\x00\x00\x00'\xf4\xd2 \x00\x00" +
+       "\x00\x00(\xe4\xd10\x00\x00\x00\x00)xy0\x00\x00\x00\x00)Դ \x00\x00\x00\x00*ĥ \x00\x00\x00\x00+\xb4\x96 \x00\x00\x00\x00,\xa4\x87 \x00\x00\x00\x00-\x94x \x00\x00\x00\x00.\x84" +
+       "i \x00\x00\x00\x00/tZ \x00\x00\x00\x000dK \x00\x00\x00\x001]v\xa0\x00\x00\x00\x002rQ\xa0\x00\x00\x00\x003=X\xa0\x00\x00\x00\x004R3\xa0\x00\x00\x00\x005\x1d:\xa0\x00\x00" +
+       "\x00\x0062\x15\xa0\x00\x00\x00\x006\xfd\x1c\xa0\x00\x00\x00\x008\x1b2 \x00\x00\x00\x008\xdc\xfe\xa0\x00\x00\x00\x009\xfb\x14 \x00\x00\x00\x00:\xbc\xe0\xa0\x00\x00\x00\x00;\xda\xf6 \x00\x00\x00\x00<\xa5" +
+       "\xfd \x00\x00\x00\x00=\xba\xd8 \x00\x00\x00\x00>\x85\xdf \x00\x00\x00\x00?\x9a\xba \x00\x00\x00\x00@e\xc1 \x00\x00\x00\x00A\x83֠\x00\x00\x00\x00BE\xa3 \x00\x00\x00\x00Cc\xb8\xa0\x00\x00" +
+       "\x00\x00D%\x85 \x00\x00\x00\x00EC\x9a\xa0\x00\x00\x00\x00F\x05g \x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\ue0e0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I\xcee\xa0\x00\x00\x00\x00J\xe3" +
+       "@\xa0\x00\x00\x00\x00K\xaeG\xa0\x00\x00\x00\x00L\xcc] \x00\x00\x00\x00M\x8e)\xa0\x00\x00\x00\x00TK\xd7\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x06\x04\x00\x00a\xc1\x00\x00\x00\x00a\xc1\x00\x04\x00\x00bp\x00\b\x00\x00" +
+       "~\x90\x01\f\x00\x00p\x80\x00\x10\x00\x00p\x80\x01\x10\x00\x00~\x90\x00\fLMT\x00IMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9RO\xb0\x03\xe9\xe5\x02\x00\x00\xe5\x02\x00\x00\f\x00\x1c\x00Asia/YakutskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\xea^\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp" +
+       "\x00\x00\x00\x00\x16\x18\x87\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00\x00\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00" +
+       "\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ" +
+       "\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xb6\x90\x00\x00\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00" +
+       ")Ԧ\x10\x00\x00\x00\x00*ė\x10\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10" +
+       "\x00\x00\x00\x001]h\x90\x00\x00\x00\x002rC\x90\x00\x00\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x0062\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x00" +
+       "8\x1b$\x10\x00\x00\x00\x008\xdc\xf0\x90\x00\x00\x00\x009\xfb\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10" +
+       "\x00\x00\x00\x00?\x9a\xac\x10\x00\x00\x00\x00@e\xb3\x10\x00\x00\x00\x00A\x83Ȑ\x00\x00\x00\x00BE\x95\x10\x00\x00\x00\x00Cc\xaa\x90\x00\x00\x00\x00D%w\x10\x00\x00\x00\x00EC\x8c\x90\x00\x00\x00\x00" +
+       "F\x05Y\x10\x00\x00\x00\x00G#n\x90\x00\x00\x00\x00G\xeeu\x90\x00\x00\x00\x00I\x03P\x90\x00\x00\x00\x00I\xceW\x90\x00\x00\x00\x00J\xe32\x90\x00\x00\x00\x00K\xae9\x90\x00\x00\x00\x00L\xccO\x10" +
+       "\x00\x00\x00\x00M\x8e\x1b\x90\x00\x00\x00\x00TK\xc9\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00y\xa2\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x8c\xa0\x00\bLMT" +
+       "\x00+08\x00+10\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x1c\x00Asia/Jay" +
+       "apuraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03" +
+       "\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\xba\x16\xc1\x98\xff\xff\xff\xff\xd0X\xb9\xf0\xff\xff\xff\xff\xf4\xb5\xa2h\x01\x02\x03\x00\x00\x83\xe8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x85\x98\x00\b\x00\x00~\x90\x00\x0eL" +
+       "MT\x00+09\x00+0930\x00WIT\x00\nWIT-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\x0e\x00\x1c\x00Asia/H" +
+       "ong_KongUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00E\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff\x85ic\x90\xff\xff\xff\xff\xcaM10\xff\xff\xff\xff\xcaۓ0\xff\xff\xff\xff\xcbKqx\xff\xff\xff\xffҠސ\xff\xff\xff\xff\xd3k׀\xff" +
+       "\xff\xff\xffԓX\xb8\xff\xff\xff\xff\xd5B\xb08\xff\xff\xff\xff\xd6s:\xb8\xff\xff\xff\xff\xd7>A\xb8\xff\xff\xff\xff\xd8.2\xb8\xff\xff\xff\xff\xd8\xf99\xb8\xff\xff\xff\xff\xda\x0e\x14\xb8\xff\xff\xff\xff\xda" +
+       "\xd9\x1b\xb8\xff\xff\xff\xff\xdb\xed\xf6\xb8\xff\xff\xff\xffܸ\xfd\xb8\xff\xff\xff\xff\xdd\xcdظ\xff\xff\xff\xffޢ\x1a8\xff\xff\xff\xff߶\xf58\xff\xff\xff\xff\xe0\x81\xfc8\xff\xff\xff\xff\xe1\x96\xc9(\xff" +
+       "\xff\xff\xff\xe2Oi8\xff\xff\xff\xff\xe3v\xab(\xff\xff\xff\xff\xe4/K8\xff\xff\xff\xff\xe5_Ǩ\xff\xff\xff\xff\xe6\x0f-8\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff\xff\xe9" +
+       "\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefwѸ\xff" +
+       "\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff\xff\xf7" +
+       "%~8\xff\xff\xff\xff\xf8\x15a(\xff\xff\xff\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf5C(\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA\xa8\xff" +
+       "\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00\x00\x05" +
+       "G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩8\x00" +
+       "\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00\x00\x00\x00\x12ol\xa8\x01\x02\x03\x04\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00k\n\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x01\b\x00\x00w\x88\x01\r\x00\x00~\x90" +
+       "\x00\x12LMT\x00HKT\x00HKST\x00HKWT\x00JST\x00\nHKT-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RS\xa5\x81e\xf7\x00\x00\x00\xf7\x00\x00\x00\x0e\x00\x1c" +
+       "\x00Asia/PontianakUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00\x1f\xff\xff\xff\xff\x8b\xff\x8e\x00\xff\xff\xff\xff\xba\x16\xdf\x00\xff\xff\xff\xff\xcby\xa4\b\xff\xff\xff\xff\xd2V\xeep\xff\xff\xff\xff\xd7<\xc6\b\xff\xff" +
+       "\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xf4\xb5\xbe\x88\x00\x00\x00\x00!\xdat\x80\x01\x02\x03\x02\x04\x02\x05\x06\x00\x00f\x80\x00\x00\x00\x00f\x80\x00\x04\x00\x00ix\x00\b\x00\x00~\x90\x00\x0e\x00\x00p\x80\x00\x12" +
+       "\x00\x00p\x80\x00\x16\x00\x00bp\x00\x1bLMT\x00PMT\x00+0730\x00+09\x00+08\x00WITA\x00WIB\x00\nWIB-7\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x1c\x00Asia/TehranUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff\xff\x9al}\xc8\xff\xff\xff\xff\xd2\xdb\x12\xc8\x00\x00\x00\x00\x0e\xbb\xa2H\x00\x00" +
+       "\x00\x00\x0ft-@\x00\x00\x00\x00\x10\x8e@0\x00\x00\x00\x00\x10\xed:@\x00\x00\x00\x00\x11Ug\xc8\x00\x00\x00\x00\x12EJ\xb8\x00\x00\x00\x00\x137\xec\xc8\x00\x00\x00\x00\x14-\x15\xb8\x00\x00\x00\x00( " +
+       "v\xc8\x00\x00\x00\x00(\u06dd\xb8\x00\x00\x00\x00)˜\xc8\x00\x00\x00\x00*\xbe\"\xb8\x00\x00\x00\x00+\xac\xd0H\x00\x00\x00\x00,\x9fV8\x00\x00\x00\x00-\x8e\x03\xc8\x00\x00\x00\x00.\x80\x89\xb8\x00\x00" +
+       "\x00\x00/o7H\x00\x00\x00\x000a\xbd8\x00\x00\x00\x001Pj\xc8\x00\x00\x00\x002B\xf0\xb8\x00\x00\x00\x0032\xef\xc8\x00\x00\x00\x004%u\xb8\x00\x00\x00\x005\x14#H\x00\x00\x00\x006\x06" +
+       "\xa98\x00\x00\x00\x006\xf5V\xc8\x00\x00\x00\x007\xe7ܸ\x00\x00\x00\x008֊H\x00\x00\x00\x009\xc9\x108\x00\x00\x00\x00:\xb9\x0fH\x00\x00\x00\x00;\xab\x958\x00\x00\x00\x00<\x9aB\xc8\x00\x00" +
+       "\x00\x00=\x8cȸ\x00\x00\x00\x00>{vH\x00\x00\x00\x00?m\xfc8\x00\x00\x00\x00@\\\xa9\xc8\x00\x00\x00\x00AO/\xb8\x00\x00\x00\x00B?.\xc8\x00\x00\x00\x00C1\xb4\xb8\x00\x00\x00\x00G\xe2" +
+       "\xc9H\x00\x00\x00\x00H\xd5O8\x00\x00\x00\x00I\xc5NH\x00\x00\x00\x00J\xb7\xd48\x00\x00\x00\x00K\xa6\x81\xc8\x00\x00\x00\x00L\x99\a\xb8\x00\x00\x00\x00M\x87\xb5H\x00\x00\x00\x00Nz;8\x00\x00" +
+       "\x00\x00Oh\xe8\xc8\x00\x00\x00\x00P[n\xb8\x00\x00\x00\x00QKm\xc8\x00\x00\x00\x00R=\xf3\xb8\x00\x00\x00\x00S,\xa1H\x00\x00\x00\x00T\x1f'8\x00\x00\x00\x00U\r\xd4\xc8\x00\x00\x00\x00V\x00" +
+       "Z\xb8\x00\x00\x00\x00V\xef\bH\x00\x00\x00\x00W\xe1\x8e8\x00\x00\x00\x00XэH\x00\x00\x00\x00Y\xc4\x138\x00\x00\x00\x00Z\xb2\xc0\xc8\x00\x00\x00\x00[\xa5F\xb8\x00\x00\x00\x00\\\x93\xf4H\x00\x00" +
+       "\x00\x00]\x86z8\x00\x00\x00\x00^u'\xc8\x00\x00\x00\x00_g\xad\xb8\x00\x00\x00\x00`W\xac\xc8\x00\x00\x00\x00aJ2\xb8\x00\x00\x00\x00b8\xe0H\x00\x00\x00\x00c+f8\x00\x00\x00\x00d\x1a" +
+       "\x13\xc8\x00\x00\x00\x00e\f\x99\xb8\x00\x00\x00\x00e\xfbGH\x00\x00\x00\x00f\xed\xcd8\x00\x00\x00\x00g\xdd\xccH\x00\x00\x00\x00h\xd0R8\x00\x00\x00\x00i\xbe\xff\xc8\x00\x00\x00\x00j\xb1\x85\xb8\x00\x00" +
+       "\x00\x00k\xa03H\x00\x00\x00\x00l\x92\xb98\x00\x00\x00\x00m\x81f\xc8\x00\x00\x00\x00ns\xec\xb8\x00\x00\x00\x00ob\x9aH\x00\x00\x00\x00pU 8\x00\x00\x00\x00qE\x1fH\x00\x00\x00\x00r7" +
+       "\xa58\x00\x00\x00\x00s&R\xc8\x00\x00\x00\x00t\x18ظ\x00\x00\x00\x00u\a\x86H\x00\x00\x00\x00u\xfa\f8\x00\x00\x00\x00v\xe8\xb9\xc8\x00\x00\x00\x00w\xdb?\xb8\x00\x00\x00\x00x\xcb>\xc8\x00\x00" +
+       "\x00\x00y\xbdĸ\x00\x00\x00\x00z\xacrH\x00\x00\x00\x00{\x9e\xf88\x00\x00\x00\x00|\x8d\xa5\xc8\x00\x00\x00\x00}\x80+\xb8\x00\x00\x00\x00~n\xd9H\x00\x00\x00\x00\u007fa_8\x00\x00\x00\x00\x80Q" +
+       "^H\x00\x00\x00\x00\x81C\xe48\x00\x00\x00\x00\x822\x91\xc8\x00\x00\x00\x00\x83%\x17\xb8\x00\x00\x00\x00\x84\x13\xc5H\x00\x00\x00\x00\x85\x06K8\x00\x00\x00\x00\x85\xf4\xf8\xc8\x00\x00\x00\x00\x86\xe7~\xb8\x00\x00" +
+       "\x00\x00\x87\xd7}\xc8\x00\x00\x00\x00\x88\xca\x03\xb8\x00\x00\x00\x00\x89\xb8\xb1H\x00\x00\x00\x00\x8a\xab78\x00\x00\x00\x00\x8b\x99\xe4\xc8\x00\x00\x00\x00\x8c\x8cj\xb8\x00\x00\x00\x00\x8d{\x18H\x00\x00\x00\x00\x8em" +
+       "\x9e8\x00\x00\x00\x00\x8f]\x9dH\x00\x00\x00\x00\x90P#8\x00\x00\x00\x00\x91>\xd0\xc8\x00\x00\x00\x00\x921V\xb8\x00\x00\x00\x00\x93 \x04H\x00\x00\x00\x00\x94\x12\x8a8\x00\x00\x00\x00\x95\x017\xc8\x00\x00" +
+       "\x00\x00\x95\xf3\xbd\xb8\x00\x00\x00\x00\x96\xe3\xbc\xc8\x00\x00\x00\x00\x97\xd6B\xb8\x00\x00\x00\x00\x98\xc4\xf0H\x00\x00\x00\x00\x99\xb7v8\x00\x00\x00\x00\x9a\xa6#\xc8\x00\x00\x00\x00\x9b\x98\xa9\xb8\x00\x00\x00\x00\x9c\x87" +
+       "WH\x00\x00\x00\x00\x9dy\xdd8\x00\x00\x00\x00\x9ei\xdcH\x00\x00\x00\x00\x9f\\b8\x00\x00\x00\x00\xa0K\x0f\xc8\x00\x00\x00\x00\xa1=\x95\xb8\x00\x00\x00\x00\xa2,CH\x00\x00\x00\x00\xa3\x1e\xc98\x00\x00" +
+       "\x00\x00\xa4\rv\xc8\x00\x00\x00\x00\xa4\xff\xfc\xb8\x00\x00\x00\x00\xa5\xef\xfb\xc8\x00\x00\x00\x00\xa6⁸\x00\x00\x00\x00\xa7\xd1/H\x00\x00\x00\x00\xa8õ8\x00\x00\x00\x00\xa9\xb2b\xc8\x00\x00\x00\x00\xaa\xa4" +
+       "\xe8\xb8\x00\x00\x00\x00\xab\x93\x96H\x00\x00\x00\x00\xac\x86\x1c8\x00\x00\x00\x00\xadt\xc9\xc8\x00\x00\x00\x00\xaegO\xb8\x00\x00\x00\x00\xafWN\xc8\x00\x00\x00\x00\xb0IԸ\x00\x00\x00\x00\xb18\x82H\x00\x00" +
+       "\x00\x00\xb2+\b8\x00\x00\x00\x00\xb3\x19\xb5\xc8\x00\x00\x00\x00\xb4\f;\xb8\x00\x00\x00\x00\xb4\xfa\xe9H\x00\x00\x00\x00\xb5\xedo8\x00\x00\x00\x00\xb6\xddnH\x00\x00\x00\x00\xb7\xcf\xf48\x00\x00\x00\x00\xb8\xbe" +
+       "\xa1\xc8\x00\x00\x00\x00\xb9\xb1'\xb8\x00\x00\x00\x00\xba\x9f\xd5H\x00\x00\x00\x00\xbb\x92[8\x00\x00\x00\x00\xbc\x81\b\xc8\x00\x00\x00\x00\xbds\x8e\xb8\x00\x00\x00\x00\xbec\x8d\xc8\x00\x00\x00\x00\xbfV\x13\xb8\x00\x00" +
+       "\x00\x00\xc0D\xc1H\x00\x00\x00\x00\xc17G8\x00\x00\x00\x00\xc2%\xf4\xc8\x00\x00\x00\x00\xc3\x18z\xb8\x00\x00\x00\x00\xc4\a(H\x00\x00\x00\x00\xc4\xf9\xae8\x00\x00\x00\x00\xc5\xe9\xadH\x00\x00\x00\x00\xc6\xdc" +
+       "38\x00\x00\x00\x00\xc7\xca\xe0\xc8\x00\x00\x00\x00Ƚf\xb8\x00\x00\x00\x00ɬ\x14H\x00\x00\x00\x00ʞ\x9a8\x00\x00\x00\x00ˍG\xc8\x00\x00\x00\x00\xcc\u007f\u0378\x00\x00\x00\x00\xcdo\xcc\xc8\x00\x00" +
+       "\x00\x00\xcebR\xb8\x00\x00\x00\x00\xcfQ\x00H\x00\x00\x00\x00\xd0C\x868\x00\x00\x00\x00\xd123\xc8\x00\x00\x00\x00\xd2$\xb9\xb8\x00\x00\x00\x00\xd3\x13gH\x00\x00\x00\x00\xd4\x05\xed8\x00\x00\x00\x00\xd4\xf5" +
+       "\xecH\x00\x00\x00\x00\xd5\xe8r8\x00\x00\x00\x00\xd6\xd7\x1f\xc8\x00\x00\x00\x00\xd7ɥ\xb8\x00\x00\x00\x00ظSH\x00\x00\x00\x00٪\xd98\x00\x00\x00\x00ڙ\x86\xc8\x00\x00\x00\x00ی\f\xb8\x00\x00" +
+       "\x00\x00\xdc|\v\xc8\x00\x00\x00\x00\xddn\x91\xb8\x00\x00\x00\x00\xde]?H\x01\x02\x04\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
+       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
+       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
+       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x00\x0008\x00\x00\x00\x0008\x00\x04\x00\x0018\x00" +
+       "\b\x00\x00FP\x01\x0e\x00\x008@\x00\x12\x00\x00?H\x01\x16LMT\x00TMT\x00+0330\x00+05\x00+04\x00+0430\x00\n<+0330>-3:30" +
+       "<+0430>,J79/24,J263/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rd%\x05\xd8\xe6\x02\x00\x00\xe6\x02\x00\x00\x10\x00\x1c\x00Asia/Vl" +
+       "adivostokUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa7YG]\xff\xff\xff\xff\xb5\xa3\xb6\xf0\x00\x00\x00\x00\x15'E`\x00\x00\x00\x00\x16\x18y\xd0\x00\x00\x00\x00\x17\bx\xe0\x00\x00\x00\x00\x17\xf9\xadP" +
+       "\x00\x00\x00\x00\x18\xe9\xac`\x00\x00\x00\x00\x19\xda\xe0\xd0\x00\x00\x00\x00\x1a\xcc1`\x00\x00\x00\x00\x1b\xbc>\x80\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d\x9c \x80\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00" +
+       "\x1f|\x02\x80\x00\x00\x00\x00 k\xf3\x80\x00\x00\x00\x00![\xe4\x80\x00\x00\x00\x00\"KՀ\x00\x00\x00\x00#;ƀ\x00\x00\x00\x00$+\xb7\x80\x00\x00\x00\x00%\x1b\xa8\x80\x00\x00\x00\x00&\v\x99\x80" +
+       "\x00\x00\x00\x00'\x04\xc5\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xe4\xb5\x10\x00\x00\x00\x00)x]\x10\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*ĉ\x00\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00" +
+       ",\xa4k\x00\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84M\x00\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000d/\x00\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80" +
+       "\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xfa\xf8\x00\x00\x00\x00\x00" +
+       ":\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80" +
+       "\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00" +
+       "I\x03B\x80\x00\x00\x00\x00I\xceI\x80\x00\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00\x00\x00\x00TK\xba\xf0\x01\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00{" +
+       "\xa3\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x9a\xb0\x01\b\x00\x00\x8c\xa0\x00\f\x00\x00\x8c\xa0\x01\f\x00\x00\x9a\xb0\x00\bLMT\x00+09\x00+11\x00+10\x00\n<+10>-10\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x1c\x00Asia/OmskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xb3@\xb6\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00" +
+       "\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv" +
+       "\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00" +
+       "\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)x\x95" +
+       "P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00+\xb4\xb2@\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\x94@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00" +
+       "\x000dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8" +
+       "\xc0\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00" +
+       "\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6" +
+       "\xc0\x00\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00" +
+       "\x00L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00D\xca\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\f\x00\x00bp" +
+       "\x00\bLMT\x00+05\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00\x1c\x00Asi" +
+       "a/TaipeiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00)\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xfft\xce\xf0\x18\xff\xff\xff\xff\xc3UI\x80\xff\xff\xff\xff\xd2TY\x80\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff" +
+       "\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9\xe7\x99\xf0\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xdb\xc8\xcdp\xff\xff\xff\xff\xdc" +
+       "\xe0Y\x80\xff\xff\xff\xffݪ\x00\xf0\xff\xff\xff\xff\xders\x00\xff\xff\xff\xffߵdp\xff\xff\xff\xff\xe0|\x85\x00\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2]\xb8\x80\xff\xff\xff\xff\xe3w\xcbp\xff" +
+       "\xff\xff\xff\xe4>\xec\x00\xff\xff\xff\xff\xe50 p\xff\xff\xff\xff\xe6!q\x00\xff\xff\xff\xff\xe7\x12\xa5p\xff\xff\xff\xff\xe8\x02\xa4\x80\xff\xff\xff\xff\xe8\xf3\xd8\xf0\xff\xff\xff\xff\xe9\xe3\xd8\x00\xff\xff\xff\xff\xea" +
+       "\xd5\fp\xff\xff\xff\xff\xeb\xc5\v\x80\xff\xff\xff\xff\xec\xb6?\xf0\xff\xff\xff\xff\xed\xf7\xfc\x00\xff\xff\xff\xff\xee\x98\xc4\xf0\xff\xff\xff\xff\xef\xd9/\x80\xff\xff\xff\xff\xf0y\xf8p\x00\x00\x00\x00\a\xfcV\x00\x00" +
+       "\x00\x00\x00\b\xed\x8ap\x00\x00\x00\x00\t݉\x80\x00\x00\x00\x00\nν\xf0\x00\x00\x00\x00\x11ۡ\x80\x00\x00\x00\x00\x12T\xddp\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01" +
+       "\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x00\x00q\xe8\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x01\fLMT\x00CST\x00JST\x00CDT\x00" +
+       "\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/DaccaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff\xffi\x86\x86\xbc\xff\xff" +
+       "\xff\xff\xcaۆ\xb0\xff\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xffݨҘ\x00\x00\x00\x00J;\xc4\x10\x00\x00\x00\x00K<ؐ\x01\x02\x03\x02\x04\x05\x04\x00\x00T\xc4\x00\x00\x00" +
+       "\x00R\xd0\x00\x04\x00\x00[h\x00\b\x00\x00MX\x00\x0e\x00\x00T`\x00\x14\x00\x00bp\x01\x18LMT\x00HMT\x00+0630\x00+0530\x00+06\x00+07\x00\n<+" +
+       "06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R]S\xbb\x12\xac\x03\x00\x00\xac\x03\x00\x00\x0e\x00\x1c\x00Asia/FamagustaUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00V\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa5w\x1e" +
+       ",\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\nݒ\xd0\x00\x00\x00\x00\v\xfad\xe0\x00\x00\x00\x00\f\xbe\xc6P\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00" +
+       "\x00\x10uO\xd0\x00\x00\x00\x00\x11c\xfd`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\x19\xe0\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3" +
+       "`\x00\x00\x00\x00\x17\xf3\x86P\x00\x00\x00\x00\x18\xe3\x85`\x00\x00\x00\x00\x19\xd3hP\x00\x00\x00\x00\x1a\xc3g`\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00" +
+       "\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee" +
+       "\xd0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00" +
+       "\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90" +
+       "\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x008\xdda\x10\x00\x00\x00\x009\xfbv\x90\x00\x00\x00" +
+       "\x00:\xbdC\x10\x00\x00\x00\x00;\xdbX\x90\x00\x00\x00\x00<\xa6_\x90\x00\x00\x00\x00=\xbb:\x90\x00\x00\x00\x00>\x86A\x90\x00\x00\x00\x00?\x9b\x1c\x90\x00\x00\x00\x00@f#\x90\x00\x00\x00\x00A\x849" +
+       "\x10\x00\x00\x00\x00BF\x05\x90\x00\x00\x00\x00Cd\x1b\x10\x00\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00" +
+       "\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8e\x8c\x10\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn" +
+       "\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S7l\x90\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V,)\x90\x00\x00\x00" +
+       "\x00V\xf70\x90\x00\x00\x00\x00W\xd0\u007f\xd0\x00\x00\x00\x00Y\xf5(\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x02\x00\x00\x1f\xd4\x00\x00\x00\x00*0\x01\x04\x00" +
+       "\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00EEST\x00EET\x00+03\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/RiyadhUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*" +
+       "0\x00\x04LMT\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00Asia/Chung" +
+       "kingUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00" +
+       "\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb" +
+       "\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff" +
+       "\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"" +
+       "g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nC" +
+       "ST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xceG|\xea\x13\x03\x00\x00\x13\x03\x00\x00\n\x00\x1c\x00Asia/AmmanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00F\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xb6\xa3\xd6\xd0\x00\x00\x00\x00" +
+       "\x06ry\xe0\x00\x00\x00\x00\a\f\xabP\x00\x00\x00\x00\b$7`\x00\x00\x00\x00\b\xed\xde\xd0\x00\x00\x00\x00\n\x05j\xe0\x00\x00\x00\x00\n\xcf\x12P\x00\x00\x00\x00\v\xe7\xef\xe0\x00\x00\x00\x00\f\xdau\xd0" +
+       "\x00\x00\x00\x00\r\xc9#`\x00\x00\x00\x00\x0e\x92\xca\xd0\x00\x00\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10r\xac\xd0\x00\x00\x00\x00\x1c\xad\xd5`\x00\x00\x00\x00\x1d\x9f\t\xd0\x00\x00\x00\x00\x1e\x92\xfd`\x00\x00\x00\x00" +
+       "\x1f\x82\xe0P\x00\x00\x00\x00 r\xdf`\x00\x00\x00\x00!b\xc2P\x00\x00\x00\x00\"R\xc1`\x00\x00\x00\x00#K\xde\xd0\x00\x00\x00\x00$d\xbc`\x00\x00\x00\x00%+\xc0\xd0\x00\x00\x00\x00&7o`" +
+       "\x00\x00\x00\x00'\v\xa2\xd0\x00\x00\x00\x00(\vs\xe0\x00\x00\x00\x00(\xe2JP\x00\x00\x00\x00)\xe4\xbe`\x00\x00\x00\x00*\xcbf\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\xabH\xd0\x00\x00\x00\x00" +
+       "-\x9bG\xe0\x00\x00\x00\x00.x\xb5\xd0\x00\x00\x00\x00/\x84d`\x00\x00\x00\x000X\xa5\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`" +
+       "\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007z\x93`\x00\x00\x00\x007\xea\xa2\xe0\x00\x00\x00\x008\xe2|\xe0\x00\x00\x00\x009ӿ`\x00\x00\x00\x00:\xc2^\xe0\x00\x00\x00\x00" +
+       ";\xb3\xa1`\x00\x00\x00\x00<\xa3\x92`\x00\x00\x00\x00=\x93\x83`\x00\x00\x00\x00>\x83t`\x00\x00\x00\x00?\x98O`\x00\x00\x00\x00@cV`\x00\x00\x00\x00An\xf6\xe0\x00\x00\x00\x00BLr\xe0" +
+       "\x00\x00\x00\x00C<c\xe0\x00\x00\x00\x00D,T\xe0\x00\x00\x00\x00EA/\xe0\x00\x00\x00\x00F\f6\xe0\x00\x00\x00\x00G!\x11\xe0\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00I\n.`\x00\x00\x00\x00" +
+       "I\xcb\xfa\xe0\x00\x00\x00\x00J\xea\x10`\x00\x00\x00\x00K\xab\xdc\xe0\x00\x00\x00\x00L\xc9\xf2`\x00\x00\x00\x00M\x94\xf9`\x00\x00\x00\x00N\xa9\xd4`\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00R\xb3^P" +
+       "\x00\x00\x00\x00S4\x9f`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00!\xb0\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST," +
+       "M3.5.4/24,M10.5.5/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Asia/Makas" +
+       "sarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00" +
+       "\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xa1\xf2]\x90\xff\xff\xff\xff\xba\x16Ր\xff\xff\xff\xffˈ\x1d\x80\xff\xff\xff\xff\xd2V\xeep\x01\x02\x03\x04\x00\x00o\xf0\x00\x00\x00\x00o\xf0\x00\x04\x00\x00p\x80\x00\b" +
+       "\x00\x00~\x90\x00\f\x00\x00p\x80\x00\x10LMT\x00MMT\x00+08\x00+09\x00WITA\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8bSnT\xa1" +
+       "\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x1c\x00Asia/KathmanduUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf2}\x84\x00\x00\x00\x00\x1e\x180\xa8\x01\x02\x00\x00O\xfc\x00\x00\x00\x00MX\x00\x04\x00\x00" +
+       "P\xdc\x00\nLMT\x00+0530\x00+0545\x00\n<+0545>-5:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00" +
+       "\r\x00\x1c\x00Asia/ShanghaiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p" +
+       "\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff" +
+       "\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0" +
+       "\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00" +
+       "(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bL" +
+       "MT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd5ΜGp\x02\x00\x00p\x02\x00\x00\x0e\x00\x1c\x00Asia/Qyzylor" +
+       "daUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00" +
+       "\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x86\xa0\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2" +
+       "\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00" +
+       "\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\v" +
+       "P\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\x95P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00" +
+       "\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]" +
+       "\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00" +
+       "\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x00\x00\x00\x00\\\x1b\xd8" +
+       "\xa0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x02\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x00\x00=`\x00\x00\x00" +
+       "\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\x17✳2\x04\x00\x002\x04\x00\x00\r\x00\x1c\x00Asia/Tel_AvivUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff" +
+       "\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00" +
+       "\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xd7Z0\x80\xff\xff\xff\xff\xd7\xdfX\x00\xff\xff\xff\xff\xd8/À\xff\xff\xff\xff" +
+       "\xd9\x1ec\x00\xff\xff\xff\xff\xda\x10\xf7\x00\xff\xff\xff\xff\xda\xeb\xd0\x00\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ=\x00\xff\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80" +
+       "\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}\x00\xff\xff\xff\xff\xe2\xbef\x80\xff\xff\xff\xff\xe36_\x00\xff\xff\xff\xff\xe4\x9eH\x80\xff\xff\xff\xff\xe5\x16A\x00\xff\xff\xff\xff\xe6t\xf0\x00\xff\xff\xff\xff" +
+       "\xe7\x11Ҁ\xff\xff\xff\xff\xe8&\xad\x80\xff\xff\xff\xff\xe8\xe8z\x00\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`" +
+       "\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00" +
        " \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0" +
        "\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00" +
        "._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x001H\x96\xe0\x00\x00\x00\x002<nP\x00\x00\x00\x0031\xb3`\x00\x00\x00\x004\x1a\xfe\xd0\x00\x00\x00\x005\x11\x95`" +
@@ -2586,1057 +2761,963 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "<\xa3\xa0p\x00\x00\x00\x00=\xa0\xb2`\x00\x00\x00\x00>\x83\x82p\x00\x00\x00\x00?|\x9f\xe0\x00\x00\x00\x00@s6p\x00\x00\x00\x00AP\xa4`\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00CHOp" +
        "\x00\x00\x00\x00D,q\x00\x00\x00\x00\x00E\x1e\xf6\xf0\x00\x00\x00\x00F\fS\x00\x00\x00\x00\x00F\xecc\xf0\x00\x00\x00\x00G\xec5\x00\x00\x00\x00\x00H\xe7\xf5p\x00\x00\x00\x00I\xcc\x17\x00\x00\x00\x00\x00" +
        "J\xbe\x9c\xf0\x00\x00\x00\x00K\xab\xf9\x00\x00\x00\x00\x00L\x8c\t\xf0\x00\x00\x00\x00M\x95\x15\x80\x00\x00\x00\x00N\x87\x9bp\x00\x00\x00\x00Ot\xf7\x80\x00\x00\x00\x00P^B\xf0\x00\x00\x00\x00QTـ" +
-       "\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00\x1c " +
-       "\x00\f\x00\x008@\x01\x10LMT\x00JMT\x00IDT\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQy\x19\xe0N\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/BruneiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\xad\x8a\x02D\xff\xff\xff\xff\xbagG\x88\x01\x02\x00" +
-       "\x00k\xbc\x00\x00\x00\x00ix\x00\x04\x00\x00p\x80\x00\nLMT\x00+0730\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xb9\xf4\xb6R\x02" +
-       "\x00\x00R\x02\x00\x00\x10\x00\x1c\x00Asia/UlaanbaatarUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xeeL\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xfc" +
-       "\xf0\x00\x00\x00\x00\x1a\xccM\x80\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xf3\x80\x00\x00\x00" +
-       "\x00![\xd6p\x00\x00\x00\x00\"KՀ\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xb7\x80\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x99\x80\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xb6" +
-       "\x00\x00\x00\x00\x00(\xe4\x98\xf0\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00" +
-       "\x00/t>\x00\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002M=p\x00\x00\x00\x003=<\x80\x00\x00\x00\x004-\x1fp\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\r\x01" +
-       "p\x00\x00\x00\x00:鳠\x00\x00\x00\x00;\xb4\xac\x90\x00\x00\x00\x00<\xa4\xab\xa0\x00\x00\x00\x00=\x94\x8e\x90\x00\x00\x00\x00>\x84\x8d\xa0\x00\x00\x00\x00?tp\x90\x00\x00\x00\x00@do\xa0\x00\x00\x00" +
-       "\x00ATR\x90\x00\x00\x00\x00BDQ\xa0\x00\x00\x00\x00C44\x90\x00\x00\x00\x00D$3\xa0\x00\x00\x00\x00E\x1dQ\x10\x00\x00\x00\x00U\x15\x9a\xa0\x00\x00\x00\x00V\x05ap\x00\x00\x00\x00V\xf5|" +
-       "\xa0\x00\x00\x00\x00W\xe5Cp\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00" +
-       "\x00d4\x00\x00\x00\x00bp\x00\x04\x00\x00~\x90\x01\b\x00\x00p\x80\x00\fLMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xceG|\xea\x13\x03\x00\x00\x13\x03\x00\x00\n\x00\x1c\x00Asia/AmmanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00F\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xb6\xa3\xd6\xd0\x00\x00\x00\x00\x06ry\xe0\x00\x00\x00\x00\a\f\xabP\x00\x00\x00\x00\b" +
-       "$7`\x00\x00\x00\x00\b\xed\xde\xd0\x00\x00\x00\x00\n\x05j\xe0\x00\x00\x00\x00\n\xcf\x12P\x00\x00\x00\x00\v\xe7\xef\xe0\x00\x00\x00\x00\f\xdau\xd0\x00\x00\x00\x00\r\xc9#`\x00\x00\x00\x00\x0e\x92\xca\xd0\x00" +
-       "\x00\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10r\xac\xd0\x00\x00\x00\x00\x1c\xad\xd5`\x00\x00\x00\x00\x1d\x9f\t\xd0\x00\x00\x00\x00\x1e\x92\xfd`\x00\x00\x00\x00\x1f\x82\xe0P\x00\x00\x00\x00 r\xdf`\x00\x00\x00\x00!" +
-       "b\xc2P\x00\x00\x00\x00\"R\xc1`\x00\x00\x00\x00#K\xde\xd0\x00\x00\x00\x00$d\xbc`\x00\x00\x00\x00%+\xc0\xd0\x00\x00\x00\x00&7o`\x00\x00\x00\x00'\v\xa2\xd0\x00\x00\x00\x00(\vs\xe0\x00" +
-       "\x00\x00\x00(\xe2JP\x00\x00\x00\x00)\xe4\xbe`\x00\x00\x00\x00*\xcbf\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\xabH\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00.x\xb5\xd0\x00\x00\x00\x00/" +
-       "\x84d`\x00\x00\x00\x000X\xa5\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00" +
-       "\x00\x00\x007z\x93`\x00\x00\x00\x007\xea\xa2\xe0\x00\x00\x00\x008\xe2|\xe0\x00\x00\x00\x009ӿ`\x00\x00\x00\x00:\xc2^\xe0\x00\x00\x00\x00;\xb3\xa1`\x00\x00\x00\x00<\xa3\x92`\x00\x00\x00\x00=" +
-       "\x93\x83`\x00\x00\x00\x00>\x83t`\x00\x00\x00\x00?\x98O`\x00\x00\x00\x00@cV`\x00\x00\x00\x00An\xf6\xe0\x00\x00\x00\x00BLr\xe0\x00\x00\x00\x00C<c\xe0\x00\x00\x00\x00D,T\xe0\x00" +
-       "\x00\x00\x00EA/\xe0\x00\x00\x00\x00F\f6\xe0\x00\x00\x00\x00G!\x11\xe0\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00I\n.`\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xea\x10`\x00\x00\x00\x00K" +
-       "\xab\xdc\xe0\x00\x00\x00\x00L\xc9\xf2`\x00\x00\x00\x00M\x94\xf9`\x00\x00\x00\x00N\xa9\xd4`\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00R\xb3^P\x00\x00\x00\x00S4\x9f`\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x00\x00!\xb0\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.4/24,M10.5.5" +
-       "/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa7f^]@\x01\x00\x00@\x01\x00\x00\f\x00\x1c\x00Asia/KuchingUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x05\x00\x00\x00\x18\xff\xff\xff\xff\xad\x8a\x06\x90\xff\xff\xff\xff" +
-       "\xbagG\x88\xff\xff\xff\xff\xbf{'\x80\xff\xff\xff\xff\xbf\xf3\x1bP\xff\xff\xff\xff\xc1]\xac\x80\xff\xff\xff\xff\xc1ՠP\xff\xff\xff\xff\xc3>\xe0\x00\xff\xff\xff\xffö\xd3\xd0\xff\xff\xff\xff\xc5 \x13\x80" +
-       "\xff\xff\xff\xffŘ\aP\xff\xff\xff\xff\xc7\x01G\x00\xff\xff\xff\xff\xc7y:\xd0\xff\xff\xff\xff\xc8\xe3\xcc\x00\xff\xff\xff\xff\xc9[\xbf\xd0\xff\xff\xff\xff\xca\xc4\xff\x80\xff\xff\xff\xff\xcb<\xf3P\xff\xff\xff\xff" +
-       "ˑX\x00\xff\xff\xff\xff\xd2Hm\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x00\x00gp\x00\x00\x00\x00ix\x00\x04\x00\x00u0\x01\n\x00\x00p\x80\x00\x10\x00\x00~\x90\x00\x14" +
-       "LMT\x00+0730\x00+0820\x00+08\x00+09\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\r" +
-       "\x00\x1c\x00Asia/Tel_AvivUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00b\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff\xc8Y\xb2\xe0\xff\xff\xff\xff\xcc\xe5\xc1P\xff\xff\xff\xffͬ\xfe\x00\xff" +
-       "\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xc9p\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4k\xe0\xd0\xff\xff\xff\xff\xd7" +
-       "Z\x14`\xff\xff\xff\xff\xd7\xdf\x1f\xc0\xff\xff\xff\xff\xd8/\xb5p\xff\xff\xff\xff\xd9\x1eF\xe0\xff\xff\xff\xff\xda\x10\xe8\xf0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ \xe0\xff" +
-       "\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}\x00\xff\xff\xff\xff\xe2\xbeJ`\xff\xff\xff\xff\xe364\xd0\xff\xff\xff\xff\xe4" +
-       "\x9c\xf7\x00\xff\xff\xff\xff\xe5\x16\x16\xd0\xff\xff\xff\xff\xe6t\xd3\xe0\xff\xff\xff\xff\xe7\x11Ҁ\xff\xff\xff\xff\xe8'\xff\x00\xff\xff\xff\xff\xe8\xe8O\xd0\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00" +
-       "\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe8\xaa\xe0\x00\x00\x00\x00\x14 \t\xe0\x00\x00\x00\x00\x1a\xf9t\xe0\x00\x00\x00\x00\x1b\x8d\x1c\xe0\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1d" +
-       "\x89\xf1\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00" +
-       "\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+" +
-       "\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x001H\x96\xe0\x00\x00\x00\x002<nP\x00" +
-       "\x00\x00\x0031\xb3`\x00\x00\x00\x004\x1a\xfe\xd0\x00\x00\x00\x005\x11\x95`\x00\x00\x00\x005\xf1\xa6P\x00\x00\x00\x007\x04\b\x80\x00\x00\x00\x007\xcf\x01p\x00\x00\x00\x008\xf6_\x80\x00\x00\x00\x009" +
-       "\xdc\xf9\xe0\x00\x00\x00\x00:\xd0\xedp\x00\x00\x00\x00;\xae[`\x00\x00\x00\x00<\xa3\xa0p\x00\x00\x00\x00=\xa0\xb2`\x00\x00\x00\x00>\x83\x82p\x00\x00\x00\x00?|\x9f\xe0\x00\x00\x00\x00@s6p\x00" +
-       "\x00\x00\x00AP\xa4`\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00CHOp\x00\x00\x00\x00D,q\x00\x00\x00\x00\x00E\x1e\xf6\xf0\x00\x00\x00\x00F\fS\x00\x00\x00\x00\x00F\xecc\xf0\x00\x00\x00\x00G" +
-       "\xec5\x00\x00\x00\x00\x00H\xe7\xf5p\x00\x00\x00\x00I\xcc\x17\x00\x00\x00\x00\x00J\xbe\x9c\xf0\x00\x00\x00\x00K\xab\xf9\x00\x00\x00\x00\x00L\x8c\t\xf0\x00\x00\x00\x00M\x95\x15\x80\x00\x00\x00\x00N\x87\x9bp\x00" +
-       "\x00\x00\x00Ot\xf7\x80\x00\x00\x00\x00P^B\xf0\x00\x00\x00\x00QTـ\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\f\x00\x008@\x01\x10LMT\x00JMT\x00IDT\x00IST\x00IDDT\x00\nIST-2ID" +
-       "T,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\n\x00\x1c\x00Asia/Seoul" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x06\x00" +
-       "\x00\x00\x10\xff\xff\xff\xff\x8b\xd7\xf0x\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2C'\xf0\xff\xff\xff\xff\xd7e\x8fp\xff\xff\xff\xff\xd7\xee\x9d`\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd-\xe0\xff" +
-       "\xff\xff\xff\xda\u05ca\xf0\xff\xff\xff\xffۭ\x0f\xe0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xf1\xe0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe4k\xb7\xf8\xff\xff\xff\xff\xe5\x13\x18h\xff\xff\xff\xff\xe6" +
-       "b\x03x\xff\xff\xff\xff\xe7\x11L\xe8\xff\xff\xff\xff\xe8/px\xff\xff\xff\xff\xe8\xe7\xf4h\xff\xff\xff\xff\xea\x0fRx\xff\xff\xff\xff\xea\xc7\xd6h\xff\xff\xff\xff\xeb\xef4x\xff\xff\xff\xff째h\xff" +
-       "\xff\xff\xff\xed\xcf\x16x\xff\xff\xff\xff\ue1dah\xff\xff\xff\xff\xf05qx\x00\x00\x00\x00 \xa3`\x90\x00\x00\x00\x00!ng\x90\x00\x00\x00\x00\"\x83B\x90\x00\x00\x00\x00#NI\x90\x01\x02\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x04\x03\x04\x03\x04\x00\x00w\b\x00\x00\x00\x00w\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x01\f\x00\x00~\x90\x00\x04\x00\x00\x85\x98\x01\f" +
-       "LMT\x00KST\x00JST\x00KDT\x00\nKST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?\xa7^\xfah\x02\x00\x00h\x02\x00\x00\v\x00\x1c\x00Asia/At" +
-       "yrauUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00" +
-       "\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xaa\x19\x93P\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19" +
-       "\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00" +
-       "\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'" +
-       "\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00" +
-       "\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005" +
-       "\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00" +
-       "\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02" +
-       "\x04\x02\x04\x02\x04\x02\x04\x02\x05\x06\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x02\x00\x000\xb0\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x00\b\x00\x00T`\x00" +
-       "\f\x00\x00T`\x01\f\x00\x00FP\x01\b\x00\x008@\x00\x10LMT\x00+03\x00+05\x00+06\x00+04\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x8a\xc1\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x1c\x00Asia/PyongyangUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x8b\xd7\xf1\x9c\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2/ap\x00" +
-       "\x00\x00\x00U\xce\x02p\x00\x00\x00\x00Z\xecup\x01\x02\x03\x01\x03\x00\x00u\xe4\x00\x00\x00\x00w\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x00\x04LMT\x00KST\x00JST\x00\nKST" +
-       "-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xba\xa3b\xc1R\x02\x00\x00R\x02\x00\x00\t\x00\x1c\x00Asia/HovdUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xfc\x94\x00\x00\x00\x00\x0f\v\xea" +
-       "\xa0\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbc>\x80\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c \x80\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00" +
-       "\x00\x1f|\x02\x80\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xe4\x80\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;ƀ\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xa8\x80\x00\x00\x00\x00&\v\xa7" +
-       "\x90\x00\x00\x00\x00'\x04\xc5\x00\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)Ԧ\x10\x00\x00\x00\x00*ĉ\x00\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4k\x00\x00\x00\x00" +
-       "\x00-\x94j\x10\x00\x00\x00\x00.\x84M\x00\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d/\x00\x00\x00\x00\x001]h\x90\x00\x00\x00\x002MK\x80\x00\x00\x00\x003=J\x90\x00\x00\x00\x004--" +
-       "\x80\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x006\r\x0f\x80\x00\x00\x00\x00:\xe9\xc1\xb0\x00\x00\x00\x00;\xb4\xba\xa0\x00\x00\x00\x00<\xa4\xb9\xb0\x00\x00\x00\x00=\x94\x9c\xa0\x00\x00\x00\x00>\x84\x9b\xb0\x00\x00\x00" +
-       "\x00?t~\xa0\x00\x00\x00\x00@d}\xb0\x00\x00\x00\x00AT`\xa0\x00\x00\x00\x00BD_\xb0\x00\x00\x00\x00C4B\xa0\x00\x00\x00\x00D$A\xb0\x00\x00\x00\x00E\x1d_ \x00\x00\x00\x00U\x15\xa8" +
-       "\xb0\x00\x00\x00\x00V\x05o\x80\x00\x00\x00\x00V\xf5\x8a\xb0\x00\x00\x00\x00W\xe5Q\x80\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00U\xec\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\fLMT\x00+06\x00+08\x00+07\x00\n<+07" +
-       ">-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x06\r\xed\xbd\x04\x00\x00\xbd\x04\x00\x00\v\x00\x1c\x00Asia/HebronUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\x19\xff\xff\xff\xff" +
-       "\xc8Y\xb2\xe0\xff\xff\xff\xff\xcc\xe5\xc1P\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xc9p" +
-       "\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4k\xe0\xd0\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff" +
-       "\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap" +
-       "\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff" +
-       "\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe8\xaa\xe0\x00\x00\x00\x00\x14 \t\xe0" +
-       "\x00\x00\x00\x00\x1a\xf9t\xe0\x00\x00\x00\x00\x1b\x8d\x1c\xe0\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1d\x89\xf1\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00" +
-       "!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0" +
-       "\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00" +
-       "/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`" +
-       "\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00" +
-       "<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0" +
-       "\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xbb\x06P\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00" +
-       "J\xa0<`\x00\x00\x00\x00K\xab\xdc\xe0\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00N\\\v\xe0\x00\x00\x00\x00N\x84\xdcP\x00\x00\x00\x00Ot\xdb`" +
-       "\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00" +
-       "V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP" +
-       "\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x00\x00 \xe7\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2" +
-       "EEST,M3.4.4/48,M10.4.4/49\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia" +
-       "/KuwaitUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*0\x00\x04LMT\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x1c\x00Asia/TomskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00" +
+       "\x1c \x00\f\x00\x008@\x01\x10LMT\x00JMT\x00IDT\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x1c\x00Asia/TashkentUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x83\t\xff\xff\xff\xff\xb5\xa3\xef" +
+       "0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00" +
+       "\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r" +
+       "\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xe4\xedP\x01\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x00\x00@\xf7\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLMT\x00+05\x00+" +
+       "07\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/KuwaitUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b" +
+       "\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*0\x00\x04LMT\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RB\x1d\xc6\x1b\x85\x00\x00\x00" +
+       "\x85\x00\x00\x00\v\x00\x1c\x00Asia/UrumqiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xb0\xfe\xbad\x01\x00\x00R\x1c\x00\x00\x00\x00T`\x00\x04LMT\x00+06\x00\n<+06>-6\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Re\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00\x1c\x00Asia/AshkhabadUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x8dD\xff\xff\xff\xff\xb5" +
+       "\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xbf0\x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00" +
+       "\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"" +
+       "L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00" +
+       "\x00\x00\x00)x\xa3`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x006\xbc\x00\x00\x00\x008@\x00\x04\x00\x00T`\x01\b\x00\x00FP\x00\f\x00\x00FP" +
+       "\x01\fLMT\x00+04\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf0\x9cf>\xd7\x02\x00\x00\xd7\x02\x00\x00\x0e\x00\x1c\x00Asi" +
+       "a/KamchatkaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa7R\x96\xc4\xff\xff\xff\xff\xb5\xa3\x9a\xd0\x00\x00\x00\x00\x15')@\x00\x00\x00\x00\x16\x18]\xb0\x00\x00\x00\x00\x17\b\\\xc0\x00\x00\x00\x00\x17\xf9" +
+       "\x910\x00\x00\x00\x00\x18\xe9\x90@\x00\x00\x00\x00\x19\xdaİ\x00\x00\x00\x00\x1a\xcc\x15@\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac\x13`\x00\x00\x00\x00\x1d\x9c\x04`\x00\x00\x00\x00\x1e\x8b\xf5`\x00\x00" +
+       "\x00\x00\x1f{\xe6`\x00\x00\x00\x00 k\xd7`\x00\x00\x00\x00![\xc8`\x00\x00\x00\x00\"K\xb9`\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\x9b`\x00\x00\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v" +
+       "}`\x00\x00\x00\x00'\x04\xa8\xe0\x00\x00\x00\x00'\xf4\x99\xe0\x00\x00\x00\x00(\xe4\x98\xf0\x00\x00\x00\x00)x@\xf0\x00\x00\x00\x00)\xd4{\xe0\x00\x00\x00\x00*\xc4l\xe0\x00\x00\x00\x00+\xb4]\xe0\x00\x00" +
+       "\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94?\xe0\x00\x00\x00\x00.\x840\xe0\x00\x00\x00\x00/t!\xe0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]>`\x00\x00\x00\x002r\x19`\x00\x00\x00\x003=" +
+       " `\x00\x00\x00\x004Q\xfb`\x00\x00\x00\x005\x1d\x02`\x00\x00\x00\x0061\xdd`\x00\x00\x00\x006\xfc\xe4`\x00\x00\x00\x008\x1a\xf9\xe0\x00\x00\x00\x008\xdc\xc6`\x00\x00\x00\x009\xfa\xdb\xe0\x00\x00" +
+       "\x00\x00:\xbc\xa8`\x00\x00\x00\x00;ڽ\xe0\x00\x00\x00\x00<\xa5\xc4\xe0\x00\x00\x00\x00=\xba\x9f\xe0\x00\x00\x00\x00>\x85\xa6\xe0\x00\x00\x00\x00?\x9a\x81\xe0\x00\x00\x00\x00@e\x88\xe0\x00\x00\x00\x00A\x83" +
+       "\x9e`\x00\x00\x00\x00BEj\xe0\x00\x00\x00\x00Cc\x80`\x00\x00\x00\x00D%L\xe0\x00\x00\x00\x00ECb`\x00\x00\x00\x00F\x05.\xe0\x00\x00\x00\x00G#D`\x00\x00\x00\x00G\xeeK`\x00\x00" +
+       "\x00\x00I\x03&`\x00\x00\x00\x00I\xce-`\x00\x00\x00\x00J\xe3\b`\x00\x00\x00\x00K\xae\x0f`\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x00\x94\xbc\x00\x00\x00\x00\x9a\xb0" +
+       "\x00\x04\x00\x00\xb6\xd0\x01\b\x00\x00\xa8\xc0\x00\f\x00\x00\xa8\xc0\x01\fLMT\x00+11\x00+13\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\x87\xbd\xedL\xf1\x02\x00\x00\xf1\x02\x00\x00\f\x00\x1c\x00Asia/BarnaulUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xe5N\xd9\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xd5}\xfc\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16" +
        "\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00" +
        "\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$" +
        "+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00" +
-       "\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY0\x00\x00\x00\x001" +
-       "]\x84\xb0\x00\x00\x00\x002r_\xb0\x00\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00\x008\x1b@0\x00" +
-       "\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\v0\x00\x00\x00\x00<\xce\xe9\xb0\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>" +
+       "\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x00/\xc7L\x80\x00\x00\x00\x000" +
+       "dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0\x00" +
+       "\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>" +
        "\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0\x00" +
        "\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00L" +
-       "\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00\x00\x00WI\xf8\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00O\xa7\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00" +
-       "bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQǯ\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x1c\x00A" +
-       "sia/ManilaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\n\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x14\xe1\xdc\x10\xff\xff\xff\xff{\x1f?\x90\xff\xff\xff\xff\xc1\x9c\xf4\x80\xff\xff\xff\xff\xc2\x160p\xff\xff\xff\xff\xcb\xf2\xe7\x00\xff\xff\xff\xffЩ%" +
-       "p\xff\xff\xff\xff\xe2l9\x00\xff\xff\xff\xff\xe2բ\xf0\x00\x00\x00\x00\x0fuF\x80\x00\x00\x00\x00\x10fz\xf0\x01\x03\x02\x03\x04\x03\x02\x03\x02\x03\xff\xff\x1f\xf0\x00\x00\x00\x00qp\x00\x00\x00\x00~\x90\x01" +
-       "\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\fLMT\x00PDT\x00PST\x00JST\x00\nPST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02" +
-       "\x00\x00\n\x00\x1c\x00Asia/ChitaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00\x00\x00V\xf6\xea@\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x04" +
+       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00N\x84\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00" +
+       "bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11\x00\x1c\x00A" +
+       "sia/NovokuznetskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\xf9\xa0\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18\x87\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00" +
-       "\x00\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e" +
-       "\x8c\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xb6\x90\x00" +
-       "\x00\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00)Ԧ\x10\x00\x00\x00\x00*ė\x10\x00\x00\x00\x00+" +
-       "\xb4\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10\x00\x00\x00\x001]h\x90\x00\x00\x00\x002rC\x90\x00" +
-       "\x00\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x0062\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x008\x1b$\x10\x00\x00\x00\x008\xdc\xf0\x90\x00\x00\x00\x009" +
-       "\xfb\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10\x00\x00\x00\x00?\x9a\xac\x10\x00\x00\x00\x00@e\xb3\x10\x00" +
-       "\x00\x00\x00A\x83Ȑ\x00\x00\x00\x00BE\x95\x10\x00\x00\x00\x00Cc\xaa\x90\x00\x00\x00\x00D%w\x10\x00\x00\x00\x00EC\x8c\x90\x00\x00\x00\x00F\x05Y\x10\x00\x00\x00\x00G#n\x90\x00\x00\x00\x00G" +
-       "\xeeu\x90\x00\x00\x00\x00I\x03P\x90\x00\x00\x00\x00I\xceW\x90\x00\x00\x00\x00J\xe32\x90\x00\x00\x00\x00K\xae9\x90\x00\x00\x00\x00L\xccO\x10\x00\x00\x00\x00M\x8e\x1b\x90\x00\x00\x00\x00TK\xc9\x00\x00" +
-       "\x00\x00\x00V\xf6\xce \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x01\x03\x00\x00j`\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x8c\xa0\x00\bLMT\x00+08\x00+10" +
-       "\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\r\x00\x1c\x00Asia/KatmanduUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x10" +
-       "\xff\xff\xff\xff\xa1\xf2}\x84\x00\x00\x00\x00\x1e\x180\xa8\x01\x02\x00\x00O\xfc\x00\x00\x00\x00MX\x00\x04\x00\x00P\xdc\x00\nLMT\x00+0530\x00+0545\x00\n<+0545>" +
-       "-5:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xac\xf7\xf4\xc0\xab\x04\x00\x00\xab\x04\x00\x00\t\x00\x1c\x00Asia/GazaUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00q\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\xb0\xff\xff\xff\xff" +
-       "\xc8Y\xb2\xe0\xff\xff\xff\xff\xcc\xe5\xc1P\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xc9p" +
-       "\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4k\xe0\xd0\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff" +
-       "\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap" +
-       "\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff" +
-       "\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe8\xaa\xe0\x00\x00\x00\x00\x14 \t\xe0" +
-       "\x00\x00\x00\x00\x1a\xf9t\xe0\x00\x00\x00\x00\x1b\x8d\x1c\xe0\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1d\x89\xf1\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00" +
-       "!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0" +
-       "\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00" +
-       "/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`" +
-       "\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00" +
-       "<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0" +
-       "\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00" +
-       "J\xa0<`\x00\x00\x00\x00K\xad.\x9c\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`" +
-       "\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00" +
-       "Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 P\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c" +
-       " \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10" +
-       ".4.4/49\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQw\rD\an\x01\x00\x00n\x01\x00\x00\x0e\x00\x1c\x00Asia/SamarkandUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa" +
-       "\x19\x857\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00" +
-       "\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!" +
-       "\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00" +
-       "\x00\x00\x00(\xe4\xedP\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00>\xc9\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00" +
-       "\fLMT\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00\x1c\x00Asia" +
-       "/TaipeiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x18 \xc0\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00" +
+       "\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e" +
+       "\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00" +
+       "\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00\x00\x00\x00*ij0\x00\x00\x00\x00+" +
+       "\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY0\x00\x00\x00\x001]\x84\xb0\x00\x00\x00\x002r_\xb0\x00" +
+       "\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00\x008\x1b@0\x00\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009" +
+       "\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\v0\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xed0\x00\x00\x00\x00?\x9a\xc80\x00\x00\x00\x00@e\xcf0\x00" +
+       "\x00\x00\x00A\x83\xe4\xb0\x00\x00\x00\x00BE\xb10\x00\x00\x00\x00Ccư\x00\x00\x00\x00D%\x930\x00\x00\x00\x00EC\xa8\xb0\x00\x00\x00\x00F\x05u0\x00\x00\x00\x00G#\x8a\xb0\x00\x00\x00\x00G" +
+       "\ue470\x00\x00\x00\x00I\x03l\xb0\x00\x00\x00\x00I\xces\xb0\x00\x00\x00\x00J\xe3N\xb0\x00\x00\x00\x00K\xaeU\xb0\x00\x00\x00\x00L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x00Q\xc0\x00" +
+       "\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R0]*\x1bj\x02\x00\x00j\x02\x00\x00\f\x00\x1c\x00Asia/BishkekUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19~\x10\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00" +
+       "\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c" +
+       "\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00" +
+       "\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xbe\xa3\xc0\x00\x00\x00\x00)\xe770\x00\x00\x00\x00*" +
+       "ĥ \x00\x00\x00\x00+\xc7\x190\x00\x00\x00\x00,\xa4\x87 \x00\x00\x00\x00-\xa6\xfb0\x00\x00\x00\x00.\x84i \x00\x00\x00\x00/\x86\xdd0\x00\x00\x00\x000dK \x00\x00\x00\x001f\xbf0\x00" +
+       "\x00\x00\x002Mg\xa0\x00\x00\x00\x003=\x89\xd8\x00\x00\x00\x004RV\xc8\x00\x00\x00\x005\x1dk\xd8\x00\x00\x00\x00628\xc8\x00\x00\x00\x006\xfdM\xd8\x00\x00\x00\x008\x1bUH\x00\x00\x00\x008" +
+       "\xdd/\xd8\x00\x00\x00\x009\xfb7H\x00\x00\x00\x00:\xbd\x11\xd8\x00\x00\x00\x00;\xdb\x19H\x00\x00\x00\x00<\xa6.X\x00\x00\x00\x00=\xba\xfbH\x00\x00\x00\x00>\x86\x10X\x00\x00\x00\x00?\x9a\xddH\x00" +
+       "\x00\x00\x00@e\xf2X\x00\x00\x00\x00A\x83\xf9\xc8\x00\x00\x00\x00BE\xd4X\x00\x00\x00\x00B\xfb\x92 \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04" +
+       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x03\x00\x00E\xf0\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLMT\x00+05" +
+       "\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa7f^]@\x01\x00\x00@\x01\x00\x00\f\x00\x1c\x00Asia/Kuching" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x05\x00" +
+       "\x00\x00\x18\xff\xff\xff\xff\xad\x8a\x06\x90\xff\xff\xff\xff\xbagG\x88\xff\xff\xff\xff\xbf{'\x80\xff\xff\xff\xff\xbf\xf3\x1bP\xff\xff\xff\xff\xc1]\xac\x80\xff\xff\xff\xff\xc1ՠP\xff\xff\xff\xff\xc3>\xe0\x00\xff" +
+       "\xff\xff\xffö\xd3\xd0\xff\xff\xff\xff\xc5 \x13\x80\xff\xff\xff\xffŘ\aP\xff\xff\xff\xff\xc7\x01G\x00\xff\xff\xff\xff\xc7y:\xd0\xff\xff\xff\xff\xc8\xe3\xcc\x00\xff\xff\xff\xff\xc9[\xbf\xd0\xff\xff\xff\xff\xca" +
+       "\xc4\xff\x80\xff\xff\xff\xff\xcb<\xf3P\xff\xff\xff\xffˑX\x00\xff\xff\xff\xff\xd2Hm\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x00\x00gp\x00\x00\x00\x00ix\x00\x04\x00\x00u" +
+       "0\x01\n\x00\x00p\x80\x00\x10\x00\x00~\x90\x00\x14LMT\x00+0730\x00+0820\x00+08\x00+09\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\v\x00\x1c\x00Asia/SaigonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x88\x8cC\x80\xff\xff\xff\xff\x91\xa3+\n\xff\xff\xff\xff\xcd5\xe6\x80\xff\xff\xff\xff" +
+       "\xd1Y\xcep\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xff\xd52\xbb\x10\xff\xff\xff\xff\xe4\xb6\xe4\x80\xff\xff\xff\xff\xed/\x98\x00\x00\x00\x00\x00\n=\xc7\x00\x01\x02\x03\x04\x02\x03\x02\x03\x02\x00\x00d\x00\x00\x00\x00" +
+       "\x00c\xf6\x00\x04\x00\x00bp\x00\t\x00\x00p\x80\x00\r\x00\x00~\x90\x00\x11LMT\x00PLMT\x00+07\x00+08\x00+09\x00\n<+07>-7\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e\x00\x1c\x00Asia/SingaporeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00 \xff\xff\xff\xff~6S\xa3\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff" +
+       "\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xffˑ_\b\xff\xff\xff\xff\xd2Hm\xf0\x00\x00\x00\x00\x16\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00a]\x00\x00\x00\x00" +
+       "a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00ix\x00\x12\x00\x00~\x90\x00\x18\x00\x00p\x80\x00\x1cLMT\x00SMT\x00+07\x00+0720\x00+0" +
+       "730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R)p\x1cX\xf1\x02\x00\x00\xf1\x02\x00\x00\x10\x00\x1c\x00Asia/Novo" +
+       "sibirskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00)\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xfft\xce\xf0\x18\xff\xff\xff\xff\xc3UI\x80\xff\xff\xff\xff\xd2TY\x80\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff" +
-       "\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9\xe7\x99\xf0\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xdb\xc8\xcdp\xff\xff\xff\xff\xdc\xe0" +
-       "Y\x80\xff\xff\xff\xffݪ\x00\xf0\xff\xff\xff\xff\xders\x00\xff\xff\xff\xffߵdp\xff\xff\xff\xff\xe0|\x85\x00\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2]\xb8\x80\xff\xff\xff\xff\xe3w\xcbp\xff\xff" +
-       "\xff\xff\xe4>\xec\x00\xff\xff\xff\xff\xe50 p\xff\xff\xff\xff\xe6!q\x00\xff\xff\xff\xff\xe7\x12\xa5p\xff\xff\xff\xff\xe8\x02\xa4\x80\xff\xff\xff\xff\xe8\xf3\xd8\xf0\xff\xff\xff\xff\xe9\xe3\xd8\x00\xff\xff\xff\xff\xea\xd5" +
-       "\fp\xff\xff\xff\xff\xeb\xc5\v\x80\xff\xff\xff\xff\xec\xb6?\xf0\xff\xff\xff\xff\xed\xf7\xfc\x00\xff\xff\xff\xff\xee\x98\xc4\xf0\xff\xff\xff\xff\xef\xd9/\x80\xff\xff\xff\xff\xf0y\xf8p\x00\x00\x00\x00\a\xfcV\x00\x00\x00" +
-       "\x00\x00\b\xed\x8ap\x00\x00\x00\x00\t݉\x80\x00\x00\x00\x00\nν\xf0\x00\x00\x00\x00\x11ۡ\x80\x00\x00\x00\x00\x12T\xddp\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03" +
-       "\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x00\x00q\xe8\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x01\fLMT\x00CST\x00JST\x00CDT\x00\n" +
-       "CST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x1c\x00Asia/TashkentUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x83\t" +
-       "\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00" +
-       "\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0" +
-       "\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00" +
-       "(\xe4\xedP\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x00\x00@\xf7\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLM" +
-       "T\x00+05\x00+07\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\xea\x18\xd4\xf8\x02\x00\x00\xf8\x02\x00\x00\x12\x00\x1c\x00Asia/Ye" +
-       "katerinburgUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\x9b_\t'\xff\xff\xff\xff\xa1\x12\xb1\xff\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b" +
-       "\xbf0\x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00" +
-       "\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b" +
-       "\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00" +
-       "\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r" +
-       "{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00" +
-       "\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e" +
-       "\xebP\x00\x00\x00\x00A\x84\x00\xd0\x00\x00\x00\x00BE\xcdP\x00\x00\x00\x00Cc\xe2\xd0\x00\x00\x00\x00D%\xafP\x00\x00\x00\x00EC\xc4\xd0\x00\x00\x00\x00F\x05\x91P\x00\x00\x00\x00G#\xa6\xd0\x00\x00" +
-       "\x00\x00G\xee\xad\xd0\x00\x00\x00\x00I\x03\x88\xd0\x00\x00\x00\x00IΏ\xd0\x00\x00\x00\x00J\xe3j\xd0\x00\x00\x00\x00K\xaeq\xd0\x00\x00\x00\x00L̇P\x00\x00\x00\x00M\x8eS\xd0\x00\x00\x00\x00TL" +
-       "\x01@\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x06\x04\x00\x008\xd9\x00\x00\x00\x004\xc1\x00\x04\x00\x008@\x00\b\x00\x00T`\x01\f\x00\x00FP\x00\x10\x00\x00FP\x01\x10\x00\x00T`\x00\fLMT\x00PMT\x00+0" +
-       "4\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacauU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x05\x00\x00" +
-       "\x00\x14\xff\xff\xff\xff\x85i[\x8e\xff\xff\xff\xff\xcbGu\xf0\xff\xff\xff\xff\xcb\xf2\xca\xe0\xff\xff\xff\xff\xcc\xfb\xbaP\xff\xff\xff\xff\xcd\xd3\xfe`\xff\xff\xff\xffΝ\xa5\xd0\xff\xff\xff\xff\xd2azp\xff\xff" +
-       "\xff\xff\xd3x\xf8p\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5K\xabp\xff\xff\xff\xff\xd6tL\xf0\xff\xff\xff\xff\xd7?S\xf0\xff\xff\xff\xff\xd8/D\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xda\r" +
-       "\xd5p\xff\xff\xff\xff\xda\xd8\xdcp\xff\xff\xff\xff\xdb\xed\xb7p\xff\xff\xff\xffܸ\xbep\xff\xff\xff\xff\xdd\xce\xea\xf0\xff\xff\xff\xffޡ\xda\xf0\xff\xff\xff\xff߶\xb5\xf0\xff\xff\xff\xff\xe0\x81\xbc\xf0\xff\xff" +
-       "\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe3vy\xf0\xff\xff\xff\xff\xe4/\v\xf0\xff\xff\xff\xff\xe5_\x96p\xff\xff\xff\xff\xe6\x0e\xed\xf0\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8" +
-       "I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff" +
-       "\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G" +
-       "\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15S\x18\xff\xff\xff\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf55\x18\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff" +
-       "\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M" +
-       "\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00" +
-       "\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00\x00\x00\x00\x12ol\xa8\x01\x03\x02\x03\x02\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
-       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00jr\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00" +
-       "\x00~\x90\x00\f\x00\x00~\x90\x01\x10LMT\x00CST\x00+10\x00+09\x00CDT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd5ΜGp\x02\x00\x00" +
-       "p\x02\x00\x00\x0e\x00\x1c\x00Asia/QyzylordaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x86\xa0\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00" +
-       "\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf" +
-       "\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00" +
-       "\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\x95P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xcf" +
-       "P\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00" +
-       "\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(" +
-       "\xd0\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00" +
-       "\x00@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x00\x00\x00\x00\\\x1bؠ\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x02\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x00\x00=`\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+05" +
-       "\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacaoUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff" +
-       "\xff\x85i[\x8e\xff\xff\xff\xff\xcbGu\xf0\xff\xff\xff\xff\xcb\xf2\xca\xe0\xff\xff\xff\xff\xcc\xfb\xbaP\xff\xff\xff\xff\xcd\xd3\xfe`\xff\xff\xff\xffΝ\xa5\xd0\xff\xff\xff\xff\xd2azp\xff\xff\xff\xff\xd3x\xf8" +
-       "p\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5K\xabp\xff\xff\xff\xff\xd6tL\xf0\xff\xff\xff\xff\xd7?S\xf0\xff\xff\xff\xff\xd8/D\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xda\r\xd5p\xff\xff\xff" +
-       "\xff\xda\xd8\xdcp\xff\xff\xff\xff\xdb\xed\xb7p\xff\xff\xff\xffܸ\xbep\xff\xff\xff\xff\xdd\xce\xea\xf0\xff\xff\xff\xffޡ\xda\xf0\xff\xff\xff\xff߶\xb5\xf0\xff\xff\xff\xff\xe0\x81\xbc\xf0\xff\xff\xff\xffᖗ" +
-       "\xf0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe3vy\xf0\xff\xff\xff\xff\xe4/\v\xf0\xff\xff\xff\xff\xe5_\x96p\xff\xff\xff\xff\xe6\x0e\xed\xf0\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff" +
-       "\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefw\xd1" +
-       "\xb8\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff" +
-       "\xff\xf7%~8\xff\xff\xff\xff\xf8\x15S\x18\xff\xff\xff\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf55\x18\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA" +
-       "\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00" +
-       "\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩" +
-       "8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00\x00\x00\x00\x12ol\xa8\x01\x03\x02\x03\x02\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00jr\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f" +
-       "\x00\x00~\x90\x01\x10LMT\x00CST\x00+10\x00+09\x00CDT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\n" +
-       "\x00\x1c\x00Asia/TokyoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffe¤p\xff\xff\xff\xff\xd7>\x02p\xff\xff\xff\xff\xd7\xedY\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd;\xf0\xff\xff\xff\xff" +
-       "\xdb\a\x00\xf0\xff\xff\xff\xffۭ\x1d\xf0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xff\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x83\x03\x00\x00\x00\x00\x8c\xa0\x01\x04\x00\x00~\x90\x00\bLMT\x00J" +
-       "DT\x00JST\x00\nJST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t\x00\x1c\x00Asia/BakuUT\t\x00\x03\xec," +
-       "\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff" +
-       "\xaa\x19\x95D\xff\xff\xff\xff\xe7\xda\fP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50" +
-       "\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00" +
-       "!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`" +
-       "\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x001]\xd9\x10\x00\x00\x00\x002r\xb4\x10\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x00" +
-       "5\x1d\x8f\x00\x00\x00\x00\x0062j\x00\x00\x00\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x009\xfbh\x80\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80" +
-       "\x00\x00\x00\x00<\xa6Q\x80\x00\x00\x00\x00=\xbb,\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80\x00\x00\x00\x00A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00" +
-       "Cd\r\x00\x00\x00\x00\x00D%ـ\x00\x00\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00G\xee\xd8\x00\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00" +
-       "\x00\x00\x00\x00J\xe3\x95\x00\x00\x00\x00\x00K\xae\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x00\x00\x00\x00N\xac\x93\x80\x00\x00\x00\x00On`\x00\x00\x00\x00\x00P\x8cu\x80\x00\x00\x00\x00" +
-       "QW|\x80\x00\x00\x00\x00RlW\x80\x00\x00\x00\x00S7^\x80\x00\x00\x00\x00TL9\x80\x00\x00\x00\x00U\x17@\x80\x00\x00\x00\x00V,\x1b\x80\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x04\x01\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00.\xbc\x00\x00\x00\x00*0" +
-       "\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x87" +
-       "\xbd\xedL\xf1\x02\x00\x00\xf1\x02\x00\x00\f\x00\x1c\x00Asia/BarnaulUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xd5}\xfc\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16\x18" +
-       "\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00\x00" +
-       "\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$+" +
-       "\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00\x00" +
-       "\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x00/\xc7L\x80\x00\x00\x00\x000d" +
-       "g@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0\x00\x00" +
-       "\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>\x85" +
-       "\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0\x00\x00" +
-       "\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00L\xcc" +
-       "y@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00\x00\x00V\xf6\xea@\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00N\x84\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00b" +
-       "p\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00\x1c\x00As" +
-       "ia/IstanbulUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x19\xff\xff\xff\xffV\xb6\xc8\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{" +
-       "\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff\xff\xab\xf9\x89\xe0\xff\xff" +
-       "\xff\xff\xac\xc31P\xff\xff\xff\xffȁ?\xe0\xff\xff\xff\xff\xc9\x01\x13P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\tP\xff\xff\xff\xffӢ" +
-       "9`\xff\xff\xff\xff\xd4C\x02P\xff\xff\xff\xff\xd5L\r\xe0\xff\xff\xff\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff\xff\xd9\xe9?\xd0\xff\xff" +
-       "\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff\xdb\xd2\\P\xff\xff\xff\xff\xdc\xd4\xd0`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06`\xff\xff\xff\xff\xf6\x1f" +
-       "8\xd0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a9\x9ap\x00\x00\x00\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00\x00\v\xb1\xfe\x80\x00\x00" +
-       "\x00\x00\f\xd9@p\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\xa6\xadp\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ\xe0\x00\x00\x00\x00\x1b\xe6" +
-       "\xd0\xf0\x00\x00\x00\x00\x1c\xc6\xef\xf0\x00\x00\x00\x00\x1d\x9b1p\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00" +
-       "\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4" +
-       "\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00" +
-       "\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1b" +
-       "xp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00" +
-       "\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05" +
-       "ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00" +
-       "\x00\x00M\x8fݐ\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe\x10\x00\x00\x00\x00TL" +
-       "G\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V>\x9e\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00*0\x00\x11\x00" +
-       "\x008@\x01\x15LMT\x00IMT\x00EEST\x00EET\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf9l\x03\x12\xf8\x02\x00" +
-       "\x00\xf8\x02\x00\x00\f\x00\x1c\x00Asia/IrkutskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xffV\xb6\x82?\xff\xff\xff\xff\xa2\x12\x0f\xbf\xff\xff\xff\xff\xb5\xa3\xd3\x10\x00\x00\x00\x00\x15'a\x80\x00\x00\x00\x00" +
-       "\x16\x18\x95\xf0\x00\x00\x00\x00\x17\b\x95\x00\x00\x00\x00\x00\x17\xf9\xc9p\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xfc\xf0\x00\x00\x00\x00\x1a\xccM\x80\x00\x00\x00\x00\x1b\xbcZ\xa0\x00\x00\x00\x00\x1c\xacK\xa0" +
-       "\x00\x00\x00\x00\x1d\x9c<\xa0\x00\x00\x00\x00\x1e\x8c-\xa0\x00\x00\x00\x00\x1f|\x1e\xa0\x00\x00\x00\x00 l\x0f\xa0\x00\x00\x00\x00!\\\x00\xa0\x00\x00\x00\x00\"K\xf1\xa0\x00\x00\x00\x00#;\xe2\xa0\x00\x00\x00\x00" +
-       "$+Ӡ\x00\x00\x00\x00%\x1bĠ\x00\x00\x00\x00&\v\xb5\xa0\x00\x00\x00\x00'\x04\xe1 \x00\x00\x00\x00'\xf4\xd2 \x00\x00\x00\x00(\xe4\xd10\x00\x00\x00\x00)xy0\x00\x00\x00\x00)Դ " +
-       "\x00\x00\x00\x00*ĥ \x00\x00\x00\x00+\xb4\x96 \x00\x00\x00\x00,\xa4\x87 \x00\x00\x00\x00-\x94x \x00\x00\x00\x00.\x84i \x00\x00\x00\x00/tZ \x00\x00\x00\x000dK \x00\x00\x00\x00" +
-       "1]v\xa0\x00\x00\x00\x002rQ\xa0\x00\x00\x00\x003=X\xa0\x00\x00\x00\x004R3\xa0\x00\x00\x00\x005\x1d:\xa0\x00\x00\x00\x0062\x15\xa0\x00\x00\x00\x006\xfd\x1c\xa0\x00\x00\x00\x008\x1b2 " +
-       "\x00\x00\x00\x008\xdc\xfe\xa0\x00\x00\x00\x009\xfb\x14 \x00\x00\x00\x00:\xbc\xe0\xa0\x00\x00\x00\x00;\xda\xf6 \x00\x00\x00\x00<\xa5\xfd \x00\x00\x00\x00=\xba\xd8 \x00\x00\x00\x00>\x85\xdf \x00\x00\x00\x00" +
-       "?\x9a\xba \x00\x00\x00\x00@e\xc1 \x00\x00\x00\x00A\x83֠\x00\x00\x00\x00BE\xa3 \x00\x00\x00\x00Cc\xb8\xa0\x00\x00\x00\x00D%\x85 \x00\x00\x00\x00EC\x9a\xa0\x00\x00\x00\x00F\x05g " +
-       "\x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\ue0e0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I\xcee\xa0\x00\x00\x00\x00J\xe3@\xa0\x00\x00\x00\x00K\xaeG\xa0\x00\x00\x00\x00L\xcc] \x00\x00\x00\x00" +
-       "M\x8e)\xa0\x00\x00\x00\x00TK\xd7\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x06\x04\x00\x00a\xc1\x00\x00\x00\x00a\xc1\x00\x04\x00\x00bp\x00\b\x00\x00~\x90\x01\f\x00\x00p\x80\x00\x10\x00\x00p\x80\x01\x10\x00\x00~\x90\x00\f" +
-       "LMT\x00IMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\n\x00\x1c\x00A" +
-       "sia/QatarUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa1\xf2\x9d0\x00\x00\x00\x00\x04\x8a\x92\xc0\x01\x02\x00\x000P\x00\x00\x00\x008@\x00\x04\x00\x00*0\x00\bLMT\x00+04\x00+03\x00" +
-       "\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x1c\x00Asia/BahrainUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa1\xf2" +
-       "\x9d0\x00\x00\x00\x00\x04\x8a\x92\xc0\x01\x02\x00\x000P\x00\x00\x00\x008@\x00\x04\x00\x00*0\x00\bLMT\x00+04\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x1c\x00Asia/YangonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
+       "\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\x19$\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00" +
+       "\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|" +
+       ",\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00" +
+       "\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00+\xfe" +
+       "N\x00\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\x94@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x000dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00" +
+       "\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb" +
+       "0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00" +
+       "\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0\x00\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee" +
+       "\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00" +
+       "\x00\x00W\x93\xcc\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
+       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00M\xbc\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n" +
+       "<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?\xa7^\xfah\x02\x00\x00h\x02\x00\x00\v\x00\x1c\x00Asia/AtyrauUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xaa\x19\x93P" +
+       "\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00" +
+       "\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0" +
+       "\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00" +
+       ")x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P" +
+       "\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x00" +
+       "6\xfdF\xd0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`" +
+       "\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\x06\x02\x04\x02\x04\x02" +
+       "\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x02\x00\x000\xb0\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x00\b\x00\x00T`\x00\f\x00\x00T`\x01\f\x00\x00FP\x01\b\x00\x00" +
+       "8@\x00\x10LMT\x00+03\x00+05\x00+06\x00+04\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x88έ\xe2\xbd\x04\x00\x00\xbd\x04\x00\x00\t" +
+       "\x00\x1c\x00Asia/GazaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\xb0\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xff\xcd" +
+       "\xac\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff" +
+       "\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee" +
+       "\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff" +
+       "\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b" +
+       "|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00" +
+       "\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00#" +
+       " ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00" +
+       "\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000" +
+       "\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00" +
+       "\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>" +
+       "\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00" +
+       "\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xa0<`\x00\x00\x00\x00K\xad.\x9c\x00\x00\x00\x00L" +
+       "a\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00" +
+       "\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z" +
+       "\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 P\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11" +
+       "LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.4.4/49\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9RΒ\x1a\x8c\xaa\x00\x00\x00\xaa\x00\x00\x00\t\x00\x1c\x00Asia/DiliUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
        "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffV\xb6\x89\xd1\xff\xff\xff\xff\xa1\xf2sQ\xff\xff\xff\xff\xcb\xf2\xfc\x18\xff" +
-       "\xff\xff\xffњg\xf0\x01\x02\x03\x02\x00\x00Z/\x00\x00\x00\x00Z/\x00\x04\x00\x00[h\x00\b\x00\x00~\x90\x00\x0eLMT\x00RMT\x00+0630\x00+09\x00\n<+0630" +
-       ">-6:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x02\x95-\xad\xc4\x02\x00\x00\xc4\x02\x00\x00\f\x00\x1c\x00Asia/YerevanUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x9aH" +
-       "\xff\xff\xff\xff\xe7\xda\fP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00" +
-       "\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0" +
-       "\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00" +
-       "(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p" +
-       "\x00\x00\x00\x000d\x91p\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x00" +
-       "8\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`" +
-       "\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x00\x00\x00\x00BE\xdb`\x00\x00\x00\x00Cc\xf0\xe0\x00\x00\x00\x00D%\xbd`\x00\x00\x00\x00EC\xd2\xe0\x00\x00\x00\x00F\x05\x9f`\x00\x00\x00\x00" +
-       "G#\xb4\xe0\x00\x00\x00\x00G\xee\xbb\xe0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΝ\xe0\x00\x00\x00\x00J\xe3x\xe0\x00\x00\x00\x00K\xae\u007f\xe0\x00\x00\x00\x00L̕`\x00\x00\x00\x00M\x8ea\xe0" +
-       "\x00\x00\x00\x00N\xacw`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00)\xb8\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+0" +
-       "4>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQS\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00\x1c\x00Asia/AlmatyUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19{\xdc\xff\xff\xff" +
-       "\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci" +
-       "\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00" +
-       "\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xe4\xed" +
-       "P\x00\x00\x00\x00)x\x95P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00+\xb4\xb2@\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\x94@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00" +
-       "\x00/tv@\x00\x00\x00\x000dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621" +
-       "\xc0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00" +
-       "\x00=\xba\xf4@\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04" +
-       "\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00H$\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLM" +
-       "T\x00+05\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQΒ\x1a\x8c\xaa\x00\x00\x00\xaa\x00\x00\x00\t\x00\x1c\x00Asia/Di" +
-       "liUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00" +
-       "\x03\x00\x00\x00\f\xff\xff\xff\xff\x92\xe6\x18\xc4\xff\xff\xff\xff˙2\xf0\x00\x00\x00\x00\v\xea0p\x00\x00\x00\x009Ù\x00\x01\x02\x01\x02\x00\x00u\xbc\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\bL" +
-       "MT\x00+08\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/Dacca" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x92\xe6\x18\xc4\xff\xff\xff\xff˙2\xf0\x00\x00\x00\x00\v\xea0p\x00" +
+       "\x00\x00\x009Ù\x00\x01\x02\x01\x02\x00\x00u\xbc\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\bLMT\x00+08\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02\x00\x00\n\x00\x1c\x00Asia/ChitaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\xf9\xa0\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00" +
+       "\x00\x16\x18\x87\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00\x00\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00\x1c\xac=" +
+       "\x90\x00\x00\x00\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ\x00\x00\x00" +
+       "\x00$+Ő\x00\x00\x00\x00%\x1b\xb6\x90\x00\x00\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00)Ԧ" +
+       "\x10\x00\x00\x00\x00*ė\x10\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10\x00\x00\x00" +
+       "\x001]h\x90\x00\x00\x00\x002rC\x90\x00\x00\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x0062\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x008\x1b$" +
+       "\x10\x00\x00\x00\x008\xdc\xf0\x90\x00\x00\x00\x009\xfb\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10\x00\x00\x00" +
+       "\x00?\x9a\xac\x10\x00\x00\x00\x00@e\xb3\x10\x00\x00\x00\x00A\x83Ȑ\x00\x00\x00\x00BE\x95\x10\x00\x00\x00\x00Cc\xaa\x90\x00\x00\x00\x00D%w\x10\x00\x00\x00\x00EC\x8c\x90\x00\x00\x00\x00F\x05Y" +
+       "\x10\x00\x00\x00\x00G#n\x90\x00\x00\x00\x00G\xeeu\x90\x00\x00\x00\x00I\x03P\x90\x00\x00\x00\x00I\xceW\x90\x00\x00\x00\x00J\xe32\x90\x00\x00\x00\x00K\xae9\x90\x00\x00\x00\x00L\xccO\x10\x00\x00\x00" +
+       "\x00M\x8e\x1b\x90\x00\x00\x00\x00TK\xc9\x00\x00\x00\x00\x00V\xf6\xce \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x01\x03\x00\x00j`\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x8c" +
+       "\xa0\x00\bLMT\x00+08\x00+10\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x0f\x00\x1c\x00As" +
+       "ia/Ulan_BatorUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xeeL\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xfc\xf0\x00\x00\x00\x00\x1a\xccM\x80\x00\x00\x00\x00" +
+       "\x1b\xbc0p\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xf3\x80\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"KՀ" +
+       "\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xb7\x80\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x99\x80\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xe4\x98\xf0\x00\x00\x00\x00" +
+       ")Ԙ\x00\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000d \xf0" +
+       "\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002M=p\x00\x00\x00\x003=<\x80\x00\x00\x00\x004-\x1fp\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\r\x01p\x00\x00\x00\x00:鳠\x00\x00\x00\x00" +
+       ";\xb4\xac\x90\x00\x00\x00\x00<\xa4\xab\xa0\x00\x00\x00\x00=\x94\x8e\x90\x00\x00\x00\x00>\x84\x8d\xa0\x00\x00\x00\x00?tp\x90\x00\x00\x00\x00@do\xa0\x00\x00\x00\x00ATR\x90\x00\x00\x00\x00BDQ\xa0" +
+       "\x00\x00\x00\x00C44\x90\x00\x00\x00\x00D$3\xa0\x00\x00\x00\x00E\x1dQ\x10\x00\x00\x00\x00U\x15\x9a\xa0\x00\x00\x00\x00V\x05ap\x00\x00\x00\x00V\xf5|\xa0\x00\x00\x00\x00W\xe5Cp\x01\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00d4\x00\x00\x00\x00bp\x00\x04\x00\x00" +
+       "~\x90\x01\b\x00\x00p\x80\x00\fLMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rw\rD\an\x01\x00\x00n\x01\x00" +
+       "\x00\x0e\x00\x1c\x00Asia/SamarkandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x857\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b" +
+       "\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00" +
+       "\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b" +
+       "\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xedP\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00" +
+       ">\xc9\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\fLMT\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x1c\x00Asia/NicosiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x001\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xa5w\x1e\xb8\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\n\xdd" +
+       "\x92\xd0\x00\x00\x00\x00\v\xfad\xe0\x00\x00\x00\x00\f\xbe\xc6P\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00\x00\x10uO\xd0\x00\x00\x00\x00\x11c\xfd`\x00\x00" +
+       "\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\x19\xe0\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3`\x00\x00\x00\x00\x17\xf3\x86P\x00\x00\x00\x00\x18\xe3" +
+       "\x85`\x00\x00\x00\x00\x19\xd3hP\x00\x00\x00\x00\x1a\xc3g`\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|H\xd0\x00\x00" +
+       "\x00\x00 lG\xe0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05" +
+       "\vP\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00" +
+       "\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1d" +
+       "r\xe0\x00\x00\x00\x0062x\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00" +
+       "\x00\x1fH\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x1c\x00Asia/AdenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*" +
+       "0\x00\x04LMT\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/Dhaka" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00" +
        "\x00\x00\x1c\xff\xff\xff\xffi\x86\x86\xbc\xff\xff\xff\xff\xcaۆ\xb0\xff\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xffݨҘ\x00\x00\x00\x00J;\xc4\x10\x00\x00\x00\x00K<ؐ\x01" +
        "\x02\x03\x02\x04\x05\x04\x00\x00T\xc4\x00\x00\x00\x00R\xd0\x00\x04\x00\x00[h\x00\b\x00\x00MX\x00\x0e\x00\x00T`\x00\x14\x00\x00bp\x01\x18LMT\x00HMT\x00+0630\x00+053" +
-       "0\x00+06\x00+07\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00Asia/Chongq" +
-       "ingUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00" +
-       "\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05" +
-       "\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff" +
-       "\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g" +
-       "\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCS" +
-       "T-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQw\x86\x8d^\x03\x03\x00\x00\x03\x03\x00\x00\r\x00\x1c\x00Asia/Ust-NeraUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\b\x00\x00\x00\x18\xff\xff\xff\xff\xa1\xdbݺ\xff\xff" +
-       "\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc" +
-       "#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00" +
-       "\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4" +
-       "\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00" +
-       "\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061" +
-       "\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\a\xf0\x00\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00" +
-       "\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x8f\xf0\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D%" +
-       "Z\xf0\x00\x00\x00\x00ECpp\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I\xce;p\x00\x00\x00\x00J\xe3\x16p\x00\x00" +
-       "\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x00\x00\x00\x00Nm\xf4@\x00\x00\x00\x00TK\xba\xf0\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x05\x06\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\a\x03\x06\x00\x00\x86F\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90" +
-       "\x00\b\x00\x00\x9a\xb0\x00\f\x00\x00\xa8\xc0\x01\x10\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x14\x00\x00\xa8\xc0\x00\x10LMT\x00+08\x00+09\x00+11\x00+12\x00+10\x00\n<+1" +
-       "0>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00\x1c\x00Asia/MagadanUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x196\xa0\xff" +
-       "\xff\xff\xff\xb5\xa3\xa8\xe0\x00\x00\x00\x00\x15'7P\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a" +
-       "\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00" +
-       "\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(" +
-       "\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00" +
-       "\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x006" +
-       "1\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\a\xf0\x00\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00" +
-       "\x00\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x8f\xf0\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D" +
-       "%Z\xf0\x00\x00\x00\x00ECpp\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I\xce;p\x00\x00\x00\x00J\xe3\x16p\x00" +
-       "\x00\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x00\x00\x00\x00TK\xac\xe0\x00\x00\x00\x00W\x1b\x9c\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x01\x03\x00\x00\x8d`\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa8" +
-       "\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\xa8\xc0\x00\bLMT\x00+10\x00+12\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x1c\x00Asia/ColomboUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00\x18\xff\xff\xff\xffV\xb6\x99$\xff\xff\xff\xff\x87\x9d\xbd\x1c\xff\xff\xff\xff\xcbZ\x1c(\xff\xff\xff\xff" +
-       "̕+\xa0\xff\xff\xff\xff\xd2u\x808\x00\x00\x00\x001\xa6\x00(\x00\x00\x00\x002q\x00 \x00\x00\x00\x00D?\xea(\x01\x02\x03\x04\x02\x05\x06\x02\x00\x00J\xdc\x00\x00\x00\x00J\xe4\x00\x04\x00\x00MX" +
-       "\x00\b\x00\x00T`\x01\x0e\x00\x00[h\x01\x12\x00\x00[h\x00\x12\x00\x00T`\x00\x0eLMT\x00MMT\x00+0530\x00+06\x00+0630\x00\n<+0530>-5" +
-       ":30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQL\xe0\x91y\xe5\x02\x00\x00\xe5\x02\x00\x00\x10\x00\x1c\x00Asia/KrasnoyarskUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf9\r" +
-       "\xf2\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00" +
-       "\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e" +
-       "\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00" +
-       "\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w" +
-       "0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY0\x00\x00\x00\x001]\x84\xb0\x00\x00\x00\x002r_\xb0\x00\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00\x00" +
-       "\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00\x008\x1b@0\x00\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\v" +
-       "0\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xed0\x00\x00\x00\x00?\x9a\xc80\x00\x00\x00\x00@e\xcf0\x00\x00\x00\x00A\x83\xe4\xb0\x00\x00\x00\x00BE\xb10\x00\x00\x00\x00Ccư\x00\x00\x00" +
-       "\x00D%\x930\x00\x00\x00\x00EC\xa8\xb0\x00\x00\x00\x00F\x05u0\x00\x00\x00\x00G#\x8a\xb0\x00\x00\x00\x00G\ue470\x00\x00\x00\x00I\x03l\xb0\x00\x00\x00\x00I\xces\xb0\x00\x00\x00\x00J\xe3N" +
-       "\xb0\x00\x00\x00\x00K\xaeU\xb0\x00\x00\x00\x00L\xcck0\x00\x00\x00\x00M\x8e7\xb0\x00\x00\x00\x00TK\xe5 \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00W\x0e\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp" +
-       "\x00\f\x00\x00bp\x01\f\x00\x00p\x80\x00\bLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf0\x9cf>\xd7\x02\x00" +
-       "\x00\xd7\x02\x00\x00\x0e\x00\x1c\x00Asia/KamchatkaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "0\x00+06\x00+07\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R)\x15II\xf3\x02\x00\x00\xf3\x02\x00\x00\r\x00\x1c\x00Asia/Sakhal" +
+       "inUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00" +
+       "\x06\x00\x00\x00\x14\xff\xff\xff\xff\x86\xf0\u0378\xff\xff\xff\xff\xd20\xb2\xf0\x00\x00\x00\x00\x15'7P\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9e" +
+       "P\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00" +
+       "\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6" +
+       "\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00" +
+       "\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\x17" +
+       "\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xfa\xf8\x00\x00\x00\x00\x00:\xbcĀ\x00\x00\x00" +
+       "\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87" +
+       "\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00I\x03B\x80\x00\x00\x00" +
+       "\x00I\xceI\x80\x00\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00\x00\x00\x00TK\xba\xf0\x00\x00\x00\x00V\xf6\xb2\x00\x01\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03\x05\x03\x00" +
+       "\x00\x85\xc8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\xa8\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x10LMT\x00+09\x00+12\x00+11\x00+10\x00\n<+11" +
+       ">-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RT\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x1c\x00Asia/AqtauUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x94\xe0\xff\xff\xff\xff" +
+       "\xb5\xa3\xfd@\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0" +
+       "\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00" +
+       "#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`" +
+       "\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x00" +
+       "0d\x83`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006\xfdT\xe0" +
+       "\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00" +
+       ">\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\x01\x02\x04\x02\x04\x02\x04\x01\x05\x01" +
+       "\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x02\x00\x00/ \x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x00\f\x00\x00T`\x01\f\x00\x00FP\x01\bLMT\x00+0" +
+       "4\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8a\xc1\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x1c\x00Asia/Pyongy" +
+       "angUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00" +
+       "\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x8b\xd7\xf1\x9c\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2/ap\x00\x00\x00\x00U\xce\x02p\x00\x00\x00\x00Z\xecup\x01\x02\x03\x01\x03\x00\x00u\xe4\x00\x00\x00\x00w" +
+       "\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x00\x04LMT\x00KST\x00JST\x00\nKST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x17✳2\x04\x00\x002\x04\x00\x00" +
+       "\x0e\x00\x1c\x00Asia/JerusalemUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c" +
+       "\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff" +
+       "\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xd7Z0\x80\xff\xff\xff\xff\xd7\xdfX\x00\xff\xff\xff\xff\xd8/À\xff\xff\xff\xff\xd9\x1ec\x00\xff\xff\xff\xff\xda\x10\xf7\x00\xff\xff\xff\xff\xda\xeb\xd0" +
+       "\x00\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ=\x00\xff\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}\x00\xff\xff\xff" +
+       "\xff\xe2\xbef\x80\xff\xff\xff\xff\xe36_\x00\xff\xff\xff\xff\xe4\x9eH\x80\xff\xff\xff\xff\xe5\x16A\x00\xff\xff\xff\xff\xe6t\xf0\x00\xff\xff\xff\xff\xe7\x11Ҁ\xff\xff\xff\xff\xe8&\xad\x80\xff\xff\xff\xff\xe8\xe8z" +
+       "\x00\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00" +
+       "\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e" +
+       "\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00" +
+       "\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5" +
+       "\xd0\x00\x00\x00\x001H\x96\xe0\x00\x00\x00\x002<nP\x00\x00\x00\x0031\xb3`\x00\x00\x00\x004\x1a\xfe\xd0\x00\x00\x00\x005\x11\x95`\x00\x00\x00\x005\xf1\xa6P\x00\x00\x00\x007\x04\b\x80\x00\x00\x00" +
+       "\x007\xcf\x01p\x00\x00\x00\x008\xf6_\x80\x00\x00\x00\x009\xdc\xf9\xe0\x00\x00\x00\x00:\xd0\xedp\x00\x00\x00\x00;\xae[`\x00\x00\x00\x00<\xa3\xa0p\x00\x00\x00\x00=\xa0\xb2`\x00\x00\x00\x00>\x83\x82" +
+       "p\x00\x00\x00\x00?|\x9f\xe0\x00\x00\x00\x00@s6p\x00\x00\x00\x00AP\xa4`\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00CHOp\x00\x00\x00\x00D,q\x00\x00\x00\x00\x00E\x1e\xf6\xf0\x00\x00\x00" +
+       "\x00F\fS\x00\x00\x00\x00\x00F\xecc\xf0\x00\x00\x00\x00G\xec5\x00\x00\x00\x00\x00H\xe7\xf5p\x00\x00\x00\x00I\xcc\x17\x00\x00\x00\x00\x00J\xbe\x9c\xf0\x00\x00\x00\x00K\xab\xf9\x00\x00\x00\x00\x00L\x8c\t" +
+       "\xf0\x00\x00\x00\x00M\x95\x15\x80\x00\x00\x00\x00N\x87\x9bp\x00\x00\x00\x00Ot\xf7\x80\x00\x00\x00\x00P^B\xf0\x00\x00\x00\x00QTـ\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\f\x00\x008@\x01\x10LMT\x00JMT\x00I" +
+       "DT\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R's\x96\x1en\x01" +
+       "\x00\x00n\x01\x00\x00\r\x00\x1c\x00Asia/DushanbeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa7R\x96\xc4\xff\xff\xff\xff\xb5\xa3\x9a\xd0\x00\x00\x00\x00\x15')@\x00\x00\x00\x00\x16\x18]\xb0\x00\x00" +
-       "\x00\x00\x17\b\\\xc0\x00\x00\x00\x00\x17\xf9\x910\x00\x00\x00\x00\x18\xe9\x90@\x00\x00\x00\x00\x19\xdaİ\x00\x00\x00\x00\x1a\xcc\x15@\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac\x13`\x00\x00\x00\x00\x1d\x9c" +
-       "\x04`\x00\x00\x00\x00\x1e\x8b\xf5`\x00\x00\x00\x00\x1f{\xe6`\x00\x00\x00\x00 k\xd7`\x00\x00\x00\x00![\xc8`\x00\x00\x00\x00\"K\xb9`\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\x9b`\x00\x00" +
-       "\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v}`\x00\x00\x00\x00'\x04\xa8\xe0\x00\x00\x00\x00'\xf4\x99\xe0\x00\x00\x00\x00(\xe4\x98\xf0\x00\x00\x00\x00)x@\xf0\x00\x00\x00\x00)\xd4{\xe0\x00\x00\x00\x00*\xc4" +
-       "l\xe0\x00\x00\x00\x00+\xb4]\xe0\x00\x00\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94?\xe0\x00\x00\x00\x00.\x840\xe0\x00\x00\x00\x00/t!\xe0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]>`\x00\x00" +
-       "\x00\x002r\x19`\x00\x00\x00\x003= `\x00\x00\x00\x004Q\xfb`\x00\x00\x00\x005\x1d\x02`\x00\x00\x00\x0061\xdd`\x00\x00\x00\x006\xfc\xe4`\x00\x00\x00\x008\x1a\xf9\xe0\x00\x00\x00\x008\xdc" +
-       "\xc6`\x00\x00\x00\x009\xfa\xdb\xe0\x00\x00\x00\x00:\xbc\xa8`\x00\x00\x00\x00;ڽ\xe0\x00\x00\x00\x00<\xa5\xc4\xe0\x00\x00\x00\x00=\xba\x9f\xe0\x00\x00\x00\x00>\x85\xa6\xe0\x00\x00\x00\x00?\x9a\x81\xe0\x00\x00" +
-       "\x00\x00@e\x88\xe0\x00\x00\x00\x00A\x83\x9e`\x00\x00\x00\x00BEj\xe0\x00\x00\x00\x00Cc\x80`\x00\x00\x00\x00D%L\xe0\x00\x00\x00\x00ECb`\x00\x00\x00\x00F\x05.\xe0\x00\x00\x00\x00G#" +
-       "D`\x00\x00\x00\x00G\xeeK`\x00\x00\x00\x00I\x03&`\x00\x00\x00\x00I\xce-`\x00\x00\x00\x00J\xe3\b`\x00\x00\x00\x00K\xae\x0f`\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x01\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04" +
-       "\x01\x03\x00\x00\x94\xbc\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00\xb6\xd0\x01\b\x00\x00\xa8\xc0\x00\f\x00\x00\xa8\xc0\x01\fLMT\x00+11\x00+13\x00+12\x00\n<+12>-12\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x1c\x00Asia/Ujung_PandangUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xa1\xf2]\x90\xff\xff\xff" +
-       "\xff\xba\x16Ր\xff\xff\xff\xffˈ\x1d\x80\xff\xff\xff\xff\xd2V\xeep\x01\x02\x03\x04\x00\x00o\xf0\x00\x00\x00\x00o\xf0\x00\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\f\x00\x00p\x80\x00\x10LMT\x00M" +
-       "MT\x00+08\x00+09\x00WITA\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x1c\x00Asia/J" +
-       "akartaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\b\x00\x00\x00\a\x00\x00\x00 \xff\xff\xff\xff?fI`\xff\xff\xff\xff\xa9x\x85\xe0\xff\xff\xff\xff\xba\x16\xde`\xff\xff\xff\xff˿\x83\x88\xff\xff\xff\xff\xd2V\xeep\xff\xff\xff\xff\xd7<\xc6\b\xff\xff\xff" +
-       "\xff\xda\xff&\x00\xff\xff\xff\xff\xf4\xb5\xbe\x88\x01\x02\x03\x04\x03\x05\x03\x06\x00\x00d \x00\x00\x00\x00d \x00\x04\x00\x00g \x00\b\x00\x00ix\x00\x0e\x00\x00~\x90\x00\x14\x00\x00p\x80\x00\x18\x00\x00b" +
-       "p\x00\x1cLMT\x00BMT\x00+0720\x00+0730\x00+09\x00+08\x00WIB\x00\nWIB-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x1a\xdc\xca" +
-       "\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x1c\x00Asia/KolkataUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff&\xba\x18(\xff\xff\xff\xffC\xe7\xeb0\xff\xff\xff\xff\x87\x9d\xbc\xba\xff\xff\xff\xff\xcaی(\xff" +
-       "\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\x01\x02\x03\x04\x03\x04\x03\x00\x00R\xd8\x00\x00\x00\x00R\xd0\x00\x04\x00\x00KF\x00\b\x00\x00MX\x00\f\x00\x00[h\x01\x10" +
-       "LMT\x00HMT\x00MMT\x00IST\x00+0630\x00\nIST-5:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00" +
-       "\x1c\x00Asia/KabulUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffi\x86\x9a\xa0\xff\xff\xff\xff\xd0\xf9\xd7@\x01\x02\x00\x00@\xe0\x00\x00\x00\x008@\x00\x04\x00\x00?H\x00\bLMT\x00+04\x00+" +
-       "0430\x00\n<+0430>-4:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x1c\x00Asia/OralUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\a\x00\x00\x00" +
-       "\x14\xff\xff\xff\xff\xaa\x19\x93\xdc\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00" +
-       "\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9" +
-       "\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00" +
-       "\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xbf`\x00\x00\x00\x00-\x94\xb0" +
-       "`\x00\x00\x00\x00.\x84\xa1`\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000d\x83`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00" +
-       "\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb." +
-       "`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x05\x06\x05\x06\x05\x06\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x02\x00\x000$\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x00\b\x00\x00" +
-       "T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\b\x00\x008@\x00\x10LMT\x00+03\x00+05\x00+06\x00+04\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x1c\x00Asia/JayapuraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\xba\x16\xc1\x98\xff\xff\xff\xff\xd0X\xb9\xf0\xff\xff\xff\xff\xf4\xb5\xa2" +
-       "h\x01\x02\x03\x00\x00\x83\xe8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x85\x98\x00\b\x00\x00~\x90\x00\x0eLMT\x00+09\x00+0930\x00WIT\x00\nWIT-9\nPK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQS\xa5\x81e\xf7\x00\x00\x00\xf7\x00\x00\x00\x0e\x00\x1c\x00Asia/PontianakUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00\x1f\xff\xff\xff\xff\x8b\xff\x8e\x00\xff\xff\xff\xff\xba\x16\xdf\x00\xff\xff\xff\xff" +
-       "\xcby\xa4\b\xff\xff\xff\xff\xd2V\xeep\xff\xff\xff\xff\xd7<\xc6\b\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xf4\xb5\xbe\x88\x00\x00\x00\x00!\xdat\x80\x01\x02\x03\x02\x04\x02\x05\x06\x00\x00f\x80\x00\x00\x00\x00" +
-       "f\x80\x00\x04\x00\x00ix\x00\b\x00\x00~\x90\x00\x0e\x00\x00p\x80\x00\x12\x00\x00p\x80\x00\x16\x00\x00bp\x00\x1bLMT\x00PMT\x00+0730\x00+09\x00+08\x00WITA" +
-       "\x00WIB\x00\nWIB-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Asia/MakassarUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff" +
-       "\xff\xff\xa1\xf2]\x90\xff\xff\xff\xff\xba\x16Ր\xff\xff\xff\xffˈ\x1d\x80\xff\xff\xff\xff\xd2V\xeep\x01\x02\x03\x04\x00\x00o\xf0\x00\x00\x00\x00o\xf0\x00\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\f\x00\x00" +
-       "p\x80\x00\x10LMT\x00MMT\x00+08\x00+09\x00WITA\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQѾ\xa8\xc7u\x02\x00\x00u\x02\x00\x00\f" +
-       "\x00\x1c\x00Asia/TbilisiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x83\x80\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00" +
+       "\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9c" +
+       "X\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00" +
+       "\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(ʏP\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x04\x01\x00\x00@\x80\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLMT\x00+05\x00+07\x00+06\x00\n<+05>-5\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x1c\x00Asia/ColomboUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00\x18\xff\xff\xff\xffV\xb6\x99$\xff\xff\xff\xff\x87\x9d\xbd\x1c\xff\xff" +
+       "\xff\xff\xcbZ\x1c(\xff\xff\xff\xff̕+\xa0\xff\xff\xff\xff\xd2u\x808\x00\x00\x00\x001\xa6\x00(\x00\x00\x00\x002q\x00 \x00\x00\x00\x00D?\xea(\x01\x02\x03\x04\x02\x05\x06\x02\x00\x00J\xdc\x00\x00" +
+       "\x00\x00J\xe4\x00\x04\x00\x00MX\x00\b\x00\x00T`\x01\x0e\x00\x00[h\x01\x12\x00\x00[h\x00\x12\x00\x00T`\x00\x0eLMT\x00MMT\x00+0530\x00+06\x00+0630\x00" +
+       "\n<+0530>-5:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x1c\x00Asia/KarachiUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x06\x00\x00\x00\x1d\xff" +
+       "\xff\xff\xff\x89~\xfc\xa4\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\xff\xff\xff\xffݨ\xe0\xa8\x00\x00\x00\x00\x02O\xab0\x00\x00\x00\x00<\xafE\xb0\x00\x00\x00\x00=\x9f(\xa0\x00\x00\x00\x00H" +
+       "A\xa00\x00\x00\x00\x00I\vG\xa0\x00\x00\x00\x00I\xe4\xdd0\x00\x00\x00\x00J\xec{ \x01\x02\x01\x03\x05\x04\x05\x04\x05\x04\x05\x00\x00>\xdc\x00\x00\x00\x00MX\x00\x04\x00\x00[h\x01\n\x00\x00FP" +
+       "\x00\x10\x00\x00T`\x01\x14\x00\x00FP\x00\x19LMT\x00+0530\x00+0630\x00+05\x00PKST\x00PKT\x00\nPKT-5\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R恸\x1e\x00\x01\x00\x00\x00\x01\x00\x00\x11\x00\x1c\x00Asia/Kuala_LumpurUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00 \xff\xff\xff\xff~6U\xaa\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff" +
+       "\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xffˑ_\b\xff\xff\xff\xff\xd2Hm\xf0\x00\x00\x00\x00\x16\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00_V\x00\x00\x00\x00" +
+       "a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00ix\x00\x12\x00\x00~\x90\x00\x18\x00\x00p\x80\x00\x1cLMT\x00SMT\x00+07\x00+0720\x00+0" +
+       "730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Re\x1bb2w\x01\x00\x00w\x01\x00\x00\r\x00\x1c\x00Asia/Ashg" +
+       "abatUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00" +
+       "\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x8dD\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xbf0\x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18" +
+       "\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00" +
+       "\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'" +
+       "\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x006\xbc\x00\x00\x00\x00" +
+       "8@\x00\x04\x00\x00T`\x01\b\x00\x00FP\x00\f\x00\x00FP\x01\fLMT\x00+04\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x1c\x00Asia/KolkataUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff&\xba\x18(\xff\xff\xff\xffC\xe7\xeb0\xff\xff\xff\xff\x87\x9d\xbc\xba\xff\xff\xff\xff" +
+       "\xcaی(\xff\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\x01\x02\x03\x04\x03\x04\x03\x00\x00R\xd8\x00\x00\x00\x00R\xd0\x00\x04\x00\x00KF\x00\b\x00\x00MX\x00\f\x00" +
+       "\x00[h\x01\x10LMT\x00HMT\x00MMT\x00IST\x00+0630\x00\nIST-5:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RB\x1d\xc6\x1b\x85\x00\x00\x00\x85" +
+       "\x00\x00\x00\f\x00\x1c\x00Asia/KashgarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xb0\xfe\xbad\x01\x00\x00R\x1c\x00\x00\x00\x00T`\x00\x04LMT\x00+06\x00\n<+06>-6\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xba\xa3b\xc1R\x02\x00\x00R\x02\x00\x00\t\x00\x1c\x00Asia/HovdUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xfc\x94\x00\x00\x00\x00\x0f\v\xea\xa0\x00\x00" +
+       "\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbc>\x80\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c \x80\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00\x00\x1f|" +
+       "\x02\x80\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xe4\x80\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;ƀ\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xa8\x80\x00\x00\x00\x00&\v\xa7\x90\x00\x00" +
+       "\x00\x00'\x04\xc5\x00\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)Ԧ\x10\x00\x00\x00\x00*ĉ\x00\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4k\x00\x00\x00\x00\x00-\x94" +
+       "j\x10\x00\x00\x00\x00.\x84M\x00\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d/\x00\x00\x00\x00\x001]h\x90\x00\x00\x00\x002MK\x80\x00\x00\x00\x003=J\x90\x00\x00\x00\x004--\x80\x00\x00" +
+       "\x00\x005\x1d,\x90\x00\x00\x00\x006\r\x0f\x80\x00\x00\x00\x00:\xe9\xc1\xb0\x00\x00\x00\x00;\xb4\xba\xa0\x00\x00\x00\x00<\xa4\xb9\xb0\x00\x00\x00\x00=\x94\x9c\xa0\x00\x00\x00\x00>\x84\x9b\xb0\x00\x00\x00\x00?t" +
+       "~\xa0\x00\x00\x00\x00@d}\xb0\x00\x00\x00\x00AT`\xa0\x00\x00\x00\x00BD_\xb0\x00\x00\x00\x00C4B\xa0\x00\x00\x00\x00D$A\xb0\x00\x00\x00\x00E\x1d_ \x00\x00\x00\x00U\x15\xa8\xb0\x00\x00" +
+       "\x00\x00V\x05o\x80\x00\x00\x00\x00V\xf5\x8a\xb0\x00\x00\x00\x00W\xe5Q\x80\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00U\xec\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t\x00\x1c\x00Asia/BakuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x95D\xff\xff\xff\xff\xe7\xda\fP\x00" +
+       "\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b" +
+       "\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00" +
+       "\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)" +
+       "\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x001]\xd9\x10\x00\x00\x00\x002r\xb4\x10\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062j\x00\x00" +
+       "\x00\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x009\xfbh\x80\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80\x00\x00\x00\x00<\xa6Q\x80\x00\x00\x00\x00=" +
+       "\xbb,\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80\x00\x00\x00\x00A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00Cd\r\x00\x00\x00\x00\x00D%ـ\x00" +
+       "\x00\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00G\xee\xd8\x00\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00\x00\x00\x00\x00J\xe3\x95\x00\x00\x00\x00\x00K" +
+       "\xae\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x00\x00\x00\x00N\xac\x93\x80\x00\x00\x00\x00On`\x00\x00\x00\x00\x00P\x8cu\x80\x00\x00\x00\x00QW|\x80\x00\x00\x00\x00RlW\x80\x00" +
+       "\x00\x00\x00S7^\x80\x00\x00\x00\x00TL9\x80\x00\x00\x00\x00U\x17@\x80\x00\x00\x00\x00V,\x1b\x80\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00.\xbc\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00" +
+       "\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00" +
+       "\x1c\x00Asia/KhandygaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xba\x01\xff\xff\xff\xff\xaa\x19\x9a\x01\xff\xff\xff\xff\xe7\xda\fP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00" +
-       "\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9c" +
-       "t\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00" +
-       "\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00+\xb4" +
-       "\xc0P\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x000dY0\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x003=f\xb0\x00\x00" +
-       "\x00\x004RA\xb0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1b@0\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc" +
-       "\xfc\xc0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xc80\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00@\xddǰ\x00\x00" +
-       "\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x05\x02\x05\x02\x05\x04\x03\x04\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x05\x02\x04\x00\x00)\xff\x00\x00\x00\x00)\xff\x00\x04\x00\x00*0\x00\t\x00\x00FP\x01\r\x00\x008@\x00\x11\x00\x008@\x01\x11LMT\x00TBMT\x00+03\x00+05\x00+" +
-       "04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e\x00\x1c\x00Asia/SingaporeUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00 \xff" +
-       "\xff\xff\xff~6S\xa3\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xffˑ_\b\xff\xff\xff\xff\xd2Hm\xf0\x00\x00\x00\x00\x16" +
-       "\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00a]\x00\x00\x00\x00a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00ix\x00\x12\x00\x00~\x90\x00\x18\x00\x00p\x80\x00\x1cL" +
-       "MT\x00SMT\x00+07\x00+0720\x00+0730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01" +
-       "\x00\x00\x89\x01\x00\x00\v\x00\x1c\x00Asia/HarbinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff" +
-       "\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00" +
-       "\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00" +
-       " ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10" +
-       "\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p" +
-       "\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\f\x00\x1c\x00Asia/Kas" +
-       "hgarUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xb0\xfe\xbad\x01\x00\x00R\x1c\x00\x00\x00\x00T`\x00\x04LMT\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?" +
-       "Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/DhakaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff\xffi\x86\x86\xbc\xff\xff\xff\xff\xcaۆ\xb0\xff\xff\xff\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8" +
-       "\xff\xff\xff\xffݨҘ\x00\x00\x00\x00J;\xc4\x10\x00\x00\x00\x00K<ؐ\x01\x02\x03\x02\x04\x05\x04\x00\x00T\xc4\x00\x00\x00\x00R\xd0\x00\x04\x00\x00[h\x00\b\x00\x00MX\x00\x0e\x00\x00T`\x00" +
-       "\x14\x00\x00bp\x01\x18LMT\x00HMT\x00+0630\x00+0530\x00+06\x00+07\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQO\xb0" +
-       "\x03\xe9\xe5\x02\x00\x00\xe5\x02\x00\x00\f\x00\x1c\x00Asia/YakutskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xff\xa1\xdb\xe4\xeb\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18\x87\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00\x00" +
+       "\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e\x8c" +
+       "\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ\x00\x00\x00\x00$+Ő\x00\x00\x00\x00%\x1b\xb6\x90\x00\x00" +
+       "\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00)Ԧ\x10\x00\x00\x00\x00*ė\x10\x00\x00\x00\x00+\xb4" +
+       "\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10\x00\x00\x00\x001]h\x90\x00\x00\x00\x002rC\x90\x00\x00" +
+       "\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x0062\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x008\x1b$\x10\x00\x00\x00\x008\xdc\xf0\x90\x00\x00\x00\x009\xfb" +
+       "\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10\x00\x00\x00\x00?\x9a\xac\x10\x00\x00\x00\x00?\xf2\xe4p\x00\x00" +
+       "\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#" +
+       "`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00I\x03B\x80\x00\x00\x00\x00I\xceI\x80\x00\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00\x00" +
+       "\x00\x00Nn\x02P\x00\x00\x00\x00TK\xc9\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\x06\x03\x00\x00\u007f\x15\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x9a\xb0\x01\x10\x00\x00\x8c" +
+       "\xa0\x00\b\x00\x00\x9a\xb0\x00\x10LMT\x00+08\x00+10\x00+09\x00+11\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9a\xea\x18\xd4\xf8\x02\x00\x00" +
+       "\xf8\x02\x00\x00\x12\x00\x1c\x00Asia/YekaterinburgUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\xea^\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18\x87" +
-       "\xe0\x00\x00\x00\x00\x17\b\x86\xf0\x00\x00\x00\x00\x17\xf9\xbb`\x00\x00\x00\x00\x18\xe9\xbap\x00\x00\x00\x00\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbcL\x90\x00\x00\x00\x00\x1c\xac=\x90\x00\x00\x00" +
-       "\x00\x1d\x9c.\x90\x00\x00\x00\x00\x1e\x8c\x1f\x90\x00\x00\x00\x00\x1f|\x10\x90\x00\x00\x00\x00 l\x01\x90\x00\x00\x00\x00![\xf2\x90\x00\x00\x00\x00\"K\xe3\x90\x00\x00\x00\x00#;Ԑ\x00\x00\x00\x00$+\xc5" +
-       "\x90\x00\x00\x00\x00%\x1b\xb6\x90\x00\x00\x00\x00&\v\xa7\x90\x00\x00\x00\x00'\x04\xd3\x10\x00\x00\x00\x00'\xf4\xc4\x10\x00\x00\x00\x00(\xe4\xc3 \x00\x00\x00\x00)xk \x00\x00\x00\x00)Ԧ\x10\x00\x00\x00" +
-       "\x00*ė\x10\x00\x00\x00\x00+\xb4\x88\x10\x00\x00\x00\x00,\xa4y\x10\x00\x00\x00\x00-\x94j\x10\x00\x00\x00\x00.\x84[\x10\x00\x00\x00\x00/tL\x10\x00\x00\x00\x000d=\x10\x00\x00\x00\x001]h" +
-       "\x90\x00\x00\x00\x002rC\x90\x00\x00\x00\x003=J\x90\x00\x00\x00\x004R%\x90\x00\x00\x00\x005\x1d,\x90\x00\x00\x00\x0062\a\x90\x00\x00\x00\x006\xfd\x0e\x90\x00\x00\x00\x008\x1b$\x10\x00\x00\x00" +
-       "\x008\xdc\xf0\x90\x00\x00\x00\x009\xfb\x06\x10\x00\x00\x00\x00:\xbcҐ\x00\x00\x00\x00;\xda\xe8\x10\x00\x00\x00\x00<\xa5\xef\x10\x00\x00\x00\x00=\xba\xca\x10\x00\x00\x00\x00>\x85\xd1\x10\x00\x00\x00\x00?\x9a\xac" +
-       "\x10\x00\x00\x00\x00@e\xb3\x10\x00\x00\x00\x00A\x83Ȑ\x00\x00\x00\x00BE\x95\x10\x00\x00\x00\x00Cc\xaa\x90\x00\x00\x00\x00D%w\x10\x00\x00\x00\x00EC\x8c\x90\x00\x00\x00\x00F\x05Y\x10\x00\x00\x00" +
-       "\x00G#n\x90\x00\x00\x00\x00G\xeeu\x90\x00\x00\x00\x00I\x03P\x90\x00\x00\x00\x00I\xceW\x90\x00\x00\x00\x00J\xe32\x90\x00\x00\x00\x00K\xae9\x90\x00\x00\x00\x00L\xccO\x10\x00\x00\x00\x00M\x8e\x1b" +
-       "\x90\x00\x00\x00\x00TK\xc9\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00y\xa2\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\f\x00\x00\x8c\xa0\x00\bLMT\x00+08\x00+1" +
-       "0\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ恸\x1e\x00\x01\x00\x00\x00\x01\x00\x00\x11\x00\x1c\x00Asia/Kuala_Lump" +
-       "urUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00" +
-       "\b\x00\x00\x00 \xff\xff\xff\xff~6U\xaa\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xffˑ_\b\xff\xff\xff\xff\xd2Hm" +
-       "\xf0\x00\x00\x00\x00\x16\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00_V\x00\x00\x00\x00a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00ix\x00\x12\x00\x00~\x90\x00\x18\x00" +
-       "\x00p\x80\x00\x1cLMT\x00SMT\x00+07\x00+0720\x00+0730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       ";\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x1c\x00Asia/TehranUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff\xff\x9al}\xc8\xff\xff\xff\xff\xd2\xdb\x12\xc8\x00\x00\x00\x00\x0e\xbb\xa2H\x00\x00\x00\x00\x0ft" +
-       "-@\x00\x00\x00\x00\x10\x8e@0\x00\x00\x00\x00\x10\xed:@\x00\x00\x00\x00\x11Ug\xc8\x00\x00\x00\x00\x12EJ\xb8\x00\x00\x00\x00\x137\xec\xc8\x00\x00\x00\x00\x14-\x15\xb8\x00\x00\x00\x00( v\xc8\x00\x00" +
-       "\x00\x00(\u06dd\xb8\x00\x00\x00\x00)˜\xc8\x00\x00\x00\x00*\xbe\"\xb8\x00\x00\x00\x00+\xac\xd0H\x00\x00\x00\x00,\x9fV8\x00\x00\x00\x00-\x8e\x03\xc8\x00\x00\x00\x00.\x80\x89\xb8\x00\x00\x00\x00/o" +
-       "7H\x00\x00\x00\x000a\xbd8\x00\x00\x00\x001Pj\xc8\x00\x00\x00\x002B\xf0\xb8\x00\x00\x00\x0032\xef\xc8\x00\x00\x00\x004%u\xb8\x00\x00\x00\x005\x14#H\x00\x00\x00\x006\x06\xa98\x00\x00" +
-       "\x00\x006\xf5V\xc8\x00\x00\x00\x007\xe7ܸ\x00\x00\x00\x008֊H\x00\x00\x00\x009\xc9\x108\x00\x00\x00\x00:\xb9\x0fH\x00\x00\x00\x00;\xab\x958\x00\x00\x00\x00<\x9aB\xc8\x00\x00\x00\x00=\x8c" +
-       "ȸ\x00\x00\x00\x00>{vH\x00\x00\x00\x00?m\xfc8\x00\x00\x00\x00@\\\xa9\xc8\x00\x00\x00\x00AO/\xb8\x00\x00\x00\x00B?.\xc8\x00\x00\x00\x00C1\xb4\xb8\x00\x00\x00\x00G\xe2\xc9H\x00\x00" +
-       "\x00\x00H\xd5O8\x00\x00\x00\x00I\xc5NH\x00\x00\x00\x00J\xb7\xd48\x00\x00\x00\x00K\xa6\x81\xc8\x00\x00\x00\x00L\x99\a\xb8\x00\x00\x00\x00M\x87\xb5H\x00\x00\x00\x00Nz;8\x00\x00\x00\x00Oh" +
-       "\xe8\xc8\x00\x00\x00\x00P[n\xb8\x00\x00\x00\x00QKm\xc8\x00\x00\x00\x00R=\xf3\xb8\x00\x00\x00\x00S,\xa1H\x00\x00\x00\x00T\x1f'8\x00\x00\x00\x00U\r\xd4\xc8\x00\x00\x00\x00V\x00Z\xb8\x00\x00" +
-       "\x00\x00V\xef\bH\x00\x00\x00\x00W\xe1\x8e8\x00\x00\x00\x00XэH\x00\x00\x00\x00Y\xc4\x138\x00\x00\x00\x00Z\xb2\xc0\xc8\x00\x00\x00\x00[\xa5F\xb8\x00\x00\x00\x00\\\x93\xf4H\x00\x00\x00\x00]\x86" +
-       "z8\x00\x00\x00\x00^u'\xc8\x00\x00\x00\x00_g\xad\xb8\x00\x00\x00\x00`W\xac\xc8\x00\x00\x00\x00aJ2\xb8\x00\x00\x00\x00b8\xe0H\x00\x00\x00\x00c+f8\x00\x00\x00\x00d\x1a\x13\xc8\x00\x00" +
-       "\x00\x00e\f\x99\xb8\x00\x00\x00\x00e\xfbGH\x00\x00\x00\x00f\xed\xcd8\x00\x00\x00\x00g\xdd\xccH\x00\x00\x00\x00h\xd0R8\x00\x00\x00\x00i\xbe\xff\xc8\x00\x00\x00\x00j\xb1\x85\xb8\x00\x00\x00\x00k\xa0" +
-       "3H\x00\x00\x00\x00l\x92\xb98\x00\x00\x00\x00m\x81f\xc8\x00\x00\x00\x00ns\xec\xb8\x00\x00\x00\x00ob\x9aH\x00\x00\x00\x00pU 8\x00\x00\x00\x00qE\x1fH\x00\x00\x00\x00r7\xa58\x00\x00" +
-       "\x00\x00s&R\xc8\x00\x00\x00\x00t\x18ظ\x00\x00\x00\x00u\a\x86H\x00\x00\x00\x00u\xfa\f8\x00\x00\x00\x00v\xe8\xb9\xc8\x00\x00\x00\x00w\xdb?\xb8\x00\x00\x00\x00x\xcb>\xc8\x00\x00\x00\x00y\xbd" +
-       "ĸ\x00\x00\x00\x00z\xacrH\x00\x00\x00\x00{\x9e\xf88\x00\x00\x00\x00|\x8d\xa5\xc8\x00\x00\x00\x00}\x80+\xb8\x00\x00\x00\x00~n\xd9H\x00\x00\x00\x00\u007fa_8\x00\x00\x00\x00\x80Q^H\x00\x00" +
-       "\x00\x00\x81C\xe48\x00\x00\x00\x00\x822\x91\xc8\x00\x00\x00\x00\x83%\x17\xb8\x00\x00\x00\x00\x84\x13\xc5H\x00\x00\x00\x00\x85\x06K8\x00\x00\x00\x00\x85\xf4\xf8\xc8\x00\x00\x00\x00\x86\xe7~\xb8\x00\x00\x00\x00\x87\xd7" +
-       "}\xc8\x00\x00\x00\x00\x88\xca\x03\xb8\x00\x00\x00\x00\x89\xb8\xb1H\x00\x00\x00\x00\x8a\xab78\x00\x00\x00\x00\x8b\x99\xe4\xc8\x00\x00\x00\x00\x8c\x8cj\xb8\x00\x00\x00\x00\x8d{\x18H\x00\x00\x00\x00\x8em\x9e8\x00\x00" +
-       "\x00\x00\x8f]\x9dH\x00\x00\x00\x00\x90P#8\x00\x00\x00\x00\x91>\xd0\xc8\x00\x00\x00\x00\x921V\xb8\x00\x00\x00\x00\x93 \x04H\x00\x00\x00\x00\x94\x12\x8a8\x00\x00\x00\x00\x95\x017\xc8\x00\x00\x00\x00\x95\xf3" +
-       "\xbd\xb8\x00\x00\x00\x00\x96\xe3\xbc\xc8\x00\x00\x00\x00\x97\xd6B\xb8\x00\x00\x00\x00\x98\xc4\xf0H\x00\x00\x00\x00\x99\xb7v8\x00\x00\x00\x00\x9a\xa6#\xc8\x00\x00\x00\x00\x9b\x98\xa9\xb8\x00\x00\x00\x00\x9c\x87WH\x00\x00" +
-       "\x00\x00\x9dy\xdd8\x00\x00\x00\x00\x9ei\xdcH\x00\x00\x00\x00\x9f\\b8\x00\x00\x00\x00\xa0K\x0f\xc8\x00\x00\x00\x00\xa1=\x95\xb8\x00\x00\x00\x00\xa2,CH\x00\x00\x00\x00\xa3\x1e\xc98\x00\x00\x00\x00\xa4\r" +
-       "v\xc8\x00\x00\x00\x00\xa4\xff\xfc\xb8\x00\x00\x00\x00\xa5\xef\xfb\xc8\x00\x00\x00\x00\xa6⁸\x00\x00\x00\x00\xa7\xd1/H\x00\x00\x00\x00\xa8õ8\x00\x00\x00\x00\xa9\xb2b\xc8\x00\x00\x00\x00\xaa\xa4\xe8\xb8\x00\x00" +
-       "\x00\x00\xab\x93\x96H\x00\x00\x00\x00\xac\x86\x1c8\x00\x00\x00\x00\xadt\xc9\xc8\x00\x00\x00\x00\xaegO\xb8\x00\x00\x00\x00\xafWN\xc8\x00\x00\x00\x00\xb0IԸ\x00\x00\x00\x00\xb18\x82H\x00\x00\x00\x00\xb2+" +
-       "\b8\x00\x00\x00\x00\xb3\x19\xb5\xc8\x00\x00\x00\x00\xb4\f;\xb8\x00\x00\x00\x00\xb4\xfa\xe9H\x00\x00\x00\x00\xb5\xedo8\x00\x00\x00\x00\xb6\xddnH\x00\x00\x00\x00\xb7\xcf\xf48\x00\x00\x00\x00\xb8\xbe\xa1\xc8\x00\x00" +
-       "\x00\x00\xb9\xb1'\xb8\x00\x00\x00\x00\xba\x9f\xd5H\x00\x00\x00\x00\xbb\x92[8\x00\x00\x00\x00\xbc\x81\b\xc8\x00\x00\x00\x00\xbds\x8e\xb8\x00\x00\x00\x00\xbec\x8d\xc8\x00\x00\x00\x00\xbfV\x13\xb8\x00\x00\x00\x00\xc0D" +
-       "\xc1H\x00\x00\x00\x00\xc17G8\x00\x00\x00\x00\xc2%\xf4\xc8\x00\x00\x00\x00\xc3\x18z\xb8\x00\x00\x00\x00\xc4\a(H\x00\x00\x00\x00\xc4\xf9\xae8\x00\x00\x00\x00\xc5\xe9\xadH\x00\x00\x00\x00\xc6\xdc38\x00\x00" +
-       "\x00\x00\xc7\xca\xe0\xc8\x00\x00\x00\x00Ƚf\xb8\x00\x00\x00\x00ɬ\x14H\x00\x00\x00\x00ʞ\x9a8\x00\x00\x00\x00ˍG\xc8\x00\x00\x00\x00\xcc\u007f\u0378\x00\x00\x00\x00\xcdo\xcc\xc8\x00\x00\x00\x00\xceb" +
-       "R\xb8\x00\x00\x00\x00\xcfQ\x00H\x00\x00\x00\x00\xd0C\x868\x00\x00\x00\x00\xd123\xc8\x00\x00\x00\x00\xd2$\xb9\xb8\x00\x00\x00\x00\xd3\x13gH\x00\x00\x00\x00\xd4\x05\xed8\x00\x00\x00\x00\xd4\xf5\xecH\x00\x00" +
-       "\x00\x00\xd5\xe8r8\x00\x00\x00\x00\xd6\xd7\x1f\xc8\x00\x00\x00\x00\xd7ɥ\xb8\x00\x00\x00\x00ظSH\x00\x00\x00\x00٪\xd98\x00\x00\x00\x00ڙ\x86\xc8\x00\x00\x00\x00ی\f\xb8\x00\x00\x00\x00\xdc|" +
-       "\v\xc8\x00\x00\x00\x00\xddn\x91\xb8\x00\x00\x00\x00\xde]?H\x01\x02\x04\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x00\x0008\x00\x00\x00\x0008\x00\x04\x00\x0018\x00\b\x00\x00F" +
-       "P\x01\x0e\x00\x008@\x00\x12\x00\x00?H\x01\x16LMT\x00TMT\x00+0330\x00+05\x00+04\x00+0430\x00\n<+0330>-3:30<+04" +
-       "30>,J79/24,J263/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x1c\x00Asia/Beirut" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x03\x00" +
-       "\x00\x00\r\xff\xff\xff\xffV\xb6¸\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff" +
-       "\xff\xff\xff\xa8)\xf3\xe0\xff\xff\xff\xff\xa8\xeb\xb2P\xff\xff\xff\xff\xe8*\x85\xe0\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xec\xe0\xff\xff\xff\xff\xec" +
-       "\xb6\x94P\xff\xff\xff\xff\xed\xcfq\xe0\xff\xff\xff\xff\xee\x99\x19P\xff\xff\xff\xffﰥ`\xff\xff\xff\xff\xf0zL\xd0\x00\x00\x00\x00\x04\xa6^`\x00\x00\x00\x00\x05+w\xd0\x00\x00\x00\x00\x06C\x03\xe0\x00" +
-       "\x00\x00\x00\a\f\xabP\x00\x00\x00\x00\b$7`\x00\x00\x00\x00\b\xed\xde\xd0\x00\x00\x00\x00\n\x05j\xe0\x00\x00\x00\x00\n\xcf\x12P\x00\x00\x00\x00\v\xe7\xef\xe0\x00\x00\x00\x00\f\xb1\x97P\x00\x00\x00\x00\r" +
-       "\xc9#`\x00\x00\x00\x00\x0e\x92\xca\xd0\x00\x00\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10r\xac\xd0\x00\x00\x00\x00\x1a\xf4.\xe0\x00\x00\x00\x00\x1bќ\xd0\x00\x00\x00\x00\x1c\xd5b`\x00\x00\x00\x00\x1d\xb2\xd0P\x00" +
-       "\x00\x00\x00\x1e\xb6\x95\xe0\x00\x00\x00\x00\x1f\x94\x03\xd0\x00\x00\x00\x00 \x97\xc9`\x00\x00\x00\x00!u7P\x00\x00\x00\x00\"\xa3,\xe0\x00\x00\x00\x00#W\xbcP\x00\x00\x00\x00$g_`\x00\x00\x00\x00%" +
-       "8\xef\xd0\x00\x00\x00\x00&<\xb5`\x00\x00\x00\x00'\x1a#P\x00\x00\x00\x00(\x1d\xe8\xe0\x00\x00\x00\x00(\xfbV\xd0\x00\x00\x00\x00*\x00m\xe0\x00\x00\x00\x00*\xce\t\xd0\x00\x00\x00\x00+\xb4\xce`\x00" +
-       "\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003" +
-       "=\x90\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x006\rU\xd0\x00\x00\x00\x006\xfdT\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00!H\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT" +
-       "\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/0,M10.5.0/0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xdb\xfa\xb5\xbeg\x02" +
-       "\x00\x00g\x02\x00\x00\v\x00\x1c\x00Asia/AqtobeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x8eh\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00" +
-       "\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0" +
-       "\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00" +
-       "%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP" +
-       "\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x00" +
-       "2r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0" +
-       "\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00" +
-       "@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x00\x005\x98\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+05\x00+06\x00\n<+05" +
-       ">-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x1c\x00Asia/AnadyrUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xaa\x19\x1d\x9c\xff\xff\xff\xff" +
-       "\xb5\xa3\x8c\xc0\x00\x00\x00\x00\x15'\x1b0\x00\x00\x00\x00\x16\x18O\xa0\x00\x00\x00\x00\x17\bN\xb0\x00\x00\x00\x00\x17\xf9\x910\x00\x00\x00\x00\x18\xe9\x90@\x00\x00\x00\x00\x19\xdaİ\x00\x00\x00\x00\x1a\xcc\x15@" +
-       "\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac\x13`\x00\x00\x00\x00\x1d\x9c\x04`\x00\x00\x00\x00\x1e\x8b\xf5`\x00\x00\x00\x00\x1f{\xe6`\x00\x00\x00\x00 k\xd7`\x00\x00\x00\x00![\xc8`\x00\x00\x00\x00" +
-       "\"K\xb9`\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\x9b`\x00\x00\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v}`\x00\x00\x00\x00'\x04\xa8\xe0\x00\x00\x00\x00'\xf4\x99\xe0\x00\x00\x00\x00(\xe4\x98\xf0" +
-       "\x00\x00\x00\x00)x@\xf0\x00\x00\x00\x00)\xd4{\xe0\x00\x00\x00\x00*\xc4l\xe0\x00\x00\x00\x00+\xb4]\xe0\x00\x00\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94?\xe0\x00\x00\x00\x00.\x840\xe0\x00\x00\x00\x00" +
-       "/t!\xe0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]>`\x00\x00\x00\x002r\x19`\x00\x00\x00\x003= `\x00\x00\x00\x004Q\xfb`\x00\x00\x00\x005\x1d\x02`\x00\x00\x00\x0061\xdd`" +
-       "\x00\x00\x00\x006\xfc\xe4`\x00\x00\x00\x008\x1a\xf9\xe0\x00\x00\x00\x008\xdc\xc6`\x00\x00\x00\x009\xfa\xdb\xe0\x00\x00\x00\x00:\xbc\xa8`\x00\x00\x00\x00;ڽ\xe0\x00\x00\x00\x00<\xa5\xc4\xe0\x00\x00\x00\x00" +
-       "=\xba\x9f\xe0\x00\x00\x00\x00>\x85\xa6\xe0\x00\x00\x00\x00?\x9a\x81\xe0\x00\x00\x00\x00@e\x88\xe0\x00\x00\x00\x00A\x83\x9e`\x00\x00\x00\x00BEj\xe0\x00\x00\x00\x00Cc\x80`\x00\x00\x00\x00D%L\xe0" +
-       "\x00\x00\x00\x00ECb`\x00\x00\x00\x00F\x05.\xe0\x00\x00\x00\x00G#D`\x00\x00\x00\x00G\xeeK`\x00\x00\x00\x00I\x03&`\x00\x00\x00\x00I\xce-`\x00\x00\x00\x00J\xe3\b`\x00\x00\x00\x00" +
-       "K\xae\x0f`\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x01\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x06\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
-       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x06\x01\x00\x00\xa6d\x00\x00\x00\x00\xa8\xc0\x00\x04\x00\x00\xc4\xe0\x01\b\x00\x00\xb6\xd0\x00\f\x00\x00\xb6\xd0\x01\f\x00\x00\xa8\xc0\x01\x04" +
-       "\x00\x00\x9a\xb0\x00\x10LMT\x00+12\x00+14\x00+13\x00+11\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ0]*\x1bj\x02\x00\x00j\x02" +
-       "\x00\x00\f\x00\x1c\x00Asia/BishkekUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19~\x10\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1" +
-       " \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00" +
-       "\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0" +
-       "\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xbe\xa3\xc0\x00\x00\x00\x00)\xe770\x00\x00\x00\x00*ĥ \x00\x00\x00\x00+\xc7\x190\x00\x00\x00" +
-       "\x00,\xa4\x87 \x00\x00\x00\x00-\xa6\xfb0\x00\x00\x00\x00.\x84i \x00\x00\x00\x00/\x86\xdd0\x00\x00\x00\x000dK \x00\x00\x00\x001f\xbf0\x00\x00\x00\x002Mg\xa0\x00\x00\x00\x003=\x89" +
-       "\xd8\x00\x00\x00\x004RV\xc8\x00\x00\x00\x005\x1dk\xd8\x00\x00\x00\x00628\xc8\x00\x00\x00\x006\xfdM\xd8\x00\x00\x00\x008\x1bUH\x00\x00\x00\x008\xdd/\xd8\x00\x00\x00\x009\xfb7H\x00\x00\x00" +
-       "\x00:\xbd\x11\xd8\x00\x00\x00\x00;\xdb\x19H\x00\x00\x00\x00<\xa6.X\x00\x00\x00\x00=\xba\xfbH\x00\x00\x00\x00>\x86\x10X\x00\x00\x00\x00?\x9a\xddH\x00\x00\x00\x00@e\xf2X\x00\x00\x00\x00A\x83\xf9" +
-       "\xc8\x00\x00\x00\x00BE\xd4X\x00\x00\x00\x00B\xfb\x92 \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
-       "\x01\x04\x01\x04\x01\x04\x01\x04\x03\x00\x00E\xf0\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\fLMT\x00+05\x00+07\x00+06\x00\n<+06" +
-       ">-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\n\x00\x1c\x00Asia/DubaiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1\xf2\x99\xa8\x01\x00\x003\xd8" +
-       "\x00\x00\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/" +
-       "RiyadhUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xd5\x1b6\xb4\x01\x00\x00+\xcc\x00\x00\x00\x00*0\x00\x04LMT\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11\x00\x1c\x00Asia/NovokuznetskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x18 \xc0\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o" +
-       "\x90\x00\x00\x00\x00\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00" +
-       "\x00\x1c\xacY\xb0\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0" +
-       "\xb0\x00\x00\x00\x00$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00" +
-       "\x00)\xd4\xc20\x00\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY" +
-       "0\x00\x00\x00\x001]\x84\xb0\x00\x00\x00\x002r_\xb0\x00\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00" +
-       "\x008\x1b@0\x00\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\v0\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xed" +
-       "0\x00\x00\x00\x00?\x9a\xc80\x00\x00\x00\x00@e\xcf0\x00\x00\x00\x00A\x83\xe4\xb0\x00\x00\x00\x00BE\xb10\x00\x00\x00\x00Ccư\x00\x00\x00\x00D%\x930\x00\x00\x00\x00EC\xa8\xb0\x00\x00\x00" +
-       "\x00F\x05u0\x00\x00\x00\x00G#\x8a\xb0\x00\x00\x00\x00G\ue470\x00\x00\x00\x00I\x03l\xb0\x00\x00\x00\x00I\xces\xb0\x00\x00\x00\x00J\xe3N\xb0\x00\x00\x00\x00K\xaeU\xb0\x00\x00\x00\x00L\xccy" +
-       "@\x00\x00\x00\x00M\x8eE\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x00Q\xc0\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n" +
-       "<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQT\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x1c\x00Asia/AqtauUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x94\xe0\xff" +
-       "\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b" +
-       "\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00" +
-       "\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)" +
-       "x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00" +
-       "\x00\x00\x000d\x83`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006" +
-       "\xfdT\xe0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00" +
-       "\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\x01\x02\x04\x02\x04\x02\x04" +
-       "\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x02\x00\x00/ \x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x00\f\x00\x00T`\x01\f\x00\x00FP\x01\bLMT" +
-       "\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x1c\x00Asia/Oms" +
-       "kUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06" +
-       "\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xb3@\xb6\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0" +
-       "\x00\x00\x00\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00" +
-       " l+\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@" +
-       "\x00\x00\x00\x00'\xf4\xee@\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)x\x95P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00+\xb4\xb2@\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00" +
-       "-\x94\x94@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x000dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0" +
-       "\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00" +
-       ";\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@" +
-       "\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0\x00\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00" +
-       "I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00D\xca\x00\x00\x00\x00FP\x00" +
-       "\x04\x00\x00bp\x01\b\x00\x00T`\x00\f\x00\x00T`\x01\f\x00\x00bp\x00\bLMT\x00+05\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQe\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00\x1c\x00Asia/AshkhabadUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x8dD\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\x9b_\t'\xff\xff\xff\xff\xa1\x12\xb1\xff\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b" +
        "\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xbf0\x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00" +
        "\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f" +
-       "\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x01\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x006\xbc\x00\x00\x00\x008@\x00\x04\x00\x00T`\x01\b\x00\x00FP\x00\f\x00\x00FP\x01\fLMT\x00+04\x00" +
-       "+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\v\x00\x1c\x00Asia/SaigonUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x05\x00\x00\x00" +
-       "\x15\xff\xff\xff\xff\x88\x8cC\x80\xff\xff\xff\xff\x91\xa3+\n\xff\xff\xff\xff\xcd5\xe6\x80\xff\xff\xff\xff\xd1Y\xcep\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xff\xd52\xbb\x10\xff\xff\xff\xff\xe4\xb6\xe4\x80\xff\xff\xff" +
-       "\xff\xed/\x98\x00\x00\x00\x00\x00\n=\xc7\x00\x01\x02\x03\x04\x02\x03\x02\x03\x02\x00\x00d\x00\x00\x00\x00\x00c\xf6\x00\x04\x00\x00bp\x00\t\x00\x00p\x80\x00\r\x00\x00~\x90\x00\x11LMT\x00PLMT" +
-       "\x00+07\x00+08\x00+09\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ)\x15II\xf3\x02\x00\x00\xf3\x02\x00\x00\r\x00\x1c\x00Asia/Sak" +
-       "halinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B" +
-       "\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff\x86\xf0\u0378\xff\xff\xff\xff\xd20\xb2\xf0\x00\x00\x00\x00\x15'7P\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00" +
-       "\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p" +
-       "\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00" +
-       "'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0" +
-       "\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x00" +
-       "4R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xfa\xf8\x00\x00\x00\x00\x00:\xbcĀ" +
-       "\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00" +
-       "BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D%i\x00\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xeeg\x80\x00\x00\x00\x00I\x03B\x80" +
-       "\x00\x00\x00\x00I\xceI\x80\x00\x00\x00\x00J\xe3$\x80\x00\x00\x00\x00K\xae+\x80\x00\x00\x00\x00L\xccA\x00\x00\x00\x00\x00M\x8e\r\x80\x00\x00\x00\x00TK\xba\xf0\x00\x00\x00\x00V\xf6\xb2\x00\x01\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x03" +
-       "\x05\x03\x00\x00\x85\xc8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\xa8\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x10LMT\x00+09\x00+12\x00+11\x00+10\x00\n<" +
-       "+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\x0e\x00\x1c\x00Asia/Hong_KongUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff\x85" +
-       "ic\x90\xff\xff\xff\xff\xcaM10\xff\xff\xff\xff\xcaۓ0\xff\xff\xff\xff\xcbKqx\xff\xff\xff\xffҠސ\xff\xff\xff\xff\xd3k׀\xff\xff\xff\xffԓX\xb8\xff\xff\xff\xff\xd5B\xb08\xff" +
-       "\xff\xff\xff\xd6s:\xb8\xff\xff\xff\xff\xd7>A\xb8\xff\xff\xff\xff\xd8.2\xb8\xff\xff\xff\xff\xd8\xf99\xb8\xff\xff\xff\xff\xda\x0e\x14\xb8\xff\xff\xff\xff\xda\xd9\x1b\xb8\xff\xff\xff\xff\xdb\xed\xf6\xb8\xff\xff\xff\xff\xdc" +
-       "\xb8\xfd\xb8\xff\xff\xff\xff\xdd\xcdظ\xff\xff\xff\xffޢ\x1a8\xff\xff\xff\xff߶\xf58\xff\xff\xff\xff\xe0\x81\xfc8\xff\xff\xff\xff\xe1\x96\xc9(\xff\xff\xff\xff\xe2Oi8\xff\xff\xff\xff\xe3v\xab(\xff" +
-       "\xff\xff\xff\xe4/K8\xff\xff\xff\xff\xe5_Ǩ\xff\xff\xff\xff\xe6\x0f-8\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea" +
-       "\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff" +
-       "\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15a(\xff\xff\xff\xff\xf9" +
-       "\x05`8\xff\xff\xff\xff\xf9\xf5C(\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00" +
-       "\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a" +
-       "&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00" +
-       "\x00\x00\x00\x12ol\xa8\x01\x02\x03\x04\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00k\n\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x01\b\x00\x00w\x88\x01\r\x00\x00~\x90\x00\x12LMT\x00HKT\x00HKST\x00H" +
-       "KWT\x00JST\x00\nHKT-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Asia/Phnom_Penh" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00" +
-       "\x00\x00\f\xff\xff\xff\xffV\xb6\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00BMT\x00+07\x00\n<+07>-7\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x1c\x00Asia/NicosiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x001\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xa5w\x1e\xb8\x00\x00\x00\x00\t\xed\xaf" +
-       "\xe0\x00\x00\x00\x00\nݒ\xd0\x00\x00\x00\x00\v\xfad\xe0\x00\x00\x00\x00\f\xbe\xc6P\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00\x00\x10uO\xd0\x00\x00\x00" +
-       "\x00\x11c\xfd`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\x19\xe0\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3`\x00\x00\x00\x00\x17\xf3\x86" +
-       "P\x00\x00\x00\x00\x18\xe3\x85`\x00\x00\x00\x00\x19\xd3hP\x00\x00\x00\x00\x1a\xc3g`\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00" +
-       "\x00\x1f|H\xd0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xed" +
-       "\xe0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00" +
-       "\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004-s" +
-       "\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062x\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x00\x00\x1fH\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10" +
-       ".5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd7e&uv\x02\x00\x00v\x02\x00\x00\f\x00\x1c\x00Asia/BaghdadUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x006\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x86\xb1\xdc" +
-       "\xff\xff\xff\xff\x9e0<\xe0\x00\x00\x00\x00\x170hP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xe8\xbdP\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbd\xc8@\x00\x00\x00\x00" +
-       "\x1c\xad\xc7P\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0" +
-       "\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf6x\x00\x00\x00\x00\x00(纀\x00\x00\x00\x00)\xd8\xfd\x00\x00\x00\x00\x00" +
-       "*\xca?\x80\x00\x00\x00\x00+\xba0\x80\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00-\x9bd\x00\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/|\x97\x80\x00\x00\x00\x000m\xda\x00\x00\x00\x00\x001_\x1c\x80" +
-       "\x00\x00\x00\x002P_\x00\x00\x00\x00\x003@P\x00\x00\x00\x00\x0041\x92\x80\x00\x00\x00\x005!\x83\x80\x00\x00\x00\x006\x12\xc6\x00\x00\x00\x00\x007\x02\xb7\x00\x00\x00\x00\x007\xf3\xf9\x80\x00\x00\x00\x00" +
-       "8\xe5<\x00\x00\x00\x00\x009\xd6~\x80\x00\x00\x00\x00:\xc6o\x80\x00\x00\x00\x00;\xb7\xb2\x00\x00\x00\x00\x00<\xa7\xa3\x00\x00\x00\x00\x00=\x98\xe5\x80\x00\x00\x00\x00>\x88ր\x00\x00\x00\x00?z\x19\x00" +
-       "\x00\x00\x00\x00@k[\x80\x00\x00\x00\x00A\\\x9e\x00\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00C=р\x00\x00\x00\x00D-\u0080\x00\x00\x00\x00E\x1f\x05\x00\x00\x00\x00\x00F\x0e\xf6\x00\x00\x00\x00\x00" +
-       "G\x008\x80\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00" +
-       ")\xa4\x00\x00\x00\x00)\xa0\x00\x04\x00\x00*0\x00\b\x00\x008@\x01\fLMT\x00BMT\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xa4Zߐ\xe6\x02\x00\x00\xe6\x02\x00\x00\x12\x00\x1c\x00Asia/SrednekolymskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x193\xe4\xff\xff\xff\xff\xb5\xa3\xa8\xe0\x00\x00\x00\x00\x15'" +
-       "7P\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00" +
-       "\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;" +
-       "\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00" +
-       "\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d" +
-       " \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00" +
-       "\x00\x008\x1b\a\xf0\x00\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85" +
-       "\xb4\xf0\x00\x00\x00\x00?\x9a\x8f\xf0\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D%Z\xf0\x00\x00\x00\x00ECpp\x00\x00" +
-       "\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I\xce;p\x00\x00\x00\x00J\xe3\x16p\x00\x00\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc" +
-       "2\xf0\x00\x00\x00\x00M\x8d\xffp\x00\x00\x00\x00TK\xac\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00\x90\x1c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa8\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\xa8\xc0\x00\bL" +
-       "MT\x00+10\x00+12\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQe\x1bb2w\x01\x00\x00w\x01\x00\x00\r\x00\x1c\x00Asia/" +
-       "AshgabatUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x19\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x8dD\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xbf0\x00\x00\x00\x00\x17\xf9\xf3\xa0\x00" +
-       "\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f" +
-       "|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00" +
-       "\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x00\x006\xbc" +
-       "\x00\x00\x00\x008@\x00\x04\x00\x00T`\x01\b\x00\x00FP\x00\f\x00\x00FP\x01\fLMT\x00+04\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x1c\x00Asia/KathmanduUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf2}\x84\x00\x00\x00\x00\x1e\x180\xa8\x01\x02\x00\x00O\xfc" +
-       "\x00\x00\x00\x00MX\x00\x04\x00\x00P\xdc\x00\nLMT\x00+0530\x00+0545\x00\n<+0545>-5:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x81z" +
-       "&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x1c\x00Asia/ChoibalsanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff\x86\xd3\xe7(\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00" +
-       "\x19\xda\xee\xe0\x00\x00\x00\x00\x1a\xcc?p\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x04`\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xe6`\x00\x00\x00\x00 k\xe5p" +
-       "\x00\x00\x00\x00![\xc8`\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xa8\xe0\x00\x00\x00\x00" +
-       "'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\x8a\xe0\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4l\xe0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x840\xe0" +
-       "\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]Lp\x00\x00\x00\x002M/`\x00\x00\x00\x003=.p\x00\x00\x00\x004-\x11`\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x00" +
-       "6\f\xf3`\x00\x00\x00\x00:饐\x00\x00\x00\x00;\xb4\x9e\x80\x00\x00\x00\x00<\xa4\x9d\x90\x00\x00\x00\x00=\x94\x80\x80\x00\x00\x00\x00>\x84\u007f\x90\x00\x00\x00\x00?tb\x80\x00\x00\x00\x00@da\x90" +
-       "\x00\x00\x00\x00ATD\x80\x00\x00\x00\x00BDC\x90\x00\x00\x00\x00C4&\x80\x00\x00\x00\x00D$%\x90\x00\x00\x00\x00E\x1dC\x00\x00\x00\x00\x00G\xef\xaa\xf0\x00\x00\x00\x00U\x15\x9a\xa0\x00\x00\x00\x00" +
-       "V\x05ap\x00\x00\x00\x00V\xf5|\xa0\x00\x00\x00\x00W\xe5Cp\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x00\x00kX\x00\x00\x00\x00bp\x00\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\f\x00\x00\x8c\xa0\x01\x10\x00\x00~\x90\x01\fLMT\x00+07\x00+08\x00+" +
-       "09\x00+10\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x1c\x00Asia/BangkokUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00" +
-       "\f\xff\xff\xff\xffV\xb6\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00BMT\x00+07\x00\n<+07>-7\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00Asia/ChungkingUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2" +
-       "\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff" +
-       "\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|" +
-       "\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00" +
-       "\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ)p\x1c" +
-       "X\xf1\x02\x00\x00\xf1\x02\x00\x00\x10\x00\x1c\x00Asia/NovosibirskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00C\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xdb\x19$\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00" +
-       "\x16\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0" +
-       "\x00\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00" +
-       "$+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20" +
-       "\x00\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00+\xfeN\x00\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\x94@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x00" +
-       "0dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0" +
-       "\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00" +
-       ">\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x00\x00\x00\x00BE\xbf@\x00\x00\x00\x00Cc\xd4\xc0\x00\x00\x00\x00D%\xa1@\x00\x00\x00\x00EC\xb6\xc0" +
-       "\x00\x00\x00\x00F\x05\x83@\x00\x00\x00\x00G#\x98\xc0\x00\x00\x00\x00G\xee\x9f\xc0\x00\x00\x00\x00I\x03z\xc0\x00\x00\x00\x00I\u0381\xc0\x00\x00\x00\x00J\xe3\\\xc0\x00\x00\x00\x00K\xaec\xc0\x00\x00\x00\x00" +
-       "L\xccy@\x00\x00\x00\x00M\x8eE\xc0\x00\x00\x00\x00TK\xf30\x00\x00\x00\x00W\x93\xcc\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x04\x01\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00M\xbc\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00" +
-       "\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ]S\xbb\x12\xac\x03\x00\x00\xac\x03\x00\x00\x0e\x00\x1c\x00" +
-       "Asia/FamagustaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00V\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa5w\x1e,\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\nݒ\xd0\x00\x00\x00\x00\v\xfad\xe0\x00\x00\x00\x00\f\xbe\xc6P\x00\x00\x00" +
-       "\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00\x00\x10uO\xd0\x00\x00\x00\x00\x11c\xfd`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\x19\xe0\x00\x00\x00\x00\x143\xc2" +
-       "P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3`\x00\x00\x00\x00\x17\xf3\x86P\x00\x00\x00\x00\x18\xe3\x85`\x00\x00\x00\x00\x19\xd3hP\x00\x00\x00\x00\x1a\xc3g`\x00\x00\x00" +
-       "\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L)" +
-       "\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00" +
-       "\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000du" +
-       "P\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00" +
-       "\x008\x1b\x94\x90\x00\x00\x00\x008\xdda\x10\x00\x00\x00\x009\xfbv\x90\x00\x00\x00\x00:\xbdC\x10\x00\x00\x00\x00;\xdbX\x90\x00\x00\x00\x00<\xa6_\x90\x00\x00\x00\x00=\xbb:\x90\x00\x00\x00\x00>\x86A" +
-       "\x90\x00\x00\x00\x00?\x9b\x1c\x90\x00\x00\x00\x00@f#\x90\x00\x00\x00\x00A\x849\x10\x00\x00\x00\x00BF\x05\x90\x00\x00\x00\x00Cd\x1b\x10\x00\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00" +
-       "\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿" +
-       "\x90\x00\x00\x00\x00M\x8e\x8c\x10\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S7l\x90\x00\x00\x00" +
-       "\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V,)\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xd0\u007f\xd0\x00\x00\x00\x00Y\xf5(\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x02\x00\x00\x1f\xd4\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x00\rLMT\x00EEST\x00EET\x00+03\x00\nEET-2EE" +
-       "ST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\f\x00\x1c\x00Asia/Ran" +
-       "goonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00" +
-       "\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffV\xb6\x89\xd1\xff\xff\xff\xff\xa1\xf2sQ\xff\xff\xff\xff\xcb\xf2\xfc\x18\xff\xff\xff\xffњg\xf0\x01\x02\x03\x02\x00\x00Z/\x00\x00\x00\x00Z/\x00\x04\x00\x00[h\x00" +
-       "\b\x00\x00~\x90\x00\x0eLMT\x00RMT\x00+0630\x00+09\x00\n<+0630>-6:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x84)\r\xbd\xec\x00\x00" +
-       "\x00\xec\x00\x00\x00\x10\x00\x1c\x00Asia/Ho_Chi_MinhUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x88\x8cC\x80\xff\xff\xff\xff\x91\xa3+\n\xff\xff\xff\xff\xcd5\xe6\x80\xff\xff\xff\xff\xd1Y\xcep" +
-       "\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xff\xd52\xbb\x10\xff\xff\xff\xff\xe4\xb6\xe4\x80\xff\xff\xff\xff\xed/\x98\x00\x00\x00\x00\x00\n=\xc7\x00\x01\x02\x03\x04\x02\x03\x02\x03\x02\x00\x00d\x00\x00\x00\x00\x00c\xf6\x00" +
-       "\x04\x00\x00bp\x00\t\x00\x00p\x80\x00\r\x00\x00~\x90\x00\x11LMT\x00PLMT\x00+07\x00+08\x00+09\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x1c\x00Atlantic/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0e\x00\x1c\x00Atlantic/FaroeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x8bm\xa4X\x00\x00\x00\x00\x15#\xeb\x90\x00" +
-       "\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c" +
-       "\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00" +
-       "\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*" +
-       "\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xf9\xa8\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\bLMT\x00WET\x00WES" +
-       "T\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00A" +
-       "tlantic/CanaryUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa6\x04\\\xf0\xff\xff\xff\xff\xd4A\xf7 \x00\x00\x00\x00\x13M6\x00\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00" +
-       "\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae" +
-       "\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00" +
-       "\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a" +
-       "\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xf1\x90\x00\x00\xff\xff\xf1\xf0\x00\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x01\fLMT\x00" +
-       "-01\x00WET\x00WEST\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe7\xcf^\xb0\x15\x03" +
-       "\x00\x00\x15\x03\x00\x00\x10\x00\x1c\x00Atlantic/StanleyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00" +
+       "\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000du" +
+       "P\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00" +
+       "\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\t" +
+       "P\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x00\x00\x00\x00BE\xcdP\x00\x00\x00\x00Cc\xe2\xd0\x00\x00\x00\x00D%\xafP\x00\x00\x00\x00EC\xc4\xd0\x00\x00\x00" +
+       "\x00F\x05\x91P\x00\x00\x00\x00G#\xa6\xd0\x00\x00\x00\x00G\xee\xad\xd0\x00\x00\x00\x00I\x03\x88\xd0\x00\x00\x00\x00IΏ\xd0\x00\x00\x00\x00J\xe3j\xd0\x00\x00\x00\x00K\xaeq\xd0\x00\x00\x00\x00L̇" +
+       "P\x00\x00\x00\x00M\x8eS\xd0\x00\x00\x00\x00TL\x01@\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x06\x04\x00\x008\xd9\x00\x00\x00\x004\xc1\x00\x04\x00\x008@\x00\b\x00\x00T`\x01\f\x00\x00FP\x00\x10\x00\x00FP\x01\x10\x00" +
+       "\x00T`\x00\fLMT\x00PMT\x00+04\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00" +
+       "\f\x00\x1c\x00Asia/RangoonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffV\xb6\x89\xd1\xff\xff\xff\xff\xa1\xf2sQ\xff\xff\xff\xff\xcb\xf2\xfc\x18\xff\xff\xff\xffњg\xf0\x01\x02\x03\x02\x00\x00Z/\x00" +
+       "\x00\x00\x00Z/\x00\x04\x00\x00[h\x00\b\x00\x00~\x90\x00\x0eLMT\x00RMT\x00+0630\x00+09\x00\n<+0630>-6:30\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9Rǯ\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x1c\x00Asia/ManilaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x14\xe1\xdc\x10\xff\xff\xff\xff{\x1f?\x90\xff\xff\xff\xff\xc1\x9c\xf4\x80\xff" +
+       "\xff\xff\xff\xc2\x160p\xff\xff\xff\xff\xcb\xf2\xe7\x00\xff\xff\xff\xffЩ%p\xff\xff\xff\xff\xe2l9\x00\xff\xff\xff\xff\xe2բ\xf0\x00\x00\x00\x00\x0fuF\x80\x00\x00\x00\x00\x10fz\xf0\x01\x03\x02\x03\x04" +
+       "\x03\x02\x03\x02\x03\xff\xff\x1f\xf0\x00\x00\x00\x00qp\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\fLMT\x00PDT\x00PST\x00JST\x00\nPST-8\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacaoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x85i[\x8e\xff\xff\xff\xff\xcbGu\xf0\xff\xff\xff" +
+       "\xff\xcb\xf2\xca\xe0\xff\xff\xff\xff\xcc\xfb\xbaP\xff\xff\xff\xff\xcd\xd3\xfe`\xff\xff\xff\xffΝ\xa5\xd0\xff\xff\xff\xff\xd2azp\xff\xff\xff\xff\xd3x\xf8p\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5K\xab" +
+       "p\xff\xff\xff\xff\xd6tL\xf0\xff\xff\xff\xff\xd7?S\xf0\xff\xff\xff\xff\xd8/D\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xda\r\xd5p\xff\xff\xff\xff\xda\xd8\xdcp\xff\xff\xff\xff\xdb\xed\xb7p\xff\xff\xff" +
+       "\xffܸ\xbep\xff\xff\xff\xff\xdd\xce\xea\xf0\xff\xff\xff\xffޡ\xda\xf0\xff\xff\xff\xff߶\xb5\xf0\xff\xff\xff\xff\xe0\x81\xbc\xf0\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe3vy" +
+       "\xf0\xff\xff\xff\xff\xe4/\v\xf0\xff\xff\xff\xff\xe5_\x96p\xff\xff\xff\xff\xe6\x0e\xed\xf0\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff" +
+       "\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3" +
+       "\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15S\x18\xff\xff\xff" +
+       "\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf55\x18\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#" +
+       "\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00" +
+       "\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b9" +
+       "8\x00\x00\x00\x00\x12ol\xa8\x01\x03\x02\x03\x02\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
+       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00jr\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\x10LMT\x00CST\x00+1" +
+       "0\x00+09\x00CDT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RS\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00\x1c\x00Asia/AlmatyUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x05\x00\x00\x00" +
+       "\x10\xff\xff\xff\xff\xaa\x19{\xdc\xff\xff\xff\xff\xb5\xa3\xef0\x00\x00\x00\x00\x15'}\xa0\x00\x00\x00\x00\x16\x18\xb2\x10\x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xe5\x90\x00\x00\x00\x00\x18\xe9\xe4\xa0\x00\x00\x00" +
+       "\x00\x19\xdb\x19\x10\x00\x00\x00\x00\x1a\xcci\xa0\x00\x00\x00\x00\x1b\xbcv\xc0\x00\x00\x00\x00\x1c\xacg\xc0\x00\x00\x00\x00\x1d\x9cX\xc0\x00\x00\x00\x00\x1e\x8cI\xc0\x00\x00\x00\x00\x1f|:\xc0\x00\x00\x00\x00 l+" +
+       "\xc0\x00\x00\x00\x00!\\\x1c\xc0\x00\x00\x00\x00\"L\r\xc0\x00\x00\x00\x00#;\xfe\xc0\x00\x00\x00\x00$+\xef\xc0\x00\x00\x00\x00%\x1b\xe0\xc0\x00\x00\x00\x00&\v\xd1\xc0\x00\x00\x00\x00'\x04\xfd@\x00\x00\x00" +
+       "\x00'\xf4\xee@\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)x\x95P\x00\x00\x00\x00)\xd4\xd0@\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00+\xb4\xb2@\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\x94" +
+       "@\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x000dg@\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x002rm\xc0\x00\x00\x00\x003=t\xc0\x00\x00\x00\x004RO\xc0\x00\x00\x00" +
+       "\x005\x1dV\xc0\x00\x00\x00\x00621\xc0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1bN@\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb0@\x00\x00\x00\x00:\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x12" +
+       "@\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xf4@\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xd6@\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00A\x83\xf2\xc0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00H$\x00\x00\x00\x00FP\x00\x04\x00\x00bp\x01\b\x00\x00" +
+       "T`\x00\f\x00\x00T`\x01\fLMT\x00+05\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RѾ\xa8\xc7u\x02\x00\x00u\x02\x00" +
+       "\x00\f\x00\x1c\x00Asia/TbilisiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xba\x01\xff\xff\xff\xff\xaa\x19\x9a\x01\xff\xff\xff\xff\xe7\xda\fP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0" +
+       "\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00" +
+       "\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0" +
+       "\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xc1@\x00\x00\x00\x00" +
+       "+\xb4\xc0P\x00\x00\x00\x00,\xa4\xa3@\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/tv@\x00\x00\x00\x000dY0\x00\x00\x00\x001]\x92\xc0\x00\x00\x00\x003=f\xb0" +
+       "\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dV\xc0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd8\xc0\x00\x00\x00\x008\x1b@0\x00\x00\x00\x008\xdd\x1a\xc0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00" +
+       ":\xbc\xfc\xc0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\x19@\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xfb@\x00\x00\x00\x00?\x9a\xc80\x00\x00\x00\x00@e\xdd@\x00\x00\x00\x00@\xddǰ" +
+       "\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x02\x05\x02\x05\x02\x05\x04\x03\x04\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x05\x02\x04\x00\x00)\xff\x00\x00\x00\x00)\xff\x00\x04\x00\x00*0\x00\t\x00\x00FP\x01\r\x00\x008@\x00\x11\x00\x008@\x01\x11LMT\x00TBMT\x00+03\x00+05" +
+       "\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Asia/Phnom_PenhU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00" +
+       "\x00\f\xff\xff\xff\xffV\xb6\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00BMT\x00+07\x00\n<+07>-7\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacauUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x85i[\x8e\xff\xff\xff\xff\xcbGu\xf0\xff\xff" +
+       "\xff\xff\xcb\xf2\xca\xe0\xff\xff\xff\xff\xcc\xfb\xbaP\xff\xff\xff\xff\xcd\xd3\xfe`\xff\xff\xff\xffΝ\xa5\xd0\xff\xff\xff\xff\xd2azp\xff\xff\xff\xff\xd3x\xf8p\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5K" +
+       "\xabp\xff\xff\xff\xff\xd6tL\xf0\xff\xff\xff\xff\xd7?S\xf0\xff\xff\xff\xff\xd8/D\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xda\r\xd5p\xff\xff\xff\xff\xda\xd8\xdcp\xff\xff\xff\xff\xdb\xed\xb7p\xff\xff" +
+       "\xff\xffܸ\xbep\xff\xff\xff\xff\xdd\xce\xea\xf0\xff\xff\xff\xffޡ\xda\xf0\xff\xff\xff\xff߶\xb5\xf0\xff\xff\xff\xff\xe0\x81\xbc\xf0\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe3v" +
+       "y\xf0\xff\xff\xff\xff\xe4/\v\xf0\xff\xff\xff\xff\xe5_\x96p\xff\xff\xff\xff\xe6\x0e\xed\xf0\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff" +
+       "\xff\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W" +
+       "\xb3\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15S\x18\xff\xff" +
+       "\xff\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf55\x18\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e" +
+       "#\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00" +
+       "\x00\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b" +
+       "98\x00\x00\x00\x00\x12ol\xa8\x01\x03\x02\x03\x02\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
+       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00jr\x00\x00\x00\x00p\x80\x00\x04\x00\x00\x8c\xa0\x01\b\x00\x00~\x90\x00\f\x00\x00~\x90\x01\x10LMT\x00CST\x00+" +
+       "10\x00+09\x00CDT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00\x1c\x00Asia/Magadan" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\x06\x00" +
+       "\x00\x00\x10\xff\xff\xff\xff\xaa\x196\xa0\xff\xff\xff\xff\xb5\xa3\xa8\xe0\x00\x00\x00\x00\x15'7P\x00\x00\x00\x00\x16\x18k\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00" +
+       "\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 " +
+       "k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00" +
+       "\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-" +
+       "\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00" +
+       "\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\a\xf0\x00\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;" +
+       "\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x8f\xf0\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00" +
+       "\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D%Z\xf0\x00\x00\x00\x00ECpp\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I" +
+       "\xce;p\x00\x00\x00\x00J\xe3\x16p\x00\x00\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x00\x00\x00\x00TK\xac\xe0\x00\x00\x00\x00W\x1b\x9c\x00\x01\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x01\x03\x00\x00\x8d" +
+       "`\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa8\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\xa8\xc0\x00\bLMT\x00+10\x00+12\x00+11\x00\n<+11>-11\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\n\x00\x1c\x00Asia/QatarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xa1\xf2\x9d0\x00\x00\x00\x00\x04\x8a\x92\xc0\x01\x02" +
+       "\x00\x000P\x00\x00\x00\x008@\x00\x04\x00\x00*0\x00\bLMT\x00+04\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9a\x1a\xdc\xca\xdc\x00\x00" +
+       "\x00\xdc\x00\x00\x00\r\x00\x1c\x00Asia/CalcuttaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff&\xba\x18(\xff\xff\xff\xffC\xe7\xeb0\xff\xff\xff\xff\x87\x9d\xbc\xba\xff\xff\xff\xff\xcaی(\xff\xff\xff" +
+       "\xff\xcc\x05q\x18\xff\xff\xff\xff̕2\xa8\xff\xff\xff\xff\xd2t\x12\x98\x01\x02\x03\x04\x03\x04\x03\x00\x00R\xd8\x00\x00\x00\x00R\xd0\x00\x04\x00\x00KF\x00\b\x00\x00MX\x00\f\x00\x00[h\x01\x10LM" +
+       "T\x00HMT\x00MMT\x00IST\x00+0630\x00\nIST-5:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x10\x00\x1c\x00" +
+       "Asia/UlaanbaatarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x86\xd3\xeeL\x00\x00\x00\x00\x0f\vܐ\x00\x00\x00\x00\x18\xe9Ȁ\x00\x00\x00\x00\x19\xda\xfc\xf0\x00\x00\x00\x00\x1a\xccM\x80\x00" +
+       "\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac/\x80\x00\x00\x00\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x11\x80\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xf3\x80\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"" +
+       "KՀ\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xb7\x80\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x99\x80\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xe4\x98\xf0\x00" +
+       "\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000" +
+       "d \xf0\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002M=p\x00\x00\x00\x003=<\x80\x00\x00\x00\x004-\x1fp\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\r\x01p\x00\x00\x00\x00:鳠\x00" +
+       "\x00\x00\x00;\xb4\xac\x90\x00\x00\x00\x00<\xa4\xab\xa0\x00\x00\x00\x00=\x94\x8e\x90\x00\x00\x00\x00>\x84\x8d\xa0\x00\x00\x00\x00?tp\x90\x00\x00\x00\x00@do\xa0\x00\x00\x00\x00ATR\x90\x00\x00\x00\x00B" +
+       "DQ\xa0\x00\x00\x00\x00C44\x90\x00\x00\x00\x00D$3\xa0\x00\x00\x00\x00E\x1dQ\x10\x00\x00\x00\x00U\x15\x9a\xa0\x00\x00\x00\x00V\x05ap\x00\x00\x00\x00V\xf5|\xa0\x00\x00\x00\x00W\xe5Cp\x01" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00d4\x00\x00\x00\x00bp\x00" +
+       "\x04\x00\x00~\x90\x01\b\x00\x00p\x80\x00\fLMT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa4Zߐ\xe6\x02\x00\x00" +
+       "\xe6\x02\x00\x00\x12\x00\x1c\x00Asia/SrednekolymskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00F\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x11\xbc\xff\xff\xff\xff\x93D_<\xff\xff\xff\xff\xc3OZ\xc0\xff\xff\xff\xff\xc46\x03" +
-       "0\xff\xff\xff\xff\xc5/<\xc0\xff\xff\xff\xff\xc6\x15\xe50\xff\xff\xff\xff\xc7\x18Y@\xff\xff\xff\xff\xc7\xff\x01\xb0\xff\xff\xff\xff\xc8\xf8;@\xff\xff\xff\xff\xc9\xde\xe3\xb0\xff\xff\xff\xff\xca\xd8\x1d@\xff\xff\xff" +
-       "\xff˾Ű\xff\xff\xff\xff̷\xff@\xff\xff\xff\xff\xcd6\x810\x00\x00\x00\x00\x19\x11\xfe@\x00\x00\x00\x00\x19Ӽ\xb0\x00\x00\x00\x00\x1a\xf1\xc4 \x00\x00\x00\x00\x1b\xaad0\x00\x00\x00\x00\x1cѦ" +
-       " \x00\x00\x00\x00\x1d\x8aF0\x00\x00\x00\x00\x1e\xa8[\xb0\x00\x00\x00\x00\x1fj6@\x00\x00\x00\x00 \x88=\xb0\x00\x00\x00\x00!J\x18@\x00\x00\x00\x00\"h\x1f\xb0\x00\x00\x00\x00#)\xfa@\x00\x00\x00" +
-       "\x00$H\x01\xb0\x00\x00\x00\x00%\t\xdc@\x00\x00\x00\x00&1\x1e0\x00\x00\x00\x00&\xe9\xbe@\x00\x00\x00\x00(\x11\x000\x00\x00\x00\x00(\xd2\xda\xc0\x00\x00\x00\x00)\xf0\xe20\x00\x00\x00\x00*\xb2\xbc" +
-       "\xc0\x00\x00\x00\x00+\xd0\xc40\x00\x00\x00\x00,\x92\x9e\xc0\x00\x00\x00\x00-\xb0\xa60\x00\x00\x00\x00.r\x80\xc0\x00\x00\x00\x00/\x90\x880\x00\x00\x00\x000Rb\xc0\x00\x00\x00\x001y\xa4\xb0\x00\x00\x00" +
-       "\x002;\u007f@\x00\x00\x00\x003Y\x86\xb0\x00\x00\x00\x004\x1ba@\x00\x00\x00\x0059h\xb0\x00\x00\x00\x005\xfbC@\x00\x00\x00\x007\x19J\xb0\x00\x00\x00\x007\xdb%@\x00\x00\x00\x008\xf9," +
-       "\xb0\x00\x00\x00\x009\xbb\a@\x00\x00\x00\x00:\xd9*\xd0\x00\x00\x00\x00;\x91\xca\xe0\x00\x00\x00\x00<\xc2GP\x00\x00\x00\x00=q\xac\xe0\x00\x00\x00\x00>\xa2)P\x00\x00\x00\x00?Z\xc9`\x00\x00\x00" +
-       "\x00@\x82\vP\x00\x00\x00\x00A:\xab`\x00\x00\x00\x00Ba\xedP\x00\x00\x00\x00C\x1a\x8d`\x00\x00\x00\x00DA\xcfP\x00\x00\x00\x00D\xfao`\x00\x00\x00\x00F!\xb1P\x00\x00\x00\x00F\xdaQ" +
-       "`\x00\x00\x00\x00H\n\xcd\xd0\x00\x00\x00\x00H\xc3m\xe0\x00\x00\x00\x00I\xea\xaf\xd0\x00\x00\x00\x00J\xa3O\xe0\x00\x00\x00\x00Kʑ\xd0\x00\x00\x00\x00L\x831\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x05\x04\x05\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\xff" +
-       "\xff\xc9\xc4\x00\x00\xff\xff\xc9\xc4\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\bLMT\x00SMT\x00-03\x00-04\x00-02\x00\n<-03" +
-       ">3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9b\xe9\xf4\x9a\xf9\x02\x00\x00\xf9\x02\x00\x00\x10\x00\x1c\x00Atlantic/BermudaUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\xb4\xc3\x1d\xe6" +
-       "\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00\x00\x00\x00" +
-       "\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0" +
-       "\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00" +
-       "\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0" +
-       "\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00\x00\x00\x00" +
-       "*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001gY\xe0" +
-       "\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x00" +
-       "8\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?\x9bT\xd0" +
-       "\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\xff\xff\xc3:\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xd5\xd0\x01\bLMT\x00AST\x00ADT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x0f-\xadׄ\x00\x00\x00\x84\x00\x00\x00\x16\x00\x1c\x00Atlantic/South_GeorgiaUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xffi\x86\xfd" +
-       "\xc0\x01\xff\xff\xdd\xc0\x00\x00\xff\xff\xe3\xe0\x00\x04LMT\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00" +
-       "Atlantic/St_HelenaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x12\x00\x1c\x00Atlantic/Jan_MayenUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff\xff\x9b" +
-       "'\xe3\x00\xff\xff\xff\xff\x9b\xd4{`\xff\xff\xff\xffȷM`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff" +
-       "\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff\xed\x98=\x10\xff\xff\xff\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff\xff\xf0" +
-       "h\x10\x10\xff\xff\xff\xff\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10\xff\xff\xff\xff\xf5\x17\xc5\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06\x10\xff" +
-       "\xff\xff\xff\xf7\xf0Ґ\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18" +
-       "㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00" +
-       "\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'" +
-       "\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00" +
-       "\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00" +
-       "\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0f\x00\x1c\x00At" +
-       "lantic/FaeroeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x8bm\xa4X\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00" +
-       "\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10" +
-       "\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00" +
-       "'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ" +
-       "\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\xff\xff\xf9\xa8\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\bLMT\x00WET\x00WEST\x00\nWET0WEST,M3.5.0/1,M10.5." +
-       "0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\x12\x00\x1c\x00Atlantic/ReykjavikUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x8b`\x83" +
-       "\xa0\xff\xff\xff\xff\x9c\x91\x1e\x00\xff\xff\xff\xff\x9dш\x90\xff\xff\xff\xff\x9erQ\x80\xff\xff\xff\xff\x9f\xd5\x03\x10\xff\xff\xff\xff\xa0S\x85\x00\xff\xff\xff\xff\xa1\xb66\x90\xff\xff\xff\xff\xa4<'\x80\xff\xff\xff" +
-       "\xff\xa4\xb9t\x10\xff\xff\xff\xff\xc6M\x1a\x00\xff\xff\xff\xff\xc7=' \xff\xff\xff\xff\xc7\xda\x17\xb0\xff\xff\xff\xff\xc9&C\xa0\xff\xff\xff\xff\xc9\xc3& \xff\xff\xff\xff\xcb\x06%\xa0\xff\xff\xff\xffˬB" +
-       "\xa0\xff\xff\xff\xff\xcc\xdc\xcd \xff\xff\xff\xff͌$\xa0\xff\xff\xff\xffμ\xaf \xff\xff\xff\xff\xcfl\x06\xa0\xff\xff\xff\xffМ\x91 \xff\xff\xff\xff\xd1K\xe8\xa0\xff\xff\xff\xff҅\xad\xa0\xff\xff\xff" +
-       "\xff\xd3+ʠ\xff\xff\xff\xff\xd4e\x8f\xa0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6Eq\xa0\xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8%S\xa0\xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep" +
-       " \xff\xff\xff\xff\xda\xd9w \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xce4 \xff\xff\xff\xffޢu\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff" +
-       "\xff\xe1\x8d\xf8 \xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3m\xda \xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe5M\xbc \xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe76ؠ\xff\xff\xff\xff\xe8\v\x1a" +
-       " \xff\xff\xff\xff\xe9\x16\xba\xa0\xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xf6\x9c\xa0\xff\xff\xff\xff\xeb\xca\xde \xff\xff\xff\xff\xec\xd6~\xa0\xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\xee\xb6`\xa0\xff\xff\xff" +
-       "\xff\uf2a2 \xff\xff\xff\xff\xf0\x96B\xa0\xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6?#" +
-       " \xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xf3F\xa0\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xd3(\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc\xbcE \x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x03\xff\xff\xeb`\x00\x00\x00\x00\x00\x00\x01\x04\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\fLMT\x00+00\x00-01\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\u0097N\xad\xaf\x00\x00\x00\xaf\x00\x00\x00\x13\x00\x1c\x00Atlantic/Cape_VerdeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x92檠\xff\xff\xff\xff̕\x9c \xff" +
-       "\xff\xff\xff\xd2t|\x10\x00\x00\x00\x00\v\x17\xf7@\x01\x02\x01\x03\xff\xff\xe9\xf4\x00\x00\xff\xff\xe3\xe0\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xf1\xf0\x00\bLMT\x00-02\x00-01\x00\n<-01" +
-       ">1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQW\x99\x9d\v\x9b\x05\x00\x00\x9b\x05\x00\x00\x0f\x00\x1c\x00Atlantic/AzoresUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\a\x00\x00\x00\x18\xff\xff\xff\xff^=\x1b\x90\xff" +
-       "\xff\xff\xff\x92檠\xff\xff\xff\xff\x9bK\x89\x90\xff\xff\xff\xff\x9b\xfe\xe3\xa0\xff\xff\xff\xff\x9c\x9d\t\x90\xff\xff\xff\xff\x9dɟ\x90\xff\xff\xff\xff\x9e\u007f\x8e\x90\xff\xff\xff\xff\x9f\xaa\xd3\x10\xff\xff\xff\xff\xa0" +
-       "_p\x90\xff\xff\xff\xff\xa1\x8c\x06\x90\xff\xff\xff\xff\xa2A\xf5\x90\xff\xff\xff\xff\xa3n\x8b\x90\xff\xff\xff\xff\xa4#)\x10\xff\xff\xff\xff\xa5O\xbf\x10\xff\xff\xff\xff\xaa\x06\v\x90\xff\xff\xff\xff\xaa\xf4\xab\x10\xff" +
-       "\xff\xff\xff\xad\xc9\xc4\x10\xff\xff\xff\xff\xae\xa7@\x10\xff\xff\xff\xff\xaf\xa0k\x90\xff\xff\xff\xff\xb0\x87\"\x10\xff\xff\xff\xff\xb1\x89\x88\x10\xff\xff\xff\xff\xb2p>\x90\xff\xff\xff\xff\xb3r\xa4\x90\xff\xff\xff\xff\xb4" +
-       "P \x90\xff\xff\xff\xff\xb72h\x90\xff\xff\xff\xff\xb8\x0f\xe4\x90\xff\xff\xff\xff\xb8\xffՐ\xff\xff\xff\xff\xb9\xefƐ\xff\xff\xff\xff\xbc\xc8\xd4\x10\xff\xff\xff\xff\xbd\xb8\xc5\x10\xff\xff\xff\xff\xbe\x9f{\x90\xff" +
-       "\xff\xff\xff\xbf\x98\xa7\x10\xff\xff\xff\xff\xc0\x9b\r\x10\xff\xff\xff\xff\xc1x\x89\x10\xff\xff\xff\xff\xc2hz\x10\xff\xff\xff\xff\xc3Xk\x10\xff\xff\xff\xff\xc4?!\x90\xff\xff\xff\xff\xc58M\x10\xff\xff\xff\xff\xc6" +
-       ":\xb3\x10\xff\xff\xff\xff\xc7XȐ\xff\xff\xff\xff\xc7\xd9\xfb\x90\xff\xff\xff\xff\xc9\x01K\x90\xff\xff\xff\xff\xc9\xf1<\x90\xff\xff\xff\xff\xca\xe2\u007f\x10\xff\xff\xff\xff˵o\x10\xff\xff\xff\xff\xcb\xec\xc0\x00\xff" +
-       "\xff\xff\xff̀h\x00\xff\xff\xff\xff\xccܿ\x10\xff\xff\xff\xff͕Q\x10\xff\xff\xff\xff\xcd\xc3g\x80\xff\xff\xff\xff\xcer\xbf\x00\xff\xff\xff\xff\xce\xc5ې\xff\xff\xff\xff\xcfu3\x10\xff\xff\xff\xff\xcf" +
-       "\xac\x84\x00\xff\xff\xff\xff\xd0R\xa1\x00\xff\xff\xff\xffХ\xbd\x90\xff\xff\xff\xff\xd1U\x15\x10\xff\xff\xff\xffьf\x00\xff\xff\xff\xff\xd22\x83\x00\xff\xff\xff\xff҅\x9f\x90\xff\xff\xff\xff\xd3Y\xe1\x10\xff" +
-       "\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd59\xed@\xff\xff\xff\xff\xd6)\xde@\xff\xff\xff\xff\xd7\x19\xcf@\xff\xff\xff\xff\xd8\t\xc0@\xff\xff\xff\xff\xd8\xf9\xb1@\xff\xff\xff\xff\xd9\xe9\xa2@\xff\xff\xff\xff\xdc" +
-       "\xb9u@\xff\xff\xff\xffݲ\xa0\xc0\xff\xff\xff\xffޢ\x91\xc0\xff\xff\xff\xffߒ\x82\xc0\xff\xff\xff\xff\xe0\x82s\xc0\xff\xff\xff\xff\xe1rd\xc0\xff\xff\xff\xff\xe2bU\xc0\xff\xff\xff\xff\xe3RF\xc0\xff" +
-       "\xff\xff\xff\xe4B7\xc0\xff\xff\xff\xff\xe52(\xc0\xff\xff\xff\xff\xe6\"\x19\xc0\xff\xff\xff\xff\xe7\x1bE@\xff\xff\xff\xff\xe8\v6@\xff\xff\xff\xff\xe8\xfb'@\xff\xff\xff\xff\xe9\xeb\x18@\xff\xff\xff\xff\xea" +
-       "\xdb\t@\xff\xff\xff\xff\xeb\xca\xfa@\xff\xff\xff\xff\xec\xba\xeb@\xff\xff\xff\xff\xed\xaa\xdc@\xff\xff\xff\xff\xee\x9a\xcd@\xff\xff\xff\xff\uf2be@\xff\xff\xff\xff\xf0z\xaf@\xff\xff\xff\xff\xf1j\xa0@\xff" +
-       "\xff\xff\xff\xf2c\xcb\xc0\xff\xff\xff\xff\xf3S\xbc\xc0\xff\xff\xff\xff\xf4C\xad\xc0\xff\xff\xff\xff\xf53\x9e\xc0\xff\xff\xff\xff\xf6#\x8f\xc0\xff\xff\xff\xff\xf7\x13\x80\xc0\xff\xff\xff\xff\xf8\x03q\xc0\xff\xff\xff\xff\xf8" +
-       "\xf3b\xc0\x00\x00\x00\x00\r\x9b)\x10\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T&\xa0\x00\x00\x00\x00\x13D\t\x90\x00" +
-       "\x00\x00\x00\x144\b\xa0\x00\x00\x00\x00\x15#\xf9\xa0\x00\x00\x00\x00\x16\x13\xea\xa0\x00\x00\x00\x00\x17\x03۠\x00\x00\x00\x00\x17\xf3̠\x00\x00\x00\x00\x18\xe3˰\x00\x00\x00\x00\x19Ӯ\xa0\x00\x00\x00\x00\x1a" +
-       "ß\xa0\x00\x00\x00\x00\x1b\xbc\xcb \x00\x00\x00\x00\x1c\xac\xbc \x00\x00\x00\x00\x1d\x9c\xad \x00\x00\x00\x00\x1e\x8c\x9e \x00\x00\x00\x00\x1f|\x8f \x00\x00\x00\x00 l\x80 \x00\x00\x00\x00!\\q \x00" +
-       "\x00\x00\x00\"Lb \x00\x00\x00\x00#<S \x00\x00\x00\x00$,D \x00\x00\x00\x00%\x1c5 \x00\x00\x00\x00&\f& \x00\x00\x00\x00'\x05Q\xa0\x00\x00\x00\x00'\xf5B\xa0\x00\x00\x00\x00(" +
-       "\xe53\xa0\x00\x00\x00\x00)\xd5$\xa0\x00\x00\x00\x00*\xc5\x15\xa0\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00" +
-       "\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x06\x04\x05\x04\x05\x04\x05\x04\xff\xff\xe7\xf0\x00\x00\xff\xff\xe5(\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xe3\xe0\x00\f\x00\x00\x00" +
-       "\x00\x01\x10\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\x14LMT\x00HMT\x00-01\x00-02\x00+00\x00WET\x00\n<-01>1<+00>,M3.5.0/0" +
-       ",M10.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x82\xfa Z\x9b\x05\x00\x00\x9b\x05\x00\x00\x10\x00\x1c\x00Atlantic/MadeiraUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\a\x00\x00\x00\x1d" +
-       "\xff\xff\xff\xff^=\x13X\xff\xff\xff\xff\x92朐\xff\xff\xff\xff\x9bK{\x80\xff\xff\xff\xff\x9b\xfeՐ\xff\xff\xff\xff\x9c\x9c\xfb\x80\xff\xff\xff\xff\x9dɑ\x80\xff\xff\xff\xff\x9e\u007f\x80\x80\xff\xff\xff\xff" +
-       "\x9f\xaa\xc5\x00\xff\xff\xff\xff\xa0_b\x80\xff\xff\xff\xff\xa1\x8b\xf8\x80\xff\xff\xff\xff\xa2A\xe7\x80\xff\xff\xff\xff\xa3n}\x80\xff\xff\xff\xff\xa4#\x1b\x00\xff\xff\xff\xff\xa5O\xb1\x00\xff\xff\xff\xff\xaa\x05\xfd\x80" +
-       "\xff\xff\xff\xff\xaa\xf4\x9d\x00\xff\xff\xff\xff\xadɶ\x00\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0]\x80\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff\xff" +
-       "\xb3r\x96\x80\xff\xff\xff\xff\xb4P\x12\x80\xff\xff\xff\xff\xb72Z\x80\xff\xff\xff\xff\xb8\x0fր\xff\xff\xff\xff\xb8\xffǀ\xff\xff\xff\xff\xb9︀\xff\xff\xff\xff\xbc\xc8\xc6\x00\xff\xff\xff\xff\xbd\xb8\xb7\x00" +
-       "\xff\xff\xff\xff\xbe\x9fm\x80\xff\xff\xff\xff\xbf\x98\x99\x00\xff\xff\xff\xff\xc0\x9a\xff\x00\xff\xff\xff\xff\xc1x{\x00\xff\xff\xff\xff\xc2hl\x00\xff\xff\xff\xff\xc3X]\x00\xff\xff\xff\xff\xc4?\x13\x80\xff\xff\xff\xff" +
-       "\xc58?\x00\xff\xff\xff\xff\xc6:\xa5\x00\xff\xff\xff\xff\xc7X\xba\x80\xff\xff\xff\xff\xc7\xd9\xed\x80\xff\xff\xff\xff\xc9\x01=\x80\xff\xff\xff\xff\xc9\xf1.\x80\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff˵a\x00" +
-       "\xff\xff\xff\xff\xcb\xec\xb1\xf0\xff\xff\xff\xff̀Y\xf0\xff\xff\xff\xff\xccܱ\x00\xff\xff\xff\xff͕C\x00\xff\xff\xff\xff\xcd\xc3Yp\xff\xff\xff\xff\xcer\xb0\xf0\xff\xff\xff\xff\xce\xc5̀\xff\xff\xff\xff" +
-       "\xcfu%\x00\xff\xff\xff\xffϬu\xf0\xff\xff\xff\xff\xd0R\x92\xf0\xff\xff\xff\xffХ\xaf\x80\xff\xff\xff\xff\xd1U\a\x00\xff\xff\xff\xffьW\xf0\xff\xff\xff\xff\xd22t\xf0\xff\xff\xff\xff҅\x91\x80" +
-       "\xff\xff\xff\xff\xd3Y\xd3\x00\xff\xff\xff\xff\xd4I\xc4\x00\xff\xff\xff\xff\xd59\xdf0\xff\xff\xff\xff\xd6)\xd00\xff\xff\xff\xff\xd7\x19\xc10\xff\xff\xff\xff\xd8\t\xb20\xff\xff\xff\xff\xd8\xf9\xa30\xff\xff\xff\xff" +
-       "\xd9\xe9\x940\xff\xff\xff\xffܹg0\xff\xff\xff\xffݲ\x92\xb0\xff\xff\xff\xffޢ\x83\xb0\xff\xff\xff\xffߒt\xb0\xff\xff\xff\xff\xe0\x82e\xb0\xff\xff\xff\xff\xe1rV\xb0\xff\xff\xff\xff\xe2bG\xb0" +
-       "\xff\xff\xff\xff\xe3R8\xb0\xff\xff\xff\xff\xe4B)\xb0\xff\xff\xff\xff\xe52\x1a\xb0\xff\xff\xff\xff\xe6\"\v\xb0\xff\xff\xff\xff\xe7\x1b70\xff\xff\xff\xff\xe8\v(0\xff\xff\xff\xff\xe8\xfb\x190\xff\xff\xff\xff" +
-       "\xe9\xeb\n0\xff\xff\xff\xff\xea\xda\xfb0\xff\xff\xff\xff\xeb\xca\xec0\xff\xff\xff\xff\xec\xba\xdd0\xff\xff\xff\xff\xed\xaa\xce0\xff\xff\xff\xff\ue6bf0\xff\xff\xff\xff\uf2b00\xff\xff\xff\xff\xf0z\xa10" +
-       "\xff\xff\xff\xff\xf1j\x920\xff\xff\xff\xff\xf2c\xbd\xb0\xff\xff\xff\xff\xf3S\xae\xb0\xff\xff\xff\xff\xf4C\x9f\xb0\xff\xff\xff\xff\xf53\x90\xb0\xff\xff\xff\xff\xf6#\x81\xb0\xff\xff\xff\xff\xf7\x13r\xb0\xff\xff\xff\xff" +
-       "\xf8\x03c\xb0\xff\xff\xff\xff\xf8\xf3T\xb0\x00\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T\x18\x90" +
-       "\x00\x00\x00\x00\x13C\xfb\x80\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㽠\x00\x00\x00\x00" +
-       "\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10" +
-       "\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00" +
-       "'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː" +
-       "\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xf0(\x00\x00\xff\xff\xf0(\x00\x04\x00\x00\x00\x00\x01\b" +
-       "\xff\xff\xf1\xf0\x00\f\x00\x00\x0e\x10\x01\x10\x00\x00\x0e\x10\x01\x14\x00\x00\x00\x00\x00\x19LMT\x00FMT\x00+00\x00-01\x00+01\x00WEST\x00WET\x00\nWET0WE" +
-       "ST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x1c\x00Australia/" +
-       "UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x85&'\x88\x03\x00\x00\x88\x03\x00\x00\x13\x00\x1c\x00Au" +
-       "stralia/MelbourneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x193\xe4\xff\xff\xff\xff\xb5\xa3\xa8\xe0\x00\x00\x00\x00\x15'7P\x00\x00\x00\x00\x16\x18k" +
+       "\xc0\x00\x00\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00" +
+       "\x00\x1d\x9c\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9" +
+       "p\x00\x00\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00" +
+       "\x00*\xc4z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]L" +
+       "p\x00\x00\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\a\xf0\x00\x00\x00" +
+       "\x008\xdc\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x8f" +
+       "\xf0\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D%Z\xf0\x00\x00\x00\x00ECpp\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00" +
+       "\x00G#Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I\xce;p\x00\x00\x00\x00J\xe3\x16p\x00\x00\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xff" +
+       "p\x00\x00\x00\x00TK\xac\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00\x90\x1c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa8\xc0\x01\b\x00\x00\x9a\xb0\x00\f\x00\x00\x9a\xb0\x01\f\x00\x00\xa8\xc0\x00\bLMT\x00+10\x00+1" +
+       "2\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xdb\xfa\xb5\xbeg\x02\x00\x00g\x02\x00\x00\v\x00\x1c\x00Asia/AqtobeUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x10" +
+       "\xff\xff\xff\xff\xaa\x19\x8eh\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00" +
+       "\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0" +
+       "\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00" +
+       "'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P" +
+       "\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x00" +
+       "5\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00\x00\x009\xfb>P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P" +
+       "\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e\xebP\x00\x00\x00\x00A\x84\x00\xd0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x005\x98\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T" +
+       "`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rw\x86\x8d^\x03\x03" +
+       "\x00\x00\x03\x03\x00\x00\r\x00\x1c\x00Asia/Ust-NeraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\b\x00\x00\x00\x18\xff\xff\xff\xff\xa1\xdbݺ\xff\xff\xff\xff\xb5\xa3\xc5\x00\x00\x00\x00\x00\x15'Sp\x00\x00\x00\x00\x16\x18k\xc0\x00\x00" +
+       "\x00\x00\x17\bj\xd0\x00\x00\x00\x00\x17\xf9\x9f@\x00\x00\x00\x00\x18\xe9\x9eP\x00\x00\x00\x00\x19\xda\xd2\xc0\x00\x00\x00\x00\x1a\xcc#P\x00\x00\x00\x00\x1b\xbc0p\x00\x00\x00\x00\x1c\xac!p\x00\x00\x00\x00\x1d\x9c" +
+       "\x12p\x00\x00\x00\x00\x1e\x8c\x03p\x00\x00\x00\x00\x1f{\xf4p\x00\x00\x00\x00 k\xe5p\x00\x00\x00\x00![\xd6p\x00\x00\x00\x00\"K\xc7p\x00\x00\x00\x00#;\xb8p\x00\x00\x00\x00$+\xa9p\x00\x00" +
+       "\x00\x00%\x1b\x9ap\x00\x00\x00\x00&\v\x8bp\x00\x00\x00\x00'\x04\xb6\xf0\x00\x00\x00\x00'\xf4\xa7\xf0\x00\x00\x00\x00(\xe4\xa7\x00\x00\x00\x00\x00)xO\x00\x00\x00\x00\x00)ԉ\xf0\x00\x00\x00\x00*\xc4" +
+       "z\xf0\x00\x00\x00\x00+\xb4k\xf0\x00\x00\x00\x00,\xa4\\\xf0\x00\x00\x00\x00-\x94M\xf0\x00\x00\x00\x00.\x84>\xf0\x00\x00\x00\x00/t/\xf0\x00\x00\x00\x000d \xf0\x00\x00\x00\x001]Lp\x00\x00" +
+       "\x00\x002r'p\x00\x00\x00\x003=.p\x00\x00\x00\x004R\tp\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xebp\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\a\xf0\x00\x00\x00\x008\xdc" +
+       "\xd4p\x00\x00\x00\x009\xfa\xe9\xf0\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xcb\xf0\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xad\xf0\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x8f\xf0\x00\x00" +
+       "\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xacp\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x8ep\x00\x00\x00\x00D%Z\xf0\x00\x00\x00\x00ECpp\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#" +
+       "Rp\x00\x00\x00\x00G\xeeYp\x00\x00\x00\x00I\x034p\x00\x00\x00\x00I\xce;p\x00\x00\x00\x00J\xe3\x16p\x00\x00\x00\x00K\xae\x1dp\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x00\x00" +
+       "\x00\x00Nm\xf4@\x00\x00\x00\x00TK\xba\xf0\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05\x06\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\a\x03\x06\x00\x00\x86F\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\b\x00\x00\x9a\xb0\x00\f\x00\x00\xa8\xc0\x01\x10\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0" +
+       "\x00\x14\x00\x00\xa8\xc0\x00\x10LMT\x00+08\x00+09\x00+11\x00+12\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RL\xe0\x91y" +
+       "\xe5\x02\x00\x00\xe5\x02\x00\x00\x10\x00\x1c\x00Asia/KrasnoyarskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf9\r\xf2\xff\xff\xff\xff\xb5\xa3\xe1 \x00\x00\x00\x00\x15'o\x90\x00\x00\x00\x00\x16" +
+       "\x18\xa4\x00\x00\x00\x00\x00\x17\b\xa3\x10\x00\x00\x00\x00\x17\xf9׀\x00\x00\x00\x00\x18\xe9\u0590\x00\x00\x00\x00\x19\xdb\v\x00\x00\x00\x00\x00\x1a\xcc[\x90\x00\x00\x00\x00\x1b\xbch\xb0\x00\x00\x00\x00\x1c\xacY\xb0\x00" +
+       "\x00\x00\x00\x1d\x9cJ\xb0\x00\x00\x00\x00\x1e\x8c;\xb0\x00\x00\x00\x00\x1f|,\xb0\x00\x00\x00\x00 l\x1d\xb0\x00\x00\x00\x00!\\\x0e\xb0\x00\x00\x00\x00\"K\xff\xb0\x00\x00\x00\x00#;\xf0\xb0\x00\x00\x00\x00$" +
+       "+\xe1\xb0\x00\x00\x00\x00%\x1bҰ\x00\x00\x00\x00&\vð\x00\x00\x00\x00'\x04\xef0\x00\x00\x00\x00'\xf4\xe00\x00\x00\x00\x00(\xe4\xdf@\x00\x00\x00\x00)x\x87@\x00\x00\x00\x00)\xd4\xc20\x00" +
+       "\x00\x00\x00*ij0\x00\x00\x00\x00+\xb4\xa40\x00\x00\x00\x00,\xa4\x950\x00\x00\x00\x00-\x94\x860\x00\x00\x00\x00.\x84w0\x00\x00\x00\x00/th0\x00\x00\x00\x000dY0\x00\x00\x00\x001" +
+       "]\x84\xb0\x00\x00\x00\x002r_\xb0\x00\x00\x00\x003=f\xb0\x00\x00\x00\x004RA\xb0\x00\x00\x00\x005\x1dH\xb0\x00\x00\x00\x0062#\xb0\x00\x00\x00\x006\xfd*\xb0\x00\x00\x00\x008\x1b@0\x00" +
+       "\x00\x00\x008\xdd\f\xb0\x00\x00\x00\x009\xfb\"0\x00\x00\x00\x00:\xbc\xee\xb0\x00\x00\x00\x00;\xdb\x040\x00\x00\x00\x00<\xa6\v0\x00\x00\x00\x00=\xba\xe60\x00\x00\x00\x00>\x85\xed0\x00\x00\x00\x00?" +
+       "\x9a\xc80\x00\x00\x00\x00@e\xcf0\x00\x00\x00\x00A\x83\xe4\xb0\x00\x00\x00\x00BE\xb10\x00\x00\x00\x00Ccư\x00\x00\x00\x00D%\x930\x00\x00\x00\x00EC\xa8\xb0\x00\x00\x00\x00F\x05u0\x00" +
+       "\x00\x00\x00G#\x8a\xb0\x00\x00\x00\x00G\ue470\x00\x00\x00\x00I\x03l\xb0\x00\x00\x00\x00I\xces\xb0\x00\x00\x00\x00J\xe3N\xb0\x00\x00\x00\x00K\xaeU\xb0\x00\x00\x00\x00L\xcck0\x00\x00\x00\x00M" +
+       "\x8e7\xb0\x00\x00\x00\x00TK\xe5 \x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x03\x00\x00W\x0e\x00\x00\x00\x00T`\x00\x04\x00\x00p\x80\x01\b\x00\x00bp\x00\f\x00\x00bp\x01\f\x00\x00p\x80\x00\bLMT\x00+06\x00" +
+       "+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\n\x00\x1c\x00Asia/SeoulUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x06\x00\x00\x00\x10" +
+       "\xff\xff\xff\xff\x8b\xd7\xf0x\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2C'\xf0\xff\xff\xff\xff\xd7e\x8fp\xff\xff\xff\xff\xd7\xee\x9d`\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd-\xe0\xff\xff\xff\xff" +
+       "\xda\u05ca\xf0\xff\xff\xff\xffۭ\x0f\xe0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xf1\xe0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe4k\xb7\xf8\xff\xff\xff\xff\xe5\x13\x18h\xff\xff\xff\xff\xe6b\x03x" +
+       "\xff\xff\xff\xff\xe7\x11L\xe8\xff\xff\xff\xff\xe8/px\xff\xff\xff\xff\xe8\xe7\xf4h\xff\xff\xff\xff\xea\x0fRx\xff\xff\xff\xff\xea\xc7\xd6h\xff\xff\xff\xff\xeb\xef4x\xff\xff\xff\xff째h\xff\xff\xff\xff" +
+       "\xed\xcf\x16x\xff\xff\xff\xff\ue1dah\xff\xff\xff\xff\xf05qx\x00\x00\x00\x00 \xa3`\x90\x00\x00\x00\x00!ng\x90\x00\x00\x00\x00\"\x83B\x90\x00\x00\x00\x00#NI\x90\x01\x02\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x04\x03\x04\x03\x04\x00\x00w\b\x00\x00\x00\x00w\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x01\f\x00\x00~\x90\x00\x04\x00\x00\x85\x98\x01\fLMT" +
+       "\x00KST\x00JST\x00KDT\x00\nKST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Ry\x19\xe0N\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/Brune" +
+       "iUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03" +
+       "\x00\x00\x00\x0e\xff\xff\xff\xff\xad\x8a\x02D\xff\xff\xff\xff\xbagG\x88\x01\x02\x00\x00k\xbc\x00\x00\x00\x00ix\x00\x04\x00\x00p\x80\x00\nLMT\x00+0730\x00+08\x00\n<+08>" +
+       "-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd7e&uv\x02\x00\x00v\x02\x00\x00\f\x00\x1c\x00Asia/BaghdadUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x006\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x86\xb1\xdc\xff\xff\xff\xff" +
+       "\x9e0<\xe0\x00\x00\x00\x00\x170hP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xe8\xbdP\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbd\xc8@\x00\x00\x00\x00\x1c\xad\xc7P" +
+       "\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00" +
+       "$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf6x\x00\x00\x00\x00\x00(纀\x00\x00\x00\x00)\xd8\xfd\x00\x00\x00\x00\x00*\xca?\x80" +
+       "\x00\x00\x00\x00+\xba0\x80\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00-\x9bd\x00\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/|\x97\x80\x00\x00\x00\x000m\xda\x00\x00\x00\x00\x001_\x1c\x80\x00\x00\x00\x00" +
+       "2P_\x00\x00\x00\x00\x003@P\x00\x00\x00\x00\x0041\x92\x80\x00\x00\x00\x005!\x83\x80\x00\x00\x00\x006\x12\xc6\x00\x00\x00\x00\x007\x02\xb7\x00\x00\x00\x00\x007\xf3\xf9\x80\x00\x00\x00\x008\xe5<\x00" +
+       "\x00\x00\x00\x009\xd6~\x80\x00\x00\x00\x00:\xc6o\x80\x00\x00\x00\x00;\xb7\xb2\x00\x00\x00\x00\x00<\xa7\xa3\x00\x00\x00\x00\x00=\x98\xe5\x80\x00\x00\x00\x00>\x88ր\x00\x00\x00\x00?z\x19\x00\x00\x00\x00\x00" +
+       "@k[\x80\x00\x00\x00\x00A\\\x9e\x00\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00C=р\x00\x00\x00\x00D-\u0080\x00\x00\x00\x00E\x1f\x05\x00\x00\x00\x00\x00F\x0e\xf6\x00\x00\x00\x00\x00G\x008\x80" +
+       "\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00)\xa4\x00\x00" +
+       "\x00\x00)\xa0\x00\x04\x00\x00*0\x00\b\x00\x008@\x01\fLMT\x00BMT\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R`\xc9\xd4" +
+       "\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x1c\x00Asia/Ujung_PandangUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\xa1\xf2]\x90\xff\xff\xff\xff\xba\x16Ր\xff\xff\xff\xffˈ\x1d\x80\xff\xff" +
+       "\xff\xff\xd2V\xeep\x01\x02\x03\x04\x00\x00o\xf0\x00\x00\x00\x00o\xf0\x00\x04\x00\x00p\x80\x00\b\x00\x00~\x90\x00\f\x00\x00p\x80\x00\x10LMT\x00MMT\x00+08\x00+09\x00WITA" +
+       "\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x1c\x00Asia/AnadyrUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xaa\x19\x1d" +
+       "\x9c\xff\xff\xff\xff\xb5\xa3\x8c\xc0\x00\x00\x00\x00\x15'\x1b0\x00\x00\x00\x00\x16\x18O\xa0\x00\x00\x00\x00\x17\bN\xb0\x00\x00\x00\x00\x17\xf9\x910\x00\x00\x00\x00\x18\xe9\x90@\x00\x00\x00\x00\x19\xdaİ\x00\x00\x00" +
+       "\x00\x1a\xcc\x15@\x00\x00\x00\x00\x1b\xbc\"`\x00\x00\x00\x00\x1c\xac\x13`\x00\x00\x00\x00\x1d\x9c\x04`\x00\x00\x00\x00\x1e\x8b\xf5`\x00\x00\x00\x00\x1f{\xe6`\x00\x00\x00\x00 k\xd7`\x00\x00\x00\x00![\xc8" +
+       "`\x00\x00\x00\x00\"K\xb9`\x00\x00\x00\x00#;\xaa`\x00\x00\x00\x00$+\x9b`\x00\x00\x00\x00%\x1b\x8c`\x00\x00\x00\x00&\v}`\x00\x00\x00\x00'\x04\xa8\xe0\x00\x00\x00\x00'\xf4\x99\xe0\x00\x00\x00" +
+       "\x00(\xe4\x98\xf0\x00\x00\x00\x00)x@\xf0\x00\x00\x00\x00)\xd4{\xe0\x00\x00\x00\x00*\xc4l\xe0\x00\x00\x00\x00+\xb4]\xe0\x00\x00\x00\x00,\xa4N\xe0\x00\x00\x00\x00-\x94?\xe0\x00\x00\x00\x00.\x840" +
+       "\xe0\x00\x00\x00\x00/t!\xe0\x00\x00\x00\x000d\x12\xe0\x00\x00\x00\x001]>`\x00\x00\x00\x002r\x19`\x00\x00\x00\x003= `\x00\x00\x00\x004Q\xfb`\x00\x00\x00\x005\x1d\x02`\x00\x00\x00" +
+       "\x0061\xdd`\x00\x00\x00\x006\xfc\xe4`\x00\x00\x00\x008\x1a\xf9\xe0\x00\x00\x00\x008\xdc\xc6`\x00\x00\x00\x009\xfa\xdb\xe0\x00\x00\x00\x00:\xbc\xa8`\x00\x00\x00\x00;ڽ\xe0\x00\x00\x00\x00<\xa5\xc4" +
+       "\xe0\x00\x00\x00\x00=\xba\x9f\xe0\x00\x00\x00\x00>\x85\xa6\xe0\x00\x00\x00\x00?\x9a\x81\xe0\x00\x00\x00\x00@e\x88\xe0\x00\x00\x00\x00A\x83\x9e`\x00\x00\x00\x00BEj\xe0\x00\x00\x00\x00Cc\x80`\x00\x00\x00" +
+       "\x00D%L\xe0\x00\x00\x00\x00ECb`\x00\x00\x00\x00F\x05.\xe0\x00\x00\x00\x00G#D`\x00\x00\x00\x00G\xeeK`\x00\x00\x00\x00I\x03&`\x00\x00\x00\x00I\xce-`\x00\x00\x00\x00J\xe3\b" +
+       "`\x00\x00\x00\x00K\xae\x0f`\x00\x00\x00\x00L\xcc2\xf0\x00\x00\x00\x00M\x8d\xffp\x01\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x06\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
+       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x06\x01\x00\x00\xa6d\x00\x00\x00\x00\xa8\xc0\x00\x04\x00\x00\xc4\xe0\x01\b\x00\x00\xb6\xd0\x00\f\x00\x00\xb6\xd0\x01\f\x00" +
+       "\x00\xa8\xc0\x01\x04\x00\x00\x9a\xb0\x00\x10LMT\x00+12\x00+14\x00+13\x00+11\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xed\x8c\xf1\x91\x85" +
+       "\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/MuscatUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1\xf2\x99\xa8\x01\x00\x003\xd8\x00\x00\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>" +
+       "-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\x10\x00\x1c\x00Asia/Ho_Chi_MinhUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x88\x8cC\x80" +
+       "\xff\xff\xff\xff\x91\xa3+\n\xff\xff\xff\xff\xcd5\xe6\x80\xff\xff\xff\xff\xd1Y\xcep\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xff\xd52\xbb\x10\xff\xff\xff\xff\xe4\xb6\xe4\x80\xff\xff\xff\xff\xed/\x98\x00\x00\x00\x00\x00" +
+       "\n=\xc7\x00\x01\x02\x03\x04\x02\x03\x02\x03\x02\x00\x00d\x00\x00\x00\x00\x00c\xf6\x00\x04\x00\x00bp\x00\t\x00\x00p\x80\x00\r\x00\x00~\x90\x00\x11LMT\x00PLMT\x00+07\x00+08\x00" +
+       "+09\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xef\\\xf4q\x17\x04\x00\x00\x17\x04\x00\x00\r\x00\x1c\x00Asia/DamascusUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00c\x00\x00\x00\x03\x00\x00\x00\r\xff" +
+       "\xff\xff\xff\xa1\xf2\xabx\xff\xff\xff\xff\xa2\x81/\x80\xff\xff\xff\xff\xa3^\x9dp\xff\xff\xff\xff\xa4a\x11\x80\xff\xff\xff\xff\xa5>\u007fp\xff\xff\xff\xff\xa6@\xf3\x80\xff\xff\xff\xff\xa7\x1eap\xff\xff\xff\xff\xa8" +
+       " Հ\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xf1\x8fR\x00\xff\xff\xff\xff\xf2[\x9cp\xff\xff\xff\xff\xf3s(\x80\xff\xff\xff\xff\xf4;~p\xff\xff\xff\xff\xf5U\xad\x80\xff\xff\xff\xff\xf6\x1fT\xf0\xff" +
+       "\xff\xff\xff\xf76\xe1\x00\xff\xff\xff\xff\xf7\xff6\xf0\xff\xff\xff\xff\xf9\x0e\xda\x00\xff\xff\xff\xff\xf9\xe1\xbb\xf0\xff\xff\xff\xff\xfa\xf9H\x00\xff\xff\xff\xff\xfb\xc2\xefp\xff\xff\xff\xff\xfc\xdb\xcd\x00\xff\xff\xff\xff\xfd" +
+       "\xa5tp\xff\xff\xff\xff\xfe\xbd\x00\x80\xff\xff\xff\xff\xff\x86\xa7\xf0\x00\x00\x00\x00\x00\x9e4\x00\x00\x00\x00\x00\x01g\xdbp\x00\x00\x00\x00\x02\u007fg\x80\x00\x00\x00\x00\x03I\x0e\xf0\x00\x00\x00\x00\x04a\xec\x80\x00" +
+       "\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06C \x00\x00\x00\x00\x00\a\f\xc7p\x00\x00\x00\x00\b$S\x80\x00\x00\x00\x00\b\xed\xfa\xf0\x00\x00\x00\x00\n\x05\x87\x00\x00\x00\x00\x00\n\xcf.p\x00\x00\x00\x00\v" +
+       "\xe8\f\x00\x00\x00\x00\x00\f\xb1\xb3p\x00\x00\x00\x00\r\xc9?\x80\x00\x00\x00\x00\x0ekY\xf0\x00\x00\x00\x00\x0f\xaas\x00\x00\x00\x00\x00\x10L\x8dp\x00\x00\x00\x00\x18\xf4\xc5\x00\x00\x00\x00\x00\x19\xdbmp\x00" +
+       "\x00\x00\x00\x1a\xd7J\x00\x00\x00\x00\x00\x1b\xbd\xf2p\x00\x00\x00\x00\x1eU#\x00\x00\x00\x00\x00\x1f\x8a\xe5p\x00\x00\x00\x00 Gz\x00\x00\x00\x00\x00!\x89\x19\xf0\x00\x00\x00\x00\"<t\x00\x00\x00\x00\x00#" +
+       "k\x9e\xf0\x00\x00\x00\x00$2\xbf\x80\x00\x00\x00\x00%%Ep\x00\x00\x00\x00&\x15D\x80\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf6[\xe0\x00\x00\x00\x00(\xe7\x90P\x00\x00\x00\x00)\xe2\x1b`\x00" +
+       "\x00\x00\x00*\xca\x15P\x00\x00\x00\x00+\xb2+`\x00\x00\x00\x00,\xa3_\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00.\x8c|P\x00\x00\x00\x00/|{`\x00\x00\x00\x000m\xaf\xd0\x00\x00\x00\x001" +
+       "_\x00`\x00\x00\x00\x002P4\xd0\x00\x00\x00\x003>\xe2`\x00\x00\x00\x0041hP\x00\x00\x00\x005\x1e\xc4`\x00\x00\x00\x006\x12\x9b\xd0\x00\x00\x00\x007\x02\x9a\xe0\x00\x00\x00\x007\xf3\xcfP\x00" +
+       "\x00\x00\x008\xe5\x1f\xe0\x00\x00\x00\x009\xd6TP\x00\x00\x00\x00:\xc6S`\x00\x00\x00\x00;\xb7\x87\xd0\x00\x00\x00\x00<\xa7\x86\xe0\x00\x00\x00\x00=\x98\xbbP\x00\x00\x00\x00>\x88\xba`\x00\x00\x00\x00?" +
+       "y\xee\xd0\x00\x00\x00\x00@k?`\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00BLr\xe0\x00\x00\x00\x00C=\xa7P\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\f6\xe0\x00" +
+       "\x00\x00\x00G*>P\x00\x00\x00\x00G\xf5S`\x00\x00\x00\x00I\vq\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xea\x02P\x00\x00\x00\x00K\xb5\x17`\x00\x00\x00\x00L\xc9\xe4P\x00\x00\x00\x00M" +
+       "\x94\xf9`\x00\x00\x00\x00N\xa9\xc6P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\"\b\x00\x00\x00\x00*0" +
+       "\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.5/0,M10.5.5/0\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9Rj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x1c\x00Asia/ThimphuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff\xd5\xe6\x15t\x00\x00\x00\x00!aM\xa8\x01\x02\x00\x00T\f\x00\x00" +
+       "\x00\x00MX\x00\x04\x00\x00T`\x00\nLMT\x00+0530\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00" +
+       "\x00\f\x00\x1c\x00Asia/BangkokUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x85\x18\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp" +
-       "\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00" +
-       "\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00" +
-       "\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00" +
-       "\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x16矀\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80" +
-       "\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!w\x94\x00\x00\x00\x00\x00" +
-       "\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00" +
-       "\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x00" +
-       "0\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80" +
-       "\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00" +
-       ">\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80" +
-       "\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x87\xe8\x00\x00\x00\x00\x9a\xb0\x01\x04\x00" +
-       "\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\x9c\xd2I\f!\x01\x00\x00!\x01\x00\x00\x14\x00\x1c\x00Australia/QueenslandUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffr\xed\x9f\b\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff" +
-       "\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p" +
-       "9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8fx\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xe2\xf1\x9d4\xea\x00\x00\x00\xea\x00\x00\x00\x0f\x00\x1c\x00Australia/NorthUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x92X\xff\xff\xff\xff{\x12\x03p" +
-       "\xff\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc'\xf8\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧ@x\xff\xff\xff\xffΠz\b\xff\xff\xff\xff" +
-       "χ\"x\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00z\xa8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:" +
-       "30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x1c\x00Australia/Lord_HoweUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x05\x00\x00\x00\x19\xff\xff\xff\xffs" +
-       "\x16w\xdc\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168@\xf8\x00\x00\x00\x00\x16\xe7\x8ah\x00\x00\x00\x00\x18!]x\x00\x00\x00\x00\x18\xc7lh\x00\x00\x00\x00\x1a\x01?x\x00\x00\x00\x00\x1a\xa7Nh\x00" +
-       "\x00\x00\x00\x1b\xe1!x\x00\x00\x00\x00\x1c\x870h\x00\x00\x00\x00\x1d\xc1\x03x\x00\x00\x00\x00\x1ey\x8ep\x00\x00\x00\x00\x1f\x97\xaa\xf8\x00\x00\x00\x00 Ypp\x00\x00\x00\x00!\x80\xc7x\x00\x00\x00\x00\"" +
-       "B\x8c\xf0\x00\x00\x00\x00#i\xe3\xf8\x00\x00\x00\x00$\"n\xf0\x00\x00\x00\x00%I\xc5\xf8\x00\x00\x00\x00%\xef\xdb\xf0\x00\x00\x00\x00')\xa7\xf8\x00\x00\x00\x00'Ͻ\xf0\x00\x00\x00\x00)\t\x89\xf8\x00" +
-       "\x00\x00\x00)\xaf\x9f\xf0\x00\x00\x00\x00*\xe9k\xf8\x00\x00\x00\x00+\x98\xbcp\x00\x00\x00\x00,҈x\x00\x00\x00\x00-x\x9ep\x00\x00\x00\x00.\xb2jx\x00\x00\x00\x00/X\x80p\x00\x00\x00\x000" +
-       "\x92Lx\x00\x00\x00\x001]Lp\x00\x00\x00\x002r.x\x00\x00\x00\x003=.p\x00\x00\x00\x004R\x10x\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xf2x\x00\x00\x00\x006\xfc\xf2p\x00" +
-       "\x00\x00\x008\x1b\x0e\xf8\x00\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xa7\xe2x\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xd2\xf8\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xb4\xf8\x00\x00\x00\x00>" +
-       "\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x96\xf8\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xb3x\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x95x\x00\x00\x00\x00D.\x95p\x00\x00\x00\x00ECwx\x00" +
-       "\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Yx\x00\x00\x00\x00G\xf7\x93\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x00\x00\x95$\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa1\xb8\x01\t\x00\x00\x93\xa8\x00\x0f\x00\x00\x9a\xb0\x01\x15LMT\x00AEST\x00+1" +
-       "130\x00+1030\x00+11\x00\n<+1030>-10:30<+11>-11,M10.1.0,M4.1.0\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQͥ\xdfD\x99\x03\x00\x00\x99\x03\x00\x00\x12\x00\x1c\x00Australia/AdelaideUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x8b\x14\xff\xff\xff\xff{\x12\x03p\xff" +
-       "\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc'\xf8\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧ@x\xff\xff\xff\xffΠz\b\xff\xff\xff\xff\xcf" +
-       "\x87\"x\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00" +
-       "\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10" +
-       "\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x16禈\x00" +
-       "\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1e" +
-       "y\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00" +
-       "\x00\x00\x00&\x02f\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xcbd\x88\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00," +
-       "Җ\x88\x00\x00\x00\x00-\x8b(\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/tE\b\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003=C\x88\x00" +
-       "\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:" +
-       "\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00" +
-       "\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x03\x02\x03\x02" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffV\xb6\x85\xc4\xff\xff\xff\xff\xa2jg\xc4\x01\x02\x00\x00^<\x00\x00\x00\x00^<\x00\x04\x00\x00bp\x00\bLMT\x00" +
+       "BMT\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x02\x95-\xad\xc4\x02\x00\x00\xc4\x02\x00\x00\f\x00\x1c\x00Asia/YerevanU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00>\x00\x00\x00\x05\x00\x00" +
+       "\x00\x10\xff\xff\xff\xff\xaa\x19\x9aH\xff\xff\xff\xff\xe7\xda\fP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00" +
+       "\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 l" +
+       "G\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00" +
+       "\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84" +
+       "\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00" +
+       "\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86" +
+       "\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x00\x00\x00\x00BE\xdb`\x00\x00\x00\x00Cc\xf0\xe0\x00\x00\x00\x00D%\xbd`\x00\x00\x00\x00EC\xd2\xe0\x00\x00" +
+       "\x00\x00F\x05\x9f`\x00\x00\x00\x00G#\xb4\xe0\x00\x00\x00\x00G\xee\xbb\xe0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΝ\xe0\x00\x00\x00\x00J\xe3x\xe0\x00\x00\x00\x00K\xae\u007f\xe0\x00\x00\x00\x00L\xcc" +
+       "\x95`\x00\x00\x00\x00M\x8ea\xe0\x00\x00\x00\x00N\xacw`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00)\xb8\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+0" +
+       "5\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\r\x00\x1c\x00Asia/KatmanduUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00" +
+       "\x10\xff\xff\xff\xff\xa1\xf2}\x84\x00\x00\x00\x00\x1e\x180\xa8\x01\x02\x00\x00O\xfc\x00\x00\x00\x00MX\x00\x04\x00\x00P\xdc\x00\nLMT\x00+0530\x00+0545\x00\n<+0545" +
+       ">-5:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x1c\x00Asia/OralUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xaa\x19\x93\xdc\xff\xff\xff" +
+       "\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw" +
+       "\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00" +
+       "\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xfc\xe0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\x19`\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xfb" +
+       "`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xbf`\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\xa1`\x00\x00\x00" +
+       "\x00/t\x92`\x00\x00\x00\x000d\x83`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M" +
+       "\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00" +
+       "\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x06\x05\x06\x05" +
+       "\x06\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x02\x00\x000$\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00" +
+       "FP\x01\b\x00\x008@\x00\x10LMT\x00+03\x00+05\x00+06\x00+04\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x02\xf4\xaeg\xd5\x00\x00" +
+       "\x00\xd5\x00\x00\x00\n\x00\x1c\x00Asia/TokyoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffe¤p\xff\xff\xff\xff\xd7>\x02p\xff\xff\xff\xff\xd7\xedY\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd" +
+       ";\xf0\xff\xff\xff\xff\xdb\a\x00\xf0\xff\xff\xff\xffۭ\x1d\xf0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xff\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x83\x03\x00\x00\x00\x00\x8c\xa0\x01\x04\x00\x00~\x90\x00" +
+       "\bLMT\x00JDT\x00JST\x00\nJST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00\x1c\x00Asia/Istan" +
+       "bulUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00" +
+       "\x00\x06\x00\x00\x00\x19\xff\xff\xff\xffV\xb6\xc8\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N" +
+       "\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff\xff\xab\xf9\x89\xe0\xff\xff\xff\xff\xac\xc31P\xff\xff" +
+       "\xff\xffȁ?\xe0\xff\xff\xff\xff\xc9\x01\x13P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\tP\xff\xff\xff\xffӢ9`\xff\xff\xff\xff\xd4C" +
+       "\x02P\xff\xff\xff\xff\xd5L\r\xe0\xff\xff\xff\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff\xff\xd9\xe9?\xd0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff" +
+       "\xff\xff\xdb\xd2\\P\xff\xff\xff\xff\xdc\xd4\xd0`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06`\xff\xff\xff\xff\xf6\x1f8\xd0\x00\x00\x00\x00\x06n" +
+       "\x93p\x00\x00\x00\x00\a9\x9ap\x00\x00\x00\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00\x00\v\xb1\xfe\x80\x00\x00\x00\x00\f\xd9@p\x00\x00" +
+       "\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\xa6\xadp\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ\xe0\x00\x00\x00\x00\x1b\xe6\xd0\xf0\x00\x00\x00\x00\x1c\xc6" +
+       "\xef\xf0\x00\x00\x00\x00\x1d\x9b1p\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00" +
+       "\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4" +
+       "\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00" +
+       "\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xdd" +
+       "D\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00" +
+       "\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#" +
+       "\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8fݐ\x00\x00" +
+       "\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe\x10\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17" +
+       "N\x90\x00\x00\x00\x00V>\x9e\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00*0\x00\x11\x00\x008@\x01\x15LMT" +
+       "\x00IMT\x00EEST\x00EET\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x1c" +
+       "\x00Asia/BeirutUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffV\xb6¸\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6" +
+       "%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xa8)\xf3\xe0\xff\xff\xff\xff\xa8\xeb\xb2P\xff\xff\xff\xff\xe8*\x85\xe0\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff" +
+       "\xff\xff\xff\xeb\xec\xec\xe0\xff\xff\xff\xff추P\xff\xff\xff\xff\xed\xcfq\xe0\xff\xff\xff\xff\xee\x99\x19P\xff\xff\xff\xffﰥ`\xff\xff\xff\xff\xf0zL\xd0\x00\x00\x00\x00\x04\xa6^`\x00\x00\x00\x00\x05" +
+       "+w\xd0\x00\x00\x00\x00\x06C\x03\xe0\x00\x00\x00\x00\a\f\xabP\x00\x00\x00\x00\b$7`\x00\x00\x00\x00\b\xed\xde\xd0\x00\x00\x00\x00\n\x05j\xe0\x00\x00\x00\x00\n\xcf\x12P\x00\x00\x00\x00\v\xe7\xef\xe0\x00" +
+       "\x00\x00\x00\f\xb1\x97P\x00\x00\x00\x00\r\xc9#`\x00\x00\x00\x00\x0e\x92\xca\xd0\x00\x00\x00\x00\x0f\xa9\x05`\x00\x00\x00\x00\x10r\xac\xd0\x00\x00\x00\x00\x1a\xf4.\xe0\x00\x00\x00\x00\x1bќ\xd0\x00\x00\x00\x00\x1c" +
+       "\xd5b`\x00\x00\x00\x00\x1d\xb2\xd0P\x00\x00\x00\x00\x1e\xb6\x95\xe0\x00\x00\x00\x00\x1f\x94\x03\xd0\x00\x00\x00\x00 \x97\xc9`\x00\x00\x00\x00!u7P\x00\x00\x00\x00\"\xa3,\xe0\x00\x00\x00\x00#W\xbcP\x00" +
+       "\x00\x00\x00$g_`\x00\x00\x00\x00%8\xef\xd0\x00\x00\x00\x00&<\xb5`\x00\x00\x00\x00'\x1a#P\x00\x00\x00\x00(\x1d\xe8\xe0\x00\x00\x00\x00(\xfbV\xd0\x00\x00\x00\x00*\x00m\xe0\x00\x00\x00\x00*" +
+       "\xce\t\xd0\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00" +
+       "\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x006\rU\xd0\x00\x00\x00\x006\xfdT\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00!H\x00\x00\x00\x00*" +
+       "0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/0,M10.5.0/0\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9Rb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x1c\x00Asia/JakartaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00 \xff\xff\xff\xff?fI`\xff\xff\xff\xff\xa9x\x85\xe0\xff\xff\xff\xff\xba\x16\xde" +
+       "`\xff\xff\xff\xff˿\x83\x88\xff\xff\xff\xff\xd2V\xeep\xff\xff\xff\xff\xd7<\xc6\b\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xf4\xb5\xbe\x88\x01\x02\x03\x04\x03\x05\x03\x06\x00\x00d \x00\x00\x00\x00d \x00" +
+       "\x04\x00\x00g \x00\b\x00\x00ix\x00\x0e\x00\x00~\x90\x00\x14\x00\x00p\x80\x00\x18\x00\x00bp\x00\x1cLMT\x00BMT\x00+0720\x00+0730\x00+09\x00+08\x00W" +
+       "IB\x00\nWIB-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\n\x00\x1c\x00Asia/DubaiUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xa1\xf2\x99" +
+       "\xa8\x01\x00\x003\xd8\x00\x00\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa1\xfax\x98g\x02\x00\x00g\x02\x00\x00\r\x00\x1c" +
+       "\x00Asia/QostanayUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x19\x88\\\xff\xff\xff\xff\xb5\xa3\xfd@\x00\x00\x00\x00\x15'\x8b\xb0\x00\x00\x00\x00\x16\x18\xc0 \x00\x00\x00\x00\x17\b\xb1 \x00\x00\x00" +
+       "\x00\x17\xf9\xf3\xa0\x00\x00\x00\x00\x18\xe9\xf2\xb0\x00\x00\x00\x00\x19\xdb' \x00\x00\x00\x00\x1a\xccw\xb0\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xacu\xd0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8cW" +
+       "\xd0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 l9\xd0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L\x1b\xd0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$+\xfd\xd0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00" +
+       "\x00&\v\xdf\xd0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf4\xfcP\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)x\xa3`\x00\x00\x00\x00)\xd4\xdeP\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xc0" +
+       "P\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xa2P\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000duP\x00\x00\x00\x001]\xa0\xd0\x00\x00\x00\x002r{\xd0\x00\x00\x00" +
+       "\x003=\x82\xd0\x00\x00\x00\x004R]\xd0\x00\x00\x00\x005\x1dd\xd0\x00\x00\x00\x0062?\xd0\x00\x00\x00\x006\xfdF\xd0\x00\x00\x00\x008\x1b\\P\x00\x00\x00\x008\xdd(\xd0\x00\x00\x00\x009\xfb>" +
+       "P\x00\x00\x00\x00:\xbd\n\xd0\x00\x00\x00\x00;\xdb P\x00\x00\x00\x00<\xa6'P\x00\x00\x00\x00=\xbb\x02P\x00\x00\x00\x00>\x86\tP\x00\x00\x00\x00?\x9a\xe4P\x00\x00\x00\x00@e\xebP\x00\x00\x00" +
+       "\x00A\x84\x00\xd0\x01\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x00\x00;\xa4" +
+       "\x00\x00\x00\x008@\x00\x04\x00\x00FP\x00\b\x00\x00T`\x01\f\x00\x00T`\x00\f\x00\x00FP\x01\bLMT\x00+04\x00+05\x00+06\x00\n<+06>-6\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\v\x00\x1c\x00Asia/HarbinUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff" +
+       "\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{" +
+       "\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00" +
+       "\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|" +
+       "\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\t\x00\x1c\x00Atlantic/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\u0097N\xad\xaf\x00\x00\x00\xaf\x00\x00\x00\x13\x00\x1c\x00Atlantic/Cape_VerdeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x92檠\xff\xff\xff\xff̕\x9c \xff\xff\xff\xff\xd2t" +
+       "|\x10\x00\x00\x00\x00\v\x17\xf7@\x01\x02\x01\x03\xff\xff\xe9\xf4\x00\x00\xff\xff\xe3\xe0\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xf1\xf0\x00\bLMT\x00-02\x00-01\x00\n<-01>1\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe7\xcf^\xb0\x15\x03\x00\x00\x15\x03\x00\x00\x10\x00\x1c\x00Atlantic/StanleyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00F\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x11\xbc\xff\xff\xff\xff\x93" +
+       "D_<\xff\xff\xff\xff\xc3OZ\xc0\xff\xff\xff\xff\xc46\x030\xff\xff\xff\xff\xc5/<\xc0\xff\xff\xff\xff\xc6\x15\xe50\xff\xff\xff\xff\xc7\x18Y@\xff\xff\xff\xff\xc7\xff\x01\xb0\xff\xff\xff\xff\xc8\xf8;@\xff" +
+       "\xff\xff\xff\xc9\xde\xe3\xb0\xff\xff\xff\xff\xca\xd8\x1d@\xff\xff\xff\xff˾Ű\xff\xff\xff\xff̷\xff@\xff\xff\xff\xff\xcd6\x810\x00\x00\x00\x00\x19\x11\xfe@\x00\x00\x00\x00\x19Ӽ\xb0\x00\x00\x00\x00\x1a" +
+       "\xf1\xc4 \x00\x00\x00\x00\x1b\xaad0\x00\x00\x00\x00\x1cѦ \x00\x00\x00\x00\x1d\x8aF0\x00\x00\x00\x00\x1e\xa8[\xb0\x00\x00\x00\x00\x1fj6@\x00\x00\x00\x00 \x88=\xb0\x00\x00\x00\x00!J\x18@\x00" +
+       "\x00\x00\x00\"h\x1f\xb0\x00\x00\x00\x00#)\xfa@\x00\x00\x00\x00$H\x01\xb0\x00\x00\x00\x00%\t\xdc@\x00\x00\x00\x00&1\x1e0\x00\x00\x00\x00&\xe9\xbe@\x00\x00\x00\x00(\x11\x000\x00\x00\x00\x00(" +
+       "\xd2\xda\xc0\x00\x00\x00\x00)\xf0\xe20\x00\x00\x00\x00*\xb2\xbc\xc0\x00\x00\x00\x00+\xd0\xc40\x00\x00\x00\x00,\x92\x9e\xc0\x00\x00\x00\x00-\xb0\xa60\x00\x00\x00\x00.r\x80\xc0\x00\x00\x00\x00/\x90\x880\x00" +
+       "\x00\x00\x000Rb\xc0\x00\x00\x00\x001y\xa4\xb0\x00\x00\x00\x002;\u007f@\x00\x00\x00\x003Y\x86\xb0\x00\x00\x00\x004\x1ba@\x00\x00\x00\x0059h\xb0\x00\x00\x00\x005\xfbC@\x00\x00\x00\x007" +
+       "\x19J\xb0\x00\x00\x00\x007\xdb%@\x00\x00\x00\x008\xf9,\xb0\x00\x00\x00\x009\xbb\a@\x00\x00\x00\x00:\xd9*\xd0\x00\x00\x00\x00;\x91\xca\xe0\x00\x00\x00\x00<\xc2GP\x00\x00\x00\x00=q\xac\xe0\x00" +
+       "\x00\x00\x00>\xa2)P\x00\x00\x00\x00?Z\xc9`\x00\x00\x00\x00@\x82\vP\x00\x00\x00\x00A:\xab`\x00\x00\x00\x00Ba\xedP\x00\x00\x00\x00C\x1a\x8d`\x00\x00\x00\x00DA\xcfP\x00\x00\x00\x00D" +
+       "\xfao`\x00\x00\x00\x00F!\xb1P\x00\x00\x00\x00F\xdaQ`\x00\x00\x00\x00H\n\xcd\xd0\x00\x00\x00\x00H\xc3m\xe0\x00\x00\x00\x00I\xea\xaf\xd0\x00\x00\x00\x00J\xa3O\xe0\x00\x00\x00\x00Kʑ\xd0\x00" +
+       "\x00\x00\x00L\x831\xe0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\xff\xff\xc9\xc4\x00\x00\xff\xff\xc9\xc4\x00\x04\xff\xff\xd5\xd0\x01\b\xff\xff\xc7\xc0\x00\f\xff\xff\xe3\xe0\x01\x10\xff\xff\xd5\xd0\x00\bLMT\x00SMT" +
+       "\x00-03\x00-04\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x82\xfa Z\x9b\x05\x00\x00\x9b\x05\x00\x00\x10\x00\x1c\x00Atlantic/" +
+       "MadeiraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x8a\x00\x00\x00\a\x00\x00\x00\x1d\xff\xff\xff\xff^=\x13X\xff\xff\xff\xff\x92朐\xff\xff\xff\xff\x9bK{\x80\xff\xff\xff\xff\x9b\xfeՐ\xff\xff\xff\xff\x9c\x9c\xfb\x80\xff\xff\xff\xff\x9dɑ\x80\xff\xff" +
+       "\xff\xff\x9e\u007f\x80\x80\xff\xff\xff\xff\x9f\xaa\xc5\x00\xff\xff\xff\xff\xa0_b\x80\xff\xff\xff\xff\xa1\x8b\xf8\x80\xff\xff\xff\xff\xa2A\xe7\x80\xff\xff\xff\xff\xa3n}\x80\xff\xff\xff\xff\xa4#\x1b\x00\xff\xff\xff\xff\xa5O" +
+       "\xb1\x00\xff\xff\xff\xff\xaa\x05\xfd\x80\xff\xff\xff\xff\xaa\xf4\x9d\x00\xff\xff\xff\xff\xadɶ\x00\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0]\x80\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff" +
+       "\xff\xff\xb2p0\x80\xff\xff\xff\xff\xb3r\x96\x80\xff\xff\xff\xff\xb4P\x12\x80\xff\xff\xff\xff\xb72Z\x80\xff\xff\xff\xff\xb8\x0fր\xff\xff\xff\xff\xb8\xffǀ\xff\xff\xff\xff\xb9︀\xff\xff\xff\xff\xbc\xc8" +
+       "\xc6\x00\xff\xff\xff\xff\xbd\xb8\xb7\x00\xff\xff\xff\xff\xbe\x9fm\x80\xff\xff\xff\xff\xbf\x98\x99\x00\xff\xff\xff\xff\xc0\x9a\xff\x00\xff\xff\xff\xff\xc1x{\x00\xff\xff\xff\xff\xc2hl\x00\xff\xff\xff\xff\xc3X]\x00\xff\xff" +
+       "\xff\xff\xc4?\x13\x80\xff\xff\xff\xff\xc58?\x00\xff\xff\xff\xff\xc6:\xa5\x00\xff\xff\xff\xff\xc7X\xba\x80\xff\xff\xff\xff\xc7\xd9\xed\x80\xff\xff\xff\xff\xc9\x01=\x80\xff\xff\xff\xff\xc9\xf1.\x80\xff\xff\xff\xff\xca\xe2" +
+       "q\x00\xff\xff\xff\xff˵a\x00\xff\xff\xff\xff\xcb\xec\xb1\xf0\xff\xff\xff\xff̀Y\xf0\xff\xff\xff\xff\xccܱ\x00\xff\xff\xff\xff͕C\x00\xff\xff\xff\xff\xcd\xc3Yp\xff\xff\xff\xff\xcer\xb0\xf0\xff\xff" +
+       "\xff\xff\xce\xc5̀\xff\xff\xff\xff\xcfu%\x00\xff\xff\xff\xffϬu\xf0\xff\xff\xff\xff\xd0R\x92\xf0\xff\xff\xff\xffХ\xaf\x80\xff\xff\xff\xff\xd1U\a\x00\xff\xff\xff\xffьW\xf0\xff\xff\xff\xff\xd22" +
+       "t\xf0\xff\xff\xff\xff҅\x91\x80\xff\xff\xff\xff\xd3Y\xd3\x00\xff\xff\xff\xff\xd4I\xc4\x00\xff\xff\xff\xff\xd59\xdf0\xff\xff\xff\xff\xd6)\xd00\xff\xff\xff\xff\xd7\x19\xc10\xff\xff\xff\xff\xd8\t\xb20\xff\xff" +
+       "\xff\xff\xd8\xf9\xa30\xff\xff\xff\xff\xd9\xe9\x940\xff\xff\xff\xffܹg0\xff\xff\xff\xffݲ\x92\xb0\xff\xff\xff\xffޢ\x83\xb0\xff\xff\xff\xffߒt\xb0\xff\xff\xff\xff\xe0\x82e\xb0\xff\xff\xff\xff\xe1r" +
+       "V\xb0\xff\xff\xff\xff\xe2bG\xb0\xff\xff\xff\xff\xe3R8\xb0\xff\xff\xff\xff\xe4B)\xb0\xff\xff\xff\xff\xe52\x1a\xb0\xff\xff\xff\xff\xe6\"\v\xb0\xff\xff\xff\xff\xe7\x1b70\xff\xff\xff\xff\xe8\v(0\xff\xff" +
+       "\xff\xff\xe8\xfb\x190\xff\xff\xff\xff\xe9\xeb\n0\xff\xff\xff\xff\xea\xda\xfb0\xff\xff\xff\xff\xeb\xca\xec0\xff\xff\xff\xff\xec\xba\xdd0\xff\xff\xff\xff\xed\xaa\xce0\xff\xff\xff\xff\ue6bf0\xff\xff\xff\xff\xef\x8a" +
+       "\xb00\xff\xff\xff\xff\xf0z\xa10\xff\xff\xff\xff\xf1j\x920\xff\xff\xff\xff\xf2c\xbd\xb0\xff\xff\xff\xff\xf3S\xae\xb0\xff\xff\xff\xff\xf4C\x9f\xb0\xff\xff\xff\xff\xf53\x90\xb0\xff\xff\xff\xff\xf6#\x81\xb0\xff\xff" +
+       "\xff\xff\xf7\x13r\xb0\xff\xff\xff\xff\xf8\x03c\xb0\xff\xff\xff\xff\xf8\xf3T\xb0\x00\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d" +
+       "\x19\x80\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13C\xfb\x80\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00" +
+       "\x00\x00\x18㽠\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|" +
+       "\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00" +
+       "\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94" +
+       "ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\xff\xff\xf0(\x00\x00\xff\xff" +
+       "\xf0(\x00\x04\x00\x00\x00\x00\x01\b\xff\xff\xf1\xf0\x00\f\x00\x00\x0e\x10\x01\x10\x00\x00\x0e\x10\x01\x14\x00\x00\x00\x00\x00\x19LMT\x00FMT\x00+00\x00-01\x00+01\x00WEST\x00W" +
+       "ET\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rl&\x04\x99\x00\x04\x00\x00\x00\x04\x00\x00\x10\x00\x1c\x00" +
+       "Atlantic/BermudaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00_\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x18F\xff\xff\xff\xff\x9c̮F\xff\xff\xff\xff\x9d\xb7K6\xff\xff\xff\xff\x9e\xb8m\xc6\xff\xff\xff\xff\x9f\x84\xb86\xff" +
+       "\xff\xff\xff\xb4\xc3\x1d\xe6\xff\xff\xff\xff\xcbb\xa6\xe0\xff\xff\xff\xff\xccӼ\xd0\xff\xff\xff\xff͞\xd1\xe0\xff\xff\xff\xff\xce\xc6\x13\xd0\xff\xff\xff\xff\xcfuy`\xff\xff\xff\xffЯ0P\xff\xff\xff\xff\xd1" +
+       "U[`\xff\xff\xff\xffҏ\x12P\xff\xff\xff\xff\xd5qh`\xff\xff\xff\xff\xd6\x0e<\xd0\xff\xff\xff\xff\xd7Z\x84\xe0\xff\xff\xff\xff\xd7\xe4\xe4P\xff\xff\xff\xff\xd9:f\xe0\xff\xff\xff\xff\xd9\xc4\xc6P\xff" +
+       "\xff\xff\xff\xdb#\x83`\xff\xff\xff\xffۤ\xa8P\xff\xff\xff\xff\xdd\x03e`\xff\xff\xff\xff݄\x8aP\xff\xff\xff\xff\xde\xe3G`\xff\xff\xff\xff\xdfm\xa6\xd0\xff\xff\xff\xff\xe6l\t\xe0\xff\xff\xff\xff\xe7" +
+       "7\x02\xd0\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r\xc0Y`\x00" +
+       "\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00\x00\x00\x00\x15" +
+       "I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b\xe1\xdfP\x00" +
+       "\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00\x00\x00\x00#" +
+       "j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)ޗ`\x00" +
+       "\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00\x00\x00\x001" +
+       "gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008\x1b\xcc\xd0\x00" +
+       "\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00\x00\x00\x00?" +
+       "\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x9a\xe0\x02" +
+       "\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\xff\xff\xc3:\x00\x00\xff\xff\xd1J\x01\x04\xff\xff\xc3:\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff" +
+       "\xc7\xc0\x00\x10LMT\x00BST\x00BMT\x00ADT\x00AST\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00Atlantic/CanaryUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa6\x04\\\xf0\xff\xff\xff\xff\xd4A\xf7 \x00\x00\x00\x00\x13M6\x00" +
+       "\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00" +
+       "\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10" +
+       "\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00" +
+       "(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90" +
+       "\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xf1\x90\x00\x00\xff\xff\xf1" +
+       "\xf0\x00\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x01\fLMT\x00-01\x00WET\x00WEST\x00\nWET0WEST,M3.5.0/1,M10.5.0\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0e\x00\x1c\x00Atlantic/FaroeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x8bm\xa4X\x00\x00\x00\x00\x15#" +
+       "\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00" +
+       "\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<" +
+       "E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00" +
+       "\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]" +
+       "\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xf9\xa8\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\bLMT\x00WET\x00" +
+       "WEST\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\x12\x00" +
+       "\x1c\x00Atlantic/ReykjavikUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x8b`\x83\xa0\xff\xff\xff\xff\x9c\x91\x1e\x00\xff\xff\xff\xff\x9dш\x90\xff\xff\xff\xff\x9erQ\x80\xff\xff\xff\xff\x9f" +
+       "\xd5\x03\x10\xff\xff\xff\xff\xa0S\x85\x00\xff\xff\xff\xff\xa1\xb66\x90\xff\xff\xff\xff\xa4<'\x80\xff\xff\xff\xff\xa4\xb9t\x10\xff\xff\xff\xff\xc6M\x1a\x00\xff\xff\xff\xff\xc7=' \xff\xff\xff\xff\xc7\xda\x17\xb0\xff" +
+       "\xff\xff\xff\xc9&C\xa0\xff\xff\xff\xff\xc9\xc3& \xff\xff\xff\xff\xcb\x06%\xa0\xff\xff\xff\xffˬB\xa0\xff\xff\xff\xff\xcc\xdc\xcd \xff\xff\xff\xff͌$\xa0\xff\xff\xff\xffμ\xaf \xff\xff\xff\xff\xcf" +
+       "l\x06\xa0\xff\xff\xff\xffМ\x91 \xff\xff\xff\xff\xd1K\xe8\xa0\xff\xff\xff\xff҅\xad\xa0\xff\xff\xff\xff\xd3+ʠ\xff\xff\xff\xff\xd4e\x8f\xa0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6Eq\xa0\xff" +
+       "\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8%S\xa0\xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xd9w \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd" +
+       "\xce4 \xff\xff\xff\xffޢu\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1\x8d\xf8 \xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3m\xda \xff\xff\xff\xff\xe4B\x1b\xa0\xff" +
+       "\xff\xff\xff\xe5M\xbc \xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe76ؠ\xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe9\x16\xba\xa0\xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xf6\x9c\xa0\xff\xff\xff\xff\xeb" +
+       "\xca\xde \xff\xff\xff\xff\xec\xd6~\xa0\xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\xee\xb6`\xa0\xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff\xf0\x96B\xa0\xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2\u007f_ \xff" +
+       "\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xf3F\xa0\xff\xff\xff\xff\xf9" +
+       "\xfe\xe7 \xff\xff\xff\xff\xfa\xd3(\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc\xbcE \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\xff\xff\xeb`\x00\x00\x00\x00\x00\x00\x01\x04\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\fL" +
+       "MT\x00+00\x00-01\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x12\x00\x1c\x00Atlantic/" +
+       "Jan_MayenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00:\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff\xff\x9b'\xe3\x00\xff\xff\xff\xff\x9b\xd4{`\xff\xff\xff\xffȷM`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90" +
+       "\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff" +
+       "\xed\x98=\x10\xff\xff\xff\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff\xff\xf0h\x10\x10\xff\xff\xff\xff\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10" +
+       "\xff\xff\xff\xff\xf5\x17\xc5\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06\x10\xff\xff\xff\xff\xf7\xf0Ґ\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00" +
+       "\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10" +
+       "\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00" +
+       "$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90" +
+       "\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00" +
+       "\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00Atlantic/St_HelenaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x92\xe6\x92H\x01\xff\xff\xfc8\x00\x00\x00" +
+       "\x00\x00\x00\x00\x04LMT\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x0f-\xadׄ\x00\x00\x00\x84\x00\x00\x00\x16\x00\x1c\x00Atlantic/So" +
+       "uth_GeorgiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xffi\x86\xfd\xc0\x01\xff\xff\xdd\xc0\x00\x00\xff\xff\xe3\xe0\x00\x04LMT\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0f\x00\x1c\x00Atlantic/FaeroeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x8bm\xa4X\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16" +
+       "\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00" +
+       "\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$" +
+       ",6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00" +
+       "\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xf9\xa8\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x01\bLMT\x00WET\x00WEST\x00\nW" +
+       "ET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RW\x99\x9d\v\x9b\x05\x00\x00\x9b\x05\x00\x00\x0f\x00\x1c\x00Atlan" +
+       "tic/AzoresUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x8a\x00\x00\x00\a\x00\x00\x00\x18\xff\xff\xff\xff^=\x1b\x90\xff\xff\xff\xff\x92檠\xff\xff\xff\xff\x9bK\x89\x90\xff\xff\xff\xff\x9b\xfe\xe3\xa0\xff\xff\xff\xff\x9c\x9d\t\x90\xff\xff\xff\xff\x9dɟ" +
+       "\x90\xff\xff\xff\xff\x9e\u007f\x8e\x90\xff\xff\xff\xff\x9f\xaa\xd3\x10\xff\xff\xff\xff\xa0_p\x90\xff\xff\xff\xff\xa1\x8c\x06\x90\xff\xff\xff\xff\xa2A\xf5\x90\xff\xff\xff\xff\xa3n\x8b\x90\xff\xff\xff\xff\xa4#)\x10\xff\xff\xff" +
+       "\xff\xa5O\xbf\x10\xff\xff\xff\xff\xaa\x06\v\x90\xff\xff\xff\xff\xaa\xf4\xab\x10\xff\xff\xff\xff\xad\xc9\xc4\x10\xff\xff\xff\xff\xae\xa7@\x10\xff\xff\xff\xff\xaf\xa0k\x90\xff\xff\xff\xff\xb0\x87\"\x10\xff\xff\xff\xff\xb1\x89\x88" +
+       "\x10\xff\xff\xff\xff\xb2p>\x90\xff\xff\xff\xff\xb3r\xa4\x90\xff\xff\xff\xff\xb4P \x90\xff\xff\xff\xff\xb72h\x90\xff\xff\xff\xff\xb8\x0f\xe4\x90\xff\xff\xff\xff\xb8\xffՐ\xff\xff\xff\xff\xb9\xefƐ\xff\xff\xff" +
+       "\xff\xbc\xc8\xd4\x10\xff\xff\xff\xff\xbd\xb8\xc5\x10\xff\xff\xff\xff\xbe\x9f{\x90\xff\xff\xff\xff\xbf\x98\xa7\x10\xff\xff\xff\xff\xc0\x9b\r\x10\xff\xff\xff\xff\xc1x\x89\x10\xff\xff\xff\xff\xc2hz\x10\xff\xff\xff\xff\xc3Xk" +
+       "\x10\xff\xff\xff\xff\xc4?!\x90\xff\xff\xff\xff\xc58M\x10\xff\xff\xff\xff\xc6:\xb3\x10\xff\xff\xff\xff\xc7XȐ\xff\xff\xff\xff\xc7\xd9\xfb\x90\xff\xff\xff\xff\xc9\x01K\x90\xff\xff\xff\xff\xc9\xf1<\x90\xff\xff\xff" +
+       "\xff\xca\xe2\u007f\x10\xff\xff\xff\xff˵o\x10\xff\xff\xff\xff\xcb\xec\xc0\x00\xff\xff\xff\xff̀h\x00\xff\xff\xff\xff\xccܿ\x10\xff\xff\xff\xff͕Q\x10\xff\xff\xff\xff\xcd\xc3g\x80\xff\xff\xff\xff\xcer\xbf" +
+       "\x00\xff\xff\xff\xff\xce\xc5ې\xff\xff\xff\xff\xcfu3\x10\xff\xff\xff\xffϬ\x84\x00\xff\xff\xff\xff\xd0R\xa1\x00\xff\xff\xff\xffХ\xbd\x90\xff\xff\xff\xff\xd1U\x15\x10\xff\xff\xff\xffьf\x00\xff\xff\xff" +
+       "\xff\xd22\x83\x00\xff\xff\xff\xff҅\x9f\x90\xff\xff\xff\xff\xd3Y\xe1\x10\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd59\xed@\xff\xff\xff\xff\xd6)\xde@\xff\xff\xff\xff\xd7\x19\xcf@\xff\xff\xff\xff\xd8\t\xc0" +
+       "@\xff\xff\xff\xff\xd8\xf9\xb1@\xff\xff\xff\xff\xd9\xe9\xa2@\xff\xff\xff\xffܹu@\xff\xff\xff\xffݲ\xa0\xc0\xff\xff\xff\xffޢ\x91\xc0\xff\xff\xff\xffߒ\x82\xc0\xff\xff\xff\xff\xe0\x82s\xc0\xff\xff\xff" +
+       "\xff\xe1rd\xc0\xff\xff\xff\xff\xe2bU\xc0\xff\xff\xff\xff\xe3RF\xc0\xff\xff\xff\xff\xe4B7\xc0\xff\xff\xff\xff\xe52(\xc0\xff\xff\xff\xff\xe6\"\x19\xc0\xff\xff\xff\xff\xe7\x1bE@\xff\xff\xff\xff\xe8\v6" +
+       "@\xff\xff\xff\xff\xe8\xfb'@\xff\xff\xff\xff\xe9\xeb\x18@\xff\xff\xff\xff\xea\xdb\t@\xff\xff\xff\xff\xeb\xca\xfa@\xff\xff\xff\xff\xec\xba\xeb@\xff\xff\xff\xff\xed\xaa\xdc@\xff\xff\xff\xff\xee\x9a\xcd@\xff\xff\xff" +
+       "\xff\uf2be@\xff\xff\xff\xff\xf0z\xaf@\xff\xff\xff\xff\xf1j\xa0@\xff\xff\xff\xff\xf2c\xcb\xc0\xff\xff\xff\xff\xf3S\xbc\xc0\xff\xff\xff\xff\xf4C\xad\xc0\xff\xff\xff\xff\xf53\x9e\xc0\xff\xff\xff\xff\xf6#\x8f" +
+       "\xc0\xff\xff\xff\xff\xf7\x13\x80\xc0\xff\xff\xff\xff\xf8\x03q\xc0\xff\xff\xff\xff\xf8\xf3b\xc0\x00\x00\x00\x00\r\x9b)\x10\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00" +
+       "\x00\x11d'\x90\x00\x00\x00\x00\x12T&\xa0\x00\x00\x00\x00\x13D\t\x90\x00\x00\x00\x00\x144\b\xa0\x00\x00\x00\x00\x15#\xf9\xa0\x00\x00\x00\x00\x16\x13\xea\xa0\x00\x00\x00\x00\x17\x03۠\x00\x00\x00\x00\x17\xf3\xcc" +
+       "\xa0\x00\x00\x00\x00\x18\xe3˰\x00\x00\x00\x00\x19Ӯ\xa0\x00\x00\x00\x00\x1aß\xa0\x00\x00\x00\x00\x1b\xbc\xcb \x00\x00\x00\x00\x1c\xac\xbc \x00\x00\x00\x00\x1d\x9c\xad \x00\x00\x00\x00\x1e\x8c\x9e \x00\x00\x00" +
+       "\x00\x1f|\x8f \x00\x00\x00\x00 l\x80 \x00\x00\x00\x00!\\q \x00\x00\x00\x00\"Lb \x00\x00\x00\x00#<S \x00\x00\x00\x00$,D \x00\x00\x00\x00%\x1c5 \x00\x00\x00\x00&\f&" +
+       " \x00\x00\x00\x00'\x05Q\xa0\x00\x00\x00\x00'\xf5B\xa0\x00\x00\x00\x00(\xe53\xa0\x00\x00\x00\x00)\xd5$\xa0\x00\x00\x00\x00*\xc5\x15\xa0\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00" +
+       "\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x06\x04\x05\x04\x05\x04\x05\x04\xff\xff\xe7\xf0\x00" +
+       "\x00\xff\xff\xe5(\x00\x04\xff\xff\xf1\xf0\x01\b\xff\xff\xe3\xe0\x00\f\x00\x00\x00\x00\x01\x10\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\x14LMT\x00HMT\x00-01\x00-02\x00+00\x00WET" +
+       "\x00\n<-01>1<+00>,M3.5.0/0,M10.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n" +
+       "\x00\x1c\x00Australia/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88" +
+       "\x03\x00\x00\x88\x03\x00\x00\r\x00\x1c\x00Australia/NSWUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff" +
+       "\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05" +
+       "P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00" +
+       "\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13" +
+       "\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00" +
+       "\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!" +
+       "\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00" +
+       "\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/" +
+       "X\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00" +
+       "\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=" +
+       "\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00" +
+       "\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00" +
+       "\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x12\x00\x1c\x00Australia/AdelaideUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x8b\x14\xff\xff\xff\xff{" +
+       "\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff\x9c\xbc6\b\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧN\x88\xff\xff\xff\xffΠz\b\xff" +
+       "\xff\xff\xffχ0\x88\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t" +
+       "\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00" +
+       "\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x16" +
+       "禈\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00" +
+       "\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%" +
+       "I\xd4\b\x00\x00\x00\x00&\x02f\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xcbd\x88\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00" +
+       "\x00\x00\x00,Җ\x88\x00\x00\x00\x00-\x8b(\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/tE\b\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003" +
+       "=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00" +
+       "\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A" +
+       "\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01" +
        "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x81\xec\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nAC" +
-       "ST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ1\x9eD\x00\xad\x03\x00\x00\xad\x03\x00\x00\x14\x00\x1c\x00A" +
-       "ustralia/YancowinnaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00U\x00\x00\x00\x05\x00\x00\x00\x13\xff\xff\xff\xffs\x16\x88d\xff\xff\xff\xffv\x04\xa5\xe0\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc" +
-       "'\xf8\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧ@x\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ\"x\x00\x00\x00\x00\x03p@\x88\x00\x00" +
-       "\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xef" +
-       "Ȉ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00" +
-       "\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x17\f\x90\x88\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18\xc7" +
-       "\x88\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00" +
-       "\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00%\xef\xf1\b\x00\x00\x00\x00')" +
-       "\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xaf\xb5\b\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-x\xb3\x88\x00\x00" +
-       "\x00\x00.\xb2x\x88\x00\x00\x00\x00/X\x95\x88\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d" +
-       "%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00" +
-       "\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc" +
-       "\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x00\x00\x84\x9c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\t\x00\x00\x93\xa8\x01\x0e\x00\x00\x85\x98\x00\tLMT\x00AEST\x00ACST\x00ACDT\x00\nACS" +
-       "T-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x85&'\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Au" +
-       "stralia/VictoriaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x85\x18\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff" +
-       "\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05" +
-       "\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00" +
-       "\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14" +
-       "Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x16矀\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00" +
-       "\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!w\x94\x00\x00\x00\x00\x00\"" +
-       "B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00" +
-       "\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000" +
-       "\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00" +
-       "\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>" +
-       "\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00" +
-       "\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x87\xe8\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00" +
-       "\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Australia/CanberraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c" +
-       "\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x81\xec\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT" +
+       "\x00\nACST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x12" +
+       "\x00\x1c\x00Australia/VictoriaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x85\x18\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff" +
+       "\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80" +
+       "\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00" +
+       "\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00" +
+       "\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x16矀\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00" +
+       "\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!w\x94\x00" +
+       "\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00" +
+       ")\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/t>\x00" +
+       "\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x00" +
+       "6\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00" +
+       "\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00" +
+       "EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x87\xe8\x00\x00\x00\x00\x9a" +
+       "\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9Ro3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x1c\x00Australia/LHIUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x05\x00\x00\x00\x19\xff\xff\xff\xffs\x16w\xdc\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x16" +
+       "8@\xf8\x00\x00\x00\x00\x16\xe7\x8ah\x00\x00\x00\x00\x18!]x\x00\x00\x00\x00\x18\xc7lh\x00\x00\x00\x00\x1a\x01?x\x00\x00\x00\x00\x1a\xa7Nh\x00\x00\x00\x00\x1b\xe1!x\x00\x00\x00\x00\x1c\x870h\x00" +
+       "\x00\x00\x00\x1d\xc1\x03x\x00\x00\x00\x00\x1ey\x8ep\x00\x00\x00\x00\x1f\x97\xaa\xf8\x00\x00\x00\x00 Ypp\x00\x00\x00\x00!\x80\xc7x\x00\x00\x00\x00\"B\x8c\xf0\x00\x00\x00\x00#i\xe3\xf8\x00\x00\x00\x00$" +
+       "\"n\xf0\x00\x00\x00\x00%I\xc5\xf8\x00\x00\x00\x00%\xef\xdb\xf0\x00\x00\x00\x00')\xa7\xf8\x00\x00\x00\x00'Ͻ\xf0\x00\x00\x00\x00)\t\x89\xf8\x00\x00\x00\x00)\xaf\x9f\xf0\x00\x00\x00\x00*\xe9k\xf8\x00" +
+       "\x00\x00\x00+\x98\xbcp\x00\x00\x00\x00,҈x\x00\x00\x00\x00-x\x9ep\x00\x00\x00\x00.\xb2jx\x00\x00\x00\x00/X\x80p\x00\x00\x00\x000\x92Lx\x00\x00\x00\x001]Lp\x00\x00\x00\x002" +
+       "r.x\x00\x00\x00\x003=.p\x00\x00\x00\x004R\x10x\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xf2x\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\x0e\xf8\x00\x00\x00\x008\xdc\xd4p\x00" +
+       "\x00\x00\x009\xa7\xe2x\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xd2\xf8\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xb4\xf8\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x96\xf8\x00\x00\x00\x00@" +
+       "e\x96\xf0\x00\x00\x00\x00A\x83\xb3x\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x95x\x00\x00\x00\x00D.\x95p\x00\x00\x00\x00ECwx\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G#Yx\x00" +
+       "\x00\x00\x00G\xf7\x93\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x00\x00\x95$\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa1\xb8\x01\t\x00\x00\x93\xa8\x00\x0f\x00\x00\x9a\xb0\x01\x15LMT\x00AEST\x00+1130\x00+1030\x00+11\x00\n<" +
+       "+1030>-10:30<+11>-11,M10.1.0,M4.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00" +
+       "\x00\x00\x0f\x00\x1c\x00Australia/NorthUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x92X\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff\x9c\xbc6\b\xff\xff\xff\xff" +
+       "\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧN\x88\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ0\x88\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00z\xa8\x00\x00" +
+       "\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc8R\x1a" +
+       "\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x1c\x00Australia/DarwinUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x92X\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff" +
+       "\x9c\xbc6\b\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧN\x88\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ0\x88\x01\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x00\x00z\xa8\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:30\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x14\x00\x1c\x00Australia/YancowinnaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00U\x00\x00\x00\x05\x00\x00\x00\x13\xff\xff\xff\xffs\x16\x88d\xff\xff\xff\xffv\x04\xa5\xe0" +
+       "\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff\x9c\xbc6\b\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧN\x88\xff\xff\xff\xff" +
+       "Πz\b\xff\xff\xff\xffχ0\x88\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88" +
+       "\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00" +
+       "\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b" +
+       "\x00\x00\x00\x00\x17\f\x90\x88\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00" +
+       "\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00\x00$\"\x84\b" +
+       "\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00%\xef\xf1\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xaf\xb5\b\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00" +
+       "+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-x\xb3\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/X\x95\x88\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00\x002r<\x88" +
+       "\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x00" +
+       "9\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b" +
+       "\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00" +
+       "G\xf7\xa9\b\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x84\x9c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\t\x00\x00\x93\xa8\x01\x0e\x00\x00\x85\x98\x00\tL" +
+       "MT\x00AEST\x00ACST\x00ACDT\x00\nACST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x14\x00\x1c\x00Australia/QueenslandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffr\xed\x9f\b\xff\xff\xff\xff\x9cN\u0080\xff" +
+       "\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03" +
+       "p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8fx\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x10\x00\x1c\x00Australia/SydneyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN" +
+       "\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00" +
+       "\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5" +
+       "\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00" +
+       "\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!" +
+       "d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00" +
+       "\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef" +
+       "\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00" +
+       "\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/X\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R" +
+       "\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00" +
+       "\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE" +
+       "\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M1" +
+       "0.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x12\x00\x1c\x00Australia/Tasma" +
+       "niaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00" +
+       "\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft.\x00\xe4\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\x9d\xdaD\x80\xff\xff\xff\xff\x9e\x80a\x80\xff\xff\xff\xff\x9f\xba&\x80\xff\xff\xff\xff\xa0`" +
+       "C\x80\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\xff\xff\xff\xff\xfb\u008d\x00\xff\xff" +
+       "\xff\xff\xfc\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p" +
+       "9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00" +
+       "\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>" +
+       "\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00" +
+       "\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97" +
+       "\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00" +
+       "\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94" +
+       "\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00" +
+       "\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf" +
+       "*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00" +
+       "\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x8a\x1c\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10" +
+       ".1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x1c\x00Australia/SouthU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\x04\x00\x00" +
+       "\x00\x0e\xff\xff\xff\xffs\x16\x8b\x14\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff\x9c\xbc6\b\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff" +
+       "\xff\xffͧN\x88\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ0\x88\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0" +
+       "\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00" +
+       "\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe" +
+       "\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x16禈\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00" +
+       "\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i" +
+       "\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00&\x02f\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xcbd\x88\x00\x00" +
+       "\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-\x8b(\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/tE\b\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]" +
+       "a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00" +
+       "\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a" +
+       "\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00" +
+       "\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x81\xec\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98" +
+       "\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Australia/CanberraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c" +
+       "\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00" +
        "\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n" +
        "\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00" +
        "\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18" +
@@ -3649,304 +3730,278 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "c\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M" +
-       "4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\x10\x00\x1c\x00Australia/SydneyUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff" +
-       "\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs" +
-       "\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00" +
+       "4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x1c\x00Australia/CurrieUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff" +
+       "\xfft.\x00\xe4\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\x9d\xdaD\x80\xff\xff\xff\xff\x9e\x80a\x80\xff\xff\xff\xff\x9f\xba&\x80\xff\xff\xff\xff\xa0`C\x80\xff\xff\xff\xff\xcbT\xb3" +
+       "\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\xff\xff\xff\xff\xfb\u008d\x00\xff\xff\xff\xff\xfc\xb2~\x00\xff\xff\xff" +
+       "\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c" +
+       "\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00" +
+       "\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84" +
+       "\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00" +
+       "\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~" +
+       "\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00" +
+       "\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x8d\x87" +
+       "\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00" +
+       "\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf*\x80\x00\x00\x00\x00<\xa5\xe1" +
+       "\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00" +
+       "\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x00\x00\x8a\x1c\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1" +
+       ".0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xa2ܺ\xca:\x01\x00\x00:\x01\x00\x00\x0f\x00\x1c\x00Australia/EuclaUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x10\xff\xff\xff\xfft\xa6\n" +
+       "\xb0\xff\xff\xff\xff\x9cN\xd4\x14\xff\xff\xff\xff\x9c\xbc@\x94\xff\xff\xff\xff\xcbTĔ\xff\xff\xff\xff\xcb\xc7w\x14\xff\xff\xff\xff̷h\x14\xff\xff\xff\xffͧY\x14\x00\x00\x00\x00\t\x0f\xf1\x14\x00\x00\x00" +
+       "\x00\t\xb6\x0e\x14\x00\x00\x00\x00\x1a\x01X\x14\x00\x00\x00\x00\x1a\xa7u\x14\x00\x00\x00\x00)%R\x14\x00\x00\x00\x00)\xaf\xbf\x94\x00\x00\x00\x00Eq\xb4\x94\x00\x00\x00\x00F\x05\\\x94\x00\x00\x00\x00G#r" +
+       "\x14\x00\x00\x00\x00G\xeey\x14\x00\x00\x00\x00I\x03T\x14\x00\x00\x00\x00I\xce[\x14\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00x\xd0\x00\x00\x00\x00\x89\x1c\x01\x04\x00\x00{\f" +
+       "\x00\nLMT\x00+0945\x00+0845\x00\n<+0845>-8:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00" +
+       "\x1c\x00Australia/HobartUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft.\x00\xe4\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\x9d\xdaD\x80\xff\xff\xff\xff\x9e\x80a" +
+       "\x80\xff\xff\xff\xff\x9f\xba&\x80\xff\xff\xff\xff\xa0`C\x80\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff" +
+       "\xffχ)\x80\xff\xff\xff\xff\xfb\u008d\x00\xff\xff\xff\xff\xfc\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d" +
+       "\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00" +
        "\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd" +
        "\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00" +
-       "\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n" +
-       "\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00" +
-       "\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98\xca" +
-       "\x80\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/X\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00" +
-       "\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9" +
-       "\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00" +
-       "\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2" +
-       "\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAES" +
-       "T-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x1c\x00Aust" +
-       "ralia/ACTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80" +
-       "\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00" +
-       "\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00" +
-       "\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00" +
-       "\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80" +
-       "\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00" +
-       "#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00" +
-       "\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/X\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x00" +
-       "1]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00" +
-       "\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00" +
-       "?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00" +
-       "\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT" +
-       "\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ.\x1b\xa53:" +
-       "\x01\x00\x00:\x01\x00\x00\x0f\x00\x1c\x00Australia/EuclaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x10\xff\xff\xff\xfft\xa6\n\xb0\xff\xff\xff\xff\x9cN\xb80\xff\xff\xff\xff\x9c\xbc2\x84\xff\xff\xff\xff\xcbT\xc4" +
-       "\x94\xff\xff\xff\xff\xcb\xc7i\x04\xff\xff\xff\xff̷h\x14\xff\xff\xff\xffͧK\x04\x00\x00\x00\x00\t\x0f\xf1\x14\x00\x00\x00\x00\t\xb6\x0e\x14\x00\x00\x00\x00\x1a\x01X\x14\x00\x00\x00\x00\x1a\xa7u\x14\x00\x00\x00" +
-       "\x00)%R\x14\x00\x00\x00\x00)\xaf\xbf\x94\x00\x00\x00\x00Eq\xb4\x94\x00\x00\x00\x00F\x05\\\x94\x00\x00\x00\x00G#r\x14\x00\x00\x00\x00G\xeey\x14\x00\x00\x00\x00I\x03T\x14\x00\x00\x00\x00I\xce[" +
-       "\x14\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00x\xd0\x00\x00\x00\x00\x89\x1c\x01\x04\x00\x00{\f\x00\nLMT\x00+0945\x00+0845\x00\n<+084" +
-       "5>-8:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9c\xd2I\f!\x01\x00\x00!\x01\x00\x00\x12\x00\x1c\x00Australia/BrisbaneUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x0e\xff" +
-       "\xff\xff\xffr\xed\x9f\b\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xff\xce" +
-       "\xa0s\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00" +
-       "\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8fx\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00A" +
-       "EST\x00\nAEST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQʹF\xd6\xc7\x03\x00\x00\xc7\x03\x00\x00\x12\x00\x1c\x00Australia/Tasmani" +
-       "aUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Z\x00\x00\x00\x03" +
-       "\x00\x00\x00\x0e\xff\xff\xff\xfft.\x00\xe4\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p" +
-       "\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\xff\xff\xff\xff\xfb\u008d\x00\xff\xff\xff\xff\xfc\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00" +
-       "\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80" +
-       "\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00" +
-       "\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00" +
-       "\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00" +
-       "\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00" +
-       "\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00" +
-       "*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80" +
-       "\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x00" +
-       "8\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80" +
-       "\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00" +
-       "G\a\xb1\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8a\x1c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\x9a\xb0\x01\tLMT\x00AEST" +
-       "\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQʹF\xd6\xc7\x03\x00\x00\xc7\x03" +
-       "\x00\x00\x10\x00\x1c\x00Australia/HobartUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Z\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft.\x00\xe4\xff\xff\xff\xff\x9b\xd5x\x80\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff" +
-       "\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\xff\xff\xff\xff\xfb\u008d\x00\xff\xff\xff\xff\xfc\xb2~\x00\xff\xff\xff\xff\xfd\xc7Y" +
-       "\x00\xff\xff\xff\xff\xfev\xb0\x80\xff\xff\xff\xff\xff\xa7;\x00\x00\x00\x00\x00\x00V\x92\x80\x00\x00\x00\x00\x01\x87\x1d\x00\x00\x00\x00\x00\x02?\xaf\x00\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00" +
-       "\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19" +
-       "\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00" +
-       "\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F" +
-       "\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00" +
-       "\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6" +
-       "\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00" +
-       "\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J" +
-       "\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00" +
-       "\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3" +
-       "\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8a\x1c\x00" +
-       "\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\x9a\xb0\x01\tLMT\x00AEST\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x98Ò\x8d2\x01\x00\x002\x01\x00\x00\x0f\x00\x1c\x00Australia/PerthUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft\xa6\x16\xe4\xff\xff\xff\xff\x9cN\xc2" +
-       "\xbc\xff\xff\xff\xff\x9c\xbc=\x10\xff\xff\xff\xff\xcbT\xcf \xff\xff\xff\xff\xcb\xc7s\x90\xff\xff\xff\xff̷r\xa0\xff\xff\xff\xffͧU\x90\x00\x00\x00\x00\t\x0f\xfb\xa0\x00\x00\x00\x00\t\xb6\x18\xa0\x00\x00\x00" +
-       "\x00\x1a\x01b\xa0\x00\x00\x00\x00\x1a\xa7\u007f\xa0\x00\x00\x00\x00)%\\\xa0\x00\x00\x00\x00)\xaf\xca \x00\x00\x00\x00Eq\xbf \x00\x00\x00\x00F\x05g \x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\xee\x83" +
-       "\xa0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I\xcee\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00l\x9c\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\tLMT\x00AW" +
-       "DT\x00AWST\x00\nAWST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQͥ\xdfD\x99\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x1c\x00Australia/Sout" +
-       "hUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\x04" +
-       "\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x8b\x14\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc'\xf8\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88" +
-       "\xff\xff\xff\xffͧ@x\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ\"x\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00" +
-       "\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b" +
-       "\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00" +
-       "\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x16禈\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88" +
-       "\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00" +
-       "#i\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00&\x02f\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xcbd\x88" +
-       "\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-\x8b(\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/tE\b\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x00" +
-       "1]a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b" +
-       "\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00" +
-       "?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b" +
-       "\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x81\xec\x00\x00\x00\x00~\x90\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00" +
-       "\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xce\xe5\x90AE\x01\x00\x00E\x01\x00\x00\x12\x00\x1c\x00Australia/LindemanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffr\xed\xa2\xd4\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff" +
-       "\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9" +
-       "\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00" +
-       "\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8b\xac\x00\x00\x00\x00\x9a\xb0" +
-       "\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe2\xf1\x9d4\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x1c" +
-       "\x00Australia/DarwinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\x92X\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc'\xf8\xff\xff\xff\xff\xcbT\xba\b" +
-       "\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧ@x\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ\"x\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00z\xa8\x00\x00\x00\x00~\x90" +
-       "\x00\x04\x00\x00\x93\xa8\x01\t\x00\x00\x85\x98\x00\x04LMT\x00ACST\x00ACDT\x00\nACST-9:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x98Ò\x8d2\x01\x00" +
-       "\x002\x01\x00\x00\x0e\x00\x1c\x00Australia/WestUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft\xa6\x16\xe4\xff\xff\xff\xff\x9cN¼\xff\xff\xff\xff\x9c\xbc=\x10\xff\xff\xff\xff\xcbT\xcf \xff\xff" +
-       "\xff\xff\xcb\xc7s\x90\xff\xff\xff\xff̷r\xa0\xff\xff\xff\xffͧU\x90\x00\x00\x00\x00\t\x0f\xfb\xa0\x00\x00\x00\x00\t\xb6\x18\xa0\x00\x00\x00\x00\x1a\x01b\xa0\x00\x00\x00\x00\x1a\xa7\u007f\xa0\x00\x00\x00\x00)%" +
-       "\\\xa0\x00\x00\x00\x00)\xaf\xca \x00\x00\x00\x00Eq\xbf \x00\x00\x00\x00F\x05g \x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\ue0e0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I\xcee\xa0\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00l\x9c\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\tLMT\x00AWDT\x00AWST\x00\nAWST-8\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x1c\x00Australia/LHIUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x05\x00\x00\x00\x19\xff\xff\xff\xffs\x16w\xdc\x00\x00\x00\x00\x14\xfef\xe0\x00" +
-       "\x00\x00\x00\x168@\xf8\x00\x00\x00\x00\x16\xe7\x8ah\x00\x00\x00\x00\x18!]x\x00\x00\x00\x00\x18\xc7lh\x00\x00\x00\x00\x1a\x01?x\x00\x00\x00\x00\x1a\xa7Nh\x00\x00\x00\x00\x1b\xe1!x\x00\x00\x00\x00\x1c" +
-       "\x870h\x00\x00\x00\x00\x1d\xc1\x03x\x00\x00\x00\x00\x1ey\x8ep\x00\x00\x00\x00\x1f\x97\xaa\xf8\x00\x00\x00\x00 Ypp\x00\x00\x00\x00!\x80\xc7x\x00\x00\x00\x00\"B\x8c\xf0\x00\x00\x00\x00#i\xe3\xf8\x00" +
-       "\x00\x00\x00$\"n\xf0\x00\x00\x00\x00%I\xc5\xf8\x00\x00\x00\x00%\xef\xdb\xf0\x00\x00\x00\x00')\xa7\xf8\x00\x00\x00\x00'Ͻ\xf0\x00\x00\x00\x00)\t\x89\xf8\x00\x00\x00\x00)\xaf\x9f\xf0\x00\x00\x00\x00*" +
-       "\xe9k\xf8\x00\x00\x00\x00+\x98\xbcp\x00\x00\x00\x00,҈x\x00\x00\x00\x00-x\x9ep\x00\x00\x00\x00.\xb2jx\x00\x00\x00\x00/X\x80p\x00\x00\x00\x000\x92Lx\x00\x00\x00\x001]Lp\x00" +
-       "\x00\x00\x002r.x\x00\x00\x00\x003=.p\x00\x00\x00\x004R\x10x\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xf2x\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\x0e\xf8\x00\x00\x00\x008" +
-       "\xdc\xd4p\x00\x00\x00\x009\xa7\xe2x\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xd2\xf8\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xb4\xf8\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?\x9a\x96\xf8\x00" +
-       "\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xb3x\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x95x\x00\x00\x00\x00D.\x95p\x00\x00\x00\x00ECwx\x00\x00\x00\x00F\x05<\xf0\x00\x00\x00\x00G" +
-       "#Yx\x00\x00\x00\x00G\xf7\x93\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x00\x00\x95$\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa1\xb8\x01\t\x00\x00\x93\xa8\x00\x0f\x00\x00\x9a\xb0\x01\x15LMT\x00AEST\x00+1130\x00+1030\x00+1" +
-       "1\x00\n<+1030>-10:30<+11>-11,M10.1.0,M4.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03" +
-       "\x00\x00\x88\x03\x00\x00\r\x00\x1c\x00Australia/NSWUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff\x9cN\xa6\x9c\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff" +
-       "\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P" +
-       "\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00" +
-       "\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e" +
-       "\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00" +
-       "\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80" +
-       "\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00" +
-       "\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/X" +
-       "\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00" +
-       "\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba" +
-       "\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00" +
-       "\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00" +
-       "\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ1\x9eD\x00\xad\x03\x00\x00\xad\x03\x00\x00\x15\x00\x1c\x00Australia/Broken_HillUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00U\x00\x00\x00\x05\x00\x00\x00\x13\xff\xff\xff\xffs\x16\x88d\xff\xff\xff" +
-       "\xffv\x04\xa5\xe0\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cN\xad\xa4\xff\xff\xff\xff\x9c\xbc'\xf8\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7^x\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧ@" +
-       "x\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ\"x\x00\x00\x00\x00\x03p@\x88\x00\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00" +
-       "\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7" +
-       "\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00" +
-       "\x00\x168O\b\x00\x00\x00\x00\x17\f\x90\x88\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L" +
-       "\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00" +
-       "\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00%\xef\xf1\b\x00\x00\x00\x00')\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xaf\xb5\b\x00\x00\x00\x00*\xe9z" +
-       "\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-x\xb3\x88\x00\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/X\x95\x88\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00" +
-       "\x002r<\x88\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9" +
-       "\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00" +
-       "\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00Cc\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g" +
-       "\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x84\x9c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\t\x00\x00\x93\xa8\x01\x0e\x00\x00" +
-       "\x85\x98\x00\tLMT\x00AEST\x00ACST\x00ACDT\x00\nACST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xc4\xd5\x01\xe5\u007f\x03\x00\x00\u007f\x03\x00\x00\x10\x00\x1c\x00Australia/CurrieUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft.\x04 \xff\xff\xff\xff\x9b\xd5x\x80" +
-       "\xff\xff\xff\xff\x9c\xbc \xf0\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7Wp\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧ9p\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ\x1bp\x00\x00\x00\x00" +
-       "\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80" +
-       "\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00" +
-       "\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80" +
-       "\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00" +
-       "\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00" +
-       "\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00" +
-       "-\x94\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00\x003=<\x80\x00\x00\x00\x0046h\x00" +
-       "\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00" +
-       ";\xbf*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00" +
-       "\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x00\x17\x03O\x00\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18\xe31\x00\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n" +
+       "\x80\x00\x00\x00\x00\x1eg'\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00" +
+       "\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xf4\xb6\x00\x00\x00\x00\x00(\xed\xe1\x80\x00\x00\x00\x00)Ԙ\x00\x00\x00\x00\x00*\xcdÀ\x00\x00\x00\x00+\xb4z" +
+       "\x00\x00\x00\x00\x00,\xad\xa5\x80\x00\x00\x00\x00-\x94\\\x00\x00\x00\x00\x00.\x8d\x87\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000mi\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002V\x86\x00\x00\x00\x00" +
+       "\x003=<\x80\x00\x00\x00\x0046h\x00\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x006\x16J\x00\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x007\xf6,\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9" +
+       "\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xbf*\x80\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\x9f\f\x80\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?~\xee\x80\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00" +
+       "\x00A^Ѐ\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00C>\xb2\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00E\x1e\x94\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G\a\xb1\x00\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x00\x00\x86\xe0\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\x9a\xb0\x01\tLMT\x00AEST\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1." +
-       "0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Brazil/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x1c\x00Brazil/DeNoronhaUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff" +
-       "\xff\xff\x96\xaaed\xff\xff\xff\xff\xb8\x0f;\xd0\xff\xff\xff\xff\xb8\xfd2\x90\xff\xff\xff\xff\xb9\xf1& \xff\xff\xff\xff\xba\xdef\x10\xff\xff\xff\xff\xda8\xa0 \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdc\x19" +
-       "Ӡ\xff\xff\xff\xffܹK\x10\xff\xff\xff\xff\xdd\xfb\a \xff\xff\xff\xffޛ\xd0\x10\xff\xff\xff\xff\xdf\u074c \xff\xff\xff\xff\xe0T%\x10\xff\xff\xff\xff\xf4\x97\xf1\xa0\xff\xff\xff\xff\xf5\x05P\x10\xff\xff" +
-       "\xff\xff\xf6\xc0V \xff\xff\xff\xff\xf7\x0e\x10\x90\xff\xff\xff\xff\xf8Q\x1e \xff\xff\xff\xff\xf8Ƿ\x10\xff\xff\xff\xff\xfa\nĠ\xff\xff\xff\xff\xfa\xa8\xea\x90\xff\xff\xff\xff\xfb\xeb\xf8 \xff\xff\xff\xff\xfc\x8b" +
-       "o\x90\x00\x00\x00\x00\x1dɀ \x00\x00\x00\x00\x1exɐ\x00\x00\x00\x00\x1f\xa0'\xa0\x00\x00\x00\x00 3\xc1\x90\x00\x00\x00\x00!\x81[ \x00\x00\x00\x00\"\v\xba\x90\x00\x00\x00\x00#X\x02\xa0\x00\x00" +
-       "\x00\x00#\xe2b\x10\x00\x00\x00\x00%7\xe4\xa0\x00\x00\x00\x00%Թ\x10\x00\x00\x00\x007\xf6\xb8\xa0\x00\x00\x00\x008\xb8w\x10\x00\x00\x00\x009\xdf\xd5 \x00\x00\x00\x009\xe9\x01\x90\x00\x00\x00\x00;\xc8" +
-       "\xf1\xa0\x00\x00\x00\x00<o\x00\x90\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xe1\x9c\x00\x00\xff\xff\xf1\xf0\x01" +
-       "\x04\xff\xff\xe3\xe0\x00\bLMT\x00-01\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\v\x00\x1c\x00Bra" +
-       "zil/AcreUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x1f\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff" +
-       "\xff\xff\xff\xda\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4" +
-       "\x98\x1b\xd0\xff\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff" +
-       "\xff\xff\xff\xfb\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"" +
-       "\v\xe4\xc0\x00\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0" +
-       "\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00" +
-       "\v\x00\x1c\x00Brazil/EastUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaar\xb4\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff" +
-       "\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T" +
-       "3 \xff\xff\xff\xff\xf4Z\t0\xff\xff\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff" +
-       "\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81" +
-       "i0\x00\x00\x00\x00\"\vȠ\x00\x00\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00" +
-       "\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00,\xc0\xb50\x00\x00\x00\x00-f\xc4 \x00\x00\x00\x00.\xa0\x970\x00\x00\x00\x00/F" +
-       "\xa6 \x00\x00\x00\x000\x80y0\x00\x00\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00\x00\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00" +
-       "\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=\xc4" +
-       "\x910\x00\x00\x00\x00>N\xf0\xa0\x00\x00\x00\x00?\x91\xfe0\x00\x00\x00\x00@.Ҡ\x00\x00\x00\x00A\x86\xf80\x00\x00\x00\x00B\x17\xef \x00\x00\x00\x00CQ\xc20\x00\x00\x00\x00C\xf7\xd1 \x00\x00" +
-       "\x00\x00EMS\xb0\x00\x00\x00\x00E\xe0\xed\xa0\x00\x00\x00\x00G\x11\x860\x00\x00\x00\x00G\xb7\x95 \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\x97w \x00\x00\x00\x00Jڄ\xb0\x00\x00\x00\x00K\x80" +
-       "\x93\xa0\x00\x00\x00\x00L\xbaf\xb0\x00\x00\x00\x00M`u\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x00\x00\x00\x00P\x83e0\x00\x00\x00\x00Q 9\xa0\x00\x00\x00\x00RcG0\x00\x00" +
-       "\x00\x00S\x00\x1b\xa0\x00\x00\x00\x00TC)0\x00\x00\x00\x00T\xe98 \x00\x00\x00\x00V#\v0\x00\x00\x00\x00V\xc9\x1a \x00\x00\x00\x00X\x02\xed0\x00\x00\x00\x00X\xa8\xfc \x00\x00\x00\x00Y\xe2" +
-       "\xcf0\x00\x00\x00\x00Z\x88\xde \x00\x00\x00\x00[\xde`\xb0\x00\x00\x00\x00\\h\xc0 \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd4" +
-       "L\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00" +
-       "\x00\v\x00\x1c\x00Brazil/WestUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x8a\x1c\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\n" +
+       "AEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x15\x00\x1c\x00A" +
+       "ustralia/Broken_HillUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00U\x00\x00\x00\x05\x00\x00\x00\x13\xff\xff\xff\xffs\x16\x88d\xff\xff\xff\xffv\x04\xa5\xe0\xff\xff\xff\xff{\x12\x03p\xff\xff\xff\xff\x9cNɈ\xff\xff\xff\xff\x9c" +
+       "\xbc6\b\xff\xff\xff\xff\xcbT\xba\b\xff\xff\xff\xff\xcb\xc7l\x88\xff\xff\xff\xff̷]\x88\xff\xff\xff\xffͧN\x88\xff\xff\xff\xffΠz\b\xff\xff\xff\xffχ0\x88\x00\x00\x00\x00\x03p@\x88\x00" +
+       "\x00\x00\x00\x04\r#\b\x00\x00\x00\x00\x05P\"\x88\x00\x00\x00\x00\x05\xf6?\x88\x00\x00\x00\x00\a0\x04\x88\x00\x00\x00\x00\a\xd6!\x88\x00\x00\x00\x00\t\x0f\xe6\x88\x00\x00\x00\x00\t\xb6\x03\x88\x00\x00\x00\x00\n" +
+       "\xefȈ\x00\x00\x00\x00\v\x9f \b\x00\x00\x00\x00\f\xd8\xe5\b\x00\x00\x00\x00\r\u007f\x02\b\x00\x00\x00\x00\x0e\xb8\xc7\b\x00\x00\x00\x00\x0f^\xe4\b\x00\x00\x00\x00\x10\x98\xa9\b\x00\x00\x00\x00\x11>\xc6\b\x00" +
+       "\x00\x00\x00\x12x\x8b\b\x00\x00\x00\x00\x13\x1e\xa8\b\x00\x00\x00\x00\x14Xm\b\x00\x00\x00\x00\x14\xfe\x8a\b\x00\x00\x00\x00\x168O\b\x00\x00\x00\x00\x17\f\x90\x88\x00\x00\x00\x00\x18!k\x88\x00\x00\x00\x00\x18" +
+       "Lj\x88\x00\x00\x00\x00\x1a\x01M\x88\x00\x00\x00\x00\x1a\xa7j\x88\x00\x00\x00\x00\x1b\xe1/\x88\x00\x00\x00\x00\x1c\x87L\x88\x00\x00\x00\x00\x1d\xc1\x11\x88\x00\x00\x00\x00\x1ey\xa3\x88\x00\x00\x00\x00\x1f\x97\xb9\b\x00" +
+       "\x00\x00\x00 Y\x85\x88\x00\x00\x00\x00!\x80Ո\x00\x00\x00\x00\"B\xa2\b\x00\x00\x00\x00#i\xf2\b\x00\x00\x00\x00$\"\x84\b\x00\x00\x00\x00%I\xd4\b\x00\x00\x00\x00%\xef\xf1\b\x00\x00\x00\x00'" +
+       ")\xb6\b\x00\x00\x00\x00'\xcf\xd3\b\x00\x00\x00\x00)\t\x98\b\x00\x00\x00\x00)\xaf\xb5\b\x00\x00\x00\x00*\xe9z\b\x00\x00\x00\x00+\x98ш\x00\x00\x00\x00,Җ\x88\x00\x00\x00\x00-x\xb3\x88\x00" +
+       "\x00\x00\x00.\xb2x\x88\x00\x00\x00\x00/X\x95\x88\x00\x00\x00\x000\x92Z\x88\x00\x00\x00\x001]a\x88\x00\x00\x00\x002r<\x88\x00\x00\x00\x003=C\x88\x00\x00\x00\x004R\x1e\x88\x00\x00\x00\x005" +
+       "\x1d%\x88\x00\x00\x00\x0062\x00\x88\x00\x00\x00\x006\xfd\a\x88\x00\x00\x00\x008\x1b\x1d\b\x00\x00\x00\x008\xdc\xe9\x88\x00\x00\x00\x009\xfa\xff\b\x00\x00\x00\x00:\xbcˈ\x00\x00\x00\x00;\xda\xe1\b\x00" +
+       "\x00\x00\x00<\xa5\xe8\b\x00\x00\x00\x00=\xba\xc3\b\x00\x00\x00\x00>\x85\xca\b\x00\x00\x00\x00?\x9a\xa5\b\x00\x00\x00\x00@e\xac\b\x00\x00\x00\x00A\x83\xc1\x88\x00\x00\x00\x00BE\x8e\b\x00\x00\x00\x00C" +
+       "c\xa3\x88\x00\x00\x00\x00D.\xaa\x88\x00\x00\x00\x00EC\x85\x88\x00\x00\x00\x00F\x05R\b\x00\x00\x00\x00G#g\x88\x00\x00\x00\x00G\xf7\xa9\b\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x84\x9c\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\t\x00\x00\x93\xa8\x01\x0e\x00\x00\x85\x98\x00\tLMT\x00AEST\x00ACST\x00ACDT\x00\nAC" +
+       "ST-9:30ACDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?\x95\xbd\x12E\x01\x00\x00E\x01\x00\x00\x12\x00\x1c\x00A" +
+       "ustralia/LindemanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffr\xed\xa2\xd4\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80" +
+       "\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00" +
+       "%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80" +
+       "\x00\x00\x00\x00-x\xac\x80\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8b\xac\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST" +
+       "\x00\nAEST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x13\x00\x1c\x00Australia/MelbourneU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00" +
+       "\x00\x0e\xff\xff\xff\xffs\x16\x85\x18\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff" +
+       "\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6" +
+       "\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00" +
+       "\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168" +
+       "H\x00\x00\x00\x00\x00\x16矀\x00\x00\x00\x00\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00" +
+       "\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!w\x94\x00\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"" +
+       "}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00&\x02_\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00" +
+       "\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/t>\x00\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r" +
+       "5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x004R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00" +
+       "\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e" +
+       "\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00" +
+       "\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x87\xe8\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST" +
+       "\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x12\x00\x1c" +
+       "\x00Australia/BrisbaneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffr\xed\x9f\b\xff\xff\xff\xff\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7" +
+       "e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00" +
+       "\x00\x00%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8fx\x00" +
+       "\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rϻ\xca\x1a2\x01\x00\x002\x01" +
+       "\x00\x00\x0f\x00\x1c\x00Australia/PerthUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft\xa6\x16\xe4\xff\xff\xff\xff\x9cNޠ\xff\xff\xff\xff\x9c\xbcK \xff\xff\xff\xff\xcbT\xcf \xff\xff\xff\xff" +
+       "\xcbǁ\xa0\xff\xff\xff\xff̷r\xa0\xff\xff\xff\xffͧc\xa0\x00\x00\x00\x00\t\x0f\xfb\xa0\x00\x00\x00\x00\t\xb6\x18\xa0\x00\x00\x00\x00\x1a\x01b\xa0\x00\x00\x00\x00\x1a\xa7\u007f\xa0\x00\x00\x00\x00)%\\\xa0" +
+       "\x00\x00\x00\x00)\xaf\xca \x00\x00\x00\x00Eq\xbf \x00\x00\x00\x00F\x05g \x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\ue0e0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I\xcee\xa0\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00l\x9c\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\tLMT\x00AWDT\x00AWST\x00\nAWST-8\nPK\x03\x04\n" +
+       "\x00\x00\x00\x00\x00\xf1c9Ro3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x1c\x00Australia/Lord_HoweUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x05\x00\x00\x00\x19\xff\xff\xff\xffs\x16w\xdc\x00\x00\x00\x00\x14" +
+       "\xfef\xe0\x00\x00\x00\x00\x168@\xf8\x00\x00\x00\x00\x16\xe7\x8ah\x00\x00\x00\x00\x18!]x\x00\x00\x00\x00\x18\xc7lh\x00\x00\x00\x00\x1a\x01?x\x00\x00\x00\x00\x1a\xa7Nh\x00\x00\x00\x00\x1b\xe1!x\x00" +
+       "\x00\x00\x00\x1c\x870h\x00\x00\x00\x00\x1d\xc1\x03x\x00\x00\x00\x00\x1ey\x8ep\x00\x00\x00\x00\x1f\x97\xaa\xf8\x00\x00\x00\x00 Ypp\x00\x00\x00\x00!\x80\xc7x\x00\x00\x00\x00\"B\x8c\xf0\x00\x00\x00\x00#" +
+       "i\xe3\xf8\x00\x00\x00\x00$\"n\xf0\x00\x00\x00\x00%I\xc5\xf8\x00\x00\x00\x00%\xef\xdb\xf0\x00\x00\x00\x00')\xa7\xf8\x00\x00\x00\x00'Ͻ\xf0\x00\x00\x00\x00)\t\x89\xf8\x00\x00\x00\x00)\xaf\x9f\xf0\x00" +
+       "\x00\x00\x00*\xe9k\xf8\x00\x00\x00\x00+\x98\xbcp\x00\x00\x00\x00,҈x\x00\x00\x00\x00-x\x9ep\x00\x00\x00\x00.\xb2jx\x00\x00\x00\x00/X\x80p\x00\x00\x00\x000\x92Lx\x00\x00\x00\x001" +
+       "]Lp\x00\x00\x00\x002r.x\x00\x00\x00\x003=.p\x00\x00\x00\x004R\x10x\x00\x00\x00\x005\x1d\x10p\x00\x00\x00\x0061\xf2x\x00\x00\x00\x006\xfc\xf2p\x00\x00\x00\x008\x1b\x0e\xf8\x00" +
+       "\x00\x00\x008\xdc\xd4p\x00\x00\x00\x009\xa7\xe2x\x00\x00\x00\x00:\xbc\xb6p\x00\x00\x00\x00;\xda\xd2\xf8\x00\x00\x00\x00<\xa5\xd2\xf0\x00\x00\x00\x00=\xba\xb4\xf8\x00\x00\x00\x00>\x85\xb4\xf0\x00\x00\x00\x00?" +
+       "\x9a\x96\xf8\x00\x00\x00\x00@e\x96\xf0\x00\x00\x00\x00A\x83\xb3x\x00\x00\x00\x00BEx\xf0\x00\x00\x00\x00Cc\x95x\x00\x00\x00\x00D.\x95p\x00\x00\x00\x00ECwx\x00\x00\x00\x00F\x05<\xf0\x00" +
+       "\x00\x00\x00G#Yx\x00\x00\x00\x00G\xf7\x93\xf0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x00\x00\x95$\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00\xa1\xb8\x01\t\x00\x00\x93\xa8\x00\x0f\x00\x00\x9a\xb0\x01\x15LMT\x00AEST\x00+1130\x00+103" +
+       "0\x00+11\x00\n<+1030>-10:30<+11>-11,M10.1.0,M4.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rϻ" +
+       "\xca\x1a2\x01\x00\x002\x01\x00\x00\x0e\x00\x1c\x00Australia/WestUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xfft\xa6\x16\xe4\xff\xff\xff\xff\x9cNޠ\xff\xff\xff\xff\x9c\xbcK \xff\xff\xff\xff\xcb" +
+       "T\xcf \xff\xff\xff\xff\xcbǁ\xa0\xff\xff\xff\xff̷r\xa0\xff\xff\xff\xffͧc\xa0\x00\x00\x00\x00\t\x0f\xfb\xa0\x00\x00\x00\x00\t\xb6\x18\xa0\x00\x00\x00\x00\x1a\x01b\xa0\x00\x00\x00\x00\x1a\xa7\u007f\xa0\x00" +
+       "\x00\x00\x00)%\\\xa0\x00\x00\x00\x00)\xaf\xca \x00\x00\x00\x00Eq\xbf \x00\x00\x00\x00F\x05g \x00\x00\x00\x00G#|\xa0\x00\x00\x00\x00G\ue0e0\x00\x00\x00\x00I\x03^\xa0\x00\x00\x00\x00I" +
+       "\xcee\xa0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00l\x9c\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\tLMT\x00AWDT\x00AWST\x00\nAWST-" +
+       "8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x1c\x00Australia/ACTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xffs\x16\u007f<\xff\xff\xff\xff" +
+       "\x9cN\u0080\xff\xff\xff\xff\x9c\xbc/\x00\xff\xff\xff\xff\xcbT\xb3\x00\xff\xff\xff\xff\xcb\xc7e\x80\xff\xff\xff\xff̷V\x80\xff\xff\xff\xffͧG\x80\xff\xff\xff\xffΠs\x00\xff\xff\xff\xffχ)\x80" +
+       "\x00\x00\x00\x00\x03p9\x80\x00\x00\x00\x00\x04\r\x1c\x00\x00\x00\x00\x00\x05P\x1b\x80\x00\x00\x00\x00\x05\xf68\x80\x00\x00\x00\x00\a/\xfd\x80\x00\x00\x00\x00\a\xd6\x1a\x80\x00\x00\x00\x00\t\x0f߀\x00\x00\x00\x00" +
+       "\t\xb5\xfc\x80\x00\x00\x00\x00\n\xef\xc1\x80\x00\x00\x00\x00\v\x9f\x19\x00\x00\x00\x00\x00\f\xd8\xde\x00\x00\x00\x00\x00\r~\xfb\x00\x00\x00\x00\x00\x0e\xb8\xc0\x00\x00\x00\x00\x00\x0f^\xdd\x00\x00\x00\x00\x00\x10\x98\xa2\x00" +
+       "\x00\x00\x00\x00\x11>\xbf\x00\x00\x00\x00\x00\x12x\x84\x00\x00\x00\x00\x00\x13\x1e\xa1\x00\x00\x00\x00\x00\x14Xf\x00\x00\x00\x00\x00\x14\xfe\x83\x00\x00\x00\x00\x00\x168H\x00\x00\x00\x00\x00\x17\f\x89\x80\x00\x00\x00\x00" +
+       "\x18!d\x80\x00\x00\x00\x00\x18ǁ\x80\x00\x00\x00\x00\x1a\x01F\x80\x00\x00\x00\x00\x1a\xa7c\x80\x00\x00\x00\x00\x1b\xe1(\x80\x00\x00\x00\x00\x1c\x87E\x80\x00\x00\x00\x00\x1d\xc1\n\x80\x00\x00\x00\x00\x1ey\x9c\x80" +
+       "\x00\x00\x00\x00\x1f\x97\xb2\x00\x00\x00\x00\x00 Y~\x80\x00\x00\x00\x00!\x80\u0380\x00\x00\x00\x00\"B\x9b\x00\x00\x00\x00\x00#i\xeb\x00\x00\x00\x00\x00$\"}\x00\x00\x00\x00\x00%I\xcd\x00\x00\x00\x00\x00" +
+       "%\xef\xea\x00\x00\x00\x00\x00')\xaf\x00\x00\x00\x00\x00'\xcf\xcc\x00\x00\x00\x00\x00)\t\x91\x00\x00\x00\x00\x00)\xaf\xae\x00\x00\x00\x00\x00*\xe9s\x00\x00\x00\x00\x00+\x98ʀ\x00\x00\x00\x00,ҏ\x80" +
+       "\x00\x00\x00\x00-x\xac\x80\x00\x00\x00\x00.\xb2q\x80\x00\x00\x00\x00/X\x8e\x80\x00\x00\x00\x000\x92S\x80\x00\x00\x00\x001]Z\x80\x00\x00\x00\x002r5\x80\x00\x00\x00\x003=<\x80\x00\x00\x00\x00" +
+       "4R\x17\x80\x00\x00\x00\x005\x1d\x1e\x80\x00\x00\x00\x0061\xf9\x80\x00\x00\x00\x006\xfd\x00\x80\x00\x00\x00\x008\x1b\x16\x00\x00\x00\x00\x008\xdc\xe2\x80\x00\x00\x00\x009\xa7\xe9\x80\x00\x00\x00\x00:\xbcĀ" +
+       "\x00\x00\x00\x00;\xda\xda\x00\x00\x00\x00\x00<\xa5\xe1\x00\x00\x00\x00\x00=\xba\xbc\x00\x00\x00\x00\x00>\x85\xc3\x00\x00\x00\x00\x00?\x9a\x9e\x00\x00\x00\x00\x00@e\xa5\x00\x00\x00\x00\x00A\x83\xba\x80\x00\x00\x00\x00" +
+       "BE\x87\x00\x00\x00\x00\x00Cc\x9c\x80\x00\x00\x00\x00D.\xa3\x80\x00\x00\x00\x00EC~\x80\x00\x00\x00\x00F\x05K\x00\x00\x00\x00\x00G#`\x80\x00\x00\x00\x00G\xf7\xa2\x00\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x8d\xc4\x00\x00\x00\x00\x9a\xb0\x01\x04\x00\x00\x8c\xa0\x00\tLMT\x00AEDT\x00AEST\x00\nAEST-10AEDT," +
+       "M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Brazil/UT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\v\x00\x1c\x00Brazil/E" +
+       "astUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[\x00\x00" +
+       "\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaar\xb4\xff\xff\xff\xff\xb8\x0fI\xe0\xff\xff\xff\xff\xb8\xfd@\xa0\xff\xff\xff\xff\xb9\xf140\xff\xff\xff\xff\xba\xdet \xff\xff\xff\xff\xda8\xae0\xff\xff\xff\xff\xda\xeb" +
+       "\xfa0\xff\xff\xff\xff\xdc\x19\xe1\xb0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xfb\x150\xff\xff\xff\xffޛ\xde \xff\xff\xff\xff\xdfݚ0\xff\xff\xff\xff\xe0T3 \xff\xff\xff\xff\xf4Z\t0\xff\xff" +
+       "\xff\xff\xf5\x05^ \xff\xff\xff\xff\xf6\xc0d0\xff\xff\xff\xff\xf7\x0e\x1e\xa0\xff\xff\xff\xff\xf8Q,0\xff\xff\xff\xff\xf8\xc7\xc5 \xff\xff\xff\xff\xfa\nҰ\xff\xff\xff\xff\xfa\xa8\xf8\xa0\xff\xff\xff\xff\xfb\xec" +
+       "\x060\xff\xff\xff\xff\xfc\x8b}\xa0\x00\x00\x00\x00\x1dɎ0\x00\x00\x00\x00\x1exנ\x00\x00\x00\x00\x1f\xa05\xb0\x00\x00\x00\x00 3Ϡ\x00\x00\x00\x00!\x81i0\x00\x00\x00\x00\"\vȠ\x00\x00" +
+       "\x00\x00#X\x10\xb0\x00\x00\x00\x00#\xe2p \x00\x00\x00\x00%7\xf2\xb0\x00\x00\x00\x00%\xd4\xc7 \x00\x00\x00\x00'!\x0f0\x00\x00\x00\x00'\xbd\xe3\xa0\x00\x00\x00\x00)\x00\xf10\x00\x00\x00\x00)\x94" +
+       "\x8b \x00\x00\x00\x00*\xea\r\xb0\x00\x00\x00\x00+k2\xa0\x00\x00\x00\x00,\xc0\xb50\x00\x00\x00\x00-f\xc4 \x00\x00\x00\x00.\xa0\x970\x00\x00\x00\x00/F\xa6 \x00\x00\x00\x000\x80y0\x00\x00" +
+       "\x00\x001\x1dM\xa0\x00\x00\x00\x002W \xb0\x00\x00\x00\x003\x06j \x00\x00\x00\x0048T0\x00\x00\x00\x004\xf8\xc1 \x00\x00\x00\x006 \x1f0\x00\x00\x00\x006\xcfh\xa0\x00\x00\x00\x007\xf6" +
+       "ư\x00\x00\x00\x008\xb8\x85 \x00\x00\x00\x009\xdf\xe30\x00\x00\x00\x00:\x8f,\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x00<o\x0e\xa0\x00\x00\x00\x00=đ0\x00\x00\x00\x00>N\xf0\xa0\x00\x00" +
+       "\x00\x00?\x91\xfe0\x00\x00\x00\x00@.Ҡ\x00\x00\x00\x00A\x86\xf80\x00\x00\x00\x00B\x17\xef \x00\x00\x00\x00CQ\xc20\x00\x00\x00\x00C\xf7\xd1 \x00\x00\x00\x00EMS\xb0\x00\x00\x00\x00E\xe0" +
+       "\xed\xa0\x00\x00\x00\x00G\x11\x860\x00\x00\x00\x00G\xb7\x95 \x00\x00\x00\x00H\xfa\xa2\xb0\x00\x00\x00\x00I\x97w \x00\x00\x00\x00Jڄ\xb0\x00\x00\x00\x00K\x80\x93\xa0\x00\x00\x00\x00L\xbaf\xb0\x00\x00" +
+       "\x00\x00M`u\xa0\x00\x00\x00\x00N\x9aH\xb0\x00\x00\x00\x00OI\x92 \x00\x00\x00\x00P\x83e0\x00\x00\x00\x00Q 9\xa0\x00\x00\x00\x00RcG0\x00\x00\x00\x00S\x00\x1b\xa0\x00\x00\x00\x00TC" +
+       ")0\x00\x00\x00\x00T\xe98 \x00\x00\x00\x00V#\v0\x00\x00\x00\x00V\xc9\x1a \x00\x00\x00\x00X\x02\xed0\x00\x00\x00\x00X\xa8\xfc \x00\x00\x00\x00Y\xe2\xcf0\x00\x00\x00\x00Z\x88\xde \x00\x00" +
+       "\x00\x00[\xde`\xb0\x00\x00\x00\x00\\h\xc0 \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xd4L\x00\x00\xff\xff\xe3\xe0\x01\x04\xff\xff\xd5" +
+       "\xd0\x00\bLMT\x00-02\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\v\x00\x1c\x00Brazil/" +
+       "AcreUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00" +
+       "\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\x86\x90\xff\xff\xff\xff\xb8\x0ff\x00\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xf1PP\xff\xff\xff\xff\xbaސ@\xff\xff\xff\xff\xda8\xcaP\xff\xff\xff\xff\xda" +
+       "\xec\x16P\xff\xff\xff\xff\xdc\x19\xfd\xd0\xff\xff\xff\xffܹu@\xff\xff\xff\xff\xdd\xfb1P\xff\xff\xff\xffޛ\xfa@\xff\xff\xff\xff\xdfݶP\xff\xff\xff\xff\xe0TO@\xff\xff\xff\xff\xf4\x98\x1b\xd0\xff" +
+       "\xff\xff\xff\xf5\x05z@\xff\xff\xff\xff\xf6\xc0\x80P\xff\xff\xff\xff\xf7\x0e:\xc0\xff\xff\xff\xff\xf8QHP\xff\xff\xff\xff\xf8\xc7\xe1@\xff\xff\xff\xff\xfa\n\xee\xd0\xff\xff\xff\xff\xfa\xa9\x14\xc0\xff\xff\xff\xff\xfb" +
+       "\xec\"P\xff\xff\xff\xff\xfc\x8b\x99\xc0\x00\x00\x00\x00\x1dɪP\x00\x00\x00\x00\x1ex\xf3\xc0\x00\x00\x00\x00\x1f\xa0Q\xd0\x00\x00\x00\x00 3\xeb\xc0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"\v\xe4\xc0\x00" +
+       "\x00\x00\x00H`\u007fP\x00\x00\x00\x00R\u007f\x04\xc0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\xff\xff\xc0p\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff" +
+       "\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\x04LMT\x00-04\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x1c\x00" +
+       "Brazil/DeNoronhaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\u007fD\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff" +
-       "\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0" +
-       "TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff" +
-       "\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!" +
-       "\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff" +
-       "Ǽ\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe6\x9aM\xbem\x02\x00\x00m\x02" +
-       "\x00\x00\x03\x00\x1c\x00CETUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x005\x00\x00\x00\x02\x00\x00\x00\t\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90" +
-       "\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff" +
-       "\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10" +
-       "\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00" +
-       "\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10" +
-       "\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00" +
-       "(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90" +
-       "\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
-       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x05\x00\x00\x1c \x01\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00CST6CDTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86" +
-       "\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff" +
-       "\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a" +
-       "\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00" +
-       "\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12y" +
-       "V\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00" +
-       "\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v" +
-       "\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00" +
-       "\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3" +
-       "Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00" +
-       "\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf" +
-       "\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00" +
-       "\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01" +
-       "\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0" +
-       "\x01\x00\xff\xff\xb9\xb0\x01\b\xff\xff\xb9\xb0\x01\fCDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Canada/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x1c\x00Canada/AtlanticUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xab\xa0\xff\xff\xff\xff\x9a" +
-       "\xe4\xde\xc0\xff\xff\xff\xff\x9b\xd6\x130\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xff\xa2\x9d\x17@\xff\xff\xff\xff\xa30\xb10\xff\xff\xff\xff\xa4zV@\xff\xff\xff\xff\xa5\x1b\x1f0\xff" +
-       "\xff\xff\xff\xa6S\xa0\xc0\xff\xff\xff\xff\xa6\xfcR\xb0\xff\xff\xff\xff\xa8<\xbd@\xff\xff\xff\xff\xa8\xdc4\xb0\xff\xff\xff\xff\xaa\x1c\x9f@\xff\xff\xff\xff\xaa\xcd:0\xff\xff\xff\xff\xab\xfc\x81@\xff\xff\xff\xff\xac" +
-       "\xbf\x910\xff\xff\xff\xff\xad\xee\xd8@\xff\xff\xff\xff\xae\x8c\xfe0\xff\xff\xff\xff\xaf\xbcE@\xff\xff\xff\xff\xb0\u007fU0\xff\xff\xff\xff\xb1\xae\x9c@\xff\xff\xff\xff\xb2Kp\xb0\xff\xff\xff\xff\xb3\x8e~@\xff" +
-       "\xff\xff\xff\xb4$\xbb0\xff\xff\xff\xff\xb5n`@\xff\xff\xff\xff\xb6\x15\xc0\xb0\xff\xff\xff\xff\xb7NB@\xff\xff\xff\xff\xb8\b\x17\xb0\xff\xff\xff\xff\xb9$\xe9\xc0\xff\xff\xff\xff\xb9\xe7\xf9\xb0\xff\xff\xff\xff\xbb" +
-       "\x04\xcb\xc0\xff\xff\xff\xff\xbb\xd1\x160\xff\xff\xff\xff\xbd\x00]@\xff\xff\xff\xff\xbd\x9d1\xb0\xff\xff\xff\xff\xbe\xf2\xb4@\xff\xff\xff\xff\xbf\x90\xda0\xff\xff\xff\xff\xc0\xd3\xe7\xc0\xff\xff\xff\xff\xc1^G0\xff" +
-       "\xff\xff\xff\u008d\x8e@\xff\xff\xff\xff\xc3P\x9e0\xff\xff\xff\xff\xc4mp@\xff\xff\xff\xff\xc50\x800\xff\xff\xff\xff\xc6r<@\xff\xff\xff\xff\xc7\x10b0\xff\xff\xff\xff\xc86n\xc0\xff\xff\xff\xff\xc8" +
-       "\xf9~\xb0\xff\xff\xff\xff\xca\x16P\xc0\xff\xff\xff\xff\xca\xd9`\xb0\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@\xcf\xd0\xff" +
-       "\xff\xff\xff\xd5U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9\x15|\xe0\xff\xff\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xdc\xde{`\xff\xff\xff\xff\xdd" +
-       "\xa9tP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\xff\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3I\x1aP\xff\xff\xff\xff\xe6G\x1f\xe0\xff" +
-       "\xff\xff\xff\xe7\x12\x18\xd0\xff\xff\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe8\xf1\xfa\xd0\xff\xff\xff\xff\xea\x06\xe3\xe0\xff\xff\xff\xff\xea\xd1\xdc\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff챾\xd0\xff\xff\xff\xff\xf1" +
-       "\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_kP\xff\xff\xff\xff\xf5Oj`\xff\xff\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(i\xd0\xff" +
-       "\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff\xff\xff\xff" +
-       "\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@\xd1`\x00" +
-       "\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00\x00\x00\r" +
-       "\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y\x1c\xd0\x00" +
-       "\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00\x00\x00\x1b" +
-       "\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U\xd4\xe0\x00" +
-       "\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00\x00\x00)" +
-       "ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93\nP\x00" +
-       "\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00\x00\x008" +
-       "\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xc2`\x00" +
-       "\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00\x00\x00E" +
-       "\xf3\x9a\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaaed\xff\xff\xff\xff\xb8\x0f;\xd0\xff\xff\xff\xff\xb8\xfd2\x90\xff\xff\xff\xff\xb9\xf1& \xff\xff\xff\xff\xba\xdef\x10\xff" +
+       "\xff\xff\xff\xda8\xa0 \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdc\x19Ӡ\xff\xff\xff\xffܹK\x10\xff\xff\xff\xff\xdd\xfb\a \xff\xff\xff\xffޛ\xd0\x10\xff\xff\xff\xff\xdf\u074c \xff\xff\xff\xff\xe0" +
+       "T%\x10\xff\xff\xff\xff\xf4\x97\xf1\xa0\xff\xff\xff\xff\xf5\x05P\x10\xff\xff\xff\xff\xf6\xc0V \xff\xff\xff\xff\xf7\x0e\x10\x90\xff\xff\xff\xff\xf8Q\x1e \xff\xff\xff\xff\xf8Ƿ\x10\xff\xff\xff\xff\xfa\nĠ\xff" +
+       "\xff\xff\xff\xfa\xa8\xea\x90\xff\xff\xff\xff\xfb\xeb\xf8 \xff\xff\xff\xff\xfc\x8bo\x90\x00\x00\x00\x00\x1dɀ \x00\x00\x00\x00\x1exɐ\x00\x00\x00\x00\x1f\xa0'\xa0\x00\x00\x00\x00 3\xc1\x90\x00\x00\x00\x00!" +
+       "\x81[ \x00\x00\x00\x00\"\v\xba\x90\x00\x00\x00\x00#X\x02\xa0\x00\x00\x00\x00#\xe2b\x10\x00\x00\x00\x00%7\xe4\xa0\x00\x00\x00\x00%Թ\x10\x00\x00\x00\x007\xf6\xb8\xa0\x00\x00\x00\x008\xb8w\x10\x00" +
+       "\x00\x00\x009\xdf\xd5 \x00\x00\x00\x009\xe9\x01\x90\x00\x00\x00\x00;\xc8\xf1\xa0\x00\x00\x00\x00<o\x00\x90\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xe1\x9c\x00\x00\xff\xff\xf1\xf0\x01\x04\xff\xff\xe3\xe0\x00\bLMT\x00-01\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9Ra\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\v\x00\x1c\x00Brazil/WestUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x96\xaa\u007fD\xff\xff\xff\xff\xb8\x0fW\xf0\xff\xff\xff\xff\xb8\xfdN\xb0\xff\xff\xff\xff" +
+       "\xb9\xf1B@\xff\xff\xff\xff\xbaނ0\xff\xff\xff\xff\xda8\xbc@\xff\xff\xff\xff\xda\xec\b@\xff\xff\xff\xff\xdc\x19\xef\xc0\xff\xff\xff\xffܹg0\xff\xff\xff\xff\xdd\xfb#@\xff\xff\xff\xffޛ\xec0" +
+       "\xff\xff\xff\xff\xdfݨ@\xff\xff\xff\xff\xe0TA0\xff\xff\xff\xff\xf4\x98\r\xc0\xff\xff\xff\xff\xf5\x05l0\xff\xff\xff\xff\xf6\xc0r@\xff\xff\xff\xff\xf7\x0e,\xb0\xff\xff\xff\xff\xf8Q:@\xff\xff\xff\xff" +
+       "\xf8\xc7\xd30\xff\xff\xff\xff\xfa\n\xe0\xc0\xff\xff\xff\xff\xfa\xa9\x06\xb0\xff\xff\xff\xff\xfb\xec\x14@\xff\xff\xff\xff\xfc\x8b\x8b\xb0\x00\x00\x00\x00\x1dɜ@\x00\x00\x00\x00\x1ex\xe5\xb0\x00\x00\x00\x00\x1f\xa0C\xc0" +
+       "\x00\x00\x00\x00 3ݰ\x00\x00\x00\x00!\x81w@\x00\x00\x00\x00\"\vְ\x00\x00\x00\x00,\xc0\xc3@\x00\x00\x00\x00-f\xd20\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffǼ\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\bLMT\x00-03\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Canada/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9RU9#\xbe2\x05\x00\x002\x05\x00\x00\x0e\x00\x1c\x00Canada/PacificUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=v\xec\xff\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff" +
+       "\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd3v\x0f \xff\xff\xff\xff\xd4A\b\x10\xff\xff\xff\xff\xd5U\xf1 \xff\xff\xff\xff\xd6 \xea" +
+       "\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff" +
+       "\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^;" +
+       "\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff" +
+       "\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1" +
+       "\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff" +
+       "\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98)" +
+       " \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00" +
+       "\x00\b \xeb\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf" +
+       "\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00" +
+       "\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16" +
+       "\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00" +
+       "\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab" +
+       "\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00" +
+       "\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a" +
+       " \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00" +
+       "\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x03\x04\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\xff\xff\x8c\x94\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT" +
+       ",M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x0e\x00\x1c\x00Canada/Central" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00" +
+       "\x00\x00\x14\xff\xff\xff\xffd䰔\xff\xff\xff\xff\x9b\x01\xfb\xe0\xff\xff\xff\xff\x9búP\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\u00a0;\x80\xff\xff\xff\xff\xc3O\x84\xf0\xff" +
+       "\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xffӈh\x00\xff\xff\xff\xff\xd4S`\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd7" +
+       "5\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xdb\x00\a\x00\xff\xff\xff\xff\xdb\xc8\\\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff" +
+       "\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5" +
+       ")\x18p\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff" +
+       "\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf41b\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa" +
+       "\xf8g\x00\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xfe\x00\x00" +
+       "\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b π\x00\x00\x00\x00\t" +
+       "\x10\xc0\x80\x00\x00\x00\x00\n\x00\xb1\x80\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\x92\x00\x00" +
+       "\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17" +
+       ")\x1a\x00\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00" +
+       "\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%" +
+       "J\xae\x00\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00" +
+       "\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003" +
+       "GX\x00\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005':\x00\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xd9\x00\x00" +
+       "\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A" +
+       "\x84\x9b\x80\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01" +
        "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc4`\x00\x00\xff\xff\xd5\xd0" +
-       "\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11." +
-       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQU9#\xbe2\x05\x00\x002\x05\x00\x00\x0e\x00\x1c\x00Canada/PacificUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^=v\xec\xff" +
-       "\xff\xff\xff\x9e\xb8\xbd\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xd3v\x0f \xff\xff\xff\xff\xd4A\b\x10\xff\xff\xff\xff\xd5" +
-       "U\xf1 \xff\xff\xff\xff\xd6 \xea\x10\xff\xff\xff\xff\xd75\xd3 \xff\xff\xff\xff\xd8\x00\xcc\x10\xff\xff\xff\xff\xd9\x15\xb5 \xff\xff\xff\xff\xd9\xe0\xae\x10\xff\xff\xff\xff\xda\xfeѠ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff" +
-       "\xff\xff\xff\xdc\u07b3\xa0\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x95\xa0\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ew\xa0\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~Y\xa0\xff\xff\xff\xff\xe3" +
-       "IR\x90\xff\xff\xff\xff\xe4^;\xa0\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GX \xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8': \xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x1c \xff" +
-       "\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xfe \xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xe0 \xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xfc\xa0\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1" +
-       "\x8fޠ\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xc0\xa0\xff\xff\xff\xff\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\xa2\xa0\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/\x84\xa0\xff\xff\xff\xff\xf8(\xa2\x10\xff" +
-       "\xff\xff\xff\xf9\x0ff\xa0\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff" +
-       "\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00" +
-       "\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\b \xeb\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\n\x00͠\x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r" +
-       "\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa4\xec\x00\x00\xff\xff\xb9\xb0\x01\x04" +
+       "\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1." +
+       "0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x1c\x00Canada/AtlanticUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x80\xf1\xab\xa0\xff\xff" +
+       "\xff\xff\x9a\xe4\xde\xc0\xff\xff\xff\xff\x9b\xd6\x130\xff\xff\xff\xff\x9e\xb8\x85`\xff\xff\xff\xff\x9f\xba\xddP\xff\xff\xff\xff\xa2\x9d\x17@\xff\xff\xff\xff\xa30\xb10\xff\xff\xff\xff\xa4zV@\xff\xff\xff\xff\xa5\x1b" +
+       "\x1f0\xff\xff\xff\xff\xa6S\xa0\xc0\xff\xff\xff\xff\xa6\xfcR\xb0\xff\xff\xff\xff\xa8<\xbd@\xff\xff\xff\xff\xa8\xdc4\xb0\xff\xff\xff\xff\xaa\x1c\x9f@\xff\xff\xff\xff\xaa\xcd:0\xff\xff\xff\xff\xab\xfc\x81@\xff\xff" +
+       "\xff\xff\xac\xbf\x910\xff\xff\xff\xff\xad\xee\xd8@\xff\xff\xff\xff\xae\x8c\xfe0\xff\xff\xff\xff\xaf\xbcE@\xff\xff\xff\xff\xb0\u007fU0\xff\xff\xff\xff\xb1\xae\x9c@\xff\xff\xff\xff\xb2Kp\xb0\xff\xff\xff\xff\xb3\x8e" +
+       "~@\xff\xff\xff\xff\xb4$\xbb0\xff\xff\xff\xff\xb5n`@\xff\xff\xff\xff\xb6\x15\xc0\xb0\xff\xff\xff\xff\xb7NB@\xff\xff\xff\xff\xb8\b\x17\xb0\xff\xff\xff\xff\xb9$\xe9\xc0\xff\xff\xff\xff\xb9\xe7\xf9\xb0\xff\xff" +
+       "\xff\xff\xbb\x04\xcb\xc0\xff\xff\xff\xff\xbb\xd1\x160\xff\xff\xff\xff\xbd\x00]@\xff\xff\xff\xff\xbd\x9d1\xb0\xff\xff\xff\xff\xbe\xf2\xb4@\xff\xff\xff\xff\xbf\x90\xda0\xff\xff\xff\xff\xc0\xd3\xe7\xc0\xff\xff\xff\xff\xc1^" +
+       "G0\xff\xff\xff\xff\u008d\x8e@\xff\xff\xff\xff\xc3P\x9e0\xff\xff\xff\xff\xc4mp@\xff\xff\xff\xff\xc50\x800\xff\xff\xff\xff\xc6r<@\xff\xff\xff\xff\xc7\x10b0\xff\xff\xff\xff\xc86n\xc0\xff\xff" +
+       "\xff\xff\xc8\xf9~\xb0\xff\xff\xff\xff\xca\x16P\xc0\xff\xff\xff\xff\xca\xd9`\xb0\xff\xff\xff\xffˈ\xe2`\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xed\xd0\xff\xff\xff\xff\xd3u\xd6\xe0\xff\xff\xff\xff\xd4@" +
+       "\xcf\xd0\xff\xff\xff\xff\xd5U\xb8\xe0\xff\xff\xff\xff\xd6 \xb1\xd0\xff\xff\xff\xff\xd75\x9a\xe0\xff\xff\xff\xff\xd8\x00\x93\xd0\xff\xff\xff\xff\xd9\x15|\xe0\xff\xff\xff\xff\xd9\xe0u\xd0\xff\xff\xff\xff\xdc\xde{`\xff\xff" +
+       "\xff\xffݩtP\xff\xff\xff\xff\u07be]`\xff\xff\xff\xff߉VP\xff\xff\xff\xff\xe0\x9e?`\xff\xff\xff\xff\xe1i8P\xff\xff\xff\xff\xe2~!`\xff\xff\xff\xff\xe3I\x1aP\xff\xff\xff\xff\xe6G" +
+       "\x1f\xe0\xff\xff\xff\xff\xe7\x12\x18\xd0\xff\xff\xff\xff\xe8'\x01\xe0\xff\xff\xff\xff\xe8\xf1\xfa\xd0\xff\xff\xff\xff\xea\x06\xe3\xe0\xff\xff\xff\xff\xea\xd1\xdc\xd0\xff\xff\xff\xff\xeb\xe6\xc5\xe0\xff\xff\xff\xff챾\xd0\xff\xff" +
+       "\xff\xff\xf1\x8f\xa6`\xff\xff\xff\xff\xf2\u007f\x89P\xff\xff\xff\xff\xf3o\x88`\xff\xff\xff\xff\xf4_kP\xff\xff\xff\xff\xf5Oj`\xff\xff\xff\xff\xf6?MP\xff\xff\xff\xff\xf7/L`\xff\xff\xff\xff\xf8(" +
+       "i\xd0\xff\xff\xff\xff\xf9\x0f.`\xff\xff\xff\xff\xfa\bK\xd0\xff\xff\xff\xff\xfa\xf8J\xe0\xff\xff\xff\xff\xfb\xe8-\xd0\xff\xff\xff\xff\xfc\xd8,\xe0\xff\xff\xff\xff\xfd\xc8\x0f\xd0\xff\xff\xff\xff\xfe\xb8\x0e\xe0\xff\xff" +
+       "\xff\xff\xff\xa7\xf1\xd0\x00\x00\x00\x00\x00\x97\xf0\xe0\x00\x00\x00\x00\x01\x87\xd3\xd0\x00\x00\x00\x00\x02w\xd2\xe0\x00\x00\x00\x00\x03p\xf0P\x00\x00\x00\x00\x04`\xef`\x00\x00\x00\x00\x05P\xd2P\x00\x00\x00\x00\x06@" +
+       "\xd1`\x00\x00\x00\x00\a0\xb4P\x00\x00\x00\x00\b \xb3`\x00\x00\x00\x00\t\x10\x96P\x00\x00\x00\x00\n\x00\x95`\x00\x00\x00\x00\n\xf0xP\x00\x00\x00\x00\v\xe0w`\x00\x00\x00\x00\fٔ\xd0\x00\x00" +
+       "\x00\x00\r\xc0Y`\x00\x00\x00\x00\x0e\xb9v\xd0\x00\x00\x00\x00\x0f\xa9u\xe0\x00\x00\x00\x00\x10\x99X\xd0\x00\x00\x00\x00\x11\x89W\xe0\x00\x00\x00\x00\x12y:\xd0\x00\x00\x00\x00\x13i9\xe0\x00\x00\x00\x00\x14Y" +
+       "\x1c\xd0\x00\x00\x00\x00\x15I\x1b\xe0\x00\x00\x00\x00\x168\xfe\xd0\x00\x00\x00\x00\x17(\xfd\xe0\x00\x00\x00\x00\x18\"\x1bP\x00\x00\x00\x00\x19\b\xdf\xe0\x00\x00\x00\x00\x1a\x01\xfdP\x00\x00\x00\x00\x1a\xf1\xfc`\x00\x00" +
+       "\x00\x00\x1b\xe1\xdfP\x00\x00\x00\x00\x1c\xd1\xde`\x00\x00\x00\x00\x1d\xc1\xc1P\x00\x00\x00\x00\x1e\xb1\xc0`\x00\x00\x00\x00\x1f\xa1\xa3P\x00\x00\x00\x00 u\xf2\xe0\x00\x00\x00\x00!\x81\x85P\x00\x00\x00\x00\"U" +
+       "\xd4\xe0\x00\x00\x00\x00#j\xa1\xd0\x00\x00\x00\x00$5\xb6\xe0\x00\x00\x00\x00%J\x83\xd0\x00\x00\x00\x00&\x15\x98\xe0\x00\x00\x00\x00'*e\xd0\x00\x00\x00\x00'\xfe\xb5`\x00\x00\x00\x00)\nG\xd0\x00\x00" +
+       "\x00\x00)ޗ`\x00\x00\x00\x00*\xea)\xd0\x00\x00\x00\x00+\xbey`\x00\x00\x00\x00,\xd3FP\x00\x00\x00\x00-\x9e[`\x00\x00\x00\x00.\xb3(P\x00\x00\x00\x00/~=`\x00\x00\x00\x000\x93" +
+       "\nP\x00\x00\x00\x001gY\xe0\x00\x00\x00\x002r\xecP\x00\x00\x00\x003G;\xe0\x00\x00\x00\x004R\xceP\x00\x00\x00\x005'\x1d\xe0\x00\x00\x00\x0062\xb0P\x00\x00\x00\x007\x06\xff\xe0\x00\x00" +
+       "\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xe1\xe0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:\xc6\xc3\xe0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xe0`\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f" +
+       "\xc2`\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@o\xa4`\x00\x00\x00\x00A\x84qP\x00\x00\x00\x00BO\x86`\x00\x00\x00\x00CdSP\x00\x00\x00\x00D/h`\x00\x00\x00\x00ED5P\x00\x00" +
+       "\x00\x00E\xf3\x9a\xe0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xc4`\x00\x00\xff" +
+       "\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xd5\xd0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00ADT\x00AST\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M" +
+       "11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x0f\x00\x1c\x00Canada/MountainUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x88" +
+       "\xde\xce\xe0\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x98\x91\x90\xff\xff\xff\xff\xa0҅\x80\xff\xff\xff\xff\xa2\x8a\xe8\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4jʐ\xff" +
+       "\xff\xff\xff\xa55À\xff\xff\xff\xff\xa6S\xe7\x10\xff\xff\xff\xff\xa7\x15\xa5\x80\xff\xff\xff\xff\xa83\xc9\x10\xff\xff\xff\xff\xa8\xfe\xc2\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2" +
+       "a\x18\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b ݐ\x00" +
+       "\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\n\x00\xbf\x90\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f" +
+       "\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00" +
+       "\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d" +
+       "\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00" +
+       "\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+" +
+       "\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00" +
+       "\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009" +
+       "\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00" +
+       "\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x95\xa0\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MW" +
+       "T\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\f\x00\x1c\x00" +
+       "Canada/YukonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%\xff\xff\xff\xff}\x86\x8a\x9c\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2Ҁ\xff\xff\xff\xff\xcb" +
+       "\x89(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a4 \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xfb\x1d_\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00" +
        "\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b" +
        "\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00" +
        "\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)" +
@@ -3954,169 +4009,103 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008" +
        "\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00" +
        "\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E" +
-       "\xf3\xd3 \x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x8c\x94\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PP" +
-       "T\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x1c\x00Cana" +
-       "da/EasternUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xac\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06" +
-       "\xf0\xff\xff\xff\xff\xa3U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff" +
-       "\xff\xaa\x1c\xc9p\xff\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad܍p\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-" +
-       "\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff" +
-       "\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ" +
-       "\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff" +
-       "\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd" +
-       "\xe0\xff\xff\xff\xff\xd5U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff" +
-       "\xff\xdc\x13t`\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/" +
-       "p\xff\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff" +
-       "\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5" +
-       "`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff" +
-       "\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c" +
-       "\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00" +
-       "\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢" +
-       "\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00" +
-       "\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\n" +
-       "p\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00" +
-       "\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU" +
-       "\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00" +
-       "\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r" +
-       "\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00" +
-       "\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC" +
-       "`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00" +
+       "\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00T" +
+       "U\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00V5Ԑ\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00\x00Z\xa4\xfe \x00" +
+       "\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 \x00\x00\x00\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
+       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
+       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff\x81d\x00\x00\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19\xff\xff\x9d\x90\x01\x1d" +
+       "\xff\xff\x9d\x90\x00!LMT\x00YDT\x00YST\x00YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x1c\x00Canada/NewfoundlandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\b\x00\x00\x00\x19\xff\xff\xff\xff^=4\xec\xff\xff\xff\xff\x9c\xcfb\f\xff\xff\xff" +
+       "\xff\x9d\xa4\xe6\xfc\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff\xff\xff\x9f\xba\xd6|\xff\xff\xff\xff\xa0\xb6\x88\xdc\xff\xff\xff\xff\xa18\xffL\xff\xff\xff\xff\xa2\x95\x19\\\xff\xff\xff\xff\xa3\x84\xfcL\xff\xff\xff\xff\xa4t\xfb" +
+       "\\\xff\xff\xff\xff\xa5d\xdeL\xff\xff\xff\xff\xa6^\x17\xdc\xff\xff\xff\xff\xa7D\xc0L\xff\xff\xff\xff\xa8=\xf9\xdc\xff\xff\xff\xff\xa9$\xa2L\xff\xff\xff\xff\xaa\x1d\xdb\xdc\xff\xff\xff\xff\xab\x04\x84L\xff\xff\xff" +
+       "\xff\xab\xfd\xbd\xdc\xff\xff\xff\xff\xac\xe4fL\xff\xff\xff\xff\xadݟ\xdc\xff\xff\xff\xff\xae͂\xcc\xff\xff\xff\xff\xaf\xbd\x81\xdc\xff\xff\xff\xff\xb0\xadd\xcc\xff\xff\xff\xff\xb1\xa6\x9e\\\xff\xff\xff\xff\xb2\x8dF" +
+       "\xcc\xff\xff\xff\xff\xb3\x86\x80\\\xff\xff\xff\xff\xb4m(\xcc\xff\xff\xff\xff\xb5fb\\\xff\xff\xff\xff\xb6M\n\xcc\xff\xff\xff\xff\xb7FD\\\xff\xff\xff\xff\xb8,\xec\xcc\xff\xff\xff\xff\xb9&&\\\xff\xff\xff" +
+       "\xff\xba\x16\tL\xff\xff\xff\xff\xbb\x0fB\xdc\xff\xff\xff\xff\xbb\xf5\xebL\xff\xff\xff\xff\xbc\xef$\xdc\xff\xff\xff\xff\xbd\xd5\xcdL\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xbe\xcf\x06\xa8\xff\xff\xff\xff\xbf\xb5\xaf" +
+       "\x18\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff\xff\u0098\x138\xff\xff\xff\xff\xc3YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff" +
+       "\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2(\xff\xff\xff\xff\xca ո\xff\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6" +
+       "\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff\xff\xd5h&\xd8\xff\xff\xff\xff\xd6)\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff" +
+       "\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5\xc8\xff\xff\xff\xff\xdc\xdetX\xff\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8" +
+       "X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff\xff\xe3I\x13H\xff\xff\xff\xff\xe4]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff" +
+       "\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc\xd8\xff\xff\xff\xff\xea\xd1\xd5\xc8\xff\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffe" +
+       "H\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff\xff\xf1\x8f\x9fX\xff\xff\xff\xff\xf2\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff" +
+       "\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b\xc8\xff\xff\xff\xff\xf9\x0f'X\xff\xff\xff\xff\xfa\bD\xc8\xff\xff\xff\xff\xfa\xf8C\xd8\xff\xff\xff\xff\xfb\xe8&\xc8\xff\xff\xff\xff\xfc\xd8%" +
+       "\xd8\xff\xff\xff\xff\xfd\xc8\b\xc8\xff\xff\xff\xff\xfe\xb8\a\xd8\xff\xff\xff\xff\xff\xa7\xea\xc8\x00\x00\x00\x00\x00\x97\xe9\xd8\x00\x00\x00\x00\x01\x87\xcc\xc8\x00\x00\x00\x00\x02w\xcb\xd8\x00\x00\x00\x00\x03p\xe9H\x00\x00\x00" +
+       "\x00\x04`\xe8X\x00\x00\x00\x00\x05P\xcbH\x00\x00\x00\x00\x06@\xcaX\x00\x00\x00\x00\a0\xadH\x00\x00\x00\x00\b \xacX\x00\x00\x00\x00\t\x10\x8fH\x00\x00\x00\x00\n\x00\x8eX\x00\x00\x00\x00\n\xf0q" +
+       "H\x00\x00\x00\x00\v\xe0pX\x00\x00\x00\x00\fٍ\xc8\x00\x00\x00\x00\r\xc0RX\x00\x00\x00\x00\x0e\xb9o\xc8\x00\x00\x00\x00\x0f\xa9n\xd8\x00\x00\x00\x00\x10\x99Q\xc8\x00\x00\x00\x00\x11\x89P\xd8\x00\x00\x00" +
+       "\x00\x12y3\xc8\x00\x00\x00\x00\x13i2\xd8\x00\x00\x00\x00\x14Y\x15\xc8\x00\x00\x00\x00\x15I\x14\xd8\x00\x00\x00\x00\x168\xf7\xc8\x00\x00\x00\x00\x17(\xf6\xd8\x00\x00\x00\x00\x18\"\x14H\x00\x00\x00\x00\x19\b\xd8" +
+       "\xd8\x00\x00\x00\x00\x1a\x01\xf6H\x00\x00\x00\x00\x1a\xf1\xf5X\x00\x00\x00\x00\x1b\xe1\xd8H\x00\x00\x00\x00\x1c\xd1\xd7X\x00\x00\x00\x00\x1d\xc1\xbaH\x00\x00\x00\x00\x1e\xb1\xb9X\x00\x00\x00\x00\x1f\xa1\x9cH\x00\x00\x00" +
+       "\x00 u\xcf\xf4\x00\x00\x00\x00!\x81bd\x00\x00\x00\x00\"U\xb1\xf4\x00\x00\x00\x00#jp\xd4\x00\x00\x00\x00$5\x93\xf4\x00\x00\x00\x00%J`\xe4\x00\x00\x00\x00&\x15u\xf4\x00\x00\x00\x00'*B" +
+       "\xe4\x00\x00\x00\x00'\xfe\x92t\x00\x00\x00\x00)\n$\xe4\x00\x00\x00\x00)\xdett\x00\x00\x00\x00*\xea\x06\xe4\x00\x00\x00\x00+\xbeVt\x00\x00\x00\x00,\xd3#d\x00\x00\x00\x00-\x9e8t\x00\x00\x00" +
+       "\x00.\xb3\x05d\x00\x00\x00\x00/~\x1at\x00\x00\x00\x000\x92\xe7d\x00\x00\x00\x001g6\xf4\x00\x00\x00\x002r\xc9d\x00\x00\x00\x003G\x18\xf4\x00\x00\x00\x004R\xabd\x00\x00\x00\x005&\xfa" +
+       "\xf4\x00\x00\x00\x0062\x8dd\x00\x00\x00\x007\x06\xdc\xf4\x00\x00\x00\x008\x1b\xa9\xe4\x00\x00\x00\x008\xe6\xbe\xf4\x00\x00\x00\x009\xfb\x8b\xe4\x00\x00\x00\x00:Ơ\xf4\x00\x00\x00\x00;\xdbm\xe4\x00\x00\x00" +
+       "\x00<\xaf\xbdt\x00\x00\x00\x00=\xbbO\xe4\x00\x00\x00\x00>\x8f\x9ft\x00\x00\x00\x00?\x9b1\xe4\x00\x00\x00\x00@o\x81t\x00\x00\x00\x00A\x84Nd\x00\x00\x00\x00BOct\x00\x00\x00\x00Cd0" +
+       "d\x00\x00\x00\x00D/Et\x00\x00\x00\x00ED\x12d\x00\x00\x00\x00E\xf3w\xf4\x00\x00\x00\x00G-.\xe4\x00\x00\x00\x00G\xd3Y\xf4\x00\x00\x00\x00I\r\x10\xe4\x00\x00\x00\x00I\xb3;\xf4\x00\x00\x00" +
+       "\x00J\xec\xf2\xe4\x00\x00\x00\x00K\x9cXt\x00\x00\x00\x00L\xd6\x0fd\x00\x00\x00\x00M|:t\x00\x00\x00\x00N\xb6\rH\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x06\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xffΔ\x00\x00\xff\xffܤ\x01\x04\xff\xffΔ" +
+       "\x00\b\xff\xff\xdc\xd8\x01\x04\xff\xff\xce\xc8\x00\b\xff\xff\xdc\xd8\x01\f\xff\xff\xdc\xd8\x01\x10\xff\xff\xea\xe8\x01\x14LMT\x00NDT\x00NST\x00NPT\x00NWT\x00NDDT\x00\nNS" +
+       "T3:30NDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x1c\x00Canada" +
+       "/EasternUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xac\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffr\xeex\xec\xff\xff\xff\xff\x9e\xb8\x93p\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x87.\xc8\xff\xff\xff\xff\xa1\x9a\xb1@\xff\xff\xff\xff\xa2\x94\x06\xf0\xff" +
+       "\xff\xff\xff\xa3U\xa9@\xff\xff\xff\xff\xa4\x86]\xf0\xff\xff\xff\xff\xa5(x`\xff\xff\xff\xff\xa6f?\xf0\xff\xff\xff\xff\xa7\fN\xe0\xff\xff\xff\xff\xa8F!\xf0\xff\xff\xff\xff\xa8\xec0\xe0\xff\xff\xff\xff\xaa" +
+       "\x1c\xc9p\xff\xff\xff\xff\xaa\xd5M`\xff\xff\xff\xff\xab\xfc\xabp\xff\xff\xff\xff\xac\xb5/`\xff\xff\xff\xff\xad܍p\xff\xff\xff\xff\xae\x95\x11`\xff\xff\xff\xff\xaf\xbcop\xff\xff\xff\xff\xb0~-\xe0\xff" +
+       "\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8" +
+       "\x06\xf0`\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff" +
+       "\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6" +
+       "M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff" +
+       "\xff\xff\xff\xd5U\xaa\xd0\xff\xff\xff\xff\xd6 \xa3\xc0\xff\xff\xff\xff\xd75\x8c\xd0\xff\xff\xff\xff\xd8\x00\x85\xc0\xff\xff\xff\xff\xd9\x15n\xd0\xff\xff\xff\xff\xda3v@\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdc" +
+       "\x13t`\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff" +
+       "\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5)\n`\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe7\x12&\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea" +
+       "\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff" +
+       "\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8" +
+       "(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff" +
+       "\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06" +
+       "@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\b \xc1p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00" +
+       "\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14" +
+       "Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00" +
+       "\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"" +
+       "U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00" +
+       "\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000" +
+       "\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00" +
+       "\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>" +
+       "\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00" +
+       "\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x04\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\xff\xff\xb5\x94\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT," +
-       "M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\f\x00\x1c\x00Canada/YukonUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\t\x00\x00\x00%" +
-       "\xff\xff\xff\xff}\x86\x8a\x9c\xff\xff\xff\xff\x9e\xb8˰\xff\xff\xff\xff\x9f\xbb#\xa0\xff\xff\xff\xff\xa0\xd0\f\xb0\xff\xff\xff\xff\xa1\xa2Ҁ\xff\xff\xff\xffˉ(\xb0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff" +
-       "\xd2a4 \xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xfb\x1d_\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10" +
-       "\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00" +
-       "\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef " +
-       "\x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00" +
-       "+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90" +
-       "\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x00" +
-       "9\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ" +
-       "\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x00\x00\x00\x00G-\x8a\x10\x00\x00\x00\x00" +
-       "Gӵ \x00\x00\x00\x00I\rl\x10\x00\x00\x00\x00I\xb3\x97 \x00\x00\x00\x00J\xedN\x10\x00\x00\x00\x00K\x9c\xb3\xa0\x00\x00\x00\x00L\xd6j\x90\x00\x00\x00\x00M|\x95\xa0\x00\x00\x00\x00N\xb6L\x90" +
-       "\x00\x00\x00\x00O\\w\xa0\x00\x00\x00\x00P\x96.\x90\x00\x00\x00\x00Q<Y\xa0\x00\x00\x00\x00Rv\x10\x90\x00\x00\x00\x00S\x1c;\xa0\x00\x00\x00\x00TU\xf2\x90\x00\x00\x00\x00T\xfc\x1d\xa0\x00\x00\x00\x00" +
-       "V5Ԑ\x00\x00\x00\x00V\xe5: \x00\x00\x00\x00X\x1e\xf1\x10\x00\x00\x00\x00X\xc5\x1c \x00\x00\x00\x00Y\xfe\xd3\x10\x00\x00\x00\x00Z\xa4\xfe \x00\x00\x00\x00[\u07b5\x10\x00\x00\x00\x00\\\x84\xe0 " +
-       "\x00\x00\x00\x00]\xbe\x97\x10\x00\x00\x00\x00^d\xc2 \x00\x00\x00\x00_\x9e\\\xf0\x02\x01\x02\x01\x02\x03\x04\x02\x05\x02\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a" +
-       "\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\b\xff\xff\x81" +
-       "d\x00\x00\xff\xff\x8f\x80\x01\x04\xff\xff\x81p\x00\b\xff\xff\x8f\x80\x01\f\xff\xff\x8f\x80\x01\x10\xff\xff\x9d\x90\x01\x14\xff\xff\x8f\x80\x00\x19\xff\xff\x9d\x90\x01\x1d\xff\xff\x9d\x90\x00!LMT\x00YDT\x00Y" +
-       "ST\x00YWT\x00YPT\x00YDDT\x00PST\x00PDT\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\u0096dK~\x02\x00\x00~\x02\x00\x00" +
-       "\x13\x00\x1c\x00Canada/SaskatchewanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x86\xfd\x93\x1c\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xb5eO\xf0\xff\xff" +
-       "\xff\xff\xb60H\xe0\xff\xff\xff\xff\xb7E1\xf0\xff\xff\xff\xff\xb8\x10*\xe0\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xbb\x0e0p\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xee" +
-       "\x12p\xff\xff\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xc2r\b\xf0\xff\xff\xff\xff\xc3a\xeb\xe0\xff\xff\xff\xff\xc4Q\xea\xf0\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc61\xcc\xf0\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff" +
-       "\xff\xff\xc8\x1a\xe9p\xff\xff\xff\xff\xc9\n\xcc`\xff\xff\xff\xff\xc9\xfa\xcbp\xff\xff\xff\xff\xca\xea\xae`\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3c" +
-       "\x8c\x10\xff\xff\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 \xdc\x00\xff\xff\xff\xff\xd75\xc5\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff" +
-       "\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x82\x00\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\x9e\x80\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff߉\x80\x80\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1i" +
-       "b\x80\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3ID\x80\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)&\x80\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12C\x00\xff\xff\xff\xff\xe8',\x10\xff\xff" +
-       "\xff\xff\xe8\xf2%\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xd6\xd3\x00\xff\xff\xff\xff\xed\xc6\xd2\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\xff\xff\x9d\xe4\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14L" +
-       "MT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x1c\x00C" +
-       "anada/NewfoundlandUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\b\x00\x00\x00\x19\xff\xff\xff\xff^=4\xec\xff\xff\xff\xff\x9c\xcfb\f\xff\xff\xff\xff\x9d\xa4\xe6\xfc\xff\xff\xff\xff\x9e\xb8~\x8c\xff\xff\xff\xff\x9f\xba\xd6" +
-       "|\xff\xff\xff\xff\xa0\xb6\x88\xdc\xff\xff\xff\xff\xa18\xffL\xff\xff\xff\xff\xa2\x95\x19\\\xff\xff\xff\xff\xa3\x84\xfcL\xff\xff\xff\xff\xa4t\xfb\\\xff\xff\xff\xff\xa5d\xdeL\xff\xff\xff\xff\xa6^\x17\xdc\xff\xff\xff" +
-       "\xff\xa7D\xc0L\xff\xff\xff\xff\xa8=\xf9\xdc\xff\xff\xff\xff\xa9$\xa2L\xff\xff\xff\xff\xaa\x1d\xdb\xdc\xff\xff\xff\xff\xab\x04\x84L\xff\xff\xff\xff\xab\xfd\xbd\xdc\xff\xff\xff\xff\xac\xe4fL\xff\xff\xff\xff\xadݟ" +
-       "\xdc\xff\xff\xff\xff\xae͂\xcc\xff\xff\xff\xff\xaf\xbd\x81\xdc\xff\xff\xff\xff\xb0\xadd\xcc\xff\xff\xff\xff\xb1\xa6\x9e\\\xff\xff\xff\xff\xb2\x8dF\xcc\xff\xff\xff\xff\xb3\x86\x80\\\xff\xff\xff\xff\xb4m(\xcc\xff\xff\xff" +
-       "\xff\xb5fb\\\xff\xff\xff\xff\xb6M\n\xcc\xff\xff\xff\xff\xb7FD\\\xff\xff\xff\xff\xb8,\xec\xcc\xff\xff\xff\xff\xb9&&\\\xff\xff\xff\xff\xba\x16\tL\xff\xff\xff\xff\xbb\x0fB\xdc\xff\xff\xff\xff\xbb\xf5\xeb" +
-       "L\xff\xff\xff\xff\xbc\xef$\xdc\xff\xff\xff\xff\xbd\xd5\xcdL\xff\xff\xff\xff\xbe\x9eMl\xff\xff\xff\xff\xbe\xcf\x06\xa8\xff\xff\xff\xff\xbf\xb5\xaf\x18\xff\xff\xff\xff\xc0\xb818\xff\xff\xff\xff\xc1y\xef\xa8\xff\xff\xff" +
-       "\xff\u0098\x138\xff\xff\xff\xff\xc3YѨ\xff\xff\xff\xff\xc4w\xf58\xff\xff\xff\xff\xc59\xb3\xa8\xff\xff\xff\xff\xc6a\x11\xb8\xff\xff\xff\xff\xc7\x19\x95\xa8\xff\xff\xff\xff\xc8@\xf3\xb8\xff\xff\xff\xff\xc9\x02\xb2" +
-       "(\xff\xff\xff\xff\xca ո\xff\xff\xff\xff\xca\xe2\x94(\xff\xff\xff\xff\xcc\x00\xb7\xb8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xe6\xc8\xff\xff\xff\xffӈD\xd8\xff\xff\xff\xff\xd4J\x03H\xff\xff\xff" +
-       "\xff\xd5h&\xd8\xff\xff\xff\xff\xd6)\xe5H\xff\xff\xff\xff\xd7H\b\xd8\xff\xff\xff\xff\xd8\t\xc7H\xff\xff\xff\xff\xd9'\xea\xd8\xff\xff\xff\xff\xd9\xe9\xa9H\xff\xff\xff\xff\xdb\x11\aX\xff\xff\xff\xff\xdb\xd2\xc5" +
-       "\xc8\xff\xff\xff\xff\xdc\xdetX\xff\xff\xff\xffݩmH\xff\xff\xff\xff\u07beVX\xff\xff\xff\xff߉OH\xff\xff\xff\xff\xe0\x9e8X\xff\xff\xff\xff\xe1i1H\xff\xff\xff\xff\xe2~\x1aX\xff\xff\xff" +
-       "\xff\xe3I\x13H\xff\xff\xff\xff\xe4]\xfcX\xff\xff\xff\xff\xe5(\xf5H\xff\xff\xff\xff\xe6G\x18\xd8\xff\xff\xff\xff\xe7\x12\x11\xc8\xff\xff\xff\xff\xe8&\xfa\xd8\xff\xff\xff\xff\xe8\xf1\xf3\xc8\xff\xff\xff\xff\xea\x06\xdc" +
-       "\xd8\xff\xff\xff\xff\xea\xd1\xd5\xc8\xff\xff\xff\xff\xeb\xe6\xbe\xd8\xff\xff\xff\xff챷\xc8\xff\xff\xff\xff\xedƠ\xd8\xff\xff\xff\xff\ueffeH\xff\xff\xff\xffﯽX\xff\xff\xff\xff\xf0\x9f\xa0H\xff\xff\xff" +
-       "\xff\xf1\x8f\x9fX\xff\xff\xff\xff\xf2\u007f\x82H\xff\xff\xff\xff\xf3o\x81X\xff\xff\xff\xff\xf4_dH\xff\xff\xff\xff\xf5OcX\xff\xff\xff\xff\xf6?FH\xff\xff\xff\xff\xf7/EX\xff\xff\xff\xff\xf8(b" +
-       "\xc8\xff\xff\xff\xff\xf9\x0f'X\xff\xff\xff\xff\xfa\bD\xc8\xff\xff\xff\xff\xfa\xf8C\xd8\xff\xff\xff\xff\xfb\xe8&\xc8\xff\xff\xff\xff\xfc\xd8%\xd8\xff\xff\xff\xff\xfd\xc8\b\xc8\xff\xff\xff\xff\xfe\xb8\a\xd8\xff\xff\xff" +
-       "\xff\xff\xa7\xea\xc8\x00\x00\x00\x00\x00\x97\xe9\xd8\x00\x00\x00\x00\x01\x87\xcc\xc8\x00\x00\x00\x00\x02w\xcb\xd8\x00\x00\x00\x00\x03p\xe9H\x00\x00\x00\x00\x04`\xe8X\x00\x00\x00\x00\x05P\xcbH\x00\x00\x00\x00\x06@\xca" +
-       "X\x00\x00\x00\x00\a0\xadH\x00\x00\x00\x00\b \xacX\x00\x00\x00\x00\t\x10\x8fH\x00\x00\x00\x00\n\x00\x8eX\x00\x00\x00\x00\n\xf0qH\x00\x00\x00\x00\v\xe0pX\x00\x00\x00\x00\fٍ\xc8\x00\x00\x00" +
-       "\x00\r\xc0RX\x00\x00\x00\x00\x0e\xb9o\xc8\x00\x00\x00\x00\x0f\xa9n\xd8\x00\x00\x00\x00\x10\x99Q\xc8\x00\x00\x00\x00\x11\x89P\xd8\x00\x00\x00\x00\x12y3\xc8\x00\x00\x00\x00\x13i2\xd8\x00\x00\x00\x00\x14Y\x15" +
-       "\xc8\x00\x00\x00\x00\x15I\x14\xd8\x00\x00\x00\x00\x168\xf7\xc8\x00\x00\x00\x00\x17(\xf6\xd8\x00\x00\x00\x00\x18\"\x14H\x00\x00\x00\x00\x19\b\xd8\xd8\x00\x00\x00\x00\x1a\x01\xf6H\x00\x00\x00\x00\x1a\xf1\xf5X\x00\x00\x00" +
-       "\x00\x1b\xe1\xd8H\x00\x00\x00\x00\x1c\xd1\xd7X\x00\x00\x00\x00\x1d\xc1\xbaH\x00\x00\x00\x00\x1e\xb1\xb9X\x00\x00\x00\x00\x1f\xa1\x9cH\x00\x00\x00\x00 u\xcf\xf4\x00\x00\x00\x00!\x81bd\x00\x00\x00\x00\"U\xb1" +
-       "\xf4\x00\x00\x00\x00#jp\xd4\x00\x00\x00\x00$5\x93\xf4\x00\x00\x00\x00%J`\xe4\x00\x00\x00\x00&\x15u\xf4\x00\x00\x00\x00'*B\xe4\x00\x00\x00\x00'\xfe\x92t\x00\x00\x00\x00)\n$\xe4\x00\x00\x00" +
-       "\x00)\xdett\x00\x00\x00\x00*\xea\x06\xe4\x00\x00\x00\x00+\xbeVt\x00\x00\x00\x00,\xd3#d\x00\x00\x00\x00-\x9e8t\x00\x00\x00\x00.\xb3\x05d\x00\x00\x00\x00/~\x1at\x00\x00\x00\x000\x92\xe7" +
-       "d\x00\x00\x00\x001g6\xf4\x00\x00\x00\x002r\xc9d\x00\x00\x00\x003G\x18\xf4\x00\x00\x00\x004R\xabd\x00\x00\x00\x005&\xfa\xf4\x00\x00\x00\x0062\x8dd\x00\x00\x00\x007\x06\xdc\xf4\x00\x00\x00" +
-       "\x008\x1b\xa9\xe4\x00\x00\x00\x008\xe6\xbe\xf4\x00\x00\x00\x009\xfb\x8b\xe4\x00\x00\x00\x00:Ơ\xf4\x00\x00\x00\x00;\xdbm\xe4\x00\x00\x00\x00<\xaf\xbdt\x00\x00\x00\x00=\xbbO\xe4\x00\x00\x00\x00>\x8f\x9f" +
-       "t\x00\x00\x00\x00?\x9b1\xe4\x00\x00\x00\x00@o\x81t\x00\x00\x00\x00A\x84Nd\x00\x00\x00\x00BOct\x00\x00\x00\x00Cd0d\x00\x00\x00\x00D/Et\x00\x00\x00\x00ED\x12d\x00\x00\x00" +
-       "\x00E\xf3w\xf4\x00\x00\x00\x00G-.\xe4\x00\x00\x00\x00G\xd3Y\xf4\x00\x00\x00\x00I\r\x10\xe4\x00\x00\x00\x00I\xb3;\xf4\x00\x00\x00\x00J\xec\xf2\xe4\x00\x00\x00\x00K\x9cXt\x00\x00\x00\x00L\xd6\x0f" +
-       "d\x00\x00\x00\x00M|:t\x00\x00\x00\x00N\xb6\rH\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x06\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\xff\xffΔ\x00\x00\xff\xffܤ\x01\x04\xff\xffΔ\x00\b\xff\xff\xdc\xd8\x01\x04\xff\xff\xce\xc8\x00\b\xff\xff\xdc\xd8\x01\f" +
-       "\xff\xff\xdc\xd8\x01\x10\xff\xff\xea\xe8\x01\x14LMT\x00NDT\x00NST\x00NPT\x00NWT\x00NDDT\x00\nNST3:30NDT,M3.2.0,M11." +
-       "1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x0e\x00\x1c\x00Canada/CentralUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xffd䰔\xff" +
-       "\xff\xff\xff\x9b\x01\xfb\xe0\xff\xff\xff\xff\x9búP\xff\xff\xff\xff\x9e\xb8\xa1\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\u00a0;\x80\xff\xff\xff\xff\xc3O\x84\xf0\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2" +
-       "#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xffӈh\x00\xff\xff\xff\xff\xd4S`\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff" +
-       "\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xdb\x00\a\x00\xff\xff\xff\xff\xdb\xc8\\\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff\xdf" +
-       "\x89rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5)\x18p\xff\xff\xff\xff\xe6G<\x00\xff" +
-       "\xff\xff\xff\xe7\x124\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed" +
-       "\xc6\xc4\x00\xff\xff\xff\xff\ue47c\xf0\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf41b\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8X\x00\xff" +
-       "\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03" +
-       "q\x1a\x80\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b π\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\n\x00\xb1\x80\x00" +
-       "\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11" +
-       "\x89t\x00\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"E\x80\x00" +
-       "\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f" +
-       "\xa1̀\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xb5\x00\x00" +
-       "\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-" +
-       "\x9ew\x80\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xf8\x80\x00" +
-       "\x00\x00\x005':\x00\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;" +
-       "ۻ\x00\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xa2\x80\x00" +
-       "\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xa4\xec\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f" +
-       "\xff\xff\xb9\xb0\x01\x10LMT\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x0f\x00\x1c\x00Canada/MountainUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Y\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\x88\xde\xce\xe0\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb" +
-       "\a\x80\xff\xff\xff\xff\xa0\x98\x91\x90\xff\xff\xff\xff\xa0҅\x80\xff\xff\xff\xff\xa2\x8a\xe8\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4jʐ\xff\xff\xff\xff\xa55À\xff\xff\xff\xff\xa6S\xe7\x10\xff\xff" +
-       "\xff\xff\xa7\x15\xa5\x80\xff\xff\xff\xff\xa83\xc9\x10\xff\xff\xff\xff\xa8\xfe\xc2\x00\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff\xff\xd6 " +
-       "\xdc\x00\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\b ݐ\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\n\x00\xbf\x90\x00\x00" +
-       "\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89" +
-       "\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00" +
-       "\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1" +
-       "̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00" +
-       "\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e" +
-       "\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00" +
-       "\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;\xdb" +
-       "\xbb\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00" +
-       "\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff" +
-       "\xff\x95\xa0\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3" +
-       ".2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x1c\x00Chile/UT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x12\x00\x1c\x00Chile/EasterI" +
-       "slandUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f" +
-       "\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87B\b\xff\xff\xff\xff\xb9\xc7@\x88\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00" +
-       "\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0" +
-       "\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00" +
-       "\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0" +
-       "\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00" +
-       "\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0" +
-       "\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00" +
-       "+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@" +
-       "\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x00" +
-       "9\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ" +
-       "\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00" +
-       "G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0" +
-       "\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00" +
-       "W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\x99x\x00\x00\xff\xff\x99x\x00\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0" +
-       "\x01\x10LMT\x00EMT\x00-06\x00-07\x00-05\x00\n<-06>6<-05>,M9.1.6/22,M4.1.6/22\nPK\x03\x04\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x11\x00\x1c\x00Chile/ContinentalUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87\x1d\xc6\xff\xff\xff\xff\x8f0G" +
-       "F\xff\xff\xff\xff\x9b\\\xe5P\xff\xff\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@\xff\xff\xff\xff\xb2A\x00\xd0\xff\xff\xff\xff\xb3Xp\xc0\xff\xff\xff" +
-       "\xff\xb4\"4P\xff\xff\xff\xff\xb59\xa4@\xff\xff\xff\xff\xb6\x03g\xd0\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff\xb8\xfd\\\xc0\xff\xff\xff\xff\xb9\xc7 P\xff\xff\xff\xff\xcc\x1cn" +
-       "@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff\xff\xff\xd3\u070f\xc0\xff\xff\xff\xff\xd4\x1bɰ\xff\xff\xff\xff\xd53U\xc0\xff\xff\xff\xff\xd5v\x92@\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff" +
+       "\xff\xb5\x94\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3" +
+       ".2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\u0096dK~\x02\x00\x00~\x02\x00\x00\x13\x00\x1c\x00Canada/Saskatchew" +
+       "anUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00" +
+       "\x06\x00\x00\x00\x18\xff\xff\xff\xff\x86\xfd\x93\x1c\xff\xff\xff\xff\x9e\xb8\xaf\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xb5eO\xf0\xff\xff\xff\xff\xb60H\xe0\xff\xff\xff\xff\xb7E1\xf0\xff\xff\xff\xff\xb8\x10*" +
+       "\xe0\xff\xff\xff\xff\xb9%\x13\xf0\xff\xff\xff\xff\xb9\xf0\f\xe0\xff\xff\xff\xff\xbb\x0e0p\xff\xff\xff\xff\xbb\xcf\xee\xe0\xff\xff\xff\xff\xbc\xee\x12p\xff\xff\xff\xff\xbd\xb9\v`\xff\xff\xff\xff\xc2r\b\xf0\xff\xff\xff" +
+       "\xff\xc3a\xeb\xe0\xff\xff\xff\xff\xc4Q\xea\xf0\xff\xff\xff\xff\xc58\x93`\xff\xff\xff\xff\xc61\xcc\xf0\xff\xff\xff\xff\xc7!\xaf\xe0\xff\xff\xff\xff\xc8\x1a\xe9p\xff\xff\xff\xff\xc9\n\xcc`\xff\xff\xff\xff\xc9\xfa\xcb" +
+       "p\xff\xff\xff\xff\xca\xea\xae`\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xd3c\x8c\x10\xff\xff\xff\xff\xd4So\x00\xff\xff\xff\xff\xd5U\xe3\x10\xff\xff\xff" +
+       "\xff\xd6 \xdc\x00\xff\xff\xff\xff\xd75\xc5\x10\xff\xff\xff\xff\xd8\x00\xbe\x00\xff\xff\xff\xff\xd9\x15\xa7\x10\xff\xff\xff\xff\xd9\xe0\xa0\x00\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x82\x00\xff\xff\xff\xff\xdcޥ" +
+       "\x90\xff\xff\xff\xffݩ\x9e\x80\xff\xff\xff\xff\u07be\x87\x90\xff\xff\xff\xff߉\x80\x80\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ib\x80\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3ID\x80\xff\xff\xff" +
+       "\xff\xe4^-\x90\xff\xff\xff\xff\xe5)&\x80\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12C\x00\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf2%\x00\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xd6\xd3" +
+       "\x00\xff\xff\xff\xff\xed\xc6\xd2\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x05\xff\xff\x9d\xe4\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10\xff\xff\xab\xa0\x00\x14LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CS" +
+       "T\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe6\x9aM\xbem\x02\x00\x00m\x02\x00\x00\x03\x00\x1c\x00CETUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x02\x00\x00\x00\t\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0" +
+       "\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff" +
+       "\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90" +
+       "\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00" +
+       "\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10" +
+       "\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00" +
+       "%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90" +
+       "\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
+       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x05\x00\x00\x1c \x01\x00CEST\x00CE" +
+       "T\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x1c\x00" +
+       "Chile/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00" +
+       "\x12\x00\x1c\x00Chile/EasterIslandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87B\b\xff\xff\xff\xff\xb9\xc7@\x88\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff" +
        "\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r" +
        "\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00" +
        "\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99" +
@@ -4130,331 +4119,418 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:" +
        "@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00" +
        "\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g" +
-       "\xb0\x01\x02\x01\x03\x01\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x05\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
-       "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
-       "\x03\x05\x03\xff\xff\xbd\xba\x00\x00\xff\xff\xbd\xba\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00SMT\x00-05\x00-04\x00-03\x00\n" +
-       "<-04>4<-03>,M9.1.6/24,M4.1.6/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x04\x00" +
-       "\x1c\x00CubaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "j\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87(\xb8\xff\xff\xff\xff\xacb\u0080\xff\xff\xff\xff\xb1ӔP\xff\xff\xff\xff\xb2t]@\xff\xff\xff\xff\xc8[f\xd0\xff\xff\xff\xff\xc8\xd3Q@\xff\xff\xff" +
-       "\xff\xca;H\xd0\xff\xff\xff\xffʼm\xc0\xff\xff\xff\xff\xcc$eP\xff\xff\xff\xff̜O\xc0\xff\xff\xff\xff\xd1\xc4\vP\xff\xff\xff\xff\xd2;\xf5\xc0\xff\xff\xff\xffӣ\xedP\xff\xff\xff\xff\xd4\x1b\xd7" +
-       "\xc0\xff\xff\xff\xff\xf7`\x05\xd0\xff\xff\xff\xff\xf7\xff}@\xff\xff\xff\xff\xf9=D\xd0\xff\xff\xff\xff\xf9\xe3S\xc0\xff\xff\xff\xff\xfa\xdb;\xd0\xff\xff\xff\xff\xfb\xa7\x86@\xff\xff\xff\xff\xfcũ\xd0\xff\xff\xff" +
-       "\xff\xfd\x87h@\xff\xff\xff\xff\xfe\xb8\x00\xd0\xff\xff\xff\xff\xff\xa7\xe3\xc0\x00\x00\x00\x00\x00\x97\xe2\xd0\x00\x00\x00\x00\x01\x87\xc5\xc0\x00\x00\x00\x00\x02w\xc4\xd0\x00\x00\x00\x00\x03p\xe2@\x00\x00\x00\x00\x04`\xe1" +
-       "P\x00\x00\x00\x00\x055\x14\xc0\x00\x00\x00\x00\x06@\xc3P\x00\x00\x00\x00\a\x16H@\x00\x00\x00\x00\b \xa5P\x00\x00\x00\x00\b\xf7{\xc0\x00\x00\x00\x00\n\x00\x87P\x00\x00\x00\x00\n\xf0j@\x00\x00\x00" +
-       "\x00\v\xe0iP\x00\x00\x00\x00\fن\xc0\x00\x00\x00\x00\r\xc0KP\x00\x00\x00\x00\x0e\xb9h\xc0\x00\x00\x00\x00\x0f\xb2\xa2P\x00\x00\x00\x00\x10}\x9b@\x00\x00\x00\x00\x11Q\xea\xd0\x00\x00\x00\x00\x12f\xb7" +
-       "\xc0\x00\x00\x00\x00\x131\xcc\xd0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15[\x82\xd0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x17;d\xd0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00" +
-       "\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xfb(\xd0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\xdb\n\xd0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ezSP\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 Z5" +
-       "P\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"CQ\xd0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$#3\xd0\x00\x00\x00\x00%.\xc6@\x00\x00\x00\x00&\x15\x8a\xd0\x00\x00\x00\x00'\x17\xe2\xc0\x00\x00\x00" +
-       "\x00'\xfe\xa7P\x00\x00\x00\x00(\xf7\xd2\xd0\x00\x00\x00\x00)މP\x00\x00\x00\x00*״\xd0\x00\x00\x00\x00+\xbekP\x00\x00\x00\x00,\xb7\x96\xd0\x00\x00\x00\x00-\x9eMP\x00\x00\x00\x00.\x97x" +
-       "\xd0\x00\x00\x00\x00/~/P\x00\x00\x00\x000wZ\xd0\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002W<\xd0\x00\x00\x00\x003G-\xd0\x00\x00\x00\x004@YP\x00\x00\x00\x005\x1d\xd5P\x00\x00\x00" +
-       "\x0062\xb0P\x00\x00\x00\x006\xfd\xb7P\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:Ƶ\xd0\x00\x00\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xd2" +
-       "P\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xb4P\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@f[\xd0\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3\x8c\xd0\x00\x00\x00\x00G$\x17P\x00\x00\x00" +
-       "\x00GܩP\x00\x00\x00\x00I\x03\xf9P\x00\x00\x00\x00I\xb3P\xd0\x00\x00\x00\x00J\xe3\xdbP\x00\x00\x00\x00K\x9cmP\x00\x00\x00\x00L\xcc\xf7\xd0\x00\x00\x00\x00M\x85\x89\xd0\x00\x00\x00\x00N\xbfN" +
-       "\xd0\x00\x00\x00\x00Ow\xe0\xd0\x00\x00\x00\x00P\x95\xf6P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\xff\xff\xb2\xc8\x00\x00\xff\xff\xb2\xc0\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00HMT\x00CDT\x00CST\x00\nCST5CDT,M3.2.0/0" +
-       ",M11.1.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x1c\x00EETUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x02\x00\x00\x00\t\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e" +
-       "\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00" +
-       "\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c" +
-       "\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00" +
-       "\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*" +
-       "\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01" +
-       "\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x1c \x00\x05\x00\x00*0\x01\x00EEST\x00EET\x00\n" +
-       "EET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQtX\xbe\xe4o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00E" +
-       "STUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x04\xff\xff\xb9\xb0\x00\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00EST5EDTUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00" +
-       "\x10\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1\x9a\xcd`\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff" +
-       "\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1" +
-       "\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00" +
-       "\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83" +
-       "\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00" +
-       "\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf" +
-       "`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00" +
-       "\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87" +
-       "p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00" +
-       "\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc" +
-       "\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00" +
-       "\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
-       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
-       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\xb9\xb0\x00\x04\xff\xff\xc7\xc0\x01\x00\xff\xff\xc7\xc0\x01\b\xff\xff\xc7\xc0\x01\fEDT\x00EST\x00EWT\x00EPT\x00\nEST5ED" +
-       "T,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\x05\x00\x1c\x00EgyptUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u007f\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff}" +
-       "\xbdM\xab\xff\xff\xff\xffȓ\xb4\xe0\xff\xff\xff\xff\xc8\xfa{\xd0\xff\xff\xff\xff\xc9\xfc\xef\xe0\xff\xff\xff\xff\xca\xc7\xe8\xd0\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xcc\xdf)\xd0\xff\xff\xff\xffͬ\xe1\xe0\xff" +
-       "\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xadP\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea" +
-       "\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff" +
-       "\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7" +
-       "\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb\xc2\xfd\x80\xff\xff\xff\xff\xfc۾\xf0\xff\xff\xff\xff\xfd\xa5\x82\x80\xff\xff\xff\xff\xfe\xbc\xf2p\xff" +
-       "\xff\xff\xff\xff\x86\xb6\x00\x00\x00\x00\x00\x00\x9e%\xf0\x00\x00\x00\x00\x01g\xe9\x80\x00\x00\x00\x00\x02\u007fYp\x00\x00\x00\x00\x03I\x1d\x00\x00\x00\x00\x00\x04a\xdep\x00\x00\x00\x00\x05+\xa2\x00\x00\x00\x00\x00\x06" +
-       "C\x11\xf0\x00\x00\x00\x00\a\fՀ\x00\x00\x00\x00\b$Ep\x00\x00\x00\x00\b\xee\t\x00\x00\x00\x00\x00\n\x05x\xf0\x00\x00\x00\x00\n\xcf<\x80\x00\x00\x00\x00\v\xe7\xfd\xf0\x00\x00\x00\x00\f\xb1\xc1\x80\x00" +
-       "\x00\x00\x00\r\xc91p\x00\x00\x00\x00\x0e\x92\xf5\x00\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11\x8b\x98p\x00\x00\x00\x00\x12U\\\x00\x00\x00\x00\x00\x13n\x1dp\x00\x00\x00\x00\x14" +
-       "7\xe1\x00\x00\x00\x00\x00\x15OP\xf0\x00\x00\x00\x00\x16\x19\x14\x80\x00\x00\x00\x00\x17\xa0\x93\xf0\x00\x00\x00\x00\x17\xfaH\x00\x00\x00\x00\x00\x19p\xa3\xf0\x00\x00\x00\x00\x19\xdb{\x80\x00\x00\x00\x00\x1a\xf4<\xf0\x00" +
-       "\x00\x00\x00\x1b\xbe\x00\x80\x00\x00\x00\x00\x1c\xd5pp\x00\x00\x00\x00\x1d\x9f4\x00\x00\x00\x00\x00\x1e\xb6\xa3\xf0\x00\x00\x00\x00\x1f\x80g\x80\x00\x00\x00\x00 \x97\xd7p\x00\x00\x00\x00!a\x9b\x00\x00\x00\x00\x00\"" +
-       "z\\p\x00\x00\x00\x00#D \x00\x00\x00\x00\x00$b'p\x00\x00\x00\x00%%S\x80\x00\x00\x00\x00&<\xc3p\x00\x00\x00\x00'\x06\x87\x00\x00\x00\x00\x00(\x1d\xf6\xf0\x00\x00\x00\x00(纀\x00" +
-       "\x00\x00\x00*\x00{\xf0\x00\x00\x00\x00*\xca?\x80\x00\x00\x00\x00+\xe1\xafp\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00-\xc2\xe2\xf0\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/\xa0\x13\xe0\x00\x00\x00\x000" +
-       "k\f\xd0\x00\x00\x00\x001\u007f\xf5\xe0\x00\x00\x00\x002J\xee\xd0\x00\x00\x00\x003_\xd7\xe0\x00\x00\x00\x004*\xd0\xd0\x00\x00\x00\x005?\xb9\xe0\x00\x00\x00\x006\n\xb2\xd0\x00\x00\x00\x007(\xd6`\x00" +
-       "\x00\x00\x007\xf3\xcfP\x00\x00\x00\x009\b\xb8`\x00\x00\x00\x009ӱP\x00\x00\x00\x00:\xe8\x9a`\x00\x00\x00\x00;\xb3\x93P\x00\x00\x00\x00<\xc8|`\x00\x00\x00\x00=\x93uP\x00\x00\x00\x00>" +
-       "\xa8^`\x00\x00\x00\x00?sWP\x00\x00\x00\x00@\x91z\xe0\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00Bq\\\xe0\x00\x00\x00\x00C<U\xd0\x00\x00\x00\x00DQ>\xe0\x00\x00\x00\x00E\x12\xfdP\x00" +
-       "\x00\x00\x00F1 \xe0\x00\x00\x00\x00F\xe0jP\x00\x00\x00\x00H\x11\x02\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xf0\xe4\xe0\x00\x00\x00\x00J\x8d\xb9P\x00\x00\x00\x00K\xda\x01`\x00\x00\x00\x00L" +
-       "a\xbd\xd0\x00\x00\x00\x00L\x89X\xe0\x00\x00\x00\x00L\xa4\xfaP\x00\x00\x00\x00Su8\xe0\x00\x00\x00\x00S\xac\x89\xd0\x00\x00\x00\x00Sڼ`\x00\x00\x00\x00T$\x82P\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00" +
-       "\x1dU\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05" +
-       "\x00\x00\x04\x00\x1c\x00EireUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x91\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6\v\x11\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d" +
-       "\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff" +
-       "\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l" +
-       " \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff" +
-       "\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00" +
-       " \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff" +
-       "\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xd4I\xe0" +
-       " \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd7,( \xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff" +
-       "\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt" +
-       " \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff" +
-       "\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f}" +
-       " \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff" +
-       "\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6" +
-       " \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00" +
-       "\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0" +
-       "\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00" +
-       "\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k" +
-       "\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00" +
-       "\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94\xda" +
-       "\x90\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\xff\xff" +
-       "\xfa$\x00\x00\xff\xff\xfa\x0f\x00\x04\x00\x00\b\x1f\x01\b\x00\x00\x0e\x10\x01\f\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x01\x10\x00\x00\x0e\x10\x00\bLMT\x00DMT\x00IST\x00BS" +
-       "T\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x04\x00\x1c\x00Etc/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd9|\xbd7s\x00\x00\x00s\x00" +
-       "\x00\x00\n\x00\x1c\x00Etc/GMT-10UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x8c\xa0\x00\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe5\xf38cr\x00\x00" +
-       "\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+12UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xb0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\x99x\x00\x00\xff\xff\x99x\x00\x04\xff\xff\xab\xa0\x01" +
+       "\b\xff\xff\x9d\x90\x00\f\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\x10LMT\x00EMT\x00-06\x00-07\x00-05\x00\n<-06>6<-05>,M9.1.6/2" +
+       "2,M4.1.6/22\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x11\x00\x1c\x00Chile/ContinentalU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x00\x00\x00\x06\x00\x00" +
+       "\x00\x14\xff\xff\xff\xffi\x87\x1d\xc6\xff\xff\xff\xff\x8f0GF\xff\xff\xff\xff\x9b\\\xe5P\xff\xff\xff\xff\x9f|\xe2\xc6\xff\xff\xff\xff\xa1\x00q\xc0\xff\xff\xff\xff\xb0^w\xc6\xff\xff\xff\xff\xb1w=@\xff\xff" +
+       "\xff\xff\xb2A\x00\xd0\xff\xff\xff\xff\xb3Xp\xc0\xff\xff\xff\xff\xb4\"4P\xff\xff\xff\xff\xb59\xa4@\xff\xff\xff\xff\xb6\x03g\xd0\xff\xff\xff\xff\xb7\x1a\xd7\xc0\xff\xff\xff\xff\xb7\xe4\x9bP\xff\xff\xff\xff\xb8\xfd" +
+       "\\\xc0\xff\xff\xff\xff\xb9\xc7 P\xff\xff\xff\xff\xcc\x1cn@\xff\xff\xff\xff\xccl\xe7\xd0\xff\xff\xff\xff\xd3\u070f\xc0\xff\xff\xff\xff\xd4\x1bɰ\xff\xff\xff\xff\xd53U\xc0\xff\xff\xff\xff\xd5v\x92@\xff\xff" +
+       "\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 " +
+       "+\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00" +
+       "\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f" +
+       "\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00" +
+       "\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f" +
+       "\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00" +
+       "\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97" +
+       "j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00" +
+       "\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a" +
+       "\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00" +
+       "\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1" +
+       "X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00" +
+       "\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7" +
+       "\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x02\x01\x03\x01\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x03\x02\x03\x05\x03\x02\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+       "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\xff\xff\xbd\xba\x00\x00\xff\xff\xbd\xba\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x00\f\xff\xff\xc7\xc0\x01\f\xff\xff\xd5\xd0\x01\x10LMT\x00" +
+       "SMT\x00-05\x00-04\x00-03\x00\n<-04>4<-03>,M9.1.6/24,M4.1.6/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00CST6CDTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdb" +
+       "p\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff" +
+       "\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xee" +
+       "p\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00" +
+       "\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV" +
+       "\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00" +
+       "\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1" +
+       "p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00" +
+       "\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y" +
+       "\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00" +
+       "\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e" +
+       "\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00" +
+       "\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
+       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x01\x00\xff\xff\xb9\xb0\x01\b\xff" +
+       "\xff\xb9\xb0\x01\fCDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\a" +
+       "\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x04\x00\x1c\x00CubaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffW@\x00\x00-12\x00\n<-12>12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xab\xd1Is" +
-       "\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-11UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x9a\xb0\x00\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f." +
-       "\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x1c\x00Etc/UniversalUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "P\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\r\x00\x1c\x00Etc/GreenwichUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-6UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00T`\x00\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-1UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00j\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87(\xb8\xff\xff\xff\xff\xacb\u0080\xff\xff\xff\xff\xb1ӔP\xff\xff\xff\xff\xb2t]@\xff\xff\xff\xff\xc8[" +
+       "f\xd0\xff\xff\xff\xff\xc8\xd3Q@\xff\xff\xff\xff\xca;H\xd0\xff\xff\xff\xffʼm\xc0\xff\xff\xff\xff\xcc$eP\xff\xff\xff\xff̜O\xc0\xff\xff\xff\xff\xd1\xc4\vP\xff\xff\xff\xff\xd2;\xf5\xc0\xff\xff" +
+       "\xff\xffӣ\xedP\xff\xff\xff\xff\xd4\x1b\xd7\xc0\xff\xff\xff\xff\xf7`\x05\xd0\xff\xff\xff\xff\xf7\xff}@\xff\xff\xff\xff\xf9=D\xd0\xff\xff\xff\xff\xf9\xe3S\xc0\xff\xff\xff\xff\xfa\xdb;\xd0\xff\xff\xff\xff\xfb\xa7" +
+       "\x86@\xff\xff\xff\xff\xfcũ\xd0\xff\xff\xff\xff\xfd\x87h@\xff\xff\xff\xff\xfe\xb8\x00\xd0\xff\xff\xff\xff\xff\xa7\xe3\xc0\x00\x00\x00\x00\x00\x97\xe2\xd0\x00\x00\x00\x00\x01\x87\xc5\xc0\x00\x00\x00\x00\x02w\xc4\xd0\x00\x00" +
+       "\x00\x00\x03p\xe2@\x00\x00\x00\x00\x04`\xe1P\x00\x00\x00\x00\x055\x14\xc0\x00\x00\x00\x00\x06@\xc3P\x00\x00\x00\x00\a\x16H@\x00\x00\x00\x00\b \xa5P\x00\x00\x00\x00\b\xf7{\xc0\x00\x00\x00\x00\n\x00" +
+       "\x87P\x00\x00\x00\x00\n\xf0j@\x00\x00\x00\x00\v\xe0iP\x00\x00\x00\x00\fن\xc0\x00\x00\x00\x00\r\xc0KP\x00\x00\x00\x00\x0e\xb9h\xc0\x00\x00\x00\x00\x0f\xb2\xa2P\x00\x00\x00\x00\x10}\x9b@\x00\x00" +
+       "\x00\x00\x11Q\xea\xd0\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x131\xcc\xd0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15[\x82\xd0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x17;d\xd0\x00\x00\x00\x00\x18\x06" +
+       "]\xc0\x00\x00\x00\x00\x19\x1bF\xd0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xfb(\xd0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\xdb\n\xd0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ezSP\x00\x00" +
+       "\x00\x00\x1f\x8f @\x00\x00\x00\x00 Z5P\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"CQ\xd0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$#3\xd0\x00\x00\x00\x00%.\xc6@\x00\x00\x00\x00&\x15" +
+       "\x8a\xd0\x00\x00\x00\x00'\x17\xe2\xc0\x00\x00\x00\x00'\xfe\xa7P\x00\x00\x00\x00(\xf7\xd2\xd0\x00\x00\x00\x00)މP\x00\x00\x00\x00*״\xd0\x00\x00\x00\x00+\xbekP\x00\x00\x00\x00,\xb7\x96\xd0\x00\x00" +
+       "\x00\x00-\x9eMP\x00\x00\x00\x00.\x97x\xd0\x00\x00\x00\x00/~/P\x00\x00\x00\x000wZ\xd0\x00\x00\x00\x001gK\xd0\x00\x00\x00\x002W<\xd0\x00\x00\x00\x003G-\xd0\x00\x00\x00\x004@" +
+       "YP\x00\x00\x00\x005\x1d\xd5P\x00\x00\x00\x0062\xb0P\x00\x00\x00\x006\xfd\xb7P\x00\x00\x00\x008\x1b\xcc\xd0\x00\x00\x00\x008\xe6\xd3\xd0\x00\x00\x00\x009\xfb\xae\xd0\x00\x00\x00\x00:Ƶ\xd0\x00\x00" +
+       "\x00\x00;ې\xd0\x00\x00\x00\x00<\xaf\xd2P\x00\x00\x00\x00=\xbbr\xd0\x00\x00\x00\x00>\x8f\xb4P\x00\x00\x00\x00?\x9bT\xd0\x00\x00\x00\x00@f[\xd0\x00\x00\x00\x00ED5P\x00\x00\x00\x00E\xf3" +
+       "\x8c\xd0\x00\x00\x00\x00G$\x17P\x00\x00\x00\x00GܩP\x00\x00\x00\x00I\x03\xf9P\x00\x00\x00\x00I\xb3P\xd0\x00\x00\x00\x00J\xe3\xdbP\x00\x00\x00\x00K\x9cmP\x00\x00\x00\x00L\xcc\xf7\xd0\x00\x00" +
+       "\x00\x00M\x85\x89\xd0\x00\x00\x00\x00N\xbfN\xd0\x00\x00\x00\x00Ow\xe0\xd0\x00\x00\x00\x00P\x95\xf6P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xb2\xc8\x00\x00\xff\xff\xb2\xc0\x00\x04\xff\xff\xc7\xc0\x01\b\xff\xff\xb9\xb0\x00\fLMT\x00HMT\x00CDT\x00CST\x00\nCST" +
+       "5CDT,M3.2.0/0,M11.1.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x1c\x00EETUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x02\x00\x00\x00\t" +
+       "\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00" +
+       "\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90" +
+       "\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00" +
+       "\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90" +
+       "\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x00" +
+       "0d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x1c \x00\x05\x00\x00*" +
+       "0\x01\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x12tnj" +
+       "\xfc\x04\x00\x00\xfc\x04\x00\x00\x05\x00\x1c\x00EgyptUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u007f\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff}\xbdM\xab\xff\xff\xff\xffȓ\xb4\xe0\xff\xff\xff\xff\xc8\xfa{\xd0\xff\xff\xff\xff\xc9\xfc\xef\xe0\xff\xff\xff\xff\xca\xc7\xe8\xd0" +
+       "\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xcc\xdf)\xd0\xff\xff\xff\xffͬ\xe1\xe0\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xff" +
+       "Ҋ\xadP\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0" +
+       "\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff" +
+       "\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb\xc2\xfd\x80" +
+       "\xff\xff\xff\xff\xfc۾\xf0\xff\xff\xff\xff\xfd\xa5\x82\x80\xff\xff\xff\xff\xfe\xbc\xf2p\xff\xff\xff\xff\xff\x86\xb6\x00\x00\x00\x00\x00\x00\x9e%\xf0\x00\x00\x00\x00\x01g\xe9\x80\x00\x00\x00\x00\x02\u007fYp\x00\x00\x00\x00" +
+       "\x03I\x1d\x00\x00\x00\x00\x00\x04a\xdep\x00\x00\x00\x00\x05+\xa2\x00\x00\x00\x00\x00\x06C\x11\xf0\x00\x00\x00\x00\a\fՀ\x00\x00\x00\x00\b$Ep\x00\x00\x00\x00\b\xee\t\x00\x00\x00\x00\x00\n\x05x\xf0" +
+       "\x00\x00\x00\x00\n\xcf<\x80\x00\x00\x00\x00\v\xe7\xfd\xf0\x00\x00\x00\x00\f\xb1\xc1\x80\x00\x00\x00\x00\r\xc91p\x00\x00\x00\x00\x0e\x92\xf5\x00\x00\x00\x00\x00\x0f\xaad\xf0\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00" +
+       "\x11\x8b\x98p\x00\x00\x00\x00\x12U\\\x00\x00\x00\x00\x00\x13n\x1dp\x00\x00\x00\x00\x147\xe1\x00\x00\x00\x00\x00\x15OP\xf0\x00\x00\x00\x00\x16\x19\x14\x80\x00\x00\x00\x00\x17\xa0\x93\xf0\x00\x00\x00\x00\x17\xfaH\x00" +
+       "\x00\x00\x00\x00\x19p\xa3\xf0\x00\x00\x00\x00\x19\xdb{\x80\x00\x00\x00\x00\x1a\xf4<\xf0\x00\x00\x00\x00\x1b\xbe\x00\x80\x00\x00\x00\x00\x1c\xd5pp\x00\x00\x00\x00\x1d\x9f4\x00\x00\x00\x00\x00\x1e\xb6\xa3\xf0\x00\x00\x00\x00" +
+       "\x1f\x80g\x80\x00\x00\x00\x00 \x97\xd7p\x00\x00\x00\x00!a\x9b\x00\x00\x00\x00\x00\"z\\p\x00\x00\x00\x00#D \x00\x00\x00\x00\x00$b'p\x00\x00\x00\x00%%S\x80\x00\x00\x00\x00&<\xc3p" +
+       "\x00\x00\x00\x00'\x06\x87\x00\x00\x00\x00\x00(\x1d\xf6\xf0\x00\x00\x00\x00(纀\x00\x00\x00\x00*\x00{\xf0\x00\x00\x00\x00*\xca?\x80\x00\x00\x00\x00+\xe1\xafp\x00\x00\x00\x00,\xabs\x00\x00\x00\x00\x00" +
+       "-\xc2\xe2\xf0\x00\x00\x00\x00.\x8c\xa6\x80\x00\x00\x00\x00/\xa0\x13\xe0\x00\x00\x00\x000k\f\xd0\x00\x00\x00\x001\u007f\xf5\xe0\x00\x00\x00\x002J\xee\xd0\x00\x00\x00\x003_\xd7\xe0\x00\x00\x00\x004*\xd0\xd0" +
+       "\x00\x00\x00\x005?\xb9\xe0\x00\x00\x00\x006\n\xb2\xd0\x00\x00\x00\x007(\xd6`\x00\x00\x00\x007\xf3\xcfP\x00\x00\x00\x009\b\xb8`\x00\x00\x00\x009ӱP\x00\x00\x00\x00:\xe8\x9a`\x00\x00\x00\x00" +
+       ";\xb3\x93P\x00\x00\x00\x00<\xc8|`\x00\x00\x00\x00=\x93uP\x00\x00\x00\x00>\xa8^`\x00\x00\x00\x00?sWP\x00\x00\x00\x00@\x91z\xe0\x00\x00\x00\x00A\\s\xd0\x00\x00\x00\x00Bq\\\xe0" +
+       "\x00\x00\x00\x00C<U\xd0\x00\x00\x00\x00DQ>\xe0\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F1 \xe0\x00\x00\x00\x00F\xe0jP\x00\x00\x00\x00H\x11\x02\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00" +
+       "I\xf0\xe4\xe0\x00\x00\x00\x00J\x8d\xb9P\x00\x00\x00\x00K\xda\x01`\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00L\x89X\xe0\x00\x00\x00\x00L\xa4\xfaP\x00\x00\x00\x00Su8\xe0\x00\x00\x00\x00S\xac\x89\xd0" +
+       "\x00\x00\x00\x00Sڼ`\x00\x00\x00\x00T$\x82P\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x1dU\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\x04\x00\x1c\x00EireUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6" +
+       "\v\x11\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff" +
+       "\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00" +
+       "Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff" +
+       "\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f" +
+       "\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff" +
+       "\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:" +
+       "\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd7,( \xff\xff\xff\xff\xd8.\x8e \xff\xff" +
+       "\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮" +
+       "\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff" +
+       "\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3" +
+       "\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff" +
+       "\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8" +
+       "\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00" +
+       "\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0" +
+       "\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00" +
+       "\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac" +
+       "\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00" +
+       "\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9" +
+       "\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02" +
+       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
+       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\xff\xff\xfa$\x00\x00\xff\xff\xfa\x0f\x00\x04\x00\x00\b\x1f\x01\b\x00\x00\x0e\x10\x01\f\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\b\x00" +
+       "\x00\x00\x00\x01\x10\x00\x00\x0e\x10\x00\bLMT\x00DMT\x00IST\x00BST\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RtX\xbe\xe4o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00ESTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xb9\xb0\x00\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00EST5EDTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x0e\x10\x00\x00+01\x00\n<+01>-1\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xc5\x18\xb6\xfbr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-8UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00p\x80\x00\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+4UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xc7\xc0\x00\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQe\xcb\xe9Qq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+3UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xd5\xd0\x00\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xfc\x19@\xb9r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-9UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00~\x90\x00\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00Etc/GMT-0UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQJ0p-r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-7UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00bp\x00\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xa9{\xa2qq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+2UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xe3\xe0\x00\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xd4X\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+5UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1" +
+       "\x9a\xcd`\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff" +
+       "\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05" +
+       "P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00" +
+       "\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13" +
+       "iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00" +
+       "\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!" +
+       "\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00" +
+       "\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/" +
+       "~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00" +
+       "\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=" +
+       "\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00" +
+       "\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
+       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\xb9\xb0\x00\x04\xff\xff\xc7\xc0\x01\x00\xff\xff\xc7\xc0\x01" +
+       "\b\xff\xff\xc7\xc0\x01\fEDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x1c\x00Etc/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00Etc/GMT+0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\r\x00\x1c\x00Etc/GreenwichUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
        "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xb9\xb0\x00\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/GMTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00Etc/GMT-0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\b\x00\x1c\x00Etc/ZuluUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ)\xb9" +
-       "\xbe\x9dr\x00\x00\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+11UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffeP\x00\x00-11\x00\n<-11>11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-13UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xd4X\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+5UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xb6\xd0\x00\x00+13\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ,{\xdc;s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-14UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xc4\xe0\x00\x00+14\x00\n<+14>-14\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+10UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffs`\x00\x00-10\x00\n<-10>10\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-12UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xa8\xc0\x00\x00+12\x00\n<+12>-12\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\b\x00\x1c\x00Etc/GMT0UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/UCTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00Etc/GMT+0UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x84+\x9a$q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+7UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x9d\x90\x00\x00-07\x00\n<-07>7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x84\x19\xb3\tq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+9UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xb9\xb0\x00\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-1UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x0e\x10\x00\x00+01\x00\n<+01>-1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R5\xb8\xe8\x86q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+1UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x81p\x00\x00-09\x00\n<-09>9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xbc\x19y\x04r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-2UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xf1\xf0\x00\x00-01\x00\n<-01>1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\"\xf8\x8f/q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+8UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x1c \x00\x00+02\x00\n<+02>-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-5UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x8f\x80\x00\x00-08\x00\n<-08>8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-12UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00FP\x00\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\"\xf8\x8f/q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+8UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x8f\x80\x00\x00-08\x00\n<-08>8\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+6UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xa8\xc0\x00\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/UCTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xa9{\xa2qq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+2UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xe3\xe0\x00\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xb2\xab\xd1Is\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-11UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x9a\xb0\x00\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+4UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
        "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xab\xa0\x00\x00-06\x00\n<-06>6\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ5\xb8\xe8\x86q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+1UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xc7\xc0\x00\x00-04\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\x9c\xfcm\x99r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-3UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
        "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xf1\xf0\x00\x00-01\x00\n<-01>1\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/UTCUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "k\x19<Qr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-4UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x008@\x00\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x9c\xfcm\x99r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-3UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00*0\x00\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Europe/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\r\x00\x1c\x00Europe/ZurichUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff$\xf0\xea\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff\xff\xca" +
-       "\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00" +
-       "\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f" +
-       "|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00" +
-       "\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-" +
-       "\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BMT\x00CEST\x00CET\x00\nCET-1C" +
-       "EST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc7\xf5\x94\xdaQ\x04\x00\x00Q\x04\x00\x00\f\x00\x1c\x00Europe/Pa" +
-       "risUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00e\x00\x00" +
-       "\x00\a\x00\x00\x00\x1f\xff\xff\xff\xffkɛ\xcf\xff\xff\xff\xff\x91`PO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89" +
-       "\xfep\xff\xff\xff\xff\x9f\xa0*\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff" +
-       "\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8X&p\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7_\xf0\xff\xff\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7" +
-       "A\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff" +
-       "\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb5I/\xf0\xff\xff\xff\xff\xb6/\xe6p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xba\xd6" +
-       "`\xf0\xff\xff\xff\xff\xbb\xd8\xc6\xf0\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff" +
-       "\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X\xacp\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8l" +
-       "'\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0O\xe1\xe0\xff\xff\xff\xffЉ\xf1\xf0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff" +
-       "\xff\xff\xd2N@\x90\x00\x00\x00\x00\v\xbb9\x00\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d" +
-       "'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00" +
-       "\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|" +
-       "\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00" +
-       "\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94" +
-       "ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x06\x02\x06\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x00\x00\x021\x00\x00\x00\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\r\x00\x00\x0e\x10\x00\x11\x00\x00\x1c \x01\x15\x00\x00\x1c \x01\x1aLMT" +
-       "\x00PMT\x00WEST\x00WET\x00CET\x00CEST\x00WEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\r\x00\x1c\x00Europe/MoscowUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00N\x00\x00\x00\v\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc0\xc7\xff\xff\xff\xff\x9b_\x1e\xc7\xff\xff" +
-       "\xff\xff\x9d>\xf2y\xff\xff\xff\xff\x9e*\xee\xf9\xff\xff\xff\xff\x9e\xf79i\xff\xff\xff\xff\x9f\x84W\xf9\xff\xff\xff\xff\xa0\xd8l\xe9\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xa1<\xa6@\xff\xff\xff\xff\xa4\x10" +
-       "m\xc0\xff\xff\xff\xff\xa4=2\xb0\xff\xff\xff\xff\xa5\x15h\xb0\xff\xff\xff\xff\xa5=\x03\xc0\xff\xff\xff\xff\xa7\x1eEP\xff\xff\xff\xff\xb5\xa4\x19`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00" +
-       "\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c" +
-       "\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00" +
-       "\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4" +
-       "\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00" +
-       "\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xdd" +
-       "D\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00" +
-       "\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#" +
-       "\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00" +
-       "\x00\x00TL\x1d`\x01\x03\x02\x03\x04\x02\x04\x05\x06\x05\a\x05\x06\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\t\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\n\x06\x00\x00#9\x00\x00\x00\x00#9\x00\x04\x00\x001\x87\x01\b\x00\x00#w\x00\x04\x00\x00?\x97\x01\f\x00\x008@\x01\x11" +
-       "\x00\x00*0\x00\x15\x00\x00FP\x01\x19\x00\x00\x1c \x00\x1d\x00\x00*0\x01!\x00\x008@\x00\x15LMT\x00MMT\x00MST\x00MDST\x00MSD\x00MSK\x00+05\x00E" +
-       "ET\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQM\xe5\xa9 ?\x04\x00\x00?\x04\x00\x00\x11\x00\x1c\x00Europe/Luxembou" +
-       "rgUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00" +
-       "\a\x00\x00\x00\x16\xff\xff\xff\xff\x84\xa2\xad\xbc\xff\xff\xff\xff\x9b\x1e\x8c`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9c\xea\xa7\xe0\xff\xff\xff\xff\x9d\xa4\x99p\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97" +
-       "\x90\xff\xff\xff\xff\x9f\xe0\xc4p\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xe5\xa0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zi\x10\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^?\x90\xff\xff\xff" +
-       "\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\xaa\x00\xff\xff\xff\xff\xa8*\x01\xf0\xff\xff\xff\xff\xa9\a\x9a\x10\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xabآp\xff\xff\xff\xff\xac\xc7P" +
-       "\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff" +
-       "\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb8\xff\xe3\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\u058b" +
-       " \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xc8\xe2 \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\x9f\x89\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff" +
-       "\xff\xc2h\x88 \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4?/\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8B0" +
-       " \xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0o\xb0\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\xff\xff\xff" +
-       "\xffӑ@\x10\xff\xff\xff\xff\xd4K#\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18" +
-       "\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00" +
-       "\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr" +
-       "\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00" +
-       "\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84\xcb" +
-       "\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x00\x00\x05\xc4\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00\x0e\x10\x01\r\x00\x00\x00\x00\x00\x12\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\rLMT\x00CEST\x00CET\x00" +
-       "WEST\x00WET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde" +
-       "\x01\x00\x00\x10\x00\x1c\x00Europe/LjubljanaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff" +
-       "\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1a\xc3" +
-       "\x91\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00" +
-       "\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5" +
-       "%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00" +
-       "\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10" +
-       "\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x0f\x00\x1c\x00Europe/HelsinkiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffS\xba&\x9b\xff\xff\xff\xff\xa4so\x1b\xff\xff\xff\xff\xcb\xceQ" +
-       "`\xff\xff\xff\xff\xcc\xc0\xe5`\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00" +
-       "\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c" +
-       "\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00" +
-       "\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc" +
-       "\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x17e\x00\x00\x00\x00" +
-       "\x17e\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLMT\x00HMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5.0" +
-       "/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQWI\xc3\u007f(\x03\x00\x00(\x03\x00\x00\f\x00\x1c\x00Europe/MinskUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xca(\xff\xff\xff\xff" +
-       "\xaa\x19\xaa8\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xff\xca^p\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0\n\x02`" +
-       "\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00" +
-       "\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0" +
-       "\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00" +
-       "+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00" +
-       "\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062j\x00\x00\x00\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x00" +
-       "9\xfbh\x80\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80\x00\x00\x00\x00<\xa6Q\x80\x00\x00\x00\x00=\xbb,\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80" +
-       "\x00\x00\x00\x00A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00Cd\r\x00\x00\x00\x00\x00D%ـ\x00\x00\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00" +
-       "G\xee\xd8\x00\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00\x00\x00\x00\x00J\xe3\x95\x00\x00\x00\x00\x00K\xae\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x01\x02\x03\x05\x04\x05\x04\x05" +
-       "\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\b" +
-       "\x00\x00\x19\xd8\x00\x00\x00\x00\x19\xc8\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c \x01\x14\x00\x008@\x01\x19\x00\x00*0\x01\x1d\x00\x00*0\x00\"LMT\x00MM" +
-       "T\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde" +
-       "\x01\x00\x00\xde\x01\x00\x00\r\x00\x1c\x00Europe/SkopjeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff" +
-       "\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1a" +
-       "Ñ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00" +
-       "\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(" +
-       "\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00" +
-       "\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e" +
-       "\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\r\x00\x1c\x00Europe/DublinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00*0\x00\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-5UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00FP\x00\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9Re\xcb\xe9Qq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+3UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xd5\xd0\x00\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xd9|\xbd7s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-10UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x8c\xa0\x00\x00+10\x00\n<+10>-10\nPK\x03\x04\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\xe5\xf38cr\x00\x00\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+12UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffW@\x00\x00-12\x00\n<-12>12\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfc\x19@\xb9r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-9UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00~\x90\x00\x00+09\x00\n<+09>-9\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-13UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xb6\xd0\x00\x00+13\x00\n<+13>-13" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\b\x00\x1c\x00Etc/GMT0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+10UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffs`\x00\x00-10\x00\n<-10>10\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-6UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00T`\x00\x00+06\x00\n<+06>-6" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/UTCUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\x84+\x9a$q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+7UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x9d\x90\x00\x00-07\x00\n<-07>7\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+6UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\xab\xa0\x00\x00-06\x00\n<-06>6\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RJ0p-r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-7UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00bp\x00\x00+07\x00\n<+07>-7\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Etc/GMTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\xbc\x19y\x04r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-2UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
        "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6\v\x11" +
-       "\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff" +
-       "\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ" +
-       "\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff" +
-       "\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0" +
-       "\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff" +
-       "\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 " +
-       "\xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd7,( \xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x1c \x00\x00+02\x00\n<+02>-2\nPK\x03\x04\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R,{\xdc;s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-14UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\xc4\xe0\x00\x00+14\x00\n<+14>-14\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x1c\x00Etc/UniversalUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc5\x18\xb6\xfbr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-8UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00p\x80\x00\x00+08\x00\n<+08>-8" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R)\xb9\xbe\x9dr\x00\x00\x00r\x00\x00\x00\n\x00\x1c\x00Etc/GMT+11UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffeP\x00\x00-11\x00\n<-11>" +
+       "11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\b\x00\x1c\x00Etc/ZuluUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\x19<Qr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-4UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x008@\x00\x00+04\x00\n<+04>-4" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x84\x19\xb3\tq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+9UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x81p\x00\x00-09\x00\n<-09>9" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Europe/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x95\u007fpp\xdc\x02\x00\x00\xdc\x02\x00\x00\r\x00\x1c\x00Europe/SamaraUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80" +
+       "\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00" +
+       "\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0" +
+       "\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00" +
+       "(\xe5\x17\x80\x00\x00\x00\x00)\x00\xc7\x00\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xbf`\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\xa1`" +
+       "\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000d\x83`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x00" +
+       "62M\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00\x00\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`" +
+       "\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x00\x00\x00\x00BE\xdb`\x00\x00\x00\x00Cc\xf0\xe0\x00\x00\x00\x00" +
+       "D%\xbd`\x00\x00\x00\x00EC\xd2\xe0\x00\x00\x00\x00F\x05\x9f`\x00\x00\x00\x00G#\xb4\xe0\x00\x00\x00\x00G\xee\xbb\xe0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΝ\xe0\x00\x00\x00\x00J\xe3x\xe0" +
+       "\x00\x00\x00\x00K\xae\u007f\xe0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x02\x00\x00.\xf4\x00\x00\x00\x00*0\x00\x04\x00\x008@\x00\b\x00\x00FP\x01\f\x00\x008@\x01\b\x00\x00" +
+       "*0\x01\x04LMT\x00+03\x00+04\x00+05\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0e\x00\x1c\x00E" +
+       "urope/BelfastUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff" +
+       "\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb " +
+       "\xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff" +
+       "\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0" +
+       "\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff" +
+       "\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 " +
+       "\xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff" +
+       "\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90" +
+       "\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff" +
+       "\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0" +
+       "\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff" +
+       "\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq " +
+       "\xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff" +
+       "\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 " +
+       "\xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00" +
+       "\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N " +
+       "\x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00" +
+       "\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐" +
+       "\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00" +
+       " lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90" +
+       "\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00" +
+       ".\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0B" +
+       "ST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Ro\xbc\x831O\x04\x00\x00O\x04\x00\x00\x0f\x00\x1c\x00Europe/Bru" +
+       "sselsUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f" +
+       "\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xdf\xe6\xff\xff\xff\xffm\xe8\xc8\x00\xff\xff\xff\xff\x98DI\x80\xff\xff\xff\xff\x9b\f%p\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff" +
+       "\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\x9f\xce\xf80\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xbbp\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0" +
+       "\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8*\x01\xf0\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff" +
+       "\xaa\xe7_\xf0\xff\xff\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7A\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0" +
+       "\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff" +
+       "\xb8\xff\xe3\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\u058b \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xc8\xe2 \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\x9f\x89\xa0\xff\xff\xff\xff\xbf\x98\xb5 " +
+       "\xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2h\x88 \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4?/\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff" +
+       "\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8J\x19 \xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90" +
+       "\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\xff\xff\xff\xffӑ@\x10\xff\xff\xff\xff\xd4K#\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00" +
+       "\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐" +
+       "\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00" +
+       "\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10" +
+       "\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00" +
+       ",\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x04\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x05\x02" +
+       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x04\x1a\x00\x00\x00\x00\x04\x1a\x00\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x00\f\x00\x00\x1c \x01\x10\x00\x00\x0e\x10" +
+       "\x01\x15LMT\x00BMT\x00WET\x00CET\x00CEST\x00WEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\f\x00\x1c\x00Europe/VaduzUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff$\xf0\xea\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff" +
+       "\xff\xca\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe" +
+       "\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00" +
+       "\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18" +
+       "\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00" +
+       "\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BMT\x00CEST\x00CET\x00\nCET-" +
+       "1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcb*j\x8f\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x1c\x00Europe/" +
+       "AthensUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "7\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xfft?\x98D\xff\xff\xff\xff\x9b\x80!\x80\xff\xff\xff\xff\xb9|\xe9\xe0\xff\xff\xff\xff\xb9Ư\xd0\xff\xff\xff\xff\xc9\xf2c\xe0\xff\xff\xff\xff\xca\x10\xa8P\xff\xff\xff" +
+       "\xff\xcc\xe7K\x10\xff\xff\xff\xffͪL\xf0\xff\xff\xff\xff\u03a2\x18\xe0\xff\xff\xff\xffϓip\xff\xff\xff\xff\xdf\x13\x9e`\xff\xff\xff\xff߷\nP\x00\x00\x00\x00\t\xec^`\x00\x00\x00\x00\v\x18\xf4" +
+       "`\x00\x00\x00\x00\vͮ\x00\x00\x00\x00\x00\f\xbd\x9f\x00\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\x8c]\x80\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10j\xfc\x10\x00\x00\x00\x00\x11d{\xf0\x00\x00\x00" +
+       "\x00\x12R\xaa\xf0\x00\x00\x00\x00\x13F\x82`\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18\xe3\xaf" +
+       "\x90\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00" +
+       "\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C" +
+       "\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00" +
+       "\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x05\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x16<\x00\x00\x00\x00\x16<\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00\x0e\x10\x00\x11\x00\x00\x1c \x01\x15" +
+       "LMT\x00AMT\x00EEST\x00EET\x00CET\x00CEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9RM\xe5\xa9 ?\x04\x00\x00?\x04\x00\x00\x11\x00\x1c\x00Europe/LuxembourgUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00\a\x00\x00\x00\x16\xff\xff\xff\xff\x84\xa2\xad\xbc\xff\xff\xff\xff\x9b\x1e" +
+       "\x8c`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9c\xea\xa7\xe0\xff\xff\xff\xff\x9d\xa4\x99p\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\x9f\xe0\xc4p\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff" +
+       "\xff\xff\xa1~\xe5\xa0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zi\x10\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^?\x90\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\xaa\x00\xff\xff\xff\xff\xa8*" +
+       "\x01\xf0\xff\xff\xff\xff\xa9\a\x9a\x10\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xabآp\xff\xff\xff\xff\xac\xc7P\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa72\x00\xff\xff" +
+       "\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60" +
+       "\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb8\xff\xe3\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\u058b \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xc8\xe2 \xff\xff" +
+       "\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\x9f\x89\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2h\x88 \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4?" +
+       "/\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8B0 \xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff" +
+       "\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0o\xb0\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\xff\xff\xff\xffӑ@\x10\xff\xff\xff\xff\xd4K#\x90\x00\x00\x00\x00\r\xa4" +
+       "c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00" +
+       "\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc" +
+       "\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00" +
+       "\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5" +
+       "\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00" +
+       "\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x06" +
+       "\x05\x06\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x05\xc4\x00\x00\x00\x00\x1c \x01\x04\x00\x00" +
+       "\x0e\x10\x00\t\x00\x00\x0e\x10\x01\r\x00\x00\x00\x00\x00\x12\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\rLMT\x00CEST\x00CET\x00WEST\x00WET\x00\nCET-1CEST" +
+       ",M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x92\xfc\f+o\x02\x00\x00o\x02\x00\x00\x11\x00\x1c\x00Europe/Copen" +
+       "hagenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003" +
+       "\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x86ϴ\xff\xff\xff\xffq\f\xef4\xff\xff\xff\xff\x9b\x1e\x8c`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xc8CWp\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xff" +
+       "ͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2$\x10\x90\xff\xff\xff\xff\xd3y\x85\x10\xff\xff\xff\xff\xd4\x1b\xad\x90" +
+       "\xff\xff\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd7Gɐ\xff\xff\xff\xff\u05ff\xc2\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00" +
+       "\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10" +
+       "\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00" +
+       "$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90" +
+       "\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xcc\x00\x00\x00\x00\v\xcc\x00\x04\x00" +
+       "\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00CMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9RVa\x92\xd3\xdf\x02\x00\x00\xdf\x02\x00\x00\x10\x00\x1c\x00Europe/VolgogradUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00A\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf5F\xdc\xff\xff\xff\xff\xb5\xa4\v" +
+       "P\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00" +
+       "\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)" +
+       "\xe0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00" +
+       "\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc" +
+       "\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00" +
+       "\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00" +
+       "p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00" +
+       "\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo" +
+       "\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00[\xd4\xed\xf0\x00\x00\x00\x00_\xe7\xb2`\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
+       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x02\x01\x02\x01\x00\x00)\xa4\x00\x00\x00\x00*0\x00\x04\x00\x008@\x00\b\x00\x00FP\x01\f\x00\x008@\x01\b" +
+       "LMT\x00+03\x00+04\x00+05\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RO+j\x94\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Europ" +
+       "e/KaliningradUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\b\x00\x00\x00\"\xff\xff\xff\xffo\xa2[H\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff" +
+       "\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10" +
+       "\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1|w\xe0\xff\xff\xff\xffѕ\x84`\xff\xff\xff\xffҊ\xadP\xff\xff\xff\xff\xd3Y\xb6\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00" +
+       "\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0" +
+       "\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00" +
+       "%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80" +
+       "\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x00" +
+       "3=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062j\x00\x00\x00\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x009\xfbh\x80" +
+       "\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80\x00\x00\x00\x00<\xa6Q\x80\x00\x00\x00\x00=\xbb,\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80\x00\x00\x00\x00" +
+       "A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00Cd\r\x00\x00\x00\x00\x00D%ـ\x00\x00\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00G\xee\xd8\x00" +
+       "\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00\x00\x00\x00\x00J\xe3\x95\x00\x00\x00\x00\x00K\xae\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x00\x00\x00\x00TL+p\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x00\x00\x138\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x12\x00\x008@\x01\x16\x00\x00*0\x00\x1a\x00\x00" +
+       "*0\x00\x1eLMT\x00CEST\x00CET\x00EEST\x00EET\x00MSD\x00MSK\x00+03\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1" +
+       "C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00Europe/BelgradeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff" +
+       "\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ" +
+       "\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00" +
+       "\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54" +
+       "\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00" +
+       "\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x13" +
+       "8\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0f\x00\x1c\x00Europe/GuernseyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0" +
+       "\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff" +
+       "\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0" +
+       "\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff" +
+       "\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0" +
+       "\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff" +
+       "\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ " +
+       "\xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xff" +
+       "ͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0" +
+       "\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff" +
        "\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 " +
        "\xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff" +
        "\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0" +
@@ -4466,1641 +4542,1645 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10" +
        "\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00" +
        "$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90" +
-       "\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x04\x03" +
-       "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06" +
-       "\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\xff\xff\xfa$\x00\x00\xff\xff\xfa\x0f\x00\x04\x00\x00\b\x1f\x01\b\x00\x00\x0e\x10\x01\f\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\b\x00\x00\x00" +
-       "\x00\x01\x10\x00\x00\x0e\x10\x00\bLMT\x00DMT\x00IST\x00BST\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x1c\x00Europe/JerseyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff" +
-       "\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2" +
-       "e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff" +
-       "\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0" +
-       "\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff" +
-       "\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe" +
-       "\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff" +
-       "\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xff\xcd" +
-       "\xb1\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff" +
-       "\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8" +
-       "\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff" +
-       "\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7" +
-       "\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff" +
-       "\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5" +
-       "!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff" +
-       "\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a" +
-       "\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00" +
-       "\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16" +
-       "8Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00" +
-       "\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$" +
-       ",6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00" +
-       "\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00" +
-       "\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x11\x00\x1c\x00Europe/San_MarinoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8" +
-       "p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff" +
-       "\xff\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^" +
-       "\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff" +
-       "\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0" +
-       "\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00" +
-       "\x00\x06n\x93p\x00\x00\x00\x00\a\vu\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xebW\xf0\x00\x00\x00\x00\n.Wp\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b" +
-       "\xf0\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00" +
-       "\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ" +
-       "\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00" +
-       "\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%" +
-       "\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00" +
-       "\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00" +
-       "\x0e\x10\x00\rLMT\x00RMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ==\xa4\x16\xc4\x04\x00\x00\xc4\x04\x00\x00\x10\x00\x1c\x00Europe/GibraltarUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffW\xd1\n\x04\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6" +
-       "\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff" +
-       "\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00" +
-       "Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff" +
-       "\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f" +
-       "\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff" +
-       "\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:" +
-       "\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff" +
-       "\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I" +
-       "\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff" +
-       "\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94" +
-       "̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff" +
-       "\xff\xff\xe8\x14T\xa0\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac" +
-       "\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00" +
-       "\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5" +
-       "\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01" +
-       "\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\xff\xff\xfa\xfc\x00\x00\x00" +
-       "\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x11\x00\x00\x1c \x01\x15LMT\x00BST\x00GMT\x00BDST\x00CET\x00CEST\x00\nCET-" +
-       "1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00Europe/" +
-       "BelgradeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff" +
-       "\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c" +
-       "\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00" +
-       "\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*" +
-       "\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET" +
-       "\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00" +
-       "\x0f\x00\x1c\x00Europe/GuernseyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01" +
+       "\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00" +
+       "\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00Europe/SarajevoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10" +
+       "\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00" +
+       "\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10" +
+       "\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00" +
+       "'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː" +
+       "\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rh\xa5J[\xa0\x03\x00\x00\xa0\x03\x00\x00\f\x00\x1c\x00Europe/MaltaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00V\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffp\xbd\xd3d\xff\xff\xff\xff\x9b8\xf8p" +
+       "\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff" +
+       "\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90" +
+       "\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff" +
+       "\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0" +
+       "\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00" +
+       "\x06\x1a3p\x00\x00\x00\x00\a\n$p\x00\x00\x00\x00\b\x17\x16p\x00\x00\x00\x00\b\xda4p\x00\x00\x00\x00\t\xf7\x14\x90\x00\x00\x00\x00\n\xc2\r\x80\x00\x00\x00\x00\v\xd6\xf6\x90\x00\x00\x00\x00\f\xa1\xef\x80" +
+       "\x00\x00\x00\x00\r\xb6ؐ\x00\x00\x00\x00\x0e\x81р\x00\x00\x00\x00\x0f\x96\xba\x90\x00\x00\x00\x00\x10a\xb3\x80\x00\x00\x00\x00\x11v\x9c\x90\x00\x00\x00\x00\x12A\x95\x80\x00\x00\x00\x00\x13E[\x10\x00\x00\x00\x00" +
+       "\x14*\xb2\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90" +
+       "\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00" +
+       "\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90" +
+       "\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x00" +
+       "0d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\r\x9c\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00" +
+       "CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc7\xf5\x94\xdaQ\x04\x00\x00Q" +
+       "\x04\x00\x00\f\x00\x1c\x00Europe/ParisUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4" +
-       "à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff" +
-       "\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9" +
-       "\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff" +
-       "\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xef" +
-       "Ԡ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff" +
-       "\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda" +
-       "\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff" +
-       "\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B" +
-       "\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff" +
-       "\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2k" +
-       "t \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff" +
-       "\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f" +
-       "} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff" +
-       "\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p" +
-       "\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00" +
-       "\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q" +
-       "\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00" +
-       "\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1" +
-       "k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00" +
-       "\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94" +
-       "ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00" +
-       "\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQu\xb0\xcd\xfc\xf8\x02\x00\x00\xf8\x02\x00\x00\x10\x00\x1c\x00Euro" +
-       "pe/UlyanovskUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00\x00\x00\x14\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17" +
-       "\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00" +
-       "\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&" +
-       "\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00" +
-       "\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003" +
-       "=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00" +
-       "\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A" +
-       "\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00" +
-       "\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00V" +
-       "\xf7\x14p\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x05\x06\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00-`\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\f\x00\x00*0\x01\x04\x00\x00\x1c \x00\x10LMT\x00+03\x00+" +
-       "05\x00+04\x00+02\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x1b8\xfel\xd6\x02\x00\x00\xd6\x02\x00\x00\x0e\x00\x1c\x00Europe/Sar" +
-       "atovUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00e\x00\x00\x00\a\x00\x00\x00\x1f\xff\xff\xff\xffkɛ\xcf\xff\xff\xff\xff\x91`PO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc" +
+       "\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0*\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff" +
+       "\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8X&p\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7" +
+       "_\xf0\xff\xff\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7A\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff" +
+       "\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb5I/\xf0\xff\xff\xff\xff\xb6/\xe6p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff" +
+       "\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xba\xd6`\xf0\xff\xff\xff\xff\xbb\xd8\xc6\xf0\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff" +
+       "\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X" +
+       "\xacp\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8l'\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0O\xe1\xe0\xff\xff" +
+       "\xff\xffЉ\xf1\xf0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\v\xbb9\x00\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84" +
+       "E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00" +
+       "\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c" +
+       "\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00" +
+       "\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4" +
+       "\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x04\x05\x04\x05\x06\x02\x06\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x00\x00\x021\x00\x00\x00\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\r\x00\x00\x0e\x10\x00" +
+       "\x11\x00\x00\x1c \x01\x15\x00\x00\x1c \x01\x1aLMT\x00PMT\x00WEST\x00WET\x00CET\x00CEST\x00WEMT\x00\nCET-1CEST,M3.5." +
+       "0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x10\x00\x1c\x00Europe/MariehamnUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00" +
+       "\x11\xff\xff\xff\xffS\xba&\x9b\xff\xff\xff\xff\xa4so\x1b\xff\xff\xff\xff\xcb\xceQ`\xff\xff\xff\xff\xcc\xc0\xe5`\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00" +
+       "\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90" +
+       "\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00" +
+       "\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9" +
+       "\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x17e\x00\x00\x00\x00\x17e\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLMT\x00HMT\x00EEST\x00EET\x00\nEE" +
+       "T-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rߜvυ\x01\x00\x00\x85\x01\x00\x00\x0e\x00\x1c\x00Eur" +
+       "ope/AndorraUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x19\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff~6\xb3\x94\xff\xff\xff\xff\xd4A\xdb\x00\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|" +
+       "\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00" +
+       "\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94" +
+       "ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00" +
+       "\x00\x01l\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x00\b\x00\x00\x1c \x01\fLMT\x00WET\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M1" +
+       "0.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\r\x00\x1c\x00Europe/LisbonUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xff^=" +
+       "\f\x1d\xff\xff\xff\xff\x92掀\xff\xff\xff\xff\x9bKmp\xff\xff\xff\xff\x9b\xfeǀ\xff\xff\xff\xff\x9c\x9c\xedp\xff\xff\xff\xff\x9dɃp\xff\xff\xff\xff\x9e\u007frp\xff\xff\xff\xff\x9f\xaa\xb6\xf0\xff\xff" +
+       "\xff\xff\xa0_Tp\xff\xff\xff\xff\xa1\x8b\xeap\xff\xff\xff\xff\xa2A\xd9p\xff\xff\xff\xff\xa3nop\xff\xff\xff\xff\xa4#\f\xf0\xff\xff\xff\xff\xa5O\xa2\xf0\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xf4" +
+       "\x8e\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff" +
+       "\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f" +
+       "_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff" +
+       "\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X\xacp\xff\xff\xff\xff\xc7\xd9\xdfp\xff\xff\xff\xff\xc9\x01/p\xff\xff\xff\xff\xc9\xf1 p\xff\xff\xff\xff\xca\xe2b\xf0\xff\xff\xff\xff˵R\xf0\xff\xff\xff\xff\xcb\xec" +
+       "\xa3\xe0\xff\xff\xff\xff̀K\xe0\xff\xff\xff\xff\xccܢ\xf0\xff\xff\xff\xff͕4\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xff\xcer\xa2\xe0\xff\xff\xff\xff\xceſp\xff\xff\xff\xff\xcfu\x16\xf0\xff\xff" +
+       "\xff\xffϬg\xe0\xff\xff\xff\xff\xd0R\x84\xe0\xff\xff\xff\xffХ\xa1p\xff\xff\xff\xff\xd1T\xf8\xf0\xff\xff\xff\xffьI\xe0\xff\xff\xff\xff\xd22f\xe0\xff\xff\xff\xff҅\x83p\xff\xff\xff\xff\xd3Y" +
+       "\xc4\xf0\xff\xff\xff\xff\xd4I\xb5\xf0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6)\xc2 \xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8\t\xa4 \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xd9\xe9\x86 \xff\xff" +
+       "\xff\xffܹY \xff\xff\xff\xffݲ\x84\xa0\xff\xff\xff\xffޢu\xa0\xff\xff\xff\xffߒf\xa0\xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3R" +
+       "*\xa0\xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xea\xfc \xff\xff" +
+       "\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xca\xde \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff\xf0z\x93 \xff\xff\xff\xff\xf1j" +
+       "\x84 \xff\xff\xff\xff\xf2c\xaf\xa0\xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4C\x91\xa0\xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6#s\xa0\xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x03U\xa0\xff\xff" +
+       "\xff\xff\xf8\xf3F\xa0\x00\x00\x00\x00\f\xab*\x00\x00\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T" +
+       "\x18\x90\x00\x00\x00\x00\x13C\xfb\x80\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㽠\x00\x00" +
+       "\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 l" +
+       "r\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00" +
+       "\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84" +
+       "ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x05\x04\x05\x04\x05\x04\x01\xff\xff\xf7c\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00" +
+       "\x00\x00\t\x00\x00\x1c \x01\r\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\x16LMT\x00WEST\x00WET\x00WEMT\x00CET\x00CEST\x00\nWET0WEST,M3" +
+       ".5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RN\xa5\xa5\xcb\x12\x02\x00\x00\x12\x02\x00\x00\x0f\x00\x1c\x00Europe/Uzhgorod" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\a\x00" +
+       "\x00\x00\x1e\xff\xff\xff\xffj\xee\xb0\x18\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffС\x9e\xe0\xff" +
+       "\xff\xff\xff\xd1\xe5\xfd\xf0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a" +
+       "̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00" +
+       "\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\x8d.\xf0\x00\x00\x00\x00'\xf5B\xa0\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*" +
+       "\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01" +
+       "\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x00\x00\x14\xe8\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\b\x00\x008@\x01\r" +
+       "\x00\x00*0\x00\x11\x00\x00\x1c \x00\x15\x00\x00*0\x01\x19LMT\x00CET\x00CEST\x00MSD\x00MSK\x00EET\x00EEST\x00\nEET-2EEST,M" +
+       "3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R]i\x11u\xd6\x02\x00\x00\xd6\x02\x00\x00\x10\x00\x1c\x00Europe/Astra" +
+       "khanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00" +
-       "\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18" +
+       "\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x18Et\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18" +
        "\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00" +
-       "\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'" +
+       "\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'" +
        "\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00" +
        "\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x006" +
        "2[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00" +
        "\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D" +
        "%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00" +
-       "\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00XCNp\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04" +
-       "\x01\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00+2\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01" +
-       "\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQDd#\xc4\xf1\x01\x00\x00" +
-       "\xf1\x01\x00\x00\f\x00\x1c\x00Europe/VaduzUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff$\xf0\xea\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff\xff\xca\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb" +
-       "\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00" +
-       "\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!" +
-       "\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00" +
-       "\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/" +
-       "t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00" +
-       "\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5" +
-       ".0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x0f\x00\x1c\x00Europe/IstanbulUT\t\x00\x03\xec,\x94_\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x19\xff\xff\xff\xffV\xb6\xc8" +
-       "\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff" +
-       "\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff\xff\xab\xf9\x89\xe0\xff\xff\xff\xff\xac\xc31P\xff\xff\xff\xffȁ?\xe0\xff\xff\xff\xff\xc9\x01\x13" +
-       "P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\tP\xff\xff\xff\xffӢ9`\xff\xff\xff\xff\xd4C\x02P\xff\xff\xff\xff\xd5L\r\xe0\xff\xff\xff" +
-       "\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff\xff\xd9\xe9?\xd0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff\xdb\xd2\\P\xff\xff\xff\xff\xdc\xd4\xd0" +
-       "`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06`\xff\xff\xff\xff\xf6\x1f8\xd0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a9\x9ap\x00\x00\x00" +
-       "\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00\x00\v\xb1\xfe\x80\x00\x00\x00\x00\f\xd9@p\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\xa6\xad" +
-       "p\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ\xe0\x00\x00\x00\x00\x1b\xe6\xd0\xf0\x00\x00\x00\x00\x1c\xc6\xef\xf0\x00\x00\x00\x00\x1d\x9b1p\x00\x00\x00" +
-       "\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n" +
-       "\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00" +
-       "\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e" +
-       "\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00" +
-       "\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c" +
-       "\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00" +
-       "\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8fݐ\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn" +
-       "\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe\x10\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V>\x9e\x90\x00\x00\x00" +
-       "\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00*0\x00\x11\x00\x008@\x01\x15LMT\x00IMT\x00EEST\x00EET" +
-       "\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\r\x00\x1c\x00Europe/Lisbo" +
-       "nUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x06" +
-       "\x00\x00\x00\x1b\xff\xff\xff\xff^=\f\x1d\xff\xff\xff\xff\x92掀\xff\xff\xff\xff\x9bKmp\xff\xff\xff\xff\x9b\xfeǀ\xff\xff\xff\xff\x9c\x9c\xedp\xff\xff\xff\xff\x9dɃp\xff\xff\xff\xff\x9e\u007frp" +
-       "\xff\xff\xff\xff\x9f\xaa\xb6\xf0\xff\xff\xff\xff\xa0_Tp\xff\xff\xff\xff\xa1\x8b\xeap\xff\xff\xff\xff\xa2A\xd9p\xff\xff\xff\xff\xa3nop\xff\xff\xff\xff\xa4#\f\xf0\xff\xff\xff\xff\xa5O\xa2\xf0\xff\xff\xff\xff" +
-       "\xaa\x05\xefp\xff\xff\xff\xff\xaa\xf4\x8e\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p" +
-       "\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff" +
-       "\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p" +
-       "\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X\xacp\xff\xff\xff\xff\xc7\xd9\xdfp\xff\xff\xff\xff\xc9\x01/p\xff\xff\xff\xff\xc9\xf1 p\xff\xff\xff\xff\xca\xe2b\xf0\xff\xff\xff\xff" +
-       "˵R\xf0\xff\xff\xff\xff\xcb\xec\xa3\xe0\xff\xff\xff\xff̀K\xe0\xff\xff\xff\xff\xccܢ\xf0\xff\xff\xff\xff͕4\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xff\xcer\xa2\xe0\xff\xff\xff\xff\xceſp" +
-       "\xff\xff\xff\xff\xcfu\x16\xf0\xff\xff\xff\xffϬg\xe0\xff\xff\xff\xff\xd0R\x84\xe0\xff\xff\xff\xffХ\xa1p\xff\xff\xff\xff\xd1T\xf8\xf0\xff\xff\xff\xffьI\xe0\xff\xff\xff\xff\xd22f\xe0\xff\xff\xff\xff" +
-       "҅\x83p\xff\xff\xff\xff\xd3Y\xc4\xf0\xff\xff\xff\xff\xd4I\xb5\xf0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6)\xc2 \xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8\t\xa4 \xff\xff\xff\xff\xd8\xf9\x95 " +
-       "\xff\xff\xff\xff\xd9\xe9\x86 \xff\xff\xff\xffܹY \xff\xff\xff\xffݲ\x84\xa0\xff\xff\xff\xffޢu\xa0\xff\xff\xff\xffߒf\xa0\xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff" +
-       "\xe2b9\xa0\xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe8\xfb\v " +
-       "\xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xca\xde \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff" +
-       "\xf0z\x93 \xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2c\xaf\xa0\xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4C\x91\xa0\xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6#s\xa0\xff\xff\xff\xff\xf7\x13d\xa0" +
-       "\xff\xff\xff\xff\xf8\x03U\xa0\xff\xff\xff\xff\xf8\xf3F\xa0\x00\x00\x00\x00\f\xab*\x00\x00\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00" +
-       "\x11d\x19\x80\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13C\xfb\x80\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90" +
-       "\x00\x00\x00\x00\x18㽠\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00" +
-       "\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10" +
-       "\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00" +
-       "-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x05\x04\x05\x04\x05\x04\x01\xff\xff\xf7c\x00" +
-       "\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\t\x00\x00\x1c \x01\r\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\x16LMT\x00WEST\x00WET\x00WEMT\x00CET\x00CEST\x00\nW" +
-       "ET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQN\xa5\xa5\xcb\x12\x02\x00\x00\x12\x02\x00\x00\x0f\x00\x1c\x00Europ" +
-       "e/UzhgorodUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00%\x00\x00\x00\a\x00\x00\x00\x1e\xff\xff\xff\xffj\xee\xb0\x18\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4" +
-       "\x10\xff\xff\xff\xffС\x9e\xe0\xff\xff\xff\xff\xd1\xe5\xfd\xf0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00" +
-       "\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU" +
-       "\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\x8d.\xf0\x00\x00\x00\x00'\xf5B\xa0\x00\x00\x00" +
-       "\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad" +
-       "\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x01\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x00\x00\x14\xe8\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00" +
-       "\x1c \x01\b\x00\x008@\x01\r\x00\x00*0\x00\x11\x00\x00\x1c \x00\x15\x00\x00*0\x01\x19LMT\x00CET\x00CEST\x00MSD\x00MSK\x00EET\x00EEST\x00\nE" +
-       "ET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe0\xfe\x83\xe5\xcd\x02\x00\x00\xcd\x02\x00\x00\f\x00\x1c\x00Eu" +
-       "rope/KirovUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00?\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01" +
-       "\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00" +
-       "\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb" +
-       "\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00" +
-       "\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80" +
-       "\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00" +
-       "\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe" +
-       "\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00" +
-       "\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x03" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x00\x00.\x98\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x00" +
-       "8@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xea\xc48\xde\\\x02\x00\x00\\\x02\x00" +
-       "\x00\r\x00\x1c\x00Europe/TiraneUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x96\xaa4h\xff\xff\xff\xff\xc8m\x87p\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u0378\xe9" +
-       "\x90\x00\x00\x00\x00\b(9\xf0\x00\x00\x00\x00\b\xef>`\x00\x00\x00\x00\n\x05x\xf0\x00\x00\x00\x00\n\xd0q\xe0\x00\x00\x00\x00\v\xe9Op\x00\x00\x00\x00\f\xb4H`\x00\x00\x00\x00\r\xd2k\xf0\x00\x00\x00" +
-       "\x00\x0e\x94*`\x00\x00\x00\x00\x0f\xb0\xfcp\x00\x00\x00\x00\x10t\f`\x00\x00\x00\x00\x11\x90\xdep\x00\x00\x00\x00\x12S\xee`\x00\x00\x00\x00\x13p\xc0p\x00\x00\x00\x00\x14;\xb9`\x00\x00\x00\x00\x15H\xb9" +
-       "p\x00\x00\x00\x00\x16\x13\xb2`\x00\x00\x00\x00\x171\xd5\xf0\x00\x00\x00\x00\x17\xfc\xce\xe0\x00\x00\x00\x00\x19\x00\x94p\x00\x00\x00\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00" +
-       "\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E" +
-       "\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00" +
-       "\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9" +
-       "\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x12\x98\x00\x00\x00\x00\x0e" +
-       "\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x1c\x00Europe/TiraspolUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc8\xf8\xff\xff\xff\xff\x9ek\x9f\f\xff\xff\xff\xff\xb7\xb0" +
-       "\xd2\b\xff\xff\xff\xff\xb9>\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff" +
-       "\xff\xff\xbf\x98|\xe0\xff\xff\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(" +
-       "\x13\xe0\xff\xff\xff\xff\xc7\x18\x04\xe0\xff\xff\xff\xffȼ\x93`\xff\xff\xff\xff\xcaw}P\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff" +
-       "\xff\xff\xd0N\x90`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a\xcc" +
-       "\x93\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00" +
-       "\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00&CL\xe0\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5" +
-       "&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00" +
-       "\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xad\x00\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05" +
-       "\x06\x05\x06\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x00\x00\x1b\b\x00\x00\x00\x00\x1a\xf4\x00\x04\x00\x00\x18x\x00\b\x00\x00*0" +
-       "\x01\f\x00\x00\x1c \x00\x11\x00\x00\x0e\x10\x00\x15\x00\x00\x1c \x01\x19\x00\x008@\x01\x1e\x00\x00*0\x00\"LMT\x00CMT\x00BMT\x00EEST\x00EET\x00CET\x00CES" +
-       "T\x00MSD\x00MSK\x00\nEET-2EEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00" +
-       "\xde\x01\x00\x00\x0f\x00\x1c\x00Europe/SarajevoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff" +
-       "\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1a\xc3" +
-       "\x91\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00" +
-       "\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5" +
-       "%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00" +
-       "\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10" +
-       "\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQZk#V\x81\x03\x00\x00\x81\x03\x00\x00\r\x00\x1c\x00Europe/MadridUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xff~6\xb5\x00\xff\xff\xff\xff\x9e\xba\xc5\xf0\xff\xff\xff\xff\x9f\xa09\x00\xff" +
-       "\xff\xff\xff\xa0\x90\x1b\xf0\xff\xff\xff\xff\xa1\x81l\x80\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0" +
-       "\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x12\x80\xff\xff\xff\xff\xc2\xc9\xec\xf0\xff\xff\xff\xff\xc3X]\x00\xff\xff\xff\xff\xc4H?\xf0\xff" +
-       "\xff\xff\xff\xc4m\x1b\xe0\xff\xff\xff\xff\xc59t`\xff\xff\xff\xff\xc7![\x80\xff\xff\xff\xff\xc7\xf5\x8e\xf0\xff\xff\xff\xff\xcb\xf5\xde`\xff\xff\xff\xff̕q\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xff\xce" +
-       "\xa0\xd5p\xff\xff\xff\xffϣ-`\xff\xff\xff\xffЀ\xb7p\xff\xff\xff\xffу\x0f`\xff\xff\xff\xff\xd2`\x99p\xff\xff\xff\xff\xd3b\xf1`\xff\xff\xff\xff\xd4@{p\xff\xff\xff\xff\xd9\x1eF\xe0\xff" +
-       "\xff\xff\xff\xd9\xe9[\xf0\x00\x00\x00\x00\b\r\xcd\xe0\x00\x00\x00\x00\b\xf4\x92p\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\n\xd4tp\x00\x00\x00\x00\v\xbb\x1c\xe0\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r" +
-       "\xa49`\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00" +
-       "\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b" +
-       "\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00" +
-       "\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)" +
-       "\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00" +
-       "\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\xfc\x8c\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\t\x00\x00\x1c \x01\r\x00\x00\x1c \x01\x12\x00\x00\x0e\x10" +
-       "\x00\x17LMT\x00WEST\x00WET\x00WEMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x1c\x00Europe/PodgoricaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x02" +
-       "5\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00" +
-       "\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|" +
-       "\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00" +
-       "\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94" +
-       "ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M" +
-       "10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\x0f\x00\x1c\x00Europe/BusingenUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff" +
-       "\xff$\xf0\xea\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff\xff\xca\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13\xdc" +
-       "\x90\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00" +
-       "\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6" +
-       "\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00" +
-       "\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BM" +
-       "T\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x95\xb4\x9e\xe7\xb3\x03\x00" +
-       "\x00\xb3\x03\x00\x00\x0e\x00\x1c\x00Europe/VaticanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff" +
-       "\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff\xa2\\7p\xff\xff\xff\xff\xa3L" +
-       "\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff" +
-       "\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93" +
-       "\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00" +
-       "\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a\v" +
-       "u\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xebW\xf0\x00\x00\x00\x00\n.Wp\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00" +
-       "\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#" +
-       "\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00" +
-       "\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<" +
-       "E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00" +
-       "\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]" +
-       "\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00RMT" +
-       "\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00" +
-       "?\x06\x00\x00\x0e\x00\x1c\x00Europe/BelfastUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff" +
-       "\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8" +
-       "\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff" +
-       "\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL" +
-       "\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff" +
-       "\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b" +
-       " \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff" +
-       "\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2" +
-       "\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff" +
-       "\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec" +
-       " \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff" +
-       "\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v" +
-       " \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff" +
-       "\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef" +
-       "\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00" +
-       "\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe" +
-       " \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00" +
-       "\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8" +
-       "\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00" +
-       "\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18" +
-       "\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00" +
-       "\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BD" +
-       "ST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\x11\x00\x1c\x00E" +
-       "urope/BratislavaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x1eI\x92\xf8\xff\xff\xff\xffl\xcf\xea\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff" +
-       "\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xff\xcf" +
-       "\x924\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xffӀ\x1c\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xffԓ\xb4 \xff\xff\xff\xff\xd5\x02r \xff" +
-       "\xff\xff\xff\xd5L8\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x01p\x10\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12" +
-       "T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00" +
-       "\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 " +
-       "lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00" +
-       "\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00." +
-       "\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\r\x88\x00\x00\x00\x00\r\x88\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x00\x00\x01\x11LM" +
-       "T\x00PMT\x00CEST\x00CET\x00GMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q8I\xdeN%\x02\x00\x00%\x02\x00\x00\v\x00\x1c\x00Europe/KievUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\b\x00\x00\x00\"\xff\xff\xff\xffV\xb6\xc7d\xff\xff\xff\xff\xaa\x19\xa7d\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xff\xca" +
-       "\xcd.\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xff\xceͨp\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00" +
-       "\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e" +
-       "\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00" +
-       "\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00&\x8d \xe0\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-" +
-       "\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x05\x04\x05\x04\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06" +
-       "\x03\x06\a\x02\a\x02\a\x02\a\x02\a\x02\a\x00\x00\x1c\x9c\x00\x00\x00\x00\x1c\x9c\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c \x01\x14\x00\x008@\x01\x19\x00\x00*0\x01" +
-       "\x1dLMT\x00KMT\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5" +
-       ".0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQO+j\x94\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Europe/KaliningradUT\t\x00\x03\xec," +
-       "\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\b\x00\x00\x00\"\xff\xff\xff\xff" +
-       "o\xa2[H\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90" +
-       "\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1|w\xe0\xff\xff\xff\xff" +
-       "ѕ\x84`\xff\xff\xff\xffҊ\xadP\xff\xff\xff\xff\xd3Y\xb6\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0" +
-       "\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00" +
-       " lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80" +
-       "\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00" +
-       ".\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00" +
-       "\x00\x00\x00\x0062j\x00\x00\x00\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x009\xfbh\x80\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80\x00\x00\x00\x00" +
-       "<\xa6Q\x80\x00\x00\x00\x00=\xbb,\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80\x00\x00\x00\x00A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00Cd\r\x00" +
-       "\x00\x00\x00\x00D%ـ\x00\x00\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00G\xee\xd8\x00\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00\x00\x00\x00\x00" +
-       "J\xe3\x95\x00\x00\x00\x00\x00K\xae\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x00\x00\x00\x00TL+p\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\a\x04\x00\x00\x138" +
-       "\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x12\x00\x008@\x01\x16\x00\x00*0\x00\x1a\x00\x00*0\x00\x1eLMT\x00CEST\x00CET\x00EES" +
-       "T\x00EET\x00MSD\x00MSK\x00+03\x00\nEET-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf2\xfa\xcb\x130\x02\x00\x000\x02\x00\x00\x11\x00\x1c\x00Europ" +
-       "e/ZaporozhyeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00'\x00\x00\x00\b\x00\x00\x00$\xff\xff\xff\xffV\xb6\xc3\b\xff\xff\xff\xff\xaa\x19\xa30\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xffʪ\xe7\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xff\xcd" +
-       "\xa9\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffν\xd6p\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00" +
-       "\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 " +
-       "lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00" +
-       "\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00." +
-       "\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x05\x04\x05\x04\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a" +
-       "\x02\a\x02\a\x02\a\x00\x00 \xf8\x00\x00\x00\x00 \xd0\x00\x04\x00\x00\x1c \x00\n\x00\x00*0\x00\x0e\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\x16\x00\x008@\x01\x1b\x00\x00*0\x01\x1fLMT\x00+0" +
-       "220\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQZ\x05wג\x02\x00\x00\x92\x02\x00\x00\r\x00\x1c\x00Europe/ViennaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffo\xa2_/\xff\xff\xff\xff\x9b\f" +
-       "\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa2p\x1a\x10\xff\xff\xff\xff\xa3D[\x90\xff\xff" +
-       "\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\u007f" +
-       "E\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xc3\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\x00\x00\x00\x00\x13M'\xf0\x00\x00" +
-       "\x00\x00\x143\xd0`\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1a\xc3" +
-       "\x91\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00" +
-       "\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5" +
-       "%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00" +
-       "\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x0fQ\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M" +
-       "10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe6Kf\xab\xfe\x02\x00\x00\xfe\x02\x00\x00\x0f\x00\x1c\x00Europe/BudapestUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff" +
-       "\xffk\x17\x91\x9c\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa0\x9a\xc4" +
-       "\x10\xff\xff\xff\xff\xa1dy\x90\xff\xff\xff\xff\xa2p\x1a\x10\xff\xff\xff\xff\xa3M\x96\x10\xff\xff\xff\xff\xc9\xf3\xb5`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff" +
-       "\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffљx\xe0\xff\xff\xff\xffҊ\xc9p\xff\xff\xff\xff\xd3P\xa6\x90\xff\xff\xff\xff\xd4K\x15\x80\xff\xff\xff\xff\xd59\xc3\x10\xff\xff\xff\xff\xd6)\xb4" +
-       "\x10\xff\xff\xff\xff\xd7\x19\xa5\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff⢨\xf0\xff\xff\xff\xff\xe3Q\xf2`\xff\xff\xff\xff䂧\x10\xff\xff\xff" +
-       "\xff\xe51\xfe\x90\xff\xff\xff\xff\xe6t\xfe\x10\xff\xff\xff\xff\xe7\x11\xe0\x90\xff\xff\xff\xff\xe8T\xe0\x10\xff\xff\xff\xff\xe8\xf1\u0090\x00\x00\x00\x00\x13M'\xf0\x00\x00\x00\x00\x143\xdep\x00\x00\x00\x00\x15#\xcf" +
-       "p\x00\x00\x00\x00\x16\x13\xc0p\x00\x00\x00\x00\x17\x03\xb1p\x00\x00\x00\x00\x17\xf3\xa2p\x00\x00\x00\x00\x18\xe3\x93p\x00\x00\x00\x00\x19ӄp\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00" +
-       "\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E" +
-       "\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00" +
-       "\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9" +
-       "\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x11\xe4\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M1" +
-       "0.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xccb\xf72\xa4\x02\x00\x00\xa4\x02\x00\x00\x0e\x00\x1c\x00Europe/VilniusUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV" +
-       "\xb6\xccD\xff\xff\xff\xff\x9cO\x1fP\xff\xff\xff\xff\xa1\x85J\x98\xff\xff\xff\xff\xa2\xf10\xf0\xff\xff\xff\xff\xa3fx`\xff\xff\xff\xffȬ\xcfp\xff\xff\xff\xff\xcaY*\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff" +
-       "\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd00=\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17" +
-       "\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00" +
-       "\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&" +
-       "\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00" +
-       "\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004" +
-       "R\x88\x00\x00\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x00>\x86A\x90\x01\x02\x03\x04\x03\x05\x06\x03\x06\x03\x06\x05\a\x05\a\x05\a" +
-       "\x05\a\x05\a\x05\a\x05\a\x05\a\x05\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\x06\x03\x06\x04\b\x00\x00\x17\xbc\x00\x00\x00\x00\x13\xb0\x00\x04\x00\x00\x16h\x00\b\x00\x00\x0e\x10\x00\f\x00\x00" +
-       "\x1c \x00\x10\x00\x00*0\x00\x14\x00\x00\x1c \x01\x18\x00\x008@\x01\x1d\x00\x00*0\x01!LMT\x00WMT\x00KMT\x00CET\x00EET\x00MSK\x00CEST\x00MSD" +
-       "\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQn\x81\xf4\xd7Z\x04\x00\x00Z\x04" +
-       "\x00\x00\r\x00\x1c\x00Europe/MonacoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\a\x00\x00\x00\x1f\xff\xff\xff\xffn\x11\x9f\x94\xff\xff\xff\xff\x91x\vO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc" +
-       "\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0*\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff" +
-       "\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8X&p\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7" +
-       "_\xf0\xff\xff\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7A\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff" +
-       "\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb5I/\xf0\xff\xff\xff\xff\xb6/\xe6p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff" +
-       "\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xba\xd6`\xf0\xff\xff\xff\xff\xbb\xd8\xc6\xf0\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff" +
-       "\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X" +
-       "\xacp\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x17[\xf0\xff\xff\xff\xff\xca\xe2T\xe0\xff\xff\xff\xff˭i\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff" +
-       "\xff\xffϒ4\x10\xff\xff\xff\xffЉ\xf1\xf0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\v\xbb9\x00\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b" +
-       "\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00" +
-       "\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac" +
-       "\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00" +
-       "\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5" +
-       "\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x06\x05" +
-       "\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x00\x00\x06\xec\x00\x00\x00\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00" +
-       "\x00\x00\x00\r\x00\x00\x1c \x01\x11\x00\x00\x1c \x01\x16\x00\x00\x0e\x10\x00\x1bLMT\x00PMT\x00WEST\x00WET\x00WEMT\x00CEST\x00CET\x00\nCET-1C" +
-       "EST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\v\x00\x1c\x00Europe/Os" +
-       "loUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00" +
-       "\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff\xff\x9b'\xe3\x00\xff\xff\xff\xff\x9b\xd4{`\xff\xff\xff\xffȷM`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C" +
-       "\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff\xed\x98=\x10\xff\xff\xff" +
-       "\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff\xff\xf0h\x10\x10\xff\xff\xff\xff\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10\xff\xff\xff\xff\xf5\x17\xc5" +
-       "\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06\x10\xff\xff\xff\xff\xf7\xf0Ґ\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00" +
+       "\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00V\xf7\x14p\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04" +
+       "\x01\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00-\f\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01" +
+       "\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xea\xc48\xde\\\x02\x00\x00" +
+       "\\\x02\x00\x00\r\x00\x1c\x00Europe/TiraneUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x002\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\x96\xaa4h\xff\xff\xff\xff\xc8m\x87p\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff" +
+       "\u0378\xe9\x90\x00\x00\x00\x00\b(9\xf0\x00\x00\x00\x00\b\xef>`\x00\x00\x00\x00\n\x05x\xf0\x00\x00\x00\x00\n\xd0q\xe0\x00\x00\x00\x00\v\xe9Op\x00\x00\x00\x00\f\xb4H`\x00\x00\x00\x00\r\xd2k\xf0" +
+       "\x00\x00\x00\x00\x0e\x94*`\x00\x00\x00\x00\x0f\xb0\xfcp\x00\x00\x00\x00\x10t\f`\x00\x00\x00\x00\x11\x90\xdep\x00\x00\x00\x00\x12S\xee`\x00\x00\x00\x00\x13p\xc0p\x00\x00\x00\x00\x14;\xb9`\x00\x00\x00\x00" +
+       "\x15H\xb9p\x00\x00\x00\x00\x16\x13\xb2`\x00\x00\x00\x00\x171\xd5\xf0\x00\x00\x00\x00\x17\xfc\xce\xe0\x00\x00\x00\x00\x19\x00\x94p\x00\x00\x00\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbc\xbd\x10" +
+       "\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00" +
+       "#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90" +
+       "\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x00" +
+       "1]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x12\x98\x00\x00" +
+       "\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9RIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\r\x00\x1c\x00Europe/PragueUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x1eI\x92\xf8\xff\xff\xff\xffl\xcf\xea\xf8\xff\xff\xff\xff\x9b" +
+       "\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff" +
+       "\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xffӀ\x1c\x90\xff\xff\xff\xff\xd4" +
+       "I\xd2\x10\xff\xff\xff\xffԓ\xb4 \xff\xff\xff\xff\xd5\x02r \xff\xff\xff\xff\xd5L8\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x01p\x10\xff" +
+       "\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17" +
+       "\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00" +
+       "\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%" +
+       "\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00" +
+       "\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\r\x88\x00\x00\x00\x00\r\x88\x00\x04" +
+       "\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x00\x00\x01\x11LMT\x00PMT\x00CEST\x00CET\x00GMT\x00\nCET-1CEST,M3.5.0,M10" +
+       ".5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\r\x00\x1c\x00Europe/ZagrebUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0" +
+       "H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff" +
+       "\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90" +
+       "\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00" +
+       "\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9" +
+       "\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M" +
+       "3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x11\x00\x1c\x00Europe/San_Mar" +
+       "inoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00" +
+       "\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89" +
+       "\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff" +
+       "\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I" +
+       "\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff" +
+       "\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9c" +
+       "Zp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a\vu\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xebW\xf0\x00\x00" +
+       "\x00\x00\n.Wp\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00\x00\x00\x10t" +
+       "\x1ap\x00\x00\x00\x00\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00" +
+       "\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c" +
+       "\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00" +
+       "\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4" +
+       "\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00RMT\x00CEST\x00CET\x00\nCET-1CEST" +
+       ",M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc9\a\xa0\xe1/\x04\x00\x00/\x04\x00\x00\x10\x00\x1c\x00Europe/Amste" +
+       "rdamUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00" +
+       "\x00\x00\a\x00\x00\x00!\xff\xff\xff\xff\x02\x12Ql\xff\xff\xff\xff\x9b\f.\xec\xff\xff\xff\xff\x9b\xd5\xd6\\\xff\xff\xff\xff\x9cٸ\f\xff\xff\xff\xff\x9d\xa4\xbf\f\xff\xff\xff\xff\x9e\xa7%\f\xff\xff\xff\xff\x9f" +
+       "\x97\x16\f\xff\xff\xff\xff\xa0\x90A\x8c\xff\xff\xff\xff\xa1v\xf8\f\xff\xff\xff\xff\xa2p#\x8c\xff\xff\xff\xff\xa3V\xda\f\xff\xff\xff\xff\xa4P\x05\x8c\xff\xff\xff\xff\xa56\xbc\f\xff\xff\xff\xff\xa6%[\x8c\xff" +
+       "\xff\xff\xff\xa7'\xc1\x8c\xff\xff\xff\xff\xa8^\xe3\x8c\xff\xff\xff\xff\xa9\a\xa3\x8c\xff\xff\xff\xff\xa9\xeeZ\f\xff\xff\xff\xff\xaa煌\xff\xff\xff\xff\xac'\xe2\f\xff\xff\xff\xff\xac\xc7g\x8c\xff\xff\xff\xff\xad" +
+       "\xedf\f\xff\xff\xff\xff\xae\xa7I\x8c\xff\xff\xff\xff\xafΙ\x8c\xff\xff\xff\xff\xb0\x87+\x8c\xff\xff\xff\xff\xb1\xb1\x1e\x8c\xff\xff\xff\xff\xb2pH\f\xff\xff\xff\xff\xb3\x92R\f\xff\xff\xff\xff\xb4P*\f\xff" +
+       "\xff\xff\xff\xb5s\x85\x8c\xff\xff\xff\xff\xb60\f\f\xff\xff\xff\xff\xb7T\xb9\f\xff\xff\xff\xff\xb8\x0f\xee\f\xff\xff\xff\xff\xb9@x\x8c\xff\xff\xff\xff\xb9\xef\xd0\f\xff\xff\xff\xff\xbb\x18q\x8c\xff\xff\xff\xff\xbb" +
+       "\xd8\xec\x8c\xff\xff\xff\xff\xbc\xf9\xa5\f\xff\xff\xff\xff\xbd\xb8Ό\xff\xff\xff\xff\xbe\xda،\xff\xff\xff\xff\xbf\x98\xb0\x8c\xff\xff\xff\xff\xc0\xbd]\x8c\xff\xff\xff\xff\xc1x\x92\x8c\xff\xff\xff\xff§ˌ\xff" +
+       "\xff\xff\xff\xc2\xdc]\\\xff\xff\xff\xff\xc3Xtp\xff\xff\xff\xff\xc4\u007f\xc4p\xff\xff\xff\xff\xc58Vp\xff\xff\xff\xff\xc6`\xf7\xf0\xff\xff\xff\xff\xc7!r\xf0\xff\xff\xff\xff\xc8D\xb2P\xff\xff\xff\xff\xcc" +
+       "\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00" +
+       "\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15" +
+       "#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00" +
+       "\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#" +
+       "<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00" +
+       "\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001" +
+       "]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x00\x00\x04\x94\x00\x00\x00\x00\x12\xa4\x01\x04\x00\x00\x04\x94\x00\b\x00\x00" +
+       "\x04\xb0\x00\f\x00\x00\x12\xc0\x01\x12\x00\x00\x0e\x10\x00\x18\x00\x00\x1c \x01\x1cLMT\x00NST\x00AMT\x00+0020\x00+0120\x00CET\x00CEST\x00\nCET-" +
+       "1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x0e\x00\x1c\x00Europe/" +
+       "VaticanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00W\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff" +
+       "\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7" +
+       "K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff" +
+       "\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c" +
+       "\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00" +
+       "\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a\vu\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xeb" +
+       "W\xf0\x00\x00\x00\x00\n.Wp\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00" +
+       "\x00\x00\x10t\x1ap\x00\x00\x00\x00\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03" +
+       "͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00" +
+       "\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c" +
+       "'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00" +
+       "\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00RMT\x00CEST\x00CET\x00\nCET-1" +
+       "CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\r\x00\x1c\x00Europe/D" +
+       "ublinUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91" +
+       "\x00\x00\x00\b\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6\v\x11\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff" +
+       "\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` " +
+       "\xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff" +
+       "\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0" +
+       "\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff" +
+       "\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd " +
+       "\xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff" +
+       "\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd7,( \xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0" +
+       "\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff" +
+       "\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq " +
+       "\xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff" +
+       "\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 " +
+       "\xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00" +
+       "\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N " +
+       "\x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00" +
+       "\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐" +
+       "\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00" +
+       " lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90" +
+       "\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00" +
+       ".\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\x06\a\xff\xff\xfa$\x00\x00\xff" +
+       "\xff\xfa\x0f\x00\x04\x00\x00\b\x1f\x01\b\x00\x00\x0e\x10\x01\f\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x01\x10\x00\x00\x0e\x10\x00\bLMT\x00DMT\x00IST\x00BST\x00GMT" +
+       "\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RWI\xc3\u007f(\x03\x00\x00(\x03\x00\x00\f\x00\x1c\x00E" +
+       "urope/MinskUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00D\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xca(\xff\xff\xff\xff\xaa\x19\xaa8\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xff\xca^p\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ" +
+       "\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0\n\x02`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00" +
+       "\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|" +
+       "d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00'\xf5\x18p\x00\x00" +
+       "\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t" +
+       "\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062j\x00\x00\x00" +
+       "\x00\x006\xfdq\x00\x00\x00\x00\x008\x1b\x86\x80\x00\x00\x00\x008\xddS\x00\x00\x00\x00\x009\xfbh\x80\x00\x00\x00\x00:\xbd5\x00\x00\x00\x00\x00;\xdbJ\x80\x00\x00\x00\x00<\xa6Q\x80\x00\x00\x00\x00=\xbb" +
+       ",\x80\x00\x00\x00\x00>\x863\x80\x00\x00\x00\x00?\x9b\x0e\x80\x00\x00\x00\x00@f\x15\x80\x00\x00\x00\x00A\x84+\x00\x00\x00\x00\x00BE\xf7\x80\x00\x00\x00\x00Cd\r\x00\x00\x00\x00\x00D%ـ\x00\x00" +
+       "\x00\x00EC\xef\x00\x00\x00\x00\x00F\x05\xbb\x80\x00\x00\x00\x00G#\xd1\x00\x00\x00\x00\x00G\xee\xd8\x00\x00\x00\x00\x00I\x03\xb3\x00\x00\x00\x00\x00Iκ\x00\x00\x00\x00\x00J\xe3\x95\x00\x00\x00\x00\x00K\xae" +
+       "\x9c\x00\x00\x00\x00\x00Ḻ\x80\x00\x00\x00\x00M\x8e~\x00\x01\x02\x03\x05\x04\x05\x04\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a" +
+       "\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\b\x00\x00\x19\xd8\x00\x00\x00\x00\x19\xc8\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c " +
+       "\x01\x14\x00\x008@\x01\x19\x00\x00*0\x01\x1d\x00\x00*0\x00\"LMT\x00MMT\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00+03\x00\n<" +
+       "+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RZk#V\x81\x03\x00\x00\x81\x03\x00\x00\r\x00\x1c\x00Europe/MadridUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xff~6\xb5" +
+       "\x00\xff\xff\xff\xff\x9e\xba\xc5\xf0\xff\xff\xff\xff\x9f\xa09\x00\xff\xff\xff\xff\xa0\x90\x1b\xf0\xff\xff\xff\xff\xa1\x81l\x80\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xe7n\x00\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff" +
+       "\xff\xae\xa72\x00\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x14\x00\xff\xff\xff\xff\xb1\x89z\x00\xff\xff\xff\xff\xb2p0\x80\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x12\x80\xff\xff\xff\xff\xc2\xc9\xec" +
+       "\xf0\xff\xff\xff\xff\xc3X]\x00\xff\xff\xff\xff\xc4H?\xf0\xff\xff\xff\xff\xc4m\x1b\xe0\xff\xff\xff\xff\xc59t`\xff\xff\xff\xff\xc7![\x80\xff\xff\xff\xff\xc7\xf5\x8e\xf0\xff\xff\xff\xff\xcb\xf5\xde`\xff\xff\xff" +
+       "\xff̕q\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xffΠ\xd5p\xff\xff\xff\xffϣ-`\xff\xff\xff\xffЀ\xb7p\xff\xff\xff\xffу\x0f`\xff\xff\xff\xff\xd2`\x99p\xff\xff\xff\xff\xd3b\xf1" +
+       "`\xff\xff\xff\xff\xd4@{p\xff\xff\xff\xff\xd9\x1eF\xe0\xff\xff\xff\xff\xd9\xe9[\xf0\x00\x00\x00\x00\b\r\xcd\xe0\x00\x00\x00\x00\b\xf4\x92p\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\n\xd4tp\x00\x00\x00" +
+       "\x00\v\xbb\x1c\xe0\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18" +
+       "\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00" +
+       "\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr" +
+       "\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00" +
+       "\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84\xcb" +
+       "\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\xfc\x8c\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00" +
+       "\x00\t\x00\x00\x1c \x01\r\x00\x00\x1c \x01\x12\x00\x00\x0e\x10\x00\x17LMT\x00WEST\x00WET\x00WEMT\x00CEST\x00CET\x00\nCET-1CEST,M3" +
+       ".5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x1c\x00Europe/JerseyUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00" +
+       "\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff" +
+       "\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6" +
+       " \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff" +
+       "\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ" +
+       " \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff" +
+       "\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy" +
+       " \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff" +
+       "\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2" +
+       "\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff" +
+       "\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9" +
+       "\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff" +
+       "\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS" +
+       " \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff" +
+       "\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7" +
+       " \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00" +
+       "\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00" +
+       " \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00" +
+       "\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ" +
+       "\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00" +
+       "\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f" +
+       "\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00" +
+       "\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00" +
+       "\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10" +
+       ".5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\x0e\x00\x1c\x00Europe/NicosiaUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x001\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xa5w\x1e\xb8" +
+       "\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\nݒ\xd0\x00\x00\x00\x00\v\xfad\xe0\x00\x00\x00\x00\f\xbe\xc6P\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00\x00" +
+       "\x10uO\xd0\x00\x00\x00\x00\x11c\xfd`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\x19\xe0\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3`" +
+       "\x00\x00\x00\x00\x17\xf3\x86P\x00\x00\x00\x00\x18\xe3\x85`\x00\x00\x00\x00\x19\xd3hP\x00\x00\x00\x00\x1a\xc3g`\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00" +
+       "\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\*\xd0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee\xd0" +
+       "\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00" +
+       ",\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0" +
+       "\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062x\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x1fH\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5." +
+       "0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\r\x00\x1c\x00Europe/MoscowUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00N\x00\x00\x00\v\x00\x00\x00&" +
+       "\xff\xff\xff\xffV\xb6\xc0\xc7\xff\xff\xff\xff\x9b_\x1e\xc7\xff\xff\xff\xff\x9d>\xf2y\xff\xff\xff\xff\x9e*\xee\xf9\xff\xff\xff\xff\x9e\xf79i\xff\xff\xff\xff\x9f\x84W\xf9\xff\xff\xff\xff\xa0\xd8l\xe9\xff\xff\xff\xff" +
+       "\xa1\x009\x80\xff\xff\xff\xff\xa1<\xa6@\xff\xff\xff\xff\xa4\x10m\xc0\xff\xff\xff\xff\xa4=2\xb0\xff\xff\xff\xff\xa5\x15h\xb0\xff\xff\xff\xff\xa5=\x03\xc0\xff\xff\xff\xff\xa7\x1eEP\xff\xff\xff\xff\xb5\xa4\x19`" +
+       "\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00" +
+       "\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0" +
+       "\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00" +
+       ")x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p" +
+       "\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x00" +
+       "6\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep" +
+       "\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00" +
+       "EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0" +
+       "\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x01\x03\x02\x03\x04\x02\x04\x05\x06\x05\a\x05\x06\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\t" +
+       "\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\n\x06\x00\x00#9\x00\x00\x00\x00#9\x00\x04\x00\x001\x87\x01\b" +
+       "\x00\x00#w\x00\x04\x00\x00?\x97\x01\f\x00\x008@\x01\x11\x00\x00*0\x00\x15\x00\x00FP\x01\x19\x00\x00\x1c \x00\x1d\x00\x00*0\x01!\x00\x008@\x00\x15LMT\x00MMT\x00MST\x00" +
+       "MDST\x00MSD\x00MSK\x00+05\x00EET\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x8c\xc8\x15\xd0P\x02\x00\x00P\x02\x00\x00\f" +
+       "\x00\x1c\x00Europe/SofiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00-\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xce$\xff\xff\xff\xffr\xc3\xe3\x18\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff" +
+       "\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r$ \x00\x00\x00\x00\x11c\xefP\x00\x00\x00\x00\x12U?\xe0\x00\x00\x00\x00\x13M\v\xd0\x00\x00\x00\x00\x145!\xe0\x00\x00\x00\x00\x15," +
+       "\xed\xd0\x00\x00\x00\x00\x16\x13\xc0p\x00\x00\x00\x00\x17\f\xcf\xd0\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00" +
+       "\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LF\x00\x00\x00\x00\x00#<" +
+       "7\x00\x00\x00\x00\x00$,(\x00\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00" +
+       "\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]" +
+       "\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xbb\x10\x01\x02\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
+       "\x05\x02\x05\x00\x00\x15\xdc\x00\x00\x00\x00\x1bh\x00\x04\x00\x00\x1c \x00\b\x00\x00\x0e\x10\x00\f\x00\x00\x1c \x01\x10\x00\x00*0\x01\x15LMT\x00IMT\x00EET\x00CET\x00CEST\x00" +
+       "EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xccb\xf72\xa4\x02\x00\x00\xa4\x02\x00" +
+       "\x00\x0e\x00\x1c\x00Europe/VilniusUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xccD\xff\xff\xff\xff\x9cO\x1fP\xff\xff\xff\xff\xa1\x85J\x98\xff\xff\xff\xff\xa2\xf10\xf0\xff\xff\xff\xff\xa3f" +
+       "x`\xff\xff\xff\xffȬ\xcfp\xff\xff\xff\xff\xcaY*\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd00=\xe0\x00\x00" +
+       "\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc" +
+       "\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00" +
+       "\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5" +
+       "\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00" +
+       "\x00\x001]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b" +
+       "\x94\x90\x00\x00\x00\x00>\x86A\x90\x01\x02\x03\x04\x03\x05\x06\x03\x06\x03\x06\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\a\x05\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\b\x04\x06\x03\x06\x04" +
+       "\b\x00\x00\x17\xbc\x00\x00\x00\x00\x13\xb0\x00\x04\x00\x00\x16h\x00\b\x00\x00\x0e\x10\x00\f\x00\x00\x1c \x00\x10\x00\x00*0\x00\x14\x00\x00\x1c \x01\x18\x00\x008@\x01\x1d\x00\x00*0\x01!LMT\x00W" +
+       "MT\x00KMT\x00CET\x00EET\x00MSK\x00CEST\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0" +
+       "/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x17S\x91\xb3\xc1\x02\x00\x00\xc1\x02\x00\x00\r\x00\x1c\x00Europe/BerlinUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff" +
+       "\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K" +
+       "\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff" +
+       "\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a" +
+       "\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00" +
        "\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f" +
        "\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00" +
        "\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8" +
        "\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00\x00\x00\x1c \x01\x04\x00" +
-       "\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "]i\x11u\xd6\x02\x00\x00\xd6\x02\x00\x00\x10\x00\x1c\x00Europe/AstrakhanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xaa\x18Et\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00" +
-       "\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c" +
-       "\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00" +
-       "\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+" +
-       "\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00" +
-       "\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009" +
-       "\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00" +
-       "\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G" +
-       "\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00" +
-       "\x00\x00\x00V\xf7\x14p\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00-\f\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+" +
-       "04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQz\xc3\xe8Ra\x03\x00\x00a\x03\x00\x00\x11\x00\x1c\x00Europe/SimferopolUT\t\x00\x03\xec," +
-       "\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00K\x00\x00\x00\t\x00\x00\x00\"\xff\xff\xff\xff" +
-       "V\xb6\xc4\b\xff\xff\xff\xff\xaa\x19\xa4 \xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xff\xcb\x04\x8d\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10" +
-       "\xff\xff\xff\xffϟ8\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00" +
-       "\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0" +
-       "\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\x8d.\xf0\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00" +
-       "+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00-\xc2\xc6\xd0\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000dg@\x00\x00\x00\x001]\xa0\xd0" +
-       "\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xbb\x10\x00\x00\x00\x004R\x96\x10\x00\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x00" +
-       "8\xdda\x10\x00\x00\x00\x009\xfbv\x90\x00\x00\x00\x00:\xbdC\x10\x00\x00\x00\x00;\xdbX\x90\x00\x00\x00\x00<\xa6_\x90\x00\x00\x00\x00=\xbb:\x90\x00\x00\x00\x00>\x86A\x90\x00\x00\x00\x00?\x9b\x1c\x90" +
-       "\x00\x00\x00\x00@f#\x90\x00\x00\x00\x00A\x849\x10\x00\x00\x00\x00BF\x05\x90\x00\x00\x00\x00Cd\x1b\x10\x00\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00" +
-       "G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8e\x8c\x10" +
-       "\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S7^\x80\x00\x00\x00\x00TL\x1d`\x01\x02\x03\x05" +
-       "\x04\x05\x04\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x02\a\x02\a\x02\a\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a" +
-       "\x02\a\x02\a\x02\a\x02\a\x02\b\x03\x00\x00\x1f\xf8\x00\x00\x00\x00\x1f\xe0\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c \x01\x14\x00\x008@\x01\x19\x00\x00*0\x01\x1d\x00" +
-       "\x008@\x00\fLMT\x00SMT\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "q\xf7p*\xd6\x02\x00\x00\xd6\x02\x00\x00\x10\x00\x1c\x00Europe/VolgogradUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\xf5F\xdc\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00" +
-       "\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c" +
-       "\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<(\xf0\x00" +
-       "\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+" +
-       "\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00" +
-       "\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009" +
-       "\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00" +
-       "\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G" +
-       "\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00" +
-       "\x00\x00\x00[\xd4\xed\xf0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x04\x01\x02\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01" +
-       "\x04\x01\x04\x01\x04\x01\x04\x01\x02\x01\x02\x00\x00)\xa4\x00\x00\x00\x00*0\x00\x04\x00\x008@\x00\b\x00\x00FP\x01\f\x00\x008@\x01\bLMT\x00+03\x00+04\x00+05\x00\n<+" +
-       "04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x12\x00\x1c\x00Europe/Isle_of_ManUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff" +
-       "\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba" +
-       " \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff" +
-       "\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N" +
-       " \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff" +
-       "\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW" +
-       " \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff" +
-       "\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e" +
-       "\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff" +
-       "\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03" +
-       "\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff" +
-       "\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f" +
-       "\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff" +
-       "\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf" +
-       " \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff" +
-       "\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t:" +
-       " \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00" +
-       "\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2" +
-       "\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00" +
-       "\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT" +
-       "\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00" +
-       "\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97" +
-       "\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03" +
-       "\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04" +
-       "\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x1c\x00Europe/LondonUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b" +
-       "&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff" +
-       "\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8" +
-       "\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff" +
-       "\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb7" +
-       "2v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff" +
-       "\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc5" +
-       "8[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff" +
-       "\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3" +
-       "c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff" +
-       "\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff\xdf" +
-       "\xae\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff" +
-       "\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed" +
-       "\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff" +
-       "\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb" +
-       "\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00" +
-       "\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e" +
-       "\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00" +
-       "\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c" +
-       "\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00" +
-       "\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*" +
-       "\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02" +
-       "\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c " +
-       "\x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQgp\xc0\xa7\xb6\x02\x00\x00\xb6\x02\x00\x00\v\x00\x1c\x00Europe/RigaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xcd^\xff\xff\xff\xff\x9e\xb9\x87\xfe\xff\xff\xff\xff\x9f\x84\x8e\xfe\xff" +
-       "\xff\xff\xff\xa0\x88F~\xff\xff\xff\xff\xa0˂\xfe\xff\xff\xff\xff\xad\xe7\xf1\xde\xff\xff\xff\xffȯd`\xff\xff\xff\xff\xcabeP\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\xce" +
-       "\xa2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffА\x89p\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00" +
-       "\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f" +
-       "|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00" +
-       "\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-" +
-       "\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002M\xbc\x00\x00\x00\x00\x003=\xbb\x10\x00\x00\x00\x004R\x96\x10\x00" +
-       "\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x00:\xbdC\x10\x01\x02\x01\x02\x01\x03\x04\x06\x05\x06\x05\x06\x05\x04\a\x04\a\x04\a\x04\a" +
-       "\x04\a\x04\a\x04\a\x04\a\x04\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x00\x00\x16\xa2\x00\x00\x00\x00\x16\xa2\x00\x04\x00\x00$\xb2\x01\b\x00\x00\x1c \x00\f\x00\x00*0" +
-       "\x00\x10\x00\x00\x0e\x10\x00\x14\x00\x00\x1c \x01\x18\x00\x008@\x01\x1d\x00\x00*0\x01!LMT\x00RMT\x00LST\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00E" +
-       "EST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQߜvυ\x01\x00\x00\x85\x01\x00\x00" +
-       "\x0e\x00\x1c\x00Europe/AndorraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff~6\xb3\x94\xff\xff\xff\xff\xd4A\xdb\x00\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90" +
-       "\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00" +
-       "\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9" +
-       "\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x00\x00\x01l\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x0e\x10\x00\b\x00\x00\x1c \x01\fLMT\x00WET\x00CET\x00CEST\x00\nCET-1CEST,M3" +
-       ".5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\r\x00\x1c\x00Europe/PragueUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x05\x00\x00\x00" +
-       "\x15\xff\xff\xff\xff\x1eI\x92\xf8\xff\xff\xff\xffl\xcf\xea\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff" +
-       "\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16" +
-       "\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xffӀ\x1c\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xffԓ\xb4 \xff\xff\xff\xff\xd5\x02r \xff\xff\xff\xff\xd5L8\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff" +
-       "\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x01p\x10\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa" +
-       "\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00" +
+       "\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01" +
+       "\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x1b8\xfel\xd6\x02\x00\x00\xd6\x02\x00\x00\x0e\x00\x1c\x00Europe/SaratovUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4" +
+       "\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00" +
+       "\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L" +
+       ")\xe0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00" +
+       "\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]" +
+       "\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00" +
+       "\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b" +
+       "\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00" +
+       "\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8e" +
+       "o\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00XCNp\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x04\x01\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04" +
+       "\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00+2\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00" +
+       "+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe6Kf\xab\xfe\x02\x00\x00\xfe\x02\x00\x00\x0f\x00\x1c\x00Europe/Budape" +
+       "stUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00" +
+       "\x03\x00\x00\x00\r\xff\xff\xff\xffk\x17\x91\x9c\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97" +
+       "\x90\xff\xff\xff\xff\xa0\x9a\xc4\x10\xff\xff\xff\xff\xa1dy\x90\xff\xff\xff\xff\xa2p\x1a\x10\xff\xff\xff\xff\xa3M\x96\x10\xff\xff\xff\xff\xc9\xf3\xb5`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff" +
+       "\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffљx\xe0\xff\xff\xff\xffҊ\xc9p\xff\xff\xff\xff\xd3P\xa6\x90\xff\xff\xff\xff\xd4K\x15\x80\xff\xff\xff\xff\xd59\xc3" +
+       "\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7\x19\xa5\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff⢨\xf0\xff\xff\xff\xff\xe3Q\xf2`\xff\xff\xff" +
+       "\xff䂧\x10\xff\xff\xff\xff\xe51\xfe\x90\xff\xff\xff\xff\xe6t\xfe\x10\xff\xff\xff\xff\xe7\x11\xe0\x90\xff\xff\xff\xff\xe8T\xe0\x10\xff\xff\xff\xff\xe8\xf1\u0090\x00\x00\x00\x00\x13M'\xf0\x00\x00\x00\x00\x143\xde" +
+       "p\x00\x00\x00\x00\x15#\xcfp\x00\x00\x00\x00\x16\x13\xc0p\x00\x00\x00\x00\x17\x03\xb1p\x00\x00\x00\x00\x17\xf3\xa2p\x00\x00\x00\x00\x18\xe3\x93p\x00\x00\x00\x00\x19ӄp\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00" +
        "\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT" +
        "\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00" +
        "\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad" +
-       "\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\r\x88\x00\x00\x00\x00\r\x88\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x00\x00\x01\x11LMT\x00PMT\x00CEST\x00CET\x00GMT" +
-       "\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x17S\x91\xb3\xc1\x02\x00\x00\xc1\x02\x00\x00\r\x00\x1c\x00E" +
-       "urope/BerlinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e" +
-       "\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff" +
-       "\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5" +
-       "g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00" +
-       "\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1a" +
-       "Ñ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00" +
-       "\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(" +
-       "\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00" +
-       "\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCE" +
-       "T-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQq\x16\x9b?\xa3\x02\x00\x00\xa3\x02\x00\x00\x0e\x00\x1c\x00Europ" +
-       "e/TallinnUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x004\x00\x00\x00\b\x00\x00\x00\"\xff\xff\xff\xffV\xb6\xcc\xcc\xff\xff\xff\xff\x9eY-\xcc\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa1\x00+p\xff\xff\xff\xff\xa4soL" +
-       "\xff\xff\xff\xffȰ\xb5\xe0\xff\xff\xff\xff\xcaƗP\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0t\xcb\xe0\x00\x00\x00\x00" +
-       "\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0" +
-       "\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00" +
-       "#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80" +
-       "\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x00" +
-       "1]\xcb\x00\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90" +
-       "\x00\x00\x00\x00<\xa6_\x90\x01\x03\x02\x03\x01\x04\x05\x02\x03\x02\x03\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a" +
-       "\x00\x00\x174\x00\x00\x00\x00\x174\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x1c \x00\x11\x00\x00*0\x00\x15\x00\x008@\x01\x19\x00\x00*0\x01\x1dLMT\x00TMT\x00CEST" +
-       "\x00CET\x00EET\x00MSK\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\v\x00\x1c\x00Europe/RomeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8p" +
-       "\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff" +
-       "\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90" +
-       "\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff" +
-       "\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0" +
-       "\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00" +
-       "\x06n\x93p\x00\x00\x00\x00\a\vu\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xebW\xf0\x00\x00\x00\x00\n.Wp\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b\xf0" +
-       "\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00" +
-       "\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90" +
-       "\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00" +
-       "\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90" +
-       "\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x00" +
-       "0d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e" +
-       "\x10\x00\rLMT\x00RMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQh\xa5J[\xa0\x03\x00\x00\xa0\x03\x00\x00\f\x00\x1c\x00Europe/MaltaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00V\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffp\xbd\xd3d\xff\xff\xff\xff\x9b8\xf8p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff" +
-       "\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff\xa2\\7p\xff\xff\xff\xff\xa3L\x1a" +
-       "`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff" +
-       "\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5" +
-       "\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00" +
-       "\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06\x1a3p\x00\x00\x00\x00\a\n$" +
-       "p\x00\x00\x00\x00\b\x17\x16p\x00\x00\x00\x00\b\xda4p\x00\x00\x00\x00\t\xf7\x14\x90\x00\x00\x00\x00\n\xc2\r\x80\x00\x00\x00\x00\v\xd6\xf6\x90\x00\x00\x00\x00\f\xa1\xef\x80\x00\x00\x00\x00\r\xb6ؐ\x00\x00\x00" +
-       "\x00\x0e\x81р\x00\x00\x00\x00\x0f\x96\xba\x90\x00\x00\x00\x00\x10a\xb3\x80\x00\x00\x00\x00\x11v\x9c\x90\x00\x00\x00\x00\x12A\x95\x80\x00\x00\x00\x00\x13E[\x10\x00\x00\x00\x00\x14*\xb2\x00\x00\x00\x00\x00\x15#\xeb" +
-       "\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00" +
-       "\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E" +
-       "\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00" +
-       "\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9" +
-       "\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\r\x9c\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nC" +
-       "ET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\r\x00\x1c\x00Euro" +
-       "pe/ZagrebUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10" +
-       "\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00" +
-       "\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10" +
-       "\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00" +
-       "*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CE" +
-       "T\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc9\a\xa0\xe1/\x04\x00\x00/\x04\x00" +
-       "\x00\x10\x00\x1c\x00Europe/AmsterdamUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\a\x00\x00\x00!\xff\xff\xff\xff\x02\x12Ql\xff\xff\xff\xff\x9b\f.\xec\xff\xff\xff\xff\x9b\xd5\xd6\\\xff\xff\xff\xff\x9cٸ\f\xff\xff\xff\xff" +
-       "\x9d\xa4\xbf\f\xff\xff\xff\xff\x9e\xa7%\f\xff\xff\xff\xff\x9f\x97\x16\f\xff\xff\xff\xff\xa0\x90A\x8c\xff\xff\xff\xff\xa1v\xf8\f\xff\xff\xff\xff\xa2p#\x8c\xff\xff\xff\xff\xa3V\xda\f\xff\xff\xff\xff\xa4P\x05\x8c" +
-       "\xff\xff\xff\xff\xa56\xbc\f\xff\xff\xff\xff\xa6%[\x8c\xff\xff\xff\xff\xa7'\xc1\x8c\xff\xff\xff\xff\xa8^\xe3\x8c\xff\xff\xff\xff\xa9\a\xa3\x8c\xff\xff\xff\xff\xa9\xeeZ\f\xff\xff\xff\xff\xaa煌\xff\xff\xff\xff" +
-       "\xac'\xe2\f\xff\xff\xff\xff\xac\xc7g\x8c\xff\xff\xff\xff\xad\xedf\f\xff\xff\xff\xff\xae\xa7I\x8c\xff\xff\xff\xff\xafΙ\x8c\xff\xff\xff\xff\xb0\x87+\x8c\xff\xff\xff\xff\xb1\xb1\x1e\x8c\xff\xff\xff\xff\xb2pH\f" +
-       "\xff\xff\xff\xff\xb3\x92R\f\xff\xff\xff\xff\xb4P*\f\xff\xff\xff\xff\xb5s\x85\x8c\xff\xff\xff\xff\xb60\f\f\xff\xff\xff\xff\xb7T\xb9\f\xff\xff\xff\xff\xb8\x0f\xee\f\xff\xff\xff\xff\xb9@x\x8c\xff\xff\xff\xff" +
-       "\xb9\xef\xd0\f\xff\xff\xff\xff\xbb\x18q\x8c\xff\xff\xff\xff\xbb\xd8\xec\x8c\xff\xff\xff\xff\xbc\xf9\xa5\f\xff\xff\xff\xff\xbd\xb8Ό\xff\xff\xff\xff\xbe\xda،\xff\xff\xff\xff\xbf\x98\xb0\x8c\xff\xff\xff\xff\xc0\xbd]\x8c" +
-       "\xff\xff\xff\xff\xc1x\x92\x8c\xff\xff\xff\xff§ˌ\xff\xff\xff\xff\xc2\xdc]\\\xff\xff\xff\xff\xc3Xtp\xff\xff\xff\xff\xc4\u007f\xc4p\xff\xff\xff\xff\xc58Vp\xff\xff\xff\xff\xc6`\xf7\xf0\xff\xff\xff\xff" +
-       "\xc7!r\xf0\xff\xff\xff\xff\xc8D\xb2P\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10" +
-       "\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00" +
-       "\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90" +
+       "\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x11\xe4\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M" +
+       "3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\v\x00\x1c\x00Europe/RomeUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00W\x00\x00\x00\x04\x00\x00\x00\x11" +
+       "\xff\xff\xff\xff>(\xe8L\xff\xff\xff\xffp\xbc\x81p\xff\xff\xff\xff\x9b8\xf8p\xff\xff\xff\xff\x9b\xd5\xcc\xe0\xff\xff\xff\xff\x9c\xc5\xcb\xf0\xff\xff\xff\xff\x9d\xb7\x00`\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff" +
+       "\x9f\xa0\x1c\xe0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xad`\xff\xff\xff\xff\xa2\\7p\xff\xff\xff\xff\xa3L\x1a`\xff\xff\xff\xff\xc8l5\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90" +
+       "\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2L\xd2\xf0\xff\xff\xff\xff\xd3>1\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xff" +
+       "\xd5\x1d\xf7p\xff\xff\xff\xff\xd6)\x97\xf0\xff\xff\xff\xff\xd6뀐\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xf93\xb5\xf0\xff\xff\xff\xff\xf9\xd9\xc4\xe0\xff\xff\xff\xff\xfb\x1c\xd2p\xff\xff\xff\xff\xfb\xb9\xb4\xf0" +
+       "\xff\xff\xff\xff\xfc\xfc\xb4p\xff\xff\xff\xff\xfd\x99\x96\xf0\xff\xff\xff\xff\xfe\xe5\xd0\xf0\xff\xff\xff\xff\xff\x82\xb3p\x00\x00\x00\x00\x00Ų\xf0\x00\x00\x00\x00\x01b\x95p\x00\x00\x00\x00\x02\x9cZp\x00\x00\x00\x00" +
+       "\x03Bwp\x00\x00\x00\x00\x04\x85v\xf0\x00\x00\x00\x00\x05+\x93\xf0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a\vu\xf0\x00\x00\x00\x00\bE:\xf0\x00\x00\x00\x00\b\xebW\xf0\x00\x00\x00\x00\n.Wp" +
+       "\x00\x00\x00\x00\n\xcb9\xf0\x00\x00\x00\x00\f\x0e9p\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xe4\xe0\xf0\x00\x00\x00\x00\x0e\x8a\xfd\xf0\x00\x00\x00\x00\x0f\xcd\xfdp\x00\x00\x00\x00\x10t\x1ap\x00\x00\x00\x00" +
+       "\x11\xad\xdfp\x00\x00\x00\x00\x12S\xfcp\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90" +
+       "\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00" +
+       "\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10" +
+       "\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00" +
+       "-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x00\x00\v\xb4\x00\x00\x00\x00\v\xb4\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00RMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5." +
+       "0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x90\xa9\xf5ϕ\x02\x00\x00\x95\x02\x00\x00\x10\x00\x1c\x00Europe/BucharestUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x007\x00\x00\x00\x04\x00\x00\x00" +
+       "\x11\xff\xff\xff\xffl\xcf\xe0\b\xff\xff\xff\xff\xb7\xb0\xd2\b\xff\xff\xff\xff\xb9>\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff" +
+       "\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff\xff\xff\xbf\x98|\xe0\xff\xff\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1" +
+       "\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(\x13\xe0\xff\xff\xff\xff\xc7\x18\x04\xe0\x00\x00\x00\x00\x11\xad\xd1`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\v\xd0\x00\x00\x00\x00\x143\xd0`\x00\x00\x00" +
+       "\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc\xaf" +
+       "\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LF\x00\x00\x00\x00" +
+       "\x00#<7\x00\x00\x00\x00\x00$,(\x00\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)\xd4\xec" +
+       "`\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xbf`\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00" +
+       "\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xbb\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x18x\x00\x00\x00\x00\x18x\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLMT\x00BMT\x00EEST\x00EET\x00\nEE" +
+       "T-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\x11\x00\x1c\x00Eur" +
+       "ope/BratislavaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00=\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff\x1eI\x92\xf8\xff\xff\xff\xffl\xcf\xea\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff" +
+       "\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4" +
+       "\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xffӀ\x1c\x90\xff\xff\xff\xff\xd4I\xd2\x10\xff\xff\xff\xffԓ\xb4 \xff\xff\xff\xff\xd5\x02r \xff\xff\xff" +
+       "\xff\xd5L8\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x01p\x10\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18" +
+       "\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00" +
+       "\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr" +
+       "\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00" +
+       "\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84\xcb" +
+       "\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\r\x88\x00\x00\x00\x00\r\x88\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x00\x00\x01\x11LMT\x00" +
+       "PMT\x00CEST\x00CET\x00GMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R=" +
+       "=\xa4\x16\xc4\x04\x00\x00\xc4\x04\x00\x00\x10\x00\x1c\x00Europe/GibraltarUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffW\xd1\n\x04\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff" +
+       "\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{" +
+       "Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff" +
+       "\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92" +
+       "Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff" +
+       "\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98" +
+       "\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff" +
+       "\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`" +
+       "X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff" +
+       "\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0e" +
+       "p \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff" +
+       "\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14" +
+       "T\xa0\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00" +
+       "\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$," +
+       "6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00" +
+       "\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\xff\xff\xfa\xfc\x00\x00\x00\x00\x0e\x10\x01" +
+       "\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x11\x00\x00\x1c \x01\x15LMT\x00BST\x00GMT\x00BDST\x00CET\x00CEST\x00\nCET-1CES" +
+       "T,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rq\x16\x9b?\xa3\x02\x00\x00\xa3\x02\x00\x00\x0e\x00\x1c\x00Europe/Tall" +
+       "innUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\x00\x00" +
+       "\x00\b\x00\x00\x00\"\xff\xff\xff\xffV\xb6\xcc\xcc\xff\xff\xff\xff\x9eY-\xcc\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa1\x00+p\xff\xff\xff\xff\xa4soL\xff\xff\xff\xffȰ" +
+       "\xb5\xe0\xff\xff\xff\xff\xcaƗP\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0t\xcb\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00" +
+       "\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac" +
+       "\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00" +
+       "\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4" +
+       "\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00" +
+       "\x00\x002r\xa6\x00\x00\x00\x00\x003=\xad\x00\x00\x00\x00\x004R\x88\x00\x00\x00\x00\x005\x1d\x8f\x00\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x00<\xa6" +
+       "_\x90\x01\x03\x02\x03\x01\x04\x05\x02\x03\x02\x03\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x00\x00\x174\x00\x00" +
+       "\x00\x00\x174\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00\x1c \x00\x11\x00\x00*0\x00\x15\x00\x008@\x01\x19\x00\x00*0\x01\x1dLMT\x00TMT\x00CEST\x00CET\x00E" +
+       "ET\x00MSK\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "I\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x1c\x00Europe/TiraspolUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc8\xf8\xff\xff\xff\xff\x9ek\x9f\f\xff\xff\xff\xff\xb7\xb0\xd2\b\xff\xff" +
+       "\xff\xff\xb9>\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff\xff\xff\xbf\x98" +
+       "|\xe0\xff\xff\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(\x13\xe0\xff\xff" +
+       "\xff\xff\xc7\x18\x04\xe0\xff\xff\xff\xffȼ\x93`\xff\xff\xff\xff\xcaw}P\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0N" +
+       "\x90`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00" +
+       "\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L" +
+       "7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00&CL\xe0\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00" +
+       "\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t" +
+       "\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xad\x00\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\b" +
+       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x00\x00\x1b\b\x00\x00\x00\x00\x1a\xf4\x00\x04\x00\x00\x18x\x00\b\x00\x00*0\x01\f\x00\x00" +
+       "\x1c \x00\x11\x00\x00\x0e\x10\x00\x15\x00\x00\x1c \x01\x19\x00\x008@\x01\x1e\x00\x00*0\x00\"LMT\x00CMT\x00BMT\x00EEST\x00EET\x00CET\x00CEST\x00MS" +
+       "D\x00MSK\x00\nEET-2EEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00" +
+       "\x10\x00\x1c\x00Europe/LjubljanaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\xce" +
+       "\xa2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00" +
+       "\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"" +
+       "LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00" +
+       "\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000" +
+       "d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00" +
+       "\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\r\x00\x1c\x00Europe/SkopjeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xff" +
+       "ͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90" +
        "\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00" +
        "!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90" +
        "\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00" +
-       "/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x00\x00\x04" +
-       "\x94\x00\x00\x00\x00\x12\xa4\x01\x04\x00\x00\x04\x94\x00\b\x00\x00\x04\xb0\x00\f\x00\x00\x12\xc0\x01\x12\x00\x00\x0e\x10\x00\x18\x00\x00\x1c \x01\x1cLMT\x00NST\x00AMT\x00+0020\x00+01" +
-       "20\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x03R\xda\xedU\x02" +
-       "\x00\x00U\x02\x00\x00\x0e\x00\x1c\x00Europe/NicosiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x001\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff\xa5w\x1e\xb8\x00\x00\x00\x00\t\xed\xaf\xe0\x00\x00\x00\x00\nݒ\xd0\x00\x00\x00\x00\v\xfad\xe0\x00" +
-       "\x00\x00\x00\f\xbe\xc6P\x00\x00\x00\x00\r\xa49`\x00\x00\x00\x00\x0e\x8a\xe1\xd0\x00\x00\x00\x00\x0f\x84\x1b`\x00\x00\x00\x00\x10uO\xd0\x00\x00\x00\x00\x11c\xfd`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13" +
-       "M\x19\xe0\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xc1`\x00\x00\x00\x00\x16\x13\xa4P\x00\x00\x00\x00\x17\x03\xa3`\x00\x00\x00\x00\x17\xf3\x86P\x00\x00\x00\x00\x18\xe3\x85`\x00\x00\x00\x00\x19\xd3hP\x00" +
-       "\x00\x00\x00\x1a\xc3g`\x00\x00\x00\x00\x1b\xbc\x84\xd0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9cf\xd0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|H\xd0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!" +
-       "\\*\xd0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\f\xd0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1b\xee\xd0\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00'\x05\vP\x00\x00\x00\x00'\xf5\n`\x00" +
-       "\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/" +
-       "t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002M\x91\xd0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004-s\xd0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062x\x10\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x1fH\x00\x00\x00\x00*0\x01\x04" +
-       "\x00\x00\x1c \x00\tLMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\x90\xa9\xf5ϕ\x02\x00\x00\x95\x02\x00\x00\x10\x00\x1c\x00Europe/BucharestUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x007\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffl\xcf\xe0\b\xff\xff\xff\xff\xb7\xb0\xd2\b\xff\xff\xff\xff\xb9>" +
-       "\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff\xff\xff\xbf\x98|\xe0\xff\xff" +
-       "\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(\x13\xe0\xff\xff\xff\xff\xc7\x18" +
-       "\x04\xe0\x00\x00\x00\x00\x11\xad\xd1`\x00\x00\x00\x00\x12S\xe0P\x00\x00\x00\x00\x13M\v\xd0\x00\x00\x00\x00\x143\xd0`\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00" +
-       "\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c" +
-       "\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LF\x00\x00\x00\x00\x00#<7\x00\x00\x00\x00\x00$,(\x00\x00\x00\x00\x00%\x1c\x19\x00\x00\x00" +
-       "\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4\xfb`\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4" +
-       "\xbf`\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xbb\x10\x01\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x18x\x00\x00\x00" +
-       "\x00\x18x\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLMT\x00BMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5." +
-       "0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x92\xfc\f+o\x02\x00\x00o\x02\x00\x00\x11\x00\x1c\x00Europe/CopenhagenUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffi\x86" +
-       "ϴ\xff\xff\xff\xffq\f\xef4\xff\xff\xff\xff\x9b\x1e\x8c`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xc8CWp\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff" +
-       "\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2$\x10\x90\xff\xff\xff\xff\xd3y\x85\x10\xff\xff\xff\xff\xd4\x1b\xad\x90\xff\xff\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd5\xdf" +
-       "\xe0\x10\xff\xff\xff\xff\xd7Gɐ\xff\xff\xff\xff\u05ff\xc2\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00" +
-       "\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c" +
-       "\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00" +
-       "\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4" +
-       "\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\v\xcc\x00\x00\x00\x00\v\xcc\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT" +
-       "\x00CMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQI\xb8\xbc\xd3" +
-       "\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x1c\x00Europe/ChisinauUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc8\xf8\xff\xff\xff\xff\x9ek\x9f\f\xff\xff\xff\xff\xb7\xb0\xd2\b\xff\xff\xff\xff\xb9>" +
-       "\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff\xff\xff\xbf\x98|\xe0\xff\xff" +
-       "\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(\x13\xe0\xff\xff\xff\xff\xc7\x18" +
-       "\x04\xe0\xff\xff\xff\xffȼ\x93`\xff\xff\xff\xff\xcaw}P\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0N\x90`\x00\x00" +
-       "\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc" +
-       "\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00" +
-       "\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00&CL\xe0\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5" +
-       "\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00" +
-       "\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xad\x00\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\b\a\b\a\b" +
-       "\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x00\x00\x1b\b\x00\x00\x00\x00\x1a\xf4\x00\x04\x00\x00\x18x\x00\b\x00\x00*0\x01\f\x00\x00\x1c \x00\x11" +
-       "\x00\x00\x0e\x10\x00\x15\x00\x00\x1c \x01\x19\x00\x008@\x01\x1e\x00\x00*0\x00\"LMT\x00CMT\x00BMT\x00EEST\x00EET\x00CET\x00CEST\x00MSD\x00MS" +
-       "K\x00\nEET-2EEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x10\x00\x1c\x00" +
-       "Europe/MariehamnUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffS\xba&\x9b\xff\xff\xff\xff\xa4so\x1b\xff\xff\xff\xff\xcb\xceQ`\xff\xff\xff\xff\xcc\xc0\xe5`\x00\x00\x00\x00\x15#݀\x00" +
-       "\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c" +
-       "\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00" +
-       "\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*" +
-       "\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x17e\x00\x00\x00\x00\x17e\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLM" +
-       "T\x00HMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8c" +
-       "\xc8\x15\xd0P\x02\x00\x00P\x02\x00\x00\f\x00\x1c\x00Europe/SofiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00-\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xce$\xff\xff\xff\xffr\xc3\xe3\x18\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ" +
-       "\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r$ \x00\x00\x00\x00\x11c\xefP\x00\x00\x00\x00\x12U?\xe0\x00\x00\x00\x00\x13M\v\xd0\x00\x00" +
-       "\x00\x00\x145!\xe0\x00\x00\x00\x00\x15,\xed\xd0\x00\x00\x00\x00\x16\x13\xc0p\x00\x00\x00\x00\x17\f\xcf\xd0\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1a\xc3" +
-       "\x83\x80\x00\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00" +
-       "\x00\x00\"LF\x00\x00\x00\x00\x00#<7\x00\x00\x00\x00\x00$,(\x00\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5\n`\x00\x00\x00\x00(\xe4" +
-       "\xedP\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00" +
-       "\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00\x003=\xbb\x10\x01\x02\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x00\x00\x15\xdc\x00\x00\x00\x00\x1bh\x00\x04\x00\x00\x1c \x00\b\x00\x00\x0e\x10\x00\f\x00\x00\x1c \x01\x10\x00\x00*0\x01\x15LMT\x00IMT\x00E" +
-       "ET\x00CET\x00CEST\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xcb*j\x8f\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x1c\x00Europe/AthensUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
+       "/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138" +
+       "\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x0f\x00\x1c\x00Europe/HelsinkiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00#\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffS\xba&\x9b\xff\xff\xff\xff\xa4so\x1b\xff" +
+       "\xff\xff\xff\xcb\xceQ`\xff\xff\xff\xff\xcc\xc0\xe5`\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19" +
+       "Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00" +
+       "\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'" +
+       "\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00" +
+       "\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00" +
+       "\x17e\x00\x00\x00\x00\x17e\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\rLMT\x00HMT\x00EEST\x00EET\x00\nEET-2EEST,M3.5.0/3,M" +
+       "10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rz\xc3\xe8Ra\x03\x00\x00a\x03\x00\x00\x11\x00\x1c\x00Europe/SimferopolUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00K\x00\x00\x00\t\x00\x00\x00\"\xff" +
+       "\xff\xff\xffV\xb6\xc4\b\xff\xff\xff\xff\xaa\x19\xa4 \xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xff\xcb\x04\x8d\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xff\xcf" +
+       "\x924\x10\xff\xff\xff\xffϟ8\xe0\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00" +
+       "\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!" +
+       "\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\x8d.\xf0\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00" +
+       "\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00-\xc2\xc6\xd0\x00\x00\x00\x00.\x84\x85@\x00\x00\x00\x00/t\x84P\x00\x00\x00\x000dg@\x00\x00\x00\x001" +
+       "]\xa0\xd0\x00\x00\x00\x002r\xa6\x00\x00\x00\x00\x003=\xbb\x10\x00\x00\x00\x004R\x96\x10\x00\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x0062x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00" +
+       "\x00\x00\x008\xdda\x10\x00\x00\x00\x009\xfbv\x90\x00\x00\x00\x00:\xbdC\x10\x00\x00\x00\x00;\xdbX\x90\x00\x00\x00\x00<\xa6_\x90\x00\x00\x00\x00=\xbb:\x90\x00\x00\x00\x00>\x86A\x90\x00\x00\x00\x00?" +
+       "\x9b\x1c\x90\x00\x00\x00\x00@f#\x90\x00\x00\x00\x00A\x849\x10\x00\x00\x00\x00BF\x05\x90\x00\x00\x00\x00Cd\x1b\x10\x00\x00\x00\x00D%\xe7\x90\x00\x00\x00\x00EC\xfd\x10\x00\x00\x00\x00F\x05ɐ\x00" +
+       "\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M" +
+       "\x8e\x8c\x10\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S7^\x80\x00\x00\x00\x00TL\x1d`\x01" +
+       "\x02\x03\x05\x04\x05\x04\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x02\a\x02\a\x02\a\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02" +
+       "\a\x02\a\x02\a\x02\a\x02\a\x02\a\x02\b\x03\x00\x00\x1f\xf8\x00\x00\x00\x00\x1f\xe0\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c \x01\x14\x00\x008@\x01\x19\x00\x00*0" +
+       "\x01\x1d\x00\x008@\x00\fLMT\x00SMT\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R8I\xdeN%\x02\x00\x00%\x02\x00\x00\v\x00\x1c\x00Europe/KievUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
        "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x007\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xfft?\x98D\xff\xff\xff\xff\x9b\x80!\x80\xff\xff\xff\xff\xb9|\xe9\xe0\xff\xff\xff" +
-       "\xff\xb9Ư\xd0\xff\xff\xff\xff\xc9\xf2c\xe0\xff\xff\xff\xff\xca\x10\xa8P\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͪL\xf0\xff\xff\xff\xff\u03a2\x18\xe0\xff\xff\xff\xffϓip\xff\xff\xff\xff\xdf\x13\x9e" +
-       "`\xff\xff\xff\xff߷\nP\x00\x00\x00\x00\t\xec^`\x00\x00\x00\x00\v\x18\xf4`\x00\x00\x00\x00\vͮ\x00\x00\x00\x00\x00\f\xbd\x9f\x00\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\x8c]\x80\x00\x00\x00" +
-       "\x00\x0f\x847\x80\x00\x00\x00\x00\x10j\xfc\x10\x00\x00\x00\x00\x11d{\xf0\x00\x00\x00\x00\x12R\xaa\xf0\x00\x00\x00\x00\x13F\x82`\x00\x00\x00\x00\x143\xc2P\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13\xdc" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\b\x00\x00\x00\"\xff\xff\xff\xffV\xb6\xc7d\xff\xff\xff\xff\xaa\x19\xa7d\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff" +
+       "\xff\xca\xcd.\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xff\xceͨp\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdb" +
+       "P\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00" +
+       "\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n" +
+       "\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00&\x8d \xe0\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00" +
+       "\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x05\x04\x05\x04\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06" +
+       "\x03\x06\x03\x06\a\x02\a\x02\a\x02\a\x02\a\x02\a\x00\x00\x1c\x9c\x00\x00\x00\x00\x1c\x9c\x00\x04\x00\x00\x1c \x00\b\x00\x00*0\x00\f\x00\x00\x0e\x10\x00\x10\x00\x00\x1c \x01\x14\x00\x008@\x01\x19\x00\x00*" +
+       "0\x01\x1dLMT\x00KMT\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10" +
+       ".5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\r\x00\x1c\x00Europe/ZurichUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff$\xf0\xea" +
+       "\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff\xff\xca\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00" +
+       "\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f" +
+       "\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00" +
+       "\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8" +
+       "\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BMT\x00CE" +
+       "ST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00" +
+       "\x00\x0f\x00\x1c\x00Europe/BusingenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff$\xf0\xea\x80\xff\xff\xff\xffq\xd4\x06\x86\xff\xff\xff\xff\xca\x17j\x00\xff\xff\xff\xff\xca\xe2q\x00\xff\xff\xff\xff\xcb" +
+       "\xf7L\x00\xff\xff\xff\xff\xcc\xc2S\x00\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00" +
+       "\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!" +
+       "\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00" +
+       "\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/" +
+       "t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\b\x00" +
+       "\x00\x00\x00\x00\x06\xfa\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\rLMT\x00BMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5" +
+       ".0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RZ\x05wג\x02\x00\x00\x92\x02\x00\x00\r\x00\x1c\x00Europe/ViennaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
+       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffo\xa2_/\xff" +
+       "\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa2p\x1a\x10\xff\xff\xff\xff\xa3" +
+       "D[\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff" +
+       "\xff\xff\xff\xd1\u007fE\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xc3\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\x00\x00\x00\x00\x13" +
+       "M'\xf0\x00\x00\x00\x00\x143\xd0`\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00" +
+       "\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!" +
+       "\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00" +
+       "\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/" +
+       "t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\x0fQ\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1CEST,M3." +
+       "5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Ru\xb0\xcd\xfc\xf8\x02\x00\x00\xf8\x02\x00\x00\x10\x00\x1c\x00Europe/Ulyanovsk" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00B\x00\x00\x00\a\x00" +
+       "\x00\x00\x14\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00" +
+       "\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 " +
+       "lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00" +
+       "\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-" +
+       "\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00" +
+       "\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;" +
+       "\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00" +
+       "\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00I" +
+       "Ϋ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x00\x00\x00\x00V\xf7\x14p\x01\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x05\x06\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x03\x00\x00-" +
+       "`\x00\x00\x00\x00*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\f\x00\x00*0\x01\x04\x00\x00\x1c \x00\x10LMT\x00+03\x00+05\x00+04\x00+02\x00\n" +
+       "<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd9L\xf6\xf7\xf1\x01\x00\x00\xf1\x01\x00\x00\x10\x00\x1c\x00Europe/StockholmUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff" +
+       "\xffT՟\x94\xff\xff\xff\xff|Usb\xff\xff\xff\xff\x9b\x1e\x8c`\xff\xff\xff\xff\x9b\xd5\xda\xf0\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13\xdc" +
        "\x90\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00" +
        "\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6" +
        "\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00" +
-       "\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x05\x04" +
-       "\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x16<\x00\x00\x00\x00\x16<\x00\x04" +
-       "\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00\x0e\x10\x00\x11\x00\x00\x1c \x01\x15LMT\x00AMT\x00EEST\x00EET\x00CET\x00CEST\x00\nEET-2EEST" +
-       ",M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd9L\xf6\xf7\xf1\x01\x00\x00\xf1\x01\x00\x00\x10\x00\x1c\x00Europe/Sto" +
-       "ckholmUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "%\x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xffT՟\x94\xff\xff\xff\xff|Usb\xff\xff\xff\xff\x9b\x1e\x8c`\xff\xff\xff\xff\x9b\xd5\xda\xf0\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00" +
-       "\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd" +
-       "\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00" +
-       "\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16" +
-       "\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00" +
-       "\x001]\xd9\x10\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x10\xec\x00\x00\x00\x00\x0e\x1e\x00\x04\x00\x00\x0e\x10\x00\b" +
-       "\x00\x00\x1c \x01\fLMT\x00SET\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x95\u007fpp\xdc\x02\x00\x00\xdc\x02\x00\x00\r\x00\x1c\x00Europe/SamaraUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99" +
-       "\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00" +
-       "\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a" +
-       "\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\x00\xc7\x00\x00\x00\x00" +
-       "\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xdd`\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xbf`\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\xa1`\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000d\x83" +
-       "`\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r\x89\xe0\x00\x00\x00\x003=\x90\xe0\x00\x00\x00\x004Rk\xe0\x00\x00\x00\x005\x1dr\xe0\x00\x00\x00\x0062M\xe0\x00\x00\x00\x006\xfdT\xe0\x00\x00\x00" +
-       "\x008\x1bj`\x00\x00\x00\x008\xdd6\xe0\x00\x00\x00\x009\xfbL`\x00\x00\x00\x00:\xbd\x18\xe0\x00\x00\x00\x00;\xdb.`\x00\x00\x00\x00<\xa65`\x00\x00\x00\x00=\xbb\x10`\x00\x00\x00\x00>\x86\x17" +
-       "`\x00\x00\x00\x00?\x9a\xf2`\x00\x00\x00\x00@e\xf9`\x00\x00\x00\x00A\x84\x0e\xe0\x00\x00\x00\x00BE\xdb`\x00\x00\x00\x00Cc\xf0\xe0\x00\x00\x00\x00D%\xbd`\x00\x00\x00\x00EC\xd2\xe0\x00\x00\x00" +
-       "\x00F\x05\x9f`\x00\x00\x00\x00G#\xb4\xe0\x00\x00\x00\x00G\xee\xbb\xe0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΝ\xe0\x00\x00\x00\x00J\xe3x\xe0\x00\x00\x00\x00K\xae\u007f\xe0\x00\x00\x00\x00Ḷ" +
-       "p\x00\x00\x00\x00M\x8eo\xf0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x04\x01\x05\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x01\x02\x00\x00.\xf4\x00\x00\x00\x00*0\x00\x04\x00\x008@\x00\b\x00\x00FP\x01\f\x00\x008@\x01\b\x00\x00*0\x01\x04LMT\x00+03\x00+04" +
-       "\x00+05\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQo\xbc\x831O\x04\x00\x00O\x04\x00\x00\x0f\x00\x1c\x00Europe/BrusselsU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\x06\x00\x00" +
-       "\x00\x1a\xff\xff\xff\xffV\xb6\xdf\xe6\xff\xff\xff\xffm\xe8\xc8\x00\xff\xff\xff\xff\x98DI\x80\xff\xff\xff\xff\x9b\f%p\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff" +
-       "\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\x9f\xce\xf80\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1~\xbbp\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff\xff\xff\xa45" +
-       "\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8*\x01\xf0\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7_\xf0\xff\xff" +
-       "\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7A\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p" +
-       "L\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb8\xff\xe3\xa0\xff\xff" +
-       "\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\u058b \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xc8\xe2 \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\x9f\x89\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b" +
-       "\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2h\x88 \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4?/\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff" +
-       "\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xc8J\x19 \xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r" +
-       "\x16\x10\xff\xff\xff\xff\xd2N@\x90\xff\xff\xff\xffӑ@\x10\xff\xff\xff\xff\xd4K#\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00" +
-       "\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3" +
-       "\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00" +
-       "\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f" +
-       "\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00" +
-       "\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x04\x03\x04\x03\x04\x03\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
-       "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x00\x00\x04\x1a\x00\x00\x00\x00\x04\x1a\x00\x04\x00\x00\x00\x00\x00\b\x00\x00\x0e\x10\x00\f\x00\x00\x1c \x01\x10\x00\x00\x0e\x10\x01\x15LMT\x00" +
-       "BMT\x00WET\x00CET\x00CEST\x00WEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x1c\x00Europe/WarsawUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xd0P\xff\xff\xff\xff\x99\xa8*\xd0\xff\xff\xff\xff\x9b\f\x17`" +
-       "\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa0\x9a\xb6\x00\xff\xff\xff\xff\xa1e\xbd\x00\xff\xff\xff\xff" +
-       "\xa6}|`\xff\xff\xff\xff\xc8v\xde\x10\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЄ\xba\x00\xff\xff\xff\xffѕ\x92p" +
-       "\xff\xff\xff\xffҊ\xbb`\xff\xff\xff\xff\xd3b\xffp\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff" +
-       "\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff\xe8T\xd2\x00\xff\xff\xff\xff\xe8\xf1\xb4\x80\xff\xff\xff\xff\xe9᥀\xff\xff\xff\xff\xeaі\x80\xff\xff\xff\xff\xec\x14\x96\x00\xff\xff\xff\xff캳\x00" +
-       "\xff\xff\xff\xff\xed\xaa\xa4\x00\xff\xff\xff\xff\ue695\x00\xff\xff\xff\xff\xef\xd4Z\x00\xff\xff\xff\xff\xf0zw\x00\xff\xff\xff\xff\xf1\xb4<\x00\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3\x94\x1e\x00\xff\xff\xff\xff" +
-       "\xf4:;\x00\xff\xff\xff\xff\xf5}:\x80\xff\xff\xff\xff\xf6\x1a\x1d\x00\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80" +
-       "\x00\x00\x00\x00\x12T\n\x80\x00\x00\x00\x00\x13M6\x00\x00\x00\x00\x00\x143\xec\x80\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00" +
-       "\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00" +
-       "\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00" +
-       "'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ" +
-       "\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x13\xb0\x00\x00" +
-       "\x00\x00\x13\xb0\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00*0\x01\x11\x00\x00\x1c \x00\x16LMT\x00WMT\x00CEST\x00CET\x00EEST\x00EET\x00\nCET" +
-       "-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xab\x80c$q\x00\x00\x00q\x00\x00\x00\a\x00\x1c\x00Factor" +
-       "yUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00-00\x00\n<-00>0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x02\x00\x1c\x00GBUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff" +
-       "\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba" +
-       " \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff" +
-       "\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N" +
-       " \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff" +
-       "\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW" +
-       " \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff" +
-       "\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e" +
-       "\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff" +
-       "\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03" +
-       "\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff" +
-       "\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f" +
-       "\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff" +
-       "\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf" +
-       " \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff" +
-       "\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t:" +
-       " \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00" +
-       "\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2" +
-       "\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00" +
-       "\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT" +
-       "\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00" +
-       "\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97" +
-       "\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03" +
-       "\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04" +
-       "\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0" +
-       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x1c\x00GB-EireUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff" +
-       "\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c" +
-       " \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff" +
-       "\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870" +
-       " \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff" +
-       "\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe" +
-       "\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff" +
-       "\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00" +
-       "\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff" +
-       "\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95" +
-       " \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff" +
-       "\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b)" +
-       " \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff" +
-       "\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r" +
-       "\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff" +
-       "\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c" +
-       " \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00" +
-       "\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168\xc6" +
-       "\x90\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00" +
-       "\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6" +
-       "\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00" +
-       "\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10" +
-       "\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP" +
-       "\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00GMTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x00\x00\x10\xec\x00\x00\x00\x00\x0e\x1e\x00\x04\x00\x00\x0e\x10\x00\b\x00\x00\x1c \x01\fLMT\x00SE" +
+       "T\x00CET\x00CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rgp\xc0\xa7\xb6\x02\x00" +
+       "\x00\xb6\x02\x00\x00\v\x00\x1c\x00Europe/RigaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xcd^\xff\xff\xff\xff\x9e\xb9\x87\xfe\xff\xff\xff\xff\x9f\x84\x8e\xfe\xff\xff\xff\xff\xa0\x88F~\xff\xff\xff\xff\xa0" +
+       "˂\xfe\xff\xff\xff\xff\xad\xe7\xf1\xde\xff\xff\xff\xffȯd`\xff\xff\xff\xff\xcabeP\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff" +
+       "\xff\xff\xffЂ%\x10\xff\xff\xff\xffА\x89p\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19" +
+       "\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00" +
+       "\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\x19\x00\x00\x00\x00\x00&\f\n\x00\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'" +
+       "\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd5\b\x80\x00\x00\x00\x00*\xc4\xf9\x80\x00\x00\x00\x00+\xb4\xea\x80\x00\x00\x00\x00,\xa4ۀ\x00\x00\x00\x00-\x94̀\x00\x00\x00\x00.\x84\xbd\x80\x00" +
+       "\x00\x00\x00/t\xae\x80\x00\x00\x00\x000d\x9f\x80\x00\x00\x00\x001]\xcb\x00\x00\x00\x00\x002M\xbc\x00\x00\x00\x00\x003=\xbb\x10\x00\x00\x00\x004R\x96\x10\x00\x00\x00\x005\x1d\x9d\x10\x00\x00\x00\x006" +
+       "2x\x10\x00\x00\x00\x006\xfd\u007f\x10\x00\x00\x00\x008\x1b\x94\x90\x00\x00\x00\x00:\xbdC\x10\x01\x02\x01\x02\x01\x03\x04\x06\x05\x06\x05\x06\x05\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\a\x04\b\x03\b" +
+       "\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x00\x00\x16\xa2\x00\x00\x00\x00\x16\xa2\x00\x04\x00\x00$\xb2\x01\b\x00\x00\x1c \x00\f\x00\x00*0\x00\x10\x00\x00\x0e\x10\x00\x14\x00\x00\x1c " +
+       "\x01\x18\x00\x008@\x01\x1d\x00\x00*0\x01!LMT\x00RMT\x00LST\x00EET\x00MSK\x00CET\x00CEST\x00MSD\x00EEST\x00\nEET-2EE" +
+       "ST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x12\x00\x1c\x00Europe/I" +
+       "sle_of_ManUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d" +
+       "\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff" +
+       "\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l" +
+       " \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff" +
+       "\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00" +
+       " \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff" +
+       "\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&" +
+       "\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff" +
+       "\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0" +
+       "\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff" +
+       "\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*" +
+       "\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff" +
+       "\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI" +
+       "\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff" +
+       "\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X" +
+       " \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00" +
+       "\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10" +
+       "\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00" +
+       "\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr" +
+       "\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00" +
+       "\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5" +
+       "\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST," +
+       "M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x1c\x00Europe/Chisin" +
+       "auUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00" +
+       "\t\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc8\xf8\xff\xff\xff\xff\x9ek\x9f\f\xff\xff\xff\xff\xb7\xb0\xd2\b\xff\xff\xff\xff\xb9>\xf3`\xff\xff\xff\xff\xb9\xef\x9c`\xff\xff\xff\xff\xbaߍ`\xff\xff\xff\xff\xbb\xcf~" +
+       "`\xff\xff\xff\xff\xbcȩ\xe0\xff\xff\xff\xff\xbd\xb8\x9a\xe0\xff\xff\xff\xff\xbe\xa8\x8b\xe0\xff\xff\xff\xff\xbf\x98|\xe0\xff\xff\xff\xff\xc0\x88m\xe0\xff\xff\xff\xff\xc1x^\xe0\xff\xff\xff\xff\xc2hO\xe0\xff\xff\xff" +
+       "\xff\xc3X@\xe0\xff\xff\xff\xff\xc4H1\xe0\xff\xff\xff\xff\xc58\"\xe0\xff\xff\xff\xff\xc6(\x13\xe0\xff\xff\xff\xff\xc7\x18\x04\xe0\xff\xff\xff\xffȼ\x93`\xff\xff\xff\xff\xcaw}P\xff\xff\xff\xff\xcc\xe7K" +
+       "\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xff\xd0N\x90`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00" +
+       "\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs" +
+       "\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00" +
+       "\x00&\v\xfb\xf0\x00\x00\x00\x00&CL\xe0\x00\x00\x00\x00'\x055\x80\x00\x00\x00\x00'\xf5&\x80\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce" +
+       "`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\x92`\x00\x00\x00\x000duP\x00\x00\x00\x001]\xae\xe0\x00\x00\x00\x002r{\xd0\x00\x00\x00" +
+       "\x003=\xad\x00\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x06\x05\x06\x05\x06\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\b\a\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+       "\x03\x04\x03\x04\x03\x00\x00\x1b\b\x00\x00\x00\x00\x1a\xf4\x00\x04\x00\x00\x18x\x00\b\x00\x00*0\x01\f\x00\x00\x1c \x00\x11\x00\x00\x0e\x10\x00\x15\x00\x00\x1c \x01\x19\x00\x008@\x01\x1e\x00\x00*0\x00\"L" +
+       "MT\x00CMT\x00BMT\x00EEST\x00EET\x00CET\x00CEST\x00MSD\x00MSK\x00\nEET-2EEST,M3.5.0,M10.5" +
+       ".0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf2\xfa\xcb\x130\x02\x00\x000\x02\x00\x00\x11\x00\x1c\x00Europe/ZaporozhyeUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\b\x00\x00\x00$\xff\xff\xff\xffV" +
+       "\xb6\xc3\b\xff\xff\xff\xff\xaa\x19\xa30\xff\xff\xff\xff\xb5\xa4\x19`\xff\xff\xff\xffʪ\xe7\xd0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffν\xd6p\x00" +
+       "\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b" +
+       "\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00" +
+       "\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe4\xedP\x00\x00\x00\x00)" +
+       "\xd4\xec`\x00\x00\x00\x00*\xc4\xcfP\x00\x00\x00\x00+\xb4\xce`\x00\x00\x00\x00,\xa4\xb1P\x00\x00\x00\x00-\x94\xb0`\x00\x00\x00\x00.\x84\x93P\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00" +
+       "\x00\x00\x001]\xd9\x10\x01\x02\x03\x05\x04\x05\x04\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\a\x02\a\x02\a\x02\a\x02\a\x02\a\x00\x00 \xf8\x00\x00\x00\x00 \xd0\x00\x04\x00\x00" +
+       "\x1c \x00\n\x00\x00*0\x00\x0e\x00\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\x16\x00\x008@\x01\x1b\x00\x00*0\x01\x1fLMT\x00+0220\x00EET\x00MSK\x00CET\x00CEST" +
+       "\x00MSD\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe0\xfe\x83\xe5\xcd\x02" +
+       "\x00\x00\xcd\x02\x00\x00\f\x00\x1c\x00Europe/KirovUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00?\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xb5\xa4\vP\x00\x00\x00\x00\x15'\x99\xc0\x00\x00\x00\x00\x16\x18\xce0\x00\x00\x00" +
+       "\x00\x17\b\xcd@\x00\x00\x00\x00\x17\xfa\x01\xb0\x00\x00\x00\x00\x18\xea\x00\xc0\x00\x00\x00\x00\x19\xdb50\x00\x00\x00\x00\x1a̅\xc0\x00\x00\x00\x00\x1b\xbc\x92\xe0\x00\x00\x00\x00\x1c\xac\x83\xe0\x00\x00\x00\x00\x1d\x9ct" +
+       "\xe0\x00\x00\x00\x00\x1e\x8ce\xe0\x00\x00\x00\x00\x1f|V\xe0\x00\x00\x00\x00 lG\xe0\x00\x00\x00\x00!\\8\xe0\x00\x00\x00\x00\"L)\xe0\x00\x00\x00\x00#<\x1a\xe0\x00\x00\x00\x00$,\v\xe0\x00\x00\x00" +
+       "\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcd" +
+       "p\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00" +
+       "\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&" +
+       "\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00" +
+       "\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4" +
+       "\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x04\x01\x04\x01\x03\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x03\x01\x00\x00.\x98\x00\x00\x00\x00" +
+       "*0\x00\x04\x00\x00FP\x01\b\x00\x008@\x00\f\x00\x008@\x01\fLMT\x00+03\x00+05\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x1c\x00Europe/WarsawUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xd0P\xff\xff\xff\xff\x99\xa8*\xd0\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff" +
+       "\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa0\x9a\xb6\x00\xff\xff\xff\xff\xa1e\xbd\x00\xff\xff\xff\xff\xa6}|" +
+       "`\xff\xff\xff\xff\xc8v\xde\x10\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЄ\xba\x00\xff\xff\xff\xffѕ\x92p\xff\xff\xff" +
+       "\xffҊ\xbb`\xff\xff\xff\xff\xd3b\xffp\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1" +
+       "\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff\xe8T\xd2\x00\xff\xff\xff\xff\xe8\xf1\xb4\x80\xff\xff\xff\xff\xe9᥀\xff\xff\xff\xff\xeaі\x80\xff\xff\xff\xff\xec\x14\x96\x00\xff\xff\xff\xff캳\x00\xff\xff\xff" +
+       "\xff\xed\xaa\xa4\x00\xff\xff\xff\xff\ue695\x00\xff\xff\xff\xff\xef\xd4Z\x00\xff\xff\xff\xff\xf0zw\x00\xff\xff\xff\xff\xf1\xb4<\x00\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3\x94\x1e\x00\xff\xff\xff\xff\xf4:;" +
+       "\x00\xff\xff\xff\xff\xf5}:\x80\xff\xff\xff\xff\xf6\x1a\x1d\x00\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00" +
+       "\x00\x12T\n\x80\x00\x00\x00\x00\x13M6\x00\x00\x00\x00\x00\x143\xec\x80\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18\xe3\xa1" +
+       "\x80\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00" +
+       "\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C" +
+       "\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00" +
+       "\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x13\xb0\x00\x00\x00\x00\x13" +
+       "\xb0\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00*0\x01\x11\x00\x00\x1c \x00\x16LMT\x00WMT\x00CEST\x00CET\x00EEST\x00EET\x00\nCET-1C" +
+       "EST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x1c\x00Europe/Lo" +
+       "ndonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00" +
+       "\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f" +
+       "\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff" +
+       "\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad" +
+       "\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff" +
+       "\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb" +
+       "\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff" +
+       "\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xff\xca" +
+       "\x97Y\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff" +
+       "\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6" +
+       "N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff" +
+       "\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4" +
+       "T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff" +
+       "\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2" +
+       "\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff" +
+       "\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05" +
+       "P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00" +
+       "\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x13" +
+       "1\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00" +
+       "\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!" +
+       "\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00" +
+       "\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/" +
+       "t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff" +
+       "\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0" +
+       "/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rn\x81\xf4\xd7Z\x04\x00\x00Z\x04\x00\x00\r\x00\x1c\x00Europe/MonacoUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\a\x00\x00\x00\x1f\xff\xff\xff" +
+       "\xffn\x11\x9f\x94\xff\xff\xff\xff\x91x\vO\xff\xff\xff\xff\x9bGx\xf0\xff\xff\xff\xff\x9b\xd7,p\xff\xff\xff\xff\x9c\xbc\x91p\xff\xff\xff\xff\x9d\xc0H\xf0\xff\xff\xff\xff\x9e\x89\xfep\xff\xff\xff\xff\x9f\xa0*" +
+       "\xf0\xff\xff\xff\xff\xa0`\xa5\xf0\xff\xff\xff\xff\xa1\x80\f\xf0\xff\xff\xff\xff\xa2.\x12\xf0\xff\xff\xff\xff\xa3zL\xf0\xff\xff\xff\xff\xa45\x81\xf0\xff\xff\xff\xff\xa5^#p\xff\xff\xff\xff\xa6%5\xf0\xff\xff\xff" +
+       "\xff\xa7'\x9b\xf0\xff\xff\xff\xff\xa8X&p\xff\xff\xff\xff\xa9\a}\xf0\xff\xff\xff\xff\xa9\xee4p\xff\xff\xff\xff\xaa\xe7_\xf0\xff\xff\xff\xff\xab\xd7P\xf0\xff\xff\xff\xff\xac\xc7A\xf0\xff\xff\xff\xff\xadɧ" +
+       "\xf0\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff" +
+       "\xff\xb5I/\xf0\xff\xff\xff\xff\xb6/\xe6p\xff\xff\xff\xff\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xba\xd6`\xf0\xff\xff\xff\xff\xbb\xd8\xc6" +
+       "\xf0\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff" +
+       "\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X\xacp\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x17[\xf0\xff\xff\xff\xff\xca\xe2T" +
+       "\xe0\xff\xff\xff\xff˭i\xf0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЉ\xf1\xf0\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff" +
+       "\xff\xd2N@\x90\x00\x00\x00\x00\v\xbb9\x00\x00\x00\x00\x00\f\xab\x1b\xf0\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'" +
+       "\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00" +
+       "\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81" +
+       "\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00" +
+       "\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94\xda" +
+       "\x90\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x00\x00\x06\xec\x00\x00\x00\x00\x021\x00\x04\x00\x00\x0e\x10\x01\b\x00\x00\x00\x00\x00\r\x00\x00\x1c \x01\x11\x00\x00\x1c \x01\x16\x00\x00\x0e\x10\x00\x1bLMT" +
+       "\x00PMT\x00WEST\x00WET\x00WEMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\v\x00\x1c\x00Europe/OsloUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffr\xee$l\xff\xff\xff\xff\x9b'\xe3\x00\xff\xff\xff\xff" +
+       "\x9b\xd4{`\xff\xff\xff\xffȷM`\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10" +
+       "\xff\xff\xff\xff\xd2b\a\x10\xff\xff\xff\xff\xeb\xaf \x90\xff\xff\xff\xff\xec\xa8L\x10\xff\xff\xff\xff\xed\x98=\x10\xff\xff\xff\xff\xee\x88.\x10\xff\xff\xff\xff\xefx\x1f\x10\xff\xff\xff\xff\xf0h\x10\x10\xff\xff\xff\xff" +
+       "\xf1X\x01\x10\xff\xff\xff\xff\xf2G\xf2\x10\xff\xff\xff\xff\xf37\xe3\x10\xff\xff\xff\xff\xf4'\xd4\x10\xff\xff\xff\xff\xf5\x17\xc5\x10\xff\xff\xff\xff\xf6\x10\xf0\x90\xff\xff\xff\xff\xf7/\x06\x10\xff\xff\xff\xff\xf7\xf0Ґ" +
+       "\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00" +
+       "\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10" +
+       "\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00" +
+       "'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː" +
+       "\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\n\x14\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\tLMT\x00CEST\x00CET\x00\nCET-1C" +
+       "EST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x1c\x00Europe/Po" +
+       "dgoricaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00$\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xff^<\xf0H\xff\xff\xff\xff\xca\x025\xe0\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff" +
+       "\xff\xffЂ%\x10\xff\xff\xff\xffѡ\x8c\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac" +
+       "\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00" +
+       "\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5" +
+       "\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x138\x00\x00\x00\x00\x0e\x10\x00\x04\x00\x00\x1c \x01\bLMT\x00CET\x00" +
+       "CEST\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x0f" +
+       "\x00\x1c\x00Europe/IstanbulUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o" +
-       "\x00\x00\x00\x05\x00\x1c\x00GMT+0UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x1c" +
-       "\x00GMT-0UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x04\x00\x1c\x00GMT0U" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
-       "\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00GreenwichUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04" +
-       "\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ=\xf7\xfawp\x00\x00\x00p\x00\x00\x00\x03\x00\x1c\x00HSTUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffs`\x00\x00HS" +
-       "T\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\b\x00\x1c\x00HongkongUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff\x85ic\x90\xff\xff" +
-       "\xff\xff\xcaM10\xff\xff\xff\xff\xcaۓ0\xff\xff\xff\xff\xcbKqx\xff\xff\xff\xffҠސ\xff\xff\xff\xff\xd3k׀\xff\xff\xff\xffԓX\xb8\xff\xff\xff\xff\xd5B\xb08\xff\xff\xff\xff\xd6s" +
-       ":\xb8\xff\xff\xff\xff\xd7>A\xb8\xff\xff\xff\xff\xd8.2\xb8\xff\xff\xff\xff\xd8\xf99\xb8\xff\xff\xff\xff\xda\x0e\x14\xb8\xff\xff\xff\xff\xda\xd9\x1b\xb8\xff\xff\xff\xff\xdb\xed\xf6\xb8\xff\xff\xff\xffܸ\xfd\xb8\xff\xff" +
-       "\xff\xff\xdd\xcdظ\xff\xff\xff\xffޢ\x1a8\xff\xff\xff\xff߶\xf58\xff\xff\xff\xff\xe0\x81\xfc8\xff\xff\xff\xff\xe1\x96\xc9(\xff\xff\xff\xff\xe2Oi8\xff\xff\xff\xff\xe3v\xab(\xff\xff\xff\xff\xe4/" +
-       "K8\xff\xff\xff\xff\xe5_Ǩ\xff\xff\xff\xff\xe6\x0f-8\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7\xf8I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea\xffm\xa8\xff\xff" +
-       "\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff\xff\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff\xff\xff\xff\xf2\x88" +
-       "0(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6G\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15a(\xff\xff\xff\xff\xf9\x05`8\xff\xff" +
-       "\xff\xff\xf9\xf5C(\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff\xff\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00\x00\x00\x00\x00\x8e" +
-       "\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04M\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a&\xe6(\x00\x00" +
-       "\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00\x00\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00\x00\x00\x00\x12o" +
-       "l\xa8\x01\x02\x03\x04\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00k\n\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x01\b\x00\x00w\x88\x01\r\x00\x00~\x90\x00\x12LMT\x00HKT\x00HKST\x00HKWT\x00J" +
-       "ST\x00\nHKT-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00\x1c\x00IcelandUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00D\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x8b`\x83\xa0\xff\xff" +
-       "\xff\xff\x9c\x91\x1e\x00\xff\xff\xff\xff\x9dш\x90\xff\xff\xff\xff\x9erQ\x80\xff\xff\xff\xff\x9f\xd5\x03\x10\xff\xff\xff\xff\xa0S\x85\x00\xff\xff\xff\xff\xa1\xb66\x90\xff\xff\xff\xff\xa4<'\x80\xff\xff\xff\xff\xa4\xb9" +
-       "t\x10\xff\xff\xff\xff\xc6M\x1a\x00\xff\xff\xff\xff\xc7=' \xff\xff\xff\xff\xc7\xda\x17\xb0\xff\xff\xff\xff\xc9&C\xa0\xff\xff\xff\xff\xc9\xc3& \xff\xff\xff\xff\xcb\x06%\xa0\xff\xff\xff\xffˬB\xa0\xff\xff" +
-       "\xff\xff\xcc\xdc\xcd \xff\xff\xff\xff͌$\xa0\xff\xff\xff\xffμ\xaf \xff\xff\xff\xff\xcfl\x06\xa0\xff\xff\xff\xffМ\x91 \xff\xff\xff\xff\xd1K\xe8\xa0\xff\xff\xff\xff҅\xad\xa0\xff\xff\xff\xff\xd3+" +
-       "ʠ\xff\xff\xff\xff\xd4e\x8f\xa0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6Eq\xa0\xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8%S\xa0\xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff" +
-       "\xff\xff\xda\xd9w \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xce4 \xff\xff\xff\xffޢu\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1\x8d" +
-       "\xf8 \xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3m\xda \xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe5M\xbc \xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe76ؠ\xff\xff\xff\xff\xe8\v\x1a \xff\xff" +
-       "\xff\xff\xe9\x16\xba\xa0\xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xf6\x9c\xa0\xff\xff\xff\xff\xeb\xca\xde \xff\xff\xff\xff\xec\xd6~\xa0\xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\xee\xb6`\xa0\xff\xff\xff\xff\xef\x8a" +
-       "\xa2 \xff\xff\xff\xff\xf0\x96B\xa0\xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6?# \xff\xff" +
-       "\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xf3F\xa0\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xd3(\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc\xbcE \x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x03\xff\xff\xeb`\x00\x00\x00\x00\x00\x00\x01\x04\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\fLMT\x00+00\x00-01\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Indian/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x1c\x00Indian/MauritiusUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x89\u007f\x05\x98\x00\x00\x00\x00\x18\x05\xed@\x00\x00" +
-       "\x00\x00\x18\xdbr0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΏ\xd0\x02\x01\x02\x01\x02\x00\x005\xe8\x00\x00\x00\x00FP\x01\x04\x00\x008@\x00\bLMT\x00+05\x00+04\x00\n<+" +
-       "04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00\x1c\x00Indian/ChagosUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x89~\xf7\x9c" +
-       "\x00\x00\x00\x000\xe6ݰ\x01\x02\x00\x00C\xe4\x00\x00\x00\x00FP\x00\x04\x00\x00T`\x00\bLMT\x00+05\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0e\x00\x1c\x00Indian/MayotteUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8" +
-       "\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT" +
-       "-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ$l=҅\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Indian/ChristmasUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xffs\x16\xa9\xe4" +
-       "\x01\x00\x00c\x1c\x00\x00\x00\x00bp\x00\x04LMT\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x1c\x00" +
-       "Indian/CocosUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\n\xff\xff\xff\xff|U&\xa4\x01\x00\x00Z\xdc\x00\x00\x00\x00[h\x00\x04LMT\x00+0630\x00\n<+0630>-6:30\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb9\xb2Z\xac\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Indian/MaldivesUT\t\x00\x03\xec,\x94_\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
-       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffV\xb6\x9f\x18\xff\xff\xff\xff" +
-       "\xed/Ø\x01\x02\x00\x00D\xe8\x00\x00\x00\x00D\xe8\x00\x04\x00\x00FP\x00\bLMT\x00MMT\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xeb" +
-       "E1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x1c\x00Indian/ComoroUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x19\xff\xff\xff\xffV\xb6\xc8\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec" +
+       "\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff" +
+       "\xff\xab\xf9\x89\xe0\xff\xff\xff\xff\xac\xc31P\xff\xff\xff\xffȁ?\xe0\xff\xff\xff\xff\xc9\x01\x13P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\t" +
+       "P\xff\xff\xff\xffӢ9`\xff\xff\xff\xff\xd4C\x02P\xff\xff\xff\xff\xd5L\r\xe0\xff\xff\xff\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff" +
+       "\xff\xd9\xe9?\xd0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff\xdb\xd2\\P\xff\xff\xff\xff\xdc\xd4\xd0`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06" +
+       "`\xff\xff\xff\xff\xf6\x1f8\xd0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a9\x9ap\x00\x00\x00\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00" +
+       "\x00\v\xb1\xfe\x80\x00\x00\x00\x00\f\xd9@p\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\xa6\xadp\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ" +
+       "\xe0\x00\x00\x00\x00\x1b\xe6\xd0\xf0\x00\x00\x00\x00\x1c\xc6\xef\xf0\x00\x00\x00\x00\x1d\x9b1p\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00" +
+       "\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\t" +
+       "p\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00" +
+       "\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb" +
+       "\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00" +
+       "\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0" +
+       "\xf0\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00" +
+       "\x00L̿\x90\x00\x00\x00\x00M\x8fݐ\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe" +
+       "\x10\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V>\x9e\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r" +
+       "\x00\x00*0\x00\x11\x00\x008@\x01\x15LMT\x00IMT\x00EEST\x00EET\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\xab\x80c$q\x00\x00\x00q\x00\x00\x00\a\x00\x1c\x00FactoryUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00-00\x00\n<-00>0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4" +
+       ",\xb6?\x06\x00\x00?\x06\x00\x00\x02\x00\x1c\x00GBUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff" +
+       "\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5" +
+       "?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff" +
+       "\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3" +
+       "r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff" +
+       "\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1" +
+       "x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff" +
+       "\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0" +
+       "n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff" +
+       "\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb" +
+       "\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff" +
+       "\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9" +
+       "\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff" +
+       "\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8" +
+       "\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00" +
+       "\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n" +
+       "\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00" +
+       "\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18" +
+       "㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00" +
+       "\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'" +
+       "*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00" +
+       "\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGM" +
+       "T0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x1c\x00GB-Eire" +
+       "UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x05\x00" +
+       "\x00\x00\x11\xff\xff\xff\xff\x1a]\t\xcb\xff\xff\xff\xff\x9b&\xad\xa0\xff\xff\xff\xff\x9b\xd6\x05 \xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4à\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff" +
+       "\xff\xff\xff\xa0\x85\xba \xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c \xff\xff\xff\xff\xa3{Ƞ\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb \xff\xff\xff\xff\xa6%` \xff\xff\xff\xff\xa7" +
+       "'\xc6 \xff\xff\xff\xff\xa8*, \xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00Ӡ\xff\xff\xff\xff\xaa\xd5\x15 \xff\xff\xff\xff\xab\xe9\xf0 \xff\xff\xff\xff\xac\xc7l \xff\xff\xff\xff\xad\xc9\xd2 \xff" +
+       "\xff\xff\xff\xae\xa7N \xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870 \xff\xff\xff\xff\xb1\x92Р\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5" +
+       "IZ \xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xefԠ\xff\xff\xff\xff\xba\xe9\x00 \xff\xff\xff\xff\xbb\xd8\xf1 \xff" +
+       "\xff\xff\xff\xbc\xdbW \xff\xff\xff\xff\xbd\xb8\xd3 \xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5 \xff\xff\xff\xff\xc0\x9b\x1b \xff\xff\xff\xff\xc1x\x97 \xff\xff\xff\xff\xc2z\xfd \xff\xff\xff\xff\xc3" +
+       "Xy \xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[ \xff\xff\xff\xff\xc6:\xc1 \xff\xff\xff\xff\xc7X֠\xff\xff\xff\xff\xc7\xda\t\xa0\xff\xff\xff\xff\xca\x16&\x90\xff\xff\xff\xffʗY\x90\xff" +
+       "\xff\xff\xff\xcb\xd1\x1e\x90\xff\xff\xff\xff\xccw;\x90\xff\xff\xff\xffͱ\x00\x90\xff\xff\xff\xff\xce`X\x10\xff\xff\xff\xffϐ\xe2\x90\xff\xff\xff\xff\xd0n^\x90\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd1" +
+       "\xfb2\x10\xff\xff\xff\xff\xd2i\xfe \xff\xff\xff\xff\xd3c)\xa0\xff\xff\xff\xff\xd4I\xe0 \xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd5B\xfd\x90\xff\xff\xff\xff\xd5\xdf\xe0\x10\xff\xff\xff\xff\xd6N\xac \xff" +
+       "\xff\xff\xff\xd6\xfe\x03\xa0\xff\xff\xff\xff\xd8.\x8e \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xeb\xec \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce \xff\xff\xff\xff\xdd" +
+       "\xc4\xf9\xa0\xff\xff\xff\xff\u07b4\xea\xa0\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x94̠\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt \xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff" +
+       "\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6=\xad \xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xfdq \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb" +
+       "\xddS \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f} \xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\u007f_ \xff" +
+       "\xff\xff\xff\xf3Jf \xff\xff\xff\xff\xf4_A \xff\xff\xff\xff\xf5!\r\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xe0Ѡ\xff\xff\xff\xff\xf9" +
+       "\xfe\xe7 \xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfdǻp\x00\x00\x00\x00\x03p\xc6 \x00\x00\x00\x00\x04)X \x00\x00\x00\x00\x05P\xa8 \x00" +
+       "\x00\x00\x00\x06\t: \x00\x00\x00\x00\a0\x8a \x00\x00\x00\x00\a\xe9\x1c \x00\x00\x00\x00\t\x10l \x00\x00\x00\x00\t\xc8\xfe \x00\x00\x00\x00\n\xf0N \x00\x00\x00\x00\v\xb2\x1a\xa0\x00\x00\x00\x00\f" +
+       "\xd00 \x00\x00\x00\x00\r\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12 \x00\x00\x00\x00\x0fqޠ\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00" +
+       "\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168Ɛ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1a" +
+       "Ñ\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\x81M\x10\x00" +
+       "\x00\x00\x00\"LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)" +
+       "\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9Ӑ\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00" +
+       "\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xff\xb5\x00\x00" +
+       "\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\b\x00\x00\x1c \x01\f\x00\x00\x0e\x10\x00\x04LMT\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M" +
+       "10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00GMTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00T" +
+       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x1c\x00GMT+0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x1c\x00GMT-0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif" +
        "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed" +
-       "/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK" +
-       "\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQy(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x1c\x00Indian/ReunionUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x91\xcc9\x80\x01\x00\x004\x00\x00\x00" +
-       "\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xbd\xf3\x17\xf1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Indian/" +
-       "MaheUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x88d\xe6\x84\x01\x00\x003\xfc\x00\x00\x00\x008@\x00\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xb8" +
-       "K\xabυ\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Indian/KerguelenUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xdaab\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00FP\x00\x04-00\x00+" +
-       "05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x13\x00\x1c\x00Indian/Antananariv" +
-       "oUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04" +
-       "\x00\x00\x00\x14\xff\xff\xff\xff\xb1\xee\xda\xfc\xff\xff\xff\xff\xb4\u009a\xd0\xff\xff\xff\xffǑG\xd8\xff\xff\xff\xff\xed/\xe1\xd4\x01\x02\x03\x01\x00\x00\"\x84\x00\x00\x00\x00*0\x00\x04\x00\x00#(\x00\b\x00\x00" +
-       "&\xac\x00\x0eLMT\x00EAT\x00+0230\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x1c" +
-       "\x00IranUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9" +
-       "\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff\xff\x9al}\xc8\xff\xff\xff\xff\xd2\xdb\x12\xc8\x00\x00\x00\x00\x0e\xbb\xa2H\x00\x00\x00\x00\x0ft-@\x00\x00\x00\x00\x10\x8e@0\x00\x00\x00\x00\x10\xed:@\x00\x00\x00\x00" +
-       "\x11Ug\xc8\x00\x00\x00\x00\x12EJ\xb8\x00\x00\x00\x00\x137\xec\xc8\x00\x00\x00\x00\x14-\x15\xb8\x00\x00\x00\x00( v\xc8\x00\x00\x00\x00(\u06dd\xb8\x00\x00\x00\x00)˜\xc8\x00\x00\x00\x00*\xbe\"\xb8" +
-       "\x00\x00\x00\x00+\xac\xd0H\x00\x00\x00\x00,\x9fV8\x00\x00\x00\x00-\x8e\x03\xc8\x00\x00\x00\x00.\x80\x89\xb8\x00\x00\x00\x00/o7H\x00\x00\x00\x000a\xbd8\x00\x00\x00\x001Pj\xc8\x00\x00\x00\x00" +
-       "2B\xf0\xb8\x00\x00\x00\x0032\xef\xc8\x00\x00\x00\x004%u\xb8\x00\x00\x00\x005\x14#H\x00\x00\x00\x006\x06\xa98\x00\x00\x00\x006\xf5V\xc8\x00\x00\x00\x007\xe7ܸ\x00\x00\x00\x008֊H" +
-       "\x00\x00\x00\x009\xc9\x108\x00\x00\x00\x00:\xb9\x0fH\x00\x00\x00\x00;\xab\x958\x00\x00\x00\x00<\x9aB\xc8\x00\x00\x00\x00=\x8cȸ\x00\x00\x00\x00>{vH\x00\x00\x00\x00?m\xfc8\x00\x00\x00\x00" +
-       "@\\\xa9\xc8\x00\x00\x00\x00AO/\xb8\x00\x00\x00\x00B?.\xc8\x00\x00\x00\x00C1\xb4\xb8\x00\x00\x00\x00G\xe2\xc9H\x00\x00\x00\x00H\xd5O8\x00\x00\x00\x00I\xc5NH\x00\x00\x00\x00J\xb7\xd48" +
-       "\x00\x00\x00\x00K\xa6\x81\xc8\x00\x00\x00\x00L\x99\a\xb8\x00\x00\x00\x00M\x87\xb5H\x00\x00\x00\x00Nz;8\x00\x00\x00\x00Oh\xe8\xc8\x00\x00\x00\x00P[n\xb8\x00\x00\x00\x00QKm\xc8\x00\x00\x00\x00" +
-       "R=\xf3\xb8\x00\x00\x00\x00S,\xa1H\x00\x00\x00\x00T\x1f'8\x00\x00\x00\x00U\r\xd4\xc8\x00\x00\x00\x00V\x00Z\xb8\x00\x00\x00\x00V\xef\bH\x00\x00\x00\x00W\xe1\x8e8\x00\x00\x00\x00XэH" +
-       "\x00\x00\x00\x00Y\xc4\x138\x00\x00\x00\x00Z\xb2\xc0\xc8\x00\x00\x00\x00[\xa5F\xb8\x00\x00\x00\x00\\\x93\xf4H\x00\x00\x00\x00]\x86z8\x00\x00\x00\x00^u'\xc8\x00\x00\x00\x00_g\xad\xb8\x00\x00\x00\x00" +
-       "`W\xac\xc8\x00\x00\x00\x00aJ2\xb8\x00\x00\x00\x00b8\xe0H\x00\x00\x00\x00c+f8\x00\x00\x00\x00d\x1a\x13\xc8\x00\x00\x00\x00e\f\x99\xb8\x00\x00\x00\x00e\xfbGH\x00\x00\x00\x00f\xed\xcd8" +
-       "\x00\x00\x00\x00g\xdd\xccH\x00\x00\x00\x00h\xd0R8\x00\x00\x00\x00i\xbe\xff\xc8\x00\x00\x00\x00j\xb1\x85\xb8\x00\x00\x00\x00k\xa03H\x00\x00\x00\x00l\x92\xb98\x00\x00\x00\x00m\x81f\xc8\x00\x00\x00\x00" +
-       "ns\xec\xb8\x00\x00\x00\x00ob\x9aH\x00\x00\x00\x00pU 8\x00\x00\x00\x00qE\x1fH\x00\x00\x00\x00r7\xa58\x00\x00\x00\x00s&R\xc8\x00\x00\x00\x00t\x18ظ\x00\x00\x00\x00u\a\x86H" +
-       "\x00\x00\x00\x00u\xfa\f8\x00\x00\x00\x00v\xe8\xb9\xc8\x00\x00\x00\x00w\xdb?\xb8\x00\x00\x00\x00x\xcb>\xc8\x00\x00\x00\x00y\xbdĸ\x00\x00\x00\x00z\xacrH\x00\x00\x00\x00{\x9e\xf88\x00\x00\x00\x00" +
-       "|\x8d\xa5\xc8\x00\x00\x00\x00}\x80+\xb8\x00\x00\x00\x00~n\xd9H\x00\x00\x00\x00\u007fa_8\x00\x00\x00\x00\x80Q^H\x00\x00\x00\x00\x81C\xe48\x00\x00\x00\x00\x822\x91\xc8\x00\x00\x00\x00\x83%\x17\xb8" +
-       "\x00\x00\x00\x00\x84\x13\xc5H\x00\x00\x00\x00\x85\x06K8\x00\x00\x00\x00\x85\xf4\xf8\xc8\x00\x00\x00\x00\x86\xe7~\xb8\x00\x00\x00\x00\x87\xd7}\xc8\x00\x00\x00\x00\x88\xca\x03\xb8\x00\x00\x00\x00\x89\xb8\xb1H\x00\x00\x00\x00" +
-       "\x8a\xab78\x00\x00\x00\x00\x8b\x99\xe4\xc8\x00\x00\x00\x00\x8c\x8cj\xb8\x00\x00\x00\x00\x8d{\x18H\x00\x00\x00\x00\x8em\x9e8\x00\x00\x00\x00\x8f]\x9dH\x00\x00\x00\x00\x90P#8\x00\x00\x00\x00\x91>\xd0\xc8" +
-       "\x00\x00\x00\x00\x921V\xb8\x00\x00\x00\x00\x93 \x04H\x00\x00\x00\x00\x94\x12\x8a8\x00\x00\x00\x00\x95\x017\xc8\x00\x00\x00\x00\x95\xf3\xbd\xb8\x00\x00\x00\x00\x96\xe3\xbc\xc8\x00\x00\x00\x00\x97\xd6B\xb8\x00\x00\x00\x00" +
-       "\x98\xc4\xf0H\x00\x00\x00\x00\x99\xb7v8\x00\x00\x00\x00\x9a\xa6#\xc8\x00\x00\x00\x00\x9b\x98\xa9\xb8\x00\x00\x00\x00\x9c\x87WH\x00\x00\x00\x00\x9dy\xdd8\x00\x00\x00\x00\x9ei\xdcH\x00\x00\x00\x00\x9f\\b8" +
-       "\x00\x00\x00\x00\xa0K\x0f\xc8\x00\x00\x00\x00\xa1=\x95\xb8\x00\x00\x00\x00\xa2,CH\x00\x00\x00\x00\xa3\x1e\xc98\x00\x00\x00\x00\xa4\rv\xc8\x00\x00\x00\x00\xa4\xff\xfc\xb8\x00\x00\x00\x00\xa5\xef\xfb\xc8\x00\x00\x00\x00" +
-       "\xa6⁸\x00\x00\x00\x00\xa7\xd1/H\x00\x00\x00\x00\xa8õ8\x00\x00\x00\x00\xa9\xb2b\xc8\x00\x00\x00\x00\xaa\xa4\xe8\xb8\x00\x00\x00\x00\xab\x93\x96H\x00\x00\x00\x00\xac\x86\x1c8\x00\x00\x00\x00\xadt\xc9\xc8" +
-       "\x00\x00\x00\x00\xaegO\xb8\x00\x00\x00\x00\xafWN\xc8\x00\x00\x00\x00\xb0IԸ\x00\x00\x00\x00\xb18\x82H\x00\x00\x00\x00\xb2+\b8\x00\x00\x00\x00\xb3\x19\xb5\xc8\x00\x00\x00\x00\xb4\f;\xb8\x00\x00\x00\x00" +
-       "\xb4\xfa\xe9H\x00\x00\x00\x00\xb5\xedo8\x00\x00\x00\x00\xb6\xddnH\x00\x00\x00\x00\xb7\xcf\xf48\x00\x00\x00\x00\xb8\xbe\xa1\xc8\x00\x00\x00\x00\xb9\xb1'\xb8\x00\x00\x00\x00\xba\x9f\xd5H\x00\x00\x00\x00\xbb\x92[8" +
-       "\x00\x00\x00\x00\xbc\x81\b\xc8\x00\x00\x00\x00\xbds\x8e\xb8\x00\x00\x00\x00\xbec\x8d\xc8\x00\x00\x00\x00\xbfV\x13\xb8\x00\x00\x00\x00\xc0D\xc1H\x00\x00\x00\x00\xc17G8\x00\x00\x00\x00\xc2%\xf4\xc8\x00\x00\x00\x00" +
-       "\xc3\x18z\xb8\x00\x00\x00\x00\xc4\a(H\x00\x00\x00\x00\xc4\xf9\xae8\x00\x00\x00\x00\xc5\xe9\xadH\x00\x00\x00\x00\xc6\xdc38\x00\x00\x00\x00\xc7\xca\xe0\xc8\x00\x00\x00\x00Ƚf\xb8\x00\x00\x00\x00ɬ\x14H" +
-       "\x00\x00\x00\x00ʞ\x9a8\x00\x00\x00\x00ˍG\xc8\x00\x00\x00\x00\xcc\u007f\u0378\x00\x00\x00\x00\xcdo\xcc\xc8\x00\x00\x00\x00\xcebR\xb8\x00\x00\x00\x00\xcfQ\x00H\x00\x00\x00\x00\xd0C\x868\x00\x00\x00\x00" +
-       "\xd123\xc8\x00\x00\x00\x00\xd2$\xb9\xb8\x00\x00\x00\x00\xd3\x13gH\x00\x00\x00\x00\xd4\x05\xed8\x00\x00\x00\x00\xd4\xf5\xecH\x00\x00\x00\x00\xd5\xe8r8\x00\x00\x00\x00\xd6\xd7\x1f\xc8\x00\x00\x00\x00\xd7ɥ\xb8" +
-       "\x00\x00\x00\x00ظSH\x00\x00\x00\x00٪\xd98\x00\x00\x00\x00ڙ\x86\xc8\x00\x00\x00\x00ی\f\xb8\x00\x00\x00\x00\xdc|\v\xc8\x00\x00\x00\x00\xddn\x91\xb8\x00\x00\x00\x00\xde]?H\x01\x02\x04\x03" +
-       "\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x00\x0008\x00\x00\x00\x0008\x00\x04\x00\x0018\x00\b\x00\x00FP\x01\x0e\x00\x008@\x00\x12\x00\x00?H\x01\x16LMT\x00TMT" +
-       "\x00+0330\x00+05\x00+04\x00+0430\x00\n<+0330>-3:30<+0430>,J79/24,J263/24\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\x06\x00\x1c\x00IsraelUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00b\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff\xc8Y\xb2\xe0" +
-       "\xff\xff\xff\xff\xcc\xe5\xc1P\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc6\xf4\xd0\xff\xff\xff\xffϏf\xe0\xff\xff\xff\xffЩy\xd0\xff\xff\xff\xffф`\xe0\xff\xff\xff\xffҊ\xc9p\xff\xff\xff\xff" +
-       "\xd3e\xb0\x80\xff\xff\xff\xff\xd4k\xe0\xd0\xff\xff\xff\xff\xd7Z\x14`\xff\xff\xff\xff\xd7\xdf\x1f\xc0\xff\xff\xff\xff\xd8/\xb5p\xff\xff\xff\xff\xd9\x1eF\xe0\xff\xff\xff\xff\xda\x10\xe8\xf0\xff\xff\xff\xff\xda\xeb\xb3\xe0" +
-       "\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ \xe0\xff\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}\x00\xff\xff\xff\xff" +
-       "\xe2\xbeJ`\xff\xff\xff\xff\xe364\xd0\xff\xff\xff\xff\xe4\x9c\xf7\x00\xff\xff\xff\xff\xe5\x16\x16\xd0\xff\xff\xff\xff\xe6t\xd3\xe0\xff\xff\xff\xff\xe7\x11Ҁ\xff\xff\xff\xff\xe8'\xff\x00\xff\xff\xff\xff\xe8\xe8O\xd0" +
-       "\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe8\xaa\xe0\x00\x00\x00\x00\x14 \t\xe0\x00\x00\x00\x00\x1a\xf9t\xe0\x00\x00\x00\x00" +
-       "\x1b\x8d\x1c\xe0\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1d\x89\xf1\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0" +
-       "\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00" +
-       ")\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0" +
-       "\x00\x00\x00\x001H\x96\xe0\x00\x00\x00\x002<nP\x00\x00\x00\x0031\xb3`\x00\x00\x00\x004\x1a\xfe\xd0\x00\x00\x00\x005\x11\x95`\x00\x00\x00\x005\xf1\xa6P\x00\x00\x00\x007\x04\b\x80\x00\x00\x00\x00" +
-       "7\xcf\x01p\x00\x00\x00\x008\xf6_\x80\x00\x00\x00\x009\xdc\xf9\xe0\x00\x00\x00\x00:\xd0\xedp\x00\x00\x00\x00;\xae[`\x00\x00\x00\x00<\xa3\xa0p\x00\x00\x00\x00=\xa0\xb2`\x00\x00\x00\x00>\x83\x82p" +
-       "\x00\x00\x00\x00?|\x9f\xe0\x00\x00\x00\x00@s6p\x00\x00\x00\x00AP\xa4`\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00CHOp\x00\x00\x00\x00D,q\x00\x00\x00\x00\x00E\x1e\xf6\xf0\x00\x00\x00\x00" +
-       "F\fS\x00\x00\x00\x00\x00F\xecc\xf0\x00\x00\x00\x00G\xec5\x00\x00\x00\x00\x00H\xe7\xf5p\x00\x00\x00\x00I\xcc\x17\x00\x00\x00\x00\x00J\xbe\x9c\xf0\x00\x00\x00\x00K\xab\xf9\x00\x00\x00\x00\x00L\x8c\t\xf0" +
-       "\x00\x00\x00\x00M\x95\x15\x80\x00\x00\x00\x00N\x87\x9bp\x00\x00\x00\x00Ot\xf7\x80\x00\x00\x00\x00P^B\xf0\x00\x00\x00\x00QTـ\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\f\x00\x008@\x01\x10LMT\x00JMT\x00IDT\x00" +
-       "IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ%J\xd5\xebS\x01\x00\x00S" +
-       "\x01\x00\x00\a\x00\x1c\x00JamaicaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87#~\xff\xff\xff\xff\x93\x0f\xb4\xfe\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00" +
-       "\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e" +
-       "\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00" +
-       "\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xb8\x02\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\fL" +
-       "MT\x00KMT\x00EST\x00EDT\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\x05\x00\x1c\x00JapanUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x03\x00\x00\x00\f\xff" +
-       "\xff\xff\xffe¤p\xff\xff\xff\xff\xd7>\x02p\xff\xff\xff\xff\xd7\xedY\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd;\xf0\xff\xff\xff\xff\xdb\a\x00\xf0\xff\xff\xff\xffۭ\x1d\xf0\xff\xff\xff\xff\xdc" +
-       "\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xff\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x83\x03\x00\x00\x00\x00\x8c\xa0\x01\x04\x00\x00~\x90\x00\bLMT\x00JDT\x00JST\x00\nJST-9\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x1c\x00KwajaleinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff~6\x18 \xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9" +
-       "\xea\n`\xff\xff\xff\xff\xcfF\x81\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x00,v\x0e@\x01\x02\x03\x01\x04\x05\x00\x00\x9c\xe0\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00\x8c\xa0\x00\b\x00\x00~\x90\x00\f\xff\xffW" +
-       "@\x00\x10\x00\x00\xa8\xc0\x00\x14LMT\x00+11\x00+10\x00+09\x00-12\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ_\u007f2" +
-       "[\xaf\x01\x00\x00\xaf\x01\x00\x00\x05\x00\x1c\x00LibyaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa1\xf2\xc1$\xff\xff\xff\xffݻ\xb1\x10\xff\xff\xff\xff\xde#\xad`\xff\xff\xff\xff\xe1x\xd2\x10\xff\xff\xff\xff\xe1\xe7e" +
-       "\xe0\xff\xff\xff\xff\xe5/?p\xff\xff\xff\xff\xe5\xa9\xcc\xe0\xff\xff\xff\xff\xebN\xc6\xf0\x00\x00\x00\x00\x16\x92B`\x00\x00\x00\x00\x17\b\xf7p\x00\x00\x00\x00\x17\xfa+\xe0\x00\x00\x00\x00\x18\xea*\xf0\x00\x00\x00" +
-       "\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbd\xe4`\x00\x00\x00\x00\x1c\xb4z\xf0\x00\x00\x00\x00\x1d\x9f\x17\xe0\x00\x00\x00\x00\x1e\x93\vp\x00\x00\x00\x00\x1f\x82\xee`\x00\x00\x00\x00 pJ" +
-       "p\x00\x00\x00\x00!a~\xe0\x00\x00\x00\x00\"R\xcfp\x00\x00\x00\x00#D\x03\xe0\x00\x00\x00\x00$4\x02\xf0\x00\x00\x00\x00%%7`\x00\x00\x00\x00&@\xb7\xf0\x00\x00\x00\x002N\xf1`\x00\x00\x00" +
-       "\x003D6p\x00\x00\x00\x0045j\xe0\x00\x00\x00\x00P\x9d\x99\x00\x00\x00\x00\x00QTـ\x00\x00\x00\x00Ri\xb4\x80\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x03\x02\x01\x03\x02\x01\x03\x00\x00\f\\\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00\x1c \x00\rLMT\x00CEST\x00CET\x00EET\x00\nEET-2\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00\x1c\x00METUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x02\x00\x00\x00\t\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff" +
-       "\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4" +
-       "\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00" +
-       "\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe" +
-       "\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00" +
-       "\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18" +
-       "\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00" +
-       "\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01" +
-       "\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x05\x00\x00\x1c \x01\x00MEST\x00MET\x00\nMET-1MES" +
-       "T,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf5\x8d\x99\x92o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00MSTUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x9d\x90\x00" +
-       "\x00MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00MST7MDTUT\t\x00\x03\xec,\x94_\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" +
-       "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6:\x90\xff" +
-       "\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb" +
-       "\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00" +
-       "\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t" +
-       "\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00" +
-       "\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18" +
-       "\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00" +
-       "\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&" +
-       "\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00" +
-       "\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004" +
-       "R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00" +
-       "\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00B" +
-       "O\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
-       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
-       "\x01\x00\x01\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x01\x00\xff\xff\xab\xa0\x01\b\xff\xff\xab\xa0\x01\fMDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M" +
-       "11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Mexico/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x1c\x00Mexico/BajaNorteUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00" +
-       "\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff" +
-       "\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4" +
-       "\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff" +
-       "\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae" +
-       " \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00" +
-       "\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9" +
-       "\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00" +
-       "\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1" +
-       "\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00" +
-       "\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7" +
-       "\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00" +
-       "\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f" +
-       " \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10\xff\xff\x9d\x90\x01\x14LMT\x00MST\x00PST\x00PDT\x00P" +
-       "WT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x1c" +
-       "\x00Mexico/GeneralUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x04\x00\x1c\x00GMT0UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00" +
+       "\x00\x00o\x00\x00\x00\t\x00\x1c\x00GreenwichUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RE\t\xfa-\a\x03\x00\x00" +
+       "\a\x03\x00\x00\b\x00\x1c\x00HongkongUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x05\x00\x00\x00\x16\xff\xff\xff\xff\x85ic\x90\xff\xff\xff\xff\xcaM10\xff\xff\xff\xff\xcaۓ0\xff\xff\xff\xff\xcbKqx\xff\xff\xff\xffҠސ\xff" +
+       "\xff\xff\xff\xd3k׀\xff\xff\xff\xffԓX\xb8\xff\xff\xff\xff\xd5B\xb08\xff\xff\xff\xff\xd6s:\xb8\xff\xff\xff\xff\xd7>A\xb8\xff\xff\xff\xff\xd8.2\xb8\xff\xff\xff\xff\xd8\xf99\xb8\xff\xff\xff\xff\xda" +
+       "\x0e\x14\xb8\xff\xff\xff\xff\xda\xd9\x1b\xb8\xff\xff\xff\xff\xdb\xed\xf6\xb8\xff\xff\xff\xffܸ\xfd\xb8\xff\xff\xff\xff\xdd\xcdظ\xff\xff\xff\xffޢ\x1a8\xff\xff\xff\xff߶\xf58\xff\xff\xff\xff\xe0\x81\xfc8\xff" +
+       "\xff\xff\xff\xe1\x96\xc9(\xff\xff\xff\xff\xe2Oi8\xff\xff\xff\xff\xe3v\xab(\xff\xff\xff\xff\xe4/K8\xff\xff\xff\xff\xe5_Ǩ\xff\xff\xff\xff\xe6\x0f-8\xff\xff\xff\xff\xe7?\xa9\xa8\xff\xff\xff\xff\xe7" +
+       "\xf8I\xb8\xff\xff\xff\xff\xe9\x1f\x8b\xa8\xff\xff\xff\xff\xe9\xd8+\xb8\xff\xff\xff\xff\xea\xffm\xa8\xff\xff\xff\xff\xeb\xb8\r\xb8\xff\xff\xff\xff\xec\xdfO\xa8\xff\xff\xff\xff\xed\x97\xef\xb8\xff\xff\xff\xff\xee\xc8l(\xff" +
+       "\xff\xff\xff\xefwѸ\xff\xff\xff\xff\xf0\xa8N(\xff\xff\xff\xff\xf1W\xb3\xb8\xff\xff\xff\xff\xf2\x880(\xff\xff\xff\xff\xf3@\xd08\xff\xff\xff\xff\xf4h\x12(\xff\xff\xff\xff\xf5 \xb28\xff\xff\xff\xff\xf6" +
+       "G\xf4(\xff\xff\xff\xff\xf7%~8\xff\xff\xff\xff\xf8\x15a(\xff\xff\xff\xff\xf9\x05`8\xff\xff\xff\xff\xf9\xf5C(\xff\xff\xff\xff\xfa\xe5B8\xff\xff\xff\xff\xfb\xde_\xa8\xff\xff\xff\xff\xfc\xce^\xb8\xff" +
+       "\xff\xff\xff\xfd\xbeA\xa8\xff\xff\xff\xff\xfe\xae@\xb8\xff\xff\xff\xff\xff\x9e#\xa8\x00\x00\x00\x00\x00\x8e\"\xb8\x00\x00\x00\x00\x01~\x05\xa8\x00\x00\x00\x00\x02n\x04\xb8\x00\x00\x00\x00\x03]\xe7\xa8\x00\x00\x00\x00\x04" +
+       "M\xe6\xb8\x00\x00\x00\x00\x05G\x04(\x00\x00\x00\x00\x067\x038\x00\x00\x00\x00\a&\xe6(\x00\x00\x00\x00\a\x83=8\x00\x00\x00\x00\t\x06\xc8(\x00\x00\x00\x00\t\xf6\xc78\x00\x00\x00\x00\n\xe6\xaa(\x00" +
+       "\x00\x00\x00\v֩8\x00\x00\x00\x00\fƌ(\x00\x00\x00\x00\x11\x9b98\x00\x00\x00\x00\x12ol\xa8\x01\x02\x03\x04\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00k\n\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x01\b\x00\x00" +
+       "w\x88\x01\r\x00\x00~\x90\x00\x12LMT\x00HKT\x00HKST\x00HKWT\x00JST\x00\nHKT-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R=\xf7\xfawp\x00\x00" +
+       "\x00p\x00\x00\x00\x03\x00\x1c\x00HSTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xffs`\x00\x00HST\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00" +
+       "\x1c\x00IcelandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00D\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x8b`\x83\xa0\xff\xff\xff\xff\x9c\x91\x1e\x00\xff\xff\xff\xff\x9dш\x90\xff\xff\xff\xff\x9erQ\x80\xff\xff\xff\xff\x9f\xd5\x03\x10\xff\xff\xff\xff\xa0S\x85\x00" +
+       "\xff\xff\xff\xff\xa1\xb66\x90\xff\xff\xff\xff\xa4<'\x80\xff\xff\xff\xff\xa4\xb9t\x10\xff\xff\xff\xff\xc6M\x1a\x00\xff\xff\xff\xff\xc7=' \xff\xff\xff\xff\xc7\xda\x17\xb0\xff\xff\xff\xff\xc9&C\xa0\xff\xff\xff\xff" +
+       "\xc9\xc3& \xff\xff\xff\xff\xcb\x06%\xa0\xff\xff\xff\xffˬB\xa0\xff\xff\xff\xff\xcc\xdc\xcd \xff\xff\xff\xff͌$\xa0\xff\xff\xff\xffμ\xaf \xff\xff\xff\xff\xcfl\x06\xa0\xff\xff\xff\xffМ\x91 " +
+       "\xff\xff\xff\xff\xd1K\xe8\xa0\xff\xff\xff\xff҅\xad\xa0\xff\xff\xff\xff\xd3+ʠ\xff\xff\xff\xff\xd4e\x8f\xa0\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6Eq\xa0\xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff" +
+       "\xd8%S\xa0\xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xda\x0ep \xff\xff\xff\xff\xda\xd9w \xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xffܹY \xff\xff\xff\xff\xdd\xce4 \xff\xff\xff\xffޢu\xa0" +
+       "\xff\xff\xff\xff߮\x16 \xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1\x8d\xf8 \xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3m\xda \xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe5M\xbc \xff\xff\xff\xff" +
+       "\xe6!\xfd\xa0\xff\xff\xff\xff\xe76ؠ\xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe9\x16\xba\xa0\xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xf6\x9c\xa0\xff\xff\xff\xff\xeb\xca\xde \xff\xff\xff\xff\xec\xd6~\xa0" +
+       "\xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\xee\xb6`\xa0\xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff\xf0\x96B\xa0\xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2\u007f_ \xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff" +
+       "\xf4_A \xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6?# \xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x1f\x05 \xff\xff\xff\xff\xf8\xf3F\xa0\xff\xff\xff\xff\xf9\xfe\xe7 \xff\xff\xff\xff\xfa\xd3(\xa0" +
+       "\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc\xbcE \x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\xff\xff\xeb`\x00\x00\x00\x00\x00\x00\x01\x04\xff\xff\xf1\xf0\x00\b\x00\x00\x00\x00\x00\fLMT\x00+00\x00-01\x00" +
+       "GMT\x00\nGMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Indian/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Indian/MayotteU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00" +
+       "\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00" +
+       "\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb8K\xabυ\x00\x00\x00" +
+       "\x85\x00\x00\x00\x10\x00\x1c\x00Indian/KerguelenUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\xdaab\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00FP\x00\x04-00\x00+05\x00\n<+0" +
+       "5>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb9\xb2Z\xac\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Indian/MaldivesUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xffV\xb6\x9f" +
+       "\x18\xff\xff\xff\xff\xed/Ø\x01\x02\x00\x00D\xe8\x00\x00\x00\x00D\xe8\x00\x04\x00\x00FP\x00\bLMT\x00MMT\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9Ry(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x1c\x00Indian/ReunionUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x91\xcc9\x80\x01\x00\x004\x00\x00\x00\x00\x008@\x00\x04LM" +
+       "T\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x1c\x00Indian/Mauritiu" +
+       "sUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x03" +
+       "\x00\x00\x00\f\xff\xff\xff\xff\x89\u007f\x05\x98\x00\x00\x00\x00\x18\x05\xed@\x00\x00\x00\x00\x18\xdbr0\x00\x00\x00\x00I\x03\x96\xe0\x00\x00\x00\x00IΏ\xd0\x02\x01\x02\x01\x02\x00\x005\xe8\x00\x00\x00\x00FP\x01" +
+       "\x04\x00\x008@\x00\bLMT\x00+05\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x13\x00\x1c\x00In" +
+       "dian/AntananarivoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4" +
+       "\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04" +
+       "\n\x00\x00\x00\x00\x00\xf1c9Ra\x85jo\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Indian/MaheUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x89\u007f\a\x84\x01\x00\x003\xfc\x00\x00\x00\x008@\x00" +
+       "\x04LMT\x00+04\x00\n<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x1c\x00Indian/Comor" +
+       "oUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04" +
+       "\x00\x00\x00\x14\xff\xff\xff\xff\x8b\xff\xd1\xfc\xff\xff\xff\xff\xb1\xee\xdaX\xff\xff\xff\xff\xb4\xc7\xe0\xd0\xff\xff\xff\xff\xc1\xed\xadX\xff\xff\xff\xff\xcclz\xd4\x01\x02\x01\x03\x02\x00\x00\"\x84\x00\x00\x00\x00#(\x00" +
+       "\x04\x00\x00*0\x00\n\x00\x00&\xac\x00\x0eLMT\x00+0230\x00EAT\x00+0245\x00\nEAT-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R$l=҅\x00" +
+       "\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Indian/ChristmasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xffs\x16\xa9\xe4\x01\x00\x00c\x1c\x00\x00\x00\x00bp\x00\x04LMT\x00+07\x00\n<" +
+       "+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00\x1c\x00Indian/ChagosUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x89~\xf7" +
+       "\x9c\x00\x00\x00\x000\xe6ݰ\x01\x02\x00\x00C\xe4\x00\x00\x00\x00FP\x00\x04\x00\x00T`\x00\bLMT\x00+05\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9RͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x1c\x00Indian/CocosUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\n\xff\xff\xff\xff|U&\xa4\x01\x00\x00Z\xdc\x00\x00\x00\x00[h\x00\x04LMT\x00" +
+       "+0630\x00\n<+0630>-6:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x1c\x00IranUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x06\x00\x00\x00\x1c\xff\xff\xff" +
+       "\xff\x9al}\xc8\xff\xff\xff\xff\xd2\xdb\x12\xc8\x00\x00\x00\x00\x0e\xbb\xa2H\x00\x00\x00\x00\x0ft-@\x00\x00\x00\x00\x10\x8e@0\x00\x00\x00\x00\x10\xed:@\x00\x00\x00\x00\x11Ug\xc8\x00\x00\x00\x00\x12EJ" +
+       "\xb8\x00\x00\x00\x00\x137\xec\xc8\x00\x00\x00\x00\x14-\x15\xb8\x00\x00\x00\x00( v\xc8\x00\x00\x00\x00(\u06dd\xb8\x00\x00\x00\x00)˜\xc8\x00\x00\x00\x00*\xbe\"\xb8\x00\x00\x00\x00+\xac\xd0H\x00\x00\x00" +
+       "\x00,\x9fV8\x00\x00\x00\x00-\x8e\x03\xc8\x00\x00\x00\x00.\x80\x89\xb8\x00\x00\x00\x00/o7H\x00\x00\x00\x000a\xbd8\x00\x00\x00\x001Pj\xc8\x00\x00\x00\x002B\xf0\xb8\x00\x00\x00\x0032\xef" +
+       "\xc8\x00\x00\x00\x004%u\xb8\x00\x00\x00\x005\x14#H\x00\x00\x00\x006\x06\xa98\x00\x00\x00\x006\xf5V\xc8\x00\x00\x00\x007\xe7ܸ\x00\x00\x00\x008֊H\x00\x00\x00\x009\xc9\x108\x00\x00\x00" +
+       "\x00:\xb9\x0fH\x00\x00\x00\x00;\xab\x958\x00\x00\x00\x00<\x9aB\xc8\x00\x00\x00\x00=\x8cȸ\x00\x00\x00\x00>{vH\x00\x00\x00\x00?m\xfc8\x00\x00\x00\x00@\\\xa9\xc8\x00\x00\x00\x00AO/" +
+       "\xb8\x00\x00\x00\x00B?.\xc8\x00\x00\x00\x00C1\xb4\xb8\x00\x00\x00\x00G\xe2\xc9H\x00\x00\x00\x00H\xd5O8\x00\x00\x00\x00I\xc5NH\x00\x00\x00\x00J\xb7\xd48\x00\x00\x00\x00K\xa6\x81\xc8\x00\x00\x00" +
+       "\x00L\x99\a\xb8\x00\x00\x00\x00M\x87\xb5H\x00\x00\x00\x00Nz;8\x00\x00\x00\x00Oh\xe8\xc8\x00\x00\x00\x00P[n\xb8\x00\x00\x00\x00QKm\xc8\x00\x00\x00\x00R=\xf3\xb8\x00\x00\x00\x00S,\xa1" +
+       "H\x00\x00\x00\x00T\x1f'8\x00\x00\x00\x00U\r\xd4\xc8\x00\x00\x00\x00V\x00Z\xb8\x00\x00\x00\x00V\xef\bH\x00\x00\x00\x00W\xe1\x8e8\x00\x00\x00\x00XэH\x00\x00\x00\x00Y\xc4\x138\x00\x00\x00" +
+       "\x00Z\xb2\xc0\xc8\x00\x00\x00\x00[\xa5F\xb8\x00\x00\x00\x00\\\x93\xf4H\x00\x00\x00\x00]\x86z8\x00\x00\x00\x00^u'\xc8\x00\x00\x00\x00_g\xad\xb8\x00\x00\x00\x00`W\xac\xc8\x00\x00\x00\x00aJ2" +
+       "\xb8\x00\x00\x00\x00b8\xe0H\x00\x00\x00\x00c+f8\x00\x00\x00\x00d\x1a\x13\xc8\x00\x00\x00\x00e\f\x99\xb8\x00\x00\x00\x00e\xfbGH\x00\x00\x00\x00f\xed\xcd8\x00\x00\x00\x00g\xdd\xccH\x00\x00\x00" +
+       "\x00h\xd0R8\x00\x00\x00\x00i\xbe\xff\xc8\x00\x00\x00\x00j\xb1\x85\xb8\x00\x00\x00\x00k\xa03H\x00\x00\x00\x00l\x92\xb98\x00\x00\x00\x00m\x81f\xc8\x00\x00\x00\x00ns\xec\xb8\x00\x00\x00\x00ob\x9a" +
+       "H\x00\x00\x00\x00pU 8\x00\x00\x00\x00qE\x1fH\x00\x00\x00\x00r7\xa58\x00\x00\x00\x00s&R\xc8\x00\x00\x00\x00t\x18ظ\x00\x00\x00\x00u\a\x86H\x00\x00\x00\x00u\xfa\f8\x00\x00\x00" +
+       "\x00v\xe8\xb9\xc8\x00\x00\x00\x00w\xdb?\xb8\x00\x00\x00\x00x\xcb>\xc8\x00\x00\x00\x00y\xbdĸ\x00\x00\x00\x00z\xacrH\x00\x00\x00\x00{\x9e\xf88\x00\x00\x00\x00|\x8d\xa5\xc8\x00\x00\x00\x00}\x80+" +
+       "\xb8\x00\x00\x00\x00~n\xd9H\x00\x00\x00\x00\u007fa_8\x00\x00\x00\x00\x80Q^H\x00\x00\x00\x00\x81C\xe48\x00\x00\x00\x00\x822\x91\xc8\x00\x00\x00\x00\x83%\x17\xb8\x00\x00\x00\x00\x84\x13\xc5H\x00\x00\x00" +
+       "\x00\x85\x06K8\x00\x00\x00\x00\x85\xf4\xf8\xc8\x00\x00\x00\x00\x86\xe7~\xb8\x00\x00\x00\x00\x87\xd7}\xc8\x00\x00\x00\x00\x88\xca\x03\xb8\x00\x00\x00\x00\x89\xb8\xb1H\x00\x00\x00\x00\x8a\xab78\x00\x00\x00\x00\x8b\x99\xe4" +
+       "\xc8\x00\x00\x00\x00\x8c\x8cj\xb8\x00\x00\x00\x00\x8d{\x18H\x00\x00\x00\x00\x8em\x9e8\x00\x00\x00\x00\x8f]\x9dH\x00\x00\x00\x00\x90P#8\x00\x00\x00\x00\x91>\xd0\xc8\x00\x00\x00\x00\x921V\xb8\x00\x00\x00" +
+       "\x00\x93 \x04H\x00\x00\x00\x00\x94\x12\x8a8\x00\x00\x00\x00\x95\x017\xc8\x00\x00\x00\x00\x95\xf3\xbd\xb8\x00\x00\x00\x00\x96\xe3\xbc\xc8\x00\x00\x00\x00\x97\xd6B\xb8\x00\x00\x00\x00\x98\xc4\xf0H\x00\x00\x00\x00\x99\xb7v" +
+       "8\x00\x00\x00\x00\x9a\xa6#\xc8\x00\x00\x00\x00\x9b\x98\xa9\xb8\x00\x00\x00\x00\x9c\x87WH\x00\x00\x00\x00\x9dy\xdd8\x00\x00\x00\x00\x9ei\xdcH\x00\x00\x00\x00\x9f\\b8\x00\x00\x00\x00\xa0K\x0f\xc8\x00\x00\x00" +
+       "\x00\xa1=\x95\xb8\x00\x00\x00\x00\xa2,CH\x00\x00\x00\x00\xa3\x1e\xc98\x00\x00\x00\x00\xa4\rv\xc8\x00\x00\x00\x00\xa4\xff\xfc\xb8\x00\x00\x00\x00\xa5\xef\xfb\xc8\x00\x00\x00\x00\xa6⁸\x00\x00\x00\x00\xa7\xd1/" +
+       "H\x00\x00\x00\x00\xa8õ8\x00\x00\x00\x00\xa9\xb2b\xc8\x00\x00\x00\x00\xaa\xa4\xe8\xb8\x00\x00\x00\x00\xab\x93\x96H\x00\x00\x00\x00\xac\x86\x1c8\x00\x00\x00\x00\xadt\xc9\xc8\x00\x00\x00\x00\xaegO\xb8\x00\x00\x00" +
+       "\x00\xafWN\xc8\x00\x00\x00\x00\xb0IԸ\x00\x00\x00\x00\xb18\x82H\x00\x00\x00\x00\xb2+\b8\x00\x00\x00\x00\xb3\x19\xb5\xc8\x00\x00\x00\x00\xb4\f;\xb8\x00\x00\x00\x00\xb4\xfa\xe9H\x00\x00\x00\x00\xb5\xedo" +
+       "8\x00\x00\x00\x00\xb6\xddnH\x00\x00\x00\x00\xb7\xcf\xf48\x00\x00\x00\x00\xb8\xbe\xa1\xc8\x00\x00\x00\x00\xb9\xb1'\xb8\x00\x00\x00\x00\xba\x9f\xd5H\x00\x00\x00\x00\xbb\x92[8\x00\x00\x00\x00\xbc\x81\b\xc8\x00\x00\x00" +
+       "\x00\xbds\x8e\xb8\x00\x00\x00\x00\xbec\x8d\xc8\x00\x00\x00\x00\xbfV\x13\xb8\x00\x00\x00\x00\xc0D\xc1H\x00\x00\x00\x00\xc17G8\x00\x00\x00\x00\xc2%\xf4\xc8\x00\x00\x00\x00\xc3\x18z\xb8\x00\x00\x00\x00\xc4\a(" +
+       "H\x00\x00\x00\x00\xc4\xf9\xae8\x00\x00\x00\x00\xc5\xe9\xadH\x00\x00\x00\x00\xc6\xdc38\x00\x00\x00\x00\xc7\xca\xe0\xc8\x00\x00\x00\x00Ƚf\xb8\x00\x00\x00\x00ɬ\x14H\x00\x00\x00\x00ʞ\x9a8\x00\x00\x00" +
+       "\x00ˍG\xc8\x00\x00\x00\x00\xcc\u007f\u0378\x00\x00\x00\x00\xcdo\xcc\xc8\x00\x00\x00\x00\xcebR\xb8\x00\x00\x00\x00\xcfQ\x00H\x00\x00\x00\x00\xd0C\x868\x00\x00\x00\x00\xd123\xc8\x00\x00\x00\x00\xd2$\xb9" +
+       "\xb8\x00\x00\x00\x00\xd3\x13gH\x00\x00\x00\x00\xd4\x05\xed8\x00\x00\x00\x00\xd4\xf5\xecH\x00\x00\x00\x00\xd5\xe8r8\x00\x00\x00\x00\xd6\xd7\x1f\xc8\x00\x00\x00\x00\xd7ɥ\xb8\x00\x00\x00\x00ظSH\x00\x00\x00" +
+       "\x00٪\xd98\x00\x00\x00\x00ڙ\x86\xc8\x00\x00\x00\x00ی\f\xb8\x00\x00\x00\x00\xdc|\v\xc8\x00\x00\x00\x00\xddn\x91\xb8\x00\x00\x00\x00\xde]?H\x01\x02\x04\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x00\x0008\x00\x00\x00\x0008\x00\x04\x00\x0018\x00\b\x00\x00FP\x01\x0e\x00\x008@\x00\x12\x00\x00?H\x01\x16LMT\x00TMT\x00+0330\x00+05\x00" +
+       "+04\x00+0430\x00\n<+0330>-3:30<+0430>,J79/24,J263/24\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\x17✳2\x04\x00\x002\x04\x00\x00\x06\x00\x1c\x00IsraelUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6\xc2\xfa\xff\xff\xff\xff\x9e0E\x88\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff" +
+       "\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ\xd7" +
+       "\x80\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xd7Z0\x80\xff\xff\xff\xff\xd7\xdfX\x00\xff\xff\xff\xff\xd8/À\xff\xff\xff\xff\xd9\x1ec\x00\xff\xff\xff\xff\xda\x10\xf7\x00\xff\xff\xff" +
+       "\xff\xda\xeb\xd0\x00\xff\xff\xff\xff۴4\x00\xff\xff\xff\xffܹ=\x00\xff\xff\xff\xff\xdd\xe0\x8d\x00\xff\xff\xff\xff\u07b4\u0380\xff\xff\xff\xffߤ\xbf\x80\xff\xff\xff\xff\xe0\x8bv\x00\xff\xff\xff\xff\xe1V}" +
+       "\x00\xff\xff\xff\xff\xe2\xbef\x80\xff\xff\xff\xff\xe36_\x00\xff\xff\xff\xff\xe4\x9eH\x80\xff\xff\xff\xff\xe5\x16A\x00\xff\xff\xff\xff\xe6t\xf0\x00\xff\xff\xff\xff\xe7\x11Ҁ\xff\xff\xff\xff\xe8&\xad\x80\xff\xff\xff" +
+       "\xff\xe8\xe8z\x00\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6" +
+       "`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00" +
+       "\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03" +
+       "P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00" +
+       "\x000H\xc5\xd0\x00\x00\x00\x001H\x96\xe0\x00\x00\x00\x002<nP\x00\x00\x00\x0031\xb3`\x00\x00\x00\x004\x1a\xfe\xd0\x00\x00\x00\x005\x11\x95`\x00\x00\x00\x005\xf1\xa6P\x00\x00\x00\x007\x04\b" +
+       "\x80\x00\x00\x00\x007\xcf\x01p\x00\x00\x00\x008\xf6_\x80\x00\x00\x00\x009\xdc\xf9\xe0\x00\x00\x00\x00:\xd0\xedp\x00\x00\x00\x00;\xae[`\x00\x00\x00\x00<\xa3\xa0p\x00\x00\x00\x00=\xa0\xb2`\x00\x00\x00" +
+       "\x00>\x83\x82p\x00\x00\x00\x00?|\x9f\xe0\x00\x00\x00\x00@s6p\x00\x00\x00\x00AP\xa4`\x00\x00\x00\x00BL\x8f\x00\x00\x00\x00\x00CHOp\x00\x00\x00\x00D,q\x00\x00\x00\x00\x00E\x1e\xf6" +
+       "\xf0\x00\x00\x00\x00F\fS\x00\x00\x00\x00\x00F\xecc\xf0\x00\x00\x00\x00G\xec5\x00\x00\x00\x00\x00H\xe7\xf5p\x00\x00\x00\x00I\xcc\x17\x00\x00\x00\x00\x00J\xbe\x9c\xf0\x00\x00\x00\x00K\xab\xf9\x00\x00\x00\x00" +
+       "\x00L\x8c\t\xf0\x00\x00\x00\x00M\x95\x15\x80\x00\x00\x00\x00N\x87\x9bp\x00\x00\x00\x00Ot\xf7\x80\x00\x00\x00\x00P^B\xf0\x00\x00\x00\x00QTـ\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x04" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00!\x06\x00\x00\x00\x00 \xf8\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\f\x00\x008@\x01\x10LMT\x00J" +
+       "MT\x00IDT\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R%J" +
+       "\xd5\xebS\x01\x00\x00S\x01\x00\x00\a\x00\x1c\x00JamaicaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xffi\x87#~\xff\xff\xff\xff\x93\x0f\xb4\xfe\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00" +
+       "\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0" +
+       "\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00" +
+       "\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xff\xb8\x02\x00\x00\xff\xff\xb8\x02\x00\x04\xff\xff\xb9\xb0\x00\b" +
+       "\xff\xff\xc7\xc0\x01\fLMT\x00KMT\x00EST\x00EDT\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\x05\x00\x1c\x00Ja" +
+       "panUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00" +
+       "\x00\x03\x00\x00\x00\f\xff\xff\xff\xffe¤p\xff\xff\xff\xff\xd7>\x02p\xff\xff\xff\xff\xd7\xedY\xf0\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd;\xf0\xff\xff\xff\xff\xdb\a\x00\xf0\xff\xff\xff\xffۭ" +
+       "\x1d\xf0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xff\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x83\x03\x00\x00\x00\x00\x8c\xa0\x01\x04\x00\x00~\x90\x00\bLMT\x00JDT\x00JST\x00\nJS" +
+       "T-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x1c\x00KwajaleinUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff~6\x18 \xff\xff\xff\xff\xc1\xed" +
+       "5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xcfF\x81\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x00,v\x0e@\x01\x02\x03\x01\x04\x05\x00\x00\x9c\xe0\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00\x8c\xa0\x00\b\x00\x00" +
+       "~\x90\x00\f\xff\xffW@\x00\x10\x00\x00\xa8\xc0\x00\x14LMT\x00+11\x00+10\x00+09\x00-12\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x05\x00\x1c\x00LibyaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x00\x04\x00\x00\x00\x11\xff\xff\xff\xff\xa1\xf2\xc1$\xff\xff\xff\xffݻ\xb1\x10\xff\xff\xff\xff\xde#\xad`\xff\xff\xff\xff\xe1x\xd2\x10" +
+       "\xff\xff\xff\xff\xe1\xe7e\xe0\xff\xff\xff\xff\xe5/?p\xff\xff\xff\xff\xe5\xa9\xcc\xe0\xff\xff\xff\xff\xebN\xc6\xf0\x00\x00\x00\x00\x16\x92B`\x00\x00\x00\x00\x17\b\xf7p\x00\x00\x00\x00\x17\xfa+\xe0\x00\x00\x00\x00" +
+       "\x18\xea*\xf0\x00\x00\x00\x00\x19\xdb_`\x00\x00\x00\x00\x1a̯\xf0\x00\x00\x00\x00\x1b\xbd\xe4`\x00\x00\x00\x00\x1c\xb4z\xf0\x00\x00\x00\x00\x1d\x9f\x17\xe0\x00\x00\x00\x00\x1e\x93\vp\x00\x00\x00\x00\x1f\x82\xee`" +
+       "\x00\x00\x00\x00 pJp\x00\x00\x00\x00!a~\xe0\x00\x00\x00\x00\"R\xcfp\x00\x00\x00\x00#D\x03\xe0\x00\x00\x00\x00$4\x02\xf0\x00\x00\x00\x00%%7`\x00\x00\x00\x00&@\xb7\xf0\x00\x00\x00\x00" +
+       "2N\xf1`\x00\x00\x00\x003D6p\x00\x00\x00\x0045j\xe0\x00\x00\x00\x00P\x9d\x99\x00\x00\x00\x00\x00QTـ\x00\x00\x00\x00Ri\xb4\x80\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x03\x02\x01\x03\x00\x00\f\\\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00\x1c \x00\rLMT\x00CEST\x00CET\x00EET\x00\nEE" +
+       "T-2\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00\x1c\x00METUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x005\x00\x00\x00\x02\x00\x00\x00\t\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff" +
+       "\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10" +
+       "\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xff\xd2N@\x90\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00" +
+       "\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐" +
+       "\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00" +
+       "\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10" +
+       "\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00" +
+       ",\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
+       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x05\x00\x00\x1c \x01\x00MEST\x00MET\x00\nM" +
+       "ET-1MEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Mexi" +
+       "co/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x1c" +
+       "\x00Mexico/GeneralUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff" +
        "\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xc5ް`\xff\xff\xff\xffƗ4P\xff\xff\xff\xff\xc9U\xf1\xe0\xff\xff\xff\xff\xc9\xea\xddP\xff\xff\xff\xff\xcf\x02\xc6\xe0\xff\xff\xff\xffϷVP\xff\xff\xff\xffڙ" +
        "\x15\xe0\xff\xff\xff\xff\xdbv\x83\xd0\x00\x00\x00\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00" +
        "\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xf5\x04\x80\x00\x00\x00\x00;\xb6\xc2\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x01\x02\x01\x02\x01\x02" +
        "\x03\x02\x03\x02\x04\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xa3\f\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10LMT\x00MST\x00C" +
-       "ST\x00CDT\x00CWT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ8\xcdZ\x05o\x01\x00\x00o\x01\x00" +
-       "\x00\x0e\x00\x1c\x00Mexico/BajaSurUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f" +
-       "6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00" +
-       "\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5" +
-       "\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff\xff\x9c<\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff" +
-       "\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00PST\x00MDT\x00\nMST7MDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x1c\x00NZUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5" +
-       "h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff" +
-       "\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac" +
-       "\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff" +
-       "\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1" +
-       "\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00" +
-       "\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G" +
-       "`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00" +
-       "\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5" +
-       "`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00" +
-       "\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9" +
-       "\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00" +
-       "\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex" +
-       "`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00" +
-       "\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LMT\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT" +
-       ",M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\a\x00\x1c\x00NZ-CHATUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x04\x00\x00\x00\x16\xff\xff\xff" +
-       "\xffA\xb7D\x84\xff\xff\xff\xff\xd2ږ\xbc\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde" +
-       "\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00" +
-       "\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f" +
-       "`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00" +
-       "\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06" +
-       "\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00" +
-       "\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f" +
-       "\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00" +
-       "\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4" +
-       "`\x00\x00\x00\x00F\xfeZ`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\xab\xfc\x00\x00\x00\x00\xacD\x00\x04\x00\x00\xc1\\\x01\n\x00\x00\xb3L\x00\x10LMT\x00+1215\x00+1345\x00+1" +
-       "245\x00\n<+1245>-12:45<+1345>,M9.5.0/2:45,M4.1.0/3:45\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x1c\x00NavajoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c" +
-       "\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff" +
-       "\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W" +
-       "\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00" +
-       "\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2" +
-       "\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00" +
-       "\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n" +
-       "\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00" +
-       "\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90" +
-       "\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00" +
-       "\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H" +
-       "\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00" +
-       "\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}" +
-       "\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT" +
-       ",M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x03\x00\x1c\x00PRCUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)" +
-       "\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff" +
-       "\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80" +
-       "\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR \x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00" +
-       "$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQŭV\xad\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00PST8PDTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
+       "ST\x00CDT\x00CWT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00" +
+       "\x00\x10\x00\x1c\x00Mexico/BajaNorteUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00^\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\xa5\xb6\xf6\x80\xff\xff\xff\xff\xa9yOp\xff\xff\xff\xff\xaf\xf2|\xf0\xff\xff\xff\xff\xb6fdp\xff\xff\xff\xff" +
+       "\xb7\x1b\x10\x00\xff\xff\xff\xff\xb8\n\xf2\xf0\xff\xff\xff\xff\xcbꍀ\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xffҙ\xbap\xff\xff\xff\xff\xd7\x1bY\x00\xff\xff\xff\xffؑ\xb4\xf0\xff\xff\xff\xff\xe2~K\x90" +
+       "\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff" +
+       "\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10" +
+       "\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00" +
+       "\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0" +
+       "\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00" +
+       "\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10" +
+       "\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x00" +
+       "0\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 " +
+       "\x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00" +
+       ">\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90" +
+       "\x00\x00\x00\x00F\x0f\x82\xa0\x00\x00\x00\x00G$O\x90\x00\x00\x00\x00G\xf8\x9f \x00\x00\x00\x00I\x041\x90\x00\x00\x00\x00I\u0601 \x00\x00\x00\x00J\xe4\x13\x90\x00\x00\x00\x00K\x9c\xb3\xa0\x01\x02\x01\x02" +
+       "\x03\x02\x04\x05\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\x92L\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\x8f\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10" +
+       "\xff\xff\x9d\x90\x01\x14LMT\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R8\xcdZ\x05o\x01\x00\x00o\x01\x00\x00\x0e\x00\x1c\x00Mexico/BajaSurUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff\xa5\xb6\xe8p\xff\xff\xff\xff\xaf\xf2n\xe0\xff\xff\xff" +
+       "\xff\xb6fV`\xff\xff\xff\xff\xb7C\xd2`\xff\xff\xff\xff\xb8\f6`\xff\xff\xff\xff\xb8\xfd\x86\xf0\xff\xff\xff\xff\xcb\xeaq`\xff\xff\xff\xffؑ\xb4\xf0\x00\x00\x00\x00\x00\x00p\x80\x00\x00\x00\x001g\x84" +
+       "\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00" +
+       "\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xf5\x12\x90\x00\x00\x00\x00;\xb6\xd1\x00\x00\x00\x00\x00<\xb0\n\x90\x01\x02\x01\x02\x01\x02\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\xff" +
+       "\xff\x9c<\x00\x00\xff\xff\x9d\x90\x00\x04\xff\xff\xab\xa0\x00\b\xff\xff\x8f\x80\x00\f\xff\xff\xab\xa0\x01\x10LMT\x00MST\x00CST\x00PST\x00MDT\x00\nMST7MDT,M4" +
+       ".1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf5\x8d\x99\x92o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00MSTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
+       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\xff\xff\x9d\x90\x00\x00MST\x00\n" +
+       "MST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00MST7MDTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a" +
+       "\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff" +
+       "\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a" +
+       "\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00" +
+       "\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82" +
+       "\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00" +
+       "\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1\xcd" +
+       "\x80\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00" +
+       "\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85" +
+       "\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00" +
+       "\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ" +
+       "\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00" +
+       "\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00" +
+       "\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\x9d" +
+       "\x90\x00\x04\xff\xff\xab\xa0\x01\x00\xff\xff\xab\xa0\x01\b\xff\xff\xab\xa0\x01\fMDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x1c\x00NavajoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff" +
+       "\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90" +
+       "\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff" +
+       "\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10" +
+       "\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00" +
+       "\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00" +
+       "\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00" +
+       "\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90" +
+       "\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00" +
+       "&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80" +
+       "\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x00" +
+       "4R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10" +
+       "\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00" +
+       "BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00M" +
+       "PT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x1c\x00NZU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00" +
+       "\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff" +
+       "\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3" +
+       "\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff" +
+       "\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18" +
+       "\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00" +
+       "\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7" +
+       "\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00" +
+       "\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%." +
+       "\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00" +
+       "\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*" +
+       "\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00" +
+       "\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^" +
+       "\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0" +
+       "\x00\x04LMT\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\a\x00\x1c\x00NZ-CHATUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a" +
-       "\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff" +
-       "\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q" +
-       "\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00" +
-       "\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13i" +
-       "r \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00" +
-       "\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81" +
-       "\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00" +
-       "\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~" +
-       "u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00" +
-       "\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb" +
-       "\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00" +
-       "\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x01\x00\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01" +
-       "\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\x00\xff\xff\x9d\x90\x01\b" +
-       "\xff\xff\x9d\x90\x01\fPDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00Pacific/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x1c\x00Pacific/Port_MoresbyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffV\xb6Z\b\xff\xff\xff\xffr\xed\xa4" +
-       "\x90\x01\x02\x00\x00\x89\xf8\x00\x00\x00\x00\x89\xf0\x00\x04\x00\x00\x8c\xa0\x00\tLMT\x00PMMT\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\xf3" +
-       "9a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x1c\x00Pacific/ChuukUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x04\x00\x00\x00\x16\xff\xff\xff\xffA\xb7D\x84\xff\xff\xff\xff\xd2ږ\xbc\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac" +
+       "\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00" +
+       "\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!" +
+       "H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00" +
+       "\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02" +
+       "B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00" +
+       "\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046" +
+       "K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00" +
+       "\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<" +
+       "0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\xab\xfc\x00\x00\x00\x00\xac" +
+       "D\x00\x04\x00\x00\xc1\\\x01\n\x00\x00\xb3L\x00\x10LMT\x00+1215\x00+1345\x00+1245\x00\n<+1245>-12:45<+1345>,M" +
+       "9.5.0/2:45,M4.1.0/3:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00Pacific" +
+       "/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x1c\x00P" +
+       "acific/EasterUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xffi\x87B\b\xff\xff\xff\xff\xb9\xc7@\x88\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00" +
+       "\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@" +
+       "\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00" +
+       "\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0" +
+       "\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00" +
+       "\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@" +
+       "\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00" +
+       "*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0" +
+       "\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x00" +
+       "8\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0" +
+       "\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00" +
+       "G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0" +
+       "\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00" +
+       "W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc80\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
+       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\x99x\x00\x00\xff\xff\x99x\x00\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff" +
+       "\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\x10LMT\x00EMT\x00-06\x00-07\x00-05\x00\n<-06>6<-05>,M9.1.6/22,M4.1.6/" +
+       "22\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00\x10\x00\x1c\x00Pacific/PitcairnUT\t\x00\x03\x15\xac\x0e`\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff~7.\xf4" +
+       "\x00\x00\x00\x005DB\b\x01\x02\xff\xff\x86\f\x00\x00\xff\xff\x88x\x00\x04\xff\xff\x8f\x80\x00\nLMT\x00-0830\x00-08\x00\n<-08>8\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R3\x03\x1f\f\xac\x00\x00\x00\xac\x00\x00\x00\x11\x00\x1c\x00Pacific/EnderburyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff~7Ud\x00\x00\x00\x00\x12V\x04\xc0\x00\x00\x00\x00" +
+       "/\x059\xb0\x01\x02\x03\xff\xff_\x9c\x00\x00\xff\xffW@\x00\x04\xff\xffeP\x00\b\x00\x00\xb6\xd0\x00\fLMT\x00-12\x00-11\x00+13\x00\n<+13>-13\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9Ra\vೆ\x00\x00\x00\x86\x00\x00\x00\x10\x00\x1c\x00Pacific/FunafutiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff~6\f\xfc\x01\x00\x00\xa8\x04\x00" +
+       "\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x1c\x00Pacif" +
+       "ic/PonapeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x14\xe1\xb9,\xff\xff\xff\xff~6 \xac\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`" +
+       "\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x04\x03\x02\xff\xffB\xd4\x00\x00\x00\x00\x94T\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x00\fLMT\x00+11\x00+09\x00+10" +
+       "\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x1c\x00Pacific/NoumeaUT\t\x00\x03" +
+       "\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff" +
+       "\xff\xff\x92\xf5\xc4t\x00\x00\x00\x00\x0e\xe6\xbaP\x00\x00\x00\x00\x0fV\xbb\xc0\x00\x00\x00\x00\x10ƜP\x00\x00\x00\x00\x117\xef@\x00\x00\x00\x002\xa0K\xf0\x00\x00\x00\x003\x18Dp\x02\x01\x02\x01\x02\x01" +
+       "\x02\x00\x00\x9c\f\x00\x00\x00\x00\xa8\xc0\x01\x04\x00\x00\x9a\xb0\x00\bLMT\x00+12\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x80\xf8vܔ" +
+       "\x00\x00\x00\x94\x00\x00\x00\r\x00\x1c\x00Pacific/PalauUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xff\x14\xe1\xcfl\xff\xff\xff\xff~66\xec\x01\x02\xff\xff,\x94\x00\x00\x00\x00~\x14\x00\x00\x00\x00~" +
+       "\x90\x00\x04LMT\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/Jo" +
+       "hnstonUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\a\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!qX\xff\xff\xff\xffˉ=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff" +
+       "\xffՍsH\x01\x02\x01\x03\x04\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff\xffzh\x01\f\xff\xffzh\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00" +
+       "HWT\x00HPT\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xca\"\xb8i\xda\x00\x00\x00\xda\x00\x00\x00\x0e\x00\x1c\x00Pacific/MajuroU" +
+       "T\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00" +
+       "\x00\x14\xff\xff\xff\xff~6\x14\x80\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xcf=Gp\xff\xff\xff\xff\xff\x86\x1bP\x01\x02" +
+       "\x01\x03\x02\x01\x04\x00\x00\xa0\x80\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x00\f\x00\x00\xa8\xc0\x00\x10LMT\x00+11\x00+09\x00+10\x00+12\x00\n<+12" +
+       ">-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x1c\x00Pacific/Pago_PagoUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn" +
+       "=\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\x9e\u007f\xab\x95V\x01\x00\x00V\x01\x00\x00\r\x00\x1c\x00Pacific/EfateUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x92\xf5´\x00\x00\x00\x00\ay\x99@\x00\x00\x00\x00\a\xfa\xcc@\x00\x00\x00\x00" +
+       "\x19\xd2\xf7\xd0\x00\x00\x00\x00\x1a\xc2\xda\xc0\x00\x00\x00\x00\x1b\xb2\xd9\xd0\x00\x00\x00\x00\x1c\xa2\xbc\xc0\x00\x00\x00\x00\x1d\x9b\xf6P\x00\x00\x00\x00\x1e\x82\x9e\xc0\x00\x00\x00\x00\x1f{\xd8P\x00\x00\x00\x00 k\xbb@" +
+       "\x00\x00\x00\x00![\xbaP\x00\x00\x00\x00\"K\x9d@\x00\x00\x00\x00#;\x9cP\x00\x00\x00\x00$+\u007f@\x00\x00\x00\x00%\x1b~P\x00\x00\x00\x00&\va@\x00\x00\x00\x00&\xfb`P\x00\x00\x00\x00" +
+       "'\xebC@\x00\x00\x00\x00(\xe4|\xd0\x00\x00\x00\x00)\x81Q@\x00\x00\x00\x00*\xe9H\xd0\x00\x00\x00\x00+a3@\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00" +
+       "\x00\x9d\xcc\x00\x00\x00\x00\xa8\xc0\x01\x04\x00\x00\x9a\xb0\x00\bLMT\x00+12\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc8=ku\xae\x00\x00" +
+       "\x00\xae\x00\x00\x00\x12\x00\x1c\x00Pacific/KiritimatiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x14\xe1\xbf4\xff\xff\xff\xff~6&\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff\xff\xff\xa09" +
-       "\xf9\xf0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00\x8eL\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\bLMT\x00+10\x00+09\x00" +
-       "\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x1c\x00Pacific/EasterUT\t\x00\x03\xec" +
-       ",\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00f\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff" +
-       "\xffi\x87B\b\xff\xff\xff\xff\xb9\xc7@\x88\xff\xff\xff\xff\xfd\xd1<@\xff\xff\xff\xff\xfe\x92\xfa\xb0\xff\xff\xff\xff\xff\xcc\xcd\xc0\x00\x00\x00\x00\x00rܰ\x00\x00\x00\x00\x01uP\xc0\x00\x00\x00\x00\x02@I" +
-       "\xb0\x00\x00\x00\x00\x03U2\xc0\x00\x00\x00\x00\x04 +\xb0\x00\x00\x00\x00\x05>O@\x00\x00\x00\x00\x06\x00\r\xb0\x00\x00\x00\x00\a\v\xbc@\x00\x00\x00\x00\a\xdf\xef\xb0\x00\x00\x00\x00\b\xfe\x13@\x00\x00\x00" +
-       "\x00\t\xbfѰ\x00\x00\x00\x00\n\xdd\xf5@\x00\x00\x00\x00\v\xa8\xee0\x00\x00\x00\x00\f\xbd\xd7@\x00\x00\x00\x00\r\x88\xd00\x00\x00\x00\x00\x0e\x9d\xb9@\x00\x00\x00\x00\x0fh\xb20\x00\x00\x00\x00\x10\x86\xd5" +
-       "\xc0\x00\x00\x00\x00\x11H\x940\x00\x00\x00\x00\x12f\xb7\xc0\x00\x00\x00\x00\x13(v0\x00\x00\x00\x00\x14F\x99\xc0\x00\x00\x00\x00\x15\x11\x92\xb0\x00\x00\x00\x00\x16&{\xc0\x00\x00\x00\x00\x16\xf1t\xb0\x00\x00\x00" +
-       "\x00\x18\x06]\xc0\x00\x00\x00\x00\x18\xd1V\xb0\x00\x00\x00\x00\x19\xe6?\xc0\x00\x00\x00\x00\x1a\xb18\xb0\x00\x00\x00\x00\x1b\xcf\\@\x00\x00\x00\x00\x1c\x91\x1a\xb0\x00\x00\x00\x00\x1d\xaf>@\x00\x00\x00\x00\x1ep\xfc" +
-       "\xb0\x00\x00\x00\x00\x1f\x8f @\x00\x00\x00\x00 \u007f\x030\x00\x00\x00\x00!o\x02@\x00\x00\x00\x00\"9\xfb0\x00\x00\x00\x00#N\xe4@\x00\x00\x00\x00$\x19\xdd0\x00\x00\x00\x00%8\x00\xc0\x00\x00\x00" +
-       "\x00%\xf9\xbf0\x00\x00\x00\x00&\xf2\xf8\xc0\x00\x00\x00\x00'١0\x00\x00\x00\x00(\xf7\xc4\xc0\x00\x00\x00\x00)½\xb0\x00\x00\x00\x00*צ\xc0\x00\x00\x00\x00+\xa2\x9f\xb0\x00\x00\x00\x00,\xb7\x88" +
-       "\xc0\x00\x00\x00\x00-\x82\x81\xb0\x00\x00\x00\x00.\x97j\xc0\x00\x00\x00\x00/bc\xb0\x00\x00\x00\x000\x80\x87@\x00\x00\x00\x001BE\xb0\x00\x00\x00\x002`i@\x00\x00\x00\x003=\xd70\x00\x00\x00" +
-       "\x004@K@\x00\x00\x00\x005\vD0\x00\x00\x00\x006\r\xb8@\x00\x00\x00\x007\x06հ\x00\x00\x00\x008\x00\x0f@\x00\x00\x00\x008\xcb\b0\x00\x00\x00\x009\xe9+\xc0\x00\x00\x00\x00:\xaa\xea" +
-       "0\x00\x00\x00\x00;\xc9\r\xc0\x00\x00\x00\x00<\x8a\xcc0\x00\x00\x00\x00=\xa8\xef\xc0\x00\x00\x00\x00>j\xae0\x00\x00\x00\x00?\x88\xd1\xc0\x00\x00\x00\x00@Sʰ\x00\x00\x00\x00Ah\xb3\xc0\x00\x00\x00" +
-       "\x00B3\xac\xb0\x00\x00\x00\x00CH\x95\xc0\x00\x00\x00\x00D\x13\x8e\xb0\x00\x00\x00\x00E1\xb2@\x00\x00\x00\x00E\xf3p\xb0\x00\x00\x00\x00G\x11\x94@\x00\x00\x00\x00G\xef\x020\x00\x00\x00\x00H\xf1v" +
-       "@\x00\x00\x00\x00I\xbco0\x00\x00\x00\x00J\xd1X@\x00\x00\x00\x00K\xb8\x00\xb0\x00\x00\x00\x00L\xb1:@\x00\x00\x00\x00M\xc6\a0\x00\x00\x00\x00NP\x82\xc0\x00\x00\x00\x00O\x9c\xae\xb0\x00\x00\x00" +
-       "\x00PB\xd9\xc0\x00\x00\x00\x00Q|\x90\xb0\x00\x00\x00\x00R+\xf6@\x00\x00\x00\x00S\\r\xb0\x00\x00\x00\x00T\v\xd8@\x00\x00\x00\x00W7\xe60\x00\x00\x00\x00W\xaf\xec\xc0\x00\x00\x00\x00Y\x17\xc8" +
-       "0\x00\x00\x00\x00Y\x8f\xce\xc0\x00\x00\x00\x00Z\xf7\xaa0\x00\x00\x00\x00[o\xb0\xc0\x00\x00\x00\x00\\\xa9g\xb0\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
-       "\x03\x02\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
-       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\xff\xff\x99x\x00\x00\xff\xff\x99x\x00\x04\xff\xff\xab\xa0\x01\b\xff\xff\x9d\x90\x00\f\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\x10LMT\x00EMT\x00-" +
-       "06\x00-07\x00-05\x00\n<-06>6<-05>,M9.1.6/22,M4.1.6/22\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\xe8" +
-       "]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00\x1c\x00Pacific/KwajaleinUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff~6\x18 \xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff" +
-       "\xff\xff\xcfF\x81\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x00,v\x0e@\x01\x02\x03\x01\x04\x05\x00\x00\x9c\xe0\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00\x8c\xa0\x00\b\x00\x00~\x90\x00\f\xff\xffW@\x00\x10\x00\x00" +
-       "\xa8\xc0\x00\x14LMT\x00+11\x00+10\x00+09\x00-12\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQP:\xc0\x8c\xed\x00\x00\x00" +
-       "\xed\x00\x00\x00\x11\x00\x1c\x00Pacific/TongatapuUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff~6\a\xb8\xff\xff\xff\xff\xc9sB\x90\x00\x00\x00\x007\xfbG\xd0\x00\x00\x00\x008\xd3}\xd0" +
-       "\x00\x00\x00\x00:\x04\bP\x00\x00\x00\x00:r\xb8@\x00\x00\x00\x00;\xe3\xeaP\x00\x00\x00\x00<R\x9a@\x00\x00\x00\x00X\x1d\xd7\xd0\x00\x00\x00\x00Xz \xd0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00" +
-       "\xadH\x00\x00\x00\x00\xadp\x00\x04\x00\x00\xb6\xd0\x00\n\x00\x00\xc4\xe0\x01\x0eLMT\x00+1220\x00+13\x00+14\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x1c\x00Pacific/YapUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00T" +
-       "Zif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x14\xe1\xbf4\xff\xff\xff\xff~6&\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff" +
-       "\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00\x8eL\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\bLMT\x00+10\x00" +
-       "+09\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ1\xce_(\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00Pacific/WallisUT" +
-       "\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00" +
-       "\b\xff\xff\xff\xff~6\b\xa8\x01\x00\x00\xacX\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe9\xdd\x1e\xee\f\x01" +
-       "\x00\x00\f\x01\x00\x00\f\x00\x1c\x00Pacific/ApiaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\a\x00\x00\x00\x1a\xff\xff\xff\xffn=\xc9\x00\xff\xff\xff\xff\x91\x05\xfc\x00\xff\xff\xff\xff\xdab\x048\x00\x00\x00\x00L\x9f'\xb0\x00\x00\x00" +
-       "\x00M\x97+\xe0\x00\x00\x00\x00N}\xe2`\x00\x00\x00\x00N\xfd\x8b\xa0\x00\x00\x00\x00Ow\r\xe0\x01\x02\x04\x03\x04\x03\x06\x05\x00\x00\xb0\x80\x00\x00\xff\xff_\x00\x00\x00\xff\xff^H\x00\x04\xff\xffs`\x01" +
-       "\n\xff\xffeP\x00\x0e\x00\x00\xb6\xd0\x00\x12\x00\x00\xc4\xe0\x01\x16LMT\x00-1130\x00-10\x00-11\x00+13\x00+14\x00\n<+13>-13<+14>," +
-       "M9.5.0/3,M4.1.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00\x0f\x00\x1c\x00Pacific/Norf" +
-       "olkUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff~7H\x80\x00\x00\x00\x00\x12U\xf2\x00\x00\x00\x00\x00/\x05+\xa0\x01\x02\x03\xff\xffl" +
+       "\x80\x00\x00\xff\xffj\x00\x00\x04\xff\xffs`\x00\n\x00\x00\xc4\xe0\x00\x0eLMT\x00-1040\x00-10\x00+14\x00\n<+14>-14\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\x8a|\xdcU\x99\x00\x00\x00\x99\x00\x00\x00\x0f\x00\x1c\x00Pacific/FakaofoUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~7U\x88\x00\x00\x00\x00N\xfd\x99\xb0\x01\x02\xff\xff_x\x00" +
+       "\x00\xff\xffeP\x00\x04\x00\x00\xb6\xd0\x00\bLMT\x00-11\x00+13\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x96\xc5FF(\x03\x00\x00(\x03\x00" +
+       "\x00\x0f\x00\x1c\x00Pacific/ChathamUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x04\x00\x00\x00\x16\xff\xff\xff\xffA\xb7D\x84\xff\xff\xff\xff\xd2ږ\xbc\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n" +
+       "\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00" +
+       "\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18" +
+       "\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00" +
+       "\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'" +
+       "\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00" +
+       "\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005" +
+       "\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00" +
+       "\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C" +
+       ">\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\xab\xfc\x00\x00\x00\x00\xacD\x00\x04\x00\x00\xc1\\" +
+       "\x01\n\x00\x00\xb3L\x00\x10LMT\x00+1215\x00+1345\x00+1245\x00\n<+1245>-12:45<+1345>,M9.5.0/2" +
+       ":45,M4.1.0/3:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00\x1c\x00Pacific/Kwajal" +
+       "einUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00" +
-       "\x00\x06\x00\x00\x00\x1e\xff\xff\xff\xff~6\x17\x88\xff\xff\xff\xff\xdcA\xf8\x80\x00\x00\x00\x00\t\x0f\xcah\x00\x00\x00\x00\t\xb5\xe7h\x00\x00\x00\x00V\x0f\xe6h\x00\x00\x00\x00]\x98\xaf\xf0\x01\x02\x03\x02\x04\x05" +
-       "\x00\x00\x9dx\x00\x00\x00\x00\x9d\x80\x00\x04\x00\x00\xa1\xb8\x00\n\x00\x00\xaf\xc8\x01\x10\x00\x00\x9a\xb0\x00\x16\x00\x00\xa8\xc0\x01\x1aLMT\x00+1112\x00+1130\x00+1230\x00+1" +
-       "1\x00+12\x00\n<+11>-11<+12>,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xd5s\x9bkD\x01\x00\x00" +
-       "D\x01\x00\x00\r\x00\x1c\x00Pacific/EfateUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x92\xf5´\x00\x00\x00\x00\x19\xd2\xf7\xd0\x00\x00\x00\x00\x1a\xc2\xda\xc0\x00\x00\x00\x00\x1b\xdaf\xd0\x00\x00\x00\x00" +
-       "\x1c\xa2\xbc\xc0\x00\x00\x00\x00\x1d\x9b\xf6P\x00\x00\x00\x00\x1e\x82\x9e\xc0\x00\x00\x00\x00\x1f{\xd8P\x00\x00\x00\x00 k\xbb@\x00\x00\x00\x00![\xbaP\x00\x00\x00\x00\"K\x9d@\x00\x00\x00\x00#;\x9cP" +
-       "\x00\x00\x00\x00$+\u007f@\x00\x00\x00\x00%\x1b~P\x00\x00\x00\x00&\va@\x00\x00\x00\x00&\xfb`P\x00\x00\x00\x00'\xebC@\x00\x00\x00\x00(\xe4|\xd0\x00\x00\x00\x00)\x81Q@\x00\x00\x00\x00" +
-       "*\xe9H\xd0\x00\x00\x00\x00+a3@\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x9d\xcc\x00\x00\x00\x00\xa8\xc0\x01\x04\x00\x00\x9a\xb0\x00\bLMT\x00+12\x00+" +
-       "11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ4\xd0Yӣ\x01\x00\x00\xa3\x01\x00\x00\f\x00\x1c\x00Pacific/FijiUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff" +
-       "\xff\xff\x9a\x13\xb1\xc0\x00\x00\x00\x006;\x17\xe0\x00\x00\x00\x006\xd7\xfa`\x00\x00\x00\x008$4`\x00\x00\x00\x008\xb7\xdc`\x00\x00\x00\x00K\x11,\xe0\x00\x00\x00\x00K\xae\x0f`\x00\x00\x00\x00L\xc2" +
-       "\xea`\x00\x00\x00\x00MrA\xe0\x00\x00\x00\x00N\xa2\xcc`\x00\x00\x00\x00O\x1a\xc4\xe0\x00\x00\x00\x00P\x82\xae`\x00\x00\x00\x00P\xfa\xa6\xe0\x00\x00\x00\x00Rk\xca\xe0\x00\x00\x00\x00R\xdaz\xd0\x00\x00" +
-       "\x00\x00TT\xe7`\x00\x00\x00\x00T\xbaj\xe0\x00\x00\x00\x00V4\xc9`\x00\x00\x00\x00V\x9aL\xe0\x00\x00\x00\x00X\x1d\xe5\xe0\x00\x00\x00\x00Xz.\xe0\x00\x00\x00\x00Y\xfd\xc7\xe0\x00\x00\x00\x00ZZ" +
-       "\x10\xe0\x00\x00\x00\x00[ݩ\xe0\x00\x00\x00\x00\\9\xf2\xe0\x00\x00\x00\x00]\xc6\xc6`\x00\x00\x00\x00^\x19\xd4\xe0\x00\x00\x00\x00_\xde\a`\x00\x00\x00\x00`\x02\xf1`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xa7\xc0\x00\x00\x00\x00\xb6\xd0\x01\x04\x00\x00\xa8\xc0\x00\bLMT\x00+13\x00+12\x00\n<+12>-12<+" +
-       "13>,M11.2.0,M1.2.3/99\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQa\vೆ\x00\x00\x00\x86\x00\x00\x00\x10\x00\x1c\x00Pacific/" +
-       "FunafutiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff~6\f\xfc\x01\x00\x00\xa8\x04\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\x80\xf8vܔ\x00\x00\x00\x94\x00\x00\x00\r\x00\x1c\x00Pacific/PalauUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xff\x14\xe1\xcfl\xff\xff\xff\xff~66\xec\x01\x02\xff\xff,\x94\x00\x00" +
-       "\x00\x00~\x14\x00\x00\x00\x00~\x90\x00\x04LMT\x00+09\x00\n<+09>-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00\x1c\x00P" +
-       "acific/GuamUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x15\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xff\x14\xe1\xc5\xcc\xff\xff\xff\xff~6-L\xff\xff\xff\xff\xcb7\x95\xe0\xff\xff\xff\xff\xd0.\x89\xf0\xff\xff\xff\xff\xec7\xbe\x00\xff\xff\xff\xff\xef6" +
-       "\xf8\xf0\xff\xff\xff\xff\xfb\x9b\x00\x00\xff\xff\xff\xff\xfe?'\x8c\xff\xff\xff\xff\xff\x01\x1e\x00\xff\xff\xff\xff\xff]X\xf0\x00\x00\x00\x00\x00\x97,\x00\x00\x00\x00\x00\x01Fup\x00\x00\x00\x00\x02w\x0e\x00\x00\x00" +
-       "\x00\x00\x03&Wp\x00\x00\x00\x00\ap\x97\x00\x00\x00\x00\x00\a\xcc\xd1\xf0\x00\x00\x00\x00\f\b\x91\x00\x00\x00\x00\x00\f|\x87,\x00\x00\x00\x00\r\xbf\x94\x80\x00\x00\x00\x00\x0ee\xa3p\x00\x00\x00\x00:C" +
-       "^`\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\xff\xff64\x00\x00\x00\x00\x87\xb4\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x10L" +
-       "MT\x00GST\x00+09\x00GDT\x00ChST\x00\nChST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\x0e\x00\x1c\x00P" +
-       "acific/SaipanUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xff\x14\xe1\xc5\xcc\xff\xff\xff\xff~6-L\xff\xff\xff\xff\xcb7\x95\xe0\xff\xff\xff\xff\xd0.\x89\xf0\xff\xff\xff\xff\xec7\xbe\x00\xff\xff\xff\xff" +
-       "\xef6\xf8\xf0\xff\xff\xff\xff\xfb\x9b\x00\x00\xff\xff\xff\xff\xfe?'\x8c\xff\xff\xff\xff\xff\x01\x1e\x00\xff\xff\xff\xff\xff]X\xf0\x00\x00\x00\x00\x00\x97,\x00\x00\x00\x00\x00\x01Fup\x00\x00\x00\x00\x02w\x0e\x00" +
-       "\x00\x00\x00\x00\x03&Wp\x00\x00\x00\x00\ap\x97\x00\x00\x00\x00\x00\a\xcc\xd1\xf0\x00\x00\x00\x00\f\b\x91\x00\x00\x00\x00\x00\f|\x87,\x00\x00\x00\x00\r\xbf\x94\x80\x00\x00\x00\x00\x0ee\xa3p\x00\x00\x00\x00" +
-       ":C^`\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\xff\xff64\x00\x00\x00\x00\x87\xb4\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00" +
-       "\x10LMT\x00GST\x00+09\x00GDT\x00ChST\x00\nChST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x97n7\x1a\xf2\x00\x00\x00\xf2\x00\x00\x00\x0e\x00\x1c" +
-       "\x00Pacific/KosraeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff~6\x18 \xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xcfF\x81\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x00,v\x0e@\x01\x02\x03\x01\x04\x05" +
+       "\x00\x00\x9c\xe0\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00\x8c\xa0\x00\b\x00\x00~\x90\x00\f\xff\xffW@\x00\x10\x00\x00\xa8\xc0\x00\x14LMT\x00+11\x00+10\x00+09\x00-12\x00+12\x00" +
+       "\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x1c\x00Pacific/MidwayUT\t\x00\x03\x15" +
+       "\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff" +
+       "\xffn=\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R1\xce_(\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00Pacific/WallisUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff~6\b\xa8\x01\x00\x00\xacX\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00" +
+       "+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R4\xd0Yӣ\x01\x00\x00\xa3\x01\x00\x00\f\x00\x1c\x00Pacific/FijiUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff" +
+       "\xff\xff\xff\x9a\x13\xb1\xc0\x00\x00\x00\x006;\x17\xe0\x00\x00\x00\x006\xd7\xfa`\x00\x00\x00\x008$4`\x00\x00\x00\x008\xb7\xdc`\x00\x00\x00\x00K\x11,\xe0\x00\x00\x00\x00K\xae\x0f`\x00\x00\x00\x00L" +
+       "\xc2\xea`\x00\x00\x00\x00MrA\xe0\x00\x00\x00\x00N\xa2\xcc`\x00\x00\x00\x00O\x1a\xc4\xe0\x00\x00\x00\x00P\x82\xae`\x00\x00\x00\x00P\xfa\xa6\xe0\x00\x00\x00\x00Rk\xca\xe0\x00\x00\x00\x00R\xdaz\xd0\x00" +
+       "\x00\x00\x00TT\xe7`\x00\x00\x00\x00T\xbaj\xe0\x00\x00\x00\x00V4\xc9`\x00\x00\x00\x00V\x9aL\xe0\x00\x00\x00\x00X\x1d\xe5\xe0\x00\x00\x00\x00Xz.\xe0\x00\x00\x00\x00Y\xfd\xc7\xe0\x00\x00\x00\x00Z" +
+       "Z\x10\xe0\x00\x00\x00\x00[ݩ\xe0\x00\x00\x00\x00\\9\xf2\xe0\x00\x00\x00\x00]\xc6\xc6`\x00\x00\x00\x00^\x19\xd4\xe0\x00\x00\x00\x00_\xde\a`\x00\x00\x00\x00`\x02\xf1`\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xa7\xc0\x00\x00\x00\x00\xb6\xd0\x01\x04\x00\x00\xa8\xc0\x00\bLMT\x00+13\x00+12\x00\n<+12>-12<" +
+       "+13>,M11.2.0,M1.2.3/99\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe9\xdd\x1e\xee\f\x01\x00\x00\f\x01\x00\x00\f\x00\x1c\x00Pacific" +
+       "/ApiaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b" +
+       "\x00\x00\x00\a\x00\x00\x00\x1a\xff\xff\xff\xffn=\xc9\x00\xff\xff\xff\xff\x91\x05\xfc\x00\xff\xff\xff\xff\xdab\x048\x00\x00\x00\x00L\x9f'\xb0\x00\x00\x00\x00M\x97+\xe0\x00\x00\x00\x00N}\xe2`\x00\x00\x00\x00" +
+       "N\xfd\x8b\xa0\x00\x00\x00\x00Ow\r\xe0\x01\x02\x04\x03\x04\x03\x06\x05\x00\x00\xb0\x80\x00\x00\xff\xff_\x00\x00\x00\xff\xff^H\x00\x04\xff\xffs`\x01\n\xff\xffeP\x00\x0e\x00\x00\xb6\xd0\x00\x12\x00\x00\xc4\xe0" +
+       "\x01\x16LMT\x00-1130\x00-10\x00-11\x00+13\x00+14\x00\n<+13>-13<+14>,M9.5.0/3,M4.1.0/4" +
+       "\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x1c\x00Pacific/YapUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x14\xe1\xbf4\xff\xff\xff\xff~6&" +
+       "\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00\x8eL\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~" +
+       "\x90\x00\bLMT\x00+10\x00+09\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x1c\x00Pacif" +
+       "ic/Port_MoresbyUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff\x14ᴴ\xff\xff\xff\xff~6\x1c4\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff" +
-       "\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x006\x8bg@\x01\x02\x03\x02\x04\x03\x02\x05\x02\xff\xffGL\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~" +
-       "\x90\x00\b\x00\x00\x8c\xa0\x00\f\x00\x00\xa8\xc0\x00\x10LMT\x00+11\x00+09\x00+10\x00+12\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x81" +
-       "\xeb\xb8m\xaf\x00\x00\x00\xaf\x00\x00\x00\f\x00\x1c\x00Pacific/NiueUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\r\xff\xff\xff\xffV\xb6Z\b\xff\xff\xff\xffr\xed\xa4\x90\x01\x02\x00\x00\x89\xf8\x00\x00\x00\x00\x89\xf0\x00\x04\x00\x00\x8c\xa0\x00\tLMT\x00PM" +
+       "MT\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/Honol" +
+       "uluUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00" +
+       "\x00\x06\x00\x00\x00\x14\xff\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!qX\xff\xff\xff\xffˉ=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff\xffՍ" +
+       "sH\x01\x02\x01\x03\x04\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff\xffzh\x01\f\xff\xffzh\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00HWT" +
+       "\x00HPT\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0f\x00\x1c\x00Pacific/PohnpeiUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x10" +
+       "\xff\xff\xff\xff\x14\xe1\xb9,\xff\xff\xff\xff~6 \xac\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02" +
+       "\x04\x03\x02\xff\xffB\xd4\x00\x00\x00\x00\x94T\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x00\fLMT\x00+11\x00+09\x00+10\x00\n<+11>-11\nP" +
+       "K\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc23\xa0\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x1c\x00Pacific/GambierUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
+       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94PH\x04\x01\xff\xff\x81|" +
+       "\x00\x00\xff\xff\x81p\x00\x04LMT\x00-09\x00\n<-09>9\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe2;Z\xf7\xb7\x00\x00\x00\xb7\x00\x00\x00\r\x00\x1c\x00Pacifi" +
+       "c/NauruUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\xa3\xe7+\x04\xff\xff\xff\xff̐\xe9\xc8\xff\xff\xff\xff\xd2C'\xf0\x00\x00\x00\x00\x11!\xa8\xe8\x01\x02\x01\x03\x00\x00\x9c|\x00\x00\x00\x00\xa1\xb8\x00\x04\x00\x00" +
+       "~\x90\x00\n\x00\x00\xa8\xc0\x00\x0eLMT\x00+1130\x00+09\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x97n7\x1a\xf2\x00\x00\x00" +
+       "\xf2\x00\x00\x00\x0e\x00\x1c\x00Pacific/KosraeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xff\x14ᴴ\xff\xff\xff\xff~6\x1c4\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff" +
+       "\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\xff\xff\xff\xff\xff\x86\x1bP\x00\x00\x00\x006\x8bg@\x01\x02\x03\x02\x04\x03\x02\x05\x02\xff\xffGL\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00" +
+       "\x9a\xb0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x00\f\x00\x00\xa8\xc0\x00\x10LMT\x00+11\x00+09\x00+10\x00+12\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x85v\xf8\x8c\x87\x01\x00\x00\x87\x01\x00\x00\x11\x00\x1c\x00Pacific/RarotongaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
+       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff~7J\xc8\x00\x00\x00\x00\x10\xac\x1b(\x00\x00" +
+       "\x00\x00\x11?\xb5\x18\x00\x00\x00\x00\x12y\x81 \x00\x00\x00\x00\x13\x1f\x97\x18\x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x14\xffy\x18\x00\x00\x00\x00\x169E \x00\x00\x00\x00\x16蕘\x00\x00\x00\x00\x18\"" +
+       "a\xa0\x00\x00\x00\x00\x18\xc8w\x98\x00\x00\x00\x00\x1a\x02C\xa0\x00\x00\x00\x00\x1a\xa8Y\x98\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\x88;\x98\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1eh\x1d\x98\x00\x00" +
+       "\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 G\xff\x98\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"1\x1c\x18\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$\x10\xfe\x18\x00\x00\x00\x00%J\xca \x00\x00\x00\x00%\xf0" +
+       "\xe0\x18\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xd0\xc2\x18\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xffj8\x00\x00\xff\xfflX\x00\x04\xff\xffs" +
+       "`\x00\n\xff\xffzh\x01\x0eLMT\x00-1030\x00-10\x00-0930\x00\n<-10>10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RD6\x83\xa1\x8b\x00\x00\x00" +
+       "\x8b\x00\x00\x00\x11\x00\x1c\x00Pacific/MarquesasUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\n\xff\xff\xff\xff\x94PLH\x01\xff\xff}8\x00\x00\xff\xffzh\x00\x04LMT\x00-0930\x00\n" +
+       "<-0930>9:30\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00Pacific/TarawaUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff" +
+       "\xff\xff\xff~6\x12\xcc\x01\x00\x00\xa24\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00" +
+       "\xc3\x00\x00\x00\f\x00\x1c\x00Pacific/TrukUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x14\xe1\xbf4\xff\xff\xff\xff~6&\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc9" +
+       "\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00\x8eL\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\bLMT\x00+10\x00+09\x00\n<+10>-" +
+       "10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x81\xeb\xb8m\xaf\x00\x00\x00\xaf\x00\x00\x00\f\x00\x1c\x00Pacific/NiueUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" +
+       "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff~7TL\xff\xff\xff\xff" +
+       "\xdcC5`\x00\x00\x00\x00\x10t\xca8\x01\x02\x03\xff\xff`\xb4\x00\x00\xff\xff`\xa0\x00\x04\xff\xff^H\x00\n\xff\xffeP\x00\x10LMT\x00-1120\x00-1130\x00-11\x00\n" +
+       "<-11>11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x1c\x00Pacific/SamoaUT\t\x00\x03\x15\xac\x0e`" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=" +
+       "\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RF" +
+       "I\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00\x1c\x00Pacific/GuamUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff~7TL\xff\xff\xff\xff\xdcC5`\x00\x00\x00\x00\x10t\xca8\x01\x02\x03\xff\xff`" +
-       "\xb4\x00\x00\xff\xff`\xa0\x00\x04\xff\xff^H\x00\n\xff\xffeP\x00\x10LMT\x00-1120\x00-1130\x00-11\x00\n<-11>11\nPK\x03\x04\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x1c\x00Pacific/PonapeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xff\x14\xe1\xc5\xcc\xff\xff\xff\xff~6-L\xff\xff\xff\xff\xcb7\x95\xe0\xff\xff\xff\xff\xd0." +
+       "\x89\xf0\xff\xff\xff\xff\xec7\xbe\x00\xff\xff\xff\xff\xef6\xf8\xf0\xff\xff\xff\xff\xfb\x9b\x00\x00\xff\xff\xff\xff\xfe?'\x8c\xff\xff\xff\xff\xff\x01\x1e\x00\xff\xff\xff\xff\xff]X\xf0\x00\x00\x00\x00\x00\x97,\x00\x00\x00" +
+       "\x00\x00\x01Fup\x00\x00\x00\x00\x02w\x0e\x00\x00\x00\x00\x00\x03&Wp\x00\x00\x00\x00\ap\x97\x00\x00\x00\x00\x00\a\xcc\xd1\xf0\x00\x00\x00\x00\f\b\x91\x00\x00\x00\x00\x00\f|\x87,\x00\x00\x00\x00\r\xbf" +
+       "\x94\x80\x00\x00\x00\x00\x0ee\xa3p\x00\x00\x00\x00:C^`\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\xff\xff64\x00\x00\x00\x00\x87\xb4\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~" +
+       "\x90\x00\b\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x10LMT\x00GST\x00+09\x00GDT\x00ChST\x00\nChST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RF" +
+       "I\xfe\x14^\x01\x00\x00^\x01\x00\x00\x0e\x00\x1c\x00Pacific/SaipanUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x06\x00\x00\x00\x15\xff\xff\xff\xff\x14\xe1\xc5\xcc\xff\xff\xff\xff~6-L\xff\xff\xff\xff\xcb7\x95\xe0\xff\xff\xff\xff" +
+       "\xd0.\x89\xf0\xff\xff\xff\xff\xec7\xbe\x00\xff\xff\xff\xff\xef6\xf8\xf0\xff\xff\xff\xff\xfb\x9b\x00\x00\xff\xff\xff\xff\xfe?'\x8c\xff\xff\xff\xff\xff\x01\x1e\x00\xff\xff\xff\xff\xff]X\xf0\x00\x00\x00\x00\x00\x97,\x00" +
+       "\x00\x00\x00\x00\x01Fup\x00\x00\x00\x00\x02w\x0e\x00\x00\x00\x00\x00\x03&Wp\x00\x00\x00\x00\ap\x97\x00\x00\x00\x00\x00\a\xcc\xd1\xf0\x00\x00\x00\x00\f\b\x91\x00\x00\x00\x00\x00\f|\x87,\x00\x00\x00\x00" +
+       "\r\xbf\x94\x80\x00\x00\x00\x00\x0ee\xa3p\x00\x00\x00\x00:C^`\x01\x02\x03\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x04\x02\x05\xff\xff64\x00\x00\x00\x00\x87\xb4\x00\x00\x00\x00\x8c\xa0\x00\x04\x00" +
+       "\x00~\x90\x00\b\x00\x00\x9a\xb0\x01\f\x00\x00\x8c\xa0\x00\x10LMT\x00GST\x00+09\x00GDT\x00ChST\x00\nChST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\x81\xe3w\n\xaf\x00\x00\x00\xaf\x00\x00\x00\x11\x00\x1c\x00Pacific/GalapagosUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
        "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x14\xe1\xb9,\xff\xff\xff\xff~6 \xac\xff\xff\xff\xff\x98\x11\x95" +
-       "\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x04\x03\x02\xff\xffB\xd4\x00\x00\x00\x00\x94T\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00" +
-       "~\x90\x00\b\x00\x00\x8c\xa0\x00\fLMT\x00+11\x00+09\x00+10\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ߃\xa0_\x86\x00\x00\x00\x86\x00" +
-       "\x00\x00\f\x00\x1c\x00Pacific/WakeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\xb6\xa4L\x80\x00\x00\x00\x00\x1e\x18\xc4P\x00\x00\x00\x00+\x17\n" +
+       "\xe0\x00\x00\x00\x00+q\xf4P\x01\x03\x02\x03\xff\xff\xac\x00\x00\x00\xff\xff\xb9\xb0\x00\x04\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00-05\x00-06\x00\n<-06>6\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14\x00\x1c\x00Pacific/BougainvilleUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6R(\xff\xff" +
+       "\xff\xffr\xed\xa4\x90\xff\xff\xff\xff\xccC6`\xff\xff\xff\xff\xd2+l\xf0\x00\x00\x00\x00T\x9e׀\x01\x02\x03\x02\x04\x00\x00\x91\xd8\x00\x00\x00\x00\x89\xf0\x00\x04\x00\x00\x8c\xa0\x00\t\x00\x00~\x90\x00\r\x00" +
+       "\x00\x9a\xb0\x00\x11LMT\x00PMMT\x00+10\x00+09\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R߃\xa0_\x86\x00\x00\x00\x86\x00" +
+       "\x00\x00\f\x00\x1c\x00Pacific/WakeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff~6\x18\xcc\x01\x00\x00\x9c4\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x81\xe3w\n\xaf\x00\x00\x00\xaf\x00\x00\x00\x11\x00\x1c\x00Pacific/GalapagosUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\xb6\xa4L\x80\x00\x00" +
-       "\x00\x00\x1e\x18\xc4P\x00\x00\x00\x00+\x17\n\xe0\x00\x00\x00\x00+q\xf4P\x01\x03\x02\x03\xff\xff\xac\x00\x00\x00\xff\xff\xb9\xb0\x00\x04\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\bLMT\x00-05\x00-0" +
-       "6\x00\n<-06>6\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/JohnstonUT\t\x00" +
-       "\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x14\xff" +
-       "\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!qX\xff\xff\xff\xffˉ=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff\xffՍsH\x01\x02\x01\x03\x04" +
-       "\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff\xffzh\x01\f\xff\xffzh\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00HWT\x00HPT\x00\nH" +
-       "ST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x1c\x00Pacific/MidwayUT\t\x00\x03\xec,\x94_\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
-       "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=\xc8\b" +
-       "\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe2;Z" +
-       "\xf7\xb7\x00\x00\x00\xb7\x00\x00\x00\r\x00\x1c\x00Pacific/NauruUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff\xa3\xe7+\x04\xff\xff\xff\xff̐\xe9\xc8\xff\xff\xff\xff\xd2C'\xf0\x00\x00\x00\x00\x11!\xa8" +
-       "\xe8\x01\x02\x01\x03\x00\x00\x9c|\x00\x00\x00\x00\xa1\xb8\x00\x04\x00\x00~\x90\x00\n\x00\x00\xa8\xc0\x00\x0eLMT\x00+1130\x00+09\x00+12\x00\n<+12>-12\nPK\x03" +
-       "\x04\n\x00\x00\x00\x00\x00\x0e|XQY\xd2K|\x86\x00\x00\x00\x86\x00\x00\x00\x13\x00\x1c\x00Pacific/GuadalcanalUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94O3\x8c\x01\x00\x00" +
-       "\x95\xf4\x00\x00\x00\x00\x9a\xb0\x00\x04LMT\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\x0f\x00\x1c\x00Pa" +
-       "cific/ChathamUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00E\x00\x00\x00\x04\x00\x00\x00\x16\xff\xff\xff\xffA\xb7D\x84\xff\xff\xff\xff\xd2ږ\xbc\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00" +
-       "\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0" +
-       "\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00" +
-       "\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`" +
-       "\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00" +
-       "'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`" +
-       "\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x00" +
-       "6\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0" +
-       "\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00" +
-       "D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\xab\xfc\x00\x00\x00\x00\xacD\x00\x04\x00\x00\xc1\\\x01\n\x00\x00\xb3L\x00" +
-       "\x10LMT\x00+1215\x00+1345\x00+1245\x00\n<+1245>-12:45<+1345>,M9.5.0/2:45,M4." +
-       "1.0/3:45\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x10\x00\x1c\x00Pacific/AucklandUT\t\x00\x03" +
-       "\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff" +
-       "\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68" +
-       "\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff" +
-       "\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4c" +
-       "p\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00" +
-       "\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98" +
-       "\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00" +
-       "\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg" +
-       "\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00" +
-       "\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad" +
-       "\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00" +
-       "\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3" +
-       "m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00" +
-       "\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04" +
-       "\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LM" +
-       "T\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x1c\x00Pacific/NoumeaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x92\xf5\xc4t\x00\x00\x00\x00\x0e\xe6\xbaP\x00\x00\x00\x00\x0fV\xbb\xc0\x00\x00\x00" +
-       "\x00\x10ƜP\x00\x00\x00\x00\x117\xef@\x00\x00\x00\x002\xa0K\xf0\x00\x00\x00\x003\x18Dp\x02\x01\x02\x01\x02\x01\x02\x00\x00\x9c\f\x00\x00\x00\x00\xa8\xc0\x01\x04\x00\x00\x9a\xb0\x00\bLMT\x00+1" +
-       "2\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x8a|\xdcU\x99\x00\x00\x00\x99\x00\x00\x00\x0f\x00\x1c\x00Pacific/Fakaof" +
-       "oUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03" +
-       "\x00\x00\x00\f\xff\xff\xff\xff~7U\x88\x00\x00\x00\x00N\xfd\x99\xb0\x01\x02\xff\xff_x\x00\x00\xff\xffeP\x00\x04\x00\x00\xb6\xd0\x00\bLMT\x00-11\x00+13\x00\n<+13>-1" +
-       "3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xea\xc1\xdaυ\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x1c\x00Pacific/TahitiUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94PU\xb8\x01\xff\xff" +
-       "s\xc8\x00\x00\xff\xffs`\x00\x04LMT\x00-10\x00\n<-10>10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc23\xa0\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x1c\x00Pac" +
-       "ific/GambierUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94PH\x04\x01\xff\xff\x81|\x00\x00\xff\xff\x81p\x00\x04LMT\x00-09\x00\n<-09>9\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\xca\"\xb8i\xda\x00\x00\x00\xda\x00\x00\x00\x0e\x00\x1c\x00Pacific/MajuroUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff~6\x14\x80\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa0" +
-       "9\xf9\xf0\xff\xff\xff\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xcf=Gp\xff\xff\xff\xff\xff\x86\x1bP\x01\x02\x01\x03\x02\x01\x04\x00\x00\xa0\x80\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~\x90\x00\b" +
-       "\x00\x00\x8c\xa0\x00\f\x00\x00\xa8\xc0\x00\x10LMT\x00+11\x00+09\x00+10\x00+12\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xeaK\x85v" +
-       "\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/HonoluluUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!qX\xff\xff\xff\xff\xcb" +
-       "\x89=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff\xffՍsH\x01\x02\x01\x03\x04\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff\xffzh\x01\f\xff\xff" +
-       "zh\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00HWT\x00HPT\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\u07b54-\xd6\x00\x00\x00\xd6" +
-       "\x00\x00\x00\x0f\x00\x1c\x00Pacific/PohnpeiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RP:\xc0\x8c\xed\x00\x00\x00\xed\x00\x00\x00\x11\x00\x1c\x00Pacific/TongatapuUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
+       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff~6\a\xb8\xff\xff" +
+       "\xff\xff\xc9sB\x90\x00\x00\x00\x007\xfbG\xd0\x00\x00\x00\x008\xd3}\xd0\x00\x00\x00\x00:\x04\bP\x00\x00\x00\x00:r\xb8@\x00\x00\x00\x00;\xe3\xeaP\x00\x00\x00\x00<R\x9a@\x00\x00\x00\x00X\x1d" +
+       "\xd7\xd0\x00\x00\x00\x00Xz \xd0\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\xadH\x00\x00\x00\x00\xadp\x00\x04\x00\x00\xb6\xd0\x00\n\x00\x00\xc4\xe0\x01\x0eLMT\x00+1220\x00+13\x00+1" +
+       "4\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x1c\x00Pacific/ChuukUT\t\x00\x03" +
+       "\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff" +
+       "\xff\xff\x14\xe1\xbf4\xff\xff\xff\xff~6&\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00" +
+       "\x8eL\x00\x00\x00\x00\x8c\xa0\x00\x04\x00\x00~\x90\x00\bLMT\x00+10\x00+09\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xea\xc1\xdaυ\x00\x00\x00" +
+       "\x85\x00\x00\x00\x0e\x00\x1c\x00Pacific/TahitiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x05\x00\x00\x00\x10\xff\xff\xff\xff\x14\xe1\xb9,\xff\xff\xff\xff~6 \xac\xff\xff\xff\xff\x98\x11\x95\xd0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff" +
-       "\xff\xc1\xed5\xd0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x04\x03\x02\xff\xffB\xd4\x00\x00\x00\x00\x94T\x00\x00\x00\x00\x9a\xb0\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x00\fLM" +
-       "T\x00+11\x00+09\x00+10\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x1c\x00Pacifi" +
-       "c/Pago_PagoUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nS" +
-       "ST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\f\x00\x1c\x00Pacific/TrukUT\t\x00\x03\xec,\x94_\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" +
-       "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x04\x00\x00\x00\f\xff\xff\xff\xff\x14\xe1\xbf4\xff\xff" +
-       "\xff\xff~6&\xb4\xff\xff\xff\xff\x98\x11\xa3\xe0\xff\xff\xff\xff\xa09\xf9\xf0\xff\xff\xff\xff\xc9\xea\n`\xff\xff\xff\xff\xd2\x11\x0e\xf0\x01\x02\x03\x02\x03\x02\xff\xff<\xcc\x00\x00\x00\x00\x8eL\x00\x00\x00\x00\x8c\xa0" +
-       "\x00\x04\x00\x00~\x90\x00\bLMT\x00+10\x00+09\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00\x10\x00\x1c\x00" +
-       "Pacific/PitcairnUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\xff\xff\xff\xff~7.\xf4\x00\x00\x00\x005DB\b\x01\x02\xff\xff\x86\f\x00\x00\xff\xff\x88x\x00\x04\xff\xff\x8f\x80\x00\nLMT\x00-" +
-       "0830\x00-08\x00\n<-08>8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQD6\x83\xa1\x8b\x00\x00\x00\x8b\x00\x00\x00\x11\x00\x1c\x00Pacific/Marqu" +
-       "esasUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x02\x00\x00\x00\n\xff\xff\xff\xff\x94PLH\x01\xff\xff}8\x00\x00\xff\xffzh\x00\x04LMT\x00-0930\x00\n<-0930>9:30\nPK\x03\x04\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14\x00\x1c\x00Pacific/BougainvilleUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xffV\xb6R(\xff\xff\xff\xffr\xed\xa4\x90" +
-       "\xff\xff\xff\xff\xccC6`\xff\xff\xff\xff\xd2+l\xf0\x00\x00\x00\x00T\x9e׀\x01\x02\x03\x02\x04\x00\x00\x91\xd8\x00\x00\x00\x00\x89\xf0\x00\x04\x00\x00\x8c\xa0\x00\t\x00\x00~\x90\x00\r\x00\x00\x9a\xb0\x00\x11L" +
-       "MT\x00PMMT\x00+10\x00+09\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00" +
-       "Pacific/TarawaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff~6\x12\xcc\x01\x00\x00\xa24\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+12\x00\n<+12>-12\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\x85v\xf8\x8c\x87\x01\x00\x00\x87\x01\x00\x00\x11\x00\x1c\x00Pacific/RarotongaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" +
-       "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x04\x00\x00\x00\x14\xff\xff\xff\xff~7J\xc8\x00\x00\x00\x00\x10\xac" +
-       "\x1b(\x00\x00\x00\x00\x11?\xb5\x18\x00\x00\x00\x00\x12y\x81 \x00\x00\x00\x00\x13\x1f\x97\x18\x00\x00\x00\x00\x14Yc \x00\x00\x00\x00\x14\xffy\x18\x00\x00\x00\x00\x169E \x00\x00\x00\x00\x16蕘\x00\x00" +
-       "\x00\x00\x18\"a\xa0\x00\x00\x00\x00\x18\xc8w\x98\x00\x00\x00\x00\x1a\x02C\xa0\x00\x00\x00\x00\x1a\xa8Y\x98\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\x88;\x98\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00\x00\x00\x1eh" +
-       "\x1d\x98\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 G\xff\x98\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"1\x1c\x18\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$\x10\xfe\x18\x00\x00\x00\x00%J\xca \x00\x00" +
-       "\x00\x00%\xf0\xe0\x18\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xd0\xc2\x18\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\xff\xffj8\x00\x00\xff\xfflX\x00" +
-       "\x04\xff\xffs`\x00\n\xff\xffzh\x01\x0eLMT\x00-1030\x00-10\x00-0930\x00\n<-10>10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQt\xca{e" +
-       "\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x1c\x00Pacific/SamoaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xff" +
-       "eP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc8=ku\xae\x00\x00\x00\xae\x00\x00\x00\x12\x00\x1c\x00Pacific/Kir" +
-       "itimatiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94PU\xb8\x01\xff\xffs\xc8\x00\x00\xff\xffs`\x00\x04LMT\x00-10\x00\n<-10>" +
+       "10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RY\xd2K|\x86\x00\x00\x00\x86\x00\x00\x00\x13\x00\x1c\x00Pacific/GuadalcanalUT\t\x00\x03\x15\xac\x0e" +
+       "`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
+       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\b\xff\xff\xff\xff\x94" +
+       "O3\x8c\x01\x00\x00\x95\xf4\x00\x00\x00\x00\x9a\xb0\x00\x04LMT\x00+11\x00\n<+11>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00" +
+       "\x10\x00\x1c\x00Pacific/AucklandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x06\x00\x00\x00\x13\xff\xff\xff\xffA\xb7L\xa8\xff\xff\xff\xff\xb0\xb4\xb2\xe8\xff\xff\xff\xff\xb1Q\x87X\xff\xff\xff\xff\xb2x\xe5h\xff\xff\xff\xff\xb3" +
+       "C\xe5`\xff\xff\xff\xff\xb4X\xc7h\xff\xff\xff\xff\xb5#\xc7`\xff\xff\xff\xff\xb68\xa9h\xff\xff\xff\xff\xb7\x03\xa9`\xff\xff\xff\xff\xb8\x18\x8bh\xff\xff\xff\xff\xb8\xec\xc5\xe0\xff\xff\xff\xff\xb9\xf8mh\xff" +
+       "\xff\xff\xff\xba̧\xe0\xff\xff\xff\xff\xbb\xd8Oh\xff\xff\xff\xff\xbc\xe3\xe8\xe0\xff\xff\xff\xff\xbd\xae\xf6\xe8\xff\xff\xff\xff\xbe\xc3\xca\xe0\xff\xff\xff\xff\xbf\x8e\xd8\xe8\xff\xff\xff\xff\xc0\xa3\xac\xe0\xff\xff\xff\xff\xc1" +
+       "n\xba\xe8\xff\xff\xff\xff\u0083\x8e\xe0\xff\xff\xff\xff\xc3N\x9c\xe8\xff\xff\xff\xff\xc4cp\xe0\xff\xff\xff\xff\xc5.~\xe8\xff\xff\xff\xff\xc6L\x8d`\xff\xff\xff\xff\xc7\x0e`\xe8\xff\xff\xff\xff\xc8,o`\xff" +
+       "\xff\xff\xff\xc8\xf7}h\xff\xff\xff\xff\xd2ښ@\x00\x00\x00\x00\t\x18\xfd\xe0\x00\x00\x00\x00\t\xac\xa5\xe0\x00\x00\x00\x00\n\xef\xa5`\x00\x00\x00\x00\v\x9e\xfc\xe0\x00\x00\x00\x00\f\xd8\xc1\xe0\x00\x00\x00\x00\r" +
+       "~\xde\xe0\x00\x00\x00\x00\x0e\xb8\xa3\xe0\x00\x00\x00\x00\x0f^\xc0\xe0\x00\x00\x00\x00\x10\x98\x85\xe0\x00\x00\x00\x00\x11>\xa2\xe0\x00\x00\x00\x00\x12xg\xe0\x00\x00\x00\x00\x13\x1e\x84\xe0\x00\x00\x00\x00\x14XI\xe0\x00" +
+       "\x00\x00\x00\x14\xfef\xe0\x00\x00\x00\x00\x168+\xe0\x00\x00\x00\x00\x16\xe7\x83`\x00\x00\x00\x00\x18!H`\x00\x00\x00\x00\x18\xc7e`\x00\x00\x00\x00\x1a\x01*`\x00\x00\x00\x00\x1a\xa7G`\x00\x00\x00\x00\x1b" +
+       "\xe1\f`\x00\x00\x00\x00\x1c\x87)`\x00\x00\x00\x00\x1d\xc0\xee`\x00\x00\x00\x00\x1eg\v`\x00\x00\x00\x00\x1f\xa0\xd0`\x00\x00\x00\x00 F\xed`\x00\x00\x00\x00!\x80\xb2`\x00\x00\x00\x00\"0\t\xe0\x00" +
+       "\x00\x00\x00#i\xce\xe0\x00\x00\x00\x00$\x0f\xeb\xe0\x00\x00\x00\x00%.\x01`\x00\x00\x00\x00&\x02B\xe0\x00\x00\x00\x00'\r\xe3`\x00\x00\x00\x00'\xe2$\xe0\x00\x00\x00\x00(\xed\xc5`\x00\x00\x00\x00)" +
+       "\xc2\x06\xe0\x00\x00\x00\x00*ͧ`\x00\x00\x00\x00+\xab#`\x00\x00\x00\x00,\xad\x89`\x00\x00\x00\x00-\x8b\x05`\x00\x00\x00\x00.\x8dk`\x00\x00\x00\x00/j\xe7`\x00\x00\x00\x000mM`\x00" +
+       "\x00\x00\x001J\xc9`\x00\x00\x00\x002Vi\xe0\x00\x00\x00\x003*\xab`\x00\x00\x00\x0046K\xe0\x00\x00\x00\x005\n\x8d`\x00\x00\x00\x006\x16-\xe0\x00\x00\x00\x006\xf3\xa9\xe0\x00\x00\x00\x007" +
+       "\xf6\x0f\xe0\x00\x00\x00\x008Ӌ\xe0\x00\x00\x00\x009\xd5\xf1\xe0\x00\x00\x00\x00:\xb3m\xe0\x00\x00\x00\x00;\xbf\x0e`\x00\x00\x00\x00<\x93O\xe0\x00\x00\x00\x00=\x9e\xf0`\x00\x00\x00\x00>s1\xe0\x00" +
+       "\x00\x00\x00?~\xd2`\x00\x00\x00\x00@\\N`\x00\x00\x00\x00A^\xb4`\x00\x00\x00\x00B<0`\x00\x00\x00\x00C>\x96`\x00\x00\x00\x00D\x1c\x12`\x00\x00\x00\x00E\x1ex`\x00\x00\x00\x00E" +
+       "\xfb\xf4`\x00\x00\x00\x00F\xfeZ`\x02\x01\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05" +
+       "\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x00\x00\xa3\xd8\x00\x00\x00\x00\xaf\xc8\x01\x04\x00" +
+       "\x00\xa1\xb8\x00\t\x00\x00\xa8\xc0\x01\x04\x00\x00\xb6\xd0\x01\x0e\x00\x00\xa8\xc0\x00\x04LMT\x00NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT,M9.5." +
+       "0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00\x0f\x00\x1c\x00Pacific/NorfolkUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x1e\xff" +
+       "\xff\xff\xff~6\x17\x88\xff\xff\xff\xff\xdcA\xf8\x80\x00\x00\x00\x00\t\x0f\xcah\x00\x00\x00\x00\t\xb5\xe7h\x00\x00\x00\x00V\x0f\xe6h\x00\x00\x00\x00]\x98\xaf\xf0\x01\x02\x03\x02\x04\x05\x00\x00\x9dx\x00\x00\x00" +
+       "\x00\x9d\x80\x00\x04\x00\x00\xa1\xb8\x00\n\x00\x00\xaf\xc8\x01\x10\x00\x00\x9a\xb0\x00\x16\x00\x00\xa8\xc0\x01\x1aLMT\x00+1112\x00+1130\x00+1230\x00+11\x00+12\x00\n" +
+       "<+11>-11<+12>,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\x06\x00\x1c" +
+       "\x00PolandUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x03\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xff~7H\x80\x00\x00\x00\x00\x12U\xf2\x00\x00\x00\x00\x00/\x05+\xa0\x01\x02\x03\xff\xffl\x80\x00\x00\xff\xffj\x00\x00\x04\xff\xffs`\x00\n\x00\x00\xc4\xe0\x00" +
-       "\x0eLMT\x00-1040\x00-10\x00+14\x00\n<+14>-14\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ3\x03\x1f\f\xac\x00\x00\x00\xac\x00\x00\x00\x11\x00\x1c\x00P" +
-       "acific/EnderburyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff~7Ud\x00\x00\x00\x00\x12V\x04\xc0\x00\x00\x00\x00/\x059\xb0\x01\x02\x03\xff\xff_\x9c\x00\x00\xff\xffW@\x00\x04\xff\xff" +
-       "eP\x00\b\x00\x00\xb6\xd0\x00\fLMT\x00-12\x00-11\x00+13\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ>\xfe垛\x03\x00\x00\x9b\x03" +
-       "\x00\x00\x06\x00\x1c\x00PolandUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00R\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xd0P\xff\xff\xff\xff\x99\xa8*\xd0\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d" +
-       "\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa0\x9a\xb6\x00\xff\xff\xff\xff\xa1e\xbd\x00\xff\xff\xff\xff\xa6}|`\xff\xff\xff\xff\xc8v\xde\x10\xff\xff\xff\xff\xcc\xe7K\x10\xff" +
-       "\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЄ\xba\x00\xff\xff\xff\xffѕ\x92p\xff\xff\xff\xffҊ\xbb`\xff\xff\xff\xff\xd3b\xffp\xff\xff\xff\xff\xd4" +
-       "K#\x90\xff\xff\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff\xe8T\xd2\x00\xff" +
-       "\xff\xff\xff\xe8\xf1\xb4\x80\xff\xff\xff\xff\xe9᥀\xff\xff\xff\xff\xeaі\x80\xff\xff\xff\xff\xec\x14\x96\x00\xff\xff\xff\xff캳\x00\xff\xff\xff\xff\xed\xaa\xa4\x00\xff\xff\xff\xff\ue695\x00\xff\xff\xff\xff\xef" +
-       "\xd4Z\x00\xff\xff\xff\xff\xf0zw\x00\xff\xff\xff\xff\xf1\xb4<\x00\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3\x94\x1e\x00\xff\xff\xff\xff\xf4:;\x00\xff\xff\xff\xff\xf5}:\x80\xff\xff\xff\xff\xf6\x1a\x1d\x00\x00" +
-       "\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T\n\x80\x00\x00\x00\x00\x13M6\x00\x00\x00\x00\x00\x14" +
-       "3\xec\x80\x00\x00\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00" +
-       "\x00\x00\x00\x1b\xbc\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"" +
+       "\x00R\x00\x00\x00\x06\x00\x00\x00\x1a\xff\xff\xff\xffV\xb6\xd0P\xff\xff\xff\xff\x99\xa8*\xd0\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff" +
+       "\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xa0\x9a\xb6\x00\xff\xff\xff\xff\xa1e\xbd\x00\xff\xff\xff\xff\xa6}|`\xff\xff\xff\xff\xc8v\xde\x10\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ" +
+       "\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЄ\xba\x00\xff\xff\xff\xffѕ\x92p\xff\xff\xff\xffҊ\xbb`\xff\xff\xff\xff\xd3b\xffp\xff\xff\xff\xff\xd4K#\x90\xff\xff" +
+       "\xff\xff\xd5^\xad\x10\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\xff\xff\xff\xff\xe8T\xd2\x00\xff\xff\xff\xff\xe8\xf1" +
+       "\xb4\x80\xff\xff\xff\xff\xe9᥀\xff\xff\xff\xff\xeaі\x80\xff\xff\xff\xff\xec\x14\x96\x00\xff\xff\xff\xff캳\x00\xff\xff\xff\xff\xed\xaa\xa4\x00\xff\xff\xff\xff\ue695\x00\xff\xff\xff\xff\xef\xd4Z\x00\xff\xff" +
+       "\xff\xff\xf0zw\x00\xff\xff\xff\xff\xf1\xb4<\x00\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3\x94\x1e\x00\xff\xff\xff\xff\xf4:;\x00\xff\xff\xff\xff\xf5}:\x80\xff\xff\xff\xff\xf6\x1a\x1d\x00\x00\x00\x00\x00\r\xa4" +
+       "U\x80\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T\n\x80\x00\x00\x00\x00\x13M6\x00\x00\x00\x00\x00\x143\xec\x80\x00\x00" +
+       "\x00\x00\x15#݀\x00\x00\x00\x00\x16\x13\u0380\x00\x00\x00\x00\x17\x03\xbf\x80\x00\x00\x00\x00\x17\xf3\xb0\x80\x00\x00\x00\x00\x18㡀\x00\x00\x00\x00\x19Ӓ\x80\x00\x00\x00\x00\x1aÃ\x80\x00\x00\x00\x00\x1b\xbc" +
+       "\xaf\x00\x00\x00\x00\x00\x1c\xac\xa0\x00\x00\x00\x00\x00\x1d\x9c\x91\x00\x00\x00\x00\x00\x1e\x8c\x82\x00\x00\x00\x00\x00\x1f|s\x00\x00\x00\x00\x00 ld\x00\x00\x00\x00\x00!\\U\x00\x00\x00\x00\x00\"LT\x10\x00\x00" +
+       "\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5" +
+       "\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00" +
+       "\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x13\xb0\x00\x00\x00\x00\x13\xb0\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00*0\x01\x11\x00\x00" +
+       "\x1c \x00\x16LMT\x00WMT\x00CEST\x00CET\x00EEST\x00EET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\b\x00\x1c\x00PortugalUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xff^=\f\x1d\xff\xff\xff\xff\x92掀\xff\xff\xff\xff\x9b" +
+       "Kmp\xff\xff\xff\xff\x9b\xfeǀ\xff\xff\xff\xff\x9c\x9c\xedp\xff\xff\xff\xff\x9dɃp\xff\xff\xff\xff\x9e\u007frp\xff\xff\xff\xff\x9f\xaa\xb6\xf0\xff\xff\xff\xff\xa0_Tp\xff\xff\xff\xff\xa1\x8b\xeap\xff" +
+       "\xff\xff\xff\xa2A\xd9p\xff\xff\xff\xff\xa3nop\xff\xff\xff\xff\xa4#\f\xf0\xff\xff\xff\xff\xa5O\xa2\xf0\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xf4\x8e\xf0\xff\xff\xff\xff\xadɧ\xf0\xff\xff\xff\xff\xae" +
+       "\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff\xff\xb72Lp\xff" +
+       "\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0\xff\xff\xff\xff\xc0" +
+       "\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff\xc7X\xacp\xff" +
+       "\xff\xff\xff\xc7\xd9\xdfp\xff\xff\xff\xff\xc9\x01/p\xff\xff\xff\xff\xc9\xf1 p\xff\xff\xff\xff\xca\xe2b\xf0\xff\xff\xff\xff˵R\xf0\xff\xff\xff\xff\xcb\xec\xa3\xe0\xff\xff\xff\xff̀K\xe0\xff\xff\xff\xff\xcc" +
+       "ܢ\xf0\xff\xff\xff\xff͕4\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xff\xcer\xa2\xe0\xff\xff\xff\xff\xceſp\xff\xff\xff\xff\xcfu\x16\xf0\xff\xff\xff\xffϬg\xe0\xff\xff\xff\xff\xd0R\x84\xe0\xff" +
+       "\xff\xff\xffХ\xa1p\xff\xff\xff\xff\xd1T\xf8\xf0\xff\xff\xff\xffьI\xe0\xff\xff\xff\xff\xd22f\xe0\xff\xff\xff\xff҅\x83p\xff\xff\xff\xff\xd3Y\xc4\xf0\xff\xff\xff\xff\xd4I\xb5\xf0\xff\xff\xff\xff\xd5" +
+       "9\xd1 \xff\xff\xff\xff\xd6)\xc2 \xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8\t\xa4 \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xd9\xe9\x86 \xff\xff\xff\xffܹY \xff\xff\xff\xffݲ\x84\xa0\xff" +
+       "\xff\xff\xffޢu\xa0\xff\xff\xff\xffߒf\xa0\xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4B\x1b\xa0\xff\xff\xff\xff\xe5" +
+       "2\f\xa0\xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff\xeb\xca\xde \xff" +
+       "\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff\xf0z\x93 \xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2c\xaf\xa0\xff\xff\xff\xff\xf3" +
+       "S\xa0\xa0\xff\xff\xff\xff\xf4C\x91\xa0\xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6#s\xa0\xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x03U\xa0\xff\xff\xff\xff\xf8\xf3F\xa0\x00\x00\x00\x00\f\xab*\x00\x00" +
+       "\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13C\xfb\x80\x00\x00\x00\x00\x14" +
+       "3\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㽠\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00" +
+       "\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"" +
        "LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00" +
        "\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000" +
-       "d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x03\x02\x03\x02\x03\x02\x05\x04\x05\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x00\x00\x13\xb0\x00\x00\x00\x00\x13\xb0\x00\x04\x00\x00\x1c \x01\b\x00\x00\x0e\x10\x00\r\x00\x00*" +
-       "0\x01\x11\x00\x00\x1c \x00\x16LMT\x00WMT\x00CEST\x00CET\x00EEST\x00EET\x00\nCET-1CEST,M3.5.0,M10.5.0" +
-       "/3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\b\x00\x1c\x00PortugalUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x06\x00\x00\x00\x1b\xff\xff\xff\xff^=\f\x1d\xff\xff\xff\xff\x92掀" +
-       "\xff\xff\xff\xff\x9bKmp\xff\xff\xff\xff\x9b\xfeǀ\xff\xff\xff\xff\x9c\x9c\xedp\xff\xff\xff\xff\x9dɃp\xff\xff\xff\xff\x9e\u007frp\xff\xff\xff\xff\x9f\xaa\xb6\xf0\xff\xff\xff\xff\xa0_Tp\xff\xff\xff\xff" +
-       "\xa1\x8b\xeap\xff\xff\xff\xff\xa2A\xd9p\xff\xff\xff\xff\xa3nop\xff\xff\xff\xff\xa4#\f\xf0\xff\xff\xff\xff\xa5O\xa2\xf0\xff\xff\xff\xff\xaa\x05\xefp\xff\xff\xff\xff\xaa\xf4\x8e\xf0\xff\xff\xff\xff\xadɧ\xf0" +
-       "\xff\xff\xff\xff\xae\xa7#\xf0\xff\xff\xff\xff\xaf\xa0Op\xff\xff\xff\xff\xb0\x87\x05\xf0\xff\xff\xff\xff\xb1\x89k\xf0\xff\xff\xff\xff\xb2p\"p\xff\xff\xff\xff\xb3r\x88p\xff\xff\xff\xff\xb4P\x04p\xff\xff\xff\xff" +
-       "\xb72Lp\xff\xff\xff\xff\xb8\x0f\xc8p\xff\xff\xff\xff\xb8\xff\xb9p\xff\xff\xff\xff\xb9\xef\xaap\xff\xff\xff\xff\xbcȷ\xf0\xff\xff\xff\xff\xbd\xb8\xa8\xf0\xff\xff\xff\xff\xbe\x9f_p\xff\xff\xff\xff\xbf\x98\x8a\xf0" +
-       "\xff\xff\xff\xff\xc0\x9a\xf0\xf0\xff\xff\xff\xff\xc1xl\xf0\xff\xff\xff\xff\xc2h]\xf0\xff\xff\xff\xff\xc3XN\xf0\xff\xff\xff\xff\xc4?\x05p\xff\xff\xff\xff\xc580\xf0\xff\xff\xff\xff\xc6:\x96\xf0\xff\xff\xff\xff" +
-       "\xc7X\xacp\xff\xff\xff\xff\xc7\xd9\xdfp\xff\xff\xff\xff\xc9\x01/p\xff\xff\xff\xff\xc9\xf1 p\xff\xff\xff\xff\xca\xe2b\xf0\xff\xff\xff\xff˵R\xf0\xff\xff\xff\xff\xcb\xec\xa3\xe0\xff\xff\xff\xff̀K\xe0" +
-       "\xff\xff\xff\xff\xccܢ\xf0\xff\xff\xff\xff͕4\xf0\xff\xff\xff\xff\xcd\xc3K`\xff\xff\xff\xff\xcer\xa2\xe0\xff\xff\xff\xff\xceſp\xff\xff\xff\xff\xcfu\x16\xf0\xff\xff\xff\xffϬg\xe0\xff\xff\xff\xff" +
-       "\xd0R\x84\xe0\xff\xff\xff\xffХ\xa1p\xff\xff\xff\xff\xd1T\xf8\xf0\xff\xff\xff\xffьI\xe0\xff\xff\xff\xff\xd22f\xe0\xff\xff\xff\xff҅\x83p\xff\xff\xff\xff\xd3Y\xc4\xf0\xff\xff\xff\xff\xd4I\xb5\xf0" +
-       "\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd6)\xc2 \xff\xff\xff\xff\xd7\x19\xb3 \xff\xff\xff\xff\xd8\t\xa4 \xff\xff\xff\xff\xd8\xf9\x95 \xff\xff\xff\xff\xd9\xe9\x86 \xff\xff\xff\xffܹY \xff\xff\xff\xff" +
-       "ݲ\x84\xa0\xff\xff\xff\xffޢu\xa0\xff\xff\xff\xffߒf\xa0\xff\xff\xff\xff\xe0\x82W\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2b9\xa0\xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4B\x1b\xa0" +
-       "\xff\xff\xff\xff\xe52\f\xa0\xff\xff\xff\xff\xe6!\xfd\xa0\xff\xff\xff\xff\xe7\x1b) \xff\xff\xff\xff\xe8\v\x1a \xff\xff\xff\xff\xe8\xfb\v \xff\xff\xff\xff\xe9\xea\xfc \xff\xff\xff\xff\xea\xda\xed \xff\xff\xff\xff" +
-       "\xeb\xca\xde \xff\xff\xff\xff\xec\xba\xcf \xff\xff\xff\xff\xed\xaa\xc0 \xff\xff\xff\xff\ue6b1 \xff\xff\xff\xff\uf2a2 \xff\xff\xff\xff\xf0z\x93 \xff\xff\xff\xff\xf1j\x84 \xff\xff\xff\xff\xf2c\xaf\xa0" +
-       "\xff\xff\xff\xff\xf3S\xa0\xa0\xff\xff\xff\xff\xf4C\x91\xa0\xff\xff\xff\xff\xf53\x82\xa0\xff\xff\xff\xff\xf6#s\xa0\xff\xff\xff\xff\xf7\x13d\xa0\xff\xff\xff\xff\xf8\x03U\xa0\xff\xff\xff\xff\xf8\xf3F\xa0\x00\x00\x00\x00" +
-       "\f\xab*\x00\x00\x00\x00\x00\r\x9b\x1b\x00\x00\x00\x00\x00\x0e\x8b\f\x00\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x10t(\x80\x00\x00\x00\x00\x11d\x19\x80\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13C\xfb\x80" +
-       "\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㽠\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00" +
-       "\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10" +
-       "\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00" +
-       "(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90" +
-       "\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x05\x04\x05\x04\x05\x04\x01\xff\xff\xf7c\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\t\x00\x00\x1c \x01\r\x00" +
-       "\x00\x0e\x10\x00\x12\x00\x00\x1c \x01\x16LMT\x00WEST\x00WET\x00WEMT\x00CET\x00CEST\x00\nWET0WEST,M3.5.0/1,M10" +
-       ".5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\x03\x00\x1c\x00ROCUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
-       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xfft\xce\xf0\x18\xff\xff\xff\xff\xc3UI\x80\xff\xff\xff" +
-       "\xff\xd2TY\x80\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2" +
-       "\x80\xff\xff\xff\xff\xd9\xe7\x99\xf0\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xdb\xc8\xcdp\xff\xff\xff\xff\xdc\xe0Y\x80\xff\xff\xff\xffݪ\x00\xf0\xff\xff\xff\xff\xders\x00\xff\xff\xff\xffߵdp\xff\xff\xff" +
-       "\xff\xe0|\x85\x00\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2]\xb8\x80\xff\xff\xff\xff\xe3w\xcbp\xff\xff\xff\xff\xe4>\xec\x00\xff\xff\xff\xff\xe50 p\xff\xff\xff\xff\xe6!q\x00\xff\xff\xff\xff\xe7\x12\xa5" +
-       "p\xff\xff\xff\xff\xe8\x02\xa4\x80\xff\xff\xff\xff\xe8\xf3\xd8\xf0\xff\xff\xff\xff\xe9\xe3\xd8\x00\xff\xff\xff\xff\xea\xd5\fp\xff\xff\xff\xff\xeb\xc5\v\x80\xff\xff\xff\xff\xec\xb6?\xf0\xff\xff\xff\xff\xed\xf7\xfc\x00\xff\xff\xff" +
-       "\xff\xee\x98\xc4\xf0\xff\xff\xff\xff\xef\xd9/\x80\xff\xff\xff\xff\xf0y\xf8p\x00\x00\x00\x00\a\xfcV\x00\x00\x00\x00\x00\b\xed\x8ap\x00\x00\x00\x00\t݉\x80\x00\x00\x00\x00\nν\xf0\x00\x00\x00\x00\x11ۡ" +
-       "\x80\x00\x00\x00\x00\x12T\xddp\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x00\x00q\xe8\x00\x00\x00\x00p\x80" +
-       "\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x01\fLMT\x00CST\x00JST\x00CDT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xc7X,Y\x9f\x01\x00\x00\x9f" +
-       "\x01\x00\x00\x03\x00\x1c\x00ROKUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x1d\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\x8b\xd7\xf0x\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2C'\xf0\xff\xff\xff\xff\xd7e\x8fp\xff\xff\xff\xff\xd7\xee\x9d`\xff\xff\xff\xff\xd8\xf8\xfa" +
-       "p\xff\xff\xff\xff\xd9\xcd-\xe0\xff\xff\xff\xff\xda\u05ca\xf0\xff\xff\xff\xffۭ\x0f\xe0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff\xff\xff\u074c\xf1\xe0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe4k\xb7\xf8\xff\xff\xff" +
-       "\xff\xe5\x13\x18h\xff\xff\xff\xff\xe6b\x03x\xff\xff\xff\xff\xe7\x11L\xe8\xff\xff\xff\xff\xe8/px\xff\xff\xff\xff\xe8\xe7\xf4h\xff\xff\xff\xff\xea\x0fRx\xff\xff\xff\xff\xea\xc7\xd6h\xff\xff\xff\xff\xeb\xef4" +
-       "x\xff\xff\xff\xff째h\xff\xff\xff\xff\xed\xcf\x16x\xff\xff\xff\xff\ue1dah\xff\xff\xff\xff\xf05qx\x00\x00\x00\x00 \xa3`\x90\x00\x00\x00\x00!ng\x90\x00\x00\x00\x00\"\x83B\x90\x00\x00\x00" +
-       "\x00#NI\x90\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x04\x03\x04\x03\x04\x00\x00w\b\x00\x00\x00\x00w\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x01\f\x00\x00" +
-       "~\x90\x00\x04\x00\x00\x85\x98\x01\fLMT\x00KST\x00JST\x00KDT\x00\nKST-9\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\t" +
-       "\x00\x1c\x00SingaporeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00 \xff\xff\xff\xff~6S\xa3\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xff\xcb" +
-       "\x91_\b\xff\xff\xff\xff\xd2Hm\xf0\x00\x00\x00\x00\x16\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00a]\x00\x00\x00\x00a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00i" +
-       "x\x00\x12\x00\x00~\x90\x00\x18\x00\x00p\x80\x00\x1cLMT\x00SMT\x00+07\x00+0720\x00+0730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x1c\x00TurkeyUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x19\xff\xff\xff\xffV\xb6\xc8\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff" +
-       "\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa" +
-       "((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff\xff\xab\xf9\x89\xe0\xff\xff\xff\xff\xac\xc31P\xff\xff\xff\xffȁ?\xe0\xff\xff\xff\xff\xc9\x01\x13P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff" +
-       "\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\tP\xff\xff\xff\xffӢ9`\xff\xff\xff\xff\xd4C\x02P\xff\xff\xff\xff\xd5L\r\xe0\xff\xff\xff\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8" +
-       "\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff\xff\xd9\xe9?\xd0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff\xdb\xd2\\P\xff\xff\xff\xff\xdc\xd4\xd0`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff" +
-       "\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06`\xff\xff\xff\xff\xf6\x1f8\xd0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00\a9\x9ap\x00\x00\x00\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t" +
-       "\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00\x00\v\xb1\xfe\x80\x00\x00\x00\x00\f\xd9@p\x00\x00\x00\x00\r\xa4U\x80\x00\x00\x00\x00\x0e\xa6\xadp\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00" +
-       "\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ\xe0\x00\x00\x00\x00\x1b\xe6\xd0\xf0\x00\x00\x00\x00\x1c\xc6\xef\xf0\x00\x00\x00\x00\x1d\x9b1p\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 " +
-       "lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00" +
-       "\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00." +
-       "\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00" +
-       "\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<" +
-       "\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00" +
-       "\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J" +
-       "\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8fݐ\x00\x00\x00\x00N\xac\xa1\x90\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00" +
-       "\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe\x10\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00V>\x9e\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02" +
-       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
-       "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh" +
-       "\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00*0\x00\x11\x00\x008@\x01\x15LMT\x00IMT\x00EEST\x00EET\x00+03\x00+04\x00\n<+03>-3\n" +
-       "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00UCTUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
+       "d\xad\x90\x00\x00\x00\x001]\xd9\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01" +
+       "\x03\x01\x02\x01\x03\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x05\x04\x05\x04\x05\x04\x01\xff\xff\xf7c\x00\x00\x00\x00\x0e\x10\x01\x04\x00\x00\x00\x00\x00\t\x00\x00\x1c \x01\r\x00\x00\x0e\x10\x00\x12" +
+       "\x00\x00\x1c \x01\x16LMT\x00WEST\x00WET\x00WEMT\x00CET\x00CEST\x00\nWET0WEST,M3.5.0/1,M10.5.0\n" +
+       "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x03\x00\x1c\x00PRCUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
        "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x1c\x00US/UT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x03\x04\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\t\x00\x1c\x00US/AlaskaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00(\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87AH\xff\xff\xff\xffˉ6\xc0\xff" +
-       "\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aB0\xff\xff\xff\xff\xfa\xd2G\xa0\xff\xff\xff\xff\xfe\xb8c@\xff\xff\xff\xff\xff\xa8F0\x00\x00\x00\x00\x00\x98E@\x00\x00\x00\x00\x01\x88(0\x00\x00\x00\x00\x02" +
-       "x'@\x00\x00\x00\x00\x03qD\xb0\x00\x00\x00\x00\x04aC\xc0\x00\x00\x00\x00\x05Q&\xb0\x00\x00\x00\x00\x06A%\xc0\x00\x00\x00\x00\a1\b\xb0\x00\x00\x00\x00\a\x8d_\xc0\x00\x00\x00\x00\t\x10\xea\xb0\x00" +
-       "\x00\x00\x00\t\xad\xdb@\x00\x00\x00\x00\n\xf0̰\x00\x00\x00\x00\v\xe0\xcb\xc0\x00\x00\x00\x00\f\xd9\xe90\x00\x00\x00\x00\r\xc0\xad\xc0\x00\x00\x00\x00\x0e\xb9\xcb0\x00\x00\x00\x00\x0f\xa9\xca@\x00\x00\x00\x00\x10" +
-       "\x99\xad0\x00\x00\x00\x00\x11\x89\xac@\x00\x00\x00\x00\x12y\x8f0\x00\x00\x00\x00\x13i\x8e@\x00\x00\x00\x00\x14Yq0\x00\x00\x00\x00\x15Ip@\x00\x00\x00\x00\x169S0\x00\x00\x00\x00\x17)R@\x00" +
-       "\x00\x00\x00\x18\"o\xb0\x00\x00\x00\x00\x19\t4@\x00\x00\x00\x00\x1a\x02Q\xb0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d" +
-       "\xc2\a\xa0\x00\x00\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00" +
-       "\x00\x00\x00%J\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+" +
-       "\xbe\xbf\xb0\x00\x00\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00" +
-       "\x00\x00\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009" +
-       "\xfb\xf5 \x00\x00\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00" +
-       "\x00\x00\x00A\x84\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t" +
-       "\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xc4\xf8\x00\x00\xff\xffsx\x00\x00\xff\xffs`\x00\x04\xff\xff\x81p\x01\b\xff\xff\x81p\x01\f\xff\xffs`\x00\x10\xff\xff\x81p\x01\x15\xff\xff\x81p\x00\x1a\xff" +
-       "\xff\x8f\x80\x01\x1e\xff\xff\x81p\x00#LMT\x00AST\x00AWT\x00APT\x00AHST\x00AHDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKD" +
-       "T,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x1c\x00US/PacificUT\t" +
-       "\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14" +
-       "\xff\xff\xff\xff^\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff" +
-       "\xd2a&\x10\xff\xff\xff\xff\xd6\xfet\\\xff\xff\xff\xff\u0600\xad\x90\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x87\x90" +
-       "\xff\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff" +
-       "\xe6GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10" +
-       "\xff\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fА\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xb2\x90\xff\xff\xff\xff" +
-       "\xf4_\xa3\x90\xff\xff\xff\xff\xf5O\x94\x90\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 " +
-       "\xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00" +
-       "\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ" +
-       "\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00" +
-       "\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 " +
-       "\x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00" +
-       "\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10" +
-       "\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00" +
-       ",\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt " +
-       "\x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00" +
-       ":\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90" +
-       "\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x91&\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f" +
-       "\x80\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nP" +
-       "K\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\n\x00\x1c\x00US/EasternUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZ" +
-       "if2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x03\xf0\x90\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff" +
-       "\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1\x9a\xcd`\xff\xff\xff\xff\xa2e\xe2p\xff\xff\xff\xff\xa3\x83\xe9\xe0\xff\xff\xff\xff\xa4j\xaep\xff\xff\xff\xff\xa55\xa7`\xff\xff\xff\xff\xa6S" +
-       "\xca\xf0\xff\xff\xff\xff\xa7\x15\x89`\xff\xff\xff\xff\xa83\xac\xf0\xff\xff\xff\xff\xa8\xfe\xa5\xe0\xff\xff\xff\xff\xaa\x13\x8e\xf0\xff\xff\xff\xff\xaaއ\xe0\xff\xff\xff\xff\xab\xf3p\xf0\xff\xff\xff\xff\xac\xbei\xe0\xff\xff" +
-       "\xff\xff\xad\xd3R\xf0\xff\xff\xff\xff\xae\x9eK\xe0\xff\xff\xff\xff\xaf\xb34\xf0\xff\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G" +
-       ",`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7;\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9\x1b\xd9p\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff" +
-       "\xff\xff\xbbƴ`\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084" +
-       "}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5/X\xe0\xff\xff\xff\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xff\xc8\xf8W`\xff\xff" +
-       "\xff\xff\xca\r@p\xff\xff\xff\xff\xca\xd89`\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U" +
-       "\xc6\xf0\xff\xff\xff\xff\xd6 \xbf\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xd9\x15\x8a\xf0\xff\xff\xff\xff\xd9\xe0\x83\xe0\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdb\xc0e\xe0\xff\xff" +
-       "\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I" +
-       "(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5W.\xe0\xff\xff\xff\xff\xe6G-\xf0\xff\xff\xff\xff\xe77\x10\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff" +
-       "\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f" +
-       "\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff" +
-       "\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7" +
-       "\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00" +
-       "\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0" +
-       "gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00" +
-       "\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1" +
-       "\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00" +
-       "\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)\xde" +
-       "\xa5p\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00" +
-       "\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b" +
-       "\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00" +
-       "\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3" +
-       "\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xba" +
-       "\x9e\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2" +
-       ".0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x1c\x00US/MichiganUT\t\x00\x03\xec,\x94" +
-       "_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
-       "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff\x85" +
-       "\xbd\"[\xff\xff\xff\xff\x99<\x94\x00\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0\xff\xff\xff\xff\xfb3\x90\x8c\xff" +
-       "\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00\x00\x00\x00\n" +
-       "\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10\x99f\xe0\x00" +
-       "\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00\x00\x00\x00\x18" +
-       "\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e\xb1\xcep\x00" +
-       "\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00\x00\x00\x00&" +
-       "\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00,\xd3T`\x00" +
-       "\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00\x00\x00\x004" +
-       "R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:\xc6\xd1\xf0\x00" +
-       "\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00B" +
-       "O\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02" +
-       "\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\xff\xff\xb2%\x00" +
-       "\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00EST\x00EWT\x00EPT\x00EDT\x00\nEST5" +
-       "EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\n\x00\x1c\x00US/ArizonaU" +
-       "T\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x04\x00\x00" +
-       "\x00\x10\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xcf\x17\xdf\x1c\xff\xff" +
-       "\xff\xffϏ\xe5\xac\xff\xff\xff\xffЁ\x1a\x1c\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\x02\x01\x02\x01\x02\x03\x02\x03\x02\x01\x02\xff\xff\x96\xee\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff" +
-       "\xff\xab\xa0\x01\fLMT\x00MDT\x00MST\x00MWT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x11\x00\x1c\x00US/" +
-       "Indiana-StarkeUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff" +
-       "\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99" +
-       "\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff" +
-       "\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e" +
-       "\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff" +
-       "\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I" +
-       "\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00" +
-       "\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94" +
-       "p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00" +
-       "\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc" +
-       "\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00" +
-       "\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81" +
-       "\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CS" +
-       "T\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9\x03\x00\x00" +
-       "\xc9\x03\x00\x00\v\x00\x1c\x00US/AleutianUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a" +
-       "P@\xff\xff\xff\xff\xfa\xd2U\xb0\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00" +
-       "\x00\x00\x04aQ\xd0\x00\x00\x00\x00\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0" +
-       "\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00" +
-       "\x00\x00\x12y\x9d@\x00\x00\x00\x00\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\t" +
-       "BP\x00\x00\x00\x00\x1a\x02_\xc0\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00\x1a\xf2P\xc0\x00\x00\x00\x00\x1b\xe23\xb0\x00\x00\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00" +
-       "\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00 vG@\x00\x00\x00\x00!\x81ٰ\x00\x00\x00\x00\"V)@\x00\x00\x00\x00#j\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15" +
-       "\xed@\x00\x00\x00\x00'*\xba0\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00)\n\x9c0\x00\x00\x00\x00)\xde\xeb\xc0\x00\x00\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00" +
-       "\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00.\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0\x00\x00\x00\x000\x93^\xb0\x00\x00\x00\x001g\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S" +
-       "\"\xb0\x00\x00\x00\x005'r@\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x007\aT@\x00\x00\x00\x008\x1c!0\x00\x00\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00" +
-       "\x00\x00;\xdb\xe50\x00\x00\x00\x00<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70\x00\x00\x00\x00>\x90\x16\xc0\x00\x00\x00\x00?\x9b\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO" +
-       "\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00ED\x89\xb0\x00\x00\x00\x00E\xf3\xef@\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05" +
-       "\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00" +
-       "\xab\xe2\x00\x00\xff\xffZb\x00\x00\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xffs`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LM" +
-       "T\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST10HDT,M3.2.0,M11.1.0\nPK\x03\x04" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\t\x00\x1c\x00US/HawaiiUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!" +
-       "qX\xff\xff\xff\xffˉ=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff\xffՍsH\x01\x02\x01\x03\x04\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff" +
-       "\xffzh\x01\f\xff\xffzh\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00HWT\x00HPT\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQp\xb6" +
-       "{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00\x1c\x00US/East-IndianaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZi" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff~6C)\xff\xff\xff\xff\xa0\x97\xa2\x80\xff\xff\xff\xff\xa1y\x04\xf0" +
+       "\xff\xff\xff\xff\xc8Y^\x80\xff\xff\xff\xff\xc9\t\xf9p\xff\xff\xff\xff\xc9ӽ\x00\xff\xff\xff\xff\xcb\x05\x8a\xf0\xff\xff\xff\xff\xcb|@\x00\xff\xff\xff\xff\xd2;>\xf0\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff" +
+       "\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9A|\xf0\x00\x00\x00\x00\x1e\xbaR " +
+       "\x00\x00\x00\x00\x1fi\x9b\x90\x00\x00\x00\x00 ~\x84\xa0\x00\x00\x00\x00!I}\x90\x00\x00\x00\x00\"g\xa1 \x00\x00\x00\x00#)_\x90\x00\x00\x00\x00$G\x83 \x00\x00\x00\x00%\x12|\x10\x00\x00\x00\x00" +
+       "&'e \x00\x00\x00\x00&\xf2^\x10\x00\x00\x00\x00(\aG \x00\x00\x00\x00(\xd2@\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00q" +
+       "\xd7\x00\x00\x00\x00~\x90\x01\x04\x00\x00p\x80\x00\bLMT\x00CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9RŭV\xad\xb7\x03\x00\x00\xb7\x03\x00\x00" +
+       "\a\x00\x1c\x00PST8PDTUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00X\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#" +
+       "\xf4p\xff\xff\xff\xff\xd2a&\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00" +
+       "\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0" +
+       "\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00" +
+       "\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15I" +
+       "T \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00" +
+       "\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j" +
+       "\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00" +
+       "\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00,\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g" +
+       "\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00" +
+       "\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b" +
+       "\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x01\x00" +
+       "\x01\x00\x02\x03\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01" +
+       "\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xff\xff\x8f\x80\x00\x04\xff\xff\x9d\x90\x01\x00\xff\xff\x9d\x90\x01\b\xff\xff\x9d\x90\x01\fPDT\x00PST\x00PW" +
+       "T\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\x03\x00\x1c\x00" +
+       "ROCUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)\x00\x00" +
+       "\x00\x04\x00\x00\x00\x10\xff\xff\xff\xfft\xce\xf0\x18\xff\xff\xff\xff\xc3UI\x80\xff\xff\xff\xff\xd2TY\x80\xff\xff\xff\xffӋ{\x80\xff\xff\xff\xff\xd4B\xad\xf0\xff\xff\xff\xff\xd5E\"\x00\xff\xff\xff\xff\xd6L" +
+       "\xbf\xf0\xff\xff\xff\xff\xd7<\xbf\x00\xff\xff\xff\xff\xd8\x06fp\xff\xff\xff\xff\xd9\x1d\xf2\x80\xff\xff\xff\xff\xd9\xe7\x99\xf0\xff\xff\xff\xff\xda\xff&\x00\xff\xff\xff\xff\xdb\xc8\xcdp\xff\xff\xff\xff\xdc\xe0Y\x80\xff\xff" +
+       "\xff\xffݪ\x00\xf0\xff\xff\xff\xff\xders\x00\xff\xff\xff\xffߵdp\xff\xff\xff\xff\xe0|\x85\x00\xff\xff\xff\xffᖗ\xf0\xff\xff\xff\xff\xe2]\xb8\x80\xff\xff\xff\xff\xe3w\xcbp\xff\xff\xff\xff\xe4>" +
+       "\xec\x00\xff\xff\xff\xff\xe50 p\xff\xff\xff\xff\xe6!q\x00\xff\xff\xff\xff\xe7\x12\xa5p\xff\xff\xff\xff\xe8\x02\xa4\x80\xff\xff\xff\xff\xe8\xf3\xd8\xf0\xff\xff\xff\xff\xe9\xe3\xd8\x00\xff\xff\xff\xff\xea\xd5\fp\xff\xff" +
+       "\xff\xff\xeb\xc5\v\x80\xff\xff\xff\xff\xec\xb6?\xf0\xff\xff\xff\xff\xed\xf7\xfc\x00\xff\xff\xff\xff\xee\x98\xc4\xf0\xff\xff\xff\xff\xef\xd9/\x80\xff\xff\xff\xff\xf0y\xf8p\x00\x00\x00\x00\a\xfcV\x00\x00\x00\x00\x00\b\xed" +
+       "\x8ap\x00\x00\x00\x00\t݉\x80\x00\x00\x00\x00\nν\xf0\x00\x00\x00\x00\x11ۡ\x80\x00\x00\x00\x00\x12T\xddp\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03" +
+       "\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x00\x00q\xe8\x00\x00\x00\x00p\x80\x00\x04\x00\x00~\x90\x00\b\x00\x00~\x90\x01\fLMT\x00CST\x00JST\x00CDT\x00\nCST-" +
+       "8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\x03\x00\x1c\x00ROKUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x06\x00\x00\x00\x10\xff\xff\xff\xff\x8b\xd7\xf0x\xff\xff\xff\xff\x92\xe6\x16\xf8\xff\xff\xff\xff\xd2C" +
+       "'\xf0\xff\xff\xff\xff\xd7e\x8fp\xff\xff\xff\xff\xd7\xee\x9d`\xff\xff\xff\xff\xd8\xf8\xfap\xff\xff\xff\xff\xd9\xcd-\xe0\xff\xff\xff\xff\xda\u05ca\xf0\xff\xff\xff\xffۭ\x0f\xe0\xff\xff\xff\xff\xdc\xe6\xe2\xf0\xff\xff" +
+       "\xff\xff\u074c\xf1\xe0\xff\xff\xff\xff\xe2O)\xf0\xff\xff\xff\xff\xe4k\xb7\xf8\xff\xff\xff\xff\xe5\x13\x18h\xff\xff\xff\xff\xe6b\x03x\xff\xff\xff\xff\xe7\x11L\xe8\xff\xff\xff\xff\xe8/px\xff\xff\xff\xff\xe8\xe7" +
+       "\xf4h\xff\xff\xff\xff\xea\x0fRx\xff\xff\xff\xff\xea\xc7\xd6h\xff\xff\xff\xff\xeb\xef4x\xff\xff\xff\xff째h\xff\xff\xff\xff\xed\xcf\x16x\xff\xff\xff\xff\ue1dah\xff\xff\xff\xff\xf05qx\x00\x00" +
+       "\x00\x00 \xa3`\x90\x00\x00\x00\x00!ng\x90\x00\x00\x00\x00\"\x83B\x90\x00\x00\x00\x00#NI\x90\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x04\x03\x04\x03\x04\x00" +
+       "\x00w\b\x00\x00\x00\x00w\x88\x00\x04\x00\x00~\x90\x00\b\x00\x00\x8c\xa0\x01\f\x00\x00~\x90\x00\x04\x00\x00\x85\x98\x01\fLMT\x00KST\x00JST\x00KDT\x00\nKST-9\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\t\x00\x1c\x00SingaporeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
+       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00 \xff\xff\xff\xff~6S\xa3\xff\xff\xff\xff\x86\x83\x85\xa3\xff\xff\xff\xff" +
+       "\xbagN\x90\xff\xff\xff\xff\xc0\n\xe4`\xff\xff\xff\xffʳ\xe5`\xff\xff\xff\xffˑ_\b\xff\xff\xff\xff\xd2Hm\xf0\x00\x00\x00\x00\x16\x91\xf5\b\x01\x02\x03\x04\x05\x06\x05\a\x00\x00a]\x00\x00\x00\x00" +
+       "a]\x00\x04\x00\x00bp\x00\b\x00\x00g \x01\f\x00\x00g \x00\f\x00\x00ix\x00\x12\x00\x00~\x90\x00\x18\x00\x00p\x80\x00\x1cLMT\x00SMT\x00+07\x00+0720\x00+0" +
+       "730\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x1c\x00TurkeyUT\t" +
+       "\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x06\x00\x00\x00\x19" +
+       "\xff\xff\xff\xffV\xb6\xc8\xd8\xff\xff\xff\xff\x90\x8b\xf5\x98\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9bվ\xd0\xff\xff\xff\xff\xa2ec\xe0\xff\xff\xff\xff\xa3{\x82P\xff\xff\xff\xff\xa4N\x80`\xff\xff\xff\xff" +
+       "\xa5?\xb4\xd0\xff\xff\xff\xff\xa6%'\xe0\xff\xff\xff\xff\xa7'\u007f\xd0\xff\xff\xff\xff\xaa((`\xff\xff\xff\xff\xaa\xe1\xfd\xd0\xff\xff\xff\xff\xab\xf9\x89\xe0\xff\xff\xff\xff\xac\xc31P\xff\xff\xff\xffȁ?\xe0" +
+       "\xff\xff\xff\xff\xc9\x01\x13P\xff\xff\xff\xff\xc9J\xf5`\xff\xff\xff\xff\xca\u0380P\xff\xff\xff\xff\xcbˮ`\xff\xff\xff\xff\xd2k\tP\xff\xff\xff\xffӢ9`\xff\xff\xff\xff\xd4C\x02P\xff\xff\xff\xff" +
+       "\xd5L\r\xe0\xff\xff\xff\xff\xd6){\xd0\xff\xff\xff\xff\xd7+\xef\xe0\xff\xff\xff\xff\xd8\t]\xd0\xff\xff\xff\xff\xd9\x02\x97`\xff\xff\xff\xff\xd9\xe9?\xd0\xff\xff\xff\xff\xda\xeb\xb3\xe0\xff\xff\xff\xff\xdb\xd2\\P" +
+       "\xff\xff\xff\xff\xdc\xd4\xd0`\xff\xff\xff\xffݲ>P\xff\xff\xff\xff\xf1\xf4\xb9`\xff\xff\xff\xff\xf4b\xefP\xff\xff\xff\xff\xf5h\x06`\xff\xff\xff\xff\xf6\x1f8\xd0\x00\x00\x00\x00\x06n\x93p\x00\x00\x00\x00" +
+       "\a9\x9ap\x00\x00\x00\x00\a\xfbu\x00\x00\x00\x00\x00\t\x19|p\x00\x00\x00\x00\t\xd0\xcb\x00\x00\x00\x00\x00\n\xf9^p\x00\x00\x00\x00\v\xb1\xfe\x80\x00\x00\x00\x00\f\xd9@p\x00\x00\x00\x00\r\xa4U\x80" +
+       "\x00\x00\x00\x00\x0e\xa6\xadp\x00\x00\x00\x00\x0f\x847\x80\x00\x00\x00\x00\x0f\xf8\x11P\x00\x00\x00\x00\x19\x89\xb0p\x00\x00\x00\x00\x19ܰ\xe0\x00\x00\x00\x00\x1b\xe6\xd0\xf0\x00\x00\x00\x00\x1c\xc6\xef\xf0\x00\x00\x00\x00" +
+       "\x1d\x9b1p\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0" +
+       "\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\tp\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00" +
+       "+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x8b\x83\xf0\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0" +
+       "\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x00" +
+       "9\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap" +
+       "\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05ɐ\x00\x00\x00\x00G#\xdf\x10\x00\x00\x00\x00" +
+       "G\xee\xe6\x10\x00\x00\x00\x00I\x03\xc1\x10\x00\x00\x00\x00I\xce\xc8\x10\x00\x00\x00\x00J\xe3\xa3\x10\x00\x00\x00\x00K\xae\xaa\x10\x00\x00\x00\x00L̿\x90\x00\x00\x00\x00M\x8fݐ\x00\x00\x00\x00N\xac\xa1\x90" +
+       "\x00\x00\x00\x00Onn\x10\x00\x00\x00\x00P\x8c\x83\x90\x00\x00\x00\x00QW\x8a\x90\x00\x00\x00\x00Rle\x90\x00\x00\x00\x00S8\xbe\x10\x00\x00\x00\x00TLG\x90\x00\x00\x00\x00U\x17N\x90\x00\x00\x00\x00" +
+       "V>\x9e\x90\x00\x00\x00\x00V\xf70\x90\x00\x00\x00\x00W\xcf.P\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03" +
+       "\x02\x03\x02\x03\x02\x03\x02\x04\x05\x04\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02" +
+       "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x04\x00\x00\x1b(\x00\x00\x00\x00\x1bh\x00\x04\x00\x00*0\x01\b\x00\x00\x1c \x00\r\x00\x00*0\x00\x11\x00\x008@\x01\x15LMT\x00IMT\x00E" +
+       "EST\x00EET\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00UCTUT" +
+       "\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" +
+       "\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00UniversalUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00" +
+       "\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x1c\x00US/UT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x1c\x00US/PacificUT\t\x00" +
+       "\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00}\x00\x00\x00\x05\x00\x00\x00\x14\xff" +
+       "\xff\xff\xff^\x04\x1a\xc0\xff\xff\xff\xff\x9e\xa6H\xa0\xff\xff\xff\xff\x9f\xbb\x15\x90\xff\xff\xff\xff\xa0\x86*\xa0\xff\xff\xff\xff\xa1\x9a\xf7\x90\xff\xff\xff\xffˉ\x1a\xa0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2" +
+       "a&\x10\xff\xff\xff\xff\xd6\xfet\\\xff\xff\xff\xff\u0600\xad\x90\xff\xff\xff\xff\xda\xfeÐ\xff\xff\xff\xff\xdb\xc0\x90\x10\xff\xff\xff\xff\xdcޥ\x90\xff\xff\xff\xffݩ\xac\x90\xff\xff\xff\xff\u07be\x87\x90\xff" +
+       "\xff\xff\xff߉\x8e\x90\xff\xff\xff\xff\xe0\x9ei\x90\xff\xff\xff\xff\xe1ip\x90\xff\xff\xff\xff\xe2~K\x90\xff\xff\xff\xff\xe3IR\x90\xff\xff\xff\xff\xe4^-\x90\xff\xff\xff\xff\xe5)4\x90\xff\xff\xff\xff\xe6" +
+       "GJ\x10\xff\xff\xff\xff\xe7\x12Q\x10\xff\xff\xff\xff\xe8',\x10\xff\xff\xff\xff\xe8\xf23\x10\xff\xff\xff\xff\xea\a\x0e\x10\xff\xff\xff\xff\xea\xd2\x15\x10\xff\xff\xff\xff\xeb\xe6\xf0\x10\xff\xff\xff\xff\xec\xb1\xf7\x10\xff" +
+       "\xff\xff\xff\xed\xc6\xd2\x10\xff\xff\xff\xff\xee\x91\xd9\x10\xff\xff\xff\xff\xef\xaf\xee\x90\xff\xff\xff\xff\xf0q\xbb\x10\xff\xff\xff\xff\xf1\x8fА\xff\xff\xff\xff\xf2\u007f\xc1\x90\xff\xff\xff\xff\xf3o\xb2\x90\xff\xff\xff\xff\xf4" +
+       "_\xa3\x90\xff\xff\xff\xff\xf5O\x94\x90\xff\xff\xff\xff\xf6?\x85\x90\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\xa2\x10\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b\x84\x10\xff\xff\xff\xff\xfa\xf8\x83 \xff" +
+       "\xff\xff\xff\xfb\xe8f\x10\xff\xff\xff\xff\xfc\xd8e \xff\xff\xff\xff\xfd\xc8H\x10\xff\xff\xff\xff\xfe\xb8G \xff\xff\xff\xff\xff\xa8*\x10\x00\x00\x00\x00\x00\x98) \x00\x00\x00\x00\x01\x88\f\x10\x00\x00\x00\x00\x02" +
+       "x\v \x00\x00\x00\x00\x03q(\x90\x00\x00\x00\x00\x04a'\xa0\x00\x00\x00\x00\x05Q\n\x90\x00\x00\x00\x00\x06A\t\xa0\x00\x00\x00\x00\a0\xec\x90\x00\x00\x00\x00\a\x8dC\xa0\x00\x00\x00\x00\t\x10ΐ\x00" +
+       "\x00\x00\x00\t\xad\xbf \x00\x00\x00\x00\n\xf0\xb0\x90\x00\x00\x00\x00\v\u0be0\x00\x00\x00\x00\f\xd9\xcd\x10\x00\x00\x00\x00\r\xc0\x91\xa0\x00\x00\x00\x00\x0e\xb9\xaf\x10\x00\x00\x00\x00\x0f\xa9\xae \x00\x00\x00\x00\x10" +
+       "\x99\x91\x10\x00\x00\x00\x00\x11\x89\x90 \x00\x00\x00\x00\x12ys\x10\x00\x00\x00\x00\x13ir \x00\x00\x00\x00\x14YU\x10\x00\x00\x00\x00\x15IT \x00\x00\x00\x00\x1697\x10\x00\x00\x00\x00\x17)6 \x00" +
+       "\x00\x00\x00\x18\"S\x90\x00\x00\x00\x00\x19\t\x18 \x00\x00\x00\x00\x1a\x025\x90\x00\x00\x00\x00\x1a\xf24\xa0\x00\x00\x00\x00\x1b\xe2\x17\x90\x00\x00\x00\x00\x1c\xd2\x16\xa0\x00\x00\x00\x00\x1d\xc1\xf9\x90\x00\x00\x00\x00\x1e" +
+       "\xb1\xf8\xa0\x00\x00\x00\x00\x1f\xa1ې\x00\x00\x00\x00 v+ \x00\x00\x00\x00!\x81\xbd\x90\x00\x00\x00\x00\"V\r \x00\x00\x00\x00#j\xda\x10\x00\x00\x00\x00$5\xef \x00\x00\x00\x00%J\xbc\x10\x00" +
+       "\x00\x00\x00&\x15\xd1 \x00\x00\x00\x00'*\x9e\x10\x00\x00\x00\x00'\xfe\xed\xa0\x00\x00\x00\x00)\n\x80\x10\x00\x00\x00\x00)\xdeϠ\x00\x00\x00\x00*\xeab\x10\x00\x00\x00\x00+\xbe\xb1\xa0\x00\x00\x00\x00," +
+       "\xd3~\x90\x00\x00\x00\x00-\x9e\x93\xa0\x00\x00\x00\x00.\xb3`\x90\x00\x00\x00\x00/~u\xa0\x00\x00\x00\x000\x93B\x90\x00\x00\x00\x001g\x92 \x00\x00\x00\x002s$\x90\x00\x00\x00\x003Gt \x00" +
+       "\x00\x00\x004S\x06\x90\x00\x00\x00\x005'V \x00\x00\x00\x0062\xe8\x90\x00\x00\x00\x007\a8 \x00\x00\x00\x008\x1c\x05\x10\x00\x00\x00\x008\xe7\x1a \x00\x00\x00\x009\xfb\xe7\x10\x00\x00\x00\x00:" +
+       "\xc6\xfc \x00\x00\x00\x00;\xdb\xc9\x10\x00\x00\x00\x00<\xb0\x18\xa0\x00\x00\x00\x00=\xbb\xab\x10\x00\x00\x00\x00>\x8f\xfa\xa0\x00\x00\x00\x00?\x9b\x8d\x10\x00\x00\x00\x00@oܠ\x00\x00\x00\x00A\x84\xa9\x90\x00" +
+       "\x00\x00\x00BO\xbe\xa0\x00\x00\x00\x00Cd\x8b\x90\x00\x00\x00\x00D/\xa0\xa0\x00\x00\x00\x00EDm\x90\x00\x00\x00\x00E\xf3\xd3 \x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x91&\x00\x00\xff\xff\x9d\x90\x01\x04\xff\xff\x8f\x80" +
+       "\x00\b\xff\xff\x9d\x90\x01\f\xff\xff\x9d\x90\x01\x10LMT\x00PDT\x00PST\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK" +
+       "\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x1c\x00US/CentralUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff" +
+       "\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa2\xcbt\x00\xff\xff\xff\xff\xa3\x83\xf7\xf0\xff\xff\xff\xff\xa4EҀ\xff\xff\xff\xff\xa5c\xd9\xf0\xff\xff\xff\xff\xa6S\xd9" +
+       "\x00\xff\xff\xff\xff\xa7\x15\x97p\xff\xff\xff\xff\xa83\xbb\x00\xff\xff\xff\xff\xa8\xfe\xb3\xf0\xff\xff\xff\xff\xaa\x13\x9d\x00\xff\xff\xff\xff\xaaޕ\xf0\xff\xff\xff\xff\xab\xf3\u007f\x00\xff\xff\xff\xff\xac\xbew\xf0\xff\xff\xff" +
+       "\xff\xad\xd3a\x00\xff\xff\xff\xff\xae\x9eY\xf0\xff\xff\xff\xff\xaf\xb3C\x00\xff\xff\xff\xff\xb0~;\xf0\xff\xff\xff\xff\xb1\x9c_\x80\xff\xff\xff\xff\xb2gXp\xff\xff\xff\xff\xb3|A\x80\xff\xff\xff\xff\xb4G:" +
+       "p\xff\xff\xff\xff\xb5\\#\x80\xff\xff\xff\xff\xb6'\x1cp\xff\xff\xff\xff\xb7<\x05\x80\xff\xff\xff\xff\xb8\x06\xfep\xff\xff\xff\xff\xb9\x1b\xe7\x80\xff\xff\xff\xff\xb9\xe6\xe0p\xff\xff\xff\xff\xbb\x05\x04\x00\xff\xff\xff" +
+       "\xff\xbb\xc6\xc2p\xff\xff\xff\xff\xbc\xe4\xe6\x00\xff\xff\xff\xff\xbd\xaf\xde\xf0\xff\xff\xff\xff\xbe\xc4\xc8\x00\xff\xff\xff\xff\xbf\x8f\xc0\xf0\xff\xff\xff\xff\xc0Z\xd6\x00\xff\xff\xff\xff\xc1\xb0<p\xff\xff\xff\xff\u0084\x8c" +
+       "\x00\xff\xff\xff\xff\xc3O\x84\xf0\xff\xff\xff\xff\xc4dn\x00\xff\xff\xff\xff\xc5/f\xf0\xff\xff\xff\xff\xc6M\x8a\x80\xff\xff\xff\xff\xc7\x0fH\xf0\xff\xff\xff\xff\xc8-l\x80\xff\xff\xff\xff\xc8\xf8ep\xff\xff\xff" +
+       "\xff\xca\rN\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5" +
+       "\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff" +
+       "\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6" +
+       "p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff" +
+       "\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\xc2" +
+       "\x80\xff\xff\xff\xff\xf2\u007f\xa5p\xff\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x85\xf0\xff\xff\xff" +
+       "\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa\bg\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r" +
+       "\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00" +
+       "\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u" +
+       "\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00" +
+       "\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfb" +
+       "p\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00" +
+       "\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3" +
+       "\x80\x00\x00\x00\x00*\xeaE\xf0\x00\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00" +
+       "\x001gv\x00\x00\x00\x00\x002s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8" +
+       "\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00" +
+       "\x00?\x9bp\xf0\x00\x00\x00\x00@o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7" +
+       "\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad\xd4" +
+       "\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00CDT\x00CST\x00EST\x00CWT\x00CPT\x00\nCST" +
+       "6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x1c\x00US/Michiga" +
+       "nUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00P\x00\x00\x00\x06" +
+       "\x00\x00\x00\x18\xff\xff\xff\xff\x85\xbd\"[\xff\xff\xff\xff\x99<\x94\x00\xff\xff\xff\xffˈ\xf0p\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8\x00\xa1\xe0" +
+       "\xff\xff\xff\xff\xfb3\x90\x8c\xff\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00" +
+       "\t\x10\xa4`\x00\x00\x00\x00\n\x00\xa3p\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0" +
+       "\x00\x00\x00\x00\x10\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00" +
+       "\x17)\v\xf0\x00\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`" +
+       "\x00\x00\x00\x00\x1e\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00" +
+       "%J\x91\xe0\x00\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p" +
+       "\x00\x00\x00\x00,\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x00" +
+       "3GI\xf0\x00\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0" +
+       "\x00\x00\x00\x00:\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00" +
+       "A\x84\u007f`\x00\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x01\x02\x03\x04\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05\x02\x05" +
+       "\x02\x05\x02\x05\xff\xff\xb2%\x00\x00\xff\xff\xab\xa0\x00\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff\xc7\xc0\x01\x10\xff\xff\xc7\xc0\x01\x14LMT\x00CST\x00EST\x00EWT\x00EPT\x00" +
+       "EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\v\x00\x1c\x00US" +
+       "/AleutianUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00!\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87Z^\xff\xff\xff\xffˉD\xd0\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aP@\xff\xff\xff\xff\xfa\xd2U\xb0" +
+       "\xff\xff\xff\xff\xfe\xb8qP\xff\xff\xff\xff\xff\xa8T@\x00\x00\x00\x00\x00\x98SP\x00\x00\x00\x00\x01\x886@\x00\x00\x00\x00\x02x5P\x00\x00\x00\x00\x03qR\xc0\x00\x00\x00\x00\x04aQ\xd0\x00\x00\x00\x00" +
+       "\x05Q4\xc0\x00\x00\x00\x00\x06A3\xd0\x00\x00\x00\x00\a1\x16\xc0\x00\x00\x00\x00\a\x8dm\xd0\x00\x00\x00\x00\t\x10\xf8\xc0\x00\x00\x00\x00\t\xad\xe9P\x00\x00\x00\x00\n\xf0\xda\xc0\x00\x00\x00\x00\v\xe0\xd9\xd0" +
+       "\x00\x00\x00\x00\f\xd9\xf7@\x00\x00\x00\x00\r\xc0\xbb\xd0\x00\x00\x00\x00\x0e\xb9\xd9@\x00\x00\x00\x00\x0f\xa9\xd8P\x00\x00\x00\x00\x10\x99\xbb@\x00\x00\x00\x00\x11\x89\xbaP\x00\x00\x00\x00\x12y\x9d@\x00\x00\x00\x00" +
+       "\x13i\x9cP\x00\x00\x00\x00\x14Y\u007f@\x00\x00\x00\x00\x15I~P\x00\x00\x00\x00\x169a@\x00\x00\x00\x00\x17)`P\x00\x00\x00\x00\x18\"}\xc0\x00\x00\x00\x00\x19\tBP\x00\x00\x00\x00\x1a\x02_\xc0" +
+       "\x00\x00\x00\x00\x1a+\" \x00\x00\x00\x00\x1a\xf2P\xc0\x00\x00\x00\x00\x1b\xe23\xb0\x00\x00\x00\x00\x1c\xd22\xc0\x00\x00\x00\x00\x1d\xc2\x15\xb0\x00\x00\x00\x00\x1e\xb2\x14\xc0\x00\x00\x00\x00\x1f\xa1\xf7\xb0\x00\x00\x00\x00" +
+       " vG@\x00\x00\x00\x00!\x81ٰ\x00\x00\x00\x00\"V)@\x00\x00\x00\x00#j\xf60\x00\x00\x00\x00$6\v@\x00\x00\x00\x00%J\xd80\x00\x00\x00\x00&\x15\xed@\x00\x00\x00\x00'*\xba0" +
+       "\x00\x00\x00\x00'\xff\t\xc0\x00\x00\x00\x00)\n\x9c0\x00\x00\x00\x00)\xde\xeb\xc0\x00\x00\x00\x00*\xea~0\x00\x00\x00\x00+\xbe\xcd\xc0\x00\x00\x00\x00,Ӛ\xb0\x00\x00\x00\x00-\x9e\xaf\xc0\x00\x00\x00\x00" +
+       ".\xb3|\xb0\x00\x00\x00\x00/~\x91\xc0\x00\x00\x00\x000\x93^\xb0\x00\x00\x00\x001g\xae@\x00\x00\x00\x002s@\xb0\x00\x00\x00\x003G\x90@\x00\x00\x00\x004S\"\xb0\x00\x00\x00\x005'r@" +
+       "\x00\x00\x00\x0063\x04\xb0\x00\x00\x00\x007\aT@\x00\x00\x00\x008\x1c!0\x00\x00\x00\x008\xe76@\x00\x00\x00\x009\xfc\x030\x00\x00\x00\x00:\xc7\x18@\x00\x00\x00\x00;\xdb\xe50\x00\x00\x00\x00" +
+       "<\xb04\xc0\x00\x00\x00\x00=\xbb\xc70\x00\x00\x00\x00>\x90\x16\xc0\x00\x00\x00\x00?\x9b\xa90\x00\x00\x00\x00@o\xf8\xc0\x00\x00\x00\x00A\x84Ű\x00\x00\x00\x00BO\xda\xc0\x00\x00\x00\x00Cd\xa7\xb0" +
+       "\x00\x00\x00\x00D/\xbc\xc0\x00\x00\x00\x00ED\x89\xb0\x00\x00\x00\x00E\xf3\xef@\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a" +
+       "\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\x00\x00\xab\xe2\x00\x00\xff\xffZb\x00\x00" +
+       "\xff\xffeP\x00\x04\xff\xffs`\x01\b\xff\xffs`\x01\f\xff\xffeP\x00\x10\xff\xffs`\x01\x14\xff\xffs`\x00\x18\xff\xff\x81p\x01\x1d\xff\xffs`\x00\x19LMT\x00NST\x00NWT\x00" +
+       "NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST10HDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x11\x00\x1c\x00US/Indiana-StarkeUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p" +
+       "\xff\xff\xff\xff\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff\xff\xff\xff" +
+       "\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xffݩ\x90p" +
+       "\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff" +
+       "\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xd1\xf8\xf0\xff\xff\xff\xff\xeb\xe6\xe2\x00" +
+       "\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff" +
+       "\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00\x00\x00\x00\x01\x87\xef\xf0" +
+       "\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a\x8d'\x80\x00\x00\x00\x00" +
+       "\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00\x00\x00\x00\x0f\xa9\x92\x00" +
+       "\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x169\x1a\xf0\x00\x00\x00\x00" +
+       "\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00\x00\x00\x00\x1d\xc1\xddp" +
+       "\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$5\xd3\x00\x00\x00\x00\x00" +
+       "%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00" +
+       "\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x01\x02\x01\xff\xff\xae\xca\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9" +
+       "\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03" +
+       "\x04\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\v\x00\x1c\x00US/MountainUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZi" +
+       "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff" +
+       "\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f" +
+       "\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\bv\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff" +
+       "\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd" +
+       "\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00" +
+       "\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83" +
+       "\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169)\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00" +
+       "\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea" +
+       "\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00" +
+       "\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p" +
+       "\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00" +
+       "\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee" +
+       "\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@oΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00" +
+       "\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT\x00MDT\x00MST\x00MWT\x00" +
+       "MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\n\x00\x1c\x00US" +
+       "/ArizonaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\v\x00\x00\x00\x04\x00\x00\x00\x10\xff\xff\xff\xff^\x04\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xffˉ\f\x90\xff" +
+       "\xff\xff\xff\xcf\x17\xdf\x1c\xff\xff\xff\xffϏ\xe5\xac\xff\xff\xff\xffЁ\x1a\x1c\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\x02\x01\x02\x01\x02\x03\x02\x03\x02\x01\x02\xff\xff\x96\xee\x00\x00\xff\xff\xab\xa0" +
+       "\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\fLMT\x00MDT\x00MST\x00MWT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06" +
+       "\x00\x00\n\x00\x1c\x00US/EasternUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x03\xf0\x90\xff\xff\xff\xff\x9e\xa6\x1ep\xff\xff\xff\xff\x9f\xba\xeb`\xff\xff\xff\xff\xa0\x86\x00p\xff\xff\xff\xff\xa1\x9a\xcd`\xff" +
+       "\xff\xff\xff\xa2e\xe2p\xff\xff\xff\xff\xa3\x83\xe9\xe0\xff\xff\xff\xff\xa4j\xaep\xff\xff\xff\xff\xa55\xa7`\xff\xff\xff\xff\xa6S\xca\xf0\xff\xff\xff\xff\xa7\x15\x89`\xff\xff\xff\xff\xa83\xac\xf0\xff\xff\xff\xff\xa8" +
+       "\xfe\xa5\xe0\xff\xff\xff\xff\xaa\x13\x8e\xf0\xff\xff\xff\xff\xaaއ\xe0\xff\xff\xff\xff\xab\xf3p\xf0\xff\xff\xff\xff\xac\xbei\xe0\xff\xff\xff\xff\xad\xd3R\xf0\xff\xff\xff\xff\xae\x9eK\xe0\xff\xff\xff\xff\xaf\xb34\xf0\xff" +
+       "\xff\xff\xff\xb0~-\xe0\xff\xff\xff\xff\xb1\x9cQp\xff\xff\xff\xff\xb2gJ`\xff\xff\xff\xff\xb3|3p\xff\xff\xff\xff\xb4G,`\xff\xff\xff\xff\xb5\\\x15p\xff\xff\xff\xff\xb6'\x0e`\xff\xff\xff\xff\xb7" +
+       ";\xf7p\xff\xff\xff\xff\xb8\x06\xf0`\xff\xff\xff\xff\xb9\x1b\xd9p\xff\xff\xff\xff\xb9\xe6\xd2`\xff\xff\xff\xff\xbb\x04\xf5\xf0\xff\xff\xff\xff\xbbƴ`\xff\xff\xff\xff\xbc\xe4\xd7\xf0\xff\xff\xff\xff\xbd\xaf\xd0\xe0\xff" +
+       "\xff\xff\xff\xbeĹ\xf0\xff\xff\xff\xff\xbf\x8f\xb2\xe0\xff\xff\xff\xff\xc0\xa4\x9b\xf0\xff\xff\xff\xff\xc1o\x94\xe0\xff\xff\xff\xff\u0084}\xf0\xff\xff\xff\xff\xc3Ov\xe0\xff\xff\xff\xff\xc4d_\xf0\xff\xff\xff\xff\xc5" +
+       "/X\xe0\xff\xff\xff\xff\xc6M|p\xff\xff\xff\xff\xc7\x0f:\xe0\xff\xff\xff\xff\xc8-^p\xff\xff\xff\xff\xc8\xf8W`\xff\xff\xff\xff\xca\r@p\xff\xff\xff\xff\xca\xd89`\xff\xff\xff\xffˈ\xf0p\xff" +
+       "\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2`\xfb\xe0\xff\xff\xff\xff\xd3u\xe4\xf0\xff\xff\xff\xff\xd4@\xdd\xe0\xff\xff\xff\xff\xd5U\xc6\xf0\xff\xff\xff\xff\xd6 \xbf\xe0\xff\xff\xff\xff\xd75\xa8\xf0\xff\xff\xff\xff\xd8" +
+       "\x00\xa1\xe0\xff\xff\xff\xff\xd9\x15\x8a\xf0\xff\xff\xff\xff\xd9\xe0\x83\xe0\xff\xff\xff\xff\xda\xfe\xa7p\xff\xff\xff\xff\xdb\xc0e\xe0\xff\xff\xff\xff\xdcމp\xff\xff\xff\xffݩ\x82`\xff\xff\xff\xff\u07bekp\xff" +
+       "\xff\xff\xff߉d`\xff\xff\xff\xff\xe0\x9eMp\xff\xff\xff\xff\xe1iF`\xff\xff\xff\xff\xe2~/p\xff\xff\xff\xff\xe3I(`\xff\xff\xff\xff\xe4^\x11p\xff\xff\xff\xff\xe5W.\xe0\xff\xff\xff\xff\xe6" +
+       "G-\xf0\xff\xff\xff\xff\xe77\x10\xe0\xff\xff\xff\xff\xe8'\x0f\xf0\xff\xff\xff\xff\xe9\x16\xf2\xe0\xff\xff\xff\xff\xea\x06\xf1\xf0\xff\xff\xff\xff\xea\xf6\xd4\xe0\xff\xff\xff\xff\xeb\xe6\xd3\xf0\xff\xff\xff\xff\xecֶ\xe0\xff" +
+       "\xff\xff\xff\xedƵ\xf0\xff\xff\xff\xff\xee\xbf\xd3`\xff\xff\xff\xff\xef\xaf\xd2p\xff\xff\xff\xff\xf0\x9f\xb5`\xff\xff\xff\xff\xf1\x8f\xb4p\xff\xff\xff\xff\xf2\u007f\x97`\xff\xff\xff\xff\xf3o\x96p\xff\xff\xff\xff\xf4" +
+       "_y`\xff\xff\xff\xff\xf5Oxp\xff\xff\xff\xff\xf6?[`\xff\xff\xff\xff\xf7/Zp\xff\xff\xff\xff\xf8(w\xe0\xff\xff\xff\xff\xf9\x0f<p\xff\xff\xff\xff\xfa\bY\xe0\xff\xff\xff\xff\xfa\xf8X\xf0\xff" +
+       "\xff\xff\xff\xfb\xe8;\xe0\xff\xff\xff\xff\xfc\xd8:\xf0\xff\xff\xff\xff\xfd\xc8\x1d\xe0\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00\x02" +
+       "w\xe0\xf0\x00\x00\x00\x00\x03p\xfe`\x00\x00\x00\x00\x04`\xfdp\x00\x00\x00\x00\x05P\xe0`\x00\x00\x00\x00\x06@\xdfp\x00\x00\x00\x00\a0\xc2`\x00\x00\x00\x00\a\x8d\x19p\x00\x00\x00\x00\t\x10\xa4`\x00" +
+       "\x00\x00\x00\t\xad\x94\xf0\x00\x00\x00\x00\n\xf0\x86`\x00\x00\x00\x00\v\xe0\x85p\x00\x00\x00\x00\f٢\xe0\x00\x00\x00\x00\r\xc0gp\x00\x00\x00\x00\x0e\xb9\x84\xe0\x00\x00\x00\x00\x0f\xa9\x83\xf0\x00\x00\x00\x00\x10" +
+       "\x99f\xe0\x00\x00\x00\x00\x11\x89e\xf0\x00\x00\x00\x00\x12yH\xe0\x00\x00\x00\x00\x13iG\xf0\x00\x00\x00\x00\x14Y*\xe0\x00\x00\x00\x00\x15I)\xf0\x00\x00\x00\x00\x169\f\xe0\x00\x00\x00\x00\x17)\v\xf0\x00" +
+       "\x00\x00\x00\x18\")`\x00\x00\x00\x00\x19\b\xed\xf0\x00\x00\x00\x00\x1a\x02\v`\x00\x00\x00\x00\x1a\xf2\np\x00\x00\x00\x00\x1b\xe1\xed`\x00\x00\x00\x00\x1c\xd1\xecp\x00\x00\x00\x00\x1d\xc1\xcf`\x00\x00\x00\x00\x1e" +
+       "\xb1\xcep\x00\x00\x00\x00\x1f\xa1\xb1`\x00\x00\x00\x00 v\x00\xf0\x00\x00\x00\x00!\x81\x93`\x00\x00\x00\x00\"U\xe2\xf0\x00\x00\x00\x00#j\xaf\xe0\x00\x00\x00\x00$5\xc4\xf0\x00\x00\x00\x00%J\x91\xe0\x00" +
+       "\x00\x00\x00&\x15\xa6\xf0\x00\x00\x00\x00'*s\xe0\x00\x00\x00\x00'\xfe\xc3p\x00\x00\x00\x00)\nU\xe0\x00\x00\x00\x00)ޥp\x00\x00\x00\x00*\xea7\xe0\x00\x00\x00\x00+\xbe\x87p\x00\x00\x00\x00," +
+       "\xd3T`\x00\x00\x00\x00-\x9eip\x00\x00\x00\x00.\xb36`\x00\x00\x00\x00/~Kp\x00\x00\x00\x000\x93\x18`\x00\x00\x00\x001gg\xf0\x00\x00\x00\x002r\xfa`\x00\x00\x00\x003GI\xf0\x00" +
+       "\x00\x00\x004R\xdc`\x00\x00\x00\x005'+\xf0\x00\x00\x00\x0062\xbe`\x00\x00\x00\x007\a\r\xf0\x00\x00\x00\x008\x1b\xda\xe0\x00\x00\x00\x008\xe6\xef\xf0\x00\x00\x00\x009\xfb\xbc\xe0\x00\x00\x00\x00:" +
+       "\xc6\xd1\xf0\x00\x00\x00\x00;۞\xe0\x00\x00\x00\x00<\xaf\xeep\x00\x00\x00\x00=\xbb\x80\xe0\x00\x00\x00\x00>\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00" +
+       "\x00\x00\x00BO\x94p\x00\x00\x00\x00Cda`\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
+       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
+       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xba\x9e\x00\x00\xff\xff\xc7\xc0\x01\x04\xff\xff\xb9\xb0\x00\b\xff\xff\xc7\xc0\x01\f\xff\xff" +
+       "\xc7\xc0\x01\x10LMT\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\t\x00\x1c\x00US/AlaskaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\n\x00\x00\x00(\xff\xff\xff\xff?\xc2\xfd\xd1\xff\xff\xff\xff}\x87AH\xff\xff\xff\xffˉ6\xc0\xff\xff\xff\xff\xd2#" +
+       "\xf4p\xff\xff\xff\xff\xd2aB0\xff\xff\xff\xff\xfa\xd2G\xa0\xff\xff\xff\xff\xfe\xb8c@\xff\xff\xff\xff\xff\xa8F0\x00\x00\x00\x00\x00\x98E@\x00\x00\x00\x00\x01\x88(0\x00\x00\x00\x00\x02x'@\x00\x00" +
+       "\x00\x00\x03qD\xb0\x00\x00\x00\x00\x04aC\xc0\x00\x00\x00\x00\x05Q&\xb0\x00\x00\x00\x00\x06A%\xc0\x00\x00\x00\x00\a1\b\xb0\x00\x00\x00\x00\a\x8d_\xc0\x00\x00\x00\x00\t\x10\xea\xb0\x00\x00\x00\x00\t\xad" +
+       "\xdb@\x00\x00\x00\x00\n\xf0̰\x00\x00\x00\x00\v\xe0\xcb\xc0\x00\x00\x00\x00\f\xd9\xe90\x00\x00\x00\x00\r\xc0\xad\xc0\x00\x00\x00\x00\x0e\xb9\xcb0\x00\x00\x00\x00\x0f\xa9\xca@\x00\x00\x00\x00\x10\x99\xad0\x00\x00" +
+       "\x00\x00\x11\x89\xac@\x00\x00\x00\x00\x12y\x8f0\x00\x00\x00\x00\x13i\x8e@\x00\x00\x00\x00\x14Yq0\x00\x00\x00\x00\x15Ip@\x00\x00\x00\x00\x169S0\x00\x00\x00\x00\x17)R@\x00\x00\x00\x00\x18\"" +
+       "o\xb0\x00\x00\x00\x00\x19\t4@\x00\x00\x00\x00\x1a\x02Q\xb0\x00\x00\x00\x00\x1a+\x14\x10\x00\x00\x00\x00\x1a\xf2B\xb0\x00\x00\x00\x00\x1b\xe2%\xa0\x00\x00\x00\x00\x1c\xd2$\xb0\x00\x00\x00\x00\x1d\xc2\a\xa0\x00\x00" +
+       "\x00\x00\x1e\xb2\x06\xb0\x00\x00\x00\x00\x1f\xa1\xe9\xa0\x00\x00\x00\x00 v90\x00\x00\x00\x00!\x81ˠ\x00\x00\x00\x00\"V\x1b0\x00\x00\x00\x00#j\xe8 \x00\x00\x00\x00$5\xfd0\x00\x00\x00\x00%J" +
+       "\xca \x00\x00\x00\x00&\x15\xdf0\x00\x00\x00\x00'*\xac \x00\x00\x00\x00'\xfe\xfb\xb0\x00\x00\x00\x00)\n\x8e \x00\x00\x00\x00)\xdeݰ\x00\x00\x00\x00*\xeap \x00\x00\x00\x00+\xbe\xbf\xb0\x00\x00" +
+       "\x00\x00,ӌ\xa0\x00\x00\x00\x00-\x9e\xa1\xb0\x00\x00\x00\x00.\xb3n\xa0\x00\x00\x00\x00/~\x83\xb0\x00\x00\x00\x000\x93P\xa0\x00\x00\x00\x001g\xa00\x00\x00\x00\x002s2\xa0\x00\x00\x00\x003G" +
+       "\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x005'd0\x00\x00\x00\x0062\xf6\xa0\x00\x00\x00\x007\aF0\x00\x00\x00\x008\x1c\x13 \x00\x00\x00\x008\xe7(0\x00\x00\x00\x009\xfb\xf5 \x00\x00" +
+       "\x00\x00:\xc7\n0\x00\x00\x00\x00;\xdb\xd7 \x00\x00\x00\x00<\xb0&\xb0\x00\x00\x00\x00=\xbb\xb9 \x00\x00\x00\x00>\x90\b\xb0\x00\x00\x00\x00?\x9b\x9b \x00\x00\x00\x00@o\xea\xb0\x00\x00\x00\x00A\x84" +
+       "\xb7\xa0\x00\x00\x00\x00BO̰\x00\x00\x00\x00Cd\x99\xa0\x00\x00\x00\x00D/\xae\xb0\x00\x00\x00\x00ED{\xa0\x00\x00\x00\x00E\xf3\xe10\x01\x02\x03\x04\x02\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05" +
+       "\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\a\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b\t\b" +
+       "\t\b\t\b\t\b\x00\x00\xc4\xf8\x00\x00\xff\xffsx\x00\x00\xff\xffs`\x00\x04\xff\xff\x81p\x01\b\xff\xff\x81p\x01\f\xff\xffs`\x00\x10\xff\xff\x81p\x01\x15\xff\xff\x81p\x00\x1a\xff\xff\x8f\x80\x01\x1e" +
+       "\xff\xff\x81p\x00#LMT\x00AST\x00AWT\x00APT\x00AHST\x00AHDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3." +
+       "2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\b\x00\x1c\x00US/SamoaUT\t\x00\x03\x15\xac\x0e`\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" +
+       "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=\xc8" +
+       "\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LMT\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6" +
+       "{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00\x1c\x00US/East-IndianaUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZi" +
        "f2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00" +
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00&\x00\x00\x00\a\x00\x00\x00\x1c\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff" +
        "\xa0\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xcaW\"\x80\xff\xff\xff\xff\xca\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00" +
@@ -6109,951 +6189,901 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00
        "\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff\xff\xff\xff\xe8\xf2\x16\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xfe\xb8\x1c\xf0\xff\xff\xff\xff\xff\xa7\xff\xe0\x00\x00\x00\x00" +
        "\x00\x97\xfe\xf0\x00\x00\x00\x00\x01\x87\xe1\xe0\x00\x00\x00\x00D/vp\x00\x00\x00\x00EDC`\x00\x00\x00\x00E\xf3\xa8\xf0\x02\x01\x02\x01\x02\x01\x02\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
        "\x01\x02\x01\x02\x05\x02\x05\x06\x05\x06\x05\x06\x05\x06\xff\xff\xaf:\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff\xab\xa0\x00\b\xff\xff\xb9\xb0\x01\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x00\x14\xff\xff\xc7\xc0\x01\x18LMT\x00" +
-       "CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x1c\x00US/CentralUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x06\x00\x00\x00\x18\xff\xff\xff\xff^\x03\xfe\xa0\xff\xff\xff\xff\x9e\xa6,\x80\xff\xff\xff\xff\x9f\xba\xf9p\xff\xff\xff\xff\xa0" +
-       "\x86\x0e\x80\xff\xff\xff\xff\xa1\x9a\xdbp\xff\xff\xff\xff\xa2\xcbt\x00\xff\xff\xff\xff\xa3\x83\xf7\xf0\xff\xff\xff\xff\xa4EҀ\xff\xff\xff\xff\xa5c\xd9\xf0\xff\xff\xff\xff\xa6S\xd9\x00\xff\xff\xff\xff\xa7\x15\x97p\xff" +
-       "\xff\xff\xff\xa83\xbb\x00\xff\xff\xff\xff\xa8\xfe\xb3\xf0\xff\xff\xff\xff\xaa\x13\x9d\x00\xff\xff\xff\xff\xaaޕ\xf0\xff\xff\xff\xff\xab\xf3\u007f\x00\xff\xff\xff\xff\xac\xbew\xf0\xff\xff\xff\xff\xad\xd3a\x00\xff\xff\xff\xff\xae" +
-       "\x9eY\xf0\xff\xff\xff\xff\xaf\xb3C\x00\xff\xff\xff\xff\xb0~;\xf0\xff\xff\xff\xff\xb1\x9c_\x80\xff\xff\xff\xff\xb2gXp\xff\xff\xff\xff\xb3|A\x80\xff\xff\xff\xff\xb4G:p\xff\xff\xff\xff\xb5\\#\x80\xff" +
-       "\xff\xff\xff\xb6'\x1cp\xff\xff\xff\xff\xb7<\x05\x80\xff\xff\xff\xff\xb8\x06\xfep\xff\xff\xff\xff\xb9\x1b\xe7\x80\xff\xff\xff\xff\xb9\xe6\xe0p\xff\xff\xff\xff\xbb\x05\x04\x00\xff\xff\xff\xff\xbb\xc6\xc2p\xff\xff\xff\xff\xbc" +
-       "\xe4\xe6\x00\xff\xff\xff\xff\xbd\xaf\xde\xf0\xff\xff\xff\xff\xbe\xc4\xc8\x00\xff\xff\xff\xff\xbf\x8f\xc0\xf0\xff\xff\xff\xff\xc0Z\xd6\x00\xff\xff\xff\xff\xc1\xb0<p\xff\xff\xff\xff\u0084\x8c\x00\xff\xff\xff\xff\xc3O\x84\xf0\xff" +
-       "\xff\xff\xff\xc4dn\x00\xff\xff\xff\xff\xc5/f\xf0\xff\xff\xff\xff\xc6M\x8a\x80\xff\xff\xff\xff\xc7\x0fH\xf0\xff\xff\xff\xff\xc8-l\x80\xff\xff\xff\xff\xc8\xf8ep\xff\xff\xff\xff\xca\rN\x80\xff\xff\xff\xff\xca" +
-       "\xd8Gp\xff\xff\xff\xffˈ\xfe\x80\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\t\xf0\xff\xff\xff\xff\xd3u\xf3\x00\xff\xff\xff\xff\xd4@\xeb\xf0\xff\xff\xff\xff\xd5U\xd5\x00\xff\xff\xff\xff\xd6 \xcd\xf0\xff" +
-       "\xff\xff\xff\xd75\xb7\x00\xff\xff\xff\xff\xd8\x00\xaf\xf0\xff\xff\xff\xff\xd9\x15\x99\x00\xff\xff\xff\xff\xd9\xe0\x91\xf0\xff\xff\xff\xff\xda\xfe\xb5\x80\xff\xff\xff\xff\xdb\xc0s\xf0\xff\xff\xff\xff\xdcޗ\x80\xff\xff\xff\xff\xdd" +
-       "\xa9\x90p\xff\xff\xff\xff\u07bey\x80\xff\xff\xff\xff߉rp\xff\xff\xff\xff\xe0\x9e[\x80\xff\xff\xff\xff\xe1iTp\xff\xff\xff\xff\xe2~=\x80\xff\xff\xff\xff\xe3I6p\xff\xff\xff\xff\xe4^\x1f\x80\xff" +
-       "\xff\xff\xff\xe5W<\xf0\xff\xff\xff\xff\xe6G<\x00\xff\xff\xff\xff\xe77\x1e\xf0\xff\xff\xff\xff\xe8'\x1e\x00\xff\xff\xff\xff\xe9\x17\x00\xf0\xff\xff\xff\xff\xea\a\x00\x00\xff\xff\xff\xff\xea\xf6\xe2\xf0\xff\xff\xff\xff\xeb" +
-       "\xe6\xe2\x00\xff\xff\xff\xff\xec\xd6\xc4\xf0\xff\xff\xff\xff\xed\xc6\xc4\x00\xff\xff\xff\xff\xee\xbf\xe1p\xff\xff\xff\xff\xef\xaf\xe0\x80\xff\xff\xff\xff\xf0\x9f\xc3p\xff\xff\xff\xff\xf1\x8f\u0080\xff\xff\xff\xff\xf2\u007f\xa5p\xff" +
-       "\xff\xff\xff\xf3o\xa4\x80\xff\xff\xff\xff\xf4_\x87p\xff\xff\xff\xff\xf5O\x86\x80\xff\xff\xff\xff\xf6?ip\xff\xff\xff\xff\xf7/h\x80\xff\xff\xff\xff\xf8(\x85\xf0\xff\xff\xff\xff\xf9\x0fJ\x80\xff\xff\xff\xff\xfa" +
-       "\bg\xf0\xff\xff\xff\xff\xfa\xf8g\x00\xff\xff\xff\xff\xfb\xe8I\xf0\xff\xff\xff\xff\xfc\xd8I\x00\xff\xff\xff\xff\xfd\xc8+\xf0\xff\xff\xff\xff\xfe\xb8+\x00\xff\xff\xff\xff\xff\xa8\r\xf0\x00\x00\x00\x00\x00\x98\r\x00\x00" +
-       "\x00\x00\x00\x01\x87\xef\xf0\x00\x00\x00\x00\x02w\xef\x00\x00\x00\x00\x00\x03q\fp\x00\x00\x00\x00\x04a\v\x80\x00\x00\x00\x00\x05P\xeep\x00\x00\x00\x00\x06@\xed\x80\x00\x00\x00\x00\a0\xd0p\x00\x00\x00\x00\a" +
-       "\x8d'\x80\x00\x00\x00\x00\t\x10\xb2p\x00\x00\x00\x00\t\xad\xa3\x00\x00\x00\x00\x00\n\xf0\x94p\x00\x00\x00\x00\v\xe0\x93\x80\x00\x00\x00\x00\fٰ\xf0\x00\x00\x00\x00\r\xc0u\x80\x00\x00\x00\x00\x0e\xb9\x92\xf0\x00" +
-       "\x00\x00\x00\x0f\xa9\x92\x00\x00\x00\x00\x00\x10\x99t\xf0\x00\x00\x00\x00\x11\x89t\x00\x00\x00\x00\x00\x12yV\xf0\x00\x00\x00\x00\x13iV\x00\x00\x00\x00\x00\x14Y8\xf0\x00\x00\x00\x00\x15I8\x00\x00\x00\x00\x00\x16" +
-       "9\x1a\xf0\x00\x00\x00\x00\x17)\x1a\x00\x00\x00\x00\x00\x18\"7p\x00\x00\x00\x00\x19\b\xfc\x00\x00\x00\x00\x00\x1a\x02\x19p\x00\x00\x00\x00\x1a\xf2\x18\x80\x00\x00\x00\x00\x1b\xe1\xfbp\x00\x00\x00\x00\x1c\xd1\xfa\x80\x00" +
-       "\x00\x00\x00\x1d\xc1\xddp\x00\x00\x00\x00\x1e\xb1܀\x00\x00\x00\x00\x1f\xa1\xbfp\x00\x00\x00\x00 v\x0f\x00\x00\x00\x00\x00!\x81\xa1p\x00\x00\x00\x00\"U\xf1\x00\x00\x00\x00\x00#j\xbd\xf0\x00\x00\x00\x00$" +
-       "5\xd3\x00\x00\x00\x00\x00%J\x9f\xf0\x00\x00\x00\x00&\x15\xb5\x00\x00\x00\x00\x00'*\x81\xf0\x00\x00\x00\x00'\xfeр\x00\x00\x00\x00)\nc\xf0\x00\x00\x00\x00)\u07b3\x80\x00\x00\x00\x00*\xeaE\xf0\x00" +
-       "\x00\x00\x00+\xbe\x95\x80\x00\x00\x00\x00,\xd3bp\x00\x00\x00\x00-\x9ew\x80\x00\x00\x00\x00.\xb3Dp\x00\x00\x00\x00/~Y\x80\x00\x00\x00\x000\x93&p\x00\x00\x00\x001gv\x00\x00\x00\x00\x002" +
-       "s\bp\x00\x00\x00\x003GX\x00\x00\x00\x00\x004R\xeap\x00\x00\x00\x005':\x00\x00\x00\x00\x0062\xccp\x00\x00\x00\x007\a\x1c\x00\x00\x00\x00\x008\x1b\xe8\xf0\x00\x00\x00\x008\xe6\xfe\x00\x00" +
-       "\x00\x00\x009\xfb\xca\xf0\x00\x00\x00\x00:\xc6\xe0\x00\x00\x00\x00\x00;۬\xf0\x00\x00\x00\x00<\xaf\xfc\x80\x00\x00\x00\x00=\xbb\x8e\xf0\x00\x00\x00\x00>\x8fހ\x00\x00\x00\x00?\x9bp\xf0\x00\x00\x00\x00@" +
-       "o\xc0\x80\x00\x00\x00\x00A\x84\x8dp\x00\x00\x00\x00BO\xa2\x80\x00\x00\x00\x00Cdop\x00\x00\x00\x00D/\x84\x80\x00\x00\x00\x00EDQp\x00\x00\x00\x00E\xf3\xb7\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x04\x05\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01" +
-       "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\xad\xd4\x00\x00\xff\xff\xb9\xb0\x01\x04\xff\xff" +
-       "\xab\xa0\x00\b\xff\xff\xb9\xb0\x00\f\xff\xff\xb9\xb0\x01\x10\xff\xff\xb9\xb0\x01\x14LMT\x00CDT\x00CST\x00EST\x00CWT\x00CPT\x00\nCST6CDT,M3.2." +
-       "0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\v\x00\x1c\x00US/MountainUT\t\x00\x03\xec,\x94_" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" +
-       "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff^\x04" +
-       "\f\xb0\xff\xff\xff\xff\x9e\xa6:\x90\xff\xff\xff\xff\x9f\xbb\a\x80\xff\xff\xff\xff\xa0\x86\x1c\x90\xff\xff\xff\xff\xa1\x9a\xe9\x80\xff\xff\xff\xff\xa2e\xfe\x90\xff\xff\xff\xff\xa3\x84\x06\x00\xff\xff\xff\xff\xa4E\xe0\x90\xff\xff" +
-       "\xff\xff\xa4\x8f\xa6\x80\xff\xff\xff\xffˉ\f\x90\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2a\x18\x00\xff\xff\xff\xff\xf7/v\x90\xff\xff\xff\xff\xf8(\x94\x00\xff\xff\xff\xff\xf9\x0fX\x90\xff\xff\xff\xff\xfa\b" +
-       "v\x00\xff\xff\xff\xff\xfa\xf8u\x10\xff\xff\xff\xff\xfb\xe8X\x00\xff\xff\xff\xff\xfc\xd8W\x10\xff\xff\xff\xff\xfd\xc8:\x00\xff\xff\xff\xff\xfe\xb89\x10\xff\xff\xff\xff\xff\xa8\x1c\x00\x00\x00\x00\x00\x00\x98\x1b\x10\x00\x00" +
-       "\x00\x00\x01\x87\xfe\x00\x00\x00\x00\x00\x02w\xfd\x10\x00\x00\x00\x00\x03q\x1a\x80\x00\x00\x00\x00\x04a\x19\x90\x00\x00\x00\x00\x05P\xfc\x80\x00\x00\x00\x00\x06@\xfb\x90\x00\x00\x00\x00\a0ހ\x00\x00\x00\x00\a\x8d" +
-       "5\x90\x00\x00\x00\x00\t\x10\xc0\x80\x00\x00\x00\x00\t\xad\xb1\x10\x00\x00\x00\x00\n\xf0\xa2\x80\x00\x00\x00\x00\vࡐ\x00\x00\x00\x00\fٿ\x00\x00\x00\x00\x00\r\xc0\x83\x90\x00\x00\x00\x00\x0e\xb9\xa1\x00\x00\x00" +
-       "\x00\x00\x0f\xa9\xa0\x10\x00\x00\x00\x00\x10\x99\x83\x00\x00\x00\x00\x00\x11\x89\x82\x10\x00\x00\x00\x00\x12ye\x00\x00\x00\x00\x00\x13id\x10\x00\x00\x00\x00\x14YG\x00\x00\x00\x00\x00\x15IF\x10\x00\x00\x00\x00\x169" +
-       ")\x00\x00\x00\x00\x00\x17)(\x10\x00\x00\x00\x00\x18\"E\x80\x00\x00\x00\x00\x19\t\n\x10\x00\x00\x00\x00\x1a\x02'\x80\x00\x00\x00\x00\x1a\xf2&\x90\x00\x00\x00\x00\x1b\xe2\t\x80\x00\x00\x00\x00\x1c\xd2\b\x90\x00\x00" +
-       "\x00\x00\x1d\xc1\xeb\x80\x00\x00\x00\x00\x1e\xb1\xea\x90\x00\x00\x00\x00\x1f\xa1̀\x00\x00\x00\x00 v\x1d\x10\x00\x00\x00\x00!\x81\xaf\x80\x00\x00\x00\x00\"U\xff\x10\x00\x00\x00\x00#j\xcc\x00\x00\x00\x00\x00$5" +
-       "\xe1\x10\x00\x00\x00\x00%J\xae\x00\x00\x00\x00\x00&\x15\xc3\x10\x00\x00\x00\x00'*\x90\x00\x00\x00\x00\x00'\xfeߐ\x00\x00\x00\x00)\nr\x00\x00\x00\x00\x00)\xde\xc1\x90\x00\x00\x00\x00*\xeaT\x00\x00\x00" +
-       "\x00\x00+\xbe\xa3\x90\x00\x00\x00\x00,\xd3p\x80\x00\x00\x00\x00-\x9e\x85\x90\x00\x00\x00\x00.\xb3R\x80\x00\x00\x00\x00/~g\x90\x00\x00\x00\x000\x934\x80\x00\x00\x00\x001g\x84\x10\x00\x00\x00\x002s" +
-       "\x16\x80\x00\x00\x00\x003Gf\x10\x00\x00\x00\x004R\xf8\x80\x00\x00\x00\x005'H\x10\x00\x00\x00\x0062ڀ\x00\x00\x00\x007\a*\x10\x00\x00\x00\x008\x1b\xf7\x00\x00\x00\x00\x008\xe7\f\x10\x00\x00" +
-       "\x00\x009\xfb\xd9\x00\x00\x00\x00\x00:\xc6\xee\x10\x00\x00\x00\x00;ۻ\x00\x00\x00\x00\x00<\xb0\n\x90\x00\x00\x00\x00=\xbb\x9d\x00\x00\x00\x00\x00>\x8f\xec\x90\x00\x00\x00\x00?\x9b\u007f\x00\x00\x00\x00\x00@o" +
-       "ΐ\x00\x00\x00\x00A\x84\x9b\x80\x00\x00\x00\x00BO\xb0\x90\x00\x00\x00\x00Cd}\x80\x00\x00\x00\x00D/\x92\x90\x00\x00\x00\x00ED_\x80\x00\x00\x00\x00E\xf3\xc5\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x03" +
-       "\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02" +
-       "\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xff\xff\x9d\x94\x00\x00\xff\xff\xab\xa0\x01\x04\xff\xff\x9d\x90\x00\b\xff\xff\xab\xa0\x01\f\xff\xff\xab\xa0\x01\x10LMT" +
-       "\x00MDT\x00MST\x00MWT\x00MPT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQt\xca{e\x92" +
-       "\x00\x00\x00\x92\x00\x00\x00\b\x00\x1c\x00US/SamoaUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\b\xff\xff\xff\xffn=\xc8\b\xff\xff\xff\xff\x91\x05\xfb\b\x01\x02\x00\x00\xb1x\x00\x00\xff\xff_\xf8\x00\x00\xff\xffeP\x00\x04LM" +
-       "T\x00SST\x00\nSST11\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00UTCUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\n" +
-       "UTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00UniversalUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" +
-       "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUT" +
-       "C0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\x04\x00\x1c\x00W-SUUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif" +
-       "2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00N\x00\x00\x00\v\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc0\xc7\xff\xff\xff\xff\x9b_\x1e\xc7\xff\xff\xff\xff" +
-       "\x9d>\xf2y\xff\xff\xff\xff\x9e*\xee\xf9\xff\xff\xff\xff\x9e\xf79i\xff\xff\xff\xff\x9f\x84W\xf9\xff\xff\xff\xff\xa0\xd8l\xe9\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xa1<\xa6@\xff\xff\xff\xff\xa4\x10m\xc0" +
-       "\xff\xff\xff\xff\xa4=2\xb0\xff\xff\xff\xff\xa5\x15h\xb0\xff\xff\xff\xff\xa5=\x03\xc0\xff\xff\xff\xff\xa7\x1eEP\xff\xff\xff\xff\xb5\xa4\x19`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00" +
-       "\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0" +
-       "\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00 lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00" +
-       "%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp" +
-       "\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x00" +
-       "2r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0" +
-       "\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00;\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00" +
-       "@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0" +
-       "\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00" +
-       "TL\x1d`\x01\x03\x02\x03\x04\x02\x04\x05\x06\x05\a\x05\x06\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\t\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
-       "\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\n\x06\x00\x00#9\x00\x00\x00\x00#9\x00\x04\x00\x001\x87\x01\b\x00\x00#w\x00\x04\x00\x00?\x97\x01\f\x00\x008@\x01\x11\x00\x00" +
-       "*0\x00\x15\x00\x00FP\x01\x19\x00\x00\x1c \x00\x1d\x00\x00*0\x01!\x00\x008@\x00\x15LMT\x00MMT\x00MST\x00MDST\x00MSD\x00MSK\x00+05\x00EET" +
-       "\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x1c\x00WETUT\t\x00\x03\xec,\x94_\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" +
-       "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x02\x00\x00\x00\t\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00" +
-       "\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb" +
-       "\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00" +
-       "\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E" +
-       "\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00" +
-       "\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9" +
-       "\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x00\x00\x00\x05\x00\x00\x0e\x10\x01\x00WEST\x00WET" +
-       "\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x04\x00\x1c\x00Zu" +
-       "luUT\t\x00\x03\xec,\x94_\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10" +
-       "\x00\xedA\x00\x00\x00\x00Africa/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc1\n\x8a\x84\xad\x00" +
-       "\x00\x00\xad\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81A\x00\x00\x00Africa/Sao_TomeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x817\x01\x00\x00Africa/Cona" +
-       "kryUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x01\x02\x00\x00Africa/DakarUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc9\x02\x00\x00Africa/NdjamenaUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQd\x01\x05\x89\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb2\x03\x00\x00" +
-       "Africa/CasablancaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{" +
-       "\x87\x82\x00\x00\x00\x82\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81|\v\x00\x00Africa/LomeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81C\f\x00\x00Africa/Algie" +
-       "rsUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x10\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81a\x0e\x00\x00Africa/MogadishuUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81a\x0f\x00\x00Africa/LagosUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81*\x10\x00\x00" +
-       "Africa/BrazzavilleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b" +
-       "{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf9\x10\x00\x00Africa/TimbuktuUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4\x11\x00\x00Africa/" +
-       "NouakchottUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00" +
-       "\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x91\x12\x00\x00Africa/MaseruUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x96\x13\x00\x00Africa/Libreville" +
-       "UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xa4\x81d\x14\x00\x00Africa/HarareUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.\x15\x00\x00Africa/MalaboUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8\x15\x00\x00Afri" +
-       "ca/BanguiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00" +
-       "\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2\x16\x00\x00Africa/NairobiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc0\x17\x00\x00Africa/KinshasaUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\x8c\x18\x00\x00Africa/Porto-NovoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Z\x19\x00\x00Africa/CairoUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9c\x1e\x00\x00Afr" +
-       "ica/DoualaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ%JO\xdf\xc1\x01\x00\x00\xc1\x01" +
-       "\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f\x1f\x00\x00Africa/JubaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81l!\x00\x00Africa/GaboroneUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x818\"\x00\x00Africa/TunisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE" +
-       "1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81?$\x00\x00Africa/KampalaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81=%\x00\x00Africa/M" +
-       "babaneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x12\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81C&\x00\x00Africa/Addis_AbabaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81E'\x00\x00Africa/MaputoUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\x0f(\x00\x00Africa/BissauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       " \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb(\x00\x00Africa/BlantyreUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7)\x00\x00Afric" +
-       "a/NiameyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00" +
-       "\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81*\x00\x00Africa/BanjulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81J+\x00\x00Africa/AbidjanUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81\x14,\x00\x00Africa/AsmaraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b" +
-       "{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x11-\x00\x00Africa/BamakoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xda-\x00\x00Africa/Ou" +
-       "agadougouUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00" +
-       "\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa8.\x00\x00Africa/LusakaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x11=\xfa\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81r/\x00\x00Africa/LuandaUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81<0\x00\x00Africa/AsmeraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b" +
-       "\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x8191\x00\x00Africa/LubumbashiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ9\x0f߁,\x02\x00\x00,\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\a2\x00\x00Afric" +
-       "a/AccraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\xadD\xef\xca\x01\x00\x00\xca\x01\x00\x00\x0f" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81y4\x00\x00Africa/KhartoumUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f\x1b\xeb\xdd2\x02\x00\x002\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8c6\x00\x00Africa/CeutaUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "\x049\x00\x00Africa/BujumburaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "m)\xb8P~\x02\x00\x00~\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd19\x00\x00Africa/WindhoekUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ)\xae\x8eo&\a\x00\x00&\a\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x98<\x00\x00Afric" +
-       "a/El_AaiunUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ_\u007f2[\xaf\x01\x00\x00\xaf\x01" +
-       "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\aD\x00\x00Africa/TripoliUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ6\x99rU\xa4\x00\x00\x00\xa4\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfeE\x00\x00Africa/MonroviaU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\xebF\x00\x00Africa/Dar_es_SalaamUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xefG\x00\x00Africa/JohannesburgUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\xfaH\x00\x00Africa/KigaliUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4I\x00\x00Africa/DjiboutiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3J\x00\x00Afri" +
-       "ca/FreetownUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x8eK\x00\x00America/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd0K\x00\x00America/Puerto_RicoUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xbf\x03u\xf3\xe4\x01\x00\x00\xe4\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\xceL\x00\x00America/RecifeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xd6\xfe\xf3%\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfaN\x00\x00America/ResoluteUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8Q\x00\x00Am" +
-       "erica/ManausUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ3\x9aG\xc8\xd0\x06\x00\x00" +
-       "\xd0\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdcS\x00\x00America/New_YorkUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1e+}\x15\xb4\x02\x00\x00\xb4\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6Z\x00\x00America/Rank" +
-       "in_InletUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfe7\xa1\x87\x1b\x01\x00\x00\x1b\x01\x00\x00" +
-       "\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8]\x00\x00America/LimaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y_\x00\x00America/St_Barthelem" +
-       "yUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\x0f(\b=\x01\x00\x00=\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81*`\x00\x00America/Santo_DomingoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb6a\x00\x00America/DetroitUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf1\xf9\x1dɻ\x00\x00\x00\xbb\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\x82e\x00\x00America/ParamariboUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x89f\x00\x00America/YakutatUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x04,2h\x99\x01\x00\x00\x99\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84j\x00\x00" +
-       "America/SantaremUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk^2S" +
-       "\xb9\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81gl\x00\x00America/Punta_ArenasUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81nq\x00\x00Amer" +
-       "ica/ScoresbysundUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ[Sp\x90" +
-       "\x02\x05\x00\x00\x02\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9bs\x00\x00America/SantiagoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x15\xc8\xcb\x00\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe7x\x00\x00America/" +
-       "GuyanaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x15\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdby\x00\x00America/Coral_HarbourUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\n{\x00\x00America/Rio_B" +
-       "rancoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8|\x00\x00America/Porto_AcreUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQp\x1b\xceRC\x03\x00\x00C\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe6~\x00\x00America/NipigonUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81r\x82\x00\x00America/EdmontonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x86\x86\x00\x00America/Port_of_SpainUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81W\x87\x00\x00America/Lower_PrincesUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81=\x88\x00\x00America/St_ThomasUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xac\x8a\x83S\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\n" +
-       "\x89\x00\x00America/GuatemalaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "R\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)\x8a\x00\x00America/CatamarcaUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x818\x8d\x00\x00Ame" +
-       "rica/AntiguaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1b\x81-\xa9\x8a\x01\x00\x00" +
-       "\x8a\x01\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03\x8e\x00\x00America/Porto_VelhoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ڏ\x00\x00America/R" +
-       "osarioUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe7\x92\x00\x00America/ChicagoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ⚵\xfb\x9e\x00\x00\x00\x9e\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\n\x9a\x00\x00America/CrestonUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe5s\xb3\\'\x01\x00\x00'\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x81\xf1\x9a\x00\x00America/ManaguaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x05{w\xe9\xad\x03\x00\x00\xad\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81a\x9c\x00\x00America/NassauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQc)\xf6)\xb3\x00\x00\x00\xb3\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81V\xa0\x00\x00Ameri" +
-       "ca/BogotaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf2\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00" +
-       "\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Q\xa1\x00\x00America/CancunUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaa\xa3\x00\x00America/Chihuahua" +
-       "UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xa4\x81I\xa5\x00\x00America/Campo_GrandeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81O\xa9\x00\x00America/HalifaxUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81 \xb0\x00\x00America/BoiseUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQӿ" +
-       "\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81N\xb4\x00\x00America/MontrealUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81M\xbb\x00\x00Americ" +
-       "a/Goose_BayUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9d?\xdfڸ\x03\x00\x00\xb8" +
-       "\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4\xc1\x00\x00America/Sao_PauloUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xaaʂA\xcd\x00\x00\x00\xcd\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc7\xc5\x00\x00America/Blan" +
-       "c-SablonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00" +
-       "\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2\xc6\x00\x00America/PhoenixUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1b\xc8\x00\x00America/AtikokanU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa1'\a\xbd\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81E\xc9\x00\x00America/CayenneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\xca\x00\x00America/NuukUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<\xcc\x00\x00Amer" +
-       "ica/Santa_IsabelUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf8Dz\x97" +
-       "\xae\x01\x00\x00\xae\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8b\xd0\x00\x00America/Boa_VistaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84\xd2\x00\x00America" +
-       "/Bahia_BanderasUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xe6\xd4\x00\x00America/Indiana/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ \x17\x89}q\x01\x00\x00q\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x810\xd5\x00\x00America/I" +
-       "ndiana/VevayUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00" +
-       "\x13\x02\x00\x00\x1c\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf0\xd6\x00\x00America/Indiana/IndianapolisUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQK-E\xfad\x02\x00\x00d\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y\xd9\x00\x00" +
-       "America/Indiana/WinamacUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQصK\xa6\n\x02\x00\x00\n\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e\xdc\x00\x00America/Indiana/Tell_CityUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x01\xd8N\x8c\xab\x02\x00\x00\xab\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81k\xde\x00\x00America/Indiana/PetersburgUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81j\xe1\x00\x00America/Indiana/" +
-       "VincennesUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ$ \x873\xf8\x03\x00\x00\xf8\x03\x00" +
-       "\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xe3\x00\x00America/Indiana/KnoxUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQM/U\x9f7\x02\x00\x007\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x811\xe8\x00\x00America/Ind" +
-       "iana/MarengoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00" +
-       "\x13\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb9\xea\x00\x00America/IndianapolisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1a\xed\x00\x00America/" +
-       "DominicaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xe6\xed\x00\x00America/Argentina/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQt*\x9b!\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x812\xee\x00\x00America/Argent" +
-       "ina/SaltaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00" +
-       "\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x815\xf1\x00\x00America/Argentina/UshuaiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L\xf4\x00\x00Americ" +
-       "a/Argentina/CatamarcaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "QR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 \x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81e\xf7\x00\x00America/Argentina/ComodRivada" +
-       "viaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfcz=\xe1\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x83\xfa\x00\x00America/Argentina/San_JuanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1c\x80\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa4\xfd\x00\x00America/Arg" +
-       "entina/San_LuisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8ep\xb4c\xc4" +
-       "\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc5\x00\x01\x00America/Argentina/Rio_GallegosUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81\xe1\x03\x01\x00America/Argentina/JujuyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQY\xd8֭\xd6\x02\x00\x00\xd6\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe4\x06\x01\x00America/Argentina/Tucu" +
-       "manUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\r\n\x01\x00America/Argentina/Buenos_AiresUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)\r\x01\x00America" +
-       "/Argentina/CordobaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQm\a" +
-       "D\x0e\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81@\x10\x01\x00America/Argentina/La_RiojaUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "a\x13\x01\x00America/Argentina/MendozaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xad`\x12\xe9\xaa\x00\x00\x00\xaa\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81x\x16\x01\x00America/La_PazUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfe\xe6\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81j" +
-       "\x17\x01\x00America/DawsonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ.\xf9\xc0" +
-       "\x1e\xd5\x05\x00\x00\xd5\x05\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7\x1b\x01\x00America/MonctonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQU\xactA\xb5\x01\x00\x00\xb5\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5!\x01\x00America/" +
-       "MatamorosUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00" +
-       "\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5#\x01\x00America/St_VincentUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\u0096dK~\x02\x00\x00~\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3$\x01\x00America/Regin" +
-       "aUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81i'\x01\x00America/YellowknifeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8f*\x01\x00America/Rainy_RiverU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\x1f.\x01\x00America/KralendijkUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQMv\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02/\x01\x00America/MonterreyUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "r0\x01\x00America/JamaicaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\a" +
-       "\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e2\x01\x00America/HavanaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x82\x13z\xe2\xc2\x00\x00\x00\xc2\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb36\x01\x00America" +
-       "/TegucigalpaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcd\xc3v\xe3\xb3\x00\x00\x00" +
-       "\xb3\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc27\x01\x00America/GuayaquilUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa2\x81\xbfyS\x02\x00\x00S\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc08\x01\x00America/Met" +
-       "lakatlaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ8\xcdZ\x05o\x01\x00\x00o\x01\x00\x00\x10" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81_;\x01\x00America/MazatlanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQHQ(\x9a~\x02\x00\x00~\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x18=\x01\x00America/BelizeUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\xde?\x01\x00America/Knox_INUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1fD\x01\x00America/CuiabaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQo_\x00v/\x01\x00\x00/\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\rH\x01\x00Amer" +
-       "ica/MeridaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQutZ\x1a\xb2\x02\x00\x00\xb2\x02" +
-       "\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84I\x01\x00America/JujuyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81}L\x01\x00America/CaymanUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x85-\xb9\xf8\x8a\x01\x00\x00\x8a\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81ZM\x01\x00America/BelemUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "s\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81+O\x01\x00America/EirunepeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)Q\x01\x00Amer" +
-       "ica/St_LuciaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQOKjǪ\x02\x00\x00" +
-       "\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5Q\x01\x00America/BahiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe6T\x01\x00America/Whiteho" +
-       "rseUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x817Y\x01\x00America/TortolaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQU9#\xbe2\x05\x00\x002\x05\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02Z\x01\x00America/VancouverUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf7\xe9 y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81\u007f_\x01\x00America/InuvikUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb4" +
-       "T\xbd\xeb5\x02\x00\x005\x02\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84b\x01\x00America/Port-au-PrinceUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb4\x11Z\xde\xe4\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\te\x01" +
-       "\x00America/FortalezaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb7-" +
-       "2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x818g\x01\x00America/NoronhaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ei\x01\x00America" +
-       "/Buenos_AiresUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\"\x12\xfe\x0e\x05\x00" +
-       "\x00\x0e\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81wl\x01\x00America/Los_AngelesUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd2q\x01\x00America/" +
-       "El_SalvadorUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12" +
-       "\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcfr\x01\x00America/DenverUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)w\x01\x00America/Fort_Wa" +
-       "yneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x10\x00\xedA\x88y\x01\x00America/Kentucky/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd3y\x01\x00America/Kentucky/Lou" +
-       "isvilleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00\x1b" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02\u007f\x01\x00America/Kentucky/MonticelloUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA#\x83\x01\x00Americ" +
-       "a/North_Dakota/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQR\x1b\x8b(\xde" +
-       "\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81r\x83\x01\x00America/North_Dakota/New_SalemUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81\xa8\x87\x01\x00America/North_Dakota/CenterUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb7.\xb6*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ۋ\x01\x00America/North_Dako" +
-       "ta/BeulahUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQM\x94\xc7Kp\x03\x00\x00p\x03\x00" +
-       "\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81C\x90\x01\x00America/Glace_BayUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfe\x93\x01\x00America/Montse" +
-       "rratUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81̔\x01\x00America/TorontoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ʛ\x01\x00America/PanamaUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa7" +
-       "\x9c\x01\x00America/CordobaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xdf\xe5" +
-       "\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4\x9f\x01\x00America/LouisvilleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ڤ\x01\x00Amer" +
-       "ica/EnsenadaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00" +
-       "\x12\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\xa9\x01\x00America/ShiprockUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81\xad\x01\x00America/Ojin" +
-       "agaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQU\r\xf7\xd3\xc7\x01\x00\x00\xc7\x01\x00\x00\r\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xae\xaf\x01\x00America/ThuleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbc\xb1\x01\x00America/CaracasUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ò\x01" +
-       "\x00America/AraguainaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1d`" +
-       "̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81^\xb5\x01\x00America/Cambridge_BayUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xad\xb8\x01\x00A" +
-       "merica/WinnipegUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ8\xa4]Q^" +
-       "\x03\x00\x00^\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05\xbe\x01\x00America/Grand_TurkUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaf\xc1\x01\x00America" +
-       "/VirginUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81y\xc2\x01\x00America/AnchorageUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x95\xc6\x01\x00America/Costa_Ri" +
-       "caUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQn\xab\xd5\xf9\xcf\x03\x00\x00\xcf\x03\x00\x00\f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\xc9\xc7\x01\x00America/NomeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde\xcb\x01\x00America/GrenadaUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa9\xcc\x01\x00A" +
-       "merica/St_JohnsUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9" +
-       "\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81I\xd4\x01\x00America/AtkaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81X\xd8\x01\x00America/Asunc" +
-       "ionUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x16\xdc\x01\x00America/HermosilloUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x80\xdd\x01\x00America/TijuanaUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x81\xca\xe1\x01\x00America/MarigotUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q?\xc9\x1c\xd4\xc6\x03\x00\x00\xc6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x95\xe2\x01\x00America/JuneauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc0\x98\x00\b\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3\xe6\x01\x00Ameri" +
-       "ca/MontevideoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe90T\x16\xd1\x01\x00" +
-       "\x00\xd1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb8\xea\x01\x00America/GodthabUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd2\xec\x01\x00America/Guad" +
-       "eloupeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ挋\x92\xf6\x01\x00\x00\xf6\x01\x00\x00\x0e\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa0\xed\x01\x00America/MaceioUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQJtZ\x8c\x01\x03\x00\x00\x01\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde\xef\x01\x00America/PangnirtungU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81,\xf3\x01\x00America/St_KittsUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xdf\b\x9c\x9f\xe7\x00\x00\x00\xe7\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8\xf3\x01\x00America/BarbadosUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)\xf5\x01" +
-       "\x00America/IqaluitUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ8O:\xbf" +
-       "\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81V\xf8\x01\x00America/MenomineeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x816\xfc\x01\x00America" +
-       "/MartiniqueUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd6\xe1Հ\x9c\x01\x00\x00\x9c" +
-       "\x01\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x814\xfd\x01\x00America/Mexico_CityUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1c\xd8\x19\x9dp\x01\x00\x00p\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1d\xff\x01\x00America/Sw" +
-       "ift_CurrentUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd7\b\\\xc6&\x02\x00\x00&" +
-       "\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdc\x00\x02\x00America/MiquelonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L\x03\x02\x00America/Curac" +
-       "aoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ+\x10`ȫ\x02\x00\x00\xab\x02\x00\x00\x14\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81,\x04\x02\x00America/Dawson_CreekUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\a\x02\x00America/MendozaUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x812\n\x02\x00America/AdakUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe9" +
-       "\x8c\xb4$q\x03\x00\x00q\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81A\x0e\x02\x00America/Thunder_BayUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xff\x11\x02\x00Am" +
-       "erica/ArubaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf6@\rm\xa8\x05\x00\x00\xa8" +
-       "\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdd\x12\x02\x00America/Fort_NelsonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x81{\xc1\x92\xbc\x03\x00\x00\xbc\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd2\x18\x02\x00America/Si" +
-       "tkaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5\x1c\x02\x00America/AnguillaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1\x1d\x02\x00America/DanmarkshavnU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x10\x00\xedA\xae\x1f\x02\x00Antarctica/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\x95{\xf3\xa9w\x03\x00\x00w\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf3\x1f\x02\x00Antarctica/PalmerUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x95\xea\x06\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5#\x02\x00Ant" +
-       "arctica/DavisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQƉ\xf71\x84\x00\x00" +
-       "\x00\x84\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4$\x02\x00Antarctica/RotheraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x94%\x02\x00Antarctic" +
-       "a/VostokUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\r\x0e\xf20\x85\x00\x00\x00\x85\x00\x00\x00" +
-       "\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81d&\x02\x00Antarctica/SyowaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc8\x14\xdcA\x98\x00\x00\x00\x98\x00\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x813'\x02\x00Antarctica/Dumon" +
-       "tDUrvilleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00" +
-       "\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1e(\x02\x00Antarctica/McMurdoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x97\xd4#\xed\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81},\x02\x00Antarctica/Ma" +
-       "cquarieUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9b0\x02\x00Antarctica/South_PoleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ:\xc8P7\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfd4\x02\x00Antarctica/T" +
-       "rollUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd7N\xab\x8b\x98\x00\x00\x00\x98\x00\x00\x00\x11\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf85\x02\x00Antarctica/MawsonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xddzAh\xf3\x00\x00\x00\xf3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdb6\x02\x00Antarctica/CaseyUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10" +
-       "\x00\xedA\x188\x02\x00Arctic/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x97\aĤ\x02" +
-       "\x00\x00\xa4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y8\x02\x00Arctic/LongyearbyenUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAJ;\x02\x00Asia/UT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ's\x96\x1en\x01\x00\x00n\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\x89;\x02\x00Asia/DushanbeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\xa1\xfax\x98g\x02\x00\x00g\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>=\x02\x00Asia/QostanayUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xec?\x02\x00Asia/C" +
-       "alcuttaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\v" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0fA\x02\x00Asia/UrumqiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd9A\x02\x00Asia/KarachiUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)C\x02\x00" +
-       "Asia/KhandygaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQj$\xcd\xf4\x9a\x00\x00" +
-       "\x00\x9a\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81wF\x02\x00Asia/ThimbuUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81VG\x02\x00Asia/ThimphuUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQd%\x05\xd8\xe6\x02\x00\x00\xe6\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x816H\x02\x00Asia/VladivostokUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81fK\x02\x00Asia/VientianeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81FL\x02\x00Asia" +
-       "/ShanghaiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00" +
-       "\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x16N\x02\x00Asia/Ulan_BatorUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb1P\x02\x00Asia/AdenUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81y" +
-       "Q\x02\x00Asia/MuscatUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xef\\\xf4q\x17\x04" +
-       "\x00\x00\x17\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81CR\x02\x00Asia/DamascusUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1V\x02\x00Asia/Jerusale" +
-       "mUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQy\x19\xe0N\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81\t[\x02\x00Asia/BruneiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe8[\x02\x00Asia/UlaanbaatarUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xceG|\xea\x13\x03\x00\x00\x13\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84^\x02\x00As" +
-       "ia/AmmanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa7f^]@\x01\x00\x00@\x01\x00\x00" +
-       "\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdba\x02\x00Asia/KuchingUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ac\x02\x00Asia/Tel_AvivUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc8" +
-       "g\x02\x00Asia/SeoulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ?\xa7^\xfah\x02\x00" +
-       "\x00h\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xabi\x02\x00Asia/AtyrauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8a\xc1\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Xl\x02\x00Asia/PyongyangUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xba\xa3b\xc1R\x02\x00\x00R\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81Wm\x02\x00Asia/HovdUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x06\r" +
-       "\xed\xbd\x04\x00\x00\xbd\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeco\x02\x00Asia/HebronUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeet\x02\x00Asia/KuwaitU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\xb8u\x02\x00Asia/TomskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc7" +
-       "\xaf\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xedx\x02\x00Asia/ManilaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81 z\x02\x00Asia/Chita" +
-       "UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xa4\x81R}\x02\x00Asia/KatmanduUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xac\xf7\xf4\xc0\xab\x04\x00\x00\xab\x04\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81:~\x02\x00Asia/GazaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQw\rD\an\x01\x00\x00n\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81(\x83\x02\x00Asia/Sam" +
-       "arkandUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ބ\x02\x00Asia/TaipeiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\"\x87\x02\x00Asia/TashkentUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\xea\x18\xd4\xf8\x02\x00\x00\xf8\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\u05c8\x02\x00" +
-       "Asia/YekaterinburgUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1d?" +
-       "v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1b\x8c\x02\x00Asia/MacauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd5ΜGp\x02\x00\x00p\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81v\x8f\x02\x00Asia/Qyzylor" +
-       "daUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81.\x92\x02\x00Asia/MacaoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x89\x95\x02\x00Asia/TokyoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa2\x96\x02\x00Asia/Bak" +
-       "uUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x87\xbd\xedL\xf1\x02\x00\x00\xf1\x02\x00\x00\f\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81͙\x02\x00Asia/BarnaulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x04\x9d\x02\x00Asia/IstanbulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf9l\x03\x12\xf8\x02\x00\x00\xf8\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfb\xa1\x02\x00Asia" +
-       "/IrkutskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00" +
-       "\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x819\xa5\x02\x00Asia/QatarUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x15\xa6\x02\x00Asia/BahrainUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf3\xa6\x02\x00" +
-       "Asia/YangonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x02\x95-\xad\xc4\x02\x00\x00\xc4" +
-       "\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf3\xa7\x02\x00Asia/YerevanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQS\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfd\xaa\x02\x00Asia/AlmatyUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQΒ\x1a\x8c\xaa\x00\x00\x00\xaa\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "\xa3\xad\x02\x00Asia/DiliUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ?Y\xaf\x19\xe7\x00\x00" +
-       "\x00\xe7\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x90\xae\x02\x00Asia/DaccaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbb\xaf\x02\x00Asia/ChongqingUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQw\x86\x8d^\x03\x03\x00\x00\x03\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\x8c\xb1\x02\x00Asia/Ust-NeraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ִ\x02\x00Asia/MagadanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\v\xb8\x02\x00Asia/Col" +
-       "omboUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQL\xe0\x91y\xe5\x02\x00\x00\xe5\x02\x00\x00\x10\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81H\xb9\x02\x00Asia/KrasnoyarskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\xf0\x9cf>\xd7\x02\x00\x00\xd7\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81w\xbc\x02\x00Asia/KamchatkaUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "\x96\xbf\x02\x00Asia/Ujung_PandangUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa0\xc0\x02\x00Asia/JakartaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde\xc1\x02\x00Asia/K" +
-       "olkataUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\xc3\x02\x00Asia/KabulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe3\xc3\x02\x00Asia/OralUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x97\xc6\x02\x00Asia/" +
-       "JayapuraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQS\xa5\x81e\xf7\x00\x00\x00\xf7\x00\x00\x00" +
-       "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x89\xc7\x02\x00Asia/PontianakUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc8\xc8\x02\x00Asia/MakassarUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQѾ\xa8\xc7u\x02\x00\x00u\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81\xcd\xc9\x02\x00Asia/TbilisiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x06\xaa>" +
-       "\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x88\xcc\x02\x00Asia/SingaporeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd0\xcd\x02\x00Asia/Harb" +
-       "inUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\x9e\xcf\x02\x00Asia/KashgarUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81i\xd0\x02\x00Asia/DhakaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQO\xb0\x03\xe9\xe5\x02\x00\x00\xe5\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x94\xd1\x02\x00Asia/Y" +
-       "akutskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ恸\x1e\x00\x01\x00\x00\x00\x01\x00\x00\x11\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbf\xd4\x02\x00Asia/Kuala_LumpurUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\n\xd6\x02\x00Asia/TehranUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "#\xde\x02\x00Asia/BeirutUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xdb\xfa\xb5\xbeg" +
-       "\x02\x00\x00g\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81D\xe1\x02\x00Asia/AqtobeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf0\xe3\x02\x00Asia/AnadyrUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ0]*\x1bj\x02\x00\x00j\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\x1c\xe7\x02\x00Asia/BishkekUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xed" +
-       "\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcc\xe9\x02\x00Asia/DubaiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x95\xea\x02\x00Asia/Riyadh" +
-       "UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xa4\x81_\xeb\x02\x00Asia/NovokuznetskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQT\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x80\xee\x02\x00Asia/AqtauUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\"\xf1\x02\x00Asi" +
-       "a/OmskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQe\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81J\xf4\x02\x00Asia/AshkhabadUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQ\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\t\xf6\x02\x00Asia/SaigonUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ)\x15II\xf3\x02\x00\x00\xf3\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81:\xf7\x02" +
-       "\x00Asia/SakhalinUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQE\t\xfa-\a\x03" +
-       "\x00\x00\a\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81t\xfa\x02\x00Asia/Hong_KongUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3\xfd\x02\x00Asia/Phnom_P" +
-       "enhUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa4\xfe\x02\x00Asia/NicosiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xd7e&uv\x02\x00\x00v\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81?\x01\x03\x00Asia/BaghdadUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa4Zߐ\xe6\x02\x00\x00\xe6\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfb\x03\x03\x00Asi" +
-       "a/SrednekolymskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQe\x1bb2w" +
-       "\x01\x00\x00w\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81-\a\x03\x00Asia/AshgabatUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\b\x03\x00Asia/Kathman" +
-       "duUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x81z&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\xd4\t\x03\x00Asia/ChoibalsanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x88\f\x03\x00Asia/BangkokUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f\r\x03\x00A" +
-       "sia/ChungkingUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ)p\x1cX\xf1\x02\x00" +
-       "\x00\xf1\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x817\x0f\x03\x00Asia/NovosibirskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ]S\xbb\x12\xac\x03\x00\x00\xac\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81r\x12\x03\x00Asia/Famagu" +
-       "staUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\f\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81f\x16\x03\x00Asia/RangoonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81g\x17\x03\x00Asia/Ho_Chi_MinhUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x9d\x18\x03" +
-       "\x00Atlantic/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01" +
-       "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe0\x18\x03\x00Atlantic/FaroeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK" +
-       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe1\x1a\x03\x00Atlantic/CanaryU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe7\xcf^\xb0\x15\x03\x00\x00\x15\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\b\x1d\x03\x00Atlantic/StanleyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\x9b\xe9\xf4\x9a\xf9\x02\x00\x00\xf9\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81g \x03\x00Atlantic/BermudaUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x0f-\xadׄ\x00\x00\x00\x84\x00\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaa#\x03" +
-       "\x00Atlantic/South_GeorgiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81~$\x03\x00Atlantic/St_HelenaUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L%\x03" +
-       "\x00Atlantic/Jan_MayenUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb7" +
-       "\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<(\x03\x00Atlantic/FaeroeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>*\x03\x00Atlant" +
-       "ic/ReykjavikUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\u0097N\xad\xaf\x00\x00\x00" +
-       "\xaf\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81{-\x03\x00Atlantic/Cape_VerdeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQW\x99\x9d\v\x9b\x05\x00\x00\x9b\x05\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81w.\x03\x00Atlantic/" +
-       "AzoresUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x82\xfa Z\x9b\x05\x00\x00\x9b\x05\x00\x00\x10\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81[4\x03\x00Atlantic/MadeiraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA@:\x03\x00Australia/UT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x85&'\x88\x03\x00\x00\x88\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84:" +
-       "\x03\x00Australia/MelbourneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x9c\xd2I\f!\x01\x00\x00!\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y>\x03\x00Australia/QueenslandUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe2\xf1\x9d4\xea\x00\x00\x00\xea\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc8?\x03" +
-       "\x00Australia/NorthUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQo3\xdaR" +
-       "\xb4\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfb@\x03\x00Australia/Lord_HoweUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQͥ\xdfD\x99\x03\x00\x00\x99\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfcC\x03\x00Austr" +
-       "alia/AdelaideUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ1\x9eD\x00\xad\x03\x00" +
-       "\x00\xad\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe1G\x03\x00Australia/YancowinnaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa5\x85&'\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdcK\x03\x00Austral" +
-       "ia/VictoriaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88" +
-       "\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb0O\x03\x00Australia/CanberraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84S\x03\x00Australia/S" +
-       "ydneyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81VW\x03\x00Australia/ACTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ.\x1b\xa53:\x01\x00\x00:\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%[\x03\x00Australia/EuclaUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9c\xd2I\f!\x01\x00\x00!\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa8" +
-       "\\\x03\x00Australia/BrisbaneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "QʹF\xd6\xc7\x03\x00\x00\xc7\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x15^\x03\x00Australia/TasmaniaUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQʹF\xd6\xc7\x03\x00\x00\xc7\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81(b\x03\x00A" +
-       "ustralia/HobartUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x98Ò\x8d2" +
-       "\x01\x00\x002\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x819f\x03\x00Australia/PerthUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQͥ\xdfD\x99\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4g\x03\x00Australia/" +
-       "SouthUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xce\xe5\x90AE\x01\x00\x00E\x01\x00\x00\x12\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x96k\x03\x00Australia/LindemanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe2\xf1\x9d4\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81'm\x03\x00Australia/DarwinU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x98Ò\x8d2\x01\x00\x002\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81[n\x03\x00Australia/WestUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5o\x03\x00Australia/LHIUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQf\xdd}\xfe\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd0r\x03\x00Aust" +
-       "ralia/NSWUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ1\x9eD\x00\xad\x03\x00\x00\xad\x03\x00" +
-       "\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9fv\x03\x00Australia/Broken_HillUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc4\xd5\x01\xe5\u007f\x03\x00\x00\u007f\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9bz\x03\x00Australia/" +
-       "CurrieUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAd~\x03\x00Brazil/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5~\x03\x00Brazil/DeNoronhaUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ӏ\x03\x00B" +
-       "razil/AcreUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9d?\xdfڸ\x03\x00\x00\xb8\x03" +
-       "\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xba\x82\x03\x00Brazil/EastUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7\x86\x03\x00Brazil/WestUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe6\x9aM\xbem\x02\x00\x00m\x02\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x98\x88" +
-       "\x03\x00CETUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81B\x8b\x03\x00CST6CDTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA:\x8f\x03\x00Canada/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81{\x8f\x03\x00Canada/Atla" +
-       "nticUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQU9#\xbe2\x05\x00\x002\x05\x00\x00\x0e\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L\x96\x03\x00Canada/PacificUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ƛ\x03\x00Canada/EasternUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81â" +
-       "\x03\x00Canada/YukonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\u0096dK~\x02" +
-       "\x00\x00~\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e\xa7\x03\x00Canada/SaskatchewanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81٩\x03\x00Canada/" +
-       "NewfoundlandUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ?_p\x99\x0e\x05\x00\x00" +
-       "\x0e\x05\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81|\xb1\x03\x00Canada/CentralUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ҷ\x03\x00Canada/Mountai" +
-       "nUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x10\x00\xedA\xe5\xba\x03\x00Chile/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xd0\x1c" +
-       "YN\x04\x00\x00N\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\xbb\x03\x00Chile/EasterIslandUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbf\xbf\x03\x00Chile" +
-       "/ContinentalUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\a\x1c\x9e\x9a]\x04\x00\x00" +
-       "]\x04\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\f\xc5\x03\x00CubaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa7\xc9\x03\x00EETUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQtX\xbe\xe4o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5\xcb\x03\x00ESTUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81\xcc" +
-       "\x03\x00EST5EDTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x12tnj\xfc\x04\x00\x00\xfc\x04\x00" +
-       "\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81y\xd0\x03\x00EgyptUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4\xd5\x03\x00EireUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xca\xdb\x03\x00Etc/UT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd9|\xbd7s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\b\xdc" +
-       "\x03\x00Etc/GMT-10UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe5\xf38cr\x00\x00\x00" +
-       "r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbf\xdc\x03\x00Etc/GMT+12UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb2\xab\xd1Is\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81u\xdd\x03\x00Etc/GMT-11UT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,\xde" +
-       "\x03\x00Etc/UniversalUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o" +
-       "\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2\xde\x03\x00Etc/GreenwichUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x98\xdf\x03\x00Etc/GMT-6UT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81M\xe0\x03\x00Etc/GMT-1UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc5\x18\xb6\xfb" +
-       "r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02\xe1\x03\x00Etc/GMT-8UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7\xe1\x03\x00Etc/GMT+4UT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQe\xcb\xe9Qq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "k\xe2\x03\x00Etc/GMT+3UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfc\x19@\xb9r\x00\x00" +
-       "\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1f\xe3\x03\x00Etc/GMT-9UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd4\xe3\x03\x00Etc/GMT-0UT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQJ0p-r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x86\xe4\x03" +
-       "\x00Etc/GMT-7UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xa9{\xa2qq\x00\x00\x00q\x00" +
-       "\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81;\xe5\x03\x00Etc/GMT+2UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ\xd4X\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xef\xe5\x03\x00Etc/GMT+5UT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3\xe6\x03\x00Et" +
-       "c/GMTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\b\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81S\xe7\x03\x00Etc/ZuluUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ)\xb9\xbe\x9dr\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x04\xe8\x03\x00Etc/GMT+11UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xba\xe8\x03\x00Etc/GMT" +
-       "-13UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ,{\xdc;s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81q\xe9\x03\x00Etc/GMT-14UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81(\xea\x03\x00Etc/GMT+10UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde\xea\x03\x00Etc/GMT" +
-       "-12UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\b\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x95\xeb\x03\x00Etc/GMT0UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81F\xec\x03\x00Etc/UCTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6\xec\x03\x00Etc/GMT+0UT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x84+\x9a$q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\xa8\xed\x03\x00Etc/GMT+7UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x84\x19\xb3\t" +
-       "q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\\\xee\x03\x00Etc/GMT+9UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xbc\x19y\x04r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x10\xef\x03\x00Etc/GMT-2UT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "\xc5\xef\x03\x00Etc/GMT-5UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\"\xf8\x8f/q\x00\x00" +
-       "\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81z\xf0\x03\x00Etc/GMT+8UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.\xf1\x03\x00Etc/GMT+6UT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ5\xb8\xe8\x86q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2\xf1\x03" +
-       "\x00Etc/GMT+1UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00" +
-       "\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x96\xf2\x03\x00Etc/UTCUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQk\x19<Qr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81F\xf3\x03\x00Etc/GMT-4UT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9c\xfcm\x99r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfb\xf3\x03\x00Etc/" +
-       "GMT-3UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xb0\xf4\x03\x00Europe/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf1\xf4\x03\x00Europe/ZurichUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc7\xf5\x94\xdaQ\x04\x00\x00Q\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)\xf7\x03\x00Europ" +
-       "e/ParisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\r" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc0\xfb\x03\x00Europe/MoscowUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQM\xe5\xa9 ?\x04\x00\x00?\x04\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x93\xff\x03\x00Europe/LuxembourgUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\x1d\x04\x04\x00Europe/LjubljanaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81E\x06\x04\x00Europe/HelsinkiUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQWI\xc3\u007f(\x03\x00\x00(\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o\b\x04\x00Eu" +
-       "rope/MinskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01" +
-       "\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdd\v\x04\x00Europe/SkopjeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02\x0e\x04\x00Europe/DublinUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x81!\x14\x04\x00Europe/JerseyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x95" +
-       "\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa7\x1a\x04\x00Europe/San_MarinoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ==\xa4\x16\xc4\x04\x00\x00\xc4\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5\x1e\x04\x00Euro" +
-       "pe/GibraltarUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00" +
-       "\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb3#\x04\x00Europe/BelgradeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xda%\x04\x00Europe/Guerns" +
-       "eyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQu\xb0\xcd\xfc\xf8\x02\x00\x00\xf8\x02\x00\x00\x10\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81b,\x04\x00Europe/UlyanovskUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\x1b8\xfel\xd6\x02\x00\x00\xd6\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa4/\x04\x00Europe/SaratovUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc22" +
-       "\x04\x00Europe/VaduzUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\aW\x10Ѱ\x04" +
-       "\x00\x00\xb0\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf94\x04\x00Europe/IstanbulUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf29\x04\x00Europe/Lisb" +
-       "onUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQN\xa5\xa5\xcb\x12\x02\x00\x00\x12\x02\x00\x00\x0f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\xd5?\x04\x00Europe/UzhgorodUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ\xe0\xfe\x83\xe5\xcd\x02\x00\x00\xcd\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x810B\x04\x00Europe/KirovUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xea\xc48\xde\\\x02\x00\x00\\\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81CE\x04\x00E" +
-       "urope/TiraneUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQI\xb8\xbc\xd3\xf3\x02\x00\x00" +
-       "\xf3\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe6G\x04\x00Europe/TiraspolUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\"K\x04\x00Europe/Saraje" +
-       "voUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQZk#V\x81\x03\x00\x00\x81\x03\x00\x00\r\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81IM\x04\x00Europe/MadridUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x11Q\x04\x00Europe/PodgoricaUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x819S\x04" +
-       "\x00Europe/BusingenUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x95\xb4\x9e\xe7" +
-       "\xb3\x03\x00\x00\xb3\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81sU\x04\x00Europe/VaticanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81nY\x04\x00Europe/Bel" +
-       "fastUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\x11\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5_\x04\x00Europe/BratislavaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ8I\xdeN%\x02\x00\x00%\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x13c\x04\x00Europe/KievUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQO+j\x94\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81}e" +
-       "\x04\x00Europe/KaliningradUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\xf2\xfa\xcb\x130\x02\x00\x000\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Qi\x04\x00Europe/ZaporozhyeUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQZ\x05wג\x02\x00\x00\x92\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcck\x04\x00Eur" +
-       "ope/ViennaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe6Kf\xab\xfe\x02\x00\x00\xfe\x02" +
-       "\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5n\x04\x00Europe/BudapestUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00P" +
-       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xccb\xf72\xa4\x02\x00\x00\xa4\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xecq\x04\x00Europe/VilniusU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQn\x81\xf4\xd7Z\x04\x00\x00Z\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\xd8t\x04\x00Europe/MonacoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81yy\x04\x00Europe/OsloUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ]i\x11u\xd6\x02\x00\x00\xd6\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81b|\x04\x00Europe/" +
-       "AstrakhanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQz\xc3\xe8Ra\x03\x00\x00a\x03\x00" +
-       "\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82\u007f\x04\x00Europe/SimferopolUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQq\xf7p*\xd6\x02\x00\x00\xd6\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.\x83\x04\x00Europe/Volgogr" +
-       "adUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x12\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81N\x86\x04\x00Europe/Isle_of_ManUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03" +
-       "\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ٌ\x04\x00Europe/LondonUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQgp\xc0\xa7\xb6\x02\x00\x00\xb6\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81_" +
-       "\x93\x04\x00Europe/RigaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQߜvυ\x01" +
-       "\x00\x00\x85\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Z\x96\x04\x00Europe/AndorraUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81'\x98\x04\x00Europe/Pragu" +
-       "eUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x17S\x91\xb3\xc1\x02\x00\x00\xc1\x02\x00\x00\r\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81A\x9b\x04\x00Europe/BerlinUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQq\x16\x9b?\xa3\x02\x00\x00\xa3\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81I\x9e\x04\x00Europe/TallinnUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x814\xa1\x04\x00Eu" +
-       "rope/RomeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQh\xa5J[\xa0\x03\x00\x00\xa0\x03\x00" +
-       "\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,\xa5\x04\x00Europe/MaltaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x12\xa9\x04\x00Europe/ZagrebUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc9\a\xa0\xe1/\x04\x00\x00/\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "7\xab\x04\x00Europe/AmsterdamUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb0\xaf\x04\x00Europe/NicosiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x90\xa9\xf5ϕ\x02\x00\x00\x95\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81M\xb2\x04\x00Europe" +
-       "/BucharestUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x92\xfc\f+o\x02\x00\x00o\x02" +
-       "\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,\xb5\x04\x00Europe/CopenhagenUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe6\xb7\x04\x00Europe/Chisin" +
-       "auUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x10\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\"\xbb\x04\x00Europe/MariehamnUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\x8c\xc8\x15\xd0P\x02\x00\x00P\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81M\xbd\x04\x00Europe/SofiaUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcb*j\x8f\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe3\xbf\x04\x00" +
-       "Europe/AthensUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd9L\xf6\xf7\xf1\x01\x00" +
-       "\x00\xf1\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd4\xc2\x04\x00Europe/StockholmUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x95\u007fpp\xdc\x02\x00\x00\xdc\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0f\xc5\x04\x00Europe/Sama" +
-       "raUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQo\xbc\x831O\x04\x00\x00O\x04\x00\x00\x0f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x812\xc8\x04\x00Europe/BrusselsUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
-       "\x00\x00\x00\x0e|XQ>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xca\xcc\x04\x00Europe/WarsawUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xab\x80c$q\x00\x00\x00q\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xac\xd0\x04\x00" +
-       "FactoryUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x02" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81^\xd1\x04\x00GBUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQk" +
-       "\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd9\xd7\x04\x00GB-EireUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y\xde\x04\x00GMTUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05\xdf\x04\x00G" +
-       "MT+0UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb3\xdf\x04\x00GMT-0UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP" +
-       "\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81a\xe0\x04\x00GMT0UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e\xe1\x04\x00GreenwichUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ=\xf7\xfawp\x00\x00\x00p\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc0\xe1" +
-       "\x04\x00HSTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\b\x00\x18" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81m\xe2\x04\x00HongkongUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb6\xe5\x04\x00IcelandUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xe8\xe8\x04\x00Indian/UT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81)\xe9\x04\x00Indian/MauritiusUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81&\xea\x04\x00Indian/ChagosUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05\xeb\x04\x00Indi" +
-       "an/MayotteUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ$l=҅\x00\x00\x00\x85\x00" +
-       "\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03\xec\x04\x00Indian/ChristmasUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd2\xec\x04\x00Indian/CocosUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb9\xb2Z\xac\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\xa4\xed\x04\x00Indian/MaldivesUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e" +
-       "|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x85\xee\x04\x00Indian/ComoroUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQy(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82\xef\x04\x00Indi" +
-       "an/ReunionUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xbd\xf3\x17\xf1\x85\x00\x00\x00\x85\x00" +
-       "\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81O\xf0\x04\x00Indian/MaheUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xb8K\xabυ\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x19\xf1\x04\x00Indian/KerguelenUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xebE1\u05f6\x00\x00\x00\xb6\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81\xe8\xf1\x04\x00Indian/AntananarivoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xf2\x04\x00IranUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04" +
-       "\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xba'\xa0z \x04\x00\x00 \x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfd\xfa\x04\x00IsraelUT\x05\x00" +
-       "\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\xa4\x81]\xff\x04\x00JamaicaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x02\xf4\xaeg\xd5\x00\x00" +
-       "\x00\xd5\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf1\x00\x05\x00JapanUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05\x02\x05\x00KwajaleinUT\x05\x00\x03\xec,\x94_ux\v\x00" +
-       "\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81#\x03\x05\x00Lib" +
-       "yaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\x11\x05\x05\x00METUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf5\x8d\x99\x92o" +
-       "\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbb\a\x05\x00MSTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81g\b\x05\x00MST7MDTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA_\f\x05\x00Mexic" +
-       "o/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\xa0\f\x05\x00Mexico/BajaNorteUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\x10\x05\x00Mexico/GeneralUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ8\xcdZ\x05o\x01\x00\x00o\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcf\x12" +
-       "\x05\x00Mexico/BajaSurUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7" +
-       "\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x86\x14\x05\x00NZUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQ\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd5\x18\x05\x00NZ-CHATUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>\x1c\x05\x00Navaj" +
-       "oUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\xa4\x81\x90 \x05\x00PRCUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQŭV\xad\xb7\x03" +
-       "\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81V\"\x05\x00PST8PDTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e" +
-       "\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAN&\x05\x00Pacific/UT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x90&\x05\x00P" +
-       "acific/Port_MoresbyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcc" +
-       "\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81x'\x05\x00Pacific/ChuukUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00" +
-       "\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82(\x05\x00Pacific/" +
-       "EasterUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x18-\x05\x00Pacific/KwajaleinUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQP:\xc0\x8c\xed\x00\x00\x00\xed\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>.\x05\x00Pacific/Tongatapu" +
-       "UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\x00\xa4\x81v/\x05\x00Pacific/YapUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|X" +
-       "Q1\xce_(\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81~0\x05\x00Pacific/WallisUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04" +
-       "\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe9\xdd\x1e\xee\f\x01\x00\x00\f\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L1\x05\x00Pacif" +
-       "ic/ApiaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00\x0f" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9e2\x05\x00Pacific/NorfolkUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xd5s\x9bkD\x01\x00\x00D\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde3\x05\x00Pacific/EfateUT\x05\x00\x03" +
-       "\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ4\xd0Yӣ\x01\x00\x00\xa3\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
-       "\x81i5\x05\x00Pacific/FijiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQa\v\xe0" +
-       "\xb3\x86\x00\x00\x00\x86\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81R7\x05\x00Pacific/FunafutiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x80\xf8vܔ\x00\x00\x00\x94\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\"8\x05\x00Pacific" +
-       "/PalauUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfd8\x05\x00Pacific/GuamUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00" +
-       "\x00\x00\x00\x00\x0e|XQFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1:\x05\x00Pacific/SaipanUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x97n7\x1a\xf2\x00\x00\x00\xf2\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81G<" +
-       "\x05\x00Pacific/KosraeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x81\xeb\xb8m" +
-       "\xaf\x00\x00\x00\xaf\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81=\x05\x00Pacific/NiueUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81v>\x05\x00Pacific/Pona" +
-       "peUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ߃\xa0_\x86\x00\x00\x00\x86\x00\x00\x00\f\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\x94?\x05\x00Pacific/WakeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\x81\xe3w\n\xaf\x00\x00\x00\xaf\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81`@\x05\x00Pacific/GalapagosUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ZA\x05" +
-       "\x00Pacific/JohnstonUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQt\xca{" +
-       "e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81B\x05\x00Pacific/MidwayUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00" +
-       "\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xe2;Z\xf7\xb7\x00\x00\x00\xb7\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81[C\x05\x00Pacific/N" +
-       "auruUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQY\xd2K|\x86\x00\x00\x00\x86\x00\x00\x00\x13\x00\x18\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81YD\x05\x00Pacific/GuadalcanalUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01" +
-       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,E\x05\x00Pacific/ChathamUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\x9dH\x05\x00Pacific/AucklandUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
-       "\x0e|XQ\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfaL\x05\x00Pacific/NoumeaUT\x05\x00\x03\xec,\x94_ux\v" +
-       "\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x8a|\xdcU\x99\x00\x00\x00\x99\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\bN\x05\x00Pa" +
-       "cific/FakaofoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xea\xc1\xdaυ\x00\x00" +
-       "\x00\x85\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeaN\x05\x00Pacific/TahitiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00" +
-       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc23\xa0\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7O\x05\x00Pacific/Gambi" +
-       "erUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xca\"\xb8i\xda\x00\x00\x00\xda\x00\x00\x00\x0e\x00\x18\x00\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\xa4\x81\x84P\x05\x00Pacific/MajuroUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa6Q\x05\x00Pacific/HonoluluUT\x05\x00\x03\xec,\x94" +
-       "_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcdR" +
-       "\x05\x00Pacific/PohnpeiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQt\xca{" +
-       "e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xecS\x05\x00Pacific/Pago_PagoUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5" +
-       "\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc9T\x05\x00Pacifi" +
-       "c/TrukUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00\x10\x00" +
-       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd2U\x05\x00Pacific/PitcairnUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQD6\x83\xa1\x8b\x00\x00\x00\x8b\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5V\x05\x00Pacific/MarquesasU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81\x8bW\x05\x00Pacific/BougainvilleUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n" +
-       "\x00\x00\x00\x00\x00\x0e|XQ6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa2X\x05\x00Pacific/TarawaUT\x05\x00\x03\xec," +
-       "\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x85v\xf8\x8c\x87\x01\x00\x00\x87\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81p" +
-       "Y\x05\x00Pacific/RarotongaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ" +
-       "t\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81B[\x05\x00Pacific/SamoaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01" +
-       "\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xc8=ku\xae\x00\x00\x00\xae\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1b\\\x05\x00Pacific" +
-       "/KiritimatiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ3\x03\x1f\f\xac\x00\x00\x00\xac" +
-       "\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x15]\x05\x00Pacific/EnderburyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\f^\x05\x00PolandUT\x05\x00\x03\xec" +
-       ",\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
-       "\xe7a\x05\x00PortugalUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xee\xf0BB\xff\x01\x00\x00" +
-       "\xff\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc5g\x05\x00ROCUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
-       "\x00\x0e|XQ\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x01j\x05\x00ROKUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xddk\x05\x00SingaporeUT\x05" +
-       "\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\xa4\x81 m\x05\x00TurkeyUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00" +
-       "\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x10r\x05\x00UCTUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQ\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xbcr\x05\x00US/UT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14" +
-       "\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf9r\x05\x00US/AlaskaUT" +
-       "\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\xa4\x81\rw\x05\x00US/PacificUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ3\x9a" +
-       "G\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81_|\x05\x00US/EasternUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00" +
-       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81s\x83\x05\x00US/MichiganU" +
-       "T\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" +
-       "\x00\x00\x00\xa4\x81;\x87\x05\x00US/ArizonaUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ$" +
-       " \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o\x88\x05\x00US/Indiana-StarkeUT\x05\x00\x03\xec,\x94_ux\v\x00\x01" +
-       "\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb2\x8c\x05\x00US/A" +
-       "leutianUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\t" +
-       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc0\x90\x05\x00US/HawaiiUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
-       "\x00\x00\x0e|XQp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe0\x91\x05\x00US/East-IndianaUT\x05\x00\x03\xec,\x94_" +
-       "ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<\x94\x05" +
-       "\x00US/CentralUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQV\x80\x94@\x12\x04\x00\x00\x12" +
-       "\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Z\x9b\x05\x00US/MountainUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02" +
-       "\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb1\x9f\x05\x00US/SamoaUT\x05\x00\x03\xec,\x94_u" +
-       "x\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x85\xa0\x05\x00" +
-       "UTCUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00" +
-       "\x00\x00\x00\x00\x00\x00\x00\xa4\x811\xa1\x05\x00UniversalUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|" +
-       "XQ\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe3\xa1\x05\x00W-SUUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00" +
-       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xad\xa5\x05\x00WETUT\x05\x00\x03\xec,\x94_ux" +
-       "\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\x0e|XQ\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ا\x05\x00Z" +
-       "uluUT\x05\x00\x03\xec,\x94_ux\v\x00\x01\x04\xf5\x01\x00\x00\x04\x14\x00\x00\x00PK\x05\x06\x00\x00\x00\x00f\x02f\x02\x96\xc9\x00\x00\x85\xa8\x05\x00\x00\x00"
+       "CDT\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\t\x00\x1c\x00US/HawaiiUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x00\x00\x06\x00\x00\x00\x14\xff\xff\xff\xfft\xe0p\xbe\xff\xff\xff\xff\xbb\x05CH\xff\xff\xff\xff\xbb!qX\xff\xff\xff\xffˉ" +
+       "=\xc8\xff\xff\xff\xff\xd2#\xf4p\xff\xff\xff\xff\xd2aI8\xff\xff\xff\xffՍsH\x01\x02\x01\x03\x04\x01\x05\xff\xffl\x02\x00\x00\xff\xfflX\x00\x04\xff\xffzh\x01\b\xff\xffzh\x01\f\xff\xffz" +
+       "h\x01\x10\xff\xffs`\x00\x04LMT\x00HST\x00HDT\x00HWT\x00HPT\x00\nHST10\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00" +
+       "\x00\x00\x03\x00\x1c\x00UTCUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x1c\x00WE" +
+       "TUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'\x00\x00\x00\x02" +
+       "\x00\x00\x00\t\x00\x00\x00\x00\r\xa4c\x90\x00\x00\x00\x00\x0e\x8b\x1a\x10\x00\x00\x00\x00\x0f\x84E\x90\x00\x00\x00\x00\x10t6\x90\x00\x00\x00\x00\x11d'\x90\x00\x00\x00\x00\x12T\x18\x90\x00\x00\x00\x00\x13MD\x10" +
+       "\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00" +
+       "\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10" +
+       "\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00" +
+       "(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90" +
+       "\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x00\x00\x00" +
+       "\x05\x00\x00\x0e\x10\x01\x00WEST\x00WET\x00\nWET0WEST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\xe1\xc1\xeb" +
+       "\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\x04\x00\x1c\x00W-SUUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00N\x00\x00\x00\v\x00\x00\x00&\xff\xff\xff\xffV\xb6\xc0\xc7\xff\xff\xff\xff\x9b_\x1e\xc7\xff\xff\xff\xff\x9d>\xf2y\xff\xff\xff\xff\x9e*\xee\xf9\xff\xff\xff\xff\x9e\xf79i" +
+       "\xff\xff\xff\xff\x9f\x84W\xf9\xff\xff\xff\xff\xa0\xd8l\xe9\xff\xff\xff\xff\xa1\x009\x80\xff\xff\xff\xff\xa1<\xa6@\xff\xff\xff\xff\xa4\x10m\xc0\xff\xff\xff\xff\xa4=2\xb0\xff\xff\xff\xff\xa5\x15h\xb0\xff\xff\xff\xff" +
+       "\xa5=\x03\xc0\xff\xff\xff\xff\xa7\x1eEP\xff\xff\xff\xff\xb5\xa4\x19`\x00\x00\x00\x00\x15'\xa7\xd0\x00\x00\x00\x00\x16\x18\xdc@\x00\x00\x00\x00\x17\b\xdbP\x00\x00\x00\x00\x17\xfa\x0f\xc0\x00\x00\x00\x00\x18\xea\x0e\xd0" +
+       "\x00\x00\x00\x00\x19\xdbC@\x00\x00\x00\x00\x1a̓\xd0\x00\x00\x00\x00\x1b\xbc\xa0\xf0\x00\x00\x00\x00\x1c\xac\x91\xf0\x00\x00\x00\x00\x1d\x9c\x82\xf0\x00\x00\x00\x00\x1e\x8cs\xf0\x00\x00\x00\x00\x1f|d\xf0\x00\x00\x00\x00" +
+       " lU\xf0\x00\x00\x00\x00!\\F\xf0\x00\x00\x00\x00\"L7\xf0\x00\x00\x00\x00#<(\xf0\x00\x00\x00\x00$,\x19\xf0\x00\x00\x00\x00%\x1c\n\xf0\x00\x00\x00\x00&\v\xfb\xf0\x00\x00\x00\x00'\x05'p" +
+       "\x00\x00\x00\x00'\xf5\x18p\x00\x00\x00\x00(\xe5\x17\x80\x00\x00\x00\x00)x\xbf\x80\x00\x00\x00\x00)\xd4\xfap\x00\x00\x00\x00*\xc4\xebp\x00\x00\x00\x00+\xb4\xdcp\x00\x00\x00\x00,\xa4\xcdp\x00\x00\x00\x00" +
+       "-\x94\xbep\x00\x00\x00\x00.\x84\xafp\x00\x00\x00\x00/t\xa0p\x00\x00\x00\x000d\x91p\x00\x00\x00\x001]\xbc\xf0\x00\x00\x00\x002r\x97\xf0\x00\x00\x00\x003=\x9e\xf0\x00\x00\x00\x004Ry\xf0" +
+       "\x00\x00\x00\x005\x1d\x80\xf0\x00\x00\x00\x0062[\xf0\x00\x00\x00\x006\xfdb\xf0\x00\x00\x00\x008\x1bxp\x00\x00\x00\x008\xddD\xf0\x00\x00\x00\x009\xfbZp\x00\x00\x00\x00:\xbd&\xf0\x00\x00\x00\x00" +
+       ";\xdb<p\x00\x00\x00\x00<\xa6Cp\x00\x00\x00\x00=\xbb\x1ep\x00\x00\x00\x00>\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\ap\x00\x00\x00\x00A\x84\x1c\xf0\x00\x00\x00\x00BE\xe9p" +
+       "\x00\x00\x00\x00Cc\xfe\xf0\x00\x00\x00\x00D%\xcbp\x00\x00\x00\x00EC\xe0\xf0\x00\x00\x00\x00F\x05\xadp\x00\x00\x00\x00G#\xc2\xf0\x00\x00\x00\x00G\xee\xc9\xf0\x00\x00\x00\x00I\x03\xa4\xf0\x00\x00\x00\x00" +
+       "IΫ\xf0\x00\x00\x00\x00J\xe3\x86\xf0\x00\x00\x00\x00K\xae\x8d\xf0\x00\x00\x00\x00Ḷp\x00\x00\x00\x00M\x8eo\xf0\x00\x00\x00\x00TL\x1d`\x01\x03\x02\x03\x04\x02\x04\x05\x06\x05\a\x05\x06\b\x06\x05" +
+       "\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\t\b\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06" +
+       "\n\x06\x00\x00#9\x00\x00\x00\x00#9\x00\x04\x00\x001\x87\x01\b\x00\x00#w\x00\x04\x00\x00?\x97\x01\f\x00\x008@\x01\x11\x00\x00*0\x00\x15\x00\x00FP\x01\x19\x00\x00\x1c \x00\x1d\x00\x00*0" +
+       "\x01!\x00\x008@\x00\x15LMT\x00MMT\x00MST\x00MDST\x00MSD\x00MSK\x00+05\x00EET\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x04\x00\x1c\x00ZuluUT\t\x00\x03\x15\xac\x0e`\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00TZif2" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x00\x00\x00\x00Africa/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81A\x00\x00\x00Africa/Nair" +
+       "obiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81H\x01\x00\x00Africa/FreetownUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\x9f\x1b\xeb\xdd2\x02\x00\x002\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x13\x02\x00\x00Africa/CeutaUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8b\x04\x00\x00" +
+       "Africa/AsmeraUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00" +
+       "\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x91\x05\x00\x00Africa/LuandaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x14\xcf\x10n\xca\x01\x00\x00\xca\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8c\x06\x00\x00Africa/JubaUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81\x9b\b\x00\x00Africa/JohannesburgUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa6\t\x00\x00Africa/BujumburaUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81s\n" +
+       "\x00\x00Africa/CairoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RV\xadD\xef\xca\x01" +
+       "\x00\x00\xca\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5\x0f\x00\x00Africa/KhartoumUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc8\x11\x00\x00Africa/Mbab" +
+       "aneUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R)\xae\x8eo&\a\x00\x00&\a\x00\x00\x0f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xce\x12\x00\x00Africa/El_AaiunUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R6\x99rU\xa4\x00\x00\x00\xa4\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81=\x1a\x00\x00Africa/MonroviaUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81*" +
+       "\x1b\x00\x00Africa/LusakaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87" +
+       "\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf4\x1b\x00\x00Africa/BamakoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbd\x1c\x00\x00Africa/Niam" +
+       "eyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\xa4\x81\xb8\x1d\x00\x00Africa/KigaliUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82\x1e\x00\x00Africa/BissauUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81^\x1f\x00\x00Af" +
+       "rica/KinshasaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00" +
+       "\x00\xbf\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81[ \x00\x00Africa/Addis_AbabaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f!\x00\x00Africa/Tu" +
+       "nisUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81m#\x00\x00Africa/BanjulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x816$\x00\x00Africa/OuagadougouUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "\x04%\x00\x00Africa/LibrevilleUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03&\x00\x00Africa/BrazzavilleUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03'\x00\x00A" +
+       "frica/BanguiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00" +
+       "\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfe'\x00\x00Africa/AbidjanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc8(\x00\x00Africa/Algiers" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81\xe6*\x00\x00Africa/NouakchottUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xc1\n\x8a\x84\xad\x00\x00\x00\xad\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb3+\x00\x00Africa/Sao_TomeUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa9," +
+       "\x00\x00Africa/Dar_es_SalaamUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb6-\x00\x00Africa/LubumbashiUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84.\x00\x00A" +
+       "frica/KampalaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00" +
+       "\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8b/\x00\x00Africa/BlantyreUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81W0\x00\x00Africa/Malab" +
+       "oUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81R1\x00\x00Africa/NdjamenaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81;2\x00\x00Africa/TimbuktuUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x063\x00" +
+       "\x00Africa/GaboroneUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rd\x01\x05\x89" +
+       "\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd23\x00\x00Africa/CasablancaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9c;\x00\x00Africa/" +
+       "MaputoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\f\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f<\x00\x00Africa/LagosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81`=\x00\x00Africa/MaseruUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81e>\x00" +
+       "\x00Africa/Porto-NovoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b" +
+       "{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81d?\x00\x00Africa/ConakryUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.@\x00\x00Africa/D" +
+       "oualaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x10\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)A\x00\x00Africa/MogadishuUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x812B\x00\x00Africa/DakarUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfa" +
+       "B\x00\x00Africa/TripoliUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x1b\xb0" +
+       "_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf1D\x00\x00Africa/HarareUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbbE\x00\x00Africa/Asm" +
+       "araUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rm)\xb8P~\x02\x00\x00~\x02\x00\x00\x0f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc1F\x00\x00Africa/WindhoekUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\xee\xc4h2\xbc\x02\x00\x00\xbc\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x88I\x00\x00Africa/AccraUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8aL\x00\x00" +
+       "Africa/LomeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf" +
+       "\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81QM\x00\x00Africa/DjiboutiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAYN\x00\x00America/UT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x82\x13z\xe2\xc2\x00\x00\x00\xc2\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "\x9bN\x00\x00America/TegucigalpaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaaO\x00\x00America/St_KittsUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81vP\x00\x00A" +
+       "merica/Puerto_RicoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xdf\b" +
+       "\x9c\x9f\xe7\x00\x00\x00\xe7\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81tQ\x00\x00America/BarbadosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5R\x00\x00Americ" +
+       "a/AtikokanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00" +
+       "\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcfS\x00\x00America/DominicaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xac\x8a\x83S\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9bT\x00\x00America/Guatem" +
+       "alaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x1e+}\x15\xb4\x02\x00\x00\xb4\x02\x00\x00\x14\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbaU\x00\x00America/Rankin_InletUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbcX\x00\x00America/TortolaUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81\x87Y\x00\x00America/IqaluitUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\xd7\b\\\xc6&\x02\x00\x00&\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4\\\x00\x00America/MiquelonUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x11Z\xde\xe4\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81$_\x00\x00A" +
+       "merica/FortalezaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd6\xfe\xf3%" +
+       "\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Sa\x00\x00America/ResoluteUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Qd\x00\x00America/" +
+       "St_ThomasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xbf\x03u\xf3\xe4\x01\x00\x00\xe4\x01\x00" +
+       "\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1ee\x00\x00America/RecifeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Jg\x00\x00America/CuracaoUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81*h\x00\x00America/MartiniqueUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R?\xc9\x1c\xd4\xc6\x03\x00\x00\xc6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81(i\x00\x00America/JuneauUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x816m\x00\x00" +
+       "America/BoiseUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xaaʂA\xcd\x00\x00" +
+       "\x00\xcd\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81dq\x00\x00America/Blanc-SablonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\u007fr\x00\x00America" +
+       "/CuiabaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf7\xe9 y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81mv\x00\x00America/InuvikUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9RU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ry\x00\x00America/Yellowknife" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x10\x00\xedA\x98|\x00\x00America/Indiana/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2|\x00\x00America/Indiana/KnoxUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x01\xd8N\x8c\xab\x02\x00\x00\xab\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81(\x81\x00\x00America/Indiana/PetersburgUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x1c\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81'\x84\x00\x00America/Indiana/In" +
+       "dianapolisUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RصK\xa6\n\x02\x00\x00\n\x02" +
+       "\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x90\x86\x00\x00America/Indiana/Tell_CityUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R \x17\x89}q\x01\x00\x00q\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xed\x88\x00\x00Ameri" +
+       "ca/Indiana/VevayUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RK-E\xfa" +
+       "d\x02\x00\x00d\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xad\x8a\x00\x00America/Indiana/WinamacUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RM/U\x9f7\x02\x00\x007\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81b\x8d\x00\x00A" +
+       "merica/Indiana/MarengoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xea\x8f\x00\x00America/Indiana/VincennesUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rc)\xf6)\xb3\x00\x00\x00\xb3\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81k\x92\x00\x00America/BogotaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R.\xf9\xc0\x1e\xd5\x05\x00\x00\xd5\x05\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f\x93\x00\x00America/MonctonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x84\x99\x00\x00Amer" +
+       "ica/MarigotUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R挋\x92\xf6\x01\x00\x00\xf6" +
+       "\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81O\x9a\x00\x00America/MaceioUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8d\x9c\x00\x00America/PanamaU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa2\x81\xbfyS\x02\x00\x00S\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81j\x9d\x00\x00America/MetlakatlaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xfe\xe6\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\t\xa0\x00\x00America/DawsonUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81V\xa4\x00" +
+       "\x00America/CatamarcaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xca" +
+       "g\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81e\xa7\x00\x00America/AntiguaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA0\xa8\x00\x00America" +
+       "/Kentucky/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04" +
+       "\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81{\xa8\x00\x00America/Kentucky/LouisvilleUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaa\xad\x00\x00Ame" +
+       "rica/Kentucky/MonticelloUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81˱\x00\x00America/OjinagaUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8\xb3\x00\x00A" +
+       "merica/ArubaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x81{\xc1\x92\xbc\x03\x00\x00" +
+       "\xbc\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ִ\x00\x00America/SitkaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rѱ\x86b\xee\x03\x00\x00\xee\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ٸ\x00\x00America/NassauU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\x0f\xbd\x00\x00America/Sao_PauloUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9Rg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x12\xc1\x00\x00America/Rio_BrancoUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "\x00\xc3\x00\x00America/Costa_RicaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\x1b\x81-\xa9\x8a\x01\x00\x00\x8a\x01\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x814\xc4\x00\x00America/Porto_VelhoUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\v\xc6\x00" +
+       "\x00America/IndianapolisUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xb4T\xbd\xeb5\x02\x00\x005\x02\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81l\xc8\x00\x00America/Port-au-PrinceUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf1" +
+       "\xca\x00\x00America/El_SalvadorUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xee\xcb\x00\x00America/AdakUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfd\xcf\x00\x00Americ" +
+       "a/St_JohnsUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RJtZ\x8c\x01\x03\x00\x00\x01\x03" +
+       "\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9d\xd7\x00\x00America/PangnirtungUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RU\xactA\xb5\x01\x00\x00\xb5\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xda\x00\x00America/Mat" +
+       "amorosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rs\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00\x00\x10\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xdc\x00\x00America/EirunepeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe9\xde\x00\x00America/ShiprockUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81E\xe3\x00\x00America/GodthabUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9RU\r\xf7\xd3\xc7\x01\x00\x00\xc7\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81_\xe5\x00\x00America/ThuleUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe5s\xb3\\'\x01\x00\x00'\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81m\xe7\x00\x00Amer" +
+       "ica/ManaguaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RM\x94\xc7Kp\x03\x00\x00p" +
+       "\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdd\xe8\x00\x00America/Glace_BayUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R⚵\xfb\x9e\x00\x00\x00\x9e\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x98\xec\x00\x00America/Cres" +
+       "tonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\u007f\xed\x00\x00America/HermosilloUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe9\xee\x00\x00America/Santa_Isabe" +
+       "lUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\x0f(\b=\x01\x00\x00=\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x818\xf3\x00\x00America/Santo_DomingoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4\xf4\x00\x00America/St_Vincent" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81\x92\xf5\x00\x00America/Mexico_CityUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x15\xc8\xcb\x00\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81{\xf7\x00\x00America/GuyanaUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o" +
+       "\xf8\x00\x00America/Port_of_SpainUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81@\xf9\x00\x00America/DetroitUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\f\xfd\x00\x00A" +
+       "merica/Argentina/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9" +
+       "\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81X\xfd\x00\x00America/Argentina/CatamarcaUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 \x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "q\x00\x01\x00America/Argentina/ComodRivadaviaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8f\x03\x01\x00America/Argent" +
+       "ina/UshuaiaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RŒZ\x8c\xc4\x02\x00\x00\xc4" +
+       "\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa6\x06\x01\x00America/Argentina/MendozaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbd\t\x01\x00Amer" +
+       "ica/Argentina/Buenos_AiresUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9Rm\aD\x0e\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd9\f\x01\x00America/Argentina/La_Rio" +
+       "jaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8ep\xb4c\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\xa4\x81\xfa\x0f\x01\x00America/Argentina/Rio_GallegosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x16\x13\x01\x00America/" +
+       "Argentina/JujuyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xfcz=\xe1\xcd" +
+       "\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x19\x16\x01\x00America/Argentina/San_JuanUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x1c\x80\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81:\x19\x01" +
+       "\x00America/Argentina/San_LuisUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9Rt*\x9b!\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81[\x1c\x01\x00America/Argentina/Salta" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RY\xd8֭\xd6\x02\x00\x00\xd6\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81^\x1f\x01\x00America/Argentina/TucumanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x87\"\x01\x00America/Argenti" +
+       "na/CordobaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe3\xc9I\xd0U\x03\x00\x00U\x03" +
+       "\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9e%\x01\x00America/Grand_TurkUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81?)\x01\x00America/Knox" +
+       "_INUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x80-\x01\x00America/Bahia_BanderasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2/\x01\x00America/VirginU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa1'\a\xbd\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xac0\x01\x00America/CayenneUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8c1\x01\x00America/MontserratUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Z2" +
+       "\x01\x00America/WinnipegUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xca" +
+       "g\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb27\x01\x00America/AnguillaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81~8\x01\x00Americ" +
+       "a/MendozaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x04,2h\x99\x01\x00\x00\x99\x01\x00" +
+       "\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8b;\x01\x00America/SantaremUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81n=\x01\x00America/St_Luci" +
+       "aUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81:>\x01\x00America/CaymanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9Rp\x1b\xceRC\x03\x00\x00C\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17?\x01\x00America/NipigonUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3B\x01\x00" +
+       "America/DenverUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R+\x10`ȫ\x02" +
+       "\x00\x00\xab\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfdF\x01\x00America/Dawson_CreekUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6I\x01\x00Americ" +
+       "a/NuukUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf2\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00\x00\x0e\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\rL\x01\x00America/CancunUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9Rn\xab\xd5\xf9\xcf\x03\x00\x00\xcf\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81fN\x01\x00America/NomeUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81{R" +
+       "\x01\x00America/YakutatUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag" +
+       "\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81vV\x01\x00America/GrenadaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81AW\x01\x00America/" +
+       "RosarioUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe\x00\x00\x00\x0f" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81NZ\x01\x00America/CaracasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ro_\x00v/\x01\x00\x00/\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81U[\x01\x00America/MeridaUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\xcc\\\x01\x00America/Buenos_AiresUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xde_\x01\x00America/Rainy_RiverUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81nc\x01\x00America/PhoenixUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa7d\x01\x00America/LouisvilleUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk^2S\xb9\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcdi\x01\x00Am" +
+       "erica/Punta_ArenasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xf5" +
+       "K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd4n\x01\x00America/Porto_AcreUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2p\x01\x00Amer" +
+       "ica/New_YorkUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xad`\x12\xe9\xaa\x00\x00\x00" +
+       "\xaa\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdcw\x01\x00America/La_PazUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcex\x01\x00America/Noronh" +
+       "aUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81\xfbz\x01\x00America/GuadeloupeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc9{\x01\x00America/Campo_GrandeU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xcf\u007f\x01\x00America/ScoresbysundUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xfc\x81\x01\x00America/North_Dakota/" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81K\x82\x01\x00America/North_Dakota/CenterUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RR\x1b\x8b(\xde\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81~\x86\x01\x00America/North" +
+       "_Dakota/New_SalemUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb7.\xb6" +
+       "*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4\x8a\x01\x00America/North_Dakota/BeulahUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "\x1c\x8f\x01\x00America/Goose_BayUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x93\x95\x01\x00America/Fort_WayneUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf2\x97\x01\x00A" +
+       "merica/HalifaxUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x1c\xd8\x19\x9dp\x01" +
+       "\x00\x00p\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Þ\x01\x00America/Swift_CurrentUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82\xa0\x01\x00Ameri" +
+       "ca/SantiagoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R8\xcdZ\x05o\x01\x00\x00o" +
+       "\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Υ\x01\x00America/MazatlanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xcag\xe7\x82\x00\x00\x00\x82\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x87\xa7\x01\x00America/St_Ba" +
+       "rthelemyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x89غ\xee\x15\x04\x00\x00\x15\x04\x00\x00" +
+       "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81X\xa8\x01\x00America/BelizeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcd\xc3v\xe3\xb3\x00\x00\x00\xb3\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5\xac\x01\x00America/GuayaquilU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc0\x98\x00\b\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xb3\xad\x01\x00America/MontevideoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ȱ\x01\x00America/Los_AngelesUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81#\xb7\x01\x00America/HavanaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "8O:\xbf\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ȼ\x01\x00America/MenomineeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa8\xbf\x01\x00Ame" +
+       "rica/JujuyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04" +
+       "\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1\xc2\x01\x00America/TijuanaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xc6\x01\x00America/Edmonto" +
+       "nUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81\xff\xca\x01\x00America/ChihuahuaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\x1d`̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9e\xcc\x01\x00America/Cambridge_BayU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xed\xcf\x01\x00America/WhitehorseUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xf6@\rm\xa8\x05\x00\x00\xa8\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>\xd4\x01\x00America/Fort_NelsonUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x813\xda\x01\x00America/AtkaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ra\xcb" +
+       "'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81B\xde\x01\x00America/ManausUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\xf9\x1dɻ\x00\x00\x00\xbb\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81&\xe0\x01\x00America/" +
+       "ParamariboUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xfe7\xa1\x87\x1b\x01\x00\x00\x1b\x01" +
+       "\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81-\xe1\x01\x00America/LimaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8e\xe2\x01\x00America/AsuncionUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81L\xe6\x01\x00America/ChicagoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9RMv\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o\xed\x01\x00America/MonterreyUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x14\xc1r8\xe0\x00\x00\x00\xe0\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdf\xee\x01\x00" +
+       "America/Coral_HarbourUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R錴$q\x03\x00\x00q\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e\xf0\x01\x00America/Thunder_BayUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcc\xf3\x01\x00" +
+       "America/EnsenadaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9ROKj\xc7" +
+       "\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17\xf8\x01\x00America/BahiaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\b\xfb\x01\x00America/Mon" +
+       "trealUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\a\x02\x02\x00America/JamaicaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3\x03\x02\x00America/AnchorageUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81\xbf\a\x02\x00America/DanmarkshavnUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcc\t\x02\x00America/KralendijkUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81\xaf\n\x02\x00America/AraguainaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81J\r\x02\x00America/CordobaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\u0096dK~\x02\x00\x00~\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81W\x10\x02\x00Ame" +
+       "rica/ReginaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x85-\xb9\xf8\x8a\x01\x00\x00\x8a" +
+       "\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1d\x13\x02\x00America/BelemUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xee\x14\x02\x00America/TorontoU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RU9#\xbe2\x05\x00\x002\x05\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xec\x1b\x02\x00America/VancouverUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xf8Dz\x97\xae\x01\x00\x00\xae\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81i!\x02\x00America/Boa_VistaUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x19vv\xa0\x97\x00\x00\x00\x97\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81b" +
+       "#\x02\x00America/Lower_PrincesUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAH$\x02\x00Antarctica/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8d$\x02\x00Antar" +
+       "ctica/VostokUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95{\xf3\xa9w\x03\x00\x00" +
+       "w\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81]%\x02\x00Antarctica/PalmerUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R:\xc8P7\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1f)\x02\x00Antarctica/" +
+       "TrollUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x12\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1a*\x02\x00Antarctica/McMurdoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95\xea\x06\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81y.\x02\x00Antarctica/DavisU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\r\x0e\xf20\x85\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\x88/\x02\x00Antarctica/SyowaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xc8\x14\xdcA\x98\x00\x00\x00\x98\x00\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81W0\x02\x00Antarctica/DumontDUrville" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd7N\xab\x8b\x98\x00\x00\x00\x98\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81B1\x02\x00Antarctica/MawsonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9RƉ\xf71\x84\x00\x00\x00\x84\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%2\x02\x00Antarctica/RotheraUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xddzAh\xf3\x00\x00\x00\xf3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81\xf52\x02\x00Antarctica/CaseyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xb2\x84J]\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x8124\x02\x00Antarctica/MacquarieUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81P8\x02" +
+       "\x00Antarctica/South_PoleUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xb2<\x02\x00Arctic/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf3<\x02\x00Arctic/Long" +
+       "yearbyenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\xe4?\x02\x00Asia/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81#@\x02\x00Asia/TomskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x81z&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81XC\x02\x00Asia/Ch" +
+       "oibalsanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00" +
+       "\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\fF\x02\x00Asia/ThimbuUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xebF\x02\x00Asia/VientianeUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcb" +
+       "G\x02\x00Asia/YangonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R6j\\J\xcf\x04" +
+       "\x00\x00\xcf\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcbH\x02\x00Asia/HebronUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdfM\x02\x00Asia/ChongqingU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xb0O\x02\x00Asia/KabulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xda" +
+       "v\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x93P\x02\x00Asia/BahrainUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf9l\x03\x12\xf8\x02\x00\x00\xf8\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81qQ\x02\x00Asia/Irku" +
+       "tskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RO\xb0\x03\xe9\xe5\x02\x00\x00\xe5\x02\x00\x00\f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xafT\x02\x00Asia/YakutskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdaW\x02\x00Asia/JayapuraUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xccX\x02\x00As" +
+       "ia/Hong_KongUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RS\xa5\x81e\xf7\x00\x00\x00" +
+       "\xf7\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1b\\\x02\x00Asia/PontianakUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Z]\x02\x00Asia/TehranUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rd%\x05\xd8\xe6\x02\x00\x00\xe6\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81se\x02\x00Asia/VladivostokUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa3h\x02\x00Asia/OmskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcbk\x02\x00Asia/Tai" +
+       "peiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0fn\x02\x00Asia/DaccaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R]S\xbb\x12\xac\x03\x00\x00\xac\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81:o\x02\x00Asia/FamagustaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.s\x02\x00Asi" +
+       "a/RiyadhUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00" +
+       "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8s\x02\x00Asia/ChungkingUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xceG|\xea\x13\x03\x00\x00\x13\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc9u\x02\x00Asia/AmmanUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81 y" +
+       "\x02\x00Asia/MakassarUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8bSnT\xa1" +
+       "\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%z\x02\x00Asia/KathmanduUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0e{\x02\x00Asia/Shangh" +
+       "aiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd5ΜGp\x02\x00\x00p\x02\x00\x00\x0e\x00\x18\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\xa4\x81\xde|\x02\x00Asia/QyzylordaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x17✳2\x04\x00\x002\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x96\u007f\x02\x00Asia/Tel_AvivUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0f\x84\x02\x00A" +
+       "sia/TashkentUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00" +
+       "\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ą\x02\x00Asia/KuwaitUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8e\x86\x02\x00Asia/UrumqiUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Re\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "X\x87\x02\x00Asia/AshkhabadUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf0\x9c" +
+       "f>\xd7\x02\x00\x00\xd7\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17\x89\x02\x00Asia/KamchatkaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x87\xbd\xedL\xf1\x02\x00\x00\xf1\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x816\x8c\x02\x00Asia/Bar" +
+       "naulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81m\x8f\x02\x00Asia/NovokuznetskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R0]*\x1bj\x02\x00\x00j\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8e\x92\x02\x00Asia/BishkekUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa7f^]@\x01\x00\x00@\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81>" +
+       "\x95\x02\x00Asia/KuchingUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x84)\r\xbd\xec" +
+       "\x00\x00\x00\xec\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ė\x02\x00Asia/SaigonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5\x97\x02\x00Asia/Singapore" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R)p\x1cX\xf1\x02\x00\x00\xf1\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81=\x99\x02\x00Asia/NovosibirskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R?\xa7^\xfah\x02\x00\x00h\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81x\x9c\x02\x00Asia/AtyrauUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x88έ\xe2\xbd\x04\x00\x00\xbd\x04\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\x9f\x02\x00Asi" +
+       "a/GazaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RΒ\x1a\x8c\xaa\x00\x00\x00\xaa\x00\x00\x00\t\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\xa4\x02\x00Asia/DiliUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x12\xa5\x02\x00Asia/ChitaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81D\xa8\x02\x00Asia/" +
+       "Ulan_BatorUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rw\rD\an\x01\x00\x00n\x01" +
+       "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ߪ\x02\x00Asia/SamarkandUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x95\xac\x02\x00Asia/NicosiaUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x810\xaf\x02\x00Asia/AdenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R?Y\xaf\x19\xe7" +
+       "\x00\x00\x00\xe7\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8\xaf\x02\x00Asia/DhakaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R)\x15II\xf3\x02\x00\x00\xf3\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81#\xb1\x02\x00Asia/SakhalinUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RT\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81]\xb4\x02\x00Asia/AqtauUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8a\xc1" +
+       "\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xff\xb6\x02\x00Asia/PyongyangUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x17✳2\x04\x00\x002\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfe\xb7\x02\x00Asia/Jer" +
+       "usalemUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R's\x96\x1en\x01\x00\x00n\x01\x00\x00\r\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81x\xbc\x02\x00Asia/DushanbeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81-\xbe\x02\x00Asia/ColomboUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81j\xbf\x02" +
+       "\x00Asia/KarachiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R恸\x1e\x00\x01\x00" +
+       "\x00\x00\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xba\xc0\x02\x00Asia/Kuala_LumpurUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Re\x1bb2w\x01\x00\x00w\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05\xc2\x02\x00Asia/Ashga" +
+       "batUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3\xc3\x02\x00Asia/KolkataUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9RB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe5\xc4\x02\x00Asia/KashgarUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xba\xa3b\xc1R\x02\x00\x00R\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb0\xc5\x02\x00Asi" +
+       "a/HovdUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81E\xc8\x02\x00Asia/BakuUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81p\xcb\x02\x00Asia/KhandygaUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9a\xea\x18\xd4\xf8\x02\x00\x00\xf8\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbe\xce\x02\x00As" +
+       "ia/YekaterinburgUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rʇ{_" +
+       "\xbb\x00\x00\x00\xbb\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x02\xd2\x02\x00Asia/RangoonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rǯ\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03\xd3\x02\x00Asia/ManilaU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x816\xd4\x02\x00Asia/MacaoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RS" +
+       "\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x91\xd7\x02\x00Asia/AlmatyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RѾ\xa8\xc7u\x02\x00\x00u\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x817\xda\x02\x00Asia/Tbili" +
+       "siUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x18\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\xa4\x81\xf2\xdc\x02\x00Asia/Phnom_PenhUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd3\xdd\x02\x00Asia/MacauUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81.\xe1\x02\x00Asi" +
+       "a/MagadanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xdav\x19z\x98\x00\x00\x00\x98\x00\x00" +
+       "\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81c\xe4\x02\x00Asia/QatarUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81?\xe5\x02\x00Asia/CalcuttaUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81b\xe6" +
+       "\x02\x00Asia/UlaanbaatarUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa4Z" +
+       "ߐ\xe6\x02\x00\x00\xe6\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfe\xe8\x02\x00Asia/SrednekolymskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xdb\xfa\xb5\xbeg\x02\x00\x00g\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x810\xec\x02\x00Asia" +
+       "/AqtobeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rw\x86\x8d^\x03\x03\x00\x00\x03\x03\x00\x00\r" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdc\xee\x02\x00Asia/Ust-NeraUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9RL\xe0\x91y\xe5\x02\x00\x00\xe5\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81&\xf2\x02\x00Asia/KrasnoyarskUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81U\xf5\x02\x00Asia/SeoulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ry\x19\xe0N" +
+       "\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x818\xf7\x02\x00Asia/BruneiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd7e&uv\x02\x00\x00v\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17\xf8\x02\x00Asia/BaghdadU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xd3\xfa\x02\x00Asia/Ujung_PandangUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9RV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdd\xfb\x02\x00Asia/AnadyrUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\t\xff\x02\x00As" +
+       "ia/MuscatUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00" +
+       "\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd3\xff\x02\x00Asia/Ho_Chi_MinhUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xef\\\xf4q\x17\x04\x00\x00\x17\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\t\x01\x03\x00Asia/DamascusUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81g\x05\x03\x00Asia/ThimphuUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81G\x06\x03\x00Asia/BangkokUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x02\x95-\xad\xc4\x02\x00\x00\xc4\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81%\a\x03\x00Asia/Yer" +
+       "evanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\r\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81/\n\x03\x00Asia/KatmanduUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17\v\x03\x00Asia/OralUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcb\r\x03\x00Asia" +
+       "/TokyoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe4\x0e\x03\x00Asia/IstanbulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdb\x13\x03\x00Asia/BeirutUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfc\x16\x03\x00" +
+       "Asia/JakartaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xed\x8c\xf1\x91\x85\x00\x00\x00" +
+       "\x85\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81:\x18\x03\x00Asia/DubaiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa1\xfax\x98g\x02\x00\x00g\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03\x19\x03\x00Asia/QostanayUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81\xb1\x1b\x03\x00Asia/HarbinUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\u007f\x1d\x03\x00Atlantic/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\u0097N\xad\xaf\x00\x00\x00\xaf\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2\x1d\x03\x00Atlantic/Cape_V" +
+       "erdeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe7\xcf^\xb0\x15\x03\x00\x00\x15\x03\x00\x00\x10\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbe\x1e\x03\x00Atlantic/StanleyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\x82\xfa Z\x9b\x05\x00\x00\x9b\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1d\"\x03\x00Atlantic/MadeiraUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rl&\x04\x99\x00\x04\x00\x00\x00\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\x02(\x03\x00Atlantic/BermudaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81L,\x03\x00Atlantic/CanaryUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81s.\x03\x00Atl" +
+       "antic/FaroeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rm\xbd\x10k\xf1\x02\x00\x00\xf1" +
+       "\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81t0\x03\x00Atlantic/ReykjavikUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb13\x03\x00Atlantic/Ja" +
+       "n_MayenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa16\x03\x00Atlantic/St_HelenaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x0f-\xadׄ\x00\x00\x00\x84\x00\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o7\x03\x00Atlantic/South_" +
+       "GeorgiaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0f" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81C8\x03\x00Atlantic/FaeroeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RW\x99\x9d\v\x9b\x05\x00\x00\x9b\x05\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81E:\x03\x00Atlantic/AzoresUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10" +
+       "\x00\xedA)@\x03\x00Australia/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9a" +
+       "p\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81m@\x03\x00Australia/NSWUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<D\x03\x00Australia/" +
+       "AdelaideUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00" +
+       "\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81!H\x03\x00Australia/VictoriaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ro3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5K\x03\x00Australia/LHIU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xf0N\x03\x00Australia/NorthUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81#P\x03\x00Australia/DarwinUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81WQ\x03\x00" +
+       "Australia/YancowinnaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81RU\x03\x00Australia/QueenslandUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc1V\x03\x00" +
+       "Australia/SydneyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z" +
+       "\xeb\x03\x00\x00\xeb\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x93Z\x03\x00Australia/TasmaniaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xca^\x03\x00Austra" +
+       "lia/SouthUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00" +
+       "\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xacb\x03\x00Australia/CanberraUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x80f\x03\x00Australia/Cur" +
+       "rieUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa2ܺ\xca:\x01\x00\x00:\x01\x00\x00\x0f\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5j\x03\x00Australia/EuclaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9RE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x818l\x03\x00Australia/HobartUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "mp\x03\x00Australia/Broken_HillUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R?\x95\xbd\x12E\x01\x00\x00E\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81it\x03\x00Australia/LindemanUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfa" +
+       "u\x03\x00Australia/MelbourneUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcfy\x03\x00Australia/BrisbaneUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rϻ\xca\x1a2\x01\x00\x002\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<{\x03\x00" +
+       "Australia/PerthUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ro3\xdaR\xb4" +
+       "\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7|\x03\x00Australia/Lord_HoweUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rϻ\xca\x1a2\x01\x00\x002\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb8\u007f\x03\x00Austra" +
+       "lia/WestUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00" +
+       "\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x812\x81\x03\x00Australia/ACTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x01\x85\x03\x00Brazil/UT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81B\x85\x03\x00Br" +
+       "azil/EastUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00" +
+       "\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81?\x89\x03\x00Brazil/AcreUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81&\x8b\x03\x00Brazil/DeNoronhaUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ra\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81T\x8d\x03\x00Brazil/WestUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA5\x8f\x03\x00Canada/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RU9#\xbe2\x05\x00\x002\x05\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81v\x8f\x03\x00Canada/PacificUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81\xf0\x94\x03\x00Canada/CentralUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81F\x9a\x03\x00Canada/AtlanticUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17\xa1\x03\x00Can" +
+       "ada/MountainUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc1Ȇ\x90\x05\x04\x00\x00" +
+       "\x05\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81*\xa5\x03\x00Canada/YukonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81u\xa9\x03\x00Canada/Newfoundl" +
+       "andUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x18\xb1\x03\x00Canada/EasternUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\u0096dK~\x02\x00\x00~\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x15\xb8\x03\x00Canada/SaskatchewanUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe6\x9aM\xbem\x02\x00\x00m\x02\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\xe0\xba\x03\x00CETUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x8a\xbd\x03\x00Chile/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81ʽ\x03\x00Chile/EasterIslandUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81d" +
+       "\xc2\x03\x00Chile/ContinentalUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb1\xc7\x03\x00CST6CDTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa9\xcb\x03\x00CubaUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81D\xd0\x03" +
+       "\x00EETUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\x05\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81r\xd2\x03\x00EgyptUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9a" +
+       "\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xad\xd7\x03\x00EireUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RtX\xbe\xe4o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3\xdd\x03\x00ESTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81o\xde\x03\x00EST5" +
+       "EDTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x10\x00\xedAg\xe2\x03\x00Etc/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa" +
+       "\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5\xe2\x03\x00Etc/GMT+0UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81W\xe3\x03\x00Etc/GreenwichU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\r\xe4\x03\x00Etc/GMT-0UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd4X" +
+       "\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbf\xe4\x03\x00Etc/GMT+5UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81s\xe5\x03\x00Etc/GMT-1UT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R5\xb8\xe8\x86q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81(\xe6\x03\x00Etc/GMT+1UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\"\xf8\x8f/q" +
+       "\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xdc\xe6\x03\x00Etc/GMT+8UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x90\xe7\x03\x00Etc/GMT-12UT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "G\xe8\x03\x00Etc/UCTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa9{\xa2qq\x00\x00\x00q" +
+       "\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf7\xe8\x03\x00Etc/GMT+2UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\xb2\xab\xd1Is\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xab\xe9\x03\x00Etc/GMT-11UT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81b\xea\x03\x00" +
+       "Etc/GMT+4UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9c\xfcm\x99r\x00\x00\x00r\x00\x00" +
+       "\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x16\xeb\x03\x00Etc/GMT-3UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcb\xeb\x03\x00Etc/GMT-5UT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Re\xcb\xe9Qq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x80\xec\x03\x00Etc" +
+       "/GMT+3UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd9|\xbd7s\x00\x00\x00s\x00\x00\x00\n\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x814\xed\x03\x00Etc/GMT-10UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xe5\xf38cr\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xeb\xed\x03\x00Etc/GMT+12UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xfc\x19@\xb9r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1\xee\x03\x00Etc/" +
+       "GMT-9UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81V\xef\x03\x00Etc/GMT-13UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\r\xf0\x03\x00Etc/GMT0UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbe\xf0\x03\x00Etc/GMT" +
+       "+10UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81t\xf1\x03\x00Etc/GMT-6UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)\xf2\x03\x00Etc/UTCUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8" +
+       "\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x84+\x9a$q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd9\xf2\x03\x00Etc/GMT+7UT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81\x8d\xf3\x03\x00Etc/GMT+6UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RJ0p" +
+       "-r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81A\xf4\x03\x00Etc/GMT-7UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6\xf4\x03\x00Etc/GMTUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xbc\x19y\x04r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa6" +
+       "\xf5\x03\x00Etc/GMT-2UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R,{\xdc;s\x00\x00\x00" +
+       "s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81[\xf6\x03\x00Etc/GMT-14UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x12\xf7\x03\x00Etc/UniversalUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc5\x18\xb6\xfbr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81\xc8\xf7\x03\x00Etc/GMT-8UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R)\xb9\xbe\x9dr\x00" +
+       "\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81}\xf8\x03\x00Etc/GMT+11UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x813\xf9\x03\x00Etc/ZuluUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\x19<Qr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe4\xf9" +
+       "\x03\x00Etc/GMT-4UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x84\x19\xb3\tq\x00\x00\x00q" +
+       "\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x99\xfa\x03\x00Etc/GMT+9UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03" +
+       "\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAM\xfb\x03\x00Europe/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95\u007fpp\xdc\x02\x00\x00\xdc\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8e\xfb\x03\x00Eur" +
+       "ope/SamaraUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06" +
+       "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb1\xfe\x03\x00Europe/BelfastUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ro\xbc\x831O\x04\x00\x00O\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x818\x05\x04\x00Europe/BrusselsU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xd0\t\x04\x00Europe/VaduzUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xcb*j\x8f\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\a\f\x04\x00Europe/AthensUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RM\xe5\xa9 ?\x04\x00\x00?\x04\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf8\x0e\x04\x00Europe" +
+       "/LuxembourgUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x92\xfc\f+o\x02\x00\x00o" +
+       "\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x82\x13\x04\x00Europe/CopenhagenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RVa\x92\xd3\xdf\x02\x00\x00\xdf\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81<\x16\x04\x00Europe/Volgo" +
+       "gradUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RO+j\x94\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81e\x19\x04\x00Europe/KaliningradUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x819\x1d\x04\x00Europe/BelgradeUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81`\x1f\x04\x00Europe/GuernseyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe8%\x04\x00Europe/SarajevoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rh\xa5J[\xa0\x03\x00\x00\xa0\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0f(\x04\x00Eur" +
+       "ope/MaltaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc7\xf5\x94\xdaQ\x04\x00\x00Q\x04\x00" +
+       "\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5+\x04\x00Europe/ParisUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8c0\x04\x00Europe/MariehamnUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rߜvυ\x01\x00\x00\x85\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81\xb72\x04\x00Europe/AndorraUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x844\x04\x00Europe/LisbonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RN\xa5\xa5\xcb\x12\x02\x00\x00\x12\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81g:\x04\x00Europe" +
+       "/UzhgorodUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R]i\x11u\xd6\x02\x00\x00\xd6\x02\x00" +
+       "\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2<\x04\x00Europe/AstrakhanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xea\xc48\xde\\\x02\x00\x00\\\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2?\x04\x00Europe/TiraneUT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81\x85B\x04\x00Europe/PragueUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9fE\x04\x00Europe/ZagrebUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4G\x04\x00Europe" +
+       "/San_MarinoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc9\a\xa0\xe1/\x04\x00\x00/" +
+       "\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2K\x04\x00Europe/AmsterdamUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81;P\x04\x00Europe/Vatica" +
+       "nUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\r\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x816T\x04\x00Europe/DublinUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9RWI\xc3\u007f(\x03\x00\x00(\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81UZ\x04\x00Europe/MinskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RZk#V\x81\x03\x00\x00\x81\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3]\x04\x00Euro" +
+       "pe/MadridUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00" +
+       "\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8ba\x04\x00Europe/JerseyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x11h\x04\x00Europe/NicosiaUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\xaej\x04\x00Europe/MoscowUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8c" +
+       "\xc8\x15\xd0P\x02\x00\x00P\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x81n\x04\x00Europe/SofiaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xccb\xf72\xa4\x02\x00\x00\xa4\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x17q\x04\x00Europe/Vi" +
+       "lniusUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x17S\x91\xb3\xc1\x02\x00\x00\xc1\x02\x00\x00\r\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x03t\x04\x00Europe/BerlinUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9R\x1b8\xfel\xd6\x02\x00\x00\xd6\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\vw\x04\x00Europe/SaratovUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe6Kf\xab\xfe\x02\x00\x00\xfe\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81)z" +
+       "\x04\x00Europe/BudapestUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x95\xb4\x9e" +
+       "\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81p}\x04\x00Europe/RomeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x90\xa9\xf5ϕ\x02\x00\x00\x95\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81h\x81\x04\x00Europe/Bucha" +
+       "restUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\x11\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81G\x84\x04\x00Europe/BratislavaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9R==\xa4\x16\xc4\x04\x00\x00\xc4\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81e\x87\x04\x00Europe/GibraltarUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rq\x16\x9b?\xa3\x02\x00\x00\xa3\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81s\x8c\x04\x00Europe/TallinnUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "RI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81^\x8f\x04\x00Europe/TiraspolUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x9a\x92\x04\x00Euro" +
+       "pe/LjubljanaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00" +
+       "\xde\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\u0094\x04\x00Europe/SkopjeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe7\x96\x04\x00Europe/Helsinki" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rz\xc3\xe8Ra\x03\x00\x00a\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81\x11\x99\x04\x00Europe/SimferopolUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R8I\xdeN%\x02\x00\x00%\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbd\x9c\x04\x00Europe/KievUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81'\x9f\x04\x00Eu" +
+       "rope/ZurichUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RDd#\xc4\xf1\x01\x00\x00\xf1" +
+       "\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81_\xa1\x04\x00Europe/BusingenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RZ\x05wג\x02\x00\x00\x92\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x99\xa3\x04\x00Europe/ViennaU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ru\xb0\xcd\xfc\xf8\x02\x00\x00\xf8\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81r\xa6\x04\x00Europe/UlyanovskUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" +
+       "\x00\xf1c9R\xd9L\xf6\xf7\xf1\x01\x00\x00\xf1\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4\xa9\x04\x00Europe/StockholmUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rgp\xc0\xa7\xb6\x02\x00\x00\xb6\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xef\xab\x04" +
+       "\x00Europe/RigaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00" +
+       "?\x06\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xea\xae\x04\x00Europe/Isle_of_ManUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81u\xb5\x04\x00Europe/Chi" +
+       "sinauUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf2\xfa\xcb\x130\x02\x00\x000\x02\x00\x00\x11\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb1\xb8\x04\x00Europe/ZaporozhyeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe0\xfe\x83\xe5\xcd\x02\x00\x00\xcd\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,\xbb\x04\x00Europe/KirovUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "?\xbe\x04\x00Europe/WarsawUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4," +
+       "\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81!\xc2\x04\x00Europe/LondonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rn\x81\xf4\xd7Z\x04\x00\x00Z\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa7\xc8\x04\x00Europe/Mon" +
+       "acoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\v\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81H\xcd\x04\x00Europe/OsloUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x811\xd0\x04\x00Europe/PodgoricaUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y\xd2\x04\x00" +
+       "Europe/IstanbulUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xab\x80c$q" +
+       "\x00\x00\x00q\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81R\xd7\x04\x00FactoryUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x02\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x04\xd8\x04\x00GBUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\u007f\xde\x04\x00GB-Eir" +
+       "eUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81\xff\xe4\x04\x00GMTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00" +
+       "\x00\x00o\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xab\xe5\x04\x00GMT+0UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y\xe6\x04\x00GMT-0UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\a\xe7\x04\x00GMT0UT" +
+       "\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\xa4\x81\xb4\xe7\x04\x00GreenwichUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RE\t\xfa" +
+       "-\a\x03\x00\x00\a\x03\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81f\xe8\x04\x00HongkongUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R=\xf7\xfawp\x00\x00\x00p\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaf\xeb\x04\x00HSTUT\x05\x00\x03\x15\xac\x0e`ux\v" +
+       "\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\\\xec\x04\x00Ic" +
+       "elandUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x8e\xef\x04\x00Indian/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xcf\xef\x04\x00Indian/MayotteUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb8K\xabυ\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd6\xf0\x04\x00Indi" +
+       "an/KerguelenUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb9\xb2Z\xac\x98\x00\x00\x00" +
+       "\x98\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5\xf1\x04\x00Indian/MaldivesUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ry(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x86\xf2\x04\x00Indian/Reunio" +
+       "nUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81S\xf3\x04\x00Indian/MauritiusUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81P\xf4\x04\x00Indian/AntananarivoUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ra\x85jo\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\\\xf5\x04\x00Indian/MaheUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb4\x8d\x98" +
+       "ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81&\xf6\x04\x00Indian/ComoroUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R$l=҅\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81,\xf7\x04\x00Indian/Chr" +
+       "istmasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00" +
+       "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfb\xf7\x04\x00Indian/ChagosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9RͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xda\xf8\x04\x00Indian/CocosUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xac\xf9\x04" +
+       "\x00IranUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x17✳2\x04\x00\x002\x04\x00\x00\x06\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbe\x01\x05\x00IsraelUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x810\x06\x05\x00JamaicaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc4\a\x05\x00JapanUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd8" +
+       "\b\x05\x00KwajaleinUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R_\u007f2[\xaf\x01\x00\x00" +
+       "\xaf\x01\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6\t\x05\x00LibyaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe4\v\x05\x00METUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedA\x8e\x0e\x05\x00Mexico/UT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81\xcf\x0e\x05\x00Mexico/GeneralUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9" +
+       "R\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb3\x10\x05\x00Mexico/BajaNorteUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R8\xcdZ\x05o\x01\x00\x00o\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfe\x14\x05\x00Mex" +
+       "ico/BajaSurUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf5\x8d\x99\x92o\x00\x00\x00o" +
+       "\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb5\x16\x05\x00MSTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81a\x17\x05\x00MST7MDTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00" +
+       "\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Y\x1b\x05\x00NavajoUT\x05" +
+       "\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\xa4\x81\xab\x1f\x05\x00NZUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x96\xc5FF(\x03\x00\x00(\x03\x00" +
+       "\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfa#\x05\x00NZ-CHATUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedAc'\x05\x00Pacific/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8" +
+       "\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa5'\x05\x00Pacifi" +
+       "c/EasterUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00" +
+       "\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81;,\x05\x00Pacific/PitcairnUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R3\x03\x1f\f\xac\x00\x00\x00\xac\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1e-\x05\x00Pacific/Enderbur" +
+       "yUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Ra\vೆ\x00\x00\x00\x86\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\x00\xa4\x81\x15.\x05\x00Pacific/FunafutiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe5.\x05\x00Pacific/PonapeUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x030\x05" +
+       "\x00Pacific/NoumeaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x80\xf8vܔ" +
+       "\x00\x00\x00\x94\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x111\x05\x00Pacific/PalauUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xec1\x05\x00Pacific/John" +
+       "stonUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xca\"\xb8i\xda\x00\x00\x00\xda\x00\x00\x00\x0e\x00\x18\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x133\x05\x00Pacific/MajuroUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00" +
+       "\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x8154\x05\x00Pacific/Pago_PagoUT\x05\x00\x03" +
+       "\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9e\u007f\xab\x95V\x01\x00\x00V\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4" +
+       "\x81\x125\x05\x00Pacific/EfateUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc8=" +
+       "ku\xae\x00\x00\x00\xae\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaf6\x05\x00Pacific/KiritimatiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01" +
+       "\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x8a|\xdcU\x99\x00\x00\x00\x99\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa97\x05\x00Paci" +
+       "fic/FakaofoUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x96\xc5FF(\x03\x00\x00(" +
+       "\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x8b8\x05\x00Pacific/ChathamUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00" +
+       "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfc;\x05\x00Pacific/Kwajal" +
+       "einUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\"=\x05\x00Pacific/MidwayUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00" +
+       "\x00\x00\x00\xf1c9R1\xce_(\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfc=\x05\x00Pacific/WallisUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R4\xd0Yӣ\x01\x00\x00\xa3\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xca>\x05" +
+       "\x00Pacific/FijiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe9\xdd\x1e\xee\f\x01\x00" +
+       "\x00\f\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb3@\x05\x00Pacific/ApiaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00P" +
+       "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05B\x05\x00Pacific/YapUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\rC\x05\x00Pacific/Port_MoresbyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5C\x05\x00Pacific/HonoluluUT\x05\x00\x03\x15\xac\x0e" +
+       "`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1cE" +
+       "\x05\x00Pacific/PohnpeiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc23\xa0" +
+       "\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81;F\x05\x00Pacific/GambierUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe2;Z\xf7\xb7\x00\x00\x00\xb7\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\bG\x05\x00Pacific/" +
+       "NauruUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x97n7\x1a\xf2\x00\x00\x00\xf2\x00\x00\x00\x0e\x00\x18" +
+       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x06H\x05\x00Pacific/KosraeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n" +
+       "\x00\x00\x00\x00\x00\xf1c9R\x85v\xf8\x8c\x87\x01\x00\x00\x87\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81@I\x05\x00Pacific/RarotongaUT\x05\x00" +
+       "\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RD6\x83\xa1\x8b\x00\x00\x00\x8b\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\xa4\x81\x12K\x05\x00Pacific/MarquesasUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe8K\x05\x00Pacific/TarawaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb6L\x05\x00Pac" +
+       "ific/TrukUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x81\xeb\xb8m\xaf\x00\x00\x00\xaf\x00\x00" +
+       "\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbfM\x05\x00Pacific/NiueUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e" +
+       "\x03\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb4N\x05\x00Pacific/SamoaUT\x05\x00\x03\x15" +
+       "\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81" +
+       "\x8dO\x05\x00Pacific/GuamUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RFI\xfe\x14" +
+       "^\x01\x00\x00^\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x811Q\x05\x00Pacific/SaipanUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04" +
+       "\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x81\xe3w\n\xaf\x00\x00\x00\xaf\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd7R\x05\x00Pacific/Ga" +
+       "lapagosUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd1S\x05\x00Pacific/BougainvilleUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R߃\xa0_\x86\x00\x00\x00\x86\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe8T\x05\x00Pacific/WakeU" +
+       "T\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RP:\xc0\x8c\xed\x00\x00\x00\xed\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\xa4\x81\xb4U\x05\x00Pacific/TongatapuUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" +
+       "\x00\x00\xf1c9R\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xecV\x05\x00Pacific/ChuukUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xea\xc1\xdaυ\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf6W\x05\x00P" +
+       "acific/TahitiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RY\xd2K|\x86\x00\x00" +
+       "\x00\x86\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc3X\x05\x00Pacific/GuadalcanalUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00" +
+       "\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x96Y\x05\x00Pacific/" +
+       "AucklandUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00" +
+       "\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf3]\x05\x00Pacific/NorfolkUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x813_\x05\x00PolandUT\x05\x00\x03\x15\xac\x0e`ux" +
+       "\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xfa\xd5\xd6М\x05\x00\x00\x9c\x05\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0ec\x05\x00P" +
+       "ortugalUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x03" +
+       "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xech\x05\x00PRCUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R" +
+       "ŭV\xad\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb2j\x05\x00PST8PDTUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00" +
+       "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xaan\x05\x00ROCUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe6p\x05\x00" +
+       "ROKUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\t\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xc2r\x05\x00SingaporeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c" +
+       "9R\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x05t\x05\x00TurkeyUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03" +
+       "\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xf5x\x05\x00UCTUT\x05\x00\x03\x15\xac\x0e`" +
+       "ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa1y\x05" +
+       "\x00UniversalUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
+       "\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xedASz\x05\x00US/UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1" +
+       "c9R\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x90z\x05\x00US/PacificUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03" +
+       "\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xe2\u007f\x05\x00US/Cent" +
+       "ralUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x18\x00\x00" +
+       "\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x87\x05\x00US/MichiganUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" +
+       "\xf1c9R\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ȋ\x05\x00US/AleutianUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04" +
+       "\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81֎\x05\x00US/In" +
+       "diana-StarkeUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9RV\x80\x94@\x12\x04\x00\x00" +
+       "\x12\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x19\x93\x05\x00US/MountainUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01" +
+       "\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81p\x97\x05\x00US/ArizonaUT\x05\x00\x03\x15\xac" +
+       "\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa4" +
+       "\x98\x05\x00US/EasternUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R5\x11Q\x06\xd1\x03\x00" +
+       "\x00\xd1\x03\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb8\x9f\x05\x00US/AlaskaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02" +
+       "\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81̣\x05\x00US/SamoaUT\x05\x00\x03\x15\xac\x0e`u" +
+       "x\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9Rp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xa0\xa4\x05\x00" +
+       "US/East-IndianaUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xeaK\x85v\xdd" +
+       "\x00\x00\x00\xdd\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xfc\xa6\x05\x00US/HawaiiUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK" +
+       "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x1c\xa8\x05\x00UTCUT\x05\x00\x03\x15\xac\x0e`ux\v\x00" +
+       "\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81Ȩ\x05\x00WET" +
+       "UT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00" +
+       "\x00\x00\x00\x00\xa4\x81\xf3\xaa\x05\x00W-SUUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00\xf1c9R\x9f.\xe4xo\x00" +
+       "\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xbd\xae\x05\x00ZuluUT\x05\x00\x03\x15\xac\x0e`ux\v\x00\x01\x04\xe8\x03\x00\x00\x04\xe8\x03\x00\x00PK\x05\x06\x00\x00\x00\x00" +
+       "f\x02f\x02\x96\xc9\x00\x00j\xaf\x05\x00\x00\x00"

diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 04bb67e58d6d7a04c81af639bcb932df7455b5bb..06e6ef1945c160910042cc420ae4591e43751004 100644 (file)
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -18,7 +18,7 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20201204225414-ed752295db88
+# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
 ## explicit
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.4

diff --git a/test/abi/regabipragma.dir/main.go b/test/abi/regabipragma.dir/main.go
new file mode 100644 (file)
index 0000000..d663337
--- /dev/null
+++ b/test/abi/regabipragma.dir/main.go
@@ -0,0 +1,36 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+       "fmt"
+       "regabipragma.dir/tmp"
+)
+
+type S string
+
+//go:noinline
+func (s S) ff(t string) string {
+       return string(s) + " " + t
+}
+
+//go:noinline
+//go:registerparams
+func f(s,t string) string { // ERROR "Declared function f has register params"
+       return s + " " + t
+}
+
+func check(s string) {
+       if s != "Hello world!" {
+               fmt.Printf("FAIL, wanted 'Hello world!' but got '%s'\n", s)
+       }
+}
+
+func main() {
+       check(f("Hello", "world!"))   // ERROR "Called function ...f has register params"
+       check(tmp.F("Hello", "world!"))  // ERROR "Called function regabipragma.dir/tmp.F has register params"
+       check(S("Hello").ff("world!"))
+       check(tmp.S("Hello").FF("world!"))
+}

diff --git a/test/abi/regabipragma.dir/tmp/foo.go b/test/abi/regabipragma.dir/tmp/foo.go
new file mode 100644 (file)
index 0000000..cff989b
--- /dev/null
+++ b/test/abi/regabipragma.dir/tmp/foo.go
@@ -0,0 +1,19 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tmp
+
+
+type S string
+
+//go:noinline
+func (s S) FF(t string) string {
+        return string(s) + " " + t
+}
+
+//go:noinline
+//go:registerparams
+func F(s,t string) string {
+        return s + " " + t
+}

diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
new file mode 100644 (file)
index 0000000..e7ecd58
--- /dev/null
+++ b/test/abi/regabipragma.go
@@ -0,0 +1,10 @@
+// runindir -gcflags=-c=1
+// +build !windows
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// TODO May delete or adapt this test once regabi is the default
+
+package ignore

diff --git a/test/abi/regabipragma.out b/test/abi/regabipragma.out
new file mode 100644 (file)
index 0000000..321b1ad
--- /dev/null
+++ b/test/abi/regabipragma.out
@@ -0,0 +1,6 @@
+# regabipragma.dir/tmp
+tmp/foo.go:17:6: declared function F has register params
+# regabipragma.dir
+./main.go:21:6: declared function f has register params
+./main.go:32:9: called function f has register params
+./main.go:33:13: called function tmp.F has register params

diff --git a/test/closure2.go b/test/closure2.go
index e4db05d8846cec75449a717e30fbbd9f8499a14d..812d41f8ce02cf3659d75d216a1cf17d7e9e162d 100644 (file)
--- a/test/closure2.go
+++ b/test/closure2.go
@@ -9,6 +9,8 @@
 
 package main
 
+var never bool
+
 func main() {
        {
                type X struct {
@@ -115,4 +117,16 @@ func main() {
                        panic("g() != 2")
                }
        }
+
+       {
+               var g func() int
+               q := 0
+               q, g = 1, func() int { return q }
+               if never {
+                       g = func() int { return 2 }
+               }
+               if g() != 1 {
+                       panic("g() != 1")
+               }
+       }
 }

diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index 5694673f1ec64bece849d7473362fb4296f03ff7..2fc33753ed7f8c0c8ea96c78292a82a0c61da0f7 100644 (file)
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -93,11 +93,11 @@ func main() {
                y := func(x int) int { // ERROR "can inline main.func11" "func literal does not escape"
                        return x + 2
                }
-               y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-                       return func(x int) int { // ERROR "can inline main.func12" "func literal escapes"
+               y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12"
+                       return func(x int) int { // ERROR "can inline main.func12"
                                return x + 1
                        }, 42
-               }()
+               }() // ERROR "func literal does not escape" "inlining call to main.func12"
                if y(40) != 41 {
                        ppanic("y(40) != 41")
                }
@@ -105,14 +105,14 @@ func main() {
 
        {
                func() { // ERROR "func literal does not escape"
-                       y := func(x int) int { // ERROR "can inline main.func13.1" "func literal does not escape"
+                       y := func(x int) int { // ERROR "func literal does not escape" "can inline main.func13.1"
                                return x + 2
                        }
-                       y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-                               return func(x int) int { // ERROR "can inline main.func13.2" "func literal escapes"
+                       y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2"
+                               return func(x int) int { // ERROR "can inline main.func13.2"
                                        return x + 1
                                }, 42
-                       }()
+                       }() // ERROR "inlining call to main.func13.2" "func literal does not escape"
                        if y(40) != 41 {
                                ppanic("y(40) != 41")
                        }
@@ -187,29 +187,29 @@ func main() {
 
        {
                x := 42
-               if z := func(y int) int { // ERROR "func literal does not escape"
-                       return func() int { // ERROR "can inline main.func22.1"
+               if z := func(y int) int { // ERROR "can inline main.func22"
+                       return func() int { // ERROR "can inline main.func22.1" "can inline main.func30"
                                return x + y
                        }() // ERROR "inlining call to main.func22.1"
-               }(1); z != 43 {
+               }(1); z != 43 { // ERROR "inlining call to main.func22" "inlining call to main.func30"
                        ppanic("z != 43")
                }
-               if z := func(y int) int { // ERROR "func literal does not escape"
-                       return func() int { // ERROR "can inline main.func23.1"
+               if z := func(y int) int { // ERROR "func literal does not escape" "can inline main.func23"
+                       return func() int { // ERROR "can inline main.func23.1" "can inline main.func31"
                                return x + y
                        }() // ERROR "inlining call to main.func23.1"
-               }; z(1) != 43 {
+               }; z(1) != 43 { // ERROR "inlining call to main.func23" "inlining call to main.func31"
                        ppanic("z(1) != 43")
                }
        }
 
        {
                a := 1
-               func() { // ERROR "func literal does not escape"
-                       func() { // ERROR "can inline main.func24"
+               func() { // ERROR "can inline main.func24"
+                       func() { // ERROR "can inline main.func24" "can inline main.func32"
                                a = 2
                        }() // ERROR "inlining call to main.func24"
-               }()
+               }() // ERROR "inlining call to main.func24" "inlining call to main.func32"
                if a != 2 {
                        ppanic("a != 2")
                }
@@ -250,12 +250,12 @@ func main() {
                a := 2
                if r := func(x int) int { // ERROR "func literal does not escape"
                        b := 3
-                       return func(y int) int { // ERROR "func literal does not escape"
+                       return func(y int) int { // ERROR "can inline main.func27.1"
                                c := 5
-                               return func(z int) int { // ERROR "can inline main.func27.1.1"
+                               return func(z int) int { // ERROR "can inline main.func27.1.1" "can inline main.func27.2"
                                        return a*x + b*y + c*z
                                }(10) // ERROR "inlining call to main.func27.1.1"
-                       }(100)
+                       }(100) // ERROR "inlining call to main.func27.1" "inlining call to main.func27.2"
                }(1000); r != 2350 {
                        ppanic("r != 2350")
                }
@@ -265,15 +265,15 @@ func main() {
                a := 2
                if r := func(x int) int { // ERROR "func literal does not escape"
                        b := 3
-                       return func(y int) int { // ERROR "func literal does not escape"
+                       return func(y int) int { // ERROR "can inline main.func28.1"
                                c := 5
-                               func(z int) { // ERROR "can inline main.func28.1.1"
+                               func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.2"
                                        a = a * x
                                        b = b * y
                                        c = c * z
                                }(10) // ERROR "inlining call to main.func28.1.1"
                                return a + c
-                       }(100) + b
+                       }(100) + b // ERROR "inlining call to main.func28.1" "inlining call to main.func28.2"
                }(1000); r != 2350 {
                        ppanic("r != 2350")
                }
@@ -285,5 +285,5 @@ func main() {
 
 //go:noinline
 func ppanic(s string) { // ERROR "leaking param: s"
-       panic(s)
+       panic(s) // ERROR "s escapes to heap"
 }

diff --git a/test/closure5.dir/a.go b/test/closure5.dir/a.go
new file mode 100644 (file)
index 0000000..de8082b
--- /dev/null
+++ b/test/closure5.dir/a.go
@@ -0,0 +1,11 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+
+package a
+
+func f() bool               { return true }
+func G() func() func() bool { return func() func() bool { return f } }

diff --git a/test/closure5.dir/main.go b/test/closure5.dir/main.go
new file mode 100644 (file)
index 0000000..ee5dba6
--- /dev/null
+++ b/test/closure5.dir/main.go
@@ -0,0 +1,15 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+package main
+
+import "a"
+
+func main() {
+       if !a.G()()() {
+               panic("FAIL")
+       }
+}

diff --git a/test/closure5.go b/test/closure5.go
new file mode 100644 (file)
index 0000000..a7022b2
--- /dev/null
+++ b/test/closure5.go
@@ -0,0 +1,10 @@
+// compiledir
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+
+package ignored

diff --git a/test/closure6.go b/test/closure6.go
new file mode 100644 (file)
index 0000000..b5592ad
--- /dev/null
+++ b/test/closure6.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+type Float64Slice []float64
+
+func (a Float64Slice) Search1(x float64) int {
+       f := func(q int) bool { return a[q] >= x }
+       i := 0
+       if !f(3) {
+               i = 5
+       }
+       return i
+}

diff --git a/test/closure7.go b/test/closure7.go
new file mode 100644 (file)
index 0000000..823333f
--- /dev/null
+++ b/test/closure7.go
@@ -0,0 +1,28 @@
+// run
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func g(f func()) {
+}
+
+// Must have exportable name
+func F() {
+       g(func() {
+               ch := make(chan int)
+               for {
+                       select {
+                       case <-ch:
+                               return
+                       default:
+                       }
+               }
+       })
+}
+
+func main() {
+       F()
+}

diff --git a/test/codegen/condmove.go b/test/codegen/condmove.go
index f86da3459a325d9a1c5e3240ba1e311934dd438a..7579dd1890ed2fb84c5cdccd35b1be828d35570e 100644 (file)
--- a/test/codegen/condmove.go
+++ b/test/codegen/condmove.go
@@ -31,7 +31,7 @@ func cmovuintptr(x, y uintptr) uintptr {
        if x < y {
                x = -y
        }
-       // amd64:"CMOVQCS"
+       // amd64:"CMOVQ(HI|CS)"
        // arm64:"CSEL\t(LO|HI)"
        // wasm:"Select"
        return x
@@ -41,7 +41,7 @@ func cmov32bit(x, y uint32) uint32 {
        if x < y {
                x = -y
        }
-       // amd64:"CMOVLCS"
+       // amd64:"CMOVL(HI|CS)"
        // arm64:"CSEL\t(LO|HI)"
        // wasm:"Select"
        return x
@@ -51,7 +51,7 @@ func cmov16bit(x, y uint16) uint16 {
        if x < y {
                x = -y
        }
-       // amd64:"CMOVWCS"
+       // amd64:"CMOVW(HI|CS)"
        // arm64:"CSEL\t(LO|HI)"
        // wasm:"Select"
        return x

diff --git a/test/codegen/spectre.go b/test/codegen/spectre.go
index 3753498d09f76f49fd413ab43cfcfc7af1ec45a2..d845da35ced9274b49a5f8d0df0ea41d218ac056 100644 (file)
--- a/test/codegen/spectre.go
+++ b/test/codegen/spectre.go
@@ -13,12 +13,12 @@ func IndexArray(x *[10]int, i int) int {
 }
 
 func IndexString(x string, i int) byte {
-       // amd64:`CMOVQCC`
+       // amd64:`CMOVQLS`
        return x[i]
 }
 
 func IndexSlice(x []float64, i int) float64 {
-       // amd64:`CMOVQCC`
+       // amd64:`CMOVQLS`
        return x[i]
 }
 

diff --git a/test/codegen/structs.go b/test/codegen/structs.go
index 9eddc5b16ec3e3ea85212cd394b0fc65fd154bd8..c4bcb55c637cdb3d98d9a38fdfdaf210f14dfa86 100644 (file)
--- a/test/codegen/structs.go
+++ b/test/codegen/structs.go
@@ -18,7 +18,7 @@ type Z1 struct {
 }
 
 func Zero1(t *Z1) { // Issue #18370
-       // amd64:`XORPS\tX., X`,`MOVUPS\tX., \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
+       // amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
        *t = Z1{}
 }
 
@@ -27,7 +27,7 @@ type Z2 struct {
 }
 
 func Zero2(t *Z2) {
-       // amd64:`XORPS\tX., X`,`MOVUPS\tX., \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
+       // amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
        // amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
        *t = Z2{}
 }

diff --git a/test/const2.go b/test/const2.go
index 048d0cb9f397634791841763e9de764967342918..d104a2fa7194169cac41bc712cdafd34e08c7d2e 100644 (file)
--- a/test/const2.go
+++ b/test/const2.go
@@ -19,3 +19,14 @@ const LargeB = LargeA * LargeA * LargeA
 const LargeC = LargeB * LargeB * LargeB // GC_ERROR "constant multiplication overflow"
 
 const AlsoLargeA = LargeA << 400 << 400 >> 400 >> 400 // GC_ERROR "constant shift overflow"
+
+// Issue #42732.
+
+const a = 1e+500000000
+const b = a * a // ERROR "constant multiplication overflow"
+const c = b * b
+
+const MaxInt512 = (1<<256 - 1) * (1<<256 + 1)
+const _ = MaxInt512 + 1  // ERROR "constant addition overflow"
+const _ = MaxInt512 ^ -1 // ERROR "constant bitwise XOR overflow"
+const _ = ^MaxInt512     // ERROR "constant bitwise complement overflow"

diff --git a/test/deferfin.go b/test/deferfin.go
index 80372916d20b303303483f6ea36911b20482c8dc..1312bbbe71b04ac195330dc9151c84cfcf87031e 100644 (file)
--- a/test/deferfin.go
+++ b/test/deferfin.go
@@ -18,12 +18,8 @@ import (
 var sink func()
 
 func main() {
-       // Does not work on 32-bits due to partially conservative GC.
+       // Does not work with gccgo, due to partially conservative GC.
        // Try to enable when we have fully precise GC.
-       if runtime.GOARCH != "amd64" {
-               return
-       }
-       // Likewise for gccgo.
        if runtime.Compiler == "gccgo" {
                return
        }
@@ -60,4 +56,3 @@ func main() {
                panic("not all finalizers are called")
        }
 }
-

diff --git a/test/embedfunc.go b/test/embedfunc.go
new file mode 100644 (file)
index 0000000..14e0f82
--- /dev/null
+++ b/test/embedfunc.go
@@ -0,0 +1,15 @@
+// errorcheck
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import _ "embed"
+
+func f() {
+       //go:embed x.txt // ERROR "go:embed cannot apply to var inside func"
+       var x string
+       _ = x
+}

diff --git a/test/embedvers.go b/test/embedvers.go
new file mode 100644 (file)
index 0000000..71f0f22
--- /dev/null
+++ b/test/embedvers.go
@@ -0,0 +1,12 @@
+// errorcheck -lang=go1.15
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import _ "embed"
+
+//go:embed x.txt // ERROR "go:embed requires go1.16 or later"
+var x string

diff --git a/test/escape2.go b/test/escape2.go
index 5c6eb559faf0667b37433d7d6db1bce091439892..b9b723d8666862195d9bc090eda8608ba0bf607e 100644 (file)
--- a/test/escape2.go
+++ b/test/escape2.go
@@ -1547,7 +1547,7 @@ func foo153(v interface{}) *int { // ERROR "v does not escape"
        case int: // ERROR "moved to heap: x$"
                return &x
        }
-       panic(0)
+       panic(0) // ERROR "0 escapes to heap"
 }
 
 // issue 8185 - &result escaping into result

diff --git a/test/escape2n.go b/test/escape2n.go
index 46e58f85661a7ab6e25a019c11d15a64c9da1c79..7c8208aa73ca11afb097cd1a0fb9e68922dc8d89 100644 (file)
--- a/test/escape2n.go
+++ b/test/escape2n.go
@@ -1547,7 +1547,7 @@ func foo153(v interface{}) *int { // ERROR "v does not escape"
        case int: // ERROR "moved to heap: x$"
                return &x
        }
-       panic(0)
+       panic(0) // ERROR "0 escapes to heap"
 }
 
 // issue 8185 - &result escaping into result

diff --git a/test/escape4.go b/test/escape4.go
index a4a9c14a3e0cc211eff199b93d131b8eddb28469..4e50231bf959b1a36534ba6db412da28ac0ef392 100644 (file)
--- a/test/escape4.go
+++ b/test/escape4.go
@@ -35,14 +35,14 @@ func f1() {
 func f2() {} // ERROR "can inline f2"
 
 // No inline for recover; panic now allowed to inline.
-func f3() { panic(1) } // ERROR "can inline f3"
+func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
 func f4() { recover() }
 
 func f5() *byte {
        type T struct {
                x [1]byte
        }
-       t := new(T)    // ERROR "new.T. escapes to heap"
+       t := new(T) // ERROR "new.T. escapes to heap"
        return &t.x[0]
 }
 
@@ -52,6 +52,6 @@ func f6() *byte {
                        y byte
                }
        }
-       t := new(T)   // ERROR "new.T. escapes to heap"
+       t := new(T) // ERROR "new.T. escapes to heap"
        return &t.x.y
 }

diff --git a/test/escape_param.go b/test/escape_param.go
index 993e914e1d0d4f65f8512c7179bb9970853fa865..dc93f689cf9fbd8e17a52097fbe95f244c525ddb 100644 (file)
--- a/test/escape_param.go
+++ b/test/escape_param.go
@@ -212,7 +212,7 @@ func caller7() {
 
 // **in -> heap
 func param8(i **int) { // ERROR "i does not escape$"
-       sink = **i // ERROR "\* \(\*i\) escapes to heap"
+       sink = **i // ERROR "\*\(\*i\) escapes to heap"
 }
 
 func caller8() {
@@ -402,7 +402,7 @@ func caller13h() {
        var p *int
        v := &Val{&p} // ERROR "&Val{...} does not escape$"
        v.param13(&i)
-       sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
+       sink = **v.p // ERROR "\*\(\*v\.p\) escapes to heap"
 }
 
 type Node struct {

diff --git a/test/fixedbugs/bug195.go b/test/fixedbugs/bug195.go
index aef7bd2d8944a883c344b558dbdff1abb11aad54..94f61fff7f1cb0a2b030b6ba7273b12e7f7b47b4 100644 (file)
--- a/test/fixedbugs/bug195.go
+++ b/test/fixedbugs/bug195.go
@@ -19,7 +19,7 @@ type I4 interface { // GC_ERROR "invalid recursive type I4\n\tLINE: I4 refers to
 }
 
 type I5 interface { // GC_ERROR "invalid recursive type I5\n\tLINE: I5 refers to\n\tLINE+4: I6 refers to\n\tLINE: I5$"
-       I6 // GCCGO_ERROR "interface"
+       I6
 }
 
 type I6 interface {

diff --git a/test/fixedbugs/bug251.go b/test/fixedbugs/bug251.go
index 706bb8d69019d51d2968a1d13b0911f17ecec973..977aa49e6a0e0467238e8db2c13eca701c898764 100644 (file)
--- a/test/fixedbugs/bug251.go
+++ b/test/fixedbugs/bug251.go
@@ -8,7 +8,7 @@ package main
 
 type I1 interface { // GC_ERROR "invalid recursive type"
        m() I2
-       I2 // GCCGO_ERROR "loop|interface"
+       I2
 }
 
 type I2 interface {

diff --git a/test/fixedbugs/bug302.go b/test/fixedbugs/bug302.go
index 87f9d4ef70ccc1ddc0cc6f3a528fc161294d9402..a2ab661277a38ff40b45c1c73232d25502f91bb5 100644 (file)
--- a/test/fixedbugs/bug302.go
+++ b/test/fixedbugs/bug302.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2010 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/bug340.go b/test/fixedbugs/bug340.go
index 8c543c98d97e3b5299e1747a96b6a8f6de4880ef..542a6eab03d2d5f3e418866938dbe7df5acd48a8 100644 (file)
--- a/test/fixedbugs/bug340.go
+++ b/test/fixedbugs/bug340.go
@@ -12,6 +12,7 @@ func main() {
        var x interface{}
        switch t := x.(type) {
        case 0:         // ERROR "type"
-               t.x = 1 // ERROR "type interface \{\}|reference to undefined field or method|interface with no methods"
+               t.x = 1
+               x.x = 1 // ERROR "type interface \{\}|reference to undefined field or method|interface with no methods"
        }
 }

diff --git a/test/fixedbugs/bug369.go b/test/fixedbugs/bug369.go
index 9316f7aad0b1df71d896b56ad0e02d6c37d3c108..83f638d04632af0dafaff07c4c6324fad14c79b7 100644 (file)
--- a/test/fixedbugs/bug369.go
+++ b/test/fixedbugs/bug369.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js,!windows
+// +build !nacl,!js,!windows,gc
 // run
 
 // Copyright 2011 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/bug429.go b/test/fixedbugs/bug429.go
deleted file mode 100644 (file)
index 2c31f32..0000000
--- a/test/fixedbugs/bug429.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// skip
-
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Should print deadlock message, not hang.
-// This test is run by bug429_run.go.
-
-package main
-
-func main() {
-       select {}
-}

diff --git a/test/fixedbugs/bug429_run.go b/test/fixedbugs/bug429_run.go
deleted file mode 100644 (file)
index c2bb1b8..0000000
--- a/test/fixedbugs/bug429_run.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// run
-
-// +build !nacl,!js
-
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Run the bug429.go test.
-
-package main
-
-import (
-       "fmt"
-       "os"
-       "os/exec"
-       "path/filepath"
-       "strings"
-)
-
-func main() {
-       cmd := exec.Command("go", "run", filepath.Join("fixedbugs", "bug429.go"))
-       out, err := cmd.CombinedOutput()
-       if err == nil {
-               fmt.Println("expected deadlock")
-               os.Exit(1)
-       }
-
-       want := "fatal error: all goroutines are asleep - deadlock!"
-       got := string(out)
-       if !strings.Contains(got, want) {
-               fmt.Printf("got:\n%q\nshould contain:\n%q\n", got, want)
-               os.Exit(1)
-       }
-}

diff --git a/test/fixedbugs/bug462.go b/test/fixedbugs/bug462.go
index 3df63b091ddbbf0ceda202ca95e908345b1c0afa..bae5ee0aeb01924c7bfc353da8852b72d6a86f78 100644 (file)
--- a/test/fixedbugs/bug462.go
+++ b/test/fixedbugs/bug462.go
@@ -13,7 +13,7 @@ type T struct {
 }
 
 func main() {
-       _ = T {
-               os.File: 1, // ERROR "unknown T? ?field"
+       _ = T{
+               os.File: 1, // ERROR "invalid field name os.File|unknown field"
        }
 }

diff --git a/test/fixedbugs/issue10607.go b/test/fixedbugs/issue10607.go
index 6f4717d8202ff1dee40ee30862e8045364e32157..448a37dcac24d6ec6c5a0b21ab554224805b614a 100644 (file)
--- a/test/fixedbugs/issue10607.go
+++ b/test/fixedbugs/issue10607.go
@@ -1,4 +1,4 @@
-// +build linux,!ppc64,!riscv64
+// +build linux,!ppc64,!riscv64,gc
 // run
 
 // Copyright 2015 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index f3037d53c496fb55c283ec9942dfa6f3243258f1..e0c6a9f0baa3d2a5c97f4240dac783ca310640b6 100644 (file)
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -18,11 +18,11 @@ func main() {
 
        // Any implementation must be able to handle these constants at
        // compile time (even though they cannot be assigned to a float64).
-       var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64|floating-point constant overflow"
-       var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64|floating-point constant overflow"
-       var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64|floating-point constant overflow"
-       var _ = 1e646456     // ERROR "1e\+646456 overflows float64|floating-point constant overflow"
-       var _ = 1e64645      // ERROR "1e\+64645 overflows float64|floating-point constant overflow"
+       var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64|floating-point constant overflow|exponent too large"
+       var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64|floating-point constant overflow|exponent too large"
+       var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64|floating-point constant overflow|exponent too large"
+       var _ = 1e646456     // ERROR "1e\+646456 overflows float64|floating-point constant overflow|exponent too large"
+       var _ = 1e64645      // ERROR "1e\+64645 overflows float64|floating-point constant overflow|exponent too large"
        var _ = 1e6464       // ERROR "1e\+6464 overflows float64|floating-point constant overflow"
        var _ = 1e646        // ERROR "1e\+646 overflows float64|floating-point constant overflow"
        var _ = 1e309        // ERROR "1e\+309 overflows float64|floating-point constant overflow"

diff --git a/test/fixedbugs/issue11326b.go b/test/fixedbugs/issue11326b.go
index 8aba4d91215ffdf1dc8cdd25a692b564d8b13021..b5f933bfea1153c37c28ee3b4c5f897f18b36f06 100644 (file)
--- a/test/fixedbugs/issue11326b.go
+++ b/test/fixedbugs/issue11326b.go
@@ -1,5 +1,9 @@
 // run
 
+// Does not work with gccgo, which uses a smaller (but still permitted)
+// exponent size.
+// +build !gccgo
+
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

diff --git a/test/fixedbugs/issue11362.go b/test/fixedbugs/issue11362.go
index 9e9e599595f6e8534a5e9d872c0692e69eb047df..9492ec12739afd549eb49377158b1f6ea95f0cca 100644 (file)
--- a/test/fixedbugs/issue11362.go
+++ b/test/fixedbugs/issue11362.go
@@ -8,7 +8,7 @@
 
 package main
 
-import _ "unicode//utf8" // ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)" "can't find import: .unicode//utf8."
+import _ "unicode//utf8" // GC_ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)"
 
 func main() {
 }

diff --git a/test/fixedbugs/issue11371.go b/test/fixedbugs/issue11371.go
index 05b8fcfebeb4fb6e44a60ba8b5b5f3d11d355ad6..8acd18fccb90dab033c96124c550414ca1681bf1 100644 (file)
--- a/test/fixedbugs/issue11371.go
+++ b/test/fixedbugs/issue11371.go
@@ -11,7 +11,7 @@ package issue11371
 
 const a int = 1.1        // ERROR "constant 1.1 truncated to integer|floating-point constant truncated to integer"
 const b int = 1e20       // ERROR "overflows int|integer constant overflow"
-const c int = 1 + 1e-100 // ERROR "constant truncated to integer"
-const d int = 1 - 1e-100 // ERROR "constant truncated to integer"
+const c int = 1 + 1e-70  // ERROR "constant truncated to integer"
+const d int = 1 - 1e-70  // ERROR "constant truncated to integer"
 const e int = 1.00000001 // ERROR "constant truncated to integer"
 const f int = 0.00000001 // ERROR "constant 1e-08 truncated to integer|floating-point constant truncated to integer"

diff --git a/test/fixedbugs/issue11614.go b/test/fixedbugs/issue11614.go
index d1642a3faf0d9ccbc5acdc8f63264a35091b1246..de15f9827ffb28d1c18166c762349d0834de0422 100644 (file)
--- a/test/fixedbugs/issue11614.go
+++ b/test/fixedbugs/issue11614.go
@@ -19,7 +19,7 @@ func n() {
 }
 
 func m() {
-       (interface{int}) // ERROR "interface contains embedded non-interface int" "type interface { int } is not an expression"
+       (interface{int}) // ERROR "interface contains embedded non-interface" "type interface { int } is not an expression"
 }
 
 func main() {

diff --git a/test/fixedbugs/issue11656.go b/test/fixedbugs/issue11656.go
index 451ae6348fa96321884ca7c612f7bcd3345e56cc..85fe720b30b667816908afd72da60d323c3c9837 100644 (file)
--- a/test/fixedbugs/issue11656.go
+++ b/test/fixedbugs/issue11656.go
@@ -12,6 +12,11 @@
 // wasm does not work, because the linear memory is not executable.
 // +build !wasm
 
+// This test doesn't work on gccgo/GoLLVM, because they will not find
+// any unwind information for the artificial function, and will not be
+// able to unwind past that point.
+// +build !gccgo
+
 package main
 
 import (
@@ -49,32 +54,36 @@ func f(n int) {
                x uintptr
        }
 
-       // We want to force an illegal instruction, to get a crash
-       // at a PC value != 0.
+       // We want to force a seg fault, to get a crash at a PC value != 0.
        // Not all systems make the data section non-executable.
        ill := make([]byte, 64)
        switch runtime.GOARCH {
        case "386", "amd64":
-               binary.LittleEndian.PutUint16(ill, 0x0b0f) // ud2
+               ill = append(ill[:0], 0x89, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00) // MOVL AX, 0
        case "arm":
-               binary.LittleEndian.PutUint32(ill, 0xe7f000f0) // no name, but permanently undefined
+               binary.LittleEndian.PutUint32(ill[0:4], 0xe3a00000) // MOVW $0, R0
+               binary.LittleEndian.PutUint32(ill[4:8], 0xe5800000) // MOVW R0, (R0)
        case "arm64":
-               binary.LittleEndian.PutUint32(ill, 0xd4207d00) // brk #1000
+               binary.LittleEndian.PutUint32(ill, 0xf90003ff) // MOVD ZR, (ZR)
        case "ppc64":
-               binary.BigEndian.PutUint32(ill, 0x7fe00008) // trap
+               binary.BigEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)
        case "ppc64le":
-               binary.LittleEndian.PutUint32(ill, 0x7fe00008) // trap
+               binary.LittleEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)
        case "mips", "mips64":
-               binary.BigEndian.PutUint32(ill, 0x00000034) // trap
+               binary.BigEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0)
        case "mipsle", "mips64le":
-               binary.LittleEndian.PutUint32(ill, 0x00000034) // trap
+               binary.LittleEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0)
        case "s390x":
-               binary.BigEndian.PutUint32(ill, 0) // undefined instruction
+               ill = append(ill[:0], 0xa7, 0x09, 0x00, 0x00)         // MOVD $0, R0
+               ill = append(ill, 0xe3, 0x00, 0x00, 0x00, 0x00, 0x24) // MOVD R0, (R0)
+       case "riscv64":
+               binary.LittleEndian.PutUint32(ill, 0x00003023) // MOV X0, (X0)
        default:
                // Just leave it as 0 and hope for the best.
        }
 
        f.x = uintptr(unsafe.Pointer(&ill[0]))
-       fn := *(*func())(unsafe.Pointer(&f))
+       p := &f
+       fn := *(*func())(unsafe.Pointer(&p))
        fn()
 }

diff --git a/test/fixedbugs/issue11674.go b/test/fixedbugs/issue11674.go
index e7d0bf298bf8fc9cd18ccc33a15c0a74348d02f9..b43032deac45953d0c54525c05bde43d83db64af 100644 (file)
--- a/test/fixedbugs/issue11674.go
+++ b/test/fixedbugs/issue11674.go
@@ -13,28 +13,28 @@ const x complex64 = 0
 const y complex128 = 0
 
 var _ = x / 1e-20
-var _ = x / 1e-50   // ERROR "complex division by zero"
-var _ = x / 1e-1000 // ERROR "complex division by zero"
+var _ = x / 1e-50   // GC_ERROR "complex division by zero"
+var _ = x / 1e-1000 // GC_ERROR "complex division by zero"
 var _ = x / 1e-20i
-var _ = x / 1e-50i   // ERROR "complex division by zero"
-var _ = x / 1e-1000i // ERROR "complex division by zero"
+var _ = x / 1e-50i   // GC_ERROR "complex division by zero"
+var _ = x / 1e-1000i // GC_ERROR "complex division by zero"
 
 var _ = x / 1e-45 // smallest positive float32
 
 var _ = x / (1e-20 + 1e-20i)
 var _ = x / (1e-50 + 1e-20i)
 var _ = x / (1e-20 + 1e-50i)
-var _ = x / (1e-50 + 1e-50i)     // ERROR "complex division by zero"
-var _ = x / (1e-1000 + 1e-1000i) // ERROR "complex division by zero"
+var _ = x / (1e-50 + 1e-50i)     // GC_ERROR "complex division by zero"
+var _ = x / (1e-1000 + 1e-1000i) // GC_ERROR "complex division by zero"
 
 var _ = y / 1e-50
-var _ = y / 1e-1000 // ERROR "complex division by zero"
+var _ = y / 1e-1000 // GC_ERROR "complex division by zero"
 var _ = y / 1e-50i
-var _ = y / 1e-1000i // ERROR "complex division by zero"
+var _ = y / 1e-1000i // GC_ERROR "complex division by zero"
 
 var _ = y / 5e-324 // smallest positive float64
 
 var _ = y / (1e-50 + 1e-50)
 var _ = y / (1e-1000 + 1e-50i)
 var _ = y / (1e-50 + 1e-1000i)
-var _ = y / (1e-1000 + 1e-1000i) // ERROR "complex division by zero"
+var _ = y / (1e-1000 + 1e-1000i) // GC_ERROR "complex division by zero"

diff --git a/test/fixedbugs/issue11771.go b/test/fixedbugs/issue11771.go
index 99d7060d44e4b45f41940bc869492ca0a4e49737..c95dd6ba3965849ac2432eaa1494a67d209dc972 100644 (file)
--- a/test/fixedbugs/issue11771.go
+++ b/test/fixedbugs/issue11771.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2015 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue13268.go b/test/fixedbugs/issue13268.go
index fcb69c90682f9338a4392610707148909ae790e1..53a82d5074ab97af601fee7bcb70ba84d60ff67a 100644 (file)
--- a/test/fixedbugs/issue13268.go
+++ b/test/fixedbugs/issue13268.go
@@ -1,3 +1,4 @@
+// +build gc
 // run
 
 // Copyright 2015 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue13471.go b/test/fixedbugs/issue13471.go
index 9bfc8c3d2cffd62c7cc9d1da6c96754759c45425..9069412ffa6234d14fa96fe75230ea27f783d82a 100644 (file)
--- a/test/fixedbugs/issue13471.go
+++ b/test/fixedbugs/issue13471.go
@@ -9,17 +9,17 @@
 package main
 
 func main() {
-       const _ int64 = 1e646456992 // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ int32 = 1e64645699  // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ int16 = 1e6464569   // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ int8 = 1e646456     // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ int = 1e64645       // ERROR "integer too large|floating-point constant truncated to integer"
+       const _ int64 = 1e646456992 // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ int32 = 1e64645699  // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ int16 = 1e6464569   // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ int8 = 1e646456     // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ int = 1e64645       // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
 
-       const _ uint64 = 1e646456992 // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ uint32 = 1e64645699  // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ uint16 = 1e6464569   // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ uint8 = 1e646456     // ERROR "integer too large|floating-point constant truncated to integer"
-       const _ uint = 1e64645       // ERROR "integer too large|floating-point constant truncated to integer"
+       const _ uint64 = 1e646456992 // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ uint32 = 1e64645699  // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ uint16 = 1e6464569   // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ uint8 = 1e646456     // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
+       const _ uint = 1e64645       // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
 
-       const _ rune = 1e64645 // ERROR "integer too large|floating-point constant truncated to integer"
+       const _ rune = 1e64645 // ERROR "integer too large|floating-point constant truncated to integer|exponent too large"
 }

diff --git a/test/fixedbugs/issue13799.go b/test/fixedbugs/issue13799.go
index fbdd4c32bc85a85fd9aa405962d36810776988ec..c8ecfc54e4464c3b01bc44b562d99cb4d720f2be 100644 (file)
--- a/test/fixedbugs/issue13799.go
+++ b/test/fixedbugs/issue13799.go
@@ -60,7 +60,7 @@ func test1(iter int) {
        }
 
        if len(m) != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }
 
@@ -84,7 +84,7 @@ func test2(iter int) {
        }
 
        if len(m) != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }
 
@@ -110,7 +110,7 @@ func test3(iter int) {
        }
 
        if *m != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }
 
@@ -136,7 +136,7 @@ func test4(iter int) {
        }
 
        if *m != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }
 
@@ -167,7 +167,7 @@ func test5(iter int) {
        }
 
        if *m != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }
 
@@ -185,6 +185,6 @@ func test6(iter int) {
        }
 
        if *m != maxI {
-               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+               panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
        }
 }

diff --git a/test/fixedbugs/issue14136.go b/test/fixedbugs/issue14136.go
index f9efd05f96c8cbb904305cd007ed08d6c73102b7..38308cd75c94e298412de4f87a3095d4c49b3032 100644 (file)
--- a/test/fixedbugs/issue14136.go
+++ b/test/fixedbugs/issue14136.go
@@ -14,6 +14,6 @@ package main
 type T struct{}
 
 func main() {
-       t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T"
-       var s string = 1 // ERROR "cannot use 1"
+       t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T|unknown field .*X.* in .*T.*"
+       var s string = 1 // ERROR "cannot use 1|incompatible type"
 }

diff --git a/test/fixedbugs/issue14520.go b/test/fixedbugs/issue14520.go
index 84d240faf0a14981e5182c139fed80f7e7a56fef..0b840ff4bee9ad173cfaf8f23f046630a27e1d56 100644 (file)
--- a/test/fixedbugs/issue14520.go
+++ b/test/fixedbugs/issue14520.go
@@ -9,6 +9,6 @@ package f
 import /* // ERROR "import path" */ `
 bogus`
 
-func f(x int /* // ERROR "unexpected newline"
+func f(x int /* // GC_ERROR "unexpected newline"
 
-*/)
+*/) // GCCGO_ERROR "expected .*\).*|expected declaration"

diff --git a/test/fixedbugs/issue14636.go b/test/fixedbugs/issue14636.go
index 6797046e02b66d478cd7da9374762a5663b0576f..06fd193dae0ba1d8c60085f7511b618887248646 100644 (file)
--- a/test/fixedbugs/issue14636.go
+++ b/test/fixedbugs/issue14636.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js,!android
+// +build !nacl,!js,!android,gc
 // run
 
 // Copyright 2016 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue14652.go b/test/fixedbugs/issue14652.go
index b030aee16fc1d9b679f26ae1621901e913b846d3..d53b412668314822423427c98711bb0731041b83 100644 (file)
--- a/test/fixedbugs/issue14652.go
+++ b/test/fixedbugs/issue14652.go
@@ -6,4 +6,4 @@
 
 package p
 
-var x any // ERROR "undefined: any"
+var x any // ERROR "undefined: any|undefined type .*any.*"

diff --git a/test/fixedbugs/issue14729.go b/test/fixedbugs/issue14729.go
index 88e01f9e16c32ae65254e469a2d8426b26d1b828..9b30fd271505b58c06bd56a58f001fe06ecc9c14 100644 (file)
--- a/test/fixedbugs/issue14729.go
+++ b/test/fixedbugs/issue14729.go
@@ -10,5 +10,5 @@ package main
 
 import "unsafe"
 
-type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
+type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer|embedded type may not be a pointer"
 type s1 struct { p unsafe.Pointer }

diff --git a/test/fixedbugs/issue15055.go b/test/fixedbugs/issue15055.go
index e58047e411caa50f2864992c7215af89b600f5f4..33cf63aaad8d1eb1a4543de5bf2ce148732c5cbe 100644 (file)
--- a/test/fixedbugs/issue15055.go
+++ b/test/fixedbugs/issue15055.go
@@ -8,10 +8,12 @@ package main
 
 func main() {
        type name string
-       _ = []byte("abc", "def", 12)    // ERROR "too many arguments to conversion to \[\]byte: \(\[\]byte\)\(.abc., .def., 12\)"
+       _ = []byte("abc", "def", 12)    // ERROR "too many arguments to conversion to \[\]byte: \[\]byte\(.abc., .def., 12\)"
        _ = string("a", "b", nil)       // ERROR "too many arguments to conversion to string: string\(.a., .b., nil\)"
-       _ = []byte()                    // ERROR "missing argument to conversion to \[\]byte: \(\[\]byte\)\(\)"
+       _ = []byte()                    // ERROR "missing argument to conversion to \[\]byte: \[\]byte\(\)"
        _ = string()                    // ERROR "missing argument to conversion to string: string\(\)"
+       _ = *int()                      // ERROR "missing argument to conversion to int: int\(\)"
+       _ = (*int)()                    // ERROR "missing argument to conversion to \*int: \(\*int\)\(\)"
        _ = name("a", 1, 3.3)           // ERROR "too many arguments to conversion to name: name\(.a., 1, 3.3\)"
-       _ = map[string]string(nil, nil) // ERROR "too many arguments to conversion to map\[string\]string: \(map\[string\]string\)\(nil, nil\)"
+       _ = map[string]string(nil, nil) // ERROR "too many arguments to conversion to map\[string\]string: map\[string\]string\(nil, nil\)"
 }

diff --git a/test/fixedbugs/issue15514.dir/c.go b/test/fixedbugs/issue15514.dir/c.go
index 11624f925696d144b6887d6158c060c120d16461..dc2ef5bed526db568bc7b151768c1f9f3f2ffbfe 100644 (file)
--- a/test/fixedbugs/issue15514.dir/c.go
+++ b/test/fixedbugs/issue15514.dir/c.go
@@ -7,4 +7,4 @@ package c
 import "./a"
 import "./b"
 
-var _ a.A = b.B() // ERROR "cannot use b\.B"
+var _ a.A = b.B() // ERROR "cannot use b\.B|incompatible type"

diff --git a/test/fixedbugs/issue15898.go b/test/fixedbugs/issue15898.go
index 7b66ea23dc69306b1b157706558293b3eeb3fbb2..94369f93450f29b46d36da42b8adf53f4fe557c6 100644 (file)
--- a/test/fixedbugs/issue15898.go
+++ b/test/fixedbugs/issue15898.go
@@ -8,11 +8,11 @@ package p
 
 func f(e interface{}) {
        switch e.(type) {
-       case nil, nil: // ERROR "multiple nil cases in type switch"
+       case nil, nil: // ERROR "multiple nil cases in type switch|duplicate type in switch"
        }
 
        switch e.(type) {
        case nil:
-       case nil: // ERROR "multiple nil cases in type switch"
+       case nil: // ERROR "multiple nil cases in type switch|duplicate type in switch"
        }
 }

diff --git a/test/fixedbugs/issue16037_run.go b/test/fixedbugs/issue16037_run.go
index d05e3f7f3143cf2ec005ecff2b8fac20c6e44d91..68104a9000795d835154d476a840c5dc95429220 100644 (file)
--- a/test/fixedbugs/issue16037_run.go
+++ b/test/fixedbugs/issue16037_run.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js,!android
+// +build !nacl,!js,!android,!gccgo
 // run
 
 // Copyright 2016 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue16439.go b/test/fixedbugs/issue16439.go
index f9382bafcd907e55c3e4fc2edd5f37eaa6952ae7..704b6b15a61aac9b2f984a034ef37bf21391bd29 100644 (file)
--- a/test/fixedbugs/issue16439.go
+++ b/test/fixedbugs/issue16439.go
@@ -7,12 +7,12 @@
 package p
 
 var a []int = []int{1: 1}
-var b []int = []int{-1: 1} // ERROR "must be non-negative integer constant"
+var b []int = []int{-1: 1} // ERROR "must be non-negative integer constant|index expression is negative"
 
 var c []int = []int{2.0: 2}
-var d []int = []int{-2.0: 2} // ERROR "must be non-negative integer constant"
+var d []int = []int{-2.0: 2} // ERROR "must be non-negative integer constant|index expression is negative"
 
 var e []int = []int{3 + 0i: 3}
-var f []int = []int{3i: 3} // ERROR "truncated to integer"
+var f []int = []int{3i: 3} // ERROR "truncated to integer|index expression is not integer constant"
 
-var g []int = []int{"a": 4} // ERROR "must be non-negative integer constant"
+var g []int = []int{"a": 4} // ERROR "must be non-negative integer constant|index expression is not integer constant"

diff --git a/test/fixedbugs/issue17328.go b/test/fixedbugs/issue17328.go
index abe4daa35339ad7bbf39dd05d4d12224175cd919..ef60edbd426dd61ae7c08671954690d77bb078f9 100644 (file)
--- a/test/fixedbugs/issue17328.go
+++ b/test/fixedbugs/issue17328.go
@@ -8,6 +8,6 @@ package main
 
 func main() {
        i := 0
-       for ; ; i++) { // ERROR "unexpected \), expecting { after for clause"
+       for ; ; i++) { // ERROR "unexpected \), expecting { after for clause|expected .*{.*|expected .*;.*"
        }
-}
+} // GCCGO_ERROR "expected declaration"

diff --git a/test/fixedbugs/issue17588.go b/test/fixedbugs/issue17588.go
index 1be57c62923003bb1d7d2cd70b48232627a371ad..0e3a14ef7c4faa6a398a6d4f598bd762e068a3d9 100644 (file)
--- a/test/fixedbugs/issue17588.go
+++ b/test/fixedbugs/issue17588.go
@@ -11,7 +11,7 @@
 
 package p
 
-type F func(b T)  // ERROR "T is not a type"
+type F func(b T)  // ERROR "T is not a type|expected type"
 
 func T(fn F) {
     func() {

diff --git a/test/fixedbugs/issue17631.go b/test/fixedbugs/issue17631.go
index 79b7e8a75135223fe873f74ecb9ae6cb6f63fe03..b820b2d5a7508c83f04c29dad86fa553e818e6fb 100644 (file)
--- a/test/fixedbugs/issue17631.go
+++ b/test/fixedbugs/issue17631.go
@@ -17,6 +17,6 @@ func main() {
                expect     map[string]int
        }{
                about:   "this one",
-               updates: map[string]int{"gopher": 10}, // ERROR "unknown field 'updates' in struct literal of type"
+               updates: map[string]int{"gopher": 10}, // ERROR "unknown field 'updates' in struct literal of type|unknown field .*updates.* in .*unnamed struct.*"
        }
 }

diff --git a/test/fixedbugs/issue17645.go b/test/fixedbugs/issue17645.go
index 95fcecd1e0507a2311caafbd492e66457b1e4067..bb34e4ee97a3bfd5db2cad3439ce3ef375c4a257 100644 (file)
--- a/test/fixedbugs/issue17645.go
+++ b/test/fixedbugs/issue17645.go
@@ -12,5 +12,5 @@ type Foo struct {
 
 func main() {
        var s []int
-       var _ string = append(s, Foo{""}) // ERROR "cannot use .. \(type untyped string\) as type int in field value" "cannot use Foo{...} \(type Foo\) as type int in append" "cannot use append\(s\, Foo{...}\) \(type \[\]int\) as type string in assignment"
+       var _ string = append(s, Foo{""}) // ERROR "cannot use .. \(type untyped string\) as type int in field value|incompatible type" "cannot use Foo{...} \(type Foo\) as type int in append" "cannot use append\(s\, Foo{...}\) \(type \[\]int\) as type string in assignment"
 }

diff --git a/test/fixedbugs/issue17758.go b/test/fixedbugs/issue17758.go
index e7f2f3af91506ff18aa2d49b0807d4abc020a4be..8e40f9db7339a910e41970a97697336bec5b97fe 100644 (file)
--- a/test/fixedbugs/issue17758.go
+++ b/test/fixedbugs/issue17758.go
@@ -10,7 +10,7 @@ func foo() {
        _ = func() {}
 }
 
-func foo() { // ERROR "foo redeclared in this block"
+func foo() { // ERROR "foo redeclared in this block|redefinition of .*foo.*"
        _ = func() {}
 }
 

diff --git a/test/fixedbugs/issue18092.go b/test/fixedbugs/issue18092.go
index 94fd2dd383753dcee8c06f948bc2059a227b4adb..a0f7eddda5a773b56e4af0c58bd29aa732f7c29c 100644 (file)
--- a/test/fixedbugs/issue18092.go
+++ b/test/fixedbugs/issue18092.go
@@ -10,6 +10,6 @@ func _() {
        var ch chan bool
        select {
        default:
-       case <-ch { // don't crash here
-       }           // ERROR "expecting :"
+       case <-ch { // GCCGO_ERROR "expected colon"
+       }           // GC_ERROR "expecting :"
 }

diff --git a/test/fixedbugs/issue18231.go b/test/fixedbugs/issue18231.go
index adfd2277ffe2ec25500e27365e8e83008d4278b9..774730405263eefa9f3182225e8ea038f44dcb10 100644 (file)
--- a/test/fixedbugs/issue18231.go
+++ b/test/fixedbugs/issue18231.go
@@ -14,7 +14,7 @@ type T struct {
 }
 
 var _ = T{
-       f: {                // ERROR "missing type in composite literal"
+       f: {                // ERROR "missing type in composite literal|may only omit types within"
                "a": "b",
        },
 }

diff --git a/test/fixedbugs/issue18393.go b/test/fixedbugs/issue18393.go
index c16ff4df97b9effb48a0f30a9502d07e7b672f5c..454392721f08ca69d39e52cb47a8c5667d94488c 100644 (file)
--- a/test/fixedbugs/issue18393.go
+++ b/test/fixedbugs/issue18393.go
@@ -21,4 +21,4 @@ var x     // error on line 24, not 30
 
 
 
-// ERROR "syntax error: unexpected newline, expecting type"
+// ERROR "syntax error: unexpected newline, expecting type|expected type"

diff --git a/test/fixedbugs/issue18419.dir/test.go b/test/fixedbugs/issue18419.dir/test.go
index 31c6025e3f55f467eed7a49a2c0cabfc9893c1ca..da9639dd72e30d930f4dcf5fad37ee036afd2b56 100644 (file)
--- a/test/fixedbugs/issue18419.dir/test.go
+++ b/test/fixedbugs/issue18419.dir/test.go
@@ -9,7 +9,7 @@ package main
 import "./other"
 
 func InMyCode(e *other.Exported) {
-       e.member() // ERROR "e\.member undefined .cannot refer to unexported field or method other\.\(\*Exported\)\.member."
+       e.member() // ERROR "e\.member undefined .cannot refer to unexported field or method other\.\(\*Exported\)\.member.|unexported field or method"
 }
 
 func main() {}

diff --git a/test/fixedbugs/issue18655.go b/test/fixedbugs/issue18655.go
index abc26002804d957f71977e27a516876024591fa2..13762f1a94b9e666d1fc66dade33d244d856f2c2 100644 (file)
--- a/test/fixedbugs/issue18655.go
+++ b/test/fixedbugs/issue18655.go
@@ -11,12 +11,12 @@ type A = T
 type B = T
 
 func (T) m() {}
-func (T) m() {} // ERROR "redeclared"
-func (A) m() {} // ERROR "redeclared"
-func (A) m() {} // ERROR "redeclared"
-func (B) m() {} // ERROR "redeclared"
-func (B) m() {} // ERROR "redeclared"
+func (T) m() {} // ERROR "redeclared|redefinition"
+func (A) m() {} // ERROR "redeclared|redefinition"
+func (A) m() {} // ERROR "redeclared|redefinition"
+func (B) m() {} // ERROR "redeclared|redefinition"
+func (B) m() {} // ERROR "redeclared|redefinition"
 
-func (*T) m() {} // ERROR "redeclared"
-func (*A) m() {} // ERROR "redeclared"
-func (*B) m() {} // ERROR "redeclared"
+func (*T) m() {} // ERROR "redeclared|redefinition"
+func (*A) m() {} // ERROR "redeclared|redefinition"
+func (*B) m() {} // ERROR "redeclared|redefinition"

diff --git a/test/fixedbugs/issue18915.go b/test/fixedbugs/issue18915.go
index 66e31e2556edfa299a8ed8816024af3ab953f811..22f97c6b62b8ec2dd393319478190ff61844da72 100644 (file)
--- a/test/fixedbugs/issue18915.go
+++ b/test/fixedbugs/issue18915.go
@@ -10,12 +10,12 @@
 package p
 
 func _() {
-       if a := 10 { // ERROR "cannot use a := 10 as value"
+       if a := 10 { // ERROR "cannot use a := 10 as value|expected .*;|declared but not used"
        }
 
-       for b := 10 { // ERROR "cannot use b := 10 as value"
+       for b := 10 { // ERROR "cannot use b := 10 as value|parse error|declared but not used"
        }
 
-       switch c := 10 { // ERROR "cannot use c := 10 as value"
+       switch c := 10 { // ERROR "cannot use c := 10 as value|expected .*;|declared but not used"
        }
 }

diff --git a/test/fixedbugs/issue19012.go b/test/fixedbugs/issue19012.go
index 636bf06e7548a28b5b69a915e229d1b1fe2e657b..158618aa27efcca31f0d4af81c55451cf84936a8 100644 (file)
--- a/test/fixedbugs/issue19012.go
+++ b/test/fixedbugs/issue19012.go
@@ -13,13 +13,13 @@ package main
 
 func f(x int, y uint) {
        if true {
-               return "a" > 10 // ERROR "^too many arguments to return$" "."
+               return "a" > 10 // ERROR "^too many arguments to return$|return with value in function with no return|mismatched types"
        }
-       return "gopher" == true, 10 // ERROR "^too many arguments to return$" "."
+       return "gopher" == true, 10 // ERROR "^too many arguments to return$|return with value in function with no return|mismatched types"
 }
 
 func main() {
-       f(2, 3 < "x", 10) // ERROR "^too many arguments in call to f$" "."
+       f(2, 3 < "x", 10) // ERROR "too many arguments|invalid operation|incompatible type"
 
-       f(10, 10, "a") // ERROR "too many arguments in call to f\n\thave \(number, number, string\)\n\twant \(int, uint\)"
+       f(10, 10, "a") // ERROR "too many arguments"
 }

diff --git a/test/fixedbugs/issue19028.dir/main.go b/test/fixedbugs/issue19028.dir/main.go
index 627e926f9370a9f79dd45d85d73d6410ed83e9d8..e2ee7b8ca1df2da8a26d4ae028b516e0f1b6dfdf 100644 (file)
--- a/test/fixedbugs/issue19028.dir/main.go
+++ b/test/fixedbugs/issue19028.dir/main.go
@@ -6,7 +6,7 @@ package main
 
 import (
         "reflect"
-        fake "./reflect" // 2nd package with name "reflect"
+        fake "./a" // 2nd package with name "reflect"
 )
 
 type T struct {

diff --git a/test/fixedbugs/issue19056.go b/test/fixedbugs/issue19056.go
index e4e8d07905a31a3eeb6077e9df6becd75d86c5a7..d279eaa3cf64bf0a77f740d4551320e31b694e3f 100644 (file)
--- a/test/fixedbugs/issue19056.go
+++ b/test/fixedbugs/issue19056.go
@@ -6,4 +6,4 @@
 
 package p
 
-var _ = ... . // ERROR "unexpected ..."
+var _ = ... . // ERROR "unexpected ...|expected operand|expected .*;"

diff --git a/test/fixedbugs/issue19323.go b/test/fixedbugs/issue19323.go
index f90af660d5e1d569919b51436b94db24bbf7e101..71365e10dd3d8089f8e6c5f536352bf4bc8cdd24 100644 (file)
--- a/test/fixedbugs/issue19323.go
+++ b/test/fixedbugs/issue19323.go
@@ -9,11 +9,11 @@ package p
 func g() {}
 
 func f() {
-       g()[:] // ERROR "g.. used as value"
+       g()[:] // ERROR "g.. used as value|attempt to slice object that is not"
 }
 
 func g2() ([]byte, []byte) { return nil, nil }
 
 func f2() {
-       g2()[:] // ERROR "multiple-value g2.. in single-value context"
+       g2()[:] // ERROR "multiple-value g2.. in single-value context|attempt to slice object that is not"
 }

diff --git a/test/fixedbugs/issue19482.go b/test/fixedbugs/issue19482.go
index 97497a434c384d5137a2aaf0c2ae0af704f5e133..4c2c19ec9d9d4ce63457c29b07b559c236305daf 100644 (file)
--- a/test/fixedbugs/issue19482.go
+++ b/test/fixedbugs/issue19482.go
@@ -22,13 +22,13 @@ func ok() {
 
 var (
        y = T{"stare"}
-       w = T{_: "look"} // ERROR "invalid field name _ in struct initializer"
+       w = T{_: "look"} // ERROR "invalid field name _ in struct initializer|expected struct field name"
        _ = T{"page"}
-       _ = T{_: "out"} // ERROR "invalid field name _ in struct initializer"
+       _ = T{_: "out"} // ERROR "invalid field name _ in struct initializer|expected struct field name"
 )
 
 func bad() {
-       var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer"
+       var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer|expected struct field name"
        _ = z
-       _ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer"
+       _ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer|expected struct field name"
 }

diff --git a/test/fixedbugs/issue19658.go b/test/fixedbugs/issue19658.go
index b2539629df0c45ad3a349db4068726b6c1e55b1b..bab409c6c03cc86d64ae51ef3bb51a09d77f2d6a 100644 (file)
--- a/test/fixedbugs/issue19658.go
+++ b/test/fixedbugs/issue19658.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,!gccgo
 // run
 
 // Copyright 2017 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue19667.go b/test/fixedbugs/issue19667.go
index c94a11d87129d6ccd738ec97d00b37639f4cc5a3..e33e35048752dfb4f4c3110e4fba31791e822d98 100644 (file)
--- a/test/fixedbugs/issue19667.go
+++ b/test/fixedbugs/issue19667.go
@@ -9,5 +9,5 @@
 package p
 
 func f() {
-       if err := http.ListenAndServe(
-} // ERROR "unexpected }, expecting expression"
+       if err := http.ListenAndServe( // GCCGO_ERROR "undefined name"
+} // ERROR "unexpected }, expecting expression|expected operand|missing .*\)|expected .*;|expected .*{"

diff --git a/test/fixedbugs/issue19880.go b/test/fixedbugs/issue19880.go
index 629c95d960f9defa2f9ea78a8bf1689df40dcb8f..3d83cf3a12c3dd287b1fc8e9c42309e108fd3c67 100644 (file)
--- a/test/fixedbugs/issue19880.go
+++ b/test/fixedbugs/issue19880.go
@@ -11,7 +11,7 @@ type T struct {
 }
 
 func a() {
-       _ = T // ERROR "type T is not an expression"
+       _ = T // ERROR "type T is not an expression|invalid use of type"
 }
 
 func b() {

diff --git a/test/fixedbugs/issue19977.go b/test/fixedbugs/issue19977.go
index 3db1dfd63603593348770061f604a158af5f2bf2..6e4a9cc422c7181698b0563f871c6b9783e5bceb 100644 (file)
--- a/test/fixedbugs/issue19977.go
+++ b/test/fixedbugs/issue19977.go
@@ -9,7 +9,7 @@
 package foo
 
 func Foo() {
-       switch x := a.(type) { // ERROR "undefined: a"
+       switch x := a.(type) { // ERROR "undefined: a|reference to undefined name .*a"
        default:
                _ = x
        }

diff --git a/test/fixedbugs/issue20185.go b/test/fixedbugs/issue20185.go
index 2cbb143ed00d58f306afb4697e3bcd65e385c113..9065868d7f2ba1c3690e860efc4bc754671f77a7 100644 (file)
--- a/test/fixedbugs/issue20185.go
+++ b/test/fixedbugs/issue20185.go
@@ -10,7 +10,7 @@
 package p
 
 func F() {
-       switch t := nil.(type) { // ERROR "cannot type switch on non-interface value nil"
+       switch t := nil.(type) { // ERROR "cannot type switch on non-interface value"
        default:
                _ = t
        }
@@ -19,7 +19,7 @@ func F() {
 const x = 1
 
 func G() {
-       switch t := x.(type) { // ERROR "cannot type switch on non-interface value x \(type untyped int\)"
+       switch t := x.(type) { // ERROR "cannot type switch on non-interface value|declared but not used"
        default:
        }
 }

diff --git a/test/fixedbugs/issue20227.go b/test/fixedbugs/issue20227.go
index 4448eb5438062a36885adae0b59db986e10c98b6..f59923106dd9521bc239ce81060908b9e710cd00 100644 (file)
--- a/test/fixedbugs/issue20227.go
+++ b/test/fixedbugs/issue20227.go
@@ -8,9 +8,9 @@
 
 package p
 
-var _ = 1 / 1e-600000000i  // ERROR "complex division by zero"
-var _ = 1i / 1e-600000000  // ERROR "complex division by zero"
-var _ = 1i / 1e-600000000i // ERROR "complex division by zero"
+var _ = 1 / 1e-600000000i  // ERROR "division by zero"
+var _ = 1i / 1e-600000000  // ERROR "division by zero"
+var _ = 1i / 1e-600000000i // ERROR "division by zero"
 
-var _ = 1 / (1e-600000000 + 1e-600000000i)  // ERROR "complex division by zero"
-var _ = 1i / (1e-600000000 + 1e-600000000i) // ERROR "complex division by zero"
+var _ = 1 / (1e-600000000 + 1e-600000000i)  // ERROR "division by zero"
+var _ = 1i / (1e-600000000 + 1e-600000000i) // ERROR "division by zero"

diff --git a/test/fixedbugs/issue20232.go b/test/fixedbugs/issue20232.go
index f91c74936b13f2714415eedcf260dcaa9a37fa65..7a0300a4c42d10f29c0a2ce1e4c2e4283efb499c 100644 (file)
--- a/test/fixedbugs/issue20232.go
+++ b/test/fixedbugs/issue20232.go
@@ -6,6 +6,7 @@
 
 package main
 
-const _ = 6e5518446744 // ERROR "malformed constant: 6e5518446744 \(exponent overflow\)"
+const x = 6e5518446744 // ERROR "malformed constant: 6e5518446744"
+const _ = x * x
 const _ = 1e-1000000000
-const _ = 1e+1000000000 // ERROR "constant too large"
+const _ = 1e+1000000000 // ERROR "malformed constant: 1e\+1000000000"

diff --git a/test/fixedbugs/issue20250.go b/test/fixedbugs/issue20250.go
index c190515274af21ca0cc186a0d24f810a63e3b488..1a513bea56df1f916dfe77d99b0f8f72733a6d28 100644 (file)
--- a/test/fixedbugs/issue20250.go
+++ b/test/fixedbugs/issue20250.go
@@ -1,4 +1,4 @@
-// errorcheck -0 -live -l -d=compilelater
+// errorcheck -0 -live -l
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

diff --git a/test/fixedbugs/issue20415.go b/test/fixedbugs/issue20415.go
index 6f2c342ce41506f3cad6bd8a044eaf252fc2139e..1d9a745ab47feda357827b77eb8b41494b41fcf1 100644 (file)
--- a/test/fixedbugs/issue20415.go
+++ b/test/fixedbugs/issue20415.go
@@ -11,7 +11,7 @@ package p
 // 1
 var f byte
 
-var f interface{} // ERROR "previous declaration at issue20415.go:12"
+var f interface{} // ERROR "issue20415.go:12: previous declaration|redefinition"
 
 func _(f int) {
 }
@@ -22,7 +22,7 @@ var g byte
 func _(g int) {
 }
 
-var g interface{} // ERROR "previous declaration at issue20415.go:20"
+var g interface{} // ERROR "issue20415.go:20: previous declaration|redefinition"
 
 // 3
 func _(h int) {
@@ -30,4 +30,4 @@ func _(h int) {
 
 var h byte
 
-var h interface{} // ERROR "previous declaration at issue20415.go:31"
+var h interface{} // ERROR "issue20415.go:31: previous declaration|redefinition"

diff --git a/test/fixedbugs/issue20529.go b/test/fixedbugs/issue20529.go
index 669064c2eaf38171a5df80a03c6376453680760c..eeaaf37358f8a55d02b44e6503112b774c7f6be4 100644 (file)
--- a/test/fixedbugs/issue20529.go
+++ b/test/fixedbugs/issue20529.go
@@ -15,7 +15,7 @@ package p
 
 import "runtime"
 
-func f() { // ERROR "stack frame too large"
+func f() { // GC_ERROR "stack frame too large"
        x := [][]int{1e9: []int{}}
        runtime.KeepAlive(x)
 }

diff --git a/test/fixedbugs/issue20602.go b/test/fixedbugs/issue20602.go
index ca4ce095aa20f7866ddb3a14b53c8a8db433ebf5..d4d513b0509163bb954accfe4382f80edf961e0e 100644 (file)
--- a/test/fixedbugs/issue20602.go
+++ b/test/fixedbugs/issue20602.go
@@ -10,5 +10,5 @@
 package p
 
 var p = &[1]complex128{0}
-var _ = real(p)  // ERROR "type \*\[1\]complex128"
-var _ = imag(p)         // ERROR "type \*\[1\]complex128"
+var _ = real(p)  // ERROR "type \*\[1\]complex128|argument must have complex type"
+var _ = imag(p)         // ERROR "type \*\[1\]complex128|argument must have complex type"

diff --git a/test/fixedbugs/issue20749.go b/test/fixedbugs/issue20749.go
index af9ff3fbedbc39b9c3474994a84fd8a0fd24ee3b..de2d3ad16a854980338b7c63330123fcfc64b752 100644 (file)
--- a/test/fixedbugs/issue20749.go
+++ b/test/fixedbugs/issue20749.go
@@ -9,7 +9,7 @@ package p
 // Verify that the compiler complains even if the array
 // has length 0.
 var a [0]int
-var _ = a[2:] // ERROR "invalid slice index 2"
+var _ = a[2:] // ERROR "invalid slice index 2|array index out of bounds"
 
 var b [1]int
-var _ = b[2:] // ERROR "invalid slice index 2"
+var _ = b[2:] // ERROR "invalid slice index 2|array index out of bounds"

diff --git a/test/fixedbugs/issue20780.go b/test/fixedbugs/issue20780.go
index 58952e53eea67b7f705311c45171a846a04c8d7a..f73e6d1f794bb39210965cdcaa22051c88faef96 100644 (file)
--- a/test/fixedbugs/issue20780.go
+++ b/test/fixedbugs/issue20780.go
@@ -9,11 +9,17 @@
 
 package main
 
-func f() { // ERROR "stack frame too large"
-       var x [800e6]byte
-       g(x)
-       return
+type Big = [400e6]byte
+
+func f() { // GC_ERROR "stack frame too large"
+       // Note: This test relies on the fact that we currently always
+       // spill function-results to the stack, even if they're so
+       // large that we would normally heap allocate them. If we ever
+       // improve the backend to spill temporaries to the heap, this
+       // test will probably need updating to find some new way to
+       // construct an overly large stack frame.
+       g(h(), h())
 }
 
-//go:noinline
-func g([800e6]byte) {}
+func g(Big, Big)
+func h() Big

diff --git a/test/fixedbugs/issue20780b.go b/test/fixedbugs/issue20780b.go
new file mode 100644 (file)
index 0000000..c8bf1f8
--- /dev/null
+++ b/test/fixedbugs/issue20780b.go
@@ -0,0 +1,62 @@
+// +build cgo,linux,amd64
+// run -race
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that CL 281293 doesn't interfere with race detector
+// instrumentation.
+
+package main
+
+import "fmt"
+
+const N = 2e6
+
+type Big = [N]int
+
+var sink interface{}
+
+func main() {
+       g(0, f(0))
+
+       x1 := f(1)
+       sink = &x1
+       g(1, x1)
+       g(7, f(7))
+       g(1, x1)
+
+       x3 := f(3)
+       sink = &x3
+       g(1, x1)
+       g(3, x3)
+
+       h(f(0), x1, f(2), x3, f(4))
+}
+
+//go:noinline
+func f(k int) (x Big) {
+       for i := range x {
+               x[i] = k*N + i
+       }
+       return
+}
+
+//go:noinline
+func g(k int, x Big) {
+       for i := range x {
+               if x[i] != k*N+i {
+                       panic(fmt.Sprintf("x%d[%d] = %d", k, i, x[i]))
+               }
+       }
+}
+
+//go:noinline
+func h(x0, x1, x2, x3, x4 Big) {
+       g(0, x0)
+       g(1, x1)
+       g(2, x2)
+       g(3, x3)
+       g(4, x4)
+}

diff --git a/test/fixedbugs/issue20812.go b/test/fixedbugs/issue20812.go
index 0175eede17d1a78ac161ef4d2e02bcdd198758a1..d0df831dfddd53c479dbfd80c4d13d8aacf46625 100644 (file)
--- a/test/fixedbugs/issue20812.go
+++ b/test/fixedbugs/issue20812.go
@@ -7,9 +7,9 @@
 package p
 
 func f() {
-       _ = int("1")      // ERROR "cannot convert"
-       _ = bool(0)       // ERROR "cannot convert"
-       _ = bool("false") // ERROR "cannot convert"
-       _ = int(false)    // ERROR "cannot convert"
-       _ = string(true)  // ERROR "cannot convert"
+       _ = int("1")      // ERROR "cannot convert|invalid type conversion"
+       _ = bool(0)       // ERROR "cannot convert|invalid type conversion"
+       _ = bool("false") // ERROR "cannot convert|invalid type conversion"
+       _ = int(false)    // ERROR "cannot convert|invalid type conversion"
+       _ = string(true)  // ERROR "cannot convert|invalid type conversion"
 }

diff --git a/test/fixedbugs/issue20813.go b/test/fixedbugs/issue20813.go
index b931aea5923498ec87f12b531dc9659569d1fab9..b147a8903ce9776a31b24fda9aa5f5f201de3931 100644 (file)
--- a/test/fixedbugs/issue20813.go
+++ b/test/fixedbugs/issue20813.go
@@ -7,5 +7,5 @@
 package p
 
 func f() {
-       1 = 2 // ERROR "cannot assign to 1"
+       1 = 2 // ERROR "cannot assign to 1|invalid left hand side"
 }

diff --git a/test/fixedbugs/issue21256.go b/test/fixedbugs/issue21256.go
index 3d3612478dfa50bc1bbf7c784b35ae7777e93fe7..c845ec52b3876fc5a9a470c9ddecf8d71b0a2a04 100644 (file)
--- a/test/fixedbugs/issue21256.go
+++ b/test/fixedbugs/issue21256.go
@@ -6,4 +6,4 @@
 
 package main
 
-var main = func() {} // ERROR "must be func"
+var main = func() {} // ERROR "must be func|redefinition"

diff --git a/test/fixedbugs/issue21273.go b/test/fixedbugs/issue21273.go
index 7a790d14b5dee25adedcb7beb2cdd9b4f7837c12..77a1abad9bb3b7ad5306a8b84fc2f5f5e05f8ad2 100644 (file)
--- a/test/fixedbugs/issue21273.go
+++ b/test/fixedbugs/issue21273.go
@@ -24,5 +24,5 @@ func g() {
 
 func h() {
        type T4 struct{ m map[T4]int } // ERROR "invalid map key"
-       type _ map[T4]int              // ERROR "invalid map key"
+       type _ map[T4]int              // GC_ERROR "invalid map key"
 }

diff --git a/test/fixedbugs/issue21317.go b/test/fixedbugs/issue21317.go
index f4ec422371349079eda33dbd999fc9b493bdd7ce..32b660c1639169262c16826024369d3e04d0a088 100644 (file)
--- a/test/fixedbugs/issue21317.go
+++ b/test/fixedbugs/issue21317.go
@@ -1,3 +1,4 @@
+// +build !js,gc
 // run
 
 // Copyright 2017 The Go Authors. All rights reserved.
@@ -16,15 +17,10 @@ import (
        "log"
        "os"
        "os/exec"
-       "runtime"
        "strings"
 )
 
 func main() {
-       if runtime.Compiler != "gc" || runtime.GOOS == "js" {
-               return
-       }
-
        f, err := ioutil.TempFile("", "issue21317.go")
        if err != nil {
                log.Fatal(err)

diff --git a/test/fixedbugs/issue21576.go b/test/fixedbugs/issue21576.go
index ae6161ccf52d3926a8030607f231e3b7511900fb..3f9b1ba008af4cfee4cd502d844925101ec04764 100644 (file)
--- a/test/fixedbugs/issue21576.go
+++ b/test/fixedbugs/issue21576.go
@@ -1,6 +1,6 @@
 // run
 
-// +build !nacl,!js
+// +build !nacl,!js,!gccgo
 
 // Copyright 2019 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

diff --git a/test/fixedbugs/issue21979.go b/test/fixedbugs/issue21979.go
index 1c02f574c30e5453b76df753ee4bd4a9a8b9b053..addf786c037a062caacaf378d7d505fb4a5460d3 100644 (file)
--- a/test/fixedbugs/issue21979.go
+++ b/test/fixedbugs/issue21979.go
@@ -7,39 +7,39 @@
 package p
 
 func f() {
-       _ = bool("")      // ERROR "cannot convert .. \(type untyped string\) to type bool"
-       _ = bool(1)       // ERROR "cannot convert 1 \(type untyped int\) to type bool"
-       _ = bool(1.0)     // ERROR "cannot convert 1 \(type untyped float\) to type bool"
-       _ = bool(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(type untyped complex\) to type bool"
+       _ = bool("")      // ERROR "cannot convert .. \(type untyped string\) to type bool|invalid type conversion"
+       _ = bool(1)       // ERROR "cannot convert 1 \(type untyped int\) to type bool|invalid type conversion"
+       _ = bool(1.0)     // ERROR "cannot convert 1 \(type untyped float\) to type bool|invalid type conversion"
+       _ = bool(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(type untyped complex\) to type bool|invalid type conversion"
 
-       _ = string(true) // ERROR "cannot convert true \(type untyped bool\) to type string"
+       _ = string(true) // ERROR "cannot convert true \(type untyped bool\) to type string|invalid type conversion"
        _ = string(-1)
-       _ = string(1.0)     // ERROR "cannot convert 1 \(type untyped float\) to type string"
-       _ = string(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(type untyped complex\) to type string"
+       _ = string(1.0)     // ERROR "cannot convert 1 \(type untyped float\) to type string|invalid type conversion"
+       _ = string(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(type untyped complex\) to type string|invalid type conversion"
 
-       _ = int("")   // ERROR "cannot convert .. \(type untyped string\) to type int"
-       _ = int(true) // ERROR "cannot convert true \(type untyped bool\) to type int"
+       _ = int("")   // ERROR "cannot convert .. \(type untyped string\) to type int|invalid type conversion"
+       _ = int(true) // ERROR "cannot convert true \(type untyped bool\) to type int|invalid type conversion"
        _ = int(-1)
        _ = int(1)
        _ = int(1.0)
        _ = int(-4 + 2i) // ERROR "truncated to integer"
 
-       _ = uint("")   // ERROR "cannot convert .. \(type untyped string\) to type uint"
-       _ = uint(true) // ERROR "cannot convert true \(type untyped bool\) to type uint"
-       _ = uint(-1)   // ERROR "constant -1 overflows uint"
+       _ = uint("")   // ERROR "cannot convert .. \(type untyped string\) to type uint|invalid type conversion"
+       _ = uint(true) // ERROR "cannot convert true \(type untyped bool\) to type uint|invalid type conversion"
+       _ = uint(-1)   // ERROR "constant -1 overflows uint|integer constant overflow"
        _ = uint(1)
        _ = uint(1.0)
        _ = uint(-4 + 2i) // ERROR "constant -4 overflows uint" "truncated to integer"
 
-       _ = float64("")   // ERROR "cannot convert .. \(type untyped string\) to type float64"
-       _ = float64(true) // ERROR "cannot convert true \(type untyped bool\) to type float64"
+       _ = float64("")   // ERROR "cannot convert .. \(type untyped string\) to type float64|invalid type conversion"
+       _ = float64(true) // ERROR "cannot convert true \(type untyped bool\) to type float64|invalid type conversion"
        _ = float64(-1)
        _ = float64(1)
        _ = float64(1.0)
-       _ = float64(-4 + 2i) // ERROR "truncated to real"
+       _ = float64(-4 + 2i) // ERROR "truncated to"
 
-       _ = complex128("")   // ERROR "cannot convert .. \(type untyped string\) to type complex128"
-       _ = complex128(true) // ERROR "cannot convert true \(type untyped bool\) to type complex128"
+       _ = complex128("")   // ERROR "cannot convert .. \(type untyped string\) to type complex128|invalid type conversion"
+       _ = complex128(true) // ERROR "cannot convert true \(type untyped bool\) to type complex128|invalid type conversion"
        _ = complex128(-1)
        _ = complex128(1)
        _ = complex128(1.0)

diff --git a/test/fixedbugs/issue21988.go b/test/fixedbugs/issue21988.go
index 850e0398d6ab224929d3b97bc2c806224c1502e3..4dbf06ee315bf57dfefbf029810ce07283e88c67 100644 (file)
--- a/test/fixedbugs/issue21988.go
+++ b/test/fixedbugs/issue21988.go
@@ -8,7 +8,7 @@
 
 package p
 
-const X = Wrong(0) // ERROR "undefined: Wrong"
+const X = Wrong(0) // ERROR "undefined: Wrong|undefined name .*Wrong"
 
 func _() {
        switch 0 {

diff --git a/test/fixedbugs/issue22063.go b/test/fixedbugs/issue22063.go
index bfdb2e0027bf9e3a33e709c48f9070c4db987b73..8d84047e078e24c337f9570a52c6600ed8dd8509 100644 (file)
--- a/test/fixedbugs/issue22063.go
+++ b/test/fixedbugs/issue22063.go
@@ -8,7 +8,7 @@
 
 package p
 
-const X = Wrong(0) // ERROR "undefined: Wrong"
+const X = Wrong(0) // ERROR "undefined: Wrong|reference to undefined name .*Wrong"
 
 func _() {
        switch interface{}(nil) {

diff --git a/test/fixedbugs/issue22200.go b/test/fixedbugs/issue22200.go
index 66b9538e03ae2d74446795c8ba86c1b4faef7e1f..37440d9bf0ec4e27f1373a8f383c1f6033cbed4f 100644 (file)
--- a/test/fixedbugs/issue22200.go
+++ b/test/fixedbugs/issue22200.go
@@ -12,7 +12,7 @@ func f1(x *[1<<30 - 1e6]byte) byte {
        }
        return 0
 }
-func f2(x *[1<<30 + 1e6]byte) byte { // ERROR "stack frame too large"
+func f2(x *[1<<30 + 1e6]byte) byte { // GC_ERROR "stack frame too large"
        for _, b := range *x {
                return b
        }

diff --git a/test/fixedbugs/issue22200b.go b/test/fixedbugs/issue22200b.go
index 8d4515eb05b312152a410ca88aa243be2ffceb48..ce20923334c03230c05ee428fda2a0fb24a0ccaf 100644 (file)
--- a/test/fixedbugs/issue22200b.go
+++ b/test/fixedbugs/issue22200b.go
@@ -8,19 +8,19 @@
 
 package p
 
-func f3(x *[1 << 31]byte) byte { // ERROR "stack frame too large"
+func f3(x *[1 << 31]byte) byte { // GC_ERROR "stack frame too large"
        for _, b := range *x {
                return b
        }
        return 0
 }
-func f4(x *[1 << 32]byte) byte { // ERROR "stack frame too large"
+func f4(x *[1 << 32]byte) byte { // GC_ERROR "stack frame too large"
        for _, b := range *x {
                return b
        }
        return 0
 }
-func f5(x *[1 << 33]byte) byte { // ERROR "stack frame too large"
+func f5(x *[1 << 33]byte) byte { // GC_ERROR "stack frame too large"
        for _, b := range *x {
                return b
        }

diff --git a/test/fixedbugs/issue22660.go b/test/fixedbugs/issue22660.go
index 44ba42ac968cca00dc93b8476e8954ae063399c1..9ce9c4d732e6d4b6cffb4f85e53ed3a005cdcea3 100644 (file)
--- a/test/fixedbugs/issue22660.go
+++ b/test/fixedbugs/issue22660.go
@@ -1,3 +1,4 @@
+// +build !js,gc
 // run
 
 // Copyright 2017 The Go Authors. All rights reserved.
@@ -14,15 +15,10 @@ import (
        "os"
        "os/exec"
        "path/filepath"
-       "runtime"
        "strings"
 )
 
 func main() {
-       if runtime.GOOS == "js" {
-               return // no file system available on builders
-       }
-
        f, err := ioutil.TempFile("", "issue22660.go")
        if err != nil {
                log.Fatal(err)

diff --git a/test/fixedbugs/issue22662b.go b/test/fixedbugs/issue22662b.go
index 0fcfe8d0db6d9440a4f1582e904d40bb2b88638e..8da17679be08e9f58047df4cdd8de94a46542738 100644 (file)
--- a/test/fixedbugs/issue22662b.go
+++ b/test/fixedbugs/issue22662b.go
@@ -1,3 +1,4 @@
+// +build !js,gc
 // run
 
 // Copyright 2018 The Go Authors. All rights reserved.
@@ -13,7 +14,6 @@ import (
        "log"
        "os"
        "os/exec"
-       "runtime"
        "strings"
 )
 
@@ -36,10 +36,6 @@ var tests = []struct {
 }
 
 func main() {
-       if runtime.GOOS == "js" {
-               return // can not exec go tool
-       }
-
        f, err := ioutil.TempFile("", "issue22662b.go")
        if err != nil {
                log.Fatal(err)

diff --git a/test/fixedbugs/issue22794.go b/test/fixedbugs/issue22794.go
index c7e9eb1224ff213ffd011d235c21ccc2f12b84e0..2ac31ef0c75782f7e6532ba63e2cd9310948185b 100644 (file)
--- a/test/fixedbugs/issue22794.go
+++ b/test/fixedbugs/issue22794.go
@@ -13,8 +13,8 @@ type it struct {
 
 func main() {
        i1 := it{Floats: true}
-       if i1.floats { // ERROR "(type it .* field or method floats, but does have Floats)"
+       if i1.floats { // ERROR "(type it .* field or method floats, but does have Floats)|undefined field or method"
        }
-       i2 := &it{floats: false} // ERROR "(but does have Floats)"
-       _ = &it{InneR: "foo"}    // ERROR "(but does have inner)"
+       i2 := &it{floats: false} // ERROR "(but does have Floats)|unknown field|declared but not used"
+       _ = &it{InneR: "foo"}    // ERROR "(but does have inner)|unknown field"
 }

diff --git a/test/fixedbugs/issue22822.go b/test/fixedbugs/issue22822.go
index e449ddb186e2402766a75df4849d7f5736dde3ac..dc86c97fe570655287ac2e0a2b49f76405e76970 100644 (file)
--- a/test/fixedbugs/issue22822.go
+++ b/test/fixedbugs/issue22822.go
@@ -12,5 +12,7 @@ package main
 func F() {
        slice := []int{1, 2, 3}
        len := int(2)
-       println(len(slice)) // ERROR "cannot call non-function len .type int., declared at"
+       println(len(slice)) // ERROR "cannot call non-function len .type int., declared at LINE-1|expected function"
+       const iota = 1
+       println(iota(slice)) // ERROR "cannot call non-function iota .type int., declared at LINE-1|expected function"
 }

diff --git a/test/fixedbugs/issue22904.go b/test/fixedbugs/issue22904.go
index 09f4a2118eb50b7568c5c39277e10919974d5625..02459c6a4e80201541dec58f37028a63d2f00947 100644 (file)
--- a/test/fixedbugs/issue22904.go
+++ b/test/fixedbugs/issue22904.go
@@ -10,7 +10,7 @@
 package p
 
 type a struct{ b } // ERROR "invalid recursive type"
-type b struct{ a }
+type b struct{ a } // GCCGO_ERROR "invalid recursive type"
 
 var x interface{}
 

diff --git a/test/fixedbugs/issue22921.go b/test/fixedbugs/issue22921.go
index 04f78b2c084d400cf3601d8e1e41d9658670fce1..5336ba34109f9945db72870fe14642eb2ce57d7f 100644 (file)
--- a/test/fixedbugs/issue22921.go
+++ b/test/fixedbugs/issue22921.go
@@ -8,11 +8,11 @@ package main
 
 import "bytes"
 
-type _ struct{ bytes.nonexist } // ERROR "unexported"
+type _ struct{ bytes.nonexist } // ERROR "unexported|undefined"
 
-type _ interface{ bytes.nonexist } // ERROR "unexported"
+type _ interface{ bytes.nonexist } // ERROR "unexported|undefined|expected signature or type name"
 
 func main() {
        var _ bytes.Buffer
-       var _ bytes.buffer // ERROR "unexported"
+       var _ bytes.buffer // ERROR "unexported|undefined"
 }

diff --git a/test/fixedbugs/issue23017.go b/test/fixedbugs/issue23017.go
new file mode 100644 (file)
index 0000000..770c48e
--- /dev/null
+++ b/test/fixedbugs/issue23017.go
@@ -0,0 +1,113 @@
+// run
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// assignment order in multiple assignments.
+// See issue #23017
+
+package main
+
+import "fmt"
+
+func main() {}
+
+func init() {
+       var m = map[int]int{}
+       var p *int
+
+       defer func() {
+               recover()
+               check(1, len(m))
+               check(42, m[2])
+       }()
+       m[2], *p = 42, 2
+}
+
+func init() {
+       var m = map[int]int{}
+       p := []int{}
+
+       defer func() {
+               recover()
+               check(1, len(m))
+               check(2, m[2])
+       }()
+       m[2], p[1] = 2, 2
+}
+
+func init() {
+       type P struct{ i int }
+       var m = map[int]int{}
+       var p *P
+
+       defer func() {
+               recover()
+               check(1, len(m))
+               check(3, m[2])
+       }()
+       m[2], p.i = 3, 2
+}
+
+func init() {
+       type T struct{ i int }
+       var x T
+       p := &x
+       p, p.i = new(T), 4
+       check(4, x.i)
+}
+
+func init() {
+       var m map[int]int
+       var a int
+       var p = &a
+
+       defer func() {
+               recover()
+               check(5, *p)
+       }()
+       *p, m[2] = 5, 2
+}
+
+var g int
+
+func init() {
+       var m map[int]int
+       defer func() {
+               recover()
+               check(0, g)
+       }()
+       m[0], g = 1, 2
+}
+
+func init() {
+       type T struct{ x struct{ y int } }
+       var x T
+       p := &x
+       p, p.x.y = new(T), 7
+       check(7, x.x.y)
+       check(0, p.x.y)
+}
+
+func init() {
+       type T *struct{ x struct{ y int } }
+       x := struct{ y int }{0}
+       var q T = &struct{ x struct{ y int } }{x}
+       p := q
+       p, p.x.y = nil, 7
+       check(7, q.x.y)
+}
+
+func init() {
+       x, y := 1, 2
+       x, y = y, x
+       check(2, x)
+       check(1, y)
+}
+
+func check(want, got int) {
+       if want != got {
+               panic(fmt.Sprintf("wanted %d, but got %d", want, got))
+       }
+}

diff --git a/test/fixedbugs/issue23093.go b/test/fixedbugs/issue23093.go
index 2fd7d5fff1238d79b5c531890c95a36a53890c9d..7b2865ca41de6b7394b6dd0da7124b6a671a7b20 100644 (file)
--- a/test/fixedbugs/issue23093.go
+++ b/test/fixedbugs/issue23093.go
@@ -6,4 +6,4 @@
 
 package p
 
-var f = func() { f() } // ERROR "initialization loop"
+var f = func() { f() } // ERROR "initialization loop|initialization expression for .*f.* depends upon itself"

diff --git a/test/fixedbugs/issue23732.go b/test/fixedbugs/issue23732.go
index 5e63eb2074946f35ebf73f185a60dc3199ff7d14..db2d182234100e0ef4f485f00289179eda919944 100644 (file)
--- a/test/fixedbugs/issue23732.go
+++ b/test/fixedbugs/issue23732.go
@@ -21,22 +21,22 @@ type Bar struct {
 }
 
 func main() {
-       _ = Foo{
+       _ = Foo{ // GCCGO_ERROR "too few expressions"
                1,
                2,
-               3, // ERROR "too few values in Foo{...}"
+               3, // GC_ERROR "too few values in Foo{...}"
        }
 
        _ = Foo{
                1,
                2,
                3,
-               Bar{"A", "B"}, // ERROR "too many values in Bar{...}"
+               Bar{"A", "B"}, // ERROR "too many values in Bar{...}|too many expressions"
        }
 
-       _ = Foo{
+       _ = Foo{ // GCCGO_ERROR "too few expressions"
                1,
                2,
-               Bar{"A", "B"}, // ERROR "too many values in Bar{...}" "too few values in Foo{...}"
+               Bar{"A", "B"}, // ERROR "too many values in Bar{...}|too many expressions" "too few values in Foo{...}"
        }
 }

diff --git a/test/fixedbugs/issue23823.go b/test/fixedbugs/issue23823.go
index fe6cef1fb4d26a5f55644cf500121ec670d8e96f..067a8f1638c26c4ae33fe5c116d2c0c0c14d8fdf 100644 (file)
--- a/test/fixedbugs/issue23823.go
+++ b/test/fixedbugs/issue23823.go
@@ -11,6 +11,6 @@ type I1 = interface {
 }
 
 // BAD: type loop should mention I1; see also #41669
-type I2 interface { // ERROR "invalid recursive type I2\n\tLINE: I2 refers to\n\tLINE: I2$"
-       I1
+type I2 interface { // GC_ERROR "invalid recursive type I2\n\tLINE: I2 refers to\n\tLINE: I2$"
+       I1 // GCCGO_ERROR "invalid recursive interface"
 }

diff --git a/test/fixedbugs/issue24339.go b/test/fixedbugs/issue24339.go
index 502c575ec84096909c78143fd1bd5b42b860ec88..2cca7f8bda053e15c1be57da72785e101cce5b51 100644 (file)
--- a/test/fixedbugs/issue24339.go
+++ b/test/fixedbugs/issue24339.go
@@ -17,4 +17,4 @@ var _ = struct{}{ /*line :20:1*/foo /*line :21:1*/: /*line :22:1*/0 }
 
 
 
-// ERROR "unknown field 'foo'"
\ No newline at end of file
+// ERROR "unknown field 'foo'"

diff --git a/test/fixedbugs/issue25507.go b/test/fixedbugs/issue25507.go
index 8dcbae16ab9ee98aceca4295eefa31a90a11f0e1..9143a73397d91466416e566623a8285299fc5c0c 100644 (file)
--- a/test/fixedbugs/issue25507.go
+++ b/test/fixedbugs/issue25507.go
@@ -16,14 +16,14 @@ type large struct {
        b [1500000000]byte
 }
 
-func (x large) f1() int { // ERROR "stack frame too large"
+func (x large) f1() int { // GC_ERROR "stack frame too large"
        return 5
 }
 
-func f2(x large) int { // ERROR "stack frame too large"
+func f2(x large) int { // GC_ERROR "stack frame too large"
        return 5
 }
 
-func f3() (x large, i int) { // ERROR "stack frame too large"
+func f3() (x large, i int) { // GC_ERROR "stack frame too large"
        return
 }

diff --git a/test/fixedbugs/issue25727.go b/test/fixedbugs/issue25727.go
index da7c94cc12a921c754dad343b51138186c9d79ec..936b9f8ff5cd65e99ff2ea5e2f16f228ed226c93 100644 (file)
--- a/test/fixedbugs/issue25727.go
+++ b/test/fixedbugs/issue25727.go
@@ -9,13 +9,13 @@ package main
 import "net/http"
 
 var s = http.Server{}
-var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
-var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
-var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$"
-var _ = http.Server{DoneChan: nil}  // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
+var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$|unexported field or method"
+var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$|undefined field or method"
+var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$|unknown field .?tlsConfig.? in .?http.Server"
+var _ = http.Server{DoneChan: nil}  // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$|unknown field .?DoneChan.? in .?http.Server"
 
 type foo struct {
        bar int
 }
 
-var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$"
+var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$|unknown field .?bAr.? in .?foo"

diff --git a/test/fixedbugs/issue25958.go b/test/fixedbugs/issue25958.go
index ba7ee82230fcadf40f1e88b16ae1d8ad3c7c2af9..90fcee15fd0b900a1f6448df11a048793f4f7667 100644 (file)
--- a/test/fixedbugs/issue25958.go
+++ b/test/fixedbugs/issue25958.go
@@ -11,7 +11,7 @@ package p
 
 func f(done chan struct{}) {
        select {
-       case done: // ERROR "must be receive", "not used"
-       case (chan struct{})(done): // ERROR "must be receive"
+       case done: // ERROR "must be receive|expected .*<-.* or .*=" "not used"
+       case (chan struct{})(done): // ERROR "must be receive|expected .*<-.* or .*="
        }
 }

diff --git a/test/fixedbugs/issue26416.go b/test/fixedbugs/issue26416.go
index bc37fd9d3a8e9dd3cae015a93d193ce65cb19841..44a4fc73b777f152f4b1371e456b0527af8efe70 100644 (file)
--- a/test/fixedbugs/issue26416.go
+++ b/test/fixedbugs/issue26416.go
@@ -21,7 +21,7 @@ type t3 struct {
 }
 
 var (
-       _ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2"
-       _ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3"
-       _ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3"
+       _ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2|unknown field"
+       _ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3|unknown field"
+       _ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3|unknown field"
 )

diff --git a/test/fixedbugs/issue26616.go b/test/fixedbugs/issue26616.go
index e5565b68ca55aa9160d9625188f62dc038f6b21e..87c0293661f8ad8dadf1aa3f15ad8b2007d6c674 100644 (file)
--- a/test/fixedbugs/issue26616.go
+++ b/test/fixedbugs/issue26616.go
@@ -6,13 +6,13 @@
 
 package p
 
-var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
 
 func f() {
-       var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-       var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-       a = three()         // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-       b := three()        // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+       var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+       var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+       a = three()         // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+       b := three()        // ERROR "assignment mismatch: 1 variable but three returns 3 values|single variable set to multiple-value|multiple-value function call in single-value context"
 
        _, _ = a, b
 }

diff --git a/test/fixedbugs/issue26855.go b/test/fixedbugs/issue26855.go
index 144e4415f7fae6db07a3381beb0d491ce8919d83..b965635a65ce3ad9c585fe54aa9d02ba185f8aaa 100644 (file)
--- a/test/fixedbugs/issue26855.go
+++ b/test/fixedbugs/issue26855.go
@@ -20,9 +20,9 @@ type P struct {
 type T struct{}
 
 var _ = S{
-       f: &T{}, // ERROR "cannot use &T{}"
+       f: &T{}, // ERROR "cannot use &T{}|incompatible type"
 }
 
 var _ = P{
-       f: T{}, // ERROR "cannot use T{}"
+       f: T{}, // ERROR "cannot use T{}|incompatible type"
 }

diff --git a/test/fixedbugs/issue27356.go b/test/fixedbugs/issue27356.go
index 42784876a558a2624eff8413d576b0351fa799c3..c3e686df339544ff8f7b6954a35420a5ca310120 100644 (file)
--- a/test/fixedbugs/issue27356.go
+++ b/test/fixedbugs/issue27356.go
@@ -11,9 +11,9 @@ package p
 var a = []int{1,2,3}
 
 func _(len int) {
-       _ =  len(a) // ERROR "cannot call non-function"
+       _ =  len(a) // ERROR "cannot call non-function|expected function"
 }
 
 var cap = false
-var _ = cap(a) // ERROR "cannot call non-function"
+var _ = cap(a) // ERROR "cannot call non-function|expected function"
 

diff --git a/test/fixedbugs/issue27595.go b/test/fixedbugs/issue27595.go
index af5c7a10d9b0161a14022b74816745c5b1d05506..b9328a68132a132d6a9abcea51f798e365ac8dc9 100644 (file)
--- a/test/fixedbugs/issue27595.go
+++ b/test/fixedbugs/issue27595.go
@@ -8,7 +8,7 @@ package main
 
 var a = twoResults()       // ERROR "assignment mismatch: 1 variable but twoResults returns 2 values"
 var b, c, d = twoResults() // ERROR "assignment mismatch: 3 variables but twoResults returns 2 values"
-var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 values"
+var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 value"
 
 func twoResults() (int, int) {
        return 1, 2

diff --git a/test/fixedbugs/issue27938.go b/test/fixedbugs/issue27938.go
index b0007be928361891142cffbd95ef3d9eb822a564..ed974e642df576a34a1fdfca8e7b55672eecf819 100644 (file)
--- a/test/fixedbugs/issue27938.go
+++ b/test/fixedbugs/issue27938.go
@@ -11,13 +11,13 @@
 package p
 
 type _ struct {
-       F sync.Mutex // ERROR "undefined: sync"
+       F sync.Mutex // ERROR "undefined: sync|expected package"
 }
 
 type _ struct {
-       sync.Mutex // ERROR "undefined: sync"
+       sync.Mutex // ERROR "undefined: sync|expected package"
 }
 
 type _ interface {
-       sync.Mutex // ERROR "undefined: sync"
+       sync.Mutex // ERROR "undefined: sync|expected package|expected signature or type name"
 }

diff --git a/test/fixedbugs/issue28079b.go b/test/fixedbugs/issue28079b.go
index 47cc16dfb2f6c9bb12f9fe39d3349bdfe775f301..54c9db994b8fa216f67f42ab653d7741fd3fd331 100644 (file)
--- a/test/fixedbugs/issue28079b.go
+++ b/test/fixedbugs/issue28079b.go
@@ -10,8 +10,8 @@ package p
 
 import "unsafe"
 
-type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound"
+type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound|array bound is not constant"
 
 func f() {
-       _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0)
+       _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "shift of type float64|non-integer type for left operand of shift"
 }

diff --git a/test/fixedbugs/issue28079c.go b/test/fixedbugs/issue28079c.go
index bea1898304b845642bfb550f39b2d82110daaf44..dfac8d01554737f8ebdc93f51b522a562479a272 100644 (file)
--- a/test/fixedbugs/issue28079c.go
+++ b/test/fixedbugs/issue28079c.go
@@ -11,5 +11,5 @@ package p
 import "unsafe"
 
 func f() {
-       _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*"
+       _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*|non-integer type for left operand of shift"
 }

diff --git a/test/fixedbugs/issue28268.go b/test/fixedbugs/issue28268.go
index fdc6974d1c0fbd589b74885ca7a284005dae5b31..59a4c57c6727b35cda2538f139432a20c1571387 100644 (file)
--- a/test/fixedbugs/issue28268.go
+++ b/test/fixedbugs/issue28268.go
@@ -16,8 +16,8 @@ type T struct {
 
 type E struct{}
 
-func (T) b()  {} // ERROR "field and method named b"
-func (*T) E() {} // ERROR "field and method named E"
+func (T) b()  {} // ERROR "field and method named b|redeclares struct field name"
+func (*T) E() {} // ERROR "field and method named E|redeclares struct field name"
 
 func _() {
        var x T

diff --git a/test/fixedbugs/issue28450.go b/test/fixedbugs/issue28450.go
index 1a1183b2912f63c4b6501358e6d20a4c8ff206fd..2acfe39177a04d68b98eeb3ac772760beaab058c 100644 (file)
--- a/test/fixedbugs/issue28450.go
+++ b/test/fixedbugs/issue28450.go
@@ -6,13 +6,13 @@
 
 package p
 
-func f(a, b, c, d ...int)       {} // ERROR "non-final parameter a"
-func g(a ...int, b ...int)      {} // ERROR "non-final parameter a"
-func h(...int, ...int, float32) {} // ERROR "non-final parameter"
+func f(a, b, c, d ...int)       {} // ERROR "non-final parameter a|only permits one name"
+func g(a ...int, b ...int)      {} // ERROR "non-final parameter a|must be last parameter"
+func h(...int, ...int, float32) {} // ERROR "non-final parameter|must be last parameter"
 
-type a func(...float32, ...interface{}) // ERROR "non-final parameter"
+type a func(...float32, ...interface{}) // ERROR "non-final parameter|must be last parameter"
 type b interface {
-       f(...int, ...int)                // ERROR "non-final parameter"
-       g(a ...int, b ...int, c float32) // ERROR "non-final parameter a"
+       f(...int, ...int)                // ERROR "non-final parameter|must be last parameter"
+       g(a ...int, b ...int, c float32) // ERROR "non-final parameter a|must be last parameter"
        valid(...int)
 }

diff --git a/test/fixedbugs/issue28926.go b/test/fixedbugs/issue28926.go
index 5a46bd307c7fddeca57b88b161108e5c48a252df..1ca97d6f605862ea9d7971386da144c315a71040 100644 (file)
--- a/test/fixedbugs/issue28926.go
+++ b/test/fixedbugs/issue28926.go
@@ -13,12 +13,12 @@ type Stringer interface {
 func main() {
        var e interface{}
        switch e := e.(type) {
-       case G: // ERROR "undefined: G"
+       case G: // ERROR "undefined: G|undefined type .*G"
                e.M() // ok: this error should be ignored because the case failed its typecheck
-       case E: // ERROR "undefined: E"
+       case E: // ERROR "undefined: E|undefined type .*E"
                e.D() // ok: this error should be ignored because the case failed its typecheck
        case Stringer:
                // ok: this error should not be ignored to prove that passing legs aren't left out
-               _ = e.(T) // ERROR "undefined: T"
+               _ = e.(T) // ERROR "undefined: T|undefined type .*T"
        }
 }

diff --git a/test/fixedbugs/issue29855.go b/test/fixedbugs/issue29855.go
index b57eae2b44fea342663497ce0a71fee4ad5c8664..402093c160257ce9a0b7c52e0a5c32dfe015c251 100644 (file)
--- a/test/fixedbugs/issue29855.go
+++ b/test/fixedbugs/issue29855.go
@@ -10,7 +10,7 @@ type T struct {
        GlobalName string
 }
 
-var t = T{Name: "foo"} // ERROR "unknown field 'Name' in struct literal of type T"
+var t = T{Name: "foo"} // ERROR "unknown field 'Name' in struct literal of type T|unknown field .*Name.* in .*T"
 
 func (t T) Name() string {
        return t.GlobalName

diff --git a/test/fixedbugs/issue29870b.go b/test/fixedbugs/issue29870b.go
index 2d5f638530cb46d88c3a110598dc24185bcbed15..0a83489d96322f3d1005b99048ba03c553da1821 100644 (file)
--- a/test/fixedbugs/issue29870b.go
+++ b/test/fixedbugs/issue29870b.go
@@ -10,5 +10,5 @@
 package main
 
 func _() {
-       x := 7 // ERROR "x declared but not used"
+       x := 7 // ERROR ".*x.* declared but not used"
 }

diff --git a/test/fixedbugs/issue30085.go b/test/fixedbugs/issue30085.go
index 8223c855cd04fc0f5a71042331ff7a47bde1f169..d2ac4cfbfa7a06bb598fb4b7e20d9aa4799a61eb 100644 (file)
--- a/test/fixedbugs/issue30085.go
+++ b/test/fixedbugs/issue30085.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-       var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
-       var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values"
+       var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|wrong number of initializations"
+       var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values|wrong number of initializations"
 }

diff --git a/test/fixedbugs/issue30087.go b/test/fixedbugs/issue30087.go
index dc12364d80fd23479b07b03a475de2fdff93bd4b..a8f6202329e860fdd5a32544016a8407d04794ba 100644 (file)
--- a/test/fixedbugs/issue30087.go
+++ b/test/fixedbugs/issue30087.go
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-       var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 values"
-       _ = 1, 2        // ERROR "assignment mismatch: 1 variables but 2 values"
-       c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 values"
-       e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
+       var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations"
+       _ = 1, 2        // ERROR "assignment mismatch: 1 variable but 2 values|number of variables does not match"
+       c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations"
+       e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|wrong number of initializations"
 }

diff --git a/test/fixedbugs/issue30722.go b/test/fixedbugs/issue30722.go
index 02258f0bea9a3a4c76570b22dd728b540d19b564..fe04c8f41a0c31e3cd9629a6da787eb664009ab5 100644 (file)
--- a/test/fixedbugs/issue30722.go
+++ b/test/fixedbugs/issue30722.go
@@ -10,8 +10,8 @@ package p
 
 const (
        _ = 1_       // ERROR "'_' must separate successive digits"
-       _ = 0b       // ERROR "binary literal has no digits"
-       _ = 0o       // ERROR "octal literal has no digits"
-       _ = 0x       // ERROR "hexadecimal literal has no digits"
+       _ = 0b       // ERROR "binary literal has no digits|invalid numeric literal"
+       _ = 0o       // ERROR "octal literal has no digits|invalid numeric literal"
+       _ = 0x       // ERROR "hexadecimal literal has no digits|invalid numeric literal"
        _ = 0xde__ad // ERROR "'_' must separate successive digits"
 )

diff --git a/test/fixedbugs/issue31053.dir/main.go b/test/fixedbugs/issue31053.dir/main.go
index 895c262164ca43ebd3f329ab798595598b243c76..3bc75d17d2d80b660d00fda696a2516333478bc8 100644 (file)
--- a/test/fixedbugs/issue31053.dir/main.go
+++ b/test/fixedbugs/issue31053.dir/main.go
@@ -35,8 +35,8 @@ func main() {
        _ = f.Exported
        _ = f.exported    // ERROR "f.exported undefined .type f1.Foo has no field or method exported, but does have Exported."
        _ = f.Unexported  // ERROR "f.Unexported undefined .type f1.Foo has no field or method Unexported."
-       _ = f.unexported  // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
-       f.unexported = 10 // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
-       f.unexported()    // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
+       _ = f.unexported  // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
+       f.unexported = 10 // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
+       f.unexported()    // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
        _ = f.hook        // ERROR "f.hook undefined .cannot refer to unexported field or method hook."
 }

diff --git a/test/fixedbugs/issue32723.go b/test/fixedbugs/issue32723.go
index 7d9e403fc0cfd6089393d78ce3d7b80868dbce69..850334d7024ef454e90e3630e97baae5e4a8a0ec 100644 (file)
--- a/test/fixedbugs/issue32723.go
+++ b/test/fixedbugs/issue32723.go
@@ -9,14 +9,14 @@
 package p
 
 const x = 1i
-const y = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex"
-const z = x < 2i  // ERROR "invalid operation: .*not defined on untyped complex"
+const y = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+const z = x < 2i  // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
 
 func f() {
-       _ = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex"
-       _ = 1i < 2  // ERROR "invalid operation: .*not defined on untyped complex"
-       _ = 1 < 2i  // ERROR "invalid operation: .*not defined on untyped complex"
+       _ = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+       _ = 1i < 2  // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+       _ = 1 < 2i  // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
 
        c := 1i
-       _ = c < 2i // ERROR "invalid operation: .*not defined on complex128"
+       _ = c < 2i // ERROR "invalid operation: .*not defined on complex128|non-ordered type"
 }

diff --git a/test/fixedbugs/issue33275_run.go b/test/fixedbugs/issue33275_run.go
index f3e2e14f392eb7177dacdced583902b99b545e5f..ed03dccf4c8086bb8253ae1e4f029d9fd7dc57b6 100644 (file)
--- a/test/fixedbugs/issue33275_run.go
+++ b/test/fixedbugs/issue33275_run.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,!gccgo
 // run
 
 // Copyright 2019 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue33308.go b/test/fixedbugs/issue33308.go
index b0fd6a450ca4e2e9feb0a81cff4b9225f089f279..5821099e3d36599e3944e2cce841709b0bdc8403 100644 (file)
--- a/test/fixedbugs/issue33308.go
+++ b/test/fixedbugs/issue33308.go
@@ -9,4 +9,4 @@
 package p
 
 var v uint
-var x = []byte((1 << v) + 1) // ERROR "cannot convert"
+var x = []byte((1 << v) + 1) // ERROR "cannot convert|non-integer type for left operand of shift"

diff --git a/test/fixedbugs/issue33386.go b/test/fixedbugs/issue33386.go
index afc27e62f35cc7dd14cb9f94c9c833dbea646651..7b2f565285e6f8290979fcd69d4dcc830b08c9d9 100644 (file)
--- a/test/fixedbugs/issue33386.go
+++ b/test/fixedbugs/issue33386.go
@@ -11,19 +11,19 @@
 package p
 
 func _() {
-       go func() { // no error here about goroutine
-               send <-
-       }() // ERROR "expecting expression"
+       go func() {     // no error here about goroutine
+               send <- // GCCGO_ERROR "undefined name"
+       }()             // ERROR "expecting expression|expected operand"
 }
 
 func _() {
        defer func() { // no error here about deferred function
-               1 +
-       }() // ERROR "expecting expression"
+               1 +    // GCCGO_ERROR "value computed is not used"
+       }()            // ERROR "expecting expression|expected operand"
 }
 
 func _() {
-       _ = (1 +)             // ERROR "expecting expression"
-       _ = a[2 +]            // ERROR "expecting expression"
-       _ = []int{1, 2, 3 + } // ERROR "expecting expression"
+       _ = (1 +)             // ERROR "expecting expression|expected operand"
+       _ = a[2 +]            // ERROR "expecting expression|expected operand|undefined name"
+       _ = []int{1, 2, 3 + } // ERROR "expecting expression|expected operand"
 }

diff --git a/test/fixedbugs/issue33460.go b/test/fixedbugs/issue33460.go
index 1061d3e746c26fbb9e60a87196e3c1fd6f530315..d90b0a43489d4baf66681f789cef1f0f9e065abb 100644 (file)
--- a/test/fixedbugs/issue33460.go
+++ b/test/fixedbugs/issue33460.go
@@ -18,11 +18,11 @@ const iii int = 0x3
 func f(v int) {
        switch v {
        case zero, one:
-       case two, one: // ERROR "previous case at LINE-1"
+       case two, one: // ERROR "previous case at LINE-1|duplicate case in switch"
 
        case three:
-       case 3: // ERROR "previous case at LINE-1"
-       case iii: // ERROR "previous case at LINE-2"
+       case 3: // ERROR "previous case at LINE-1|duplicate case in switch"
+       case iii: // ERROR "previous case at LINE-2|duplicate case in switch"
        }
 }
 
@@ -31,7 +31,7 @@ const b = "b"
 var _ = map[string]int{
        "a": 0,
        b:   1,
-       "a": 2, // ERROR "previous key at LINE-2"
-       "b": 3, // ERROR "previous key at LINE-2"
-       "b": 4, // ERROR "previous key at LINE-3"
+       "a": 2, // ERROR "previous key at LINE-2|duplicate key in map literal"
+       "b": 3, // GC_ERROR "previous key at LINE-2"
+       "b": 4, // GC_ERROR "previous key at LINE-3"
 }

diff --git a/test/fixedbugs/issue33555.go b/test/fixedbugs/issue33555.go
index 7debd2049cd956468b9022951e1074e37abd439b..c1fcd2a79b387a8b23020bc42c2cf666471bee6d 100644 (file)
--- a/test/fixedbugs/issue33555.go
+++ b/test/fixedbugs/issue33555.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,!gccgo
 // run
 
 // Copyright 2019 The Go Authors. All rights reserved.

diff --git a/test/fixedbugs/issue35291.go b/test/fixedbugs/issue35291.go
index 3cbdbf962aac1824c0af99fb6ec5e8bbbc20a4e6..5d8381c244e3e663edd36c58b03e6293cc9ddd40 100644 (file)
--- a/test/fixedbugs/issue35291.go
+++ b/test/fixedbugs/issue35291.go
@@ -10,5 +10,5 @@ package p
 
 var s = []string{
        1: "dup",
-       1: "dup", // ERROR "duplicate index in slice literal: 1"
+       1: "dup", // ERROR "duplicate index in slice literal: 1|duplicate value for index 1"
 }

diff --git a/test/fixedbugs/issue36437.go b/test/fixedbugs/issue36437.go
index f96544beff810846c657725a8b19194c505a3edb..c7a11d27a8934985d1bc975d7a60f4e96d793746 100644 (file)
--- a/test/fixedbugs/issue36437.go
+++ b/test/fixedbugs/issue36437.go
@@ -1,6 +1,6 @@
 // run
 
-// +build !nacl,!js
+// +build !nacl,!js,gc
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

diff --git a/test/fixedbugs/issue38745.go b/test/fixedbugs/issue38745.go
index 83a3bc6fad6e0181fa9d3d008695fbf7b0b846fc..7d4283b8453ddfc0d5e2dc9bf61b3876ab2a60b0 100644 (file)
--- a/test/fixedbugs/issue38745.go
+++ b/test/fixedbugs/issue38745.go
@@ -9,10 +9,10 @@ package p
 type t struct{ x int }
 
 func f1() {
-       t{}.M()     // ERROR "t{}.M undefined \(type t has no field or method M\)"
-       t{x: 1}.M() // ERROR "t{...}.M undefined \(type t has no field or method M\)"
+       t{}.M()     // ERROR "t{}.M undefined \(type t has no field or method M\)|undefined field or method .*M"
+       t{x: 1}.M() // ERROR "t{...}.M undefined \(type t has no field or method M\)|undefined field or method .*M"
 }
 
 func f2() (*t, error) {
-       return t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)"
+       return t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)|undefined field or method .*M|not enough arguments"
 }

diff --git a/test/fixedbugs/issue41247.go b/test/fixedbugs/issue41247.go
index b8bd81274f8526162f9c1551d540a551161606b1..c5e495ba93396cef9dfe6c99444d7825a08a3329 100644 (file)
--- a/test/fixedbugs/issue41247.go
+++ b/test/fixedbugs/issue41247.go
@@ -7,5 +7,5 @@
 package p
 
 func f() [2]int {
-       return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)"
+       return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)|incompatible type"
 }

diff --git a/test/fixedbugs/issue41440.go b/test/fixedbugs/issue41440.go
index 2b441db8037f7f8f7a59e5d97fad8b6eb2021624..0d911f0173a480ca4ceaf7b8fa725afc2030017a 100644 (file)
--- a/test/fixedbugs/issue41440.go
+++ b/test/fixedbugs/issue41440.go
@@ -10,5 +10,5 @@ func f(...int) {}
 
 func g() {
        var x []int
-       f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)"
+       f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)|too many arguments"
 }

diff --git a/test/fixedbugs/issue41500.go b/test/fixedbugs/issue41500.go
index d1e4efc8fd9f0d9bfce0d46e8b3689aa10bf1c24..82dca34820a37726d102fe70e13bbae8afbce244 100644 (file)
--- a/test/fixedbugs/issue41500.go
+++ b/test/fixedbugs/issue41500.go
@@ -13,8 +13,8 @@ type s struct {
 func f() {
        var x *s
 
-       _ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
-       _ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
-       _ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)"
-       _ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)"
+       _ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|incompatible types"
+       _ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|incompatible types"
+       _ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)|incompatible types"
+       _ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)|incompatible types"
 }

diff --git a/test/fixedbugs/issue41575.go b/test/fixedbugs/issue41575.go
index d03d1c8b3ea63f9acbaad1e648d01185e4f0a683..456873038fc891c8e2d60deebe5cbc368f96aa51 100644 (file)
--- a/test/fixedbugs/issue41575.go
+++ b/test/fixedbugs/issue41575.go
@@ -6,31 +6,31 @@
 
 package p
 
-type T1 struct { // ERROR "invalid recursive type T1\n\tLINE: T1 refers to\n\tLINE+4: T2 refers to\n\tLINE: T1$"
+type T1 struct { // ERROR "invalid recursive type T1\n\tLINE: T1 refers to\n\tLINE+4: T2 refers to\n\tLINE: T1$|invalid recursive type"
        f2 T2
 }
 
-type T2 struct {
+type T2 struct { // GCCGO_ERROR "invalid recursive type"
        f1 T1
 }
 
-type a b
-type b c // ERROR "invalid recursive type b\n\tLINE: b refers to\n\tLINE+1: c refers to\n\tLINE: b$"
-type c b
+type a b // GCCGO_ERROR "invalid recursive type"
+type b c // ERROR "invalid recursive type b\n\tLINE: b refers to\n\tLINE+1: c refers to\n\tLINE: b$|invalid recursive type"
+type c b // GCCGO_ERROR "invalid recursive type"
 
 type d e
 type e f
-type f f // ERROR "invalid recursive type f\n\tLINE: f refers to\n\tLINE: f$"
+type f f // ERROR "invalid recursive type f\n\tLINE: f refers to\n\tLINE: f$|invalid recursive type"
 
-type g struct { // ERROR "invalid recursive type g\n\tLINE: g refers to\n\tLINE: g$"
+type g struct { // ERROR "invalid recursive type g\n\tLINE: g refers to\n\tLINE: g$|invalid recursive type"
        h struct {
                g
        }
 }
 
 type w x
-type x y // ERROR "invalid recursive type x\n\tLINE: x refers to\n\tLINE+1: y refers to\n\tLINE+2: z refers to\n\tLINE: x$"
-type y struct{ z }
+type x y           // ERROR "invalid recursive type x\n\tLINE: x refers to\n\tLINE+1: y refers to\n\tLINE+2: z refers to\n\tLINE: x$|invalid recursive type"
+type y struct{ z } // GCCGO_ERROR "invalid recursive type"
 type z [10]x
 
 type w2 w // refer to the type loop again

diff --git a/test/fixedbugs/issue42058a.go b/test/fixedbugs/issue42058a.go
index 67751a1b0c9656df8e977532a0dc1ea7372f36cd..722f86e1ecfdc16ec790fd4d37d33d1a28a01fdf 100644 (file)
--- a/test/fixedbugs/issue42058a.go
+++ b/test/fixedbugs/issue42058a.go
@@ -6,8 +6,8 @@
 
 package p
 
-var c chan [2 << 16]byte // ERROR "channel element type too large"
+var c chan [2 << 16]byte // GC_ERROR "channel element type too large"
 
 type T [1 << 17]byte
 
-var x chan T // ERROR "channel element type too large"
+var x chan T // GC_ERROR "channel element type too large"

diff --git a/test/fixedbugs/issue42058b.go b/test/fixedbugs/issue42058b.go
index 03f86ee1b114b5688c6ab4dbac812a6e6036aa44..71a280f96b74ba2a0687ed1495b974a1336dca21 100644 (file)
--- a/test/fixedbugs/issue42058b.go
+++ b/test/fixedbugs/issue42058b.go
@@ -6,7 +6,7 @@
 
 package p
 
-var c chan [2 << 16]byte // ERROR "channel element type too large"
+var c chan [2 << 16]byte // GC_ERROR "channel element type too large"
 
 func f() {
        _ = 42

diff --git a/test/fixedbugs/issue4215.go b/test/fixedbugs/issue4215.go
index 795d48d7f557c552025bac9c0b92676ff6f4f8a1..be9fc7434a7d45e28827d9b18998811a1fef4e23 100644 (file)
--- a/test/fixedbugs/issue4215.go
+++ b/test/fixedbugs/issue4215.go
@@ -7,28 +7,28 @@
 package main
 
 func foo() (int, int) {
-       return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)"
+       return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)|not enough arguments to return"
 }
 
 func foo2() {
-       return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)"
+       return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)|return with value in function with no return type"
 }
 
 func foo3(v int) (a, b, c, d int) {
        if v >= 0 {
-               return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)"
+               return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)|not enough arguments to return"
        }
-       return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)"
+       return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)|not enough arguments to return"
 }
 
 func foo4(name string) (string, int) {
        switch name {
        case "cow":
-               return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+               return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|not enough arguments to return"
        case "dog":
-               return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)"
+               return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)|too many values in return statement"
        case "fish":
-               return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+               return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|not enough arguments to return"
        default:
                return "lizard", 10
        }
@@ -40,14 +40,14 @@ type U float64
 
 func foo5() (S, T, U) {
        if false {
-               return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)"
+               return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)|not enough arguments to return"
        } else {
                ptr := new(T)
-               return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)"
+               return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)|not enough arguments to return"
        }
-       return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)"
+       return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)|too many values in return statement"
 }
 
 func foo6() (T, string) {
-       return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)"
+       return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)|too many values in return statement"
 }

diff --git a/test/fixedbugs/issue43164.dir/a.go b/test/fixedbugs/issue43164.dir/a.go
new file mode 100644 (file)
index 0000000..fa10e85
--- /dev/null
+++ b/test/fixedbugs/issue43164.dir/a.go
@@ -0,0 +1,13 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import . "strings"
+
+var _ = Index // use strings
+
+type t struct{ Index int }
+
+var _ = t{Index: 0}

diff --git a/test/fixedbugs/issue43164.dir/b.go b/test/fixedbugs/issue43164.dir/b.go
new file mode 100644 (file)
index 0000000..b025927
--- /dev/null
+++ b/test/fixedbugs/issue43164.dir/b.go
@@ -0,0 +1,11 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import . "bytes"
+
+var _ = Index // use bytes
+
+var _ = t{Index: 0}

diff --git a/src/syscall/syscall_windows_amd64.go b/test/fixedbugs/issue43164.go
similarity index 54%
rename from src/syscall/syscall_windows_amd64.go
rename to test/fixedbugs/issue43164.go
index e82b540b4b64da1ef68d4cde3eb4beb73762befc..f21d1d5c582a72ad01d291edfae9050df45fb03f 100644 (file)
--- a/src/syscall/syscall_windows_amd64.go
+++ b/test/fixedbugs/issue43164.go
@@ -1,5 +1,7 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// compiledir
+
+// Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package syscall
+package ignored

diff --git a/test/fixedbugs/issue43167.go b/test/fixedbugs/issue43167.go
new file mode 100644 (file)
index 0000000..1d1b69a
--- /dev/null
+++ b/test/fixedbugs/issue43167.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import . "bytes"
+
+var _ Buffer // use package bytes
+
+var Index byte // ERROR "Index redeclared.*\n\tLINE-4: previous declaration during import .bytes.|already declared|redefinition"

diff --git a/test/fixedbugs/issue43292.go b/test/fixedbugs/issue43292.go
new file mode 100644 (file)
index 0000000..02f1c69
--- /dev/null
+++ b/test/fixedbugs/issue43292.go
@@ -0,0 +1,59 @@
+// run
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main() {
+       {
+               i := I(A{})
+
+               b := make(chan I, 1)
+               b <- B{}
+
+               var ok bool
+               i, ok = <-b
+               _ = ok
+
+               i.M()
+       }
+
+       {
+               i := I(A{})
+
+               b := make(chan I, 1)
+               b <- B{}
+
+               select {
+               case i = <-b:
+               }
+
+               i.M()
+       }
+
+       {
+               i := I(A{})
+
+               b := make(chan I, 1)
+               b <- B{}
+
+               var ok bool
+               select {
+               case i, ok = <-b:
+               }
+               _ = ok
+
+               i.M()
+       }
+}
+
+type I interface{ M() int }
+
+type T int
+
+func (T) M() int { return 0 }
+
+type A struct{ T }
+type B struct{ T }

diff --git a/test/fixedbugs/issue43384.go b/test/fixedbugs/issue43384.go
new file mode 100644 (file)
index 0000000..1bd793b
--- /dev/null
+++ b/test/fixedbugs/issue43384.go
@@ -0,0 +1,124 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.  Use of this
+// source code is governed by a BSD-style license that can be found in
+// the LICENSE file.
+
+package p
+
+type T int
+
+func (T) Mv()  {}
+func (*T) Mp() {}
+
+type P1 struct{ T }
+type P2 struct{ *T }
+type P3 *struct{ T }
+type P4 *struct{ *T }
+
+func _() {
+       {
+               var p P1
+               p.Mv()
+               (&p).Mv()
+               (*&p).Mv()
+               p.Mp()
+               (&p).Mp()
+               (*&p).Mp()
+       }
+       {
+               var p P2
+               p.Mv()
+               (&p).Mv()
+               (*&p).Mv()
+               p.Mp()
+               (&p).Mp()
+               (*&p).Mp()
+       }
+       {
+               var p P3
+               p.Mv()     // ERROR "undefined"
+               (&p).Mv()  // ERROR "undefined"
+               (*&p).Mv() // ERROR "undefined"
+               (**&p).Mv()
+               (*p).Mv()
+               (&*p).Mv()
+               p.Mp()     // ERROR "undefined"
+               (&p).Mp()  // ERROR "undefined"
+               (*&p).Mp() // ERROR "undefined"
+               (**&p).Mp()
+               (*p).Mp()
+               (&*p).Mp()
+       }
+       {
+               var p P4
+               p.Mv()     // ERROR "undefined"
+               (&p).Mv()  // ERROR "undefined"
+               (*&p).Mv() // ERROR "undefined"
+               (**&p).Mv()
+               (*p).Mv()
+               (&*p).Mv()
+               p.Mp()     // ERROR "undefined"
+               (&p).Mp()  // ERROR "undefined"
+               (*&p).Mp() // ERROR "undefined"
+               (**&p).Mp()
+               (*p).Mp()
+               (&*p).Mp()
+       }
+}
+
+func _() {
+       type P5 struct{ T }
+       type P6 struct{ *T }
+       type P7 *struct{ T }
+       type P8 *struct{ *T }
+
+       {
+               var p P5
+               p.Mv()
+               (&p).Mv()
+               (*&p).Mv()
+               p.Mp()
+               (&p).Mp()
+               (*&p).Mp()
+       }
+       {
+               var p P6
+               p.Mv()
+               (&p).Mv()
+               (*&p).Mv()
+               p.Mp()
+               (&p).Mp()
+               (*&p).Mp()
+       }
+       {
+               var p P7
+               p.Mv()     // ERROR "undefined"
+               (&p).Mv()  // ERROR "undefined"
+               (*&p).Mv() // ERROR "undefined"
+               (**&p).Mv()
+               (*p).Mv()
+               (&*p).Mv()
+               p.Mp()     // ERROR "undefined"
+               (&p).Mp()  // ERROR "undefined"
+               (*&p).Mp() // ERROR "undefined"
+               (**&p).Mp()
+               (*p).Mp()
+               (&*p).Mp()
+       }
+       {
+               var p P8
+               p.Mv()     // ERROR "undefined"
+               (&p).Mv()  // ERROR "undefined"
+               (*&p).Mv() // ERROR "undefined"
+               (**&p).Mv()
+               (*p).Mv()
+               (&*p).Mv()
+               p.Mp()     // ERROR "undefined"
+               (&p).Mp()  // ERROR "undefined"
+               (*&p).Mp() // ERROR "undefined"
+               (**&p).Mp()
+               (*p).Mp()
+               (&*p).Mp()
+       }
+}

diff --git a/test/fixedbugs/issue43428.go b/test/fixedbugs/issue43428.go
new file mode 100644 (file)
index 0000000..773a3f3
--- /dev/null
+++ b/test/fixedbugs/issue43428.go
@@ -0,0 +1,25 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import "time"
+
+type T int
+
+func (T) Mv()  {}
+func (*T) Mp() {}
+
+var _ = []int{
+       T.Mv,    // ERROR "cannot use T\.Mv|incompatible type"
+       (*T).Mv, // ERROR "cannot use \(\*T\)\.Mv|incompatible type"
+       (*T).Mp, // ERROR "cannot use \(\*T\)\.Mp|incompatible type"
+
+       time.Time.GobEncode,    // ERROR "cannot use time\.Time\.GobEncode|incompatible type"
+       (*time.Time).GobEncode, // ERROR "cannot use \(\*time\.Time\)\.GobEncode|incompatible type"
+       (*time.Time).GobDecode, // ERROR "cannot use \(\*time\.Time\)\.GobDecode|incompatible type"
+
+}

diff --git a/test/fixedbugs/issue43444.go b/test/fixedbugs/issue43444.go
new file mode 100644 (file)
index 0000000..c430e1b
--- /dev/null
+++ b/test/fixedbugs/issue43444.go
@@ -0,0 +1,28 @@
+// run
+
+package main
+
+var sp = ""
+
+func f(name string, _ ...interface{}) int {
+       print(sp, name)
+       sp = " "
+       return 0
+}
+
+var a = f("a", x)
+var b = f("b", y)
+var c = f("c", z)
+var d = func() int {
+       if false {
+               _ = z
+       }
+       return f("d")
+}()
+var e = f("e")
+
+var x int
+var y int = 42
+var z int = func() int { return 42 }()
+
+func main() { println() }

diff --git a/test/fixedbugs/issue43444.out b/test/fixedbugs/issue43444.out
new file mode 100644 (file)
index 0000000..22d6a0d
--- /dev/null
+++ b/test/fixedbugs/issue43444.out
@@ -0,0 +1 @@
+e a b c d

diff --git a/test/fixedbugs/issue43479.dir/a.go b/test/fixedbugs/issue43479.dir/a.go
new file mode 100644 (file)
index 0000000..ed3e6a5
--- /dev/null
+++ b/test/fixedbugs/issue43479.dir/a.go
@@ -0,0 +1,27 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type Here struct{ stuff int }
+type Info struct{ Dir string }
+
+func New() Here { return Here{} }
+func (h Here) Dir(p string) (Info, error)
+
+type I interface{ M(x string) }
+
+type T = struct {
+       Here
+       I
+}
+
+var X T
+
+var A = (*T).Dir
+var B = T.Dir
+var C = X.Dir
+var D = (*T).M
+var E = T.M
+var F = X.M

diff --git a/test/fixedbugs/issue43479.dir/b.go b/test/fixedbugs/issue43479.dir/b.go
new file mode 100644 (file)
index 0000000..02d1690
--- /dev/null
+++ b/test/fixedbugs/issue43479.dir/b.go
@@ -0,0 +1,38 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+var Here = a.New()
+var Dir = Here.Dir
+
+type T = struct {
+       a.Here
+       a.I
+}
+
+var X T
+
+// Test exporting the type of method values for anonymous structs with
+// promoted methods.
+var A = a.A
+var B = a.B
+var C = a.C
+var D = a.D
+var E = a.E
+var F = a.F
+var G = (*a.T).Dir
+var H = a.T.Dir
+var I = a.X.Dir
+var J = (*a.T).M
+var K = a.T.M
+var L = a.X.M
+var M = (*T).Dir
+var N = T.Dir
+var O = X.Dir
+var P = (*T).M
+var Q = T.M
+var R = X.M

diff --git a/test/fixedbugs/issue43479.go b/test/fixedbugs/issue43479.go
new file mode 100644 (file)
index 0000000..f21d1d5
--- /dev/null
+++ b/test/fixedbugs/issue43479.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ignored

diff --git a/test/fixedbugs/issue43480.go b/test/fixedbugs/issue43480.go
new file mode 100644 (file)
index 0000000..d98ad3a
--- /dev/null
+++ b/test/fixedbugs/issue43480.go
@@ -0,0 +1,33 @@
+// run
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Issue #43480: ICE on large uint64 constants in switch cases.
+
+package main
+
+func isPow10(x uint64) bool {
+       switch x {
+       case 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+               1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19:
+               return true
+       }
+       return false
+}
+
+func main() {
+       var x uint64 = 1
+
+       for {
+               if !isPow10(x) || isPow10(x-1) || isPow10(x+1) {
+                       panic(x)
+               }
+               next := x * 10
+               if next/10 != x {
+                       break // overflow
+               }
+               x = next
+       }
+}

diff --git a/test/fixedbugs/issue43551.dir/a.go b/test/fixedbugs/issue43551.dir/a.go
new file mode 100644 (file)
index 0000000..d890dd0
--- /dev/null
+++ b/test/fixedbugs/issue43551.dir/a.go
@@ -0,0 +1,13 @@
+package a
+
+type S struct {
+       a Key
+}
+
+func (s S) A() Key {
+       return s.a
+}
+
+type Key struct {
+       key int64
+}

diff --git a/test/fixedbugs/issue43551.dir/b.go b/test/fixedbugs/issue43551.dir/b.go
new file mode 100644 (file)
index 0000000..ba062bf
--- /dev/null
+++ b/test/fixedbugs/issue43551.dir/b.go
@@ -0,0 +1,14 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+type S a.S
+type Key a.Key
+
+func (s S) A() Key {
+       return Key(a.S(s).A())
+}

diff --git a/test/fixedbugs/issue43551.go b/test/fixedbugs/issue43551.go
new file mode 100644 (file)
index 0000000..b83fbd7
--- /dev/null
+++ b/test/fixedbugs/issue43551.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ignored

diff --git a/test/fixedbugs/issue43570.go b/test/fixedbugs/issue43570.go
new file mode 100644 (file)
index 0000000..d073fde
--- /dev/null
+++ b/test/fixedbugs/issue43570.go
@@ -0,0 +1,40 @@
+// run
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "fmt"
+
+type T [8]*int
+
+//go:noinline
+func f(x int) T {
+       return T{}
+}
+
+//go:noinline
+func g(x int, t T) {
+       if t != (T{}) {
+               panic(fmt.Sprintf("bad: %v", t))
+       }
+}
+
+func main() {
+       const N = 10000
+       var q T
+       func() {
+               for i := 0; i < N; i++ {
+                       q = f(0)
+                       g(0, q)
+                       sink = make([]byte, 1024)
+               }
+       }()
+       // Note that the closure is a trick to get the write to q to be a
+       // write to a pointer that is known to be non-nil and requires
+       // a write barrier.
+}
+
+var sink []byte

diff --git a/test/fixedbugs/issue43619.go b/test/fixedbugs/issue43619.go
new file mode 100644 (file)
index 0000000..3e66785
--- /dev/null
+++ b/test/fixedbugs/issue43619.go
@@ -0,0 +1,119 @@
+// run
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+       "fmt"
+       "math"
+)
+
+//go:noinline
+func fcmplt(a, b float64, x uint64) uint64 {
+       if a < b {
+               x = 0
+       }
+       return x
+}
+
+//go:noinline
+func fcmple(a, b float64, x uint64) uint64 {
+       if a <= b {
+               x = 0
+       }
+       return x
+}
+
+//go:noinline
+func fcmpgt(a, b float64, x uint64) uint64 {
+       if a > b {
+               x = 0
+       }
+       return x
+}
+
+//go:noinline
+func fcmpge(a, b float64, x uint64) uint64 {
+       if a >= b {
+               x = 0
+       }
+       return x
+}
+
+//go:noinline
+func fcmpeq(a, b float64, x uint64) uint64 {
+       if a == b {
+               x = 0
+       }
+       return x
+}
+
+//go:noinline
+func fcmpne(a, b float64, x uint64) uint64 {
+       if a != b {
+               x = 0
+       }
+       return x
+}
+
+func main() {
+       type fn func(a, b float64, x uint64) uint64
+
+       type testCase struct {
+               f       fn
+               a, b    float64
+               x, want uint64
+       }
+       NaN := math.NaN()
+       for _, t := range []testCase{
+               {fcmplt, 1.0, 1.0, 123, 123},
+               {fcmple, 1.0, 1.0, 123, 0},
+               {fcmpgt, 1.0, 1.0, 123, 123},
+               {fcmpge, 1.0, 1.0, 123, 0},
+               {fcmpeq, 1.0, 1.0, 123, 0},
+               {fcmpne, 1.0, 1.0, 123, 123},
+
+               {fcmplt, 1.0, 2.0, 123, 0},
+               {fcmple, 1.0, 2.0, 123, 0},
+               {fcmpgt, 1.0, 2.0, 123, 123},
+               {fcmpge, 1.0, 2.0, 123, 123},
+               {fcmpeq, 1.0, 2.0, 123, 123},
+               {fcmpne, 1.0, 2.0, 123, 0},
+
+               {fcmplt, 2.0, 1.0, 123, 123},
+               {fcmple, 2.0, 1.0, 123, 123},
+               {fcmpgt, 2.0, 1.0, 123, 0},
+               {fcmpge, 2.0, 1.0, 123, 0},
+               {fcmpeq, 2.0, 1.0, 123, 123},
+               {fcmpne, 2.0, 1.0, 123, 0},
+
+               {fcmplt, 1.0, NaN, 123, 123},
+               {fcmple, 1.0, NaN, 123, 123},
+               {fcmpgt, 1.0, NaN, 123, 123},
+               {fcmpge, 1.0, NaN, 123, 123},
+               {fcmpeq, 1.0, NaN, 123, 123},
+               {fcmpne, 1.0, NaN, 123, 0},
+
+               {fcmplt, NaN, 1.0, 123, 123},
+               {fcmple, NaN, 1.0, 123, 123},
+               {fcmpgt, NaN, 1.0, 123, 123},
+               {fcmpge, NaN, 1.0, 123, 123},
+               {fcmpeq, NaN, 1.0, 123, 123},
+               {fcmpne, NaN, 1.0, 123, 0},
+
+               {fcmplt, NaN, NaN, 123, 123},
+               {fcmple, NaN, NaN, 123, 123},
+               {fcmpgt, NaN, NaN, 123, 123},
+               {fcmpge, NaN, NaN, 123, 123},
+               {fcmpeq, NaN, NaN, 123, 123},
+               {fcmpne, NaN, NaN, 123, 0},
+       } {
+               got := t.f(t.a, t.b, t.x)
+               if got != t.want {
+                       panic(fmt.Sprintf("want %v, got %v", t.want, got))
+               }
+       }
+}

diff --git a/test/fixedbugs/issue43633.dir/a.go b/test/fixedbugs/issue43633.dir/a.go
new file mode 100644 (file)
index 0000000..946a37e
--- /dev/null
+++ b/test/fixedbugs/issue43633.dir/a.go
@@ -0,0 +1,28 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+func F() bool {
+       {
+               x := false
+               _ = x
+       }
+       if false {
+               _ = func(x bool) {}
+       }
+       x := true
+       return x
+}
+
+func G() func() bool {
+       x := true
+       return func() bool {
+               {
+                       x := false
+                       _ = x
+               }
+               return x
+       }
+}

diff --git a/test/fixedbugs/issue43633.dir/main.go b/test/fixedbugs/issue43633.dir/main.go
new file mode 100644 (file)
index 0000000..320e000
--- /dev/null
+++ b/test/fixedbugs/issue43633.dir/main.go
@@ -0,0 +1,18 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "./a"
+
+var g = a.G()
+
+func main() {
+       if !a.F() {
+               panic("FAIL")
+       }
+       if !g() {
+               panic("FAIL")
+       }
+}

diff --git a/src/syscall/zerrors_windows_386.go b/test/fixedbugs/issue43633.go
similarity index 56%
rename from src/syscall/zerrors_windows_386.go
rename to test/fixedbugs/issue43633.go
index 8bc5b6b1943eed12567675b737a58144a3d09bb6..40df49f83bef07a3f4c5d8fd4000d97484c3f224 100644 (file)
--- a/src/syscall/zerrors_windows_386.go
+++ b/test/fixedbugs/issue43633.go
@@ -1,5 +1,7 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// rundir
+
+// Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package syscall
+package ignored

diff --git a/test/fixedbugs/issue43677.go b/test/fixedbugs/issue43677.go
new file mode 100644 (file)
index 0000000..1a68c8b
--- /dev/null
+++ b/test/fixedbugs/issue43677.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Issue #43677: ICE during compilation of dynamic initializers for
+// composite blank variables.
+
+package p
+
+func f() *int
+
+var _ = [2]*int{nil, f()}
+
+var _ = struct{ x, y *int }{nil, f()}
+
+var _ interface{} = f()

diff --git a/test/fixedbugs/issue43701.go b/test/fixedbugs/issue43701.go
new file mode 100644 (file)
index 0000000..6e16180
--- /dev/null
+++ b/test/fixedbugs/issue43701.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+func f() {
+       var st struct {
+               s string
+               i int16
+       }
+       _ = func() {
+               var m map[int16]int
+               m[st.i] = 0
+       }
+}

diff --git a/test/fixedbugs/issue43762.go b/test/fixedbugs/issue43762.go
new file mode 100644 (file)
index 0000000..4544b6e
--- /dev/null
+++ b/test/fixedbugs/issue43762.go
@@ -0,0 +1,11 @@
+// errorcheck
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+var _ = true == '\\' // ERROR "invalid operation: true == '\\\\'"
+var _ = true == '\'' // ERROR "invalid operation: true == '\\''"
+var _ = true == '\n' // ERROR "invalid operation: true == '\\n'"

diff --git a/test/fixedbugs/issue43835.go b/test/fixedbugs/issue43835.go
new file mode 100644 (file)
index 0000000..29a5194
--- /dev/null
+++ b/test/fixedbugs/issue43835.go
@@ -0,0 +1,45 @@
+// run
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main() {
+       if f() {
+               panic("FAIL")
+       }
+       if bad, _ := g(); bad {
+               panic("FAIL")
+       }
+       if bad, _ := h(); bad {
+               panic("FAIL")
+       }
+}
+
+func f() (bad bool) {
+       defer func() {
+               recover()
+       }()
+       var p *int
+       bad, _ = true, *p
+       return
+}
+
+func g() (bool, int) {
+       defer func() {
+               recover()
+       }()
+       var p *int
+       return true, *p
+}
+
+
+func h() (_ bool, _ int) {
+       defer func() {
+               recover()
+       }()
+       var p *int
+       return true, *p
+}

diff --git a/src/syscall/zerrors_windows_amd64.go b/test/fixedbugs/issue43962.dir/a.go
similarity index 59%
rename from src/syscall/zerrors_windows_amd64.go
rename to test/fixedbugs/issue43962.dir/a.go
index 8bc5b6b1943eed12567675b737a58144a3d09bb6..168b2063b4872373b43dfbc27e30757fc7af25d2 100644 (file)
--- a/src/syscall/zerrors_windows_amd64.go
+++ b/test/fixedbugs/issue43962.dir/a.go
@@ -1,5 +1,5 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package syscall
+package init

diff --git a/test/fixedbugs/issue43962.dir/b.go b/test/fixedbugs/issue43962.dir/b.go
new file mode 100644 (file)
index 0000000..f55fea1
--- /dev/null
+++ b/test/fixedbugs/issue43962.dir/b.go
@@ -0,0 +1,7 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a" // ERROR "cannot import package as init"

diff --git a/test/fixedbugs/issue43962.go b/test/fixedbugs/issue43962.go
new file mode 100644 (file)
index 0000000..dca4d07
--- /dev/null
+++ b/test/fixedbugs/issue43962.go
@@ -0,0 +1,9 @@
+// errorcheckdir
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Issue 43962: Importing a package called "init" is an error.
+
+package ignored

diff --git a/test/fixedbugs/issue5493.go b/test/fixedbugs/issue5493.go
index 2ee0398af2c894f4939f594a758eadb9a82d71d5..8f771bc2db369c9baa9d80cd773c1d62d1cc0225 100644 (file)
--- a/test/fixedbugs/issue5493.go
+++ b/test/fixedbugs/issue5493.go
@@ -14,6 +14,7 @@ import (
 )
 
 const N = 10
+
 var count int64
 
 func run() error {
@@ -31,10 +32,9 @@ func run() error {
 }
 
 func main() {
-       // Does not work on 32-bits, or with gccgo, due to partially
-       // conservative GC.
+       // Does not work with gccgo, due to partially conservative GC.
        // Try to enable when we have fully precise GC.
-       if runtime.GOARCH != "amd64" || runtime.Compiler == "gccgo" {
+       if runtime.Compiler == "gccgo" {
                return
        }
        count = N
@@ -56,4 +56,3 @@ func main() {
                panic("not all finalizers are called")
        }
 }
-

diff --git a/test/fixedbugs/issue6402.go b/test/fixedbugs/issue6402.go
index da5980c9ab6a601ad2afddc959edbedacea261b5..ecde9ae5105c88ea7564584ca253525e6926e198 100644 (file)
--- a/test/fixedbugs/issue6402.go
+++ b/test/fixedbugs/issue6402.go
@@ -9,5 +9,5 @@
 package p
 
 func f() uintptr {
-       return nil // ERROR "cannot use nil as type uintptr in return argument"
+       return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type"
 }

diff --git a/test/fixedbugs/issue6403.go b/test/fixedbugs/issue6403.go
index b61e2e225d4859d9b3bee5b167d301c75b26c734..809efefa0f42c5c21def82d3db8dae784ddf0b4a 100644 (file)
--- a/test/fixedbugs/issue6403.go
+++ b/test/fixedbugs/issue6403.go
@@ -10,5 +10,5 @@ package p
 
 import "syscall"
 
-const A int = syscall.X // ERROR "undefined: syscall.X"
-const B int = voidpkg.X // ERROR "undefined: voidpkg"
+const A int = syscall.X // ERROR "undefined: syscall.X|undefined identifier .*syscall.X"
+const B int = voidpkg.X // ERROR "undefined: voidpkg|undefined name .*voidpkg"

diff --git a/test/fixedbugs/issue6428.go b/test/fixedbugs/issue6428.go
new file mode 100644 (file)
index 0000000..c3f7b20
--- /dev/null
+++ b/test/fixedbugs/issue6428.go
@@ -0,0 +1,15 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import . "testing" // ERROR "imported and not used"
+
+type S struct {
+       T int
+}
+
+var _ = S{T: 0}

diff --git a/test/fixedbugs/issue6772.go b/test/fixedbugs/issue6772.go
index 4d0001c870d7a5fd62749d2cf9a70a1e5d56345d..5bd15ba72ece24fead41e144f48293c86ea3acee 100644 (file)
--- a/test/fixedbugs/issue6772.go
+++ b/test/fixedbugs/issue6772.go
@@ -7,14 +7,14 @@
 package p
 
 func f1() {
-       for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+       for a, a := range []int{1, 2, 3} { // ERROR "a.* repeated on left side of :="
                println(a)
        }
 }
 
 func f2() {
        var a int
-       for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+       for a, a := range []int{1, 2, 3} { // ERROR "a.* repeated on left side of :="
                println(a)
        }
        println(a)

diff --git a/test/fixedbugs/issue6889.go b/test/fixedbugs/issue6889.go
index 805a877d582728389fc630aae40e71191364fcf0..efd8b761483410ba3561c2a2ce44b635b9e66556 100644 (file)
--- a/test/fixedbugs/issue6889.go
+++ b/test/fixedbugs/issue6889.go
@@ -107,5 +107,5 @@ const (
        f96 = f95 * 96
        f97 = f96 * 97
        f98 = f97 * 98
-       f99 = f98 * 99 // ERROR "overflow"
+       f99 = f98 * 99 // GC_ERROR "overflow"
 )

diff --git a/test/fixedbugs/issue6964.go b/test/fixedbugs/issue6964.go
index 7ad83364ab0bdbf0637aac01a3c8946f613db743..36a3c5bb40f27245315ce700fe19af761b28b1d5 100644 (file)
--- a/test/fixedbugs/issue6964.go
+++ b/test/fixedbugs/issue6964.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-       _ = string(-4 + 2i + 2) // ERROR "-4 \+ 2i"
+       _ = string(-4 + 2i + 2) // ERROR "-4 \+ 2i|invalid type conversion"
 }

diff --git a/test/fixedbugs/issue7129.go b/test/fixedbugs/issue7129.go
index 2425cbd3439ede2e15a56450c12cf28198703e64..2765200ac89fcff5045068fa2cb4f0418c21eaa6 100644 (file)
--- a/test/fixedbugs/issue7129.go
+++ b/test/fixedbugs/issue7129.go
@@ -15,7 +15,7 @@ func g() bool { return true }
 func h(int, int) {}
 
 func main() {
-       f(g())        // ERROR "in argument to f"
-       f(true)       // ERROR "in argument to f"
-       h(true, true) // ERROR "in argument to h"
+       f(g())        // ERROR "in argument to f|incompatible type"
+       f(true)       // ERROR "in argument to f|incompatible type"
+       h(true, true) // ERROR "in argument to h|incompatible type"
 }

diff --git a/test/fixedbugs/issue7150.go b/test/fixedbugs/issue7150.go
index 8a8a7d088fc8f540b60d12eac2a2b2584dd2e6b0..7cddf4875eb3ddaeea2104608c29f3a18b30cafd 100644 (file)
--- a/test/fixedbugs/issue7150.go
+++ b/test/fixedbugs/issue7150.go
@@ -9,9 +9,9 @@
 package main
 
 func main() {
-       _ = [0]int{-1: 50}              // ERROR "index must be non-negative integer constant"
-       _ = [0]int{0: 0}                // ERROR "index 0 out of bounds \[0:0\]"
-       _ = [0]int{5: 25}               // ERROR "index 5 out of bounds \[0:0\]"
-       _ = [10]int{2: 10, 15: 30}      // ERROR "index 15 out of bounds \[0:10\]"
-       _ = [10]int{5: 5, 1: 1, 12: 12} // ERROR "index 12 out of bounds \[0:10\]"
+       _ = [0]int{-1: 50}              // ERROR "index must be non-negative integer constant|index expression is negative"
+       _ = [0]int{0: 0}                // ERROR "index 0 out of bounds \[0:0\]|out of range"
+       _ = [0]int{5: 25}               // ERROR "index 5 out of bounds \[0:0\]|out of range"
+       _ = [10]int{2: 10, 15: 30}      // ERROR "index 15 out of bounds \[0:10\]|out of range"
+       _ = [10]int{5: 5, 1: 1, 12: 12} // ERROR "index 12 out of bounds \[0:10\]|out of range"
 }

diff --git a/test/fixedbugs/issue7153.go b/test/fixedbugs/issue7153.go
index 66b1338496f298658cf969ea5f2dcc4135b12604..e8b95d5db827a9a0155481be8a8401036606cd64 100644 (file)
--- a/test/fixedbugs/issue7153.go
+++ b/test/fixedbugs/issue7153.go
@@ -8,4 +8,4 @@
 
 package p
 
-var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal"
+var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal|undefined name .*a|incompatible type"

diff --git a/test/fixedbugs/issue7310.go b/test/fixedbugs/issue7310.go
index 6829d5e126bf343a956ff9d3ca6c2611c0d5ef8a..ba50e4237b38cd479cd016dc39d42929576cb0e7 100644 (file)
--- a/test/fixedbugs/issue7310.go
+++ b/test/fixedbugs/issue7310.go
@@ -9,7 +9,7 @@
 package main
 
 func main() {
-       _ = copy(nil, []int{}) // ERROR "use of untyped nil"
-       _ = copy([]int{}, nil) // ERROR "use of untyped nil"
-       _ = 1 + true           // ERROR "mismatched types untyped int and untyped bool"
+       _ = copy(nil, []int{}) // ERROR "use of untyped nil|left argument must be a slice"
+       _ = copy([]int{}, nil) // ERROR "use of untyped nil|second argument must be slice or string"
+       _ = 1 + true           // ERROR "mismatched types untyped int and untyped bool|incompatible types"
 }

diff --git a/test/fixedbugs/issue7538a.go b/test/fixedbugs/issue7538a.go
index 283d9eb1ba5089fff0ad216815de6e93ba8a1e70..b1701508d8cb180091f238230ceb4847abe6b108 100644 (file)
--- a/test/fixedbugs/issue7538a.go
+++ b/test/fixedbugs/issue7538a.go
@@ -11,5 +11,5 @@ package p
 func f() {
 _:
 _:
-       goto _ // ERROR "not defined"
+       goto _ // ERROR "not defined|undefined label"
 }

diff --git a/test/fixedbugs/issue7675.go b/test/fixedbugs/issue7675.go
index d97ee357a2257795795db6b821e8fc6172d22ceb..6cda05f332fc8986c93b00c6fdf32250beb0d780 100644 (file)
--- a/test/fixedbugs/issue7675.go
+++ b/test/fixedbugs/issue7675.go
@@ -13,12 +13,12 @@ func f(string, int, float64, string)
 func g(string, int, float64, ...string)
 
 func main() {
-       f(1, 0.5, "hello") // ERROR "not enough arguments"
+       f(1, 0.5, "hello") // ERROR "not enough arguments|incompatible type"
        f("1", 2, 3.1, "4")
-       f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments"
-       g(1, 0.5)                // ERROR "not enough arguments"
+       f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments|incompatible type"
+       g(1, 0.5)                // ERROR "not enough arguments|incompatible type"
        g("1", 2, 3.1)
-       g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments"
+       g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments|incompatible type"
        g("1", 2, 3.1, "4", "5")
-       g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments"
+       g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments|truncated to integer"
 }

diff --git a/test/fixedbugs/issue7740.go b/test/fixedbugs/issue7740.go
index 8f1afe86dae5ed1258190fdb1308522de238d2c7..6bc6249d7e0b6bfc597bade2f4d506d63814e5a1 100644 (file)
--- a/test/fixedbugs/issue7740.go
+++ b/test/fixedbugs/issue7740.go
@@ -21,7 +21,7 @@ func main() {
        var prec float64
        switch runtime.Compiler {
        case "gc":
-               prec = 512
+               prec = math.Inf(1) // exact precision using rational arithmetic
        case "gccgo":
                prec = 256
        default:

diff --git a/test/fixedbugs/issue7746.go b/test/fixedbugs/issue7746.go
index 0dc119d2e6daed0a1591f4eebeb3c84e665fe0ff..745496293d719cdfdeb6a8f88676f98c4c607b66 100644 (file)
--- a/test/fixedbugs/issue7746.go
+++ b/test/fixedbugs/issue7746.go
@@ -10,7 +10,7 @@ const (
        c0   = 1 << 100
        c1   = c0 * c0
        c2   = c1 * c1
-       c3   = c2 * c2 // ERROR "overflow"
+       c3   = c2 * c2 // GC_ERROR "overflow"
        c4   = c3 * c3
        c5   = c4 * c4
        c6   = c5 * c5
@@ -21,7 +21,7 @@ const (
        c11  = c10 * c10
        c12  = c11 * c11
        c13  = c12 * c12
-       c14  = c13 * c13
+       c14  = c13 * c13 // GCCGO_ERROR "overflow"
        c15  = c14 * c14
        c16  = c15 * c15
        c17  = c16 * c16

diff --git a/test/fixedbugs/issue7760.go b/test/fixedbugs/issue7760.go
index cccae48910a70bfc86f044dae80edcca90edbed3..7e1d03596eb9808fd1e32265f717ffeae3386b37 100644 (file)
--- a/test/fixedbugs/issue7760.go
+++ b/test/fixedbugs/issue7760.go
@@ -12,14 +12,14 @@ import "unsafe"
 
 type myPointer unsafe.Pointer
 
-const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant"
-const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant"
+const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant|invalid constant type"
+const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant|invalid constant type"
 
-const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|invalid constant type"
+const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant|invalid constant type"
 
-const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|expression is not constant"
+const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant|expression is no constant"
 
-const _ = []byte("") // ERROR "is not (a )?constant"
-const _ = []rune("") // ERROR "is not (a )?constant"
+const _ = []byte("") // ERROR "is not (a )?constant|invalid constant type"
+const _ = []rune("") // ERROR "is not (a )?constant|invalid constant type"

diff --git a/test/fixedbugs/issue7921.go b/test/fixedbugs/issue7921.go
index 5dce557ca33ccff9bd4e93fd83cf140cf2020c03..65be4b5bbee8d1e73443fbfb6859d76655fb903d 100644 (file)
--- a/test/fixedbugs/issue7921.go
+++ b/test/fixedbugs/issue7921.go
@@ -41,7 +41,7 @@ func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"
 
 func bufferNoEscape4() []byte {
        var b bytes.Buffer
-       b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
+       b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m\]$" "inlining call to bytes.\(\*Buffer\).Grow$" "string\(.*\) escapes to heap"
        useBuffer(&b)
        return b.Bytes() // ERROR "inlining call to bytes.\(\*Buffer\).Bytes$"
 }

diff --git a/test/fixedbugs/issue8311.go b/test/fixedbugs/issue8311.go
index 375b480a1738c4596ffa31286aaf2259e9c1149a..b5fd5daea1d7dd49ec20daabeb06350ab5c2cf8e 100644 (file)
--- a/test/fixedbugs/issue8311.go
+++ b/test/fixedbugs/issue8311.go
@@ -11,6 +11,6 @@ package p
 
 func f() {
        var x []byte
-       x++ // ERROR "invalid operation: x[+][+]"
+       x++ // ERROR "invalid operation: x[+][+]|non-numeric type"
 
 }

diff --git a/test/fixedbugs/issue8385.go b/test/fixedbugs/issue8385.go
index 6447e9f0e862924b865047f027e6f9ccc7fbd12a..f3d395e52175111f01a052b656929ed676c8acc9 100644 (file)
--- a/test/fixedbugs/issue8385.go
+++ b/test/fixedbugs/issue8385.go
@@ -27,16 +27,16 @@ func (t T) M(x int) {
 func g() func(int)
 
 func main() {
-       Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo"
+       Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo|incompatible type|not enough arguments"
 
        var i I
        var t *T
 
-       g()()    // ERROR "not enough arguments in call to g\(\)"
-       f()      // ERROR "not enough arguments in call to f"
-       i.M()    // ERROR "not enough arguments in call to i\.M"
-       I.M()    // ERROR "not enough arguments in call to method expression I\.M"
-       t.M()    // ERROR "not enough arguments in call to t\.M"
-       T.M()    // ERROR "not enough arguments in call to method expression T\.M"
-       (*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M"
+       g()()    // ERROR "not enough arguments in call to g\(\)|not enough arguments"
+       f()      // ERROR "not enough arguments in call to f|not enough arguments"
+       i.M()    // ERROR "not enough arguments in call to i\.M|not enough arguments"
+       I.M()    // ERROR "not enough arguments in call to method expression I\.M|not enough arguments"
+       t.M()    // ERROR "not enough arguments in call to t\.M|not enough arguments"
+       T.M()    // ERROR "not enough arguments in call to method expression T\.M|not enough arguments"
+       (*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M|not enough arguments"
 }

diff --git a/test/fixedbugs/issue8438.go b/test/fixedbugs/issue8438.go
index 3a4f193b57df33ee3f73413c70c42fc566bee210..f433e36924a38009690a9f1e77dd3fb96d2571e1 100644 (file)
--- a/test/fixedbugs/issue8438.go
+++ b/test/fixedbugs/issue8438.go
@@ -10,8 +10,8 @@
 package main
 
 func main() {
-       _ = []byte{"foo"}   // ERROR "cannot use"
-       _ = []int{"foo"}    // ERROR "cannot use"
-       _ = []rune{"foo"}   // ERROR "cannot use"
+       _ = []byte{"foo"}   // ERROR "cannot use|incompatible type"
+       _ = []int{"foo"}    // ERROR "cannot use|incompatible type"
+       _ = []rune{"foo"}   // ERROR "cannot use|incompatible type"
        _ = []string{"foo"} // OK
 }

diff --git a/test/fixedbugs/issue8440.go b/test/fixedbugs/issue8440.go
index f9b1dea3ebff209b985596d3c6bd0e8e2b413491..e9c5b54d51d2e1c8b4fd1563f025a75b5cc60678 100644 (file)
--- a/test/fixedbugs/issue8440.go
+++ b/test/fixedbugs/issue8440.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-       n.foo = 6 // ERROR "undefined: n in n.foo"
+       n.foo = 6 // ERROR "undefined: n in n.foo|undefined name .*n"
 }

diff --git a/test/fixedbugs/issue8507.go b/test/fixedbugs/issue8507.go
index ad6ba8ac68b271f79262de47228d83b090620d03..392ecf406350a7abe01425c4ec3541ad82b0e011 100644 (file)
--- a/test/fixedbugs/issue8507.go
+++ b/test/fixedbugs/issue8507.go
@@ -9,7 +9,7 @@
 
 package p
 
-type T struct{ T } // ERROR "invalid recursive type T"
+type T struct{ T } // ERROR "invalid recursive type .*T"
 
 func f() {
        println(T{} == T{})

diff --git a/test/fixedbugs/issue9355.go b/test/fixedbugs/issue9355.go
index ab3369d415df19165c8d5be13084e66bb17192d2..319a2a90df9ba26c8725fe179abe6e349262afb8 100644 (file)
--- a/test/fixedbugs/issue9355.go
+++ b/test/fixedbugs/issue9355.go
@@ -1,3 +1,4 @@
+// +build !js,gc
 // run
 
 // Copyright 2014 The Go Authors. All rights reserved.
@@ -13,14 +14,9 @@ import (
        "os/exec"
        "path/filepath"
        "regexp"
-       "runtime"
 )
 
 func main() {
-       if runtime.Compiler != "gc" || runtime.GOOS == "js" {
-               return
-       }
-
        err := os.Chdir(filepath.Join("fixedbugs", "issue9355.dir"))
        check(err)
 

diff --git a/test/fixedbugs/issue9521.go b/test/fixedbugs/issue9521.go
index a33f0483f322862eef2ba5a9b2567909b7aff010..1ad40bdfda1ff5dca519efca6489fd375b9fcc42 100644 (file)
--- a/test/fixedbugs/issue9521.go
+++ b/test/fixedbugs/issue9521.go
@@ -13,6 +13,6 @@ func f() (_, _ []int)         { return }
 func g() (x []int, y float64) { return }
 
 func main() {
-       _ = append(f()) // ERROR "cannot use \[\]int value as type int in append"
-       _ = append(g()) // ERROR "cannot use float64 value as type int in append"
+       _ = append(f()) // ERROR "cannot use \[\]int value as type int in append|incompatible type"
+       _ = append(g()) // ERROR "cannot use float64 value as type int in append|incompatible type"
 }

diff --git a/test/fixedbugs/issue9862_run.go b/test/fixedbugs/issue9862_run.go
index 299e8095450d8a97f0e27898c876ba8f1c6a1123..c956c7f7bd50f3aa0445ea1f5f994421dfc28b24 100644 (file)
--- a/test/fixedbugs/issue9862_run.go
+++ b/test/fixedbugs/issue9862_run.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2015 The Go Authors. All rights reserved.

diff --git a/test/float_lit3.go b/test/float_lit3.go
index c4d1aa567cef2bf8c64f4c87ef8669a8c01160af..850d02c9c7f97366ae3d5db35ec9e78b5417290e 100644 (file)
--- a/test/float_lit3.go
+++ b/test/float_lit3.go
@@ -37,12 +37,11 @@ var x = []interface{}{
 
        // If the compiler's internal floating point representation
        // is shorter than 1024 bits, it cannot distinguish max64+ulp64/2-1 and max64+ulp64/2.
-       // gc uses fewer than 1024 bits, so allow it to print the overflow error for the -1 case.
        float64(max64 + ulp64/2 - two1024/two256), // ok
-       float64(max64 + ulp64/2 - 1),              // GC_ERROR "constant 1\.79769e\+308 overflows float64"
+       float64(max64 + ulp64/2 - 1),              // ok
        float64(max64 + ulp64/2),                  // ERROR "constant 1\.79769e\+308 overflows float64"
 
        float64(-max64 - ulp64/2 + two1024/two256), // ok
-       float64(-max64 - ulp64/2 + 1),              // GC_ERROR "constant -1\.79769e\+308 overflows float64"
+       float64(-max64 - ulp64/2 + 1),              // ok
        float64(-max64 - ulp64/2),                  // ERROR "constant -1\.79769e\+308 overflows float64"
 }

diff --git a/test/initexp.go b/test/initexp.go
new file mode 100644 (file)
index 0000000..f279a7c
--- /dev/null
+++ b/test/initexp.go
@@ -0,0 +1,36 @@
+// errorcheck -t 10
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+// The init cycle diagnosis used to take exponential time
+// to traverse the call graph paths. This test case takes
+// at least two minutes on a modern laptop with the bug
+// and runs in a fraction of a second without it.
+// 10 seconds (-t 10 above) should be plenty if the code is working.
+
+var x = f() + z() // ERROR "initialization loop"
+
+func f() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func z() int { return x }
+
+func a1() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a2() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a3() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a4() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a5() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a6() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a7() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+func a8() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
+
+func b1() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b2() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b3() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b4() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b5() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b6() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b7() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }
+func b8() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }

diff --git a/test/inline.go b/test/inline.go
index d754f06e0340c47025c53e80ad21c9b0ade18d56..37965c0d9dc8aa45ca0f2127f1adc38eb532d19c 100644 (file)
--- a/test/inline.go
+++ b/test/inline.go
@@ -58,7 +58,7 @@ func _() int { // ERROR "can inline _"
 var somethingWrong error
 
 // local closures can be inlined
-func l(x, y int) (int, int, error) {
+func l(x, y int) (int, int, error) { // ERROR "can inline l"
        e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result"
                return 0, 0, err
        }
@@ -90,19 +90,19 @@ func n() int {
 // make sure assignment inside closure is detected
 func o() int {
        foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape"
-       func(x int) {                  // ERROR "func literal does not escape"
+       func(x int) {                  // ERROR "can inline o.func2"
                if x > 10 {
-                       foo = func() int { return 2 } // ERROR "can inline o.func2" "func literal escapes"
+                       foo = func() int { return 2 } // ERROR "can inline o.func2"
                }
-       }(11)
+       }(11) // ERROR "func literal does not escape" "inlining call to o.func2"
        return foo()
 }
 
-func p() int {
+func p() int { // ERROR "can inline p"
        return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1"
 }
 
-func q(x int) int {
+func q(x int) int { // ERROR "can inline q"
        foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
        return foo()                       // ERROR "inlining call to q.func1"
 }
@@ -111,15 +111,15 @@ func r(z int) int {
        foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
                return x + z
        }
-       bar := func(x int) int { // ERROR "func literal does not escape"
-               return x + func(y int) int { // ERROR "can inline r.func2.1"
+       bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2"
+               return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.func3"
                        return 2*y + x*z
                }(x) // ERROR "inlining call to r.func2.1"
        }
-       return foo(42) + bar(42) // ERROR "inlining call to r.func1"
+       return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.func3"
 }
 
-func s0(x int) int {
+func s0(x int) int { // ERROR "can inline s0"
        foo := func() { // ERROR "can inline s0.func1" "func literal does not escape"
                x = x + 1
        }
@@ -127,7 +127,7 @@ func s0(x int) int {
        return x
 }
 
-func s1(x int) int {
+func s1(x int) int { // ERROR "can inline s1"
        foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape"
                return x
        }

diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index 3f9451e8d2faa1f34d8f0dda4c780a8ccaf44d10..b705b976760071f6cf132c0a4be545ddc1945882 100644 (file)
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -100,6 +100,7 @@ type T2 struct{}
 func (t *T2) M() {}
 func (t *T2) _() {}
 
-// Check that nothing satisfies an interface with blank methods.
-var b1 B1 = &T2{} // ERROR "incompatible|missing _ method"
-var b2 B2 = &T2{} // ERROR "incompatible|missing _ method"
+// Already reported about the invalid blank interface method above;
+// no need to report about not implementing it.
+var b1 B1 = &T2{}
+var b2 B2 = &T2{}

diff --git a/test/linkname2.go b/test/linkname2.go
new file mode 100644 (file)
index 0000000..43e66a5
--- /dev/null
+++ b/test/linkname2.go
@@ -0,0 +1,30 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Tests that errors are reported for misuse of linkname.
+package p
+
+import _ "unsafe"
+
+type t int
+
+var x, y int
+
+//go:linkname x ok
+
+// ERROR "//go:linkname requires linkname argument or -p compiler flag"
+// BAD: want error "//go:linkname must refer to declared function or variable"
+// BAD: want error "//go:linkname must refer to declared function or variable"
+// ERROR "duplicate //go:linkname for x"
+
+// The two BAD lines are just waiting for #42938 before we can
+// re-enable the errors.
+
+//line linkname2.go:18
+//go:linkname y
+//go:linkname nonexist nonexist
+//go:linkname t notvarfunc
+//go:linkname x duplicate

diff --git a/test/linkobj.go b/test/linkobj.go
index 2902d23f4b867074ba3b8d37a275507f3d5cfc41..4c9bd24568b112a9bbd6a01d4d02ccaebf64e505 100644 (file)
--- a/test/linkobj.go
+++ b/test/linkobj.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2016 The Go Authors. All rights reserved.

diff --git a/test/linkx_run.go b/test/linkx_run.go
index f25053bf28e9c1b7502ba42c6a8f5356a86d80da..ccfc3a93dff14e0ea52872ac9f684ba981bee1f9 100644 (file)
--- a/test/linkx_run.go
+++ b/test/linkx_run.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2014 The Go Authors. All rights reserved.

diff --git a/test/live.go b/test/live.go
index 3df7ab01af47f693885bc05bdfe08873ffdbed8c..d52ce7f0075017a7669d0a4fbdb6515291055379 100644 (file)
--- a/test/live.go
+++ b/test/live.go
@@ -718,5 +718,5 @@ func f44(f func() [2]*int) interface{} { // ERROR "live at entry to f44: f"
        }
        ret := T{}
        ret.s[0] = f()
-       return ret // ERROR "stack object .autotmp_5 T"
+       return ret // ERROR "stack object .autotmp_[0-9]+ T"
 }

diff --git a/test/mainsig.go b/test/mainsig.go
new file mode 100644 (file)
index 0000000..d006d9c
--- /dev/null
+++ b/test/mainsig.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main(int)  {}           // ERROR "func main must have no arguments and no return values"
+func main() int { return 1 } // ERROR "func main must have no arguments and no return values" "main redeclared in this block"
+
+func init(int)  {}           // ERROR "func init must have no arguments and no return values"
+func init() int { return 1 } // ERROR "func init must have no arguments and no return values"

diff --git a/test/nilptr.go b/test/nilptr.go
index c9a044dd362edc713c838a864dd98b024cdbcff6..b296c88c99408a6fe6a96c6a2f06a69b40c20606 100644 (file)
--- a/test/nilptr.go
+++ b/test/nilptr.go
@@ -9,7 +9,8 @@
 
 // +build !aix
 // +build !darwin !arm64
-// Address space starts at 1<<32 on AIX and on darwin/arm64, so dummy is too far.
+// +build !windows !arm64
+// Address space starts at 1<<32 on AIX and on darwin/arm64 and on windows/arm64, so dummy is too far.
 
 package main
 

diff --git a/test/nilptr3.go b/test/nilptr3.go
index e0f2ed9767659864be3a37d57701652dcbb5cb6e..3345cfa5ab38a477a147637b59e7a557e5764bb7 100644 (file)
--- a/test/nilptr3.go
+++ b/test/nilptr3.go
@@ -214,14 +214,6 @@ func p1() byte {
        return p[5] // ERROR "removed nil check"
 }
 
-// make sure not to do nil check for access of PAUTOHEAP
-//go:noinline
-func (p *Struct) m() {}
-func c1() {
-       var x Struct
-       func() { x.m() }() // ERROR "removed nil check"
-}
-
 type SS struct {
        x byte
 }

diff --git a/test/nosplit.go b/test/nosplit.go
index a3f2a9fb7eba4ecf5154b00278c2542d03c279e8..8a3fa9bf3538e2b4da22a01769d833dce2cd4505 100644 (file)
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js,!aix,!gcflags_noopt
+// +build !nacl,!js,!aix,!gcflags_noopt,gc
 // run
 
 // Copyright 2014 The Go Authors. All rights reserved.
@@ -353,7 +353,14 @@ TestCases:
                        log.Fatal(err)
                }
 
-               cmd := exec.Command("go", "build")
+               // Turn off ABI0 wrapper generation for now. The problem here is
+               // that in these test cases main.main is an assembly routine,
+               // thus calls to it will have to go through an ABI wrapper. The
+               // ABI wrapper will consume some stack space, which throws off
+               // the numbers.
+               workaround := "-gcflags=-abiwrap=0"
+
+               cmd := exec.Command("go", "build", workaround)
                cmd.Dir = dir
                output, err := cmd.CombinedOutput()
                if err == nil {

diff --git a/test/reflectmethod7.go b/test/reflectmethod7.go
new file mode 100644 (file)
index 0000000..4242997
--- /dev/null
+++ b/test/reflectmethod7.go
@@ -0,0 +1,24 @@
+// run
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// See issue 44207.
+
+package main
+
+import "reflect"
+
+type S int
+
+func (s S) M() {}
+
+func main() {
+       t := reflect.TypeOf(S(0))
+       fn, ok := reflect.PtrTo(t).MethodByName("M")
+       if !ok {
+               panic("FAIL")
+       }
+       fn.Func.Call([]reflect.Value{reflect.New(t)})
+}

diff --git a/test/reorder.go b/test/reorder.go
index 3a87d025c2a955383601aa46520f65fd7b446705..57892f882fa5b48f0d9ed835af1ba76d5a230f0f 100644 (file)
--- a/test/reorder.go
+++ b/test/reorder.go
@@ -20,6 +20,8 @@ func main() {
        p7()
        p8()
        p9()
+       p10()
+       p11()
 }
 
 var gx []int
@@ -149,3 +151,17 @@ func checkOAS2XXX(x bool, s string) {
                panic("failed")
        }
 }
+
+//go:noinline
+func fp() (*int, int) { return nil, 42 }
+
+func p10() {
+       p := new(int)
+       p, *p = fp()
+}
+
+func p11() {
+       var i interface{}
+       p := new(bool)
+       p, *p = i.(*bool)
+}

diff --git a/test/run.go b/test/run.go
index 4abf32d25c8b6755d9d36e942d40579ac111dcc8..dba4d16d63e6ed3cce2d64c7a04b69e610c0ab18 100644 (file)
--- a/test/run.go
+++ b/test/run.go
@@ -59,7 +59,7 @@ var (
 
        // dirs are the directories to look for *.go files in.
        // TODO(bradfitz): just use all directories?
-       dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime"}
+       dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "abi"}
 
        // ratec controls the max number of tests running at a time.
        ratec chan bool
@@ -438,7 +438,7 @@ func (ctxt *context) match(name string) bool {
                }
        }
 
-       if name == ctxt.GOOS || name == ctxt.GOARCH {
+       if name == ctxt.GOOS || name == ctxt.GOARCH || name == "gc" {
                return true
        }
 
@@ -467,6 +467,8 @@ func goGcflagsIsEmpty() bool {
        return "" == os.Getenv("GO_GCFLAGS")
 }
 
+var errTimeout = errors.New("command exceeded time limit")
+
 // run runs a test.
 func (t *test) run() {
        start := time.Now()
@@ -489,7 +491,7 @@ func (t *test) run() {
        // Execution recipe stops at first blank line.
        pos := strings.Index(t.src, "\n\n")
        if pos == -1 {
-               t.err = errors.New("double newline not found")
+               t.err = fmt.Errorf("double newline ending execution recipe not found in %s", t.goFileName())
                return
        }
        action := t.src[:pos]
@@ -642,16 +644,18 @@ func (t *test) run() {
                                case err = <-done:
                                        // ok
                                case <-tick.C:
+                                       cmd.Process.Signal(os.Interrupt)
+                                       time.Sleep(1 * time.Second)
                                        cmd.Process.Kill()
-                                       err = <-done
-                                       // err = errors.New("Test timeout")
+                                       <-done
+                                       err = errTimeout
                                }
                                tick.Stop()
                        }
                } else {
                        err = cmd.Run()
                }
-               if err != nil {
+               if err != nil && err != errTimeout {
                        err = fmt.Errorf("%s\n%s", err, buf.Bytes())
                }
                return buf.Bytes(), err
@@ -731,6 +735,10 @@ func (t *test) run() {
                                t.err = fmt.Errorf("compilation succeeded unexpectedly\n%s", out)
                                return
                        }
+                       if err == errTimeout {
+                               t.err = fmt.Errorf("compilation timed out")
+                               return
+                       }
                } else {
                        if err != nil {
                                t.err = err
@@ -860,9 +868,7 @@ func (t *test) run() {
                                        t.err = err
                                        return
                                }
-                               if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-                                       t.err = fmt.Errorf("incorrect output\n%s", out)
-                               }
+                               t.checkExpectedOutput(out)
                        }
                }
 
@@ -896,15 +902,14 @@ func (t *test) run() {
                if *linkshared {
                        cmd = append(cmd, "-linkshared")
                }
+               cmd = append(cmd, flags...)
                cmd = append(cmd, ".")
                out, err := runcmd(cmd...)
                if err != nil {
                        t.err = err
                        return
                }
-               if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-                       t.err = fmt.Errorf("incorrect output\n%s", out)
-               }
+               t.checkExpectedOutput(out)
 
        case "build":
                // Build Go file.
@@ -989,9 +994,7 @@ func (t *test) run() {
                                t.err = err
                                break
                        }
-                       if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-                               t.err = fmt.Errorf("incorrect output\n%s", out)
-                       }
+                       t.checkExpectedOutput(out)
                }
 
        case "buildrun":
@@ -1017,9 +1020,7 @@ func (t *test) run() {
                        return
                }
 
-               if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-                       t.err = fmt.Errorf("incorrect output\n%s", out)
-               }
+               t.checkExpectedOutput(out)
 
        case "run":
                // Run Go file if no special go command flags are provided;
@@ -1062,9 +1063,7 @@ func (t *test) run() {
                        t.err = err
                        return
                }
-               if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-                       t.err = fmt.Errorf("incorrect output\n%s", out)
-               }
+               t.checkExpectedOutput(out)
 
        case "runoutput":
                // Run Go file and write its output into temporary Go file.
@@ -1099,9 +1098,7 @@ func (t *test) run() {
                        t.err = err
                        return
                }
-               if string(out) != t.expectedOutput() {
-                       t.err = fmt.Errorf("incorrect output\n%s", out)
-               }
+               t.checkExpectedOutput(out)
 
        case "errorcheckoutput":
                // Run Go file and write its output into temporary Go file.
@@ -1175,12 +1172,24 @@ func (t *test) makeTempDir() {
        }
 }
 
-func (t *test) expectedOutput() string {
+// checkExpectedOutput compares the output from compiling and/or running with the contents
+// of the corresponding reference output file, if any (replace ".go" with ".out").
+// If they don't match, fail with an informative message.
+func (t *test) checkExpectedOutput(gotBytes []byte) {
+       got := string(gotBytes)
        filename := filepath.Join(t.dir, t.gofile)
        filename = filename[:len(filename)-len(".go")]
        filename += ".out"
-       b, _ := ioutil.ReadFile(filename)
-       return string(b)
+       b, err := ioutil.ReadFile(filename)
+       // File is allowed to be missing (err != nil) in which case output should be empty.
+       got = strings.Replace(got, "\r\n", "\n", -1)
+       if got != string(b) {
+               if err == nil {
+                       t.err = fmt.Errorf("output does not match expected in %s. Instead saw\n%s", filename, got)
+               } else {
+                       t.err = fmt.Errorf("output should be empty when (optional) expected-output file %s is not present. Instead saw\n%s", filename, got)
+               }
+       }
 }
 
 func splitOutput(out string, wantAuto bool) []string {

diff --git a/test/sinit_run.go b/test/sinit_run.go
index c37fc9b88c8fc0df365a4ddc92ad8196d1b082d7..dcaf3383312602a524efb566e007ff635fa1dec4 100644 (file)
--- a/test/sinit_run.go
+++ b/test/sinit_run.go
@@ -1,4 +1,4 @@
-// +build !nacl,!js
+// +build !nacl,!js,gc
 // run
 
 // Copyright 2014 The Go Authors. All rights reserved.

diff --git a/test/used.go b/test/used.go
new file mode 100644 (file)
index 0000000..76f3fc9
--- /dev/null
+++ b/test/used.go
@@ -0,0 +1,144 @@
+// errorcheck
+
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+import "unsafe"
+
+const C = 1
+
+var x, x1, x2 int
+var b bool
+var s string
+var c chan int
+var cp complex128
+var slice []int
+var array [2]int
+var bytes []byte
+var runes []rune
+var r rune
+
+func f0()            {}
+func f1() int        { return 1 }
+func f2() (int, int) { return 1, 1 }
+
+type T struct{ X int }
+
+func (T) M1() int { return 1 }
+func (T) M0()     {}
+func (T) M()      {}
+
+var t T
+var tp *T
+
+type I interface{ M() }
+
+var i I
+
+var m map[int]int
+
+func _() {
+       // Note: if the next line changes to x, the error silences the x+x etc below!
+       x1 // ERROR "x1 evaluated but not used"
+
+       nil                    // ERROR "nil evaluated but not used"
+       C                      // ERROR  "C evaluated but not used"
+       1                      // ERROR "1 evaluated but not used"
+       x + x                  // ERROR "x \+ x evaluated but not used"
+       x - x                  // ERROR "x - x evaluated but not used"
+       x | x                  // ERROR "x \| x evaluated but not used"
+       "a" + s                // ERROR ".a. \+ s evaluated but not used"
+       &x                     // ERROR "&x evaluated but not used"
+       b && b                 // ERROR "b && b evaluated but not used"
+       append(slice, 1)       // ERROR "append\(slice, 1\) evaluated but not used"
+       string(bytes)          // ERROR "string\(bytes\) evaluated but not used"
+       string(runes)          // ERROR "string\(runes\) evaluated but not used"
+       f0()                   // ok
+       f1()                   // ok
+       f2()                   // ok
+       _ = f0()               // ERROR "f0\(\) used as value"
+       _ = f1()               // ok
+       _, _ = f2()            // ok
+       _ = f2()               // ERROR "assignment mismatch: 1 variable but f2 returns 2 values"
+       _ = f1(), 0            // ERROR "assignment mismatch: 1 variable but 2 values"
+       T.M0                   // ERROR "T.M0 evaluated but not used"
+       t.M0                   // ERROR "t.M0 evaluated but not used"
+       cap                    // ERROR "use of builtin cap not in function call"
+       cap(slice)             // ERROR "cap\(slice\) evaluated but not used"
+       close(c)               // ok
+       _ = close(c)           // ERROR "close\(c\) used as value"
+       func() {}              // ERROR "func literal evaluated but not used"
+       X{}                    // ERROR "undefined: X"
+       map[string]int{}       // ERROR "map\[string\]int{} evaluated but not used"
+       struct{}{}             // ERROR "struct ?{}{} evaluated but not used"
+       [1]int{}               // ERROR "\[1\]int{} evaluated but not used"
+       []int{}                // ERROR "\[\]int{} evaluated but not used"
+       &struct{}{}            // ERROR "&struct ?{}{} evaluated but not used"
+       float32(x)             // ERROR "float32\(x\) evaluated but not used"
+       I(t)                   // ERROR "I\(t\) evaluated but not used"
+       int(x)                 // ERROR "int\(x\) evaluated but not used"
+       copy(slice, slice)     // ok
+       _ = copy(slice, slice) // ok
+       delete(m, 1)           // ok
+       _ = delete(m, 1)       // ERROR "delete\(m, 1\) used as value"
+       t.X                    // ERROR "t.X evaluated but not used"
+       tp.X                   // ERROR "tp.X evaluated but not used"
+       t.M                    // ERROR "t.M evaluated but not used"
+       I.M                    // ERROR "I.M evaluated but not used"
+       i.(T)                  // ERROR "i.\(T\) evaluated but not used"
+       x == x                 // ERROR "x == x evaluated but not used"
+       x != x                 // ERROR "x != x evaluated but not used"
+       x != x                 // ERROR "x != x evaluated but not used"
+       x < x                  // ERROR "x < x evaluated but not used"
+       x >= x                 // ERROR "x >= x evaluated but not used"
+       x > x                  // ERROR "x > x evaluated but not used"
+       *tp                    // ERROR "\*tp evaluated but not used"
+       slice[0]               // ERROR "slice\[0\] evaluated but not used"
+       m[1]                   // ERROR "m\[1\] evaluated but not used"
+       len(slice)             // ERROR "len\(slice\) evaluated but not used"
+       make(chan int)         // ERROR "make\(chan int\) evaluated but not used"
+       make(map[int]int)      // ERROR "make\(map\[int\]int\) evaluated but not used"
+       make([]int, 1)         // ERROR "make\(\[\]int, 1\) evaluated but not used"
+       x * x                  // ERROR "x \* x evaluated but not used"
+       x / x                  // ERROR "x / x evaluated but not used"
+       x % x                  // ERROR "x % x evaluated but not used"
+       x << x                 // ERROR "x << x evaluated but not used"
+       x >> x                 // ERROR "x >> x evaluated but not used"
+       x & x                  // ERROR "x & x evaluated but not used"
+       x &^ x                 // ERROR "x &\^ x evaluated but not used"
+       new(int)               // ERROR "new\(int\) evaluated but not used"
+       !b                     // ERROR "!b evaluated but not used"
+       ^x                     // ERROR "\^x evaluated but not used"
+       +x                     // ERROR "\+x evaluated but not used"
+       -x                     // ERROR "-x evaluated but not used"
+       b || b                 // ERROR "b \|\| b evaluated but not used"
+       panic(1)               // ok
+       _ = panic(1)           // ERROR "panic\(1\) used as value"
+       print(1)               // ok
+       _ = print(1)           // ERROR "print\(1\) used as value"
+       println(1)             // ok
+       _ = println(1)         // ERROR "println\(1\) used as value"
+       c <- 1                 // ok
+       slice[1:1]             // ERROR "slice\[1:1\] evaluated but not used"
+       array[1:1]             // ERROR "array\[1:1\] evaluated but not used"
+       s[1:1]                 // ERROR "s\[1:1\] evaluated but not used"
+       slice[1:1:1]           // ERROR "slice\[1:1:1\] evaluated but not used"
+       array[1:1:1]           // ERROR "array\[1:1:1\] evaluated but not used"
+       recover()              // ok
+       <-c                    // ok
+       string(r)              // ERROR "string\(r\) evaluated but not used"
+       iota                   // ERROR "undefined: iota"
+       real(cp)               // ERROR "real\(cp\) evaluated but not used"
+       imag(cp)               // ERROR "imag\(cp\) evaluated but not used"
+       complex(1, 2)          // ERROR "complex\(1, 2\) evaluated but not used"
+       unsafe.Alignof(t.X)    // ERROR "unsafe.Alignof\(t.X\) evaluated but not used"
+       unsafe.Offsetof(t.X)   // ERROR "unsafe.Offsetof\(t.X\) evaluated but not used"
+       unsafe.Sizeof(t)       // ERROR "unsafe.Sizeof\(t\) evaluated but not used"
+       _ = int                // ERROR "type int is not an expression"
+       (x)                    // ERROR "x evaluated but not used"
+       _ = new(x2)            // ERROR "x2 is not a type"
+       _ = new(1 + 1)         // ERROR "1 \+ 1 is not a type"
+}